chrome: dbus: support asynchronous method replies

dbus/exported_object.cc

 // Copyright (c) 2011 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/exported_object.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 206 matching lines @@
   const base::TimeTicks start_time = base::TimeTicks::Now();
   if (bus_->HasDBusThread()) {
     // Post a task to run the method in the origin thread.
     bus_->PostTaskToOriginThread(FROM_HERE,
                                  base::Bind(&ExportedObject::RunMethod,
                                             this,
                                             iter->second,
                                             method_call.release(),
                                             start_time));
   } else {
-    // If the D-Bus thread is not used, just call the method directly. We
-    // don't need the complicated logic to wait for the method call to be
-    // complete.
-    // |response| will be deleted in OnMethodCompleted().
-    Response* response = iter->second.Run(method_call.get());
-    OnMethodCompleted(method_call.release(), response, start_time);
+    // If the D-Bus thread is not used, just call the method directly.
+    iter->second.Run(method_call.get(),
+                     base::Bind(&ExportedObject::SendResponse,
+                                this,
+                                start_time,
+                                method_call.release()));
   }
 
   // It's valid to say HANDLED here, and send a method response at a later
   // time from OnMethodCompleted() asynchronously.
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 void ExportedObject::RunMethod(MethodCallCallback method_call_callback,
                                MethodCall* method_call,
                                base::TimeTicks start_time) {
   bus_->AssertOnOriginThread();
+  method_call_callback.Run(method_call,
+                           base::Bind(&ExportedObject::SendResponse,
+                                      this,
+                                      start_time,
+                                      method_call));
+}
 
-  Response* response = method_call_callback.Run(method_call);
-  bus_->PostTaskToDBusThread(FROM_HERE,
-                             base::Bind(&ExportedObject::OnMethodCompleted,
-                                        this,
-                                        method_call,
-                                        response,
-                                        start_time));
+void ExportedObject::SendResponse(base::TimeTicks start_time,
+                                  MethodCall* method_call,
+                                  Response* response) {
+  DCHECK(method_call);
+  if (bus_->HasDBusThread()) {
+    bus_->PostTaskToDBusThread(FROM_HERE,
+                               base::Bind(&ExportedObject::OnMethodCompleted,
+                                          this,
+                                          method_call,
+                                          response,
+                                          start_time));
+  } else {
+    OnMethodCompleted(method_call, response, start_time);
+  }
 }
 
 void ExportedObject::OnMethodCompleted(MethodCall* method_call,
                                        Response* response,
                                        base::TimeTicks start_time) {
   bus_->AssertOnDBusThread();
   scoped_ptr<MethodCall> method_call_deleter(method_call);
   scoped_ptr<Response> response_deleter(response);
 
   // Record if the method call is successful, or not. 1 if successful.
@@ skipping 36 matching lines @@
   return self->HandleMessage(connection, raw_message);
 }
 
 void ExportedObject::OnUnregisteredThunk(DBusConnection *connection,
                                          void* user_data) {
   ExportedObject* self = reinterpret_cast<ExportedObject*>(user_data);
   return self->OnUnregistered(connection);
 }
 
 }  // namespace dbus