nfc: Various fixes to the NFC D-Bus client in chromeos/dbus.

chromeos/dbus/nfc_client_helpers.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/dbus/nfc_client_helpers.h"
 
 #include "base/stl_util.h"
+#include "dbus/values_util.h"
 
 namespace chromeos {
 namespace nfc_client_helpers {
 
 const char kNoResponseError[] = "org.chromium.Error.NoResponse";
 const char kUnknownObjectError[] = "org.chromium.Error.UnknownObject";
 
 void OnSuccess(const base::Closure& callback, dbus::Response* response) {
   DCHECK(response);
   callback.Run();
 }
 
 void OnError(const ErrorCallback& error_callback,
              dbus::ErrorResponse* response) {
   // Error response has optional error message argument.
   std::string error_name;
   std::string error_message;
   if (response) {
     dbus::MessageReader reader(response);
     error_name = response->GetErrorName();
     reader.PopString(&error_message);
   } else {
     error_name = kNoResponseError;
     error_message = "";
   }
   error_callback.Run(error_name, error_message);
 }
 
+void AppendValueDataAsVariant(dbus::MessageWriter* writer,
+                              const base::Value& value) {
+  switch (value.GetType()) {
+    case base::Value::TYPE_DICTIONARY: {
+      const base::DictionaryValue* dictionary = NULL;
+      value.GetAsDictionary(&dictionary);
+      dbus::MessageWriter variant_writer(NULL);
+      dbus::MessageWriter array_writer(NULL);
+      writer->OpenVariant("a{sv}", &variant_writer);
+      variant_writer.OpenArray("{sv}", &array_writer);
+      for (base::DictionaryValue::Iterator iter(*dictionary);
+           !iter.IsAtEnd(); iter.Advance()) {
+        dbus::MessageWriter entry_writer(NULL);
+        array_writer.OpenDictEntry(&entry_writer);
+        entry_writer.AppendString(iter.key());
+        AppendValueDataAsVariant(&entry_writer, iter.value());
+        array_writer.CloseContainer(&entry_writer);
+      }
+      variant_writer.CloseContainer(&array_writer);
+      writer->CloseContainer(&variant_writer);
+      break;
+    }
+    case base::Value::TYPE_LIST: {
+      const base::ListValue* list = NULL;
+      value.GetAsList(&list);
+      dbus::MessageWriter variant_writer(NULL);
+      dbus::MessageWriter array_writer(NULL);
+      writer->OpenVariant("av", &variant_writer);
+      variant_writer.OpenArray("v", &array_writer);
+      for (base::ListValue::const_iterator iter = list->begin();
+           iter != list->end(); ++iter) {
+        const base::Value* value = *iter;
+        AppendValueDataAsVariant(&array_writer, *value);
+      }
+      variant_writer.CloseContainer(&array_writer);
+      writer->CloseContainer(&variant_writer);
+      break;
+    }
+    case base::Value::TYPE_BOOLEAN:
+    case base::Value::TYPE_INTEGER:
+    case base::Value::TYPE_DOUBLE:
+    case base::Value::TYPE_STRING:
+      dbus::AppendBasicTypeValueDataAsVariant(writer, value);
+      break;
+    default:
+      DLOG(ERROR) << "Unexpected type: " << value.GetType();
+  }
+}
+
 DBusObjectMap::DBusObjectMap(const std::string& service_name,
                              Delegate* delegate,
                              dbus::Bus* bus)
     : bus_(bus),
       service_name_(service_name),
       delegate_(delegate) {
   DCHECK(bus_);
   DCHECK(delegate_);
 }
 
@@ skipping 188 matching lines @@
     NfcPropertySet* properties =
         object_map->GetObjectProperties(object_proxy_path);
     if (properties)
       return properties;
   }
   return NULL;
 }
 
 }  // namespace nfc_client_helpers
 }  // namespace chromeos