Rework chromeos::FlimflamDevice/ServiceClient with CallMethodWithErrorCallback

chromeos/dbus/flimflam_device_client.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 "chromeos/dbus/flimflam_device_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 97 matching lines @@
                                  flimflam::kAddIPConfigFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(method);
     return GetHelper(device_path)->CallObjectPathMethodAndBlock(&method_call);
   }
 
   // FlimflamProfileClient override.
   virtual void RequirePin(const dbus::ObjectPath& device_path,
                           const std::string& pin,
                           bool require,
-                          const VoidCallback& callback) OVERRIDE  {
+                          const base::Closure& callback,
+                          const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  flimflam::kRequirePinFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(pin);
     writer.AppendBool(require);
-    GetHelper(device_path)->CallVoidMethod(&method_call, callback);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(
+        &method_call, callback, error_callback);
   }
 
   // FlimflamProfileClient override.
   virtual void EnterPin(const dbus::ObjectPath& device_path,
                         const std::string& pin,
-                        const VoidCallback& callback) OVERRIDE {
+                        const base::Closure& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  flimflam::kEnterPinFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(pin);
-    GetHelper(device_path)->CallVoidMethod(&method_call, callback);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(
+        &method_call, callback, error_callback);
   }
 
   // FlimflamProfileClient override.
   virtual void UnblockPin(const dbus::ObjectPath& device_path,
                           const std::string& puk,
                           const std::string& pin,
-                          const VoidCallback& callback) OVERRIDE {
+                          const base::Closure& callback,
+                          const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  flimflam::kUnblockPinFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(puk);
     writer.AppendString(pin);
-    GetHelper(device_path)->CallVoidMethod(&method_call, callback);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(
+        &method_call, callback, error_callback);
   }
 
   // FlimflamProfileClient override.
   virtual void ChangePin(const dbus::ObjectPath& device_path,
                          const std::string& old_pin,
                          const std::string& new_pin,
-                         const VoidCallback& callback) OVERRIDE {
+                         const base::Closure& callback,
+                         const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  flimflam::kChangePinFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(old_pin);
     writer.AppendString(new_pin);
-    GetHelper(device_path)->CallVoidMethod(&method_call, callback);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(
+        &method_call, callback, error_callback);
   }
 
   // FlimflamProfileClient override.
   virtual void Register(const dbus::ObjectPath& device_path,
                         const std::string& network_id,
-                        const VoidCallback& callback) OVERRIDE {
+                        const base::Closure& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  flimflam::kRegisterFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(network_id);
-    GetHelper(device_path)->CallVoidMethod(&method_call, callback);
+    GetHelper(device_path)->CallVoidMethodWithErrorCallback(
+        &method_call, callback, error_callback);
   }
 
  private:
   typedef std::map<std::string, FlimflamClientHelper*> HelperMap;
 
   // Returns the corresponding FlimflamClientHelper for the profile.
   FlimflamClientHelper* GetHelper(const dbus::ObjectPath& device_path) {
     HelperMap::iterator it = helpers_.find(device_path.value());
     if (it != helpers_.end())
       return it->second;
@@ skipping 81 matching lines @@
   virtual dbus::ObjectPath CallAddIPConfigAndBlock(
       const dbus::ObjectPath& device_path,
       const std::string& method) OVERRIDE {
     return dbus::ObjectPath();
   }
 
   // FlimflamDeviceClient override.
   virtual void RequirePin(const dbus::ObjectPath& device_path,
                           const std::string& pin,
                           bool require,
-                          const VoidCallback& callback) OVERRIDE {
-    PostSuccessVoidCallback(callback);
+                          const base::Closure& callback,
+                          const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // FlimflamDeviceClient override.
   virtual void EnterPin(const dbus::ObjectPath& device_path,
                         const std::string& pin,
-                        const VoidCallback& callback) OVERRIDE {
-    PostSuccessVoidCallback(callback);
+                        const base::Closure& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // FlimflamDeviceClient override.
   virtual void UnblockPin(const dbus::ObjectPath& device_path,
                           const std::string& puk,
                           const std::string& pin,
-                          const VoidCallback& callback) OVERRIDE {
-    PostSuccessVoidCallback(callback);
+                          const base::Closure& callback,
+                          const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // FlimflamDeviceClient override.
   virtual void ChangePin(const dbus::ObjectPath& device_path,
                          const std::string& old_pin,
                          const std::string& new_pin,
-                         const VoidCallback& callback) OVERRIDE {
-    PostSuccessVoidCallback(callback);
+                         const base::Closure& callback,
+                         const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // FlimflamDeviceClient override.
   virtual void Register(const dbus::ObjectPath& device_path,
                         const std::string& network_id,
-                        const VoidCallback& callback) OVERRIDE {
-    PostSuccessVoidCallback(callback);
+                        const base::Closure& callback,
+                        const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
  private:
   void PassEmptyDictionaryValue(const DictionaryValueCallback& callback) const {
     base::DictionaryValue dictionary;
     callback.Run(DBUS_METHOD_CALL_SUCCESS, dictionary);
   }
 
   // Posts a task to run a void callback with success status code.
   void PostSuccessVoidCallback(const VoidCallback& callback) {
@@ skipping 17 matching lines @@
 FlimflamDeviceClient* FlimflamDeviceClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new FlimflamDeviceClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new FlimflamDeviceClientStubImpl();
 }
 
 }  // namespace chromeos