Reimplement Libcros fucntions using FlimflamProfileClient

chrome/browser/chromeos/cros/cros_network_functions.cc

 // Copyright (c) 2012 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/cros_network_functions.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/gvalue_util.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/flimflam_profile_client.h"
+#include "dbus/object_path.h"
 
 namespace chromeos {
 
 namespace {
 
+// Does nothing. Used as a callback.
+void DoNothing(DBusMethodCallStatus call_status) {}
+
 // Callback used by OnRequestNetworkProperties.
 typedef base::Callback<void(const char* path,
                             const base::DictionaryValue* properties)
                        > OnRequestNetworkPropertiesCallback;
 
 // Handles responses for RequestNetwork*Properties functions.
 void OnRequestNetworkProperties(void* object,
                                 const char* path,
                                 GHashTable* properties) {
   OnRequestNetworkPropertiesCallback* callback =
       static_cast<OnRequestNetworkPropertiesCallback*>(object);
   DictionaryValue* properties_dictionary = NULL;
   if (properties)
     properties_dictionary =
         ConvertStringValueGHashTableToDictionaryValue(properties);
 
   // Deleters.
   scoped_ptr<OnRequestNetworkPropertiesCallback> callback_deleter(callback);
   scoped_ptr<DictionaryValue> properties_dictionary_deleter(
       properties_dictionary);
 
   callback->Run(path, properties_dictionary);
 }
 
+// A callback used to implement CrosRequest*Properties functions.
+void RunCallbackWithDictionaryValue(const NetworkPropertiesCallback& callback,
+                                    const char* path,
+                                    DBusMethodCallStatus call_status,
+                                    const base::DictionaryValue& value) {
+  callback.Run(path, call_status == DBUS_METHOD_CALL_SUCCESS ? &value : NULL);
+}
+
+// A bool to remember whether we are using non-Libcros implementation or not.
+bool g_non_libcros_network_functions_enabled = false;
+
 }  // namespace
 
+void EnableNonLibcrosNetworkFunctions(bool enabled) {
+  g_non_libcros_network_functions_enabled = enabled;
+}
+
 bool CrosActivateCellularModem(const char* service_path, const char* carrier) {
   return chromeos::ActivateCellularModem(service_path, carrier);
 }
 
 void CrosSetNetworkServiceProperty(const char* service_path,
                                    const char* property,
                                    const base::Value& value) {
   ScopedGValue gvalue(ConvertValueToGValue(value));
   chromeos::SetNetworkServicePropertyGValue(service_path, property,
                                             gvalue.get());
@@ skipping 20 matching lines @@
 }
 
 void CrosSetNetworkManagerProperty(const char* property,
                                    const base::Value& value) {
   ScopedGValue gvalue(ConvertValueToGValue(value));
   chromeos::SetNetworkManagerPropertyGValue(property, gvalue.get());
 }
 
 void CrosDeleteServiceFromProfile(const char* profile_path,
                                   const char* service_path) {
-  chromeos::DeleteServiceFromProfile(profile_path, service_path);
+  if (!g_non_libcros_network_functions_enabled) {
+    // Use Libcros.
+    chromeos::DeleteServiceFromProfile(profile_path, service_path);
+    return;

[stevenjb, 2012/04/12 17:34:36]

I don't think this is a good place for early-exit style. I think all of this
code will be more readable as:
if (enable_libcros_functions) {
} else {
}

[hashimoto, 2012/04/13 05:27:22]

I thought new (non libcros) implementations may be complex and it's good to
avoid indenting the new implementations.
But it's OK if you prefer the style where everything is placed in if-else
braces.

+  }
+  DBusThreadManager::Get()->GetFlimflamProfileClient()->DeleteEntry(
+      dbus::ObjectPath(profile_path), service_path, base::Bind(&DoNothing));
 }
 
 void CrosRequestCellularDataPlanUpdate(const char* modem_service_path) {
   chromeos::RequestCellularDataPlanUpdate(modem_service_path);
 }
 
 NetworkPropertiesMonitor CrosMonitorNetworkManagerProperties(
     MonitorPropertyGValueCallback callback,
     void* object) {
   return chromeos::MonitorNetworkManagerProperties(callback, object);
@@ skipping 70 matching lines @@
   // The newly allocated callback will be deleted in OnRequestNetworkProperties.
   chromeos::RequestNetworkDeviceProperties(
       device_path,
       &OnRequestNetworkProperties,
       new OnRequestNetworkPropertiesCallback(callback));
 }
 
 void CrosRequestNetworkProfileProperties(
     const char* profile_path,
     const NetworkPropertiesCallback& callback) {
-  // The newly allocated callback will be deleted in OnRequestNetworkProperties.
-  chromeos::RequestNetworkProfileProperties(
-      profile_path,
-      &OnRequestNetworkProperties,
-      new OnRequestNetworkPropertiesCallback(callback));
+  if (!g_non_libcros_network_functions_enabled) {
+    // Use Libcros.

[stevenjb, 2012/04/12 17:34:36]

unnecessary comment here and elsewhere

[hashimoto, 2012/04/13 05:27:22]

Done.

+    // The newly allocated callback will be deleted in
+    // OnRequestNetworkProperties.
+    chromeos::RequestNetworkProfileProperties(
+        profile_path,
+        &OnRequestNetworkProperties,
+        new OnRequestNetworkPropertiesCallback(callback));
+    return;
+  }
+  DBusThreadManager::Get()->GetFlimflamProfileClient()->GetProperties(
+      dbus::ObjectPath(profile_path),
+      base::Bind(&RunCallbackWithDictionaryValue, callback, profile_path));
 }
 
 void CrosRequestNetworkProfileEntryProperties(
     const char* profile_path,
     const char* profile_entry_path,
     const NetworkPropertiesCallback& callback) {
-  // The newly allocated callback will be deleted in OnRequestNetworkProperties.
-  chromeos::RequestNetworkProfileEntryProperties(
-      profile_path,
+  if (!g_non_libcros_network_functions_enabled) {
+    // Use Libcros.
+    // The newly allocated callback will be deleted in
+    // OnRequestNetworkProperties.
+    chromeos::RequestNetworkProfileEntryProperties(
+        profile_path,
+        profile_entry_path,
+        &OnRequestNetworkProperties,
+        new OnRequestNetworkPropertiesCallback(callback));
+    return;
+  }
+  DBusThreadManager::Get()->GetFlimflamProfileClient()->GetEntry(
+      dbus::ObjectPath(profile_path),
       profile_entry_path,
-      &OnRequestNetworkProperties,
-      new OnRequestNetworkPropertiesCallback(callback));
+      base::Bind(&RunCallbackWithDictionaryValue,
+                 callback,
+                 profile_entry_path));
 }
 
 void CrosRequestHiddenWifiNetworkProperties(
     const char* ssid,
     const char* security,
     const NetworkPropertiesCallback& callback) {
   // The newly allocated callback will be deleted in OnRequestNetworkProperties.
   chromeos::RequestHiddenWifiNetworkProperties(
       ssid,
       security,
@@ skipping 104 matching lines @@
 void CrosConfigureService(const char* identifier,
                           const base::DictionaryValue& properties,
                           NetworkActionCallback callback,
                           void* object) {
   ScopedGHashTable ghash(
       ConvertDictionaryValueToStringValueGHashTable(properties));
   chromeos::ConfigureService(identifier, ghash.get(), callback, object);
 }
 
 }  // namespace chromeos