ApplicationConnection devolution, part 2.3.

shell/application_manager/application_manager_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 "shell/application_manager/application_manager.h"
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/connect.h"
-#include "mojo/public/cpp/application/interface_factory.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using mojo::Application;
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::ApplicationImpl;
 using mojo::Callback;
 using mojo::ConnectionContext;
-using mojo::InterfaceFactory;
 using mojo::InterfaceRequest;
 using mojo::StrongBinding;
 
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
@@ skipping 51 matching lines @@
                    base::Bind(&TestClient::AckTest, base::Unretained(this)));
   }
 
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClient);
 };
 
 class TestApplicationLoader : public ApplicationLoader,
-                              public ApplicationDelegate,
-                              public InterfaceFactory<TestService> {
+                              public ApplicationDelegate {
  public:
   TestApplicationLoader() : context_(nullptr), num_loads_(0) {}
 
   ~TestApplicationLoader() override {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset();
   }
 
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
   const std::vector<std::string>& GetArgs() const { return test_app_->args(); }
 
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
     ++num_loads_;
     test_app_.reset(new ApplicationImpl(this, application_request.Pass()));
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
-    connection->AddService(this);
+    connection->GetServiceProviderImpl().AddService<TestService>(
+        [this](const ConnectionContext& connection_context,
+               InterfaceRequest<TestService> request) {
+          new TestServiceImpl(context_, request.Pass());
+        });
     return true;
   }
 
-  // InterfaceFactory implementation.
-  void Create(const ConnectionContext& connection_context,
-              InterfaceRequest<TestService> request) override {
-    new TestServiceImpl(context_, request.Pass());
-  }
-
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
 class ClosingApplicationLoader : public ApplicationLoader {
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
@@ skipping 143 matching lines @@
  private:
   void B(const Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
   StrongBinding<TestB> binding_;
 };
 
-class Tester : public ApplicationDelegate,
-               public ApplicationLoader,
-               public InterfaceFactory<TestA>,
-               public InterfaceFactory<TestB> {
+class Tester : public ApplicationDelegate, public ApplicationLoader {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
     app_.reset(new ApplicationImpl(this, application_request.Pass()));
   }
 
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     const std::string& remote_url =
         connection->GetServiceProviderImpl().connection_context().remote_url;
     if (!requestor_url_.empty() && requestor_url_ != remote_url) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->Quit();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
-    if (remote_url == kTestAURLString)
-      connection->AddService<TestB>(this);
-    else
-      connection->AddService<TestA>(this);
+    if (remote_url == kTestAURLString) {
+      connection->GetServiceProviderImpl().AddService<TestB>(
+          [this](const ConnectionContext& connection_context,
+                 InterfaceRequest<TestB> test_b_request) {
+            new TestBImpl(context_, test_b_request.Pass());
+          });
+    } else {
+      connection->GetServiceProviderImpl().AddService<TestA>(
+          [this](const ConnectionContext& connection_context,
+                 InterfaceRequest<TestA> test_a_request) {
+            mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
+            app_->shell()->ConnectToApplication(
+                kTestBURLString, GetProxy(&incoming_sp_handle), nullptr);
+            a_bindings_.push_back(new TestAImpl(
+                incoming_sp_handle.Pass(), context_, test_a_request.Pass()));
+          });
+    }
     return true;
   }
 
-  void Create(const ConnectionContext& connection_context,
-              InterfaceRequest<TestA> request) override {
-    mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
-    app_->shell()->ConnectToApplication(kTestBURLString,
-                                        GetProxy(&incoming_sp_handle), nullptr);
-    a_bindings_.push_back(
-        new TestAImpl(incoming_sp_handle.Pass(), context_, request.Pass()));
-  }
-
-  void Create(const ConnectionContext& connection_context,
-              InterfaceRequest<TestB> request) override {
-    new TestBImpl(context_, request.Pass());
-  }
-
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestDelegate : public ApplicationManager::Delegate {
  public:
   void AddMapping(const GURL& from, const GURL& to) { mappings_[from] = to; }
 
@@ skipping 433 matching lines @@
   bool called = false;
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell