Use new GValue chromeos_network calls instead of base::Value

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-gtype-specialized.h>
+#include <glib-object.h>
 #include <map>
 #include <set>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
@@ skipping 44 matching lines @@
 //     remembered_network_map_, in descending order of preference.
 //
 // network_manager_monitor_: a handle to the libcros network Manager handler.
 // NetworkManagerStatusChanged: This handles all messages from the Manager.
 //   Messages are parsed here and the appropriate updates are then requested.
 //
 // UpdateNetworkServiceList: This is the primary Manager handler. It handles
 //  the "Services" message which list all visible networks. The handler
 //  rebuilds the network lists without destroying existing Network structures,
 //  then requests neccessary updates to be fetched asynchronously from
-//  libcros (RequestNetworkServiceInfo).
+//  libcros (RequestNetworkServiceProperties).
 //
 // TODO(stevenjb): Document cellular data plan handlers.
 //
 // AddNetworkObserver: Adds an observer for a specific network.
 // UpdateNetworkStatus: This handles changes to a monitored service, typically
 //     changes to transient states like Strength. (Note: also updates State).
 //
 // AddNetworkDeviceObserver: Adds an observer for a specific device.
 //                           Will be called on any device property change.
 // UpdateNetworkDeviceStatus: Handles changes to a monitored device, like
@@ skipping 24 matching lines @@
 // to be able to connect to any network.
 const char* kAlwaysInRoamingOperators[] = {
   "CUBIC"
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // Misc.
 
 // Safe string constructor since we can't rely on non NULL pointers
 // for string values from libcros.
-static std::string SafeString(const char* s) {
+std::string SafeString(const char* s) {
   return s ? std::string(s) : std::string();
 }
 
 // Erase the memory used by a string, then clear it.
-static void WipeString(std::string* str) {
+void WipeString(std::string* str) {
   str->assign(str->size(), '\0');
   str->clear();
 }
 
-static bool EnsureCrosLoaded() {
+bool EnsureCrosLoaded() {
   if (!CrosLibrary::Get()->EnsureLoaded() ||
       !CrosLibrary::Get()->GetNetworkLibrary()->IsCros()) {
     return false;
   } else {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI))
         << "chromeos_network calls made from non UI thread!";
     return true;
   }
 }
 
-static void ValidateUTF8(const std::string& str, std::string* output) {
+void ValidateUTF8(const std::string& str, std::string* output) {
   output->clear();
 
   for (int32 index = 0; index < static_cast<int32>(str.size()); ++index) {
     uint32 code_point_out;
     bool is_unicode_char = base::ReadUnicodeCharacter(str.c_str(), str.size(),
                                                       &index, &code_point_out);
     if (is_unicode_char && (code_point_out >= 0x20))
       base::WriteUnicodeCharacter(code_point_out, output);
     else
       // Puts REPLACEMENT CHARACTER (U+FFFD) if character is not readable UTF-8
       base::WriteUnicodeCharacter(0xFFFD, output);
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// glib
+
+Value* ConvertGlibValue(const GValue* gvalue);
+
+void AppendListElement(const GValue* gvalue, gpointer user_data) {
+  ListValue* list = static_cast<ListValue*>(user_data);
+  Value* value = ConvertGlibValue(gvalue);
+  list->Append(value);
+}
+
+void AppendDictionaryElement(const GValue* keyvalue,
+                             const GValue* gvalue,
+                             gpointer user_data) {
+  DictionaryValue* dict = static_cast<DictionaryValue*>(user_data);
+  std::string key(g_value_get_string(keyvalue));
+  Value* value = ConvertGlibValue(gvalue);
+  dict->SetWithoutPathExpansion(key, value);
+}
+
+Value* ConvertGlibValue(const GValue* gvalue) {
+  if (G_VALUE_HOLDS_STRING(gvalue)) {
+    return Value::CreateStringValue(g_value_get_string(gvalue));
+  } else if (G_VALUE_HOLDS_BOOLEAN(gvalue)) {
+    return Value::CreateBooleanValue(
+        static_cast<bool>(g_value_get_boolean(gvalue)));
+  } else if (G_VALUE_HOLDS_INT(gvalue)) {
+    return Value::CreateIntegerValue(g_value_get_int(gvalue));
+  } else if (G_VALUE_HOLDS_UINT(gvalue)) {
+    return Value::CreateIntegerValue(
+        static_cast<int>(g_value_get_uint(gvalue)));
+  } else if (G_VALUE_HOLDS_UCHAR(gvalue)) {
+    return Value::CreateIntegerValue(
+        static_cast<int>(g_value_get_uchar(gvalue)));
+  } else if (G_VALUE_HOLDS(gvalue, DBUS_TYPE_G_OBJECT_PATH)) {
+    const char* path = static_cast<const char*>(g_value_get_boxed(gvalue));
+    return Value::CreateStringValue(path);
+  } else if (G_VALUE_HOLDS(gvalue, G_TYPE_STRV)) {
+    ListValue* list = new ListValue();
+    for (GStrv strv = static_cast<GStrv>(g_value_get_boxed(gvalue));
+         *strv != NULL; ++strv) {
+      list->Append(Value::CreateStringValue(*strv));
+    }
+    return list;
+  } else if (dbus_g_type_is_collection(G_VALUE_TYPE(gvalue))) {
+    ListValue* list = new ListValue();
+    dbus_g_type_collection_value_iterate(gvalue, AppendListElement, list);
+    return list;
+  } else if (dbus_g_type_is_map(G_VALUE_TYPE(gvalue))) {
+    DictionaryValue* dict = new DictionaryValue();
+    dbus_g_type_map_value_iterate(gvalue, AppendDictionaryElement, dict);
+    return dict;
+  } else if (G_VALUE_HOLDS(gvalue, G_TYPE_VALUE)) {
+    const GValue* bvalue = static_cast<GValue*>(g_value_get_boxed(gvalue));
+    return ConvertGlibValue(bvalue);
+  } else {
+    LOG(ERROR) << "Unrecognized Glib value type: " << G_VALUE_TYPE(gvalue);
+    return Value::CreateNullValue();
+  }
+}
+
+DictionaryValue* ConvertGHashTable(GHashTable* ghash) {
+  DictionaryValue* dict = new DictionaryValue();
+  GHashTableIter iter;
+  gpointer gkey, gvalue;
+  g_hash_table_iter_init(&iter, ghash);
+  while (g_hash_table_iter_next(&iter, &gkey, &gvalue))  {
+    std::string key(static_cast<char*>(gkey));
+    Value* value = ConvertGlibValue(static_cast<GValue*>(gvalue));
+    dict->SetWithoutPathExpansion(key, value);
+  }
+  return dict;
+}
+
+GValue* ConvertBoolToGValue(bool b) {
+  GValue* gvalue = new GValue();
+  g_value_init(gvalue, G_TYPE_BOOLEAN);
+  g_value_set_boolean(gvalue, b);
+  return gvalue;
+}
+
+GValue* ConvertIntToGValue(int i) {
+  // Converting to a 32-bit signed int type in particular, since
+  // that's what flimflam expects in its DBus API

[satorux1, 2011/08/29 19:52:47]

Not fault of this change, but use of base::Value for D-Bus calls is worrisome.
D-Bus defines many integral types such as int16, uint32, etc, whereas Value does
not. This would become a problem if flimflam starts using something other than
int32.

+  GValue* gvalue = new GValue();
+  g_value_init(gvalue, G_TYPE_INT);
+  g_value_set_int(gvalue, i);
+  return gvalue;
+}
+
+GValue* ConvertStringToGValue(const std::string& s) {
+  GValue* gvalue = new GValue();
+  g_value_init(gvalue, G_TYPE_STRING);
+  g_value_set_string(gvalue, s.c_str());
+  return gvalue;
+}
+
+GValue* ConvertValueToGValue(const Value* value) {
+  switch (value->GetType()) {
+    case Value::TYPE_BOOLEAN: {
+      bool out;
+      if (value->GetAsBoolean(&out))
+        return ConvertBoolToGValue(out);
+      break;
+    }
+    case Value::TYPE_INTEGER: {
+      int out;
+      if (value->GetAsInteger(&out))
+        return ConvertIntToGValue(out);
+      break;
+    }
+    case Value::TYPE_STRING: {
+      std::string out;
+      if (value->GetAsString(&out))
+        return ConvertStringToGValue(out);
+      break;
+    }
+    case Value::TYPE_NULL:
+    case Value::TYPE_DOUBLE:
+    case Value::TYPE_BINARY:
+    case Value::TYPE_DICTIONARY:
+    case Value::TYPE_LIST:
+      // Other Value types shouldn't be passed through this mechanism.
+      NOTREACHED() << "Unconverted Value of type: " << value->GetType();
+      return NULL;
+  }
+  NOTREACHED() << "Value conversion failed, type: " << value->GetType();
+  return NULL;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FoundCellularNetwork
 
 FoundCellularNetwork::FoundCellularNetwork() {}
 
 FoundCellularNetwork::~FoundCellularNetwork() {}
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 93 matching lines @@
   unique_id_ = name_;
 }
 
 bool Network::RequiresUserProfile() const {
   return false;
 }
 
 void Network::CopyCredentialsFromRemembered(Network* remembered) {
 }
 
-void Network::SetValueProperty(const char* prop, Value* val) {
+void Network::SetValueProperty(const char* prop, Value* value) {
   DCHECK(prop);
-  DCHECK(val);
+  DCHECK(value);
   if (!EnsureCrosLoaded())
     return;
-  chromeos::SetNetworkServiceProperty(service_path_.c_str(), prop, val);
+  scoped_ptr<GValue> gvalue(ConvertValueToGValue(value));
+  chromeos::SetNetworkServicePropertyGValue(
+      service_path_.c_str(), prop, gvalue.get());
 }
 
 void Network::ClearProperty(const char* prop) {
   DCHECK(prop);
   if (!EnsureCrosLoaded())
     return;
   chromeos::ClearNetworkServiceProperty(service_path_.c_str(), prop);
 }
 
 void Network::SetStringProperty(
@@ skipping 2698 matching lines @@
 
   virtual NetworkIPConfigVector GetIPConfigs(
       const std::string& device_path,
       std::string* hardware_address,
       HardwareAddressFormat format) OVERRIDE;
   virtual void SetIPConfig(const NetworkIPConfig& ipconfig) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // Calbacks.
   static void NetworkStatusChangedHandler(
-      void* object, const char* path, const char* key, const Value* value);
+      void* object, const char* path, const char* key, const GValue* value);
   void UpdateNetworkStatus(
       const std::string& path, const std::string& key, const Value& value);
 
   static void NetworkDevicePropertyChangedHandler(
-      void* object, const char* path, const char* key, const Value* value);
+      void* object, const char* path, const char* key, const GValue* gvalue);
   void UpdateNetworkDeviceStatus(
       const std::string& path, const std::string& key, const Value& value);
 
   static void PinOperationCallback(void* object,
                                    const char* path,
                                    NetworkMethodErrorType error,
                                    const char* error_message);
 
   static void CellularRegisterCallback(void* object,
                                        const char* path,
                                        NetworkMethodErrorType error,
                                        const char* error_message);
 
   static void NetworkConnectCallback(void* object,
                                      const char* service_path,
                                      NetworkMethodErrorType error,
                                      const char* error_message);
 
   static void WifiServiceUpdateAndConnect(
-      void* object, const char* service_path, const Value* info);
+      void* object, const char* service_path, GHashTable* ghash);
   static void VPNServiceUpdateAndConnect(
-      void* object, const char* service_path, const Value* info);
+      void* object, const char* service_path, GHashTable* ghash);
 
   static void NetworkManagerStatusChangedHandler(
-      void* object, const char* path, const char* key, const Value* value);
+      void* object, const char* path, const char* key, const GValue* value);
   static void NetworkManagerUpdate(
-      void* object, const char* manager_path, const Value* info);
+      void* object, const char* manager_path, GHashTable* ghash);
 
   static void DataPlanUpdateHandler(void* object,
                                     const char* modem_service_path,
                                     const CellularDataPlanList* dataplan);
 
   static void NetworkServiceUpdate(
-      void* object, const char* service_path, const Value* info);
+      void* object, const char* service_path, GHashTable* ghash);
   static void RememberedNetworkServiceUpdate(
-      void* object, const char* service_path, const Value* info);
+      void* object, const char* service_path, GHashTable* ghash);
   static void ProfileUpdate(
-      void* object, const char* profile_path, const Value* info);
+      void* object, const char* profile_path, GHashTable* ghash);
   static void NetworkDeviceUpdate(
-      void* object, const char* device_path, const Value* info);
+      void* object, const char* device_path, GHashTable* ghash);
 
  private:
   // This processes all Manager update messages.
   void NetworkManagerStatusChanged(const char* key, const Value* value);
   void ParseNetworkManager(const DictionaryValue& dict);
   void UpdateTechnologies(const ListValue* technologies, int* bitfieldp);
   void UpdateAvailableTechnologies(const ListValue* technologies);
   void UpdateEnabledTechnologies(const ListValue* technologies);
   void UpdateConnectedTechnologies(const ListValue* technologies);
 
@@ skipping 16 matching lines @@
                           const DictionaryValue& info);
 
   // Empty device observer to ensure that device property updates are received.
   class NetworkLibraryDeviceObserver : public NetworkDeviceObserver {
    public:
     virtual ~NetworkLibraryDeviceObserver() {}
     virtual void OnNetworkDeviceChanged(
         NetworkLibrary* cros, const NetworkDevice* device) OVERRIDE {}
   };
 
-  typedef std::map<std::string, chromeos::PropertyChangeMonitor>
-          PropertyChangeMonitorMap;
+  typedef std::map<std::string, chromeos::NetworkPropertiesMonitor>
+          NetworkPropertiesMonitorMap;
 
   // For monitoring network manager status changes.
-  PropertyChangeMonitor network_manager_monitor_;
+  NetworkPropertiesMonitor network_manager_monitor_;
 
   // For monitoring data plan changes to the connected cellular network.
   DataPlanUpdateMonitor data_plan_monitor_;
 
   // Network device observer.
   scoped_ptr<NetworkLibraryDeviceObserver> network_device_observer_;
 
   // Map of monitored networks.
-  PropertyChangeMonitorMap montitored_networks_;
+  NetworkPropertiesMonitorMap montitored_networks_;
 
   // Map of monitored devices.
-  PropertyChangeMonitorMap montitored_devices_;
+  NetworkPropertiesMonitorMap montitored_devices_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLibraryImplCros);
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 NetworkLibraryImplCros::NetworkLibraryImplCros()
     : NetworkLibraryImplBase(),
       network_manager_monitor_(NULL),
       data_plan_monitor_(NULL) {
 }
 
 NetworkLibraryImplCros::~NetworkLibraryImplCros() {
   if (network_manager_monitor_)
-    chromeos::DisconnectPropertyChangeMonitor(network_manager_monitor_);
+    chromeos::DisconnectNetworkPropertiesMonitor(network_manager_monitor_);
   if (data_plan_monitor_)
     chromeos::DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
-  for (PropertyChangeMonitorMap::iterator iter = montitored_networks_.begin();
+  for (NetworkPropertiesMonitorMap::iterator iter =
+           montitored_networks_.begin();
        iter != montitored_networks_.end(); ++iter) {
-    chromeos::DisconnectPropertyChangeMonitor(iter->second);
+    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
   }
-  for (PropertyChangeMonitorMap::iterator iter = montitored_devices_.begin();
+  for (NetworkPropertiesMonitorMap::iterator iter =
+           montitored_devices_.begin();
        iter != montitored_devices_.end(); ++iter) {
-    chromeos::DisconnectPropertyChangeMonitor(iter->second);
+    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
   }
 }
 
 void NetworkLibraryImplCros::Init() {
   // First, get the currently available networks. This data is cached
   // on the connman side, so the call should be quick.
   VLOG(1) << "Requesting initial network manager info from libcros.";
-  chromeos::RequestNetworkManagerInfo(&NetworkManagerUpdate, this);
+  chromeos::RequestNetworkManagerProperties(&NetworkManagerUpdate, this);
   network_manager_monitor_ =
-      chromeos::MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
-                                      this);
+      chromeos::MonitorNetworkManagerProperties(
+          &NetworkManagerStatusChangedHandler, this);
   data_plan_monitor_ =
       chromeos::MonitorCellularDataPlan(&DataPlanUpdateHandler, this);
   // Always have at least one device obsever so that device updates are
   // always received.
   network_device_observer_.reset(new NetworkLibraryDeviceObserver());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase implementation.
 
 void NetworkLibraryImplCros::MonitorNetworkStart(
     const std::string& service_path) {
   if (montitored_networks_.find(service_path) == montitored_networks_.end()) {
-    chromeos::PropertyChangeMonitor monitor =
-        chromeos::MonitorNetworkService(&NetworkStatusChangedHandler,
-                                        service_path.c_str(),
-                                        this);
+    chromeos::NetworkPropertiesMonitor monitor =
+        chromeos::MonitorNetworkServiceProperties(
+            &NetworkStatusChangedHandler, service_path.c_str(), this);
     montitored_networks_[service_path] = monitor;
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkStop(
     const std::string& service_path) {
-  PropertyChangeMonitorMap::iterator iter =
+  NetworkPropertiesMonitorMap::iterator iter =
       montitored_networks_.find(service_path);
   if (iter != montitored_networks_.end()) {
-    chromeos::DisconnectPropertyChangeMonitor(iter->second);
+    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
     montitored_networks_.erase(iter);
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkDeviceStart(
     const std::string& device_path) {
   if (montitored_devices_.find(device_path) == montitored_devices_.end()) {
-    chromeos::PropertyChangeMonitor monitor =
-        chromeos::MonitorNetworkDevice(&NetworkDevicePropertyChangedHandler,
-                                       device_path.c_str(),
-                                       this);
+    chromeos::NetworkPropertiesMonitor monitor =
+        chromeos::MonitorNetworkDeviceProperties(
+            &NetworkDevicePropertyChangedHandler, device_path.c_str(), this);
     montitored_devices_[device_path] = monitor;
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkDeviceStop(
     const std::string& device_path) {
-  PropertyChangeMonitorMap::iterator iter =
+  NetworkPropertiesMonitorMap::iterator iter =
       montitored_devices_.find(device_path);
   if (iter != montitored_devices_.end()) {
-    chromeos::DisconnectPropertyChangeMonitor(iter->second);
+    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
     montitored_devices_.erase(iter);
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkStatusChangedHandler(
-    void* object, const char* path, const char* key, const Value* value) {
+    void* object, const char* path, const char* key, const GValue* gvalue) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (key == NULL || value == NULL || path == NULL || object == NULL)
+  if (key == NULL || gvalue == NULL || path == NULL || object == NULL)
     return;
+  scoped_ptr<Value> value(ConvertGlibValue(gvalue));
   networklib->UpdateNetworkStatus(std::string(path), std::string(key), *value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkStatus(
     const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Network* network = FindNetworkByPath(path);
   if (network) {
     VLOG(2) << "UpdateNetworkStatus: " << network->name() << "." << key;
     bool prev_connected = network->connected();
     if (!network->UpdateStatus(key, value, NULL)) {
       LOG(WARNING) << "UpdateNetworkStatus: Error updating: "
                    << path << "." << key;
     }
     // If we just connected, this may have been added to remembered list.
     if (!prev_connected && network->connected())
       RequestRememberedNetworksUpdate();
     NotifyNetworkChanged(network);
     // Anything observing the manager needs to know about any service change.
     NotifyNetworkManagerChanged(false);  // Not forced.
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
-    void* object, const char* path, const char* key, const Value* value) {
+    void* object, const char* path, const char* key, const GValue* gvalue) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (key == NULL || value == NULL || path == NULL || object == NULL)
+  if (key == NULL || gvalue == NULL || path == NULL || object == NULL)
     return;
+  scoped_ptr<Value> value(ConvertGlibValue(gvalue));
   networklib->UpdateNetworkDeviceStatus(std::string(path),
                                         std::string(key),
                                         *value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
     const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   NetworkDevice* device = FindNetworkDeviceByPath(path);
   if (device) {
@@ skipping 14 matching lines @@
         }
       }
     } else {
       VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
     }
     // Notify only observers on device property change.
     NotifyNetworkDeviceChanged(device, index);
     // If a device's power state changes, new properties may become defined.
     if (index == PROPERTY_INDEX_POWERED)
-      chromeos::RequestNetworkDeviceInfo(path.c_str(),
-                                         &NetworkDeviceUpdate,
-                                         this);
+      chromeos::RequestNetworkDeviceProperties(path.c_str(),
+                                               &NetworkDeviceUpdate,
+                                               this);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase connect implementation.
 
 // static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
@@ skipping 24 matching lines @@
 }
 
 void NetworkLibraryImplCros::CallConnectToNetwork(Network* network) {
   DCHECK(network);
   chromeos::RequestNetworkServiceConnect(network->service_path().c_str(),
                                          NetworkConnectCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
-    void* object, const char* service_path, const Value* info) {
+    void* object, const char* service_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path && info) {
-    DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-    const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
+  if (service_path && ghash) {
+    scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), *dict);
+        networklib->ParseNetwork(std::string(service_path), *(dict.get()));
     DCHECK_EQ(network->type(), TYPE_WIFI);
     networklib->ConnectToWifiNetworkUsingConnectData(
         static_cast<WifiNetwork*>(network));
   }
 }
 
 void NetworkLibraryImplCros::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   // Asynchronously request service properties and call
   // WifiServiceUpdateAndConnect.
-  chromeos::RequestHiddenWifiNetwork(ssid.c_str(),
-                                     SecurityToString(security),
-                                     WifiServiceUpdateAndConnect,
-                                     this);
+  chromeos::RequestHiddenWifiNetworkProperties(
+      ssid.c_str(),
+      SecurityToString(security),
+      WifiServiceUpdateAndConnect,
+      this);
 }
 
 // static callback
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
-    void* object, const char* service_path, const Value* info) {
+    void* object, const char* service_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path && info) {
+  if (service_path && ghash) {
     VLOG(1) << "Connecting to new VPN Service: " << service_path;
-    DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-    const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
+    scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), *dict);
+        networklib->ParseNetwork(std::string(service_path), *(dict.get()));
     DCHECK_EQ(network->type(), TYPE_VPN);
     networklib->ConnectToVirtualNetworkUsingConnectData(
         static_cast<VirtualNetwork*>(network));
   } else {
     LOG(WARNING) << "Unable to create VPN Service: " << service_path;
   }
 }
 
 void NetworkLibraryImplCros::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
     ProviderType provider_type) {
-  chromeos::RequestVirtualNetwork(service_name.c_str(),
-                                  server_hostname.c_str(),
-                                  ProviderTypeToString(provider_type),
-                                  VPNServiceUpdateAndConnect,
-                                  this);
+  chromeos::RequestVirtualNetworkProperties(
+      service_name.c_str(),
+      server_hostname.c_str(),
+      ProviderTypeToString(provider_type),
+      VPNServiceUpdateAndConnect,
+      this);
 }
 
 void NetworkLibraryImplCros::CallDeleteRememberedNetwork(
     const std::string& profile_path,
     const std::string& service_path) {
   chromeos::DeleteServiceFromProfile(
       profile_path.c_str(), service_path.c_str());
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 122 matching lines @@
   // but not UI doesn't assume such notification so just ignore result.
 }
 
 void NetworkLibraryImplCros::SetCellularDataRoamingAllowed(bool new_value) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling SetCellularDataRoamingAllowed method "
         "w/o cellular device.";
     return;
   }
-  scoped_ptr<Value> value(Value::CreateBooleanValue(new_value));
-  chromeos::SetNetworkDeviceProperty(cellular->device_path().c_str(),
-                                     kCellularAllowRoamingProperty,
-                                     value.get());
+  scoped_ptr<GValue> gvalue(ConvertBoolToGValue(new_value));
+  chromeos::SetNetworkDevicePropertyGValue(cellular->device_path().c_str(),
+                                           kCellularAllowRoamingProperty,
+                                           gvalue.get());
 }
 
 bool NetworkLibraryImplCros::IsCellularAlwaysInRoaming() {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling IsCellularAlwaysInRoaming method "
         "w/o cellular device.";
     return false;
   }
   const std::string& home_provider_name = cellular->home_provider_name();
   for (size_t i = 0; i < arraysize(kAlwaysInRoamingOperators); i++) {
     if (home_provider_name == kAlwaysInRoamingOperators[i])
       return true;
   }
   return false;
 }
 
 void NetworkLibraryImplCros::RequestNetworkScan() {
   if (wifi_enabled()) {
     wifi_scanning_ = true;  // Cleared when updates are received.
     chromeos::RequestNetworkScan(kTypeWifi);
   }
   if (cellular_network())
     cellular_network()->RefreshDataPlansIfNeeded();
   // Make sure all Manager info is up to date. This will also update
   // remembered networks and visible services.
-  chromeos::RequestNetworkManagerInfo(&NetworkManagerUpdate, this);
+  chromeos::RequestNetworkManagerProperties(&NetworkManagerUpdate, this);
 }
 
 bool NetworkLibraryImplCros::GetWifiAccessPoints(
     WifiAccessPointVector* result) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DeviceNetworkList* network_list = chromeos::GetDeviceNetworkList();
   if (network_list == NULL)
     return false;
   result->clear();
   result->reserve(network_list->network_size);
@@ skipping 110 matching lines @@
       if (ipconfig_status2) {
         for (int i = 0; i < ipconfig_status2->size; ++i) {
           if (ipconfig_status2->ips[i].type == chromeos::IPCONFIG_TYPE_IPV4)
             ipconfig_static = &ipconfig_status2->ips[i];
         }
       }
     }
     if (ipconfig_static) {
       // Save any changed details.
       if (ipconfig.address != ipconfig_static->address) {
-        scoped_ptr<Value> value(Value::CreateStringValue(ipconfig.address));
-        chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
-                                             kAddressProperty,
-                                             value.get());
+        scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.address));
+        chromeos::SetNetworkIPConfigPropertyGValue(
+            ipconfig_static->path, kAddressProperty, gvalue.get());
       }
       if (ipconfig.netmask != ipconfig_static->netmask) {
-        int32 prefixlen = ipconfig.GetPrefixLength();
+        int prefixlen = ipconfig.GetPrefixLength();
         if (prefixlen == -1) {
           VLOG(1) << "IP config prefixlen is invalid for netmask "
                   << ipconfig.netmask;
         } else {
-          scoped_ptr<Value> value(Value::CreateIntegerValue(prefixlen));
-          chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
-                                               kPrefixlenProperty,
-                                               value.get());
+          scoped_ptr<GValue> gvalue(ConvertIntToGValue(prefixlen));
+          chromeos::SetNetworkIPConfigPropertyGValue(
+              ipconfig_static->path, kPrefixlenProperty, gvalue.get());
         }
       }
       if (ipconfig.gateway != ipconfig_static->gateway) {
-        scoped_ptr<Value> value(Value::CreateStringValue(ipconfig.gateway));
-        chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
-                                             kGatewayProperty,
-                                             value.get());
+        scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.gateway));
+        chromeos::SetNetworkIPConfigPropertyGValue(
+            ipconfig_static->path, kGatewayProperty, gvalue.get());
       }
       if (ipconfig.name_servers != ipconfig_static->name_servers) {
-        scoped_ptr<Value> value(
-            Value::CreateStringValue(ipconfig.name_servers));
-        chromeos::SetNetworkIPConfigProperty(ipconfig_static->path,
-                                             kNameServersProperty,
-                                             value.get());
+        scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.name_servers));
+        chromeos::SetNetworkIPConfigPropertyGValue(
+            ipconfig_static->path, kNameServersProperty, gvalue.get());
       }
       // Remove dhcp ip config if there is one.
       if (ipconfig_dhcp)
         chromeos::RemoveIPConfig(ipconfig_dhcp);
     }
   }
 
   if (ipconfig_status)
     chromeos::FreeIPConfigStatus(ipconfig_status);
   if (ipconfig_status2)
     chromeos::FreeIPConfigStatus(ipconfig_status2);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Network Manager functions.
 
 // static
 void NetworkLibraryImplCros::NetworkManagerStatusChangedHandler(
-    void* object, const char* path, const char* key, const Value* value) {
+    void* object, const char* path, const char* key, const GValue* gvalue) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->NetworkManagerStatusChanged(key, value);
+  scoped_ptr<Value> value(ConvertGlibValue(gvalue));
+  networklib->NetworkManagerStatusChanged(key, value.get());
 }
 
 // This processes all Manager update messages.
 void NetworkLibraryImplCros::NetworkManagerStatusChanged(
     const char* key, const Value* value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::TimeTicks start = base::TimeTicks::Now();
   if (!key)
     return;
   VLOG(1) << "NetworkManagerStatusChanged: KEY=" << key;
@@ skipping 75 matching lines @@
       break;
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
 }
 
 // static
 void NetworkLibraryImplCros::NetworkManagerUpdate(
-    void* object, const char* manager_path, const Value* info) {
+    void* object, const char* manager_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (!info) {
+  if (!ghash) {
     LOG(ERROR) << "Error retrieving manager properties: " << manager_path;
     return;
   }
   VLOG(1) << "Received NetworkManagerUpdate.";
-  DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-  const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-  networklib->ParseNetworkManager(*dict);
+  scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
+  networklib->ParseNetworkManager(*(dict.get()));
 }
 
 void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue& dict) {
   for (DictionaryValue::key_iterator iter = dict.begin_keys();
        iter != dict.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
     bool res = dict.GetWithoutPathExpansion(key, &value);
     CHECK(res);
     NetworkManagerStatusChanged(key.c_str(), value);
@@ skipping 92 matching lines @@
         AddNetwork(found->second);
         old_network_map.erase(found);
       }
       // Always request network updates.
       // TODO(stevenjb): Investigate why we are missing updates then
       // rely on watched network updates and only request updates here for
       // new networks.
       // Use update_request map to store network priority.
       network_update_requests_[service_path] = network_priority_order++;
       wifi_scanning_ = true;
-      chromeos::RequestNetworkServiceInfo(service_path.c_str(),
-                                          &NetworkServiceUpdate,
-                                          this);
+      chromeos::RequestNetworkServiceProperties(service_path.c_str(),
+                                                &NetworkServiceUpdate,
+                                                this);
     }
   }
   // Iterate through list of remaining networks that are no longer in the
   // list and delete them or update their status and re-add them to the list.
   for (NetworkMap::iterator iter = old_network_map.begin();
        iter != old_network_map.end(); ++iter) {
     Network* network = iter->second;
     VLOG(2) << "Delete Network: " << network->name()
             << " State = " << network->GetStateString()
             << " connecting = " << network->connecting()
@@ skipping 22 matching lines @@
 // Existing networks will be updated. There should not be any new networks
 // in this list, but if there are they will be added appropriately.
 void NetworkLibraryImplCros::UpdateWatchedNetworkServiceList(
     const ListValue* services) {
   for (ListValue::const_iterator iter = services->begin();
        iter != services->end(); ++iter) {
     std::string service_path;
     (*iter)->GetAsString(&service_path);
     if (!service_path.empty()) {
       VLOG(1) << "Watched Service: " << service_path;
-      chromeos::RequestNetworkServiceInfo(service_path.c_str(),
-                                          &NetworkServiceUpdate,
-                                          this);
+      chromeos::RequestNetworkServiceProperties(service_path.c_str(),
+                                                &NetworkServiceUpdate,
+                                                this);
     }
   }
 }
 
 // static
 void NetworkLibraryImplCros::NetworkServiceUpdate(
-    void* object, const char* service_path, const Value* info) {
+    void* object, const char* service_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
-    if (!info)
+    if (!ghash)
       return;  // Network no longer in visible list, ignore.
-    DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-    const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-    networklib->ParseNetwork(std::string(service_path), *dict);
+    scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
+    networklib->ParseNetwork(std::string(service_path), *(dict.get()));
   }
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
     NativeNetworkParser parser;
     network = parser.CreateNetworkFromInfo(service_path, info);
@@ skipping 72 matching lines @@
           network->SetProfilePath(profile_path);
       }
       user_networks_.clear();
     }
   }
 }
 
 void NetworkLibraryImplCros::RequestRememberedNetworksUpdate() {
   VLOG(1) << "RequestRememberedNetworksUpdate";
   // Delete all remembered networks. We delete them because
-  // RequestNetworkProfile is asynchronous and may invoke
+  // RequestNetworkProfileProperties is asynchronous and may invoke
   // UpdateRememberedServiceList multiple times (once per profile).
   // We can do this safely because we do not save any local state for
   // remembered networks. This list updates infrequently.
   DeleteRememberedNetworks();
   // Request remembered networks from each profile. Later entries will
   // override earlier entries, so default/local entries will override
   // user entries (as desired).
   for (NetworkProfileList::iterator iter = profile_list_.begin();
        iter != profile_list_.end(); ++iter) {
     NetworkProfile& profile = *iter;
     VLOG(1) << " Requesting Profile: " << profile.path;
-    chromeos::RequestNetworkProfile(
+    chromeos::RequestNetworkProfileProperties(
         profile.path.c_str(), &ProfileUpdate, this);
   }
 }
 
 // static
 void NetworkLibraryImplCros::ProfileUpdate(
-    void* object, const char* profile_path, const Value* info) {
+    void* object, const char* profile_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (!info) {
+  if (!ghash) {
     LOG(ERROR) << "Error retrieving profile: " << profile_path;
     return;
   }
   VLOG(1) << "Received ProfileUpdate for: " << profile_path;
-  DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-  const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
+  scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
   ListValue* entries(NULL);
   dict->GetList(kEntriesProperty, &entries);
   DCHECK(entries);
   networklib->UpdateRememberedServiceList(profile_path, entries);
 }
 
 void NetworkLibraryImplCros::UpdateRememberedServiceList(
     const char* profile_path, const ListValue* profile_entries) {
   DCHECK(profile_path);
   VLOG(1) << "UpdateRememberedServiceList for path: " << profile_path;
@@ skipping 14 matching lines @@
     std::string service_path;
     (*iter2)->GetAsString(&service_path);
     if (service_path.empty()) {
       LOG(WARNING) << "Empty service path in profile.";
       continue;
     }
     VLOG(1) << " Remembered service: " << service_path;
     // Add service to profile list.
     profile.services.insert(service_path);
     // Request update for remembered network.
-    chromeos::RequestNetworkProfileEntry(profile_path,
-                                         service_path.c_str(),
-                                         &RememberedNetworkServiceUpdate,
-                                         this);
+    chromeos::RequestNetworkProfileEntryProperties(
+        profile_path,
+        service_path.c_str(),
+        &RememberedNetworkServiceUpdate,
+        this);
   }
 }
 
 // static
 void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
-    void* object, const char* service_path, const Value* info) {
+    void* object, const char* service_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
-    if (!info) {
+    if (!ghash) {
       // Remembered network no longer exists.
       networklib->DeleteRememberedNetwork(std::string(service_path));
     } else {
-      DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseRememberedNetwork(std::string(service_path), *dict);
+      scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
+      networklib->ParseRememberedNetwork(
+          std::string(service_path), *(dict.get()));
     }
   }
 }
 
 // Returns NULL if |service_path| refers to a network that is not a
 // remembered type. Called from RememberedNetworkServiceUpdate.
 Network* NetworkLibraryImplCros::ParseRememberedNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* remembered;
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
@@ skipping 22 matching lines @@
 
   if (remembered->type() == TYPE_VPN) {
     // VPNs are only stored in profiles. If we don't have a network for it,
     // request one.
     if (!FindNetworkFromRemembered(remembered)) {
       VirtualNetwork* vpn = static_cast<VirtualNetwork*>(remembered);
       std::string provider_type = ProviderTypeToString(vpn->provider_type());
       VLOG(1) << "Requesting VPN: " << vpn->name()
               << " Server: " << vpn->server_hostname()
               << " Type: " << provider_type;
-      chromeos::RequestVirtualNetwork(vpn->name().c_str(),
-                                      vpn->server_hostname().c_str(),
-                                      provider_type.c_str(),
-                                      NetworkServiceUpdate,
-                                      this);
+      chromeos::RequestVirtualNetworkProperties(
+          vpn->name().c_str(),
+          vpn->server_hostname().c_str(),
+          provider_type.c_str(),
+          NetworkServiceUpdate,
+          this);
     }
   }
 
   return remembered;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // NetworkDevice list management functions.
 
 // Update device list, and request associated device updates.
 // |devices| represents a complete list of devices.
 void NetworkLibraryImplCros::UpdateNetworkDeviceList(const ListValue* devices) {
   NetworkDeviceMap old_device_map = device_map_;
   device_map_.clear();
   VLOG(2) << "Updating Device List.";
   for (ListValue::const_iterator iter = devices->begin();
        iter != devices->end(); ++iter) {
     std::string device_path;
     (*iter)->GetAsString(&device_path);
     if (!device_path.empty()) {
       NetworkDeviceMap::iterator found = old_device_map.find(device_path);
       if (found != old_device_map.end()) {
         VLOG(2) << " Adding existing device: " << device_path;
         CHECK(found->second) << "Attempted to add NULL device pointer";
         device_map_[device_path] = found->second;
         old_device_map.erase(found);
       }
-      chromeos::RequestNetworkDeviceInfo(device_path.c_str(),
-                                         &NetworkDeviceUpdate,
-                                         this);
+      chromeos::RequestNetworkDeviceProperties(device_path.c_str(),
+                                               &NetworkDeviceUpdate,
+                                               this);
     }
   }
   // Delete any old devices that no longer exist.
   for (NetworkDeviceMap::iterator iter = old_device_map.begin();
        iter != old_device_map.end(); ++iter) {
     DeleteDeviceFromDeviceObserversMap(iter->first);
     // Delete device.
     delete iter->second;
   }
 }
 
 // static
 void NetworkLibraryImplCros::NetworkDeviceUpdate(
-    void* object, const char* device_path, const Value* info) {
+    void* object, const char* device_path, GHashTable* ghash) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (device_path) {
-    if (!info) {
+    if (!ghash) {
       // device no longer exists.
       networklib->DeleteDevice(std::string(device_path));
     } else {
-      DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseNetworkDevice(std::string(device_path), *dict);
+      scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
+      networklib->ParseNetworkDevice(std::string(device_path), *(dict.get()));
     }
   }
 }
 
 void NetworkLibraryImplCros::ParseNetworkDevice(const std::string& device_path,
                                                 const DictionaryValue& info) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   NetworkDevice* device;
   if (found != device_map_.end()) {
     device = found->second;
@@ skipping 382 matching lines @@
   return network_library;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until its last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);