D-Bus: allow multiple signal handlers for a signal

dbus/object_proxy.cc

 // Copyright (c) 2012 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.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 477 matching lines @@
     // If the D-Bus thread is not used, just call the callback on the
     // current thread. Transfer the ownership of |signal| to RunMethod().
     Signal* released_signal = signal.release();
     RunMethod(start_time, iter->second, released_signal);
   }
 
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 void ObjectProxy::RunMethod(base::TimeTicks start_time,
-                            SignalCallback signal_callback,
+                            std::vector<SignalCallback> signal_callbacks,
                             Signal* signal) {
   bus_->AssertOnOriginThread();
 
-  signal_callback.Run(signal);
+  for (std::vector<SignalCallback>::iterator iter = signal_callbacks.begin();
+       iter != signal_callbacks.end(); ++iter)
+    iter->Run(signal);
+
   // Delete the message on the D-Bus thread. See comments in
   // RunResponseCallback().
   bus_->PostTaskToDBusThread(
       FROM_HERE,
       base::Bind(&base::DeletePointer<dbus::Signal>, signal));
 
   // Record time spent for handling the signal.
   UMA_HISTOGRAM_TIMES("DBus.SignalHandleTime",
                       base::TimeTicks::Now() - start_time);
 }
@@ skipping 48 matching lines @@
     ScopedDBusError error;
     bus_->AddMatch(match_rule, error.get());
     if (error.is_set()) {
       LOG(ERROR) << "Failed to add match rule \"" << match_rule << "\". Got " <<
           error.name() << ": " << error.message();
       return false;
     } else {
       // Store the match rule, so that we can remove this in Detach().
       match_rules_.insert(match_rule);
       // Add the signal callback to the method table.
-      method_table_[absolute_signal_name] = signal_callback;
+      method_table_[absolute_signal_name].push_back(signal_callback);
       return true;
     }
   } else {
     // We already have the match rule.
-    method_table_[absolute_signal_name] = signal_callback;
+    method_table_[absolute_signal_name].push_back(signal_callback);
     return true;
   }
 }
 
 bool ObjectProxy::AddMatchRuleWithoutCallback(
     const std::string& match_rule,
     const std::string& absolute_signal_name) {
   DCHECK(!match_rule.empty());
   DCHECK(!absolute_signal_name.empty());
   bus_->AssertOnDBusThread();
@@ skipping 60 matching lines @@
     MessageReader reader(signal.get());
     std::string name, old_owner, new_owner;
     if (reader.PopString(&name) &&
         reader.PopString(&old_owner) &&
         reader.PopString(&new_owner) &&
         name == service_name_) {
       service_name_owner_ = new_owner;
       if (!name_owner_changed_callback_.is_null()) {
         const base::TimeTicks start_time = base::TimeTicks::Now();
         Signal* released_signal = signal.release();
+        std::vector<SignalCallback> callbacks;
+        callbacks.push_back(name_owner_changed_callback_);
         bus_->PostTaskToOriginThread(FROM_HERE,
                                      base::Bind(&ObjectProxy::RunMethod,
                                                 this,
                                                 start_time,
-                                                name_owner_changed_callback_,
+                                                callbacks,
                                                 released_signal));
       }
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus