cashew: defer all D-Bus signal processing to main loop

src/device.h

 // Copyright (c) 2010 The Chromium OS 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 SRC_DEVICE_H_
 #define SRC_DEVICE_H_
 
 #include <glib.h>
 
 #include <string>
 
 #include <base/basictypes.h>  // NOLINT
 #include <dbus-c++/dbus.h>  // NOLINT
 
 #include "src/byte_counter.h"
 #include "src/flimflam_device_client_glue.h"
+#include "src/property_changed_handler.h"
 
 namespace cashew {
 
 class ByteCounter;
 class Service;
 
 // represents a cellular device and monitors Flimflam state for that device
 class Device : public org::chromium::flimflam::Device_proxy,
                public DBus::IntrospectableProxy,
                public DBus::ObjectProxy,
-               public ByteCounterDelegate {
+               public ByteCounterDelegate,
+               public PropertyChangedDelegate {
   public:
     Device(Service * const parent, DBus::Connection& connection,  // NOLINT
            const DBus::Path& path);
     virtual ~Device();
 
     // get D-Bus path for this device
     virtual const DBus::Path& GetPath() const;
 
     // valid type values for this device
     typedef enum {
@@ skipping 14 matching lines @@
     // get cellular carrier for this device
     // returns empty string if we don't know
     virtual const std::string& GetCarrier() const;
 
     // get interface name for this device (e.g., "usb0")
     // returns empty string if we don't know
     virtual const std::string& GetInterface() const;
 
     // Flimflam Device D-Bus Proxy methods
 
+    // receive incoming PropertyChanged D-Bus signal from Flimflam device and
+    // schedule deferred processing
     virtual void PropertyChanged(const std::string& property_name,
                                  const DBus::Variant& new_value);
 
+    // PropertyChangedDelegate methods
+
+    virtual void OnPropertyChanged(const PropertyChangedHandler *handler,
+                                   const std::string& property_name,
+                                   const DBus::Variant& new_value);
+
     // Service methods
 
     // start a new byte counter from 0
     // there must not be an existing byte counter
     // |parent_| will receive periodic updates via Service::OnByteCounterUpdate
     // returns true on success and false on failure
     virtual bool StartByteCounter();
 
     // destroy any existing byte counter
     // |parent_| will no longer receive updates after this call
@@ skipping 51 matching lines @@
     // byte counter for this device
     // can be NULL
     ByteCounter *byte_counter_;
 
     // is the byte counter running?
     // this is distinct from whether or not byte_counter_ == NULL, since the
     // counter may be logically running but we may not yet know our interface
     // name and therefore may not yet have created a byte counter object.
     bool byte_counter_running_;
 
+    // Handler for deferred processing of D-Bus PropertyChanged signals.
+    // See comments in service_manager.h
+    PropertyChangedHandler property_changed_handler_;
+
     // convert type string to Type enum value
     Type TypeFromString(const std::string& type) const;
 
     // we've received updated Cellular.Carrier info from Flimflam
     void OnCarrierUpdate(const std::string& carrier);
 
     // we've received updated Interface info from Flimflam
     void OnInterfaceUpdate(const std::string& interface);
 
     // we've received updated Type info from Flimflam
@@ skipping 12 matching lines @@
 
     // delete byte counter object pointed to by |byte_counter_| if any
     void DeleteByteCounter();
 
     DISALLOW_COPY_AND_ASSIGN(Device);
 };
 
 }  // namespace cashew
 
 #endif  // SRC_DEVICE_H_