This converts the Shill clients to allow propagation of shill errors

chromeos/dbus/shill_manager_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/shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 39 matching lines @@
 class ShillManagerClientImpl : public ShillManagerClient {
  public:
   explicit ShillManagerClientImpl(dbus::Bus* bus)
       : proxy_(bus->GetObjectProxy(
           flimflam::kFlimflamServiceName,
           dbus::ObjectPath(flimflam::kFlimflamServicePath))),
         helper_(bus, proxy_) {
     helper_.MonitorPropertyChanged(flimflam::kFlimflamManagerInterface);
   }
 
-  // ShillManagerClient overrides:
-  virtual void SetPropertyChangedHandler(
-      const PropertyChangedHandler& handler) OVERRIDE {
-    helper_.SetPropertyChangedHandler(handler);
+  ////////////////////////////////////
+  // ShillManagerClient overrides.
+  virtual void AddPropertyChangedObserver(
+      PropertyChangedObserver* observer) OVERRIDE {
+    helper_.AddPropertyChangedObserver(observer);
   }
 
-  virtual void ResetPropertyChangedHandler() OVERRIDE {
-    helper_.ResetPropertyChangedHandler();
+  virtual void RemovePropertyChangedObserver(
+      PropertyChangedObserver* observer) OVERRIDE {
+    helper_.RemovePropertyChangedObserver(observer);
   }
 
   virtual void GetProperties(const DictionaryValueCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kGetPropertiesFunction);
     helper_.CallDictionaryValueMethod(&method_call, callback);
   }
 
   virtual base::DictionaryValue* CallGetPropertiesAndBlock() OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kGetPropertiesFunction);
     return helper_.CallDictionaryValueMethodAndBlock(&method_call);
   }
 
   virtual void SetProperty(const std::string& name,
                            const base::Value& value,
-                           const VoidDBusMethodCallback& callback) OVERRIDE {
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kSetPropertyFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     ShillClientHelper::AppendValueDataAsVariant(&writer, value);
-    helper_.CallVoidMethod(&method_call, callback);
+    helper_.CallVoidMethodWithErrorCallback(&method_call,
+                                            callback,
+                                            error_callback);
   }
 
   virtual void RequestScan(const std::string& type,
-                           const VoidDBusMethodCallback& callback) OVERRIDE {
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kRequestScanFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(type);
-    helper_.CallVoidMethod(&method_call, callback);
+    helper_.CallVoidMethodWithErrorCallback(&method_call,
+                                            callback,
+                                            error_callback);
   }
 
   virtual void EnableTechnology(
       const std::string& type,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kEnableTechnologyFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(type);
-    helper_.CallVoidMethod(&method_call, callback);
+    helper_.CallVoidMethodWithErrorCallback(&method_call,
+                                            callback,
+                                            error_callback);
   }
 
   virtual void DisableTechnology(
       const std::string& type,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kDisableTechnologyFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(type);
-    helper_.CallVoidMethod(&method_call, callback);
+    helper_.CallVoidMethodWithErrorCallback(&method_call,
+                                            callback,
+                                            error_callback);
   }
 
   virtual void ConfigureService(
       const base::DictionaryValue& properties,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
     DCHECK(AreServicePropertiesValid(properties));
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kConfigureServiceFunction);
     dbus::MessageWriter writer(&method_call);
     AppendServicePropertiesDictionary(&writer, properties);
-    helper_.CallVoidMethod(&method_call, callback);
+    helper_.CallVoidMethodWithErrorCallback(&method_call,
+                                            callback,
+                                            error_callback);
   }
 
   virtual void GetService(
       const base::DictionaryValue& properties,
-      const ObjectPathDBusMethodCallback& callback) OVERRIDE {
+      const ObjectPathDBusMethodCallback& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamManagerInterface,
                                  flimflam::kGetServiceFunction);
     dbus::MessageWriter writer(&method_call);
     AppendServicePropertiesDictionary(&writer, properties);
-    helper_.CallObjectPathMethod(&method_call, callback);
+    helper_.CallObjectPathMethodWithErrorCallback(&method_call,
+                                                  callback,
+                                                  error_callback);
   }
 
  private:
   dbus::ObjectProxy* proxy_;
   ShillClientHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillManagerClientImpl);
 };
 
 // A stub implementation of ShillManagerClient.
 // Implemented: Stub cellular DeviceList entry for SMS testing.
 class ShillManagerClientStubImpl : public ShillManagerClient {
  public:
   ShillManagerClientStubImpl() : weak_ptr_factory_(this) {
     base::ListValue* device_list = new base::ListValue;
     // Note: names match Device stub map.
     const char kStubCellular1[] = "stub_cellular1";
     const char kStubCellular2[] = "stub_cellular2";
     device_list->Append(base::Value::CreateStringValue(kStubCellular1));
     device_list->Append(base::Value::CreateStringValue(kStubCellular2));
     stub_properties_.Set(flimflam::kDevicesProperty, device_list);
   }
 
   virtual ~ShillManagerClientStubImpl() {}
 
-  // ShillManagerClient override.
-  virtual void SetPropertyChangedHandler(
-      const PropertyChangedHandler& handler) OVERRIDE {}
+  //////////////////////////////////
+  // ShillManagerClient overrides.
+  virtual void AddPropertyChangedObserver(
+      PropertyChangedObserver* observer) OVERRIDE {}
 
-  // ShillManagerClient override.
-  virtual void ResetPropertyChangedHandler() OVERRIDE {}
+  virtual void RemovePropertyChangedObserver(
+      PropertyChangedObserver* observer) OVERRIDE {}
 
   // ShillManagerClient override.
   virtual void GetProperties(const DictionaryValueCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(
             &ShillManagerClientStubImpl::PassStubProperties,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // ShillManagerClient override.
   virtual base::DictionaryValue* CallGetPropertiesAndBlock() OVERRIDE {
     return new base::DictionaryValue;
   }
 
   // ShillManagerClient override.
   virtual void SetProperty(const std::string& name,
                            const base::Value& value,
-                           const VoidDBusMethodCallback& callback) OVERRIDE {
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) OVERRIDE {
     stub_properties_.Set(name, value.DeepCopy());
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback,
-                                                DBUS_METHOD_CALL_SUCCESS));
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // ShillManagerClient override.
   virtual void RequestScan(const std::string& type,
-                           const VoidDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback,
-                                                DBUS_METHOD_CALL_SUCCESS));
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // ShillManagerClient override.
   virtual void EnableTechnology(
       const std::string& type,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback,
-                                                DBUS_METHOD_CALL_SUCCESS));
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // ShillManagerClient override.
   virtual void DisableTechnology(
       const std::string& type,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback,
-                                                DBUS_METHOD_CALL_SUCCESS));
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // ShillManagerClient override.
   virtual void ConfigureService(
       const base::DictionaryValue& properties,
-      const VoidDBusMethodCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback,
-                                                DBUS_METHOD_CALL_SUCCESS));
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   // ShillManagerClient override.
   virtual void GetService(
       const base::DictionaryValue& properties,
-      const ObjectPathDBusMethodCallback& callback) OVERRIDE {
+      const ObjectPathDBusMethodCallback& callback,
+      const ErrorCallback& error_callback) OVERRIDE {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      base::Bind(callback,
                                                 DBUS_METHOD_CALL_SUCCESS,
                                                 dbus::ObjectPath()));
   }
 
  private:
   void PassStubProperties(const DictionaryValueCallback& callback) const {
     callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_properties_);
   }
@@ skipping 17 matching lines @@
 ShillManagerClient* ShillManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new ShillManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new ShillManagerClientStubImpl();
 }
 
 }  // namespace chromeos