Support early associated interface binding on ChannelMojo

ipc/ipc_channel_mojo_unittest.cc

 // Copyright 2014 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 "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 740 matching lines @@
 };
 
 class IPCChannelProxyMojoTest : public IPCChannelMojoTestBase {
  public:
   void InitWithMojo(const std::string& client_name) {
     IPCChannelMojoTestBase::InitWithMojo(client_name);
     runner_.reset(new ChannelProxyRunner(TakeHandle(), true));
   }
   void CreateProxy(IPC::Listener* listener) { runner_->CreateProxy(listener); }
   void RunProxy() { runner_->RunProxy(); }
+  void DestroyProxy() {
+    runner_.reset();
+    base::RunLoop().RunUntilIdle();
+  }
 
   IPC::ChannelProxy* proxy() { return runner_->proxy(); }
 
  private:
   base::MessageLoop message_loop_;
   std::unique_ptr<ChannelProxyRunner> runner_;
 };
 
 class ListenerWithSimpleProxyAssociatedInterface
     : public IPC::Listener,
@@ skipping 30 matching lines @@
 
  private:
   // IPC::mojom::SimpleTestDriver:
   void ExpectString(const mojo::String& str) override {
     next_expected_string_ = str;
   }
 
   void RequestQuit(const RequestQuitCallback& callback) override {
     received_quit_ = true;
     callback.Run();
+    binding_.Close();
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void BindRequest(IPC::mojom::SimpleTestDriverAssociatedRequest request) {
     DCHECK(!binding_.is_bound());
     binding_.Bind(std::move(request));
   }
 
   std::string next_expected_string_;
   int num_messages_received_ = 0;
@@ skipping 10 matching lines @@
   ListenerWithSimpleProxyAssociatedInterface listener;
   CreateProxy(&listener);
   listener.RegisterInterfaceFactory(proxy());
   RunProxy();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(WaitForClientShutdown());
   EXPECT_TRUE(listener.received_all_messages());
 
-  base::RunLoop().RunUntilIdle();
+  DestroyProxy();
 }
 
 class ChannelProxyClient {
  public:
   void Init(mojo::ScopedMessagePipeHandle handle) {
     runner_.reset(new ChannelProxyRunner(std::move(handle), false));
   }
   void CreateProxy(IPC::Listener* listener) { runner_->CreateProxy(listener); }
   void RunProxy() { runner_->RunProxy(); }
+  void DestroyProxy() {
+    runner_.reset();
+    base::RunLoop().RunUntilIdle();
+  }
 
   IPC::ChannelProxy* proxy() { return runner_->proxy(); }
 
  private:
   base::MessageLoop message_loop_;
   std::unique_ptr<ChannelProxyRunner> runner_;
 };
 
-class ListenerThatWaitsForConnect : public IPC::Listener {
+class DummyListener : public IPC::Listener {
  public:
-  explicit ListenerThatWaitsForConnect(const base::Closure& connect_handler)
-      : connect_handler_(connect_handler) {}
-
   // IPC::Listener
   bool OnMessageReceived(const IPC::Message& message) override { return true; }
-  void OnChannelConnected(int32_t) override { connect_handler_.Run(); }
-
- private:
-  base::Closure connect_handler_;
 };
 
 DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(ProxyThreadAssociatedInterfaceClient,
                                     ChannelProxyClient) {
-  base::RunLoop connect_loop;
-  ListenerThatWaitsForConnect listener(connect_loop.QuitClosure());
+  DummyListener listener;
   CreateProxy(&listener);
   RunProxy();
-  connect_loop.Run();
 
   // Send a bunch of interleaved messages, alternating between the associated
   // interface and a legacy IPC::Message.
   IPC::mojom::SimpleTestDriverAssociatedPtr driver;
   proxy()->GetRemoteAssociatedInterface(&driver);
   for (int i = 0; i < ListenerWithSimpleProxyAssociatedInterface::kNumMessages;
        ++i) {
     std::string str = base::StringPrintf("Hello! %d", i);
     driver->ExpectString(str);
     SendString(proxy(), str);
   }
   driver->RequestQuit(base::MessageLoop::QuitWhenIdleClosure());
   base::RunLoop().Run();
+
+  DestroyProxy();
 }
 
 #if defined(OS_POSIX)
 
 class ListenerThatExpectsFile : public IPC::Listener {
  public:
   ListenerThatExpectsFile() : sender_(NULL) {}
 
   ~ListenerThatExpectsFile() override {}
 
@@ skipping 144 matching lines @@
   Connect(&listener);
 
   base::MessageLoop::current()->Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace