Remove associated interface registration from ChannelProxy

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 830 matching lines @@
 
 class ListenerWithIndirectProxyAssociatedInterface
     : public IPC::Listener,
       public IPC::mojom::IndirectTestDriver,
       public IPC::mojom::PingReceiver {
  public:
   ListenerWithIndirectProxyAssociatedInterface()
       : driver_binding_(this), ping_receiver_binding_(this) {}
   ~ListenerWithIndirectProxyAssociatedInterface() override {}
 
+  // IPC::Listener:
   bool OnMessageReceived(const IPC::Message& message) override { return true; }
 
-  void RegisterInterfaceFactory(IPC::ChannelProxy* proxy) {
-    proxy->AddAssociatedInterface(
-        base::Bind(&ListenerWithIndirectProxyAssociatedInterface::BindRequest,
-                   base::Unretained(this)));
+  void OnAssociatedInterfaceRequest(
+      const std::string& interface_name,
+      mojo::ScopedInterfaceEndpointHandle handle) override {
+    DCHECK(!driver_binding_.is_bound());
+    DCHECK_EQ(interface_name, IPC::mojom::IndirectTestDriver::Name_);
+    IPC::mojom::IndirectTestDriverAssociatedRequest request;
+    request.Bind(std::move(handle));
+    driver_binding_.Bind(std::move(request));
   }
 
   void set_ping_handler(const base::Closure& handler) {
     ping_handler_ = handler;
   }
 
  private:
   // IPC::mojom::IndirectTestDriver:
   void GetPingReceiver(
       IPC::mojom::PingReceiverAssociatedRequest request) override {
     ping_receiver_binding_.Bind(std::move(request));
   }
 
   // IPC::mojom::PingReceiver:
   void Ping(const PingCallback& callback) override {
     callback.Run();
     ping_handler_.Run();
   }
 
-  void BindRequest(IPC::mojom::IndirectTestDriverAssociatedRequest request) {
-    DCHECK(!driver_binding_.is_bound());
-    driver_binding_.Bind(std::move(request));
-  }
-
   mojo::AssociatedBinding<IPC::mojom::IndirectTestDriver> driver_binding_;
   mojo::AssociatedBinding<IPC::mojom::PingReceiver> ping_receiver_binding_;
 
   base::Closure ping_handler_;
 };
 
 TEST_F(IPCChannelProxyMojoTest, ProxyThreadAssociatedInterfaceIndirect) {
   // Tests that we can pipeline interface requests and subsequent messages
   // targeting proxy thread bindings, and the channel will still dispatch
   // messages appropriately.
 
   Init("ProxyThreadAssociatedInterfaceIndirectClient");
 
   ListenerWithIndirectProxyAssociatedInterface listener;
   CreateProxy(&listener);
-  listener.RegisterInterfaceFactory(proxy());
   RunProxy();
 
   base::RunLoop loop;
   listener.set_ping_handler(loop.QuitClosure());
   loop.Run();
 
   EXPECT_TRUE(WaitForClientShutdown());
 
   DestroyProxy();
 }
@@ skipping 25 matching lines @@
 
 class ListenerWithSyncAssociatedInterface
     : public IPC::Listener,
       public IPC::mojom::SimpleTestDriver {
  public:
   ListenerWithSyncAssociatedInterface() : binding_(this) {}
   ~ListenerWithSyncAssociatedInterface() override {}
 
   void set_sync_sender(IPC::Sender* sync_sender) { sync_sender_ = sync_sender; }
 
-  void RegisterInterfaceFactory(IPC::ChannelProxy* proxy) {
-    proxy->AddAssociatedInterface(
-        base::Bind(&ListenerWithSyncAssociatedInterface::BindRequest,
-                   base::Unretained(this)));
-  }
-
   void RunUntilQuitRequested() {
     base::RunLoop loop;
     quit_closure_ = loop.QuitClosure();
     loop.Run();
   }
 
   void CloseBinding() { binding_.Close(); }
 
   void set_response_value(int32_t response) {
     response_value_ = response;
@@ skipping 24 matching lines @@
     EXPECT_TRUE(message.is_sync());
     EXPECT_TRUE(message.should_unblock());
     std::unique_ptr<IPC::Message> reply(
         IPC::SyncMessage::GenerateReply(&message));
     reply->WriteInt(response_value_);
     DCHECK(sync_sender_);
     EXPECT_TRUE(sync_sender_->Send(reply.release()));
     return true;
   }
 
+  void OnAssociatedInterfaceRequest(
+      const std::string& interface_name,
+      mojo::ScopedInterfaceEndpointHandle handle) override {
+    DCHECK(!binding_.is_bound());
+    DCHECK_EQ(interface_name, IPC::mojom::SimpleTestDriver::Name_);
+
+    IPC::mojom::SimpleTestDriverAssociatedRequest request;
+    request.Bind(std::move(handle));
+    binding_.Bind(std::move(request));
+  }
+
   void BindRequest(IPC::mojom::SimpleTestDriverAssociatedRequest request) {
     DCHECK(!binding_.is_bound());
     binding_.Bind(std::move(request));
   }
 
   IPC::Sender* sync_sender_ = nullptr;
   int32_t next_expected_value_ = 0;
   int32_t response_value_ = 0;
   base::Closure quit_closure_;
 
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SyncReplyReader);
 };
 
 TEST_F(IPCChannelProxyMojoTest, SyncAssociatedInterface) {
   Init("SyncAssociatedInterface");
 
   ListenerWithSyncAssociatedInterface listener;
   CreateProxy(&listener);
   listener.set_sync_sender(proxy());
-  listener.RegisterInterfaceFactory(proxy());
   RunProxy();
 
   // Run the client's simple sanity check to completion.
   listener.RunUntilQuitRequested();
 
   // Verify that we can send a sync IPC and service an incoming sync request
   // while waiting on it
   listener.set_response_value(42);
   IPC::mojom::SimpleTestClientAssociatedPtr client;
   proxy()->GetRemoteAssociatedInterface(&client);
@@ skipping 23 matching lines @@
 }
 
 class SimpleTestClientImpl : public IPC::mojom::SimpleTestClient,
                              public IPC::Listener {
  public:
   SimpleTestClientImpl() : binding_(this) {}
 
   void set_driver(IPC::mojom::SimpleTestDriver* driver) { driver_ = driver; }
   void set_sync_sender(IPC::Sender* sync_sender) { sync_sender_ = sync_sender; }
 
-  void BindRequest(IPC::mojom::SimpleTestClientAssociatedRequest request) {
-    DCHECK(!binding_.is_bound());
-    binding_.Bind(std::move(request));
-  }
-
   void WaitForValueRequest() {
     run_loop_.reset(new base::RunLoop);
     run_loop_->Run();
   }
 
   void UseSyncSenderForRequest(bool use_sync_sender) {
     use_sync_sender_ = use_sync_sender;
   }
 
  private:
@@ skipping 23 matching lines @@
     std::unique_ptr<IPC::Message> reply(
         IPC::SyncMessage::GenerateReply(&message));
     reply->WriteInt(response);
     EXPECT_TRUE(sync_sender_->Send(reply.release()));
 
     DCHECK(run_loop_);
     run_loop_->Quit();
     return true;
   }
 
+  void OnAssociatedInterfaceRequest(
+      const std::string& interface_name,
+      mojo::ScopedInterfaceEndpointHandle handle) override {
+    DCHECK(!binding_.is_bound());
+    DCHECK_EQ(interface_name, IPC::mojom::SimpleTestClient::Name_);
+
+    IPC::mojom::SimpleTestClientAssociatedRequest request;
+    request.Bind(std::move(handle));
+    binding_.Bind(std::move(request));
+  }
+
   bool use_sync_sender_ = false;
   mojo::AssociatedBinding<IPC::mojom::SimpleTestClient> binding_;
   IPC::Sender* sync_sender_ = nullptr;
   IPC::mojom::SimpleTestDriver* driver_ = nullptr;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleTestClientImpl);
 };
 
 DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT_WITH_CUSTOM_FIXTURE(SyncAssociatedInterface,
                                                         ChannelProxyClient) {
   SimpleTestClientImpl client_impl;
   CreateProxy(&client_impl);
   client_impl.set_sync_sender(proxy());
-  proxy()->AddAssociatedInterface(base::Bind(&SimpleTestClientImpl::BindRequest,
-                                             base::Unretained(&client_impl)));
   RunProxy();
 
   IPC::mojom::SimpleTestDriverAssociatedPtr driver;
   proxy()->GetRemoteAssociatedInterface(&driver);
   client_impl.set_driver(driver.get());
 
   // Simple sync message sanity check.
   driver->ExpectValue(42);
   int32_t expected_value = 0;
   EXPECT_TRUE(driver->GetExpectedValue(&expected_value));
@@ skipping 262 matching lines @@
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace