chrome: dbus: support asynchronous method replies

chrome/browser/chromeos/dbus/proxy_resolution_service_provider_unittest.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.
 //
 // This test is relatively complicated. Here's the summary of what it does:
 //
 // - Set up mock D-Bus related objects to mock out D-Bus calls.
 // - Set up a mock proxy resolver to mock out the proxy resolution.
 // - Create ProxyResolutionServiceProvider by injecting the mocks
 // - Start the service provider.
 // - Request ProxyResolutionServiceProvider to resolve proxy for kSourceURL.
 // - ProxyResolutionServiceProvider will return the result as a signal.
 // - Confirm that we receive the signal and check the contents of the signal.
 
 #include "chrome/browser/chromeos/dbus/proxy_resolution_service_provider.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/message_loop.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_exported_object.h"
 #include "dbus/mock_object_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::Invoke;
@@ skipping 24 matching lines @@
                void(const std::string& source_url,
                     const std::string& signal_interface,
                     const std::string& signal_name,
                     scoped_refptr<dbus::ExportedObject> exported_object));
 };
 
 class ProxyResolutionServiceProviderTest : public testing::Test {
  public:
   ProxyResolutionServiceProviderTest()
       : signal_received_successfully_(false),
-        mock_resolver_(NULL) {
+        mock_resolver_(NULL),
+        response_received_(false) {
   }
 
   virtual void SetUp() {
     // Create a mock bus.
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
     mock_bus_ = new dbus::MockBus(options);
 
     // ShutdownAndBlock() will be called in TearDown().
     EXPECT_CALL(*mock_bus_, ShutdownAndBlock()).WillOnce(Return());
@@ skipping 20 matching lines @@
             Invoke(this,
                    &ProxyResolutionServiceProviderTest::MockSendSignal));
 
     // Create a mock object proxy, with which we call a method of
     // |mock_exported_object_|.
     mock_object_proxy_ =
         new dbus::MockObjectProxy(mock_bus_.get(),
                                   kLibCrosServiceName,
                                   kLibCrosServicePath);
     // |mock_object_proxy_|'s CallMethodAndBlock() will use
-    // CreateResponse() to return responses.
+    // MockCallMethodAndBlock() to return responses.
     EXPECT_CALL(*mock_object_proxy_,
                 CallMethodAndBlock(_, _))
         .WillOnce(Invoke(
             this,
-            &ProxyResolutionServiceProviderTest::CreateResponse));
+            &ProxyResolutionServiceProviderTest::MockCallMethodAndBlock));
     // |mock_object_proxy_|'s ConnectToSignal will use
     // MockConnectToSignal().
     EXPECT_CALL(*mock_object_proxy_,
                 ConnectToSignal(kReturnSignalInterface,
                                 kReturnSignalName,
                                 _, _))
         .WillOnce(Invoke(
             this,
             &ProxyResolutionServiceProviderTest::MockConnectToSignal));
 
@@ skipping 57 matching lines @@
 
  protected:
   bool signal_received_successfully_;
   MockProxyResolver* mock_resolver_;
   scoped_refptr<dbus::MockBus> mock_bus_;
   scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
   scoped_refptr<dbus::MockObjectProxy> mock_object_proxy_;
   scoped_ptr<ProxyResolutionServiceProvider> proxy_resolution_service_;
   dbus::ExportedObject::MethodCallCallback resolve_network_proxy_;
   dbus::ObjectProxy::SignalCallback on_signal_callback_;
+  MessageLoop message_loop_;
+  bool response_received_;
+  scoped_ptr<dbus::Response> response_;
 
  private:
   // Behaves as |mock_exported_object_|'s ExportMethod().
   void MockExportMethod(
       const std::string& interface_name,
       const std::string& method_name,
       dbus::ExportedObject::MethodCallCallback method_callback,
       dbus::ExportedObject::OnExportedCallback on_exported_callback) {
     if (interface_name == kLibCrosServiceInterface &&
         method_name == kResolveNetworkProxy) {
@@ skipping 32 matching lines @@
       writer.AppendString(kReturnEmptyErrorMessage);
       // Send the signal back to the requested signal interface and the
       // signal name.
       exported_object->SendSignal(&signal);
       return;
     }
 
     LOG(ERROR) << "Unexpected source URL: " << source_url;
   }
 
-  // Creates a response for |mock_object_proxy_|.
-  dbus::Response* CreateResponse(
+  // Calls exported method and waits for a response for |mock_object_proxy_|.
+  dbus::Response* MockCallMethodAndBlock(
       dbus::MethodCall* method_call,
       Unused) {
-    if (method_call->GetInterface() ==
-        kLibCrosServiceInterface &&
-        method_call->GetMember() == kResolveNetworkProxy) {
-      // Set the serial number to non-zero, so
-      // dbus_message_new_method_return() won't emit a warning.
-      method_call->SetSerial(1);
-      // Run the callback captured in MockExportMethod(). This will send
-      // a signal, which will be received by |on_signal_callback_|.
-      dbus::Response* response = resolve_network_proxy_.Run(method_call);
-      return response;
+    if (method_call->GetInterface() != kLibCrosServiceInterface ||
+        method_call->GetMember() != kResolveNetworkProxy) {
+      LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
+      return NULL;
     }
+    // Set the serial number to non-zero, so
+    // dbus_message_new_method_return() won't emit a warning.
+    method_call->SetSerial(1);
+    // Run the callback captured in MockExportMethod(). In addition to returning
+    // a response that the caller will ignore, this will send a signal, which
+    // will be received by |on_signal_callback_|.
+    resolve_network_proxy_.Run(
+        method_call,
+        base::Bind(&ProxyResolutionServiceProviderTest::OnResponse,
+                   base::Unretained(this)));
+    // Wait for a response.
+    while (!response_received_) {
+      message_loop_.Run();
+    }
+    // Return response.
+    return response_.release();
+  }
 
-    LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
-    return NULL;
+  // Receives a response and makes it available to MockCallMethodAndBlock().
+  void OnResponse(dbus::Response* response) {
+    response_.reset(response);
+    response_received_ = true;
+    if (message_loop_.is_running()) {
+        message_loop_.Quit();
+    }
   }
 
   // Behaves as |mock_object_proxy_|'s ConnectToSignal().
   void MockConnectToSignal(
       const std::string& interface_name,
       const std::string& signal_name,
       dbus::ObjectProxy::SignalCallback signal_callback,
       dbus::ObjectProxy::OnConnectedCallback connected_callback) {
     // Tell the callback that the object proxy is connected to the signal.
     connected_callback.Run(interface_name, signal_name, true);
@@ skipping 34 matching lines @@
   ASSERT_TRUE(response.get());
   dbus::MessageReader reader(response.get());
   ASSERT_FALSE(reader.HasMoreData());
 
   // Confirm that the signal is received successfully.
   // The contents of the signal are checked in OnSignalReceived().
   ASSERT_TRUE(signal_received_successfully_);
 }
 
 }  // namespace chromeos