dbus: Stop accessing ObjectProxy::name_owner_changed_callback_ on the D-Bus thread

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/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 167 matching lines @@
       base::Bind(&ObjectProxy::ConnectToSignalInternal,
                  this,
                  interface_name,
                  signal_name,
                  signal_callback),
       base::Bind(on_connected_callback,
                  interface_name,
                  signal_name));
 }
 
+void ObjectProxy::SetNameOwnerChangedCallback(
+    NameOwnerChangedCallback callback) {
+  bus_->AssertOnOriginThread();
+
+  name_owner_changed_callback_ = callback;
+}
+
 void ObjectProxy::Detach() {
   bus_->AssertOnDBusThread();
 
   if (filter_added_) {
     if (!bus_->RemoveFilterFunction(&ObjectProxy::HandleMessageThunk, this)) {
       LOG(ERROR) << "Failed to remove filter function";
     }
   }
 
   for (std::set<std::string>::iterator iter = match_rules_.begin();
@@ skipping 202 matching lines @@
 
   // Try getting the current name owner. It's not guaranteed that we can get
   // the name owner at this moment, as the service may not yet be started. If
   // that's the case, we'll get the name owner via NameOwnerChanged signal,
   // as soon as the service is started.
   UpdateNameOwnerAndBlock();
 
   return success;
 }
 
-void ObjectProxy::SetNameOwnerChangedCallback(SignalCallback callback) {
-  bus_->AssertOnOriginThread();
-
-  name_owner_changed_callback_ = callback;
-}
-
 DBusHandlerResult ObjectProxy::HandleMessage(
     DBusConnection* connection,
     DBusMessage* raw_message) {
   bus_->AssertOnDBusThread();
 
   if (dbus_message_get_type(raw_message) != DBUS_MESSAGE_TYPE_SIGNAL)
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   // raw_message will be unrefed on exit of the function. Increment the
   // reference so we can use it in Signal.
@@ skipping 187 matching lines @@
   if (signal->GetMember() == kNameOwnerChangedMember &&
       signal->GetInterface() == kDBusSystemObjectInterface &&
       signal->GetSender() == kDBusSystemObjectAddress) {
     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_->GetOriginTaskRunner()->PostTask(
-            FROM_HERE,
-            base::Bind(&ObjectProxy::RunMethod,
-                       this,
-                       start_time,
-                       callbacks,
-                       released_signal));
-      }
+      bus_->GetOriginTaskRunner()->PostTask(
+          FROM_HERE,
+          base::Bind(&ObjectProxy::RunNameOwnerChangedCallback,
+                     this, old_owner, new_owner));
     }
   }
 
   // Always return unhandled to let other object proxies handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
+void ObjectProxy::RunNameOwnerChangedCallback(const std::string& old_owner,
+                                              const std::string& new_owner) {
+  bus_->AssertOnOriginThread();
+  if (!name_owner_changed_callback_.is_null())
+    name_owner_changed_callback_.Run(old_owner, new_owner);
+}
+
 }  // namespace dbus