Shill: ShillServiceClient destroys ShillClientHelpers when they are not need.

chromeos/dbus/shill_client_helper.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_client_helper.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "dbus/values_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kInvalidResponseErrorName[] = "";  // No error name.
 const char kInvalidResponseErrorMessage[] = "Invalid response.";
 
 }  // namespace
 
 ShillClientHelper::ShillClientHelper(dbus::Bus* bus,
                                      dbus::ObjectProxy* proxy)
     : blocking_method_caller_(bus, proxy),
       proxy_(proxy),
+      in_progress_calls_(0),
       weak_ptr_factory_(this) {
 }
 
 ShillClientHelper::~ShillClientHelper() {
   LOG_IF(ERROR, observer_list_.size() != 0u)
       << "ShillClientHelper destroyed with active observers: "
       << observer_list_.size();
 }
 
+bool ShillClientHelper::IsObserved() const {
+  return observer_list_.size() > 0;
+}
+
+bool ShillClientHelper::IsWaitingResponse() const {
+  return in_progress_calls_ > 0;
+}
+
 void ShillClientHelper::AddPropertyChangedObserver(
     ShillPropertyChangedObserver* observer) {
+  // Excecutes all the pending MonitorPropertyChanged calls.
+  for (std::vector<std::string>::iterator it = monitored_interfaces_.begin();
+      it != monitored_interfaces_.end(); ++it) {
+    MonitorPropertyChangedInternal(*it);
+  }
+  monitored_interfaces_.clear();
+
   observer_list_.AddObserver(observer);
 }
 
 void ShillClientHelper::RemovePropertyChangedObserver(
     ShillPropertyChangedObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void ShillClientHelper::MonitorPropertyChanged(
     const std::string& interface_name) {
+  if (observer_list_.size() > 0)
+    // Effectively monitor the PropertyChanged now.
+    MonitorPropertyChangedInternal(interface_name);
+  else
+    // Delay the ConnectToSignal until an observer is added.
+    monitored_interfaces_.push_back(interface_name);
+}
+
+void ShillClientHelper::MonitorPropertyChangedInternal(
+    const std::string& interface_name) {
   // We are not using dbus::PropertySet to monitor PropertyChanged signal
   // because the interface is not "org.freedesktop.DBus.Properties".
   proxy_->ConnectToSignal(interface_name,
                           flimflam::kMonitorPropertyChanged,
                           base::Bind(&ShillClientHelper::OnPropertyChanged,
                                      weak_ptr_factory_.GetWeakPtr()),
                           base::Bind(&ShillClientHelper::OnSignalConnected,
                                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ShillClientHelper::CallVoidMethod(
     dbus::MethodCall* method_call,
     const VoidDBusMethodCallback& callback) {
+  ++in_progress_calls_;
   proxy_->CallMethod(method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&ShillClientHelper::OnVoidMethod,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 callback));
 }
 
 void ShillClientHelper::CallObjectPathMethod(
     dbus::MethodCall* method_call,
     const ObjectPathDBusMethodCallback& callback) {
+  ++in_progress_calls_;
   proxy_->CallMethod(method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&ShillClientHelper::OnObjectPathMethod,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 callback));
 }
 
 void ShillClientHelper::CallObjectPathMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback) {
+  ++in_progress_calls_;
   proxy_->CallMethodWithErrorCallback(
       method_call,
       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       base::Bind(&ShillClientHelper::OnObjectPathMethodWithoutStatus,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  error_callback),
       base::Bind(&ShillClientHelper::OnError,
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 void ShillClientHelper::CallDictionaryValueMethod(
     dbus::MethodCall* method_call,
     const DictionaryValueCallback& callback) {
+  ++in_progress_calls_;
   proxy_->CallMethod(method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&ShillClientHelper::OnDictionaryValueMethod,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 callback));
 }
 
 void ShillClientHelper::CallVoidMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
+  ++in_progress_calls_;
   proxy_->CallMethodWithErrorCallback(
       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       base::Bind(&ShillClientHelper::OnVoidMethodWithErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&ShillClientHelper::OnError,
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 void ShillClientHelper::CallDictionaryValueMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     const DictionaryValueCallbackWithoutStatus& callback,
     const ErrorCallback& error_callback) {
+  ++in_progress_calls_;
   proxy_->CallMethodWithErrorCallback(
       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       base::Bind(
           &ShillClientHelper::OnDictionaryValueMethodWithErrorCallback,
           weak_ptr_factory_.GetWeakPtr(),
           callback,
           error_callback),
       base::Bind(&ShillClientHelper::OnError,
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 void ShillClientHelper::CallListValueMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     const ListValueCallback& callback,
     const ErrorCallback& error_callback) {
+  ++in_progress_calls_;
   proxy_->CallMethodWithErrorCallback(
       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
       base::Bind(
           &ShillClientHelper::OnListValueMethodWithErrorCallback,
           weak_ptr_factory_.GetWeakPtr(),
           callback,
           error_callback),
       base::Bind(&ShillClientHelper::OnError,
                  weak_ptr_factory_.GetWeakPtr(),
                  error_callback));
@@ skipping 85 matching lines @@
   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
   if (!value.get())
     return;
 
   FOR_EACH_OBSERVER(ShillPropertyChangedObserver, observer_list_,
                     OnPropertyChanged(name, *value));
 }
 
 void ShillClientHelper::OnVoidMethod(const VoidDBusMethodCallback& callback,
                                      dbus::Response* response) {
+  --in_progress_calls_;
   if (!response) {
     callback.Run(DBUS_METHOD_CALL_FAILURE);
     return;
   }
   callback.Run(DBUS_METHOD_CALL_SUCCESS);
 }
 
 void ShillClientHelper::OnObjectPathMethod(
     const ObjectPathDBusMethodCallback& callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   if (!response) {
     callback.Run(DBUS_METHOD_CALL_FAILURE, dbus::ObjectPath());
     return;
   }
   dbus::MessageReader reader(response);
   dbus::ObjectPath result;
   if (!reader.PopObjectPath(&result)) {
     callback.Run(DBUS_METHOD_CALL_FAILURE, dbus::ObjectPath());
     return;
   }
   callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
 }
 
 void ShillClientHelper::OnObjectPathMethodWithoutStatus(
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   if (!response) {
     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     return;
   }
   dbus::MessageReader reader(response);
   dbus::ObjectPath result;
   if (!reader.PopObjectPath(&result)) {
     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     return;
   }
   callback.Run(result);
 }
 
 void ShillClientHelper::OnDictionaryValueMethod(
     const DictionaryValueCallback& callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   if (!response) {
     base::DictionaryValue result;
     callback.Run(DBUS_METHOD_CALL_FAILURE, result);
     return;
   }
   dbus::MessageReader reader(response);
   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
   base::DictionaryValue* result = NULL;
   if (!value.get() || !value->GetAsDictionary(&result)) {
     base::DictionaryValue result;
     callback.Run(DBUS_METHOD_CALL_FAILURE, result);
     return;
   }
   callback.Run(DBUS_METHOD_CALL_SUCCESS, *result);
 }
 
 void ShillClientHelper::OnVoidMethodWithErrorCallback(
     const base::Closure& callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   callback.Run();
 }
 
 void ShillClientHelper::OnDictionaryValueMethodWithErrorCallback(
     const DictionaryValueCallbackWithoutStatus& callback,
     const ErrorCallback& error_callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   dbus::MessageReader reader(response);
   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
   base::DictionaryValue* result = NULL;
   if (!value.get() || !value->GetAsDictionary(&result)) {
     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     return;
   }
   callback.Run(*result);
 }
 
 void ShillClientHelper::OnListValueMethodWithErrorCallback(
     const ListValueCallback& callback,
     const ErrorCallback& error_callback,
     dbus::Response* response) {
+  --in_progress_calls_;
   dbus::MessageReader reader(response);
   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
   base::ListValue* result = NULL;
   if (!value.get() || !value->GetAsList(&result)) {
     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     return;
   }
   callback.Run(*result);
 }
 
 void ShillClientHelper::OnError(const ErrorCallback& error_callback,
                                 dbus::ErrorResponse* response) {
+  --in_progress_calls_;
   std::string error_name;
   std::string error_message;
   if (response) {
     // Error message may contain the error message as string.
     dbus::MessageReader reader(response);
     error_name = response->GetErrorName();
     reader.PopString(&error_message);
   }
   error_callback.Run(error_name, error_message);
 }
 
 }  // namespace chromeos