Chrome OS: Attach bluetooth UI to device discovery API

dbus/message.cc

Index: dbus/message.cc
diff --git a/dbus/message.cc b/dbus/message.cc
index aa9cc550e46ce792db8fdb1a4289d80fa7933865..7f8e071e6213cf85b279d01d20c53e51c03a4fe7 100644
--- a/dbus/message.cc
+++ b/dbus/message.cc
@@ -793,6 +793,143 @@ bool MessageReader::PopArrayOfObjectPaths(
   return true;
 }
 
+// TODO(vlaviano):
+// - Can we handle integral types better?
+// - Add support for nested complex types.
+// - Write an equivalent function for MessageWriter.
+// - Write unit tests.
+bool MessageReader::PopArrayOfDictEntries(DictionaryValue* dictionary) {
+  CHECK(dictionary != NULL);
+  MessageReader array_reader(message_);
+  if (!PopArray(&array_reader)) {
+    return false;
+  }
+  while (array_reader.HasMoreData()) {
+    MessageReader dict_entry_reader(message_);
+    if (!array_reader.PopContainer(DBUS_TYPE_DICT_ENTRY, &dict_entry_reader)) {
+      return false;
+    }
+    std::string key;
+    if (!dict_entry_reader.PopString(&key)) {
+      return false;
+    }
+    MessageReader variant_reader(message_);
+    if (!dict_entry_reader.PopVariant(&variant_reader)) {
+      return false;
+    }
+    const Message::DataType type = variant_reader.GetDataType();
+    switch (type) {
+      case Message::BYTE: {
+        uint8 value = 0;
+        if (!variant_reader.PopByte(&value)) {
+          return false;
+        }
+        dictionary->SetInteger(key, value);
+        break;
+      }
+      case Message::BOOL: {
+        bool value = false;
+        if (!variant_reader.PopBool(&value)) {
+          return false;
+        }
+        dictionary->SetBoolean(key, value);
+        break;
+      }
+      case Message::INT16: {
+        int16 value = 0;
+        if (!variant_reader.PopInt16(&value)) {
+          return false;
+        }
+        dictionary->SetInteger(key, value);
+        break;
+      }
+      case Message::UINT16: {
+        uint16 value = 0;
+        if (!variant_reader.PopUint16(&value)) {
+          return false;
+        }
+        dictionary->SetInteger(key, value);
+        break;
+      }
+      case Message::INT32: {
+        int32 value = 0;
+        if (!variant_reader.PopInt32(&value)) {
+          return false;
+        }
+        dictionary->SetInteger(key, value);
+        break;
+      }
+      case Message::UINT32: {
+        uint32 value = 0;
+        if (!variant_reader.PopUint32(&value)) {
+          return false;
+        }
+        dictionary->SetInteger(key, value);
+        break;
+      }
+      case Message::INT64: {
+        int64 value = 0;
+        if (!variant_reader.PopInt64(&value)) {
+          return false;
+        }
+        dictionary->SetDouble(key, value);
+        break;
+      }
+      case Message::UINT64: {
+        uint64 value = 0;
+        if (!variant_reader.PopUint64(&value)) {
+          return false;
+        }
+        dictionary->SetDouble(key, value);
+        break;
+      }
+      case Message::DOUBLE: {
+        double value = 0;
+        if (!variant_reader.PopDouble(&value)) {
+          return false;
+        }
+        dictionary->SetDouble(key, value);
+        break;
+      }
+      case Message::STRING: {
+        std::string value;
+        if (!variant_reader.PopString(&value)) {
+          return false;
+        }
+        dictionary->SetString(key, value);
+        break;
+      }
+      case Message::OBJECT_PATH: {
+        std::string value;
+        if (!variant_reader.PopObjectPath(&value)) {
+          return false;
+        }
+        dictionary->SetString(key, value);
+        break;
+      }
+      case Message::ARRAY: {
+        // Not yet supported.
+        return false;
+      }
+      case Message::STRUCT: {
+        // Not yet supported.
+        return false;
+      }
+      case Message::DICT_ENTRY: {
+        // Not yet supported.
+        return false;
+      }
+      case Message::VARIANT: {
+        // Not yet supported.
+        return false;
+      }
+      default:
+        LOG(FATAL) << "Unknown type: " << type;
+    }
+  }
+  return true;
+}
+
 bool MessageReader::PopVariantOfByte(uint8* value) {
   return PopVariantOfBasic(DBUS_TYPE_BYTE, value);
 }