chromeos/dbus/shill_device_client.cc

   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_device_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/stl_util.h"
  10 #include "base/values.h"
  11 #include "chromeos/dbus/fake_shill_device_client.h"
  12 #include "chromeos/dbus/shill_property_changed_observer.h"
  13 #include "dbus/bus.h"
  14 #include "dbus/message.h"
  15 #include "dbus/object_path.h"
  16 #include "dbus/object_proxy.h"
  17 #include "dbus/values_util.h"
  18 #include "third_party/cros_system_api/dbus/service_constants.h"
  19
  20 namespace chromeos {
  21
  22 namespace {
  23
  24 // The ShillDeviceClient implementation.
  25 class ShillDeviceClientImpl : public ShillDeviceClient {
  26  public:
  27   explicit ShillDeviceClientImpl()
  28       : bus_(NULL) {
  29   }
  30
  31   virtual ~ShillDeviceClientImpl() {
  32     for (HelperMap::iterator iter = helpers_.begin();
  33          iter != helpers_.end(); ++iter) {
  34       // This *should* never happen, yet we're getting crash reports that
  35       // seem to imply that it does happen sometimes.  Adding CHECKs here
  36       // so we can determine more accurately where the problem lies.
  37       // See: http://crbug.com/170541
  38       CHECK(iter->second) << "NULL Helper found in helper list.";
  39       delete iter->second;
  40     }
  41     helpers_.clear();
  42   }
  43
  44   ///////////////////////////////////////
  45   // ShillDeviceClient overrides.
  46   virtual void AddPropertyChangedObserver(
  47       const dbus::ObjectPath& device_path,
  48       ShillPropertyChangedObserver* observer) OVERRIDE {
  49     GetHelper(device_path)->AddPropertyChangedObserver(observer);
  50   }
  51
  52   virtual void RemovePropertyChangedObserver(
  53       const dbus::ObjectPath& device_path,
  54       ShillPropertyChangedObserver* observer) OVERRIDE {
  55     GetHelper(device_path)->RemovePropertyChangedObserver(observer);
  56   }
  57
  58   virtual void GetProperties(const dbus::ObjectPath& device_path,
  59                              const DictionaryValueCallback& callback) OVERRIDE {
  60     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
  61                                  shill::kGetPropertiesFunction);
  62     GetHelper(device_path)->CallDictionaryValueMethod(&method_call, callback);
  63   }
  64
  65   virtual void ProposeScan(const dbus::ObjectPath& device_path,
  66                            const VoidDBusMethodCallback& callback) OVERRIDE {
  67     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
  68                                  shill::kProposeScanFunction);
  69     GetHelper(device_path)->CallVoidMethod(&method_call, callback);
  70   }
  71
  72   virtual void SetProperty(const dbus::ObjectPath& device_path,
  73                            const std::string& name,
  74                            const base::Value& value,
  75                            const base::Closure& callback,
  76                            const ErrorCallback& error_callback) OVERRIDE {
  77     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
  78                                  shill::kSetPropertyFunction);
  79     dbus::MessageWriter writer(&method_call);
  80     writer.AppendString(name);
  81     ShillClientHelper::AppendValueDataAsVariant(&writer, value);
  82     GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call,
  83                                                             callback,
  84                                                             error_callback);
  85   }
  86
  87   virtual void ClearProperty(const dbus::ObjectPath& device_path,
  88                              const std::string& name,
  89                              const VoidDBusMethodCallback& callback) OVERRIDE {
  90     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
  91                                  shill::kClearPropertyFunction);
  92     dbus::MessageWriter writer(&method_call);
  93     writer.AppendString(name);
  94     GetHelper(device_path)->CallVoidMethod(&method_call, callback);
  95   }
  96
  97   virtual void AddIPConfig(
  98       const dbus::ObjectPath& device_path,
  99       const std::string& method,
 100       const ObjectPathDBusMethodCallback& callback) OVERRIDE {
 101     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 102                                  shill::kAddIPConfigFunction);
 103     dbus::MessageWriter writer(&method_call);
 104     writer.AppendString(method);
 105     GetHelper(device_path)->CallObjectPathMethod(&method_call, callback);
 106   }
 107
 108   virtual void RequirePin(const dbus::ObjectPath& device_path,
 109                           const std::string& pin,
 110                           bool require,
 111                           const base::Closure& callback,
 112                           const ErrorCallback& error_callback) OVERRIDE {
 113     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 114                                  shill::kRequirePinFunction);
 115     dbus::MessageWriter writer(&method_call);
 116     writer.AppendString(pin);
 117     writer.AppendBool(require);
 118     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 119         &method_call, callback, error_callback);
 120   }
 121
 122   virtual void EnterPin(const dbus::ObjectPath& device_path,
 123                         const std::string& pin,
 124                         const base::Closure& callback,
 125                         const ErrorCallback& error_callback) OVERRIDE {
 126     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 127                                  shill::kEnterPinFunction);
 128     dbus::MessageWriter writer(&method_call);
 129     writer.AppendString(pin);
 130     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 131         &method_call, callback, error_callback);
 132   }
 133
 134   virtual void UnblockPin(const dbus::ObjectPath& device_path,
 135                           const std::string& puk,
 136                           const std::string& pin,
 137                           const base::Closure& callback,
 138                           const ErrorCallback& error_callback) OVERRIDE {
 139     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 140                                  shill::kUnblockPinFunction);
 141     dbus::MessageWriter writer(&method_call);
 142     writer.AppendString(puk);
 143     writer.AppendString(pin);
 144     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 145         &method_call, callback, error_callback);
 146   }
 147
 148   virtual void ChangePin(const dbus::ObjectPath& device_path,
 149                          const std::string& old_pin,
 150                          const std::string& new_pin,
 151                          const base::Closure& callback,
 152                          const ErrorCallback& error_callback) OVERRIDE {
 153     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 154                                  shill::kChangePinFunction);
 155     dbus::MessageWriter writer(&method_call);
 156     writer.AppendString(old_pin);
 157     writer.AppendString(new_pin);
 158     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 159         &method_call, callback, error_callback);
 160   }
 161
 162   virtual void Register(const dbus::ObjectPath& device_path,
 163                         const std::string& network_id,
 164                         const base::Closure& callback,
 165                         const ErrorCallback& error_callback) OVERRIDE {
 166     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 167                                  shill::kRegisterFunction);
 168     dbus::MessageWriter writer(&method_call);
 169     writer.AppendString(network_id);
 170     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 171         &method_call, callback, error_callback);
 172   }
 173
 174   virtual void SetCarrier(const dbus::ObjectPath& device_path,
 175                           const std::string& carrier,
 176                           const base::Closure& callback,
 177                           const ErrorCallback& error_callback) OVERRIDE {
 178     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 179                                  shill::kSetCarrierFunction);
 180     dbus::MessageWriter writer(&method_call);
 181     writer.AppendString(carrier);
 182     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 183         &method_call, callback, error_callback);
 184   }
 185
 186   virtual void Reset(const dbus::ObjectPath& device_path,
 187                      const base::Closure& callback,
 188                      const ErrorCallback& error_callback) OVERRIDE {
 189     dbus::MethodCall method_call(shill::kFlimflamDeviceInterface,
 190                                  shill::kResetFunction);
 191     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
 192         &method_call, callback, error_callback);
 193   }
 194
 195   virtual TestInterface* GetTestInterface() OVERRIDE {
 196     return NULL;
 197   }
 198
 199  protected:
 200   virtual void Init(dbus::Bus* bus) OVERRIDE {
 201     bus_ = bus;
 202   }
 203
 204  private:
 205   typedef std::map<std::string, ShillClientHelper*> HelperMap;
 206
 207   // Returns the corresponding ShillClientHelper for the profile.
 208   ShillClientHelper* GetHelper(const dbus::ObjectPath& device_path) {
 209     HelperMap::iterator it = helpers_.find(device_path.value());
 210     if (it != helpers_.end()) {
 211       CHECK(it->second) << "Found a NULL helper in the list.";
 212       return it->second;
 213     }
 214
 215     // There is no helper for the profile, create it.
 216     dbus::ObjectProxy* object_proxy =
 217         bus_->GetObjectProxy(shill::kFlimflamServiceName, device_path);
 218     ShillClientHelper* helper = new ShillClientHelper(object_proxy);
 219     CHECK(helper) << "Unable to create Shill client helper.";
 220     helper->MonitorPropertyChanged(shill::kFlimflamDeviceInterface);
 221     helpers_.insert(HelperMap::value_type(device_path.value(), helper));
 222     return helper;
 223   }
 224
 225   dbus::Bus* bus_;
 226   HelperMap helpers_;
 227
 228   DISALLOW_COPY_AND_ASSIGN(ShillDeviceClientImpl);
 229 };
 230
 231 }  // namespace
 232
 233 ShillDeviceClient::ShillDeviceClient() {}
 234
 235 ShillDeviceClient::~ShillDeviceClient() {}
 236
 237 // static
 238 ShillDeviceClient* ShillDeviceClient::Create(
 239     DBusClientImplementationType type) {
 240   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 241     return new ShillDeviceClientImpl();
 242   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 243   return new FakeShillDeviceClient();
 244 }
 245
 246 }  // namespace chromeos