This converts the Shill clients to allow propagation of shill errors

chromeos/dbus/shill_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_SHILL_CLIENT_HELPER_H_
 #define CHROMEOS_DBUS_SHILL_CLIENT_HELPER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 
 namespace base {
 
 class Value;
 class DictionaryValue;
 
 }  // namespace base
 
@@ skipping 17 matching lines @@
  public:
   // A callback to handle PropertyChanged signals.
   typedef base::Callback<void(const std::string& name,
                               const base::Value& value)> PropertyChangedHandler;
 
   // 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 responses for methods with DictionaryValue reuslts.
+  // A callback to handle responses for methods with DictionaryValue results.
   // This is used by CallDictionaryValueMethodWithErrorCallback.
   typedef base::Callback<void(const base::DictionaryValue& result
                               )> DictionaryValueCallbackWithoutStatus;
 
-  // A callback to handle erros for method call.
+  // A callback to handle errors for method call.
   typedef base::Callback<void(const std::string& error_name,
                               const std::string& error_message)> ErrorCallback;
 
+  class PropertyChangedObserver {

[hashimoto, 2012/09/21 11:52:01]

Please add class comment, especially about the event in which this observer is
interested.

[Greg Spencer (Chromium), 2012/09/21 22:03:47]

Done.

+   public:
+    virtual void OnPropertyChanged(const std::string& name,
+                                   const base::Value& value) = 0;
+  };
+
   ShillClientHelper(dbus::Bus* bus, dbus::ObjectProxy* proxy);
 
   virtual ~ShillClientHelper();
 
-  // Sets PropertyChanged signal handler.
-  void SetPropertyChangedHandler(const PropertyChangedHandler& handler);
-
-  // Resets PropertyChanged signal handler.
-  void ResetPropertyChangedHandler();
+  void AddPropertyChangedObserver(PropertyChangedObserver* observer);

[hashimoto, 2012/09/21 11:52:01]

Please add method comments.

[Greg Spencer (Chromium), 2012/09/21 22:03:47]

Done.

+  void RemovePropertyChangedObserver(PropertyChangedObserver* observer);
 
   // Starts monitoring PropertyChanged signal.
   void MonitorPropertyChanged(const std::string& interface_name);
 
   // Calls a method without results.
   void CallVoidMethod(dbus::MethodCall* method_call,
                       const VoidDBusMethodCallback& callback);
 
   // Calls a method with an object path result.
   void CallObjectPathMethod(dbus::MethodCall* method_call,
                             const ObjectPathDBusMethodCallback& callback);
 
+  // Calls a method with an object path result where there is an error callback.
+  void CallObjectPathMethodWithErrorCallback(
+      dbus::MethodCall* method_call,
+      const ObjectPathDBusMethodCallback& callback,

[hashimoto, 2012/09/21 11:52:01]

Can we introduce something like DictionaryValueCallbackWithoutStatus for
ObjectPath? (say, ObjectPathCallbackWithoutStatus)

[Greg Spencer (Chromium), 2012/09/21 22:03:47]

Done.

+      const ErrorCallback& error_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);
 
   // Calls a method with a dictionary value result with error callback.
@@ skipping 53 matching lines @@
       dbus::Response* response);
 
   // Handles errors for method calls.
   void OnError(const ErrorCallback& error_callback,
                dbus::ErrorResponse* response);
 
   // TODO(hashimoto): Remove this when we no longer need to make blocking calls.
   BlockingMethodCaller blocking_method_caller_;
   dbus::ObjectProxy* proxy_;
   PropertyChangedHandler property_changed_handler_;
+  ObserverList<PropertyChangedObserver> observer_list_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<ShillClientHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillClientHelper);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_SHILL_CLIENT_HELPER_H_