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

src/service.cc

 // 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.
 
 #include "src/service.h"
 
 #include <glog/logging.h>
 
 #include "src/data_plan_provider.h"
 #include "src/device.h"
@@ skipping 74 matching lines @@
       retrying_get_properties_(false),
       connectivity_state_(kConnectivityStateUnknown) {
   // schedule a GetProperties() call to our Flimflam service path to init state
   // we'll keep trying periodically until we succeed
   // we'll subsequently update this state by monitoring PropertyChanged signals
   get_properties_source_id_ =
       g_idle_add(StaticGetServicePropertiesCallback, this);
   if (get_properties_source_id_ == 0) {
     LOG(ERROR) << path_ << ": ctor: g_idle_add failed";
   }
+  property_changed_handler_.delegate(this);
 }
 
 Service::~Service() {
   DeleteCarrierState();
   DeleteDataPlans(&data_plans_);
   if (device_ != NULL) {
     DLOG(INFO) << path_ << ": deleting device " << device_->GetPath();
     delete device_;
     device_ = NULL;
   }
@@ skipping 70 matching lines @@
 
 Service::ConnectivityState Service::GetConnectivityState() const {
   return connectivity_state_;
 }
 
 // Flimflam Service D-Bus Proxy methods
 
 void Service::PropertyChanged(const std::string& property_name,
                               const DBus::Variant& new_value) {
   DLOG(INFO) << path_ << ": PropertyChanged: property_name = " << property_name;
+  // Queue a tuple representing this signal for later processing from the glib
+  // main loop. We do this to avoid libdbus-c++ deadlocks that can occur when
+  // sending a dbus message from within a dbus callback like this one.
+  PropertyChangedSignal signal(property_name, new_value);
+  property_changed_handler_.EnqueueSignal(signal);
+}
+
+// PropertyChangedDelegate methods
+
+void Service::OnPropertyChanged(const PropertyChangedHandler *handler,
+                                const std::string& property_name,
+                                const DBus::Variant& new_value) {
+  DCHECK(handler == &property_changed_handler_);
+  DLOG(INFO) << path_ << ": OnPropertyChanged: property_name = "
+      << property_name;
   if (property_name == kFlimflamServiceDeviceProperty) {
     OnDeviceUpdate(new_value.reader().get_path());
   } else if (property_name == kFlimflamServiceStateProperty) {
     OnStateUpdate(new_value.reader().get_string());
   } else if (property_name == kFlimflamServiceTypeProperty) {
     OnTypeUpdate(new_value.reader().get_string());
   } else if (property_name == kFlimflamServiceUsageUrlProperty) {
     OnUsageUrlUpdate(new_value.reader().get_string());
   } else if (property_name == kFlimflamServiceConnectivityStateProperty) {
     OnConnectivityStateUpdate(new_value.reader().get_string());
@@ skipping 720 matching lines @@
   DCHECK(policy_ != NULL);
   if (policy_->ShouldEmitDataPlansUpdate(data_plans_)) {
     DLOG(INFO) << path_ << ": MaybeEmitDataPlansUpdate: sending update";
     parent_->EmitDataPlansUpdate(*this);
   } else {
     DLOG(INFO) << path_ << ": MaybeEmitDataPlansUpdate: not sending update";
   }
 }
 
 }  // namespace cashew