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();

[Paweł Hajdan Jr., 2011/11/30 08:46:11]

This is generally an anti-pattern. Could you only Run the MessageLoop once and
quit it once? Running ML in a loop is harder to debug, and suggests you're not
waiting for an event. Instead of checking the condition in the loop, you should
Quit the loop in the place where you currently set response_received_ to true.

[Vince Laviano, 2011/11/30 23:47:48]

http://codereview.chromium.org/8764006/

+    }
+    // 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