Eliminate outgoing InterfaceProvider

services/shell/tests/connect/connect_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 66 matching lines @@
 
  protected:
   std::unique_ptr<Connection> ConnectTo(Connector::ConnectParams* params) {
     std::unique_ptr<Connection> connection = connector()->Connect(params);
     base::RunLoop loop;
     connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
     loop.Run();
     return connection;
   }
 
-  void set_ping_callback(const base::Closure& callback) {
-    ping_callback_ = callback;
-  }
-
   void CompareConnectionState(
       const std::string& connection_local_name,
       const std::string& connection_remote_name,
       const std::string& connection_remote_userid,
       const std::string& initialize_local_name,
       const std::string& initialize_userid) {
     EXPECT_EQ(connection_local_name, connection_state_->connection_local_name);
     EXPECT_EQ(connection_remote_name,
               connection_state_->connection_remote_name);
     EXPECT_EQ(connection_remote_userid,
               connection_state_->connection_remote_userid);
     EXPECT_EQ(initialize_local_name, connection_state_->initialize_local_name);
     EXPECT_EQ(initialize_userid, connection_state_->initialize_userid);
   }
 
  private:
+  class TestService : public test::ServiceTestClient {
+   public:
+    explicit TestService(ConnectTest* connect_test)
+        : test::ServiceTestClient(connect_test),
+          connect_test_(connect_test) {}
+    ~TestService() override {}
+
+   private:
+    bool OnConnect(Connection* connection) override {
+      connection->AddInterface<test::mojom::ExposedInterface>(connect_test_);
+      return true;
+    }
+
+    ConnectTest* connect_test_;
+
+    DISALLOW_COPY_AND_ASSIGN(TestService);
+  };
+
   // test::ServiceTest:
   void SetUp() override {
     test::ServiceTest::SetUp();
     // We need to connect to the package first to force the shell to read the
     // package app's manifest and register aliases for the applications it
     // provides.
     test::mojom::ConnectTestServicePtr root_service;
     std::unique_ptr<Connection> connection =
         connector()->Connect(kTestPackageName);
     connection->GetInterface(&root_service);
     base::RunLoop run_loop;
     std::string root_name;
     root_service->GetTitle(
         base::Bind(&ReceiveOneString, &root_name, &run_loop));
     run_loop.Run();
   }
+  std::unique_ptr<Service> CreateService() override {
+    return base::WrapUnique(new TestService(this));
+  }
 
   // InterfaceFactory<test::mojom::ExposedInterface>:
   void Create(const Identity& remote_identity,
               test::mojom::ExposedInterfaceRequest request) override {
     bindings_.AddBinding(this, std::move(request));
   }
 
   void ConnectionAccepted(test::mojom::ConnectionStatePtr state) override {
     connection_state_ = std::move(state);
-    ping_callback_.Run();
   }
 
-  base::Closure ping_callback_;
   test::mojom::ConnectionStatePtr connection_state_;
 
   mojo::BindingSet<test::mojom::ExposedInterface> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectTest);
 };
 
 // Ensure the connection was properly established and that a round trip
 // method call/response is completed.
 TEST_F(ConnectTest, Connect) {
@@ skipping 247 matching lines @@
   {
     base::RunLoop loop;
     inherit_connection->AddConnectionCompletedClosure(
         base::Bind(&QuitLoop, &loop));
     loop.Run();
     EXPECT_EQ(inherit_connection->GetRemoteIdentity().user_id(),
               connection->GetRemoteIdentity().user_id());
   }
 }
 
-// Tests that we can expose an interface to targets on outbound connections.
-TEST_F(ConnectTest, LocalInterface) {
-  // Connect to a standalone application.
-  {
-    test::mojom::ConnectTestServicePtr service;
-    std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
-    connection->GetInterface(&service);
-    connection->AddInterface<test::mojom::ExposedInterface>(this);
-
-    {
-      base::RunLoop run_loop;
-      EXPECT_TRUE(connection->IsPending());
-      EXPECT_EQ(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
-      connection->AddConnectionCompletedClosure(
-          base::Bind(&QuitLoop, &run_loop));
-      run_loop.Run();
-      EXPECT_FALSE(connection->IsPending());
-    }
-
-    {
-      base::RunLoop run_loop;
-      set_ping_callback(base::Bind(&QuitLoop, &run_loop));
-      run_loop.Run();
-      CompareConnectionState(
-          kTestAppName, test_name(), test_userid(), kTestAppName,
-          connection->GetRemoteIdentity().user_id());
-    }
-  }
-
-  // Connect to an application provided by a package.
-  {
-    test::mojom::ConnectTestServicePtr service_a;
-    std::unique_ptr<Connection> connection =
-        connector()->Connect(kTestAppAName);
-    connection->GetInterface(&service_a);
-    connection->AddInterface<test::mojom::ExposedInterface>(this);
-
-    {
-      base::RunLoop run_loop;
-      EXPECT_TRUE(connection->IsPending());
-      EXPECT_EQ(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
-      connection->AddConnectionCompletedClosure(
-          base::Bind(&QuitLoop, &run_loop));
-      run_loop.Run();
-      EXPECT_FALSE(connection->IsPending());
-    }
-
-    {
-      base::RunLoop run_loop;
-      set_ping_callback(base::Bind(&QuitLoop, &run_loop));
-      run_loop.Run();
-      CompareConnectionState(
-          kTestAppAName, test_name(), test_userid(), kTestAppAName,
-          connection->GetRemoteIdentity().user_id());
-    }
-
-  }
-}
-
 }  // namespace shell