Track active references in ShillClientHelper (Take 2)

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"
@@ skipping 23 matching lines @@
 class Response;
 class Signal;
 
 }  // namespace dbus
 
 namespace chromeos {
 
 // A class to help implement Shill clients.
 class ShillClientHelper {
  public:
+  class RefHolder;
+
   // 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 results.
   // This is used by CallDictionaryValueMethodWithErrorCallback.
   typedef base::Callback<void(const base::DictionaryValue& result)>
       DictionaryValueCallbackWithoutStatus;
 
   // A callback to handle responses of methods returning a ListValue.
   typedef base::Callback<void(const base::ListValue& result)> ListValueCallback;
 
   // A callback to handle errors for method call.
   typedef base::Callback<void(const std::string& error_name,
                               const std::string& error_message)> ErrorCallback;
 
   // A callback that handles responses for methods with string results.
   typedef base::Callback<void(const std::string& result)> StringCallback;
 
   // A callback that handles responses for methods with boolean results.
   typedef base::Callback<void(bool result)> BooleanCallback;
 
+  // Callback used to notify owner when this can be safely released.
+  typedef base::Callback<void(ShillClientHelper* helper)> ReleasedCallback;
 
-  ShillClientHelper(dbus::Bus* bus, dbus::ObjectProxy* proxy);
+  explicit ShillClientHelper(dbus::ObjectProxy* proxy);
 
   virtual ~ShillClientHelper();
 
+  // Sets |released_callback_|. This is optional and should only be called at
+  // most once.
+  void SetReleasedCallback(ReleasedCallback callback);
+
   // Adds an |observer| of the PropertyChanged signal.
   void AddPropertyChangedObserver(ShillPropertyChangedObserver* observer);
 
   // Removes an |observer| of the PropertyChanged signal.
   void RemovePropertyChangedObserver(ShillPropertyChangedObserver* observer);
 
   // Starts monitoring PropertyChanged signal. If there aren't observers for the
   // PropertyChanged signal, the actual monitoring will be delayed until the
   // first observer is added.
   void MonitorPropertyChanged(const std::string& interface_name);
@@ skipping 38 matching lines @@
       dbus::MethodCall* method_call,
       const DictionaryValueCallbackWithoutStatus& callback,
       const ErrorCallback& error_callback);
 
   // Calls a method with a boolean array result with error callback.
   void CallListValueMethodWithErrorCallback(
       dbus::MethodCall* method_call,
       const ListValueCallback& callback,
       const ErrorCallback& error_callback);
 
+  const dbus::ObjectProxy* object_proxy() const { return proxy_; }
+
   // Appends the value (basic types and string-to-string dictionary) to the
   // writer as a variant.
   static void AppendValueDataAsVariant(dbus::MessageWriter* writer,
                                        const base::Value& value);
 
   // Appends a string-to-variant dictionary to the writer.
   static void AppendServicePropertiesDictionary(
       dbus::MessageWriter* writer,
       const base::DictionaryValue& dictionary);
 
+ protected:
+  // Reference / Ownership management. If the number of active refs (observers
+  // + in-progress method calls) becomes 0, |released_callback_| (if set) will
+  // be called.
+  void AddRef();
+  void Release();
+
  private:
   // Starts monitoring PropertyChanged signal.
   void MonitorPropertyChangedInternal(const std::string& interface_name);
 
   // Handles the result of signal connection setup.
   void OnSignalConnected(const std::string& interface,
                          const std::string& signal,
                          bool success);
 
   // Handles PropertyChanged signal.
   void OnPropertyChanged(dbus::Signal* signal);
 
   dbus::ObjectProxy* proxy_;
+  ReleasedCallback released_callback_;
+  int active_refs_;
   PropertyChangedHandler property_changed_handler_;
   ObserverList<ShillPropertyChangedObserver, true /* check_empty */>
       observer_list_;
   std::vector<std::string> interfaces_to_be_monitored_;
 
   // 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_