Reimplement RequestNetworkServiceConnect, RequestRequirePin, RequestEnterPin, RequestEnterPin, Requ…

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"
@@ skipping 216 matching lines @@
 void OnConfigureService(void* object,
                         const char* service_path,
                         NetworkMethodErrorType error,
                         const char* error_message) {
   if (error != NETWORK_METHOD_ERROR_NONE) {
     LOG(WARNING) << "Error from ConfigureService callback: "
                  << " Error: " << error << " Message: " << error_message;
   }
 }
 
+// A callback used to call a NetworkActionCallback on success.
+void OnNetworkActionSuccess(const std::string& path,
+                            NetworkActionCallback callback,
+                            void* object) {
+  callback(object, path.c_str(), NETWORK_METHOD_ERROR_NONE, "");
+}
+
+// A callback used to call a NetworkActionCallback on error.
+void OnNetworkActionError(const std::string& path,
+                          NetworkActionCallback callback,
+                          void* object,
+                          const std::string& error_name,
+                          const std::string& error_message) {
+  if (error_name.empty()) {
+    callback(object, path.c_str(), NETWORK_METHOD_ERROR_LOCAL, "");
+  } else {
+    callback(object, path.c_str(), NETWORK_METHOD_ERROR_REMOTE,
+             error_message.c_str());
+  }
+}
+
 // Safe string constructor since we can't rely on non NULL pointers
 // for string values from libcros.
 std::string SafeString(const char* s) {
   return s ? std::string(s) : std::string();
 }
 
 // A bool to remember whether we are using Libcros network functions or not.
 bool g_libcros_network_functions_enabled = true;
 
 }  // namespace
@@ skipping 133 matching lines @@
 
 CrosNetworkWatcher* CrosMonitorSMS(const std::string& modem_device_path,
                                    MonitorSMSCallback callback,
                                    void* object) {
   return new CrosSMSWatcher(modem_device_path, callback, object);
 }
 
 void CrosRequestNetworkServiceConnect(const std::string& service_path,
                                       NetworkActionCallback callback,
                                       void* object) {
-  chromeos::RequestNetworkServiceConnect(service_path.c_str(), callback,
-                                         object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestNetworkServiceConnect(service_path.c_str(), callback,
+                                           object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamServiceClient()->Connect(
+        dbus::ObjectPath(service_path),
+        base::Bind(&OnNetworkActionSuccess, service_path, callback, object),
+        base::Bind(&OnNetworkActionError, service_path, callback, object));
+  }
 }
 
 void CrosRequestNetworkManagerProperties(
     const NetworkPropertiesCallback& callback) {
   if (g_libcros_network_functions_enabled) {
     // The newly allocated callback will be deleted in
     // OnRequestNetworkProperties.
     chromeos::RequestNetworkManagerProperties(
         &OnRequestNetworkProperties,
         new OnRequestNetworkPropertiesCallback(callback));
@@ skipping 193 matching lines @@
           network_type, base::Bind(&DoNothing));
     }
   }
 }
 
 void CrosRequestRequirePin(const std::string& device_path,
                            const std::string& pin,
                            bool enable,
                            NetworkActionCallback callback,
                            void* object) {
-  chromeos::RequestRequirePin(device_path.c_str(), pin.c_str(), enable,
-                              callback, object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestRequirePin(device_path.c_str(), pin.c_str(), enable,
+                                callback, object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamDeviceClient()->RequirePin(
+        dbus::ObjectPath(device_path), pin, enable,
+        base::Bind(&OnNetworkActionSuccess, device_path, callback, object),
+        base::Bind(&OnNetworkActionError, device_path, callback, object));
+  }
 }
 
 void CrosRequestEnterPin(const std::string& device_path,
                          const std::string& pin,
                          NetworkActionCallback callback,
                          void* object) {
-  chromeos::RequestEnterPin(device_path.c_str(), pin.c_str(), callback, object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestEnterPin(device_path.c_str(), pin.c_str(), callback,
+                              object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamDeviceClient()->EnterPin(
+        dbus::ObjectPath(device_path), pin,
+        base::Bind(&OnNetworkActionSuccess, device_path, callback, object),
+        base::Bind(&OnNetworkActionError, device_path, callback, object));
+  }
 }
 
 void CrosRequestUnblockPin(const std::string& device_path,
                            const std::string& unblock_code,
                            const std::string& pin,
                            NetworkActionCallback callback,
                            void* object) {
-  chromeos::RequestUnblockPin(device_path.c_str(), unblock_code.c_str(),
-                              pin.c_str(), callback, object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestUnblockPin(device_path.c_str(), unblock_code.c_str(),
+                                pin.c_str(), callback, object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamDeviceClient()->UnblockPin(
+        dbus::ObjectPath(device_path), unblock_code, pin,
+        base::Bind(&OnNetworkActionSuccess, device_path, callback, object),
+        base::Bind(&OnNetworkActionError, device_path, callback, object));
+  }
 }
 
 void CrosRequestChangePin(const std::string& device_path,
                           const std::string& old_pin,
                           const std::string& new_pin,
                           NetworkActionCallback callback,
                           void* object) {
-  chromeos::RequestChangePin(device_path.c_str(), old_pin.c_str(),
-                             new_pin.c_str(), callback, object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestChangePin(device_path.c_str(), old_pin.c_str(),
+                               new_pin.c_str(), callback, object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamDeviceClient()->ChangePin(
+        dbus::ObjectPath(device_path), old_pin, new_pin,
+        base::Bind(&OnNetworkActionSuccess, device_path, callback, object),
+        base::Bind(&OnNetworkActionError, device_path, callback, object));
+  }
 }
 
 void CrosProposeScan(const std::string& device_path) {
   if (g_libcros_network_functions_enabled) {
     chromeos::ProposeScan(device_path.c_str());
   } else {
     DBusThreadManager::Get()->GetFlimflamDeviceClient()->ProposeScan(
         dbus::ObjectPath(device_path), base::Bind(&DoNothing));
   }
 }
 
 void CrosRequestCellularRegister(const std::string& device_path,
                                  const std::string& network_id,
                                  chromeos::NetworkActionCallback callback,
                                  void* object) {
-  chromeos::RequestCellularRegister(device_path.c_str(), network_id.c_str(),
-                                    callback, object);
+  if (g_libcros_network_functions_enabled) {
+    chromeos::RequestCellularRegister(device_path.c_str(), network_id.c_str(),
+                                      callback, object);
+  } else {
+    DBusThreadManager::Get()->GetFlimflamDeviceClient()->Register(
+        dbus::ObjectPath(device_path), network_id,
+        base::Bind(&OnNetworkActionSuccess, device_path, callback, object),
+        base::Bind(&OnNetworkActionError, device_path, callback, object));
+  }
 }
 
 bool CrosSetOfflineMode(bool offline) {
   return chromeos::SetOfflineMode(offline);
 }
 
 IPConfigStatus* CrosListIPConfigs(const std::string& device_path) {
   return chromeos::ListIPConfigs(device_path.c_str());
 }
 
@@ skipping 79 matching lines @@
     ScopedGHashTable ghash(
         ConvertDictionaryValueToStringValueGHashTable(properties));
     chromeos::ConfigureService("", ghash.get(), OnConfigureService, NULL);
   } else {
     DBusThreadManager::Get()->GetFlimflamManagerClient()->ConfigureService(
         properties, base::Bind(&DoNothing));
   }
 }
 
 }  // namespace chromeos