dbus/values_util.cc

   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     default:
  81       DLOG(ERROR) << "Unexpected type " << value.GetType();
  82       return std::string();
  83   }
  84 }
  85
  86 }  // namespace
  87
  88 base::Value* PopDataAsValue(MessageReader* reader) {
  89   base::Value* result = NULL;
  90   switch (reader->GetDataType()) {
  91     case Message::INVALID_DATA:
  92       // Do nothing.
  93       break;
  94     case Message::BYTE: {
  95       uint8 value = 0;
  96       if (reader->PopByte(&value))
  97         result = new base::FundamentalValue(value);
  98       break;
  99     }
 100     case Message::BOOL: {
 101       bool value = false;
 102       if (reader->PopBool(&value))
 103         result = new base::FundamentalValue(value);
 104       break;
 105     }
 106     case Message::INT16: {
 107       int16 value = 0;
 108       if (reader->PopInt16(&value))
 109         result = new base::FundamentalValue(value);
 110       break;
 111     }
 112     case Message::UINT16: {
 113       uint16 value = 0;
 114       if (reader->PopUint16(&value))
 115         result = new base::FundamentalValue(value);
 116       break;
 117     }
 118     case Message::INT32: {
 119       int32 value = 0;
 120       if (reader->PopInt32(&value))
 121         result = new base::FundamentalValue(value);
 122       break;
 123     }
 124     case Message::UINT32: {
 125       uint32 value = 0;
 126       if (reader->PopUint32(&value))
 127         result = new base::FundamentalValue(static_cast<double>(value));
 128       break;
 129     }
 130     case Message::INT64: {
 131       int64 value = 0;
 132       if (reader->PopInt64(&value)) {
 133         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
 134             value << " is not exactly representable by double";
 135         result = new base::FundamentalValue(static_cast<double>(value));
 136       }
 137       break;
 138     }
 139     case Message::UINT64: {
 140       uint64 value = 0;
 141       if (reader->PopUint64(&value)) {
 142         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
 143             value << " is not exactly representable by double";
 144         result = new base::FundamentalValue(static_cast<double>(value));
 145       }
 146       break;
 147     }
 148     case Message::DOUBLE: {
 149       double value = 0;
 150       if (reader->PopDouble(&value))
 151         result = new base::FundamentalValue(value);
 152       break;
 153     }
 154     case Message::STRING: {
 155       std::string value;
 156       if (reader->PopString(&value))
 157         result = new base::StringValue(value);
 158       break;
 159     }
 160     case Message::OBJECT_PATH: {
 161       ObjectPath value;
 162       if (reader->PopObjectPath(&value))
 163         result = new base::StringValue(value.value());
 164       break;
 165     }
 166     case Message::UNIX_FD: {
 167       // Cannot distinguish a file descriptor from an int
 168       NOTREACHED();
 169       break;
 170     }
 171     case Message::ARRAY: {
 172       MessageReader sub_reader(NULL);
 173       if (reader->PopArray(&sub_reader)) {
 174         // If the type of the array's element is DICT_ENTRY, create a
 175         // DictionaryValue, otherwise create a ListValue.
 176         if (sub_reader.GetDataType() == Message::DICT_ENTRY) {
 177           scoped_ptr<base::DictionaryValue> dictionary_value(
 178               new base::DictionaryValue);
 179           if (PopDictionaryEntries(&sub_reader, dictionary_value.get()))
 180             result = dictionary_value.release();
 181         } else {
 182           scoped_ptr<base::ListValue> list_value(new base::ListValue);
 183           if (PopListElements(&sub_reader, list_value.get()))
 184             result = list_value.release();
 185         }
 186       }
 187       break;
 188     }
 189     case Message::STRUCT: {
 190       MessageReader sub_reader(NULL);
 191       if (reader->PopStruct(&sub_reader)) {
 192         scoped_ptr<base::ListValue> list_value(new base::ListValue);
 193         if (PopListElements(&sub_reader, list_value.get()))
 194           result = list_value.release();
 195       }
 196       break;
 197     }
 198     case Message::DICT_ENTRY:
 199       // DICT_ENTRY must be popped as an element of an array.
 200       NOTREACHED();
 201       break;
 202     case Message::VARIANT: {
 203       MessageReader sub_reader(NULL);
 204       if (reader->PopVariant(&sub_reader))
 205         result = PopDataAsValue(&sub_reader);
 206       break;
 207     }
 208   }
 209   return result;
 210 }
 211
 212 void AppendBasicTypeValueData(MessageWriter* writer, const base::Value& value) {
 213   switch (value.GetType()) {
 214     case base::Value::TYPE_BOOLEAN: {
 215       bool bool_value = false;
 216       bool success = value.GetAsBoolean(&bool_value);
 217       DCHECK(success);
 218       writer->AppendBool(bool_value);
 219       break;
 220     }
 221     case base::Value::TYPE_INTEGER: {
 222       int int_value = 0;
 223       bool success = value.GetAsInteger(&int_value);
 224       DCHECK(success);
 225       writer->AppendInt32(int_value);
 226       break;
 227     }
 228     case base::Value::TYPE_DOUBLE: {
 229       double double_value = 0;
 230       bool success = value.GetAsDouble(&double_value);
 231       DCHECK(success);
 232       writer->AppendDouble(double_value);
 233       break;
 234     }
 235     case base::Value::TYPE_STRING: {
 236       std::string string_value;
 237       bool success = value.GetAsString(&string_value);
 238       DCHECK(success);
 239       writer->AppendString(string_value);
 240       break;
 241     }
 242     default:
 243       DLOG(ERROR) << "Unexpected type " << value.GetType();
 244       break;
 245   }
 246 }
 247
 248 void AppendBasicTypeValueDataAsVariant(MessageWriter* writer,
 249                                        const base::Value& value) {
 250   MessageWriter sub_writer(NULL);
 251   writer->OpenVariant(GetTypeSignature(value), &sub_writer);
 252   AppendBasicTypeValueData(&sub_writer, value);
 253   writer->CloseContainer(&sub_writer);
 254 }
 255
 256 }  // namespace dbus