Home | History | Annotate | Download | only in dbus 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/dbus/shill_client_helper.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback_helpers.h"
      9 #include "base/values.h"
     10 #include "dbus/message.h"
     11 #include "dbus/object_proxy.h"
     12 #include "dbus/values_util.h"
     13 #include "third_party/cros_system_api/dbus/service_constants.h"
     14 
     15 namespace chromeos {
     16 
     17 // Class to hold onto a reference to a ShillClientHelper. This calss
     18 // is owned by callbacks and released once the callback completes.
     19 // Note: Only success callbacks hold the reference. If an error callback is
     20 // invoked instead, the success callback will still be destroyed and the
     21 // RefHolder with it, once the callback chain completes.
     22 class ShillClientHelper::RefHolder {
     23  public:
     24   explicit RefHolder(base::WeakPtr<ShillClientHelper> helper)
     25       : helper_(helper) {
     26     helper_->AddRef();
     27   }
     28   ~RefHolder() {
     29     if (helper_)
     30       helper_->Release();
     31   }
     32 
     33  private:
     34   base::WeakPtr<ShillClientHelper> helper_;
     35 };
     36 
     37 namespace {
     38 
     39 const char kInvalidResponseErrorName[] = "";  // No error name.
     40 const char kInvalidResponseErrorMessage[] = "Invalid response.";
     41 
     42 // Note: here and below, |ref_holder| is unused in the function body. It only
     43 // exists so that it will be destroyed (and the reference released) with the
     44 // Callback object once completed.
     45 void OnBooleanMethodWithErrorCallback(
     46     ShillClientHelper::RefHolder* ref_holder,
     47     const ShillClientHelper::BooleanCallback& callback,
     48     const ShillClientHelper::ErrorCallback& error_callback,
     49     dbus::Response* response) {
     50   if (!response) {
     51     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     52     return;
     53   }
     54   dbus::MessageReader reader(response);
     55   bool result;
     56   if (!reader.PopBool(&result)) {
     57     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     58     return;
     59   }
     60   callback.Run(result);
     61 }
     62 
     63 void OnStringMethodWithErrorCallback(
     64     ShillClientHelper::RefHolder* ref_holder,
     65     const ShillClientHelper::StringCallback& callback,
     66     const ShillClientHelper::ErrorCallback& error_callback,
     67     dbus::Response* response) {
     68   if (!response) {
     69     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     70     return;
     71   }
     72   dbus::MessageReader reader(response);
     73   std::string result;
     74   if (!reader.PopString(&result)) {
     75     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
     76     return;
     77   }
     78   callback.Run(result);
     79 }
     80 
     81 // Handles responses for methods without results.
     82 void OnVoidMethod(ShillClientHelper::RefHolder* ref_holder,
     83                   const VoidDBusMethodCallback& callback,
     84                   dbus::Response* response) {
     85   if (!response) {
     86     callback.Run(DBUS_METHOD_CALL_FAILURE);
     87     return;
     88   }
     89   callback.Run(DBUS_METHOD_CALL_SUCCESS);
     90 }
     91 
     92 // Handles responses for methods with ObjectPath results.
     93 void OnObjectPathMethod(
     94     ShillClientHelper::RefHolder* ref_holder,
     95     const ObjectPathDBusMethodCallback& callback,
     96     dbus::Response* response) {
     97   if (!response) {
     98     callback.Run(DBUS_METHOD_CALL_FAILURE, dbus::ObjectPath());
     99     return;
    100   }
    101   dbus::MessageReader reader(response);
    102   dbus::ObjectPath result;
    103   if (!reader.PopObjectPath(&result)) {
    104     callback.Run(DBUS_METHOD_CALL_FAILURE, dbus::ObjectPath());
    105     return;
    106   }
    107   callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
    108 }
    109 
    110 // Handles responses for methods with ObjectPath results and no status.
    111 void OnObjectPathMethodWithoutStatus(
    112     ShillClientHelper::RefHolder* ref_holder,
    113     const ObjectPathCallback& callback,
    114     const ShillClientHelper::ErrorCallback& error_callback,
    115     dbus::Response* response) {
    116   if (!response) {
    117     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
    118     return;
    119   }
    120   dbus::MessageReader reader(response);
    121   dbus::ObjectPath result;
    122   if (!reader.PopObjectPath(&result)) {
    123     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
    124     return;
    125   }
    126   callback.Run(result);
    127 }
    128 
    129 // Handles responses for methods with DictionaryValue results.
    130 void OnDictionaryValueMethod(
    131     ShillClientHelper::RefHolder* ref_holder,
    132     const ShillClientHelper::DictionaryValueCallback& callback,
    133     dbus::Response* response) {
    134   if (!response) {
    135     base::DictionaryValue result;
    136     callback.Run(DBUS_METHOD_CALL_FAILURE, result);
    137     return;
    138   }
    139   dbus::MessageReader reader(response);
    140   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
    141   base::DictionaryValue* result = NULL;
    142   if (!value.get() || !value->GetAsDictionary(&result)) {
    143     base::DictionaryValue result;
    144     callback.Run(DBUS_METHOD_CALL_FAILURE, result);
    145     return;
    146   }
    147   callback.Run(DBUS_METHOD_CALL_SUCCESS, *result);
    148 }
    149 
    150 // Handles responses for methods without results.
    151 void OnVoidMethodWithErrorCallback(
    152     ShillClientHelper::RefHolder* ref_holder,
    153     const base::Closure& callback,
    154     dbus::Response* response) {
    155   callback.Run();
    156 }
    157 
    158 // Handles responses for methods with DictionaryValue results.
    159 // Used by CallDictionaryValueMethodWithErrorCallback().
    160 void OnDictionaryValueMethodWithErrorCallback(
    161     ShillClientHelper::RefHolder* ref_holder,
    162     const ShillClientHelper::DictionaryValueCallbackWithoutStatus& callback,
    163     const ShillClientHelper::ErrorCallback& error_callback,
    164     dbus::Response* response) {
    165   dbus::MessageReader reader(response);
    166   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
    167   base::DictionaryValue* result = NULL;
    168   if (!value.get() || !value->GetAsDictionary(&result)) {
    169     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
    170     return;
    171   }
    172   callback.Run(*result);
    173 }
    174 
    175 // Handles responses for methods with ListValue results.
    176 void OnListValueMethodWithErrorCallback(
    177     ShillClientHelper::RefHolder* ref_holder,
    178     const ShillClientHelper::ListValueCallback& callback,
    179     const ShillClientHelper::ErrorCallback& error_callback,
    180     dbus::Response* response) {
    181   dbus::MessageReader reader(response);
    182   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
    183   base::ListValue* result = NULL;
    184   if (!value.get() || !value->GetAsList(&result)) {
    185     error_callback.Run(kInvalidResponseErrorName, kInvalidResponseErrorMessage);
    186     return;
    187   }
    188   callback.Run(*result);
    189 }
    190 
    191 // Handles running appropriate error callbacks.
    192 void OnError(const ShillClientHelper::ErrorCallback& error_callback,
    193              dbus::ErrorResponse* response) {
    194   std::string error_name;
    195   std::string error_message;
    196   if (response) {
    197     // Error message may contain the error message as string.
    198     dbus::MessageReader reader(response);
    199     error_name = response->GetErrorName();
    200     reader.PopString(&error_message);
    201   }
    202   error_callback.Run(error_name, error_message);
    203 }
    204 
    205 }  // namespace
    206 
    207 ShillClientHelper::ShillClientHelper(dbus::ObjectProxy* proxy)
    208     : proxy_(proxy),
    209       active_refs_(0),
    210       weak_ptr_factory_(this) {
    211 }
    212 
    213 ShillClientHelper::~ShillClientHelper() {
    214   LOG_IF(ERROR, observer_list_.might_have_observers())
    215       << "ShillClientHelper destroyed with active observers";
    216 }
    217 
    218 void ShillClientHelper::SetReleasedCallback(ReleasedCallback callback) {
    219   CHECK(released_callback_.is_null());
    220   released_callback_ = callback;
    221 }
    222 
    223 void ShillClientHelper::AddPropertyChangedObserver(
    224     ShillPropertyChangedObserver* observer) {
    225   if (observer_list_.HasObserver(observer))
    226     return;
    227   AddRef();
    228   // Excecute all the pending MonitorPropertyChanged calls.
    229   for (size_t i = 0; i < interfaces_to_be_monitored_.size(); ++i) {
    230     MonitorPropertyChangedInternal(interfaces_to_be_monitored_[i]);
    231   }
    232   interfaces_to_be_monitored_.clear();
    233 
    234   observer_list_.AddObserver(observer);
    235 }
    236 
    237 void ShillClientHelper::RemovePropertyChangedObserver(
    238     ShillPropertyChangedObserver* observer) {
    239   if (!observer_list_.HasObserver(observer))
    240     return;
    241   observer_list_.RemoveObserver(observer);
    242   Release();
    243 }
    244 
    245 void ShillClientHelper::MonitorPropertyChanged(
    246     const std::string& interface_name) {
    247   if (observer_list_.might_have_observers()) {
    248     // Effectively monitor the PropertyChanged now.
    249     MonitorPropertyChangedInternal(interface_name);
    250   } else {
    251     // Delay the ConnectToSignal until an observer is added.
    252     interfaces_to_be_monitored_.push_back(interface_name);
    253   }
    254 }
    255 
    256 void ShillClientHelper::MonitorPropertyChangedInternal(
    257     const std::string& interface_name) {
    258   // We are not using dbus::PropertySet to monitor PropertyChanged signal
    259   // because the interface is not "org.freedesktop.DBus.Properties".
    260   proxy_->ConnectToSignal(interface_name,
    261                           shill::kMonitorPropertyChanged,
    262                           base::Bind(&ShillClientHelper::OnPropertyChanged,
    263                                      weak_ptr_factory_.GetWeakPtr()),
    264                           base::Bind(&ShillClientHelper::OnSignalConnected,
    265                                      weak_ptr_factory_.GetWeakPtr()));
    266 }
    267 
    268 void ShillClientHelper::CallVoidMethod(
    269     dbus::MethodCall* method_call,
    270     const VoidDBusMethodCallback& callback) {
    271   DCHECK(!callback.is_null());
    272   proxy_->CallMethod(
    273       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    274       base::Bind(&OnVoidMethod,
    275                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    276                  callback));
    277 }
    278 
    279 void ShillClientHelper::CallObjectPathMethod(
    280     dbus::MethodCall* method_call,
    281     const ObjectPathDBusMethodCallback& callback) {
    282   DCHECK(!callback.is_null());
    283   proxy_->CallMethod(
    284       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    285       base::Bind(&OnObjectPathMethod,
    286                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    287                  callback));
    288 }
    289 
    290 void ShillClientHelper::CallObjectPathMethodWithErrorCallback(
    291     dbus::MethodCall* method_call,
    292     const ObjectPathCallback& callback,
    293     const ErrorCallback& error_callback) {
    294   DCHECK(!callback.is_null());
    295   DCHECK(!error_callback.is_null());
    296   proxy_->CallMethodWithErrorCallback(
    297       method_call,
    298       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    299       base::Bind(&OnObjectPathMethodWithoutStatus,
    300                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    301                  callback,
    302                  error_callback),
    303       base::Bind(&OnError,
    304                  error_callback));
    305 }
    306 
    307 void ShillClientHelper::CallDictionaryValueMethod(
    308     dbus::MethodCall* method_call,
    309     const DictionaryValueCallback& callback) {
    310   DCHECK(!callback.is_null());
    311   proxy_->CallMethod(
    312       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    313       base::Bind(&OnDictionaryValueMethod,
    314                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    315                  callback));
    316 }
    317 
    318 void ShillClientHelper::CallVoidMethodWithErrorCallback(
    319     dbus::MethodCall* method_call,
    320     const base::Closure& callback,
    321     const ErrorCallback& error_callback) {
    322   DCHECK(!callback.is_null());
    323   DCHECK(!error_callback.is_null());
    324   proxy_->CallMethodWithErrorCallback(
    325       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    326       base::Bind(&OnVoidMethodWithErrorCallback,
    327                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    328                  callback),
    329       base::Bind(&OnError,
    330                  error_callback));
    331 }
    332 
    333 void ShillClientHelper::CallBooleanMethodWithErrorCallback(
    334     dbus::MethodCall* method_call,
    335     const BooleanCallback& callback,
    336     const ErrorCallback& error_callback) {
    337   DCHECK(!callback.is_null());
    338   DCHECK(!error_callback.is_null());
    339   proxy_->CallMethodWithErrorCallback(
    340       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    341       base::Bind(&OnBooleanMethodWithErrorCallback,
    342                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    343                  callback,
    344                  error_callback),
    345       base::Bind(&OnError,
    346                  error_callback));
    347 }
    348 
    349 void ShillClientHelper::CallStringMethodWithErrorCallback(
    350     dbus::MethodCall* method_call,
    351     const StringCallback& callback,
    352     const ErrorCallback& error_callback) {
    353   DCHECK(!callback.is_null());
    354   DCHECK(!error_callback.is_null());
    355   proxy_->CallMethodWithErrorCallback(
    356       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    357       base::Bind(&OnStringMethodWithErrorCallback,
    358                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    359                  callback,
    360                  error_callback),
    361       base::Bind(&OnError,
    362                  error_callback));
    363 }
    364 
    365 void ShillClientHelper::CallDictionaryValueMethodWithErrorCallback(
    366     dbus::MethodCall* method_call,
    367     const DictionaryValueCallbackWithoutStatus& callback,
    368     const ErrorCallback& error_callback) {
    369   DCHECK(!callback.is_null());
    370   DCHECK(!error_callback.is_null());
    371   proxy_->CallMethodWithErrorCallback(
    372       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    373       base::Bind(&OnDictionaryValueMethodWithErrorCallback,
    374                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    375                  callback,
    376                  error_callback),
    377       base::Bind(&OnError,
    378                  error_callback));
    379 }
    380 
    381 void ShillClientHelper::CallListValueMethodWithErrorCallback(
    382     dbus::MethodCall* method_call,
    383     const ListValueCallback& callback,
    384     const ErrorCallback& error_callback) {
    385   DCHECK(!callback.is_null());
    386   DCHECK(!error_callback.is_null());
    387   proxy_->CallMethodWithErrorCallback(
    388       method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
    389       base::Bind(&OnListValueMethodWithErrorCallback,
    390                  base::Owned(new RefHolder(weak_ptr_factory_.GetWeakPtr())),
    391                  callback,
    392                  error_callback),
    393       base::Bind(&OnError,
    394                  error_callback));
    395 }
    396 
    397 // static
    398 void ShillClientHelper::AppendValueDataAsVariant(dbus::MessageWriter* writer,
    399                                                  const base::Value& value) {
    400   // Support basic types and string-to-string dictionary.
    401   switch (value.GetType()) {
    402     case base::Value::TYPE_DICTIONARY: {
    403       const base::DictionaryValue* dictionary = NULL;
    404       value.GetAsDictionary(&dictionary);
    405       dbus::MessageWriter variant_writer(NULL);
    406       writer->OpenVariant("a{ss}", &variant_writer);
    407       dbus::MessageWriter array_writer(NULL);
    408       variant_writer.OpenArray("{ss}", &array_writer);
    409       for (base::DictionaryValue::Iterator it(*dictionary);
    410            !it.IsAtEnd();
    411            it.Advance()) {
    412         dbus::MessageWriter entry_writer(NULL);
    413         array_writer.OpenDictEntry(&entry_writer);
    414         entry_writer.AppendString(it.key());
    415         const base::Value& value = it.value();
    416         std::string value_string;
    417         DLOG_IF(ERROR, value.GetType() != base::Value::TYPE_STRING)
    418             << "Unexpected type " << value.GetType();
    419         value.GetAsString(&value_string);
    420         entry_writer.AppendString(value_string);
    421         array_writer.CloseContainer(&entry_writer);
    422       }
    423       variant_writer.CloseContainer(&array_writer);
    424       writer->CloseContainer(&variant_writer);
    425       break;
    426     }
    427     case base::Value::TYPE_LIST: {
    428       const base::ListValue* list = NULL;
    429       value.GetAsList(&list);
    430       dbus::MessageWriter variant_writer(NULL);
    431       writer->OpenVariant("as", &variant_writer);
    432       dbus::MessageWriter array_writer(NULL);
    433       variant_writer.OpenArray("s", &array_writer);
    434       for (base::ListValue::const_iterator it = list->begin();
    435            it != list->end(); ++it) {
    436         const base::Value& value = **it;
    437         LOG_IF(ERROR, value.GetType() != base::Value::TYPE_STRING)
    438             << "Unexpected type " << value.GetType();
    439         std::string value_string;
    440         value.GetAsString(&value_string);
    441         array_writer.AppendString(value_string);
    442       }
    443       variant_writer.CloseContainer(&array_writer);
    444       writer->CloseContainer(&variant_writer);
    445       break;
    446     }
    447     case base::Value::TYPE_BOOLEAN:
    448     case base::Value::TYPE_INTEGER:
    449     case base::Value::TYPE_DOUBLE:
    450     case base::Value::TYPE_STRING:
    451       dbus::AppendBasicTypeValueDataAsVariant(writer, value);
    452       break;
    453     default:
    454       DLOG(ERROR) << "Unexpected type " << value.GetType();
    455   }
    456 
    457 }
    458 
    459 // static
    460 void ShillClientHelper::AppendServicePropertiesDictionary(
    461     dbus::MessageWriter* writer,
    462     const base::DictionaryValue& dictionary) {
    463   dbus::MessageWriter array_writer(NULL);
    464   writer->OpenArray("{sv}", &array_writer);
    465   for (base::DictionaryValue::Iterator it(dictionary);
    466        !it.IsAtEnd();
    467        it.Advance()) {
    468     dbus::MessageWriter entry_writer(NULL);
    469     array_writer.OpenDictEntry(&entry_writer);
    470     entry_writer.AppendString(it.key());
    471     ShillClientHelper::AppendValueDataAsVariant(&entry_writer, it.value());
    472     array_writer.CloseContainer(&entry_writer);
    473   }
    474   writer->CloseContainer(&array_writer);
    475 }
    476 
    477 void ShillClientHelper::AddRef() {
    478   ++active_refs_;
    479 }
    480 
    481 void ShillClientHelper::Release() {
    482   --active_refs_;
    483   if (active_refs_ == 0 && !released_callback_.is_null())
    484     base::ResetAndReturn(&released_callback_).Run(this);  // May delete this
    485 }
    486 
    487 void ShillClientHelper::OnSignalConnected(const std::string& interface,
    488                                           const std::string& signal,
    489                                           bool success) {
    490   LOG_IF(ERROR, !success) << "Connect to " << interface << " " << signal
    491                           << " failed.";
    492 }
    493 
    494 void ShillClientHelper::OnPropertyChanged(dbus::Signal* signal) {
    495   if (!observer_list_.might_have_observers())
    496     return;
    497 
    498   dbus::MessageReader reader(signal);
    499   std::string name;
    500   if (!reader.PopString(&name))
    501     return;
    502   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
    503   if (!value.get())
    504     return;
    505 
    506   FOR_EACH_OBSERVER(ShillPropertyChangedObserver, observer_list_,
    507                     OnPropertyChanged(name, *value));
    508 }
    509 
    510 }  // namespace chromeos
    511