Rework chromeos::FlimflamDevice/ServiceClient with CallMethodWithErrorCallback

chromeos/dbus/flimflam_client_helper.h

 // 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.
 
 #ifndef CHROMEOS_DBUS_FLIMFLAM_CLIENT_HELPER_H_
 #define CHROMEOS_DBUS_FLIMFLAM_CLIENT_HELPER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 
 namespace base {
 
 class Value;
 class DictionaryValue;
 
 }  // namespace base
 
 namespace dbus {
 
 class Bus;
+class ErrorResponse;
 class MessageWriter;
 class MethodCall;
 class ObjectPath;
 class ObjectProxy;
 class Response;
 class Signal;
 
 }  // namespace dbus
 
 namespace chromeos {
@@ skipping 11 matching lines @@
   // A callback to handle responses for methods with ObjectPath results.
   typedef base::Callback<void(
       DBusMethodCallStatus call_status,
       const dbus::ObjectPath& result)> ObjectPathCallback;
 
   // A callback to handle responses for methods with DictionaryValue results.
   typedef base::Callback<void(
       DBusMethodCallStatus call_status,
       const base::DictionaryValue& result)> DictionaryValueCallback;
 
+  // A callback to handle erros for method call.
+  typedef base::Callback<void(const std::string& error_name,
+                              const std::string& error_message)> ErrorCallback;
+
   FlimflamClientHelper(dbus::Bus* bus, dbus::ObjectProxy* proxy);
 
   virtual ~FlimflamClientHelper();
 
   // Sets PropertyChanged signal handler.
   void SetPropertyChangedHandler(const PropertyChangedHandler& handler);
 
   // Resets PropertyChanged signal handler.
   void ResetPropertyChangedHandler();
 
   // Starts monitoring PropertyChanged signal.
   void MonitorPropertyChanged(const std::string& interface_name);
 
   // Calls a method without results.
   void CallVoidMethod(dbus::MethodCall* method_call,
                       const VoidCallback& callback);
 
   // Calls a method with an object path result.
   void CallObjectPathMethod(dbus::MethodCall* method_call,
                             const ObjectPathCallback& callback);
 
   // Calls a method with a dictionary value result.
   void CallDictionaryValueMethod(dbus::MethodCall* method_call,
                                  const DictionaryValueCallback& callback);
 
+  // Calls a method without results with error callback.
+  void CallVoidMethodWithErrorCallback(dbus::MethodCall* method_call,
+                                       const base::Closure& callback,
+                                       const ErrorCallback& error_callback);
+
   // DEPRECATED DO NOT USE: Calls a method without results.
   bool CallVoidMethodAndBlock(dbus::MethodCall* method_call);
 
   // DEPRECATED DO NOT USE: Calls a method with an object path result.
   dbus::ObjectPath CallObjectPathMethodAndBlock(dbus::MethodCall* method_call);
 
   // DEPRECATED DO NOT USE: Calls a method with a dictionary value result.
   // The caller is responsible to delete the result.
   // This method returns NULL when method call fails.
   base::DictionaryValue* CallDictionaryValueMethodAndBlock(
@@ skipping 17 matching lines @@
   void OnVoidMethod(const VoidCallback& callback, dbus::Response* response);
 
   // Handles responses for methods with ObjectPath results.
   void OnObjectPathMethod(const ObjectPathCallback& callback,
                           dbus::Response* response);
 
   // Handles responses for methods with DictionaryValue results.
   void OnDictionaryValueMethod(const DictionaryValueCallback& callback,
                                dbus::Response* response);
 
+  // Handles responses for methods without results.
+  // Used by CallVoidMethodWithErrorCallback().
+  void OnVoidMethodWithErrorCallback(const base::Closure& callback,
+                                     dbus::Response* response);
+
+  // Handles errors for method calls.
+  void OnError(const ErrorCallback& error_callback,
+               dbus::ErrorResponse* response);
+
   base::WeakPtrFactory<FlimflamClientHelper> weak_ptr_factory_;
   // TODO(hashimoto): Remove this when we no longer need to make blocking calls.
   BlockingMethodCaller blocking_method_caller_;
   dbus::ObjectProxy* proxy_;
   PropertyChangedHandler property_changed_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(FlimflamClientHelper);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_FLIMFLAM_CLIENT_HELPER_H_