dbus/object_manager.cc

   1 // Copyright (c) 2013 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 "dbus/object_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "dbus/bus.h"
  10 #include "dbus/message.h"
  11 #include "dbus/object_proxy.h"
  12 #include "dbus/property.h"
  13
  14 namespace dbus {
  15
  16 ObjectManager::Object::Object()
  17   : object_proxy(NULL) {
  18 }
  19
  20 ObjectManager::Object::~Object() {
  21 }
  22
  23 ObjectManager::ObjectManager(Bus* bus,
  24                              const std::string& service_name,
  25                              const ObjectPath& object_path)
  26     : bus_(bus),
  27       service_name_(service_name),
  28       object_path_(object_path),
  29       weak_ptr_factory_(this) {
  30   DVLOG(1) << "Creating ObjectManager for " << service_name_
  31            << " " << object_path_.value();
  32
  33   DCHECK(bus_);
  34   object_proxy_ = bus_->GetObjectProxy(service_name_, object_path_);
  35   object_proxy_->SetNameOwnerChangedCallback(
  36       base::Bind(&ObjectManager::NameOwnerChanged,
  37                  weak_ptr_factory_.GetWeakPtr()));
  38
  39   object_proxy_->ConnectToSignal(
  40       kObjectManagerInterface,
  41       kObjectManagerInterfacesAdded,
  42       base::Bind(&ObjectManager::InterfacesAddedReceived,
  43                  weak_ptr_factory_.GetWeakPtr()),
  44       base::Bind(&ObjectManager::InterfacesAddedConnected,
  45                  weak_ptr_factory_.GetWeakPtr()));
  46
  47   object_proxy_->ConnectToSignal(
  48       kObjectManagerInterface,
  49       kObjectManagerInterfacesRemoved,
  50       base::Bind(&ObjectManager::InterfacesRemovedReceived,
  51                  weak_ptr_factory_.GetWeakPtr()),
  52       base::Bind(&ObjectManager::InterfacesRemovedConnected,
  53                  weak_ptr_factory_.GetWeakPtr()));
  54
  55   GetManagedObjects();
  56 }
  57
  58 ObjectManager::~ObjectManager() {
  59   // Clean up Object structures
  60   for (ObjectMap::iterator iter = object_map_.begin();
  61        iter != object_map_.end(); ++iter) {
  62     Object* object = iter->second;
  63
  64     for (Object::PropertiesMap::iterator piter = object->properties_map.begin();
  65          piter != object->properties_map.end(); ++piter) {
  66       PropertySet* properties = piter->second;
  67       delete properties;
  68     }
  69
  70     delete object;
  71   }
  72 }
  73
  74 void ObjectManager::RegisterInterface(const std::string& interface_name,
  75                                       Interface* interface) {
  76   interface_map_[interface_name] = interface;
  77 }
  78
  79 void ObjectManager::UnregisterInterface(const std::string& interface_name) {
  80   InterfaceMap::iterator iter = interface_map_.find(interface_name);
  81   if (iter != interface_map_.end())
  82     interface_map_.erase(iter);
  83 }
  84
  85 std::vector<ObjectPath> ObjectManager::GetObjects() {
  86   std::vector<ObjectPath> object_paths;
  87
  88   for (ObjectMap::iterator iter = object_map_.begin();
  89        iter != object_map_.end(); ++iter)
  90     object_paths.push_back(iter->first);
  91
  92   return object_paths;
  93 }
  94
  95 std::vector<ObjectPath> ObjectManager::GetObjectsWithInterface(
  96       const std::string& interface_name) {
  97   std::vector<ObjectPath> object_paths;
  98
  99   for (ObjectMap::iterator oiter = object_map_.begin();
 100        oiter != object_map_.end(); ++oiter) {
 101     Object* object = oiter->second;
 102
 103     Object::PropertiesMap::iterator piter =
 104         object->properties_map.find(interface_name);
 105     if (piter != object->properties_map.end())
 106       object_paths.push_back(oiter->first);
 107   }
 108
 109   return object_paths;
 110 }
 111
 112 ObjectProxy* ObjectManager::GetObjectProxy(const ObjectPath& object_path) {
 113   ObjectMap::iterator iter = object_map_.find(object_path);
 114   if (iter == object_map_.end())
 115     return NULL;
 116
 117   Object* object = iter->second;
 118   return object->object_proxy;
 119 }
 120
 121 PropertySet* ObjectManager::GetProperties(const ObjectPath& object_path,
 122                                           const std::string& interface_name) {
 123   ObjectMap::iterator iter = object_map_.find(object_path);
 124   if (iter == object_map_.end())
 125     return NULL;
 126
 127   Object* object = iter->second;
 128   Object::PropertiesMap::iterator piter =
 129       object->properties_map.find(interface_name);
 130   if (piter == object->properties_map.end())
 131     return NULL;
 132
 133   return piter->second;
 134 }
 135
 136 void ObjectManager::GetManagedObjects() {
 137   MethodCall method_call(kObjectManagerInterface,
 138                          kObjectManagerGetManagedObjects);
 139
 140   object_proxy_->CallMethod(
 141       &method_call,
 142       ObjectProxy::TIMEOUT_USE_DEFAULT,
 143       base::Bind(&ObjectManager::OnGetManagedObjects,
 144                  weak_ptr_factory_.GetWeakPtr()));
 145 }
 146
 147 void ObjectManager::OnGetManagedObjects(Response* response) {
 148   if (response != NULL) {
 149     MessageReader reader(response);
 150     MessageReader array_reader(NULL);
 151     if (!reader.PopArray(&array_reader))
 152       return;
 153
 154     while (array_reader.HasMoreData()) {
 155       MessageReader dict_entry_reader(NULL);
 156       ObjectPath object_path;
 157       if (!array_reader.PopDictEntry(&dict_entry_reader) ||
 158           !dict_entry_reader.PopObjectPath(&object_path))
 159         continue;
 160
 161       UpdateObject(object_path, &dict_entry_reader);
 162     }
 163
 164   } else {
 165     LOG(WARNING) << service_name_ << " " << object_path_.value()
 166                  << ": Failed to get managed objects";
 167   }
 168 }
 169
 170 void ObjectManager::InterfacesAddedReceived(Signal* signal) {
 171   DCHECK(signal);
 172   MessageReader reader(signal);
 173   ObjectPath object_path;
 174   if (!reader.PopObjectPath(&object_path)) {
 175     LOG(WARNING) << service_name_ << " " << object_path_.value()
 176                  << ": InterfacesAdded signal has incorrect parameters: "
 177                  << signal->ToString();
 178     return;
 179   }
 180
 181   UpdateObject(object_path, &reader);
 182 }
 183
 184 void ObjectManager::InterfacesAddedConnected(const std::string& interface_name,
 185                                              const std::string& signal_name,
 186                                              bool success) {
 187   LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value()
 188                             << ": Failed to connect to InterfacesAdded signal.";
 189 }
 190
 191 void ObjectManager::InterfacesRemovedReceived(Signal* signal) {
 192   DCHECK(signal);
 193   MessageReader reader(signal);
 194   ObjectPath object_path;
 195   std::vector<std::string> interface_names;
 196   if (!reader.PopObjectPath(&object_path) ||
 197       !reader.PopArrayOfStrings(&interface_names)) {
 198     LOG(WARNING) << service_name_ << " " << object_path_.value()
 199                  << ": InterfacesRemoved signal has incorrect parameters: "
 200                  << signal->ToString();
 201     return;
 202   }
 203
 204   for (size_t i = 0; i < interface_names.size(); ++i)
 205     RemoveInterface(object_path, interface_names[i]);
 206 }
 207
 208 void ObjectManager::InterfacesRemovedConnected(
 209     const std::string& interface_name,
 210     const std::string& signal_name,
 211     bool success) {
 212   LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value()
 213                             << ": Failed to connect to "
 214                             << "InterfacesRemoved signal.";
 215 }
 216
 217 void ObjectManager::UpdateObject(const ObjectPath& object_path,
 218                                  MessageReader* reader) {
 219   DCHECK(reader);
 220   MessageReader array_reader(NULL);
 221   if (!reader->PopArray(&array_reader))
 222     return;
 223
 224   while (array_reader.HasMoreData()) {
 225     MessageReader dict_entry_reader(NULL);
 226     std::string interface_name;
 227     if (!array_reader.PopDictEntry(&dict_entry_reader) ||
 228         !dict_entry_reader.PopString(&interface_name))
 229       continue;
 230
 231     AddInterface(object_path, interface_name, &dict_entry_reader);
 232   }
 233 }
 234
 235
 236 void ObjectManager::AddInterface(const ObjectPath& object_path,
 237                                  const std::string& interface_name,
 238                                  MessageReader* reader) {
 239   InterfaceMap::iterator iiter = interface_map_.find(interface_name);
 240   if (iiter == interface_map_.end())
 241     return;
 242   Interface* interface = iiter->second;
 243
 244   ObjectMap::iterator oiter = object_map_.find(object_path);
 245   Object* object;
 246   if (oiter == object_map_.end()) {
 247     object = object_map_[object_path] = new Object;
 248     object->object_proxy = bus_->GetObjectProxy(service_name_, object_path);
 249   } else
 250     object = oiter->second;
 251
 252   Object::PropertiesMap::iterator piter =
 253       object->properties_map.find(interface_name);
 254   PropertySet* property_set;
 255   const bool interface_added = (piter == object->properties_map.end());
 256   if (interface_added) {
 257     property_set = object->properties_map[interface_name] =
 258         interface->CreateProperties(object->object_proxy,
 259                                     object_path, interface_name);
 260     property_set->ConnectSignals();
 261   } else
 262     property_set = piter->second;
 263
 264   property_set->UpdatePropertiesFromReader(reader);
 265
 266   if (interface_added)
 267     interface->ObjectAdded(object_path, interface_name);
 268 }
 269
 270 void ObjectManager::RemoveInterface(const ObjectPath& object_path,
 271                                     const std::string& interface_name) {
 272   ObjectMap::iterator oiter = object_map_.find(object_path);
 273   if (oiter == object_map_.end())
 274     return;
 275   Object* object = oiter->second;
 276
 277   Object::PropertiesMap::iterator piter =
 278       object->properties_map.find(interface_name);
 279   if (piter == object->properties_map.end())
 280     return;
 281
 282   // Inform the interface before removing the properties structure or object
 283   // in case it needs details from them to make its own decisions.
 284   InterfaceMap::iterator iiter = interface_map_.find(interface_name);
 285   if (iiter != interface_map_.end()) {
 286     Interface* interface = iiter->second;
 287     interface->ObjectRemoved(object_path, interface_name);
 288   }
 289
 290   object->properties_map.erase(piter);
 291
 292   if (object->properties_map.empty()) {
 293     object_map_.erase(oiter);
 294     delete object;
 295   }
 296 }
 297
 298 void ObjectManager::NameOwnerChanged(const std::string& old_owner,
 299                                      const std::string& new_owner) {
 300   if (!old_owner.empty()) {
 301     ObjectMap::iterator iter = object_map_.begin();
 302     while (iter != object_map_.end()) {
 303       ObjectMap::iterator tmp = iter;
 304       ++iter;
 305
 306       // PropertiesMap is mutated by RemoveInterface, and also Object is
 307       // destroyed; easier to collect the object path and interface names
 308       // and remove them safely.
 309       const dbus::ObjectPath object_path = tmp->first;
 310       Object* object = tmp->second;
 311       std::vector<std::string> interfaces;
 312
 313       for (Object::PropertiesMap::iterator piter =
 314               object->properties_map.begin();
 315            piter != object->properties_map.end(); ++piter)
 316         interfaces.push_back(piter->first);
 317
 318       for (std::vector<std::string>::iterator iiter = interfaces.begin();
 319            iiter != interfaces.end(); ++iiter)
 320         RemoveInterface(object_path, *iiter);
 321     }
 322
 323   }
 324
 325   if (!new_owner.empty())
 326     GetManagedObjects();
 327 }
 328
 329 }  // namespace dbus