chrome: dbus: support asynchronous method replies

dbus/exported_object.h

 // 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.
 
 #ifndef DBUS_EXPORTED_OBJECT_H_
 #define DBUS_EXPORTED_OBJECT_H_
 #pragma once
 
 #include <dbus/dbus.h>
 
@@ skipping 20 matching lines @@
 // ExportedObject is a ref counted object, to ensure that |this| of the
 // object is alive when callbacks referencing |this| are called.
 class ExportedObject : public base::RefCountedThreadSafe<ExportedObject> {
  public:
   // Client code should use Bus::GetExportedObject() instead of this
   // constructor.
   ExportedObject(Bus* bus,
                  const std::string& service_name,
                  const std::string& object_path);
 
+  // Called to send a response from an exported method. Response* is the
+  // response message. Callers should pass a NULL Response* in the event
+  // of an error that prevents the sending of a response.
+  typedef base::Callback<void (Response*)> ResponseSender;
+
   // Called when an exported method is called. MethodCall* is the request
-  // message.
-  typedef base::Callback<Response* (MethodCall*)> MethodCallCallback;
+  // message. ResponseSender is the callback that should be used to send a
+  // response.
+  typedef base::Callback<void (MethodCall*, ResponseSender)> MethodCallCallback;
 
   // Called when method exporting is done.
   // Parameters:
   // - the interface name.
   // - the method name.
   // - whether exporting was successful or not.
   typedef base::Callback<void (const std::string&, const std::string&, bool)>
       OnExportedCallback;
 
   // Exports the method specified by |interface_name| and |method_name|,
@@ skipping 63 matching lines @@
   // Handles the incoming request messages and dispatches to the exported
   // methods.
   DBusHandlerResult HandleMessage(DBusConnection* connection,
                                   DBusMessage* raw_message);
 
   // Runs the method. Helper function for HandleMessage().
   void RunMethod(MethodCallCallback method_call_callback,
                  MethodCall* method_call,
                  base::TimeTicks start_time);
 
-  // Called on completion of the method run from RunMethod().
+  // Callback invoked by service provider to send a response to a method call.
+  // Can be called immediately from a MethodCallCallback to implement a
+  // synchronous service or called later to implement an asynchronous service.
+  void SendResponse(base::TimeTicks start_time,
+                    MethodCall* method_call,
+                    Response* response);
+
+  // Called on completion of the method run from SendResponse().
   // Takes ownership of |method_call| and |response|.
   void OnMethodCompleted(MethodCall* method_call,
                          Response* response,
                          base::TimeTicks start_time);
 
   // Called when the object is unregistered.
   void OnUnregistered(DBusConnection* connection);
 
   // Redirects the function call to HandleMessage().
   static DBusHandlerResult HandleMessageThunk(DBusConnection* connection,
@@ skipping 11 matching lines @@
 
   // The method table where keys are absolute method names (i.e. interface
   // name + method name), and values are the corresponding callbacks.
   typedef std::map<std::string, MethodCallCallback> MethodTable;
   MethodTable method_table_;
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_EXPORTED_OBJECT_H_