dbus::ObjectManager: Add a match rule for properties before GetManagedObjects.

dbus/object_manager.h

 // Copyright (c) 2013 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 DBUS_OBJECT_MANAGER_H_
 #define DBUS_OBJECT_MANAGER_H_
 
 #include <map>
 
 #include "base/memory/ref_counted.h"
@@ skipping 205 matching lines @@
   // cast the returned pointer to the appropriate type, e.g.:
   //   static_cast<Properties*>(GetProperties(object_path, my_interface));
   PropertySet* GetProperties(const ObjectPath& object_path,
                              const std::string& interface_name);
 
   // Instructs the object manager to refresh its list of managed objects;
   // automatically called by the D-Bus thread manager, there should never be
   // a need to call this manually.
   void GetManagedObjects();
 
+  // Cleans up any match rules and filter functions added by this ObjectManager.
+  // The Bus object will take care of this so you don't have to do it manually.
+  //
+  // BLOCKING CALL.
+  void CleanUp();
+
  protected:
   virtual ~ObjectManager();
 
  private:
   friend class base::RefCountedThreadSafe<ObjectManager>;
 
+  // Connects the InterfacesAdded and InterfacesRemoved signals and calls
+  // GetManagedObjects. Called from OnSetupMatchRuleAndFilterComplete.
+  void InitializeObjects();
+
+  // Called from the constructor to add a match rule for PropertiesChanged
+  // signals on the DBus thread and set up a corresponding filter function.
+  bool SetupMatchRuleAndFilter();
+
+  // Called on the origin thread once the match rule and filter have been set
+  // up. |success| is false, if an error occurred during set up; it's true
+  // otherwise.
+  void OnSetupMatchRuleAndFilterComplete(bool success);
+
+  // Called by dbus:: when a message is received. This is used to filter
+  // PropertiesChanged signals from the correct sender and relay the event to
+  // the correct PropertySet.
+  static DBusHandlerResult HandleMessageThunk(DBusConnection* connection,
+                                              DBusMessage* raw_message,
+                                              void* user_data);
+  DBusHandlerResult HandleMessage(DBusConnection* connection,
+                                  DBusMessage* raw_message);
+
+  // Called when a PropertiesChanged signal is received from the sender.
+  // This method notifies the relevant PropertySet that it should update its
+  // properties based on the received signal. Called from HandleMessage.
+  void NotifyPropertiesChanged(const dbus::ObjectPath object_path,
+                               Signal* signal);
+  void NotifyPropertiesChangedHelper(const dbus::ObjectPath object_path,
+                                     Signal* signal);
 
   // Called by dbus:: in response to the GetManagedObjects() method call.
   void OnGetManagedObjects(Response* response);
 
   // Called by dbus:: when an InterfacesAdded signal is received and initially
   // connected.
   void InterfacesAddedReceived(Signal* signal);
   void InterfacesAddedConnected(const std::string& interface_name,
                                 const std::string& signal_name,
                                 bool success);
@@ skipping 32 matching lines @@
                        const std::string& interface_name);
 
   // Removes all objects and interfaces from the object manager when
   // |old_owner| is not the empty string and/or re-requests the set of managed
   // objects when |new_owner| is not the empty string.
   void NameOwnerChanged(const std::string& old_owner,
                         const std::string& new_owner);
 
   Bus* bus_;
   std::string service_name_;
+  std::string service_name_owner_;
+  std::string match_rule_;
   ObjectPath object_path_;
   ObjectProxy* object_proxy_;
+  bool setup_success_;
+  bool cleanup_called_;
 
   // Maps the name of an interface to the implementation class used for
   // instantiating PropertySet structures for that interface's properties.
   typedef std::map<std::string, Interface*> InterfaceMap;
   InterfaceMap interface_map_;
 
   // Each managed object consists of a ObjectProxy used to make calls
   // against that object and a collection of D-Bus interface names and their
   // associated PropertySet structures.
   struct Object {
@@ skipping 17 matching lines @@
   // 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<ObjectManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectManager);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_OBJECT_MANAGER_H_