1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "dbus/values_util.h" 6 7 #include "base/json/json_writer.h" 8 #include "base/logging.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/values.h" 11 #include "dbus/message.h" 12 13 namespace dbus { 14 15 namespace { 16 17 // Returns whether |value| is exactly representable by double or not. 18 template<typename T> 19 bool IsExactlyRepresentableByDouble(T value) { 20 return value == static_cast<T>(static_cast<double>(value)); 21 } 22 23 // Pops values from |reader| and appends them to |list_value|. 24 bool PopListElements(MessageReader* reader, base::ListValue* list_value) { 25 while (reader->HasMoreData()) { 26 base::Value* element_value = PopDataAsValue(reader); 27 if (!element_value) 28 return false; 29 list_value->Append(element_value); 30 } 31 return true; 32 } 33 34 // Pops dict-entries from |reader| and sets them to |dictionary_value| 35 bool PopDictionaryEntries(MessageReader* reader, 36 base::DictionaryValue* dictionary_value) { 37 while (reader->HasMoreData()) { 38 DCHECK_EQ(Message::DICT_ENTRY, reader->GetDataType()); 39 MessageReader entry_reader(NULL); 40 if (!reader->PopDictEntry(&entry_reader)) 41 return false; 42 // Get key as a string. 43 std::string key_string; 44 if (entry_reader.GetDataType() == Message::STRING) { 45 // If the type of keys is STRING, pop it directly. 46 if (!entry_reader.PopString(&key_string)) 47 return false; 48 } else { 49 // If the type of keys is not STRING, convert it to string. 50 scoped_ptr<base::Value> key(PopDataAsValue(&entry_reader)); 51 if (!key.get()) 52 return false; 53 // Use JSONWriter to convert an arbitrary value to a string. 54 base::JSONWriter::Write(key.get(), &key_string); 55 } 56 // Get the value and set the key-value pair. 57 base::Value* value = PopDataAsValue(&entry_reader); 58 if (!value) 59 return false; 60 dictionary_value->SetWithoutPathExpansion(key_string, value); 61 } 62 return true; 63 } 64 65 // Gets the D-Bus type signature for the value. 66 std::string GetTypeSignature(const base::Value& value) { 67 switch (value.GetType()) { 68 case base::Value::TYPE_BOOLEAN: 69 return "b"; 70 case base::Value::TYPE_INTEGER: 71 return "i"; 72 case base::Value::TYPE_DOUBLE: 73 return "d"; 74 case base::Value::TYPE_STRING: 75 return "s"; 76 case base::Value::TYPE_BINARY: 77 return "ay"; 78 case base::Value::TYPE_DICTIONARY: 79 return "a{sv}"; 80 case base::Value::TYPE_LIST: 81 return "av"; 82 default: 83 DLOG(ERROR) << "Unexpected type " << value.GetType(); 84 return std::string(); 85 } 86 } 87 88 } // namespace 89 90 base::Value* PopDataAsValue(MessageReader* reader) { 91 base::Value* result = NULL; 92 switch (reader->GetDataType()) { 93 case Message::INVALID_DATA: 94 // Do nothing. 95 break; 96 case Message::BYTE: { 97 uint8 value = 0; 98 if (reader->PopByte(&value)) 99 result = new base::FundamentalValue(value); 100 break; 101 } 102 case Message::BOOL: { 103 bool value = false; 104 if (reader->PopBool(&value)) 105 result = new base::FundamentalValue(value); 106 break; 107 } 108 case Message::INT16: { 109 int16 value = 0; 110 if (reader->PopInt16(&value)) 111 result = new base::FundamentalValue(value); 112 break; 113 } 114 case Message::UINT16: { 115 uint16 value = 0; 116 if (reader->PopUint16(&value)) 117 result = new base::FundamentalValue(value); 118 break; 119 } 120 case Message::INT32: { 121 int32 value = 0; 122 if (reader->PopInt32(&value)) 123 result = new base::FundamentalValue(value); 124 break; 125 } 126 case Message::UINT32: { 127 uint32 value = 0; 128 if (reader->PopUint32(&value)) 129 result = new base::FundamentalValue(static_cast<double>(value)); 130 break; 131 } 132 case Message::INT64: { 133 int64 value = 0; 134 if (reader->PopInt64(&value)) { 135 DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) << 136 value << " is not exactly representable by double"; 137 result = new base::FundamentalValue(static_cast<double>(value)); 138 } 139 break; 140 } 141 case Message::UINT64: { 142 uint64 value = 0; 143 if (reader->PopUint64(&value)) { 144 DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) << 145 value << " is not exactly representable by double"; 146 result = new base::FundamentalValue(static_cast<double>(value)); 147 } 148 break; 149 } 150 case Message::DOUBLE: { 151 double value = 0; 152 if (reader->PopDouble(&value)) 153 result = new base::FundamentalValue(value); 154 break; 155 } 156 case Message::STRING: { 157 std::string value; 158 if (reader->PopString(&value)) 159 result = new base::StringValue(value); 160 break; 161 } 162 case Message::OBJECT_PATH: { 163 ObjectPath value; 164 if (reader->PopObjectPath(&value)) 165 result = new base::StringValue(value.value()); 166 break; 167 } 168 case Message::UNIX_FD: { 169 // Cannot distinguish a file descriptor from an int 170 NOTREACHED(); 171 break; 172 } 173 case Message::ARRAY: { 174 MessageReader sub_reader(NULL); 175 if (reader->PopArray(&sub_reader)) { 176 // If the type of the array's element is DICT_ENTRY, create a 177 // DictionaryValue, otherwise create a ListValue. 178 if (sub_reader.GetDataType() == Message::DICT_ENTRY) { 179 scoped_ptr<base::DictionaryValue> dictionary_value( 180 new base::DictionaryValue); 181 if (PopDictionaryEntries(&sub_reader, dictionary_value.get())) 182 result = dictionary_value.release(); 183 } else { 184 scoped_ptr<base::ListValue> list_value(new base::ListValue); 185 if (PopListElements(&sub_reader, list_value.get())) 186 result = list_value.release(); 187 } 188 } 189 break; 190 } 191 case Message::STRUCT: { 192 MessageReader sub_reader(NULL); 193 if (reader->PopStruct(&sub_reader)) { 194 scoped_ptr<base::ListValue> list_value(new base::ListValue); 195 if (PopListElements(&sub_reader, list_value.get())) 196 result = list_value.release(); 197 } 198 break; 199 } 200 case Message::DICT_ENTRY: 201 // DICT_ENTRY must be popped as an element of an array. 202 NOTREACHED(); 203 break; 204 case Message::VARIANT: { 205 MessageReader sub_reader(NULL); 206 if (reader->PopVariant(&sub_reader)) 207 result = PopDataAsValue(&sub_reader); 208 break; 209 } 210 } 211 return result; 212 } 213 214 void AppendBasicTypeValueData(MessageWriter* writer, const base::Value& value) { 215 switch (value.GetType()) { 216 case base::Value::TYPE_BOOLEAN: { 217 bool bool_value = false; 218 bool success = value.GetAsBoolean(&bool_value); 219 DCHECK(success); 220 writer->AppendBool(bool_value); 221 break; 222 } 223 case base::Value::TYPE_INTEGER: { 224 int int_value = 0; 225 bool success = value.GetAsInteger(&int_value); 226 DCHECK(success); 227 writer->AppendInt32(int_value); 228 break; 229 } 230 case base::Value::TYPE_DOUBLE: { 231 double double_value = 0; 232 bool success = value.GetAsDouble(&double_value); 233 DCHECK(success); 234 writer->AppendDouble(double_value); 235 break; 236 } 237 case base::Value::TYPE_STRING: { 238 std::string string_value; 239 bool success = value.GetAsString(&string_value); 240 DCHECK(success); 241 writer->AppendString(string_value); 242 break; 243 } 244 default: 245 DLOG(ERROR) << "Unexpected type " << value.GetType(); 246 break; 247 } 248 } 249 250 void AppendBasicTypeValueDataAsVariant(MessageWriter* writer, 251 const base::Value& value) { 252 MessageWriter sub_writer(NULL); 253 writer->OpenVariant(GetTypeSignature(value), &sub_writer); 254 AppendBasicTypeValueData(&sub_writer, value); 255 writer->CloseContainer(&sub_writer); 256 } 257 258 void AppendValueData(MessageWriter* writer, const base::Value& value) { 259 switch (value.GetType()) { 260 case base::Value::TYPE_DICTIONARY: { 261 const base::DictionaryValue* dictionary = NULL; 262 value.GetAsDictionary(&dictionary); 263 dbus::MessageWriter array_writer(NULL); 264 writer->OpenArray("{sv}", &array_writer); 265 for (base::DictionaryValue::Iterator iter(*dictionary); 266 !iter.IsAtEnd(); iter.Advance()) { 267 dbus::MessageWriter dict_entry_writer(NULL); 268 array_writer.OpenDictEntry(&dict_entry_writer); 269 dict_entry_writer.AppendString(iter.key()); 270 AppendValueDataAsVariant(&dict_entry_writer, iter.value()); 271 array_writer.CloseContainer(&dict_entry_writer); 272 } 273 writer->CloseContainer(&array_writer); 274 break; 275 } 276 case base::Value::TYPE_LIST: { 277 const base::ListValue* list = NULL; 278 value.GetAsList(&list); 279 dbus::MessageWriter array_writer(NULL); 280 writer->OpenArray("v", &array_writer); 281 for (base::ListValue::const_iterator iter = list->begin(); 282 iter != list->end(); ++iter) { 283 const base::Value* value = *iter; 284 AppendValueDataAsVariant(&array_writer, *value); 285 } 286 writer->CloseContainer(&array_writer); 287 break; 288 } 289 case base::Value::TYPE_BOOLEAN: 290 case base::Value::TYPE_INTEGER: 291 case base::Value::TYPE_DOUBLE: 292 case base::Value::TYPE_STRING: 293 AppendBasicTypeValueData(writer, value); 294 break; 295 default: 296 DLOG(ERROR) << "Unexpected type: " << value.GetType(); 297 } 298 } 299 300 void AppendValueDataAsVariant(MessageWriter* writer, const base::Value& value) { 301 MessageWriter variant_writer(NULL); 302 writer->OpenVariant(GetTypeSignature(value), &variant_writer); 303 AppendValueData(&variant_writer, value); 304 writer->CloseContainer(&variant_writer); 305 } 306 307 } // namespace dbus 308
