Almost done: ApplicationDelegate -> ApplicationImplBase conversion.

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_delegate.h"
-#include "mojo/public/cpp/application/application_impl.h"
+#include "mojo/public/cpp/application/application_impl_base.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/service_provider_impl.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::ApplicationDelegate;
-using mojo::ApplicationImpl;
+using mojo::ApplicationImplBase;
 using mojo::Callback;
 using mojo::ConnectionContext;
 using mojo::InterfaceRequest;
+using mojo::ServiceProviderImpl;
 using mojo::StrongBinding;
 
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
 struct TestContext {
@@ skipping 50 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 ApplicationImplBase {
  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()));
+    if (application_binding().is_bound())
+      application_binding().Close();
+    Bind(application_request.Pass());
   }
 
-  // ApplicationDelegate implementation.
-  bool ConfigureIncomingConnection(
-      mojo::ServiceProviderImpl* service_provider_impl) override {
+  // ApplicationImplBase override.
+  bool OnAcceptConnection(ServiceProviderImpl* service_provider_impl) override {
     service_provider_impl->AddService<TestService>(
         [this](const ConnectionContext& connection_context,
                InterfaceRequest<TestService> request) {
           new TestServiceImpl(context_, request.Pass());
         });
     return true;
   }
 
-  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,
             InterfaceRequest<Application> application_request) override {}
@@ skipping 142 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 {
+class Tester : public ApplicationImplBase, 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()));
+    Bind(application_request.Pass());
   }
 
-  bool ConfigureIncomingConnection(
-      mojo::ServiceProviderImpl* service_provider_impl) override {
+  bool OnAcceptConnection(ServiceProviderImpl* service_provider_impl) override {
     const std::string& remote_url =
         service_provider_impl->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) {
       service_provider_impl->AddService<TestB>(
           [this](const ConnectionContext& connection_context,
                  InterfaceRequest<TestB> test_b_request) {
             new TestBImpl(context_, test_b_request.Pass());
           });
     } else {
       service_provider_impl->AddService<TestA>(
           [this](const ConnectionContext& connection_context,
                  InterfaceRequest<TestA> test_a_request) {
             mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
-            app_->shell()->ConnectToApplication(
+            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;
   }
 
   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; }
 
   // ApplicationManager::Delegate
   GURL ResolveMappings(const GURL& url) override {
@@ skipping 10 matching lines @@
       replacements.SetScheme("file", url::Component(0, 4));
       mapped_url = mapped_url.ReplaceComponents(replacements);
     }
     return mapped_url;
   }
 
  private:
   std::map<GURL, GURL> mappings_;
 };
 
-class TestExternal : public ApplicationDelegate {
+class TestExternal : public ApplicationImplBase {
  public:
   TestExternal() : configure_incoming_connection_called_(false) {}
 
-  void Initialize(ApplicationImpl* app) override {
-    initialize_args_ = app->args();
-    base::MessageLoop::current()->Quit();
-  }
+  void OnInitialize() override { base::MessageLoop::current()->Quit(); }
 
-  bool ConfigureIncomingConnection(
-      mojo::ServiceProviderImpl* service_provider_impl) override {
+  bool OnAcceptConnection(ServiceProviderImpl* service_provider_impl) override {
     configure_incoming_connection_called_ = true;
     base::MessageLoop::current()->Quit();
     return true;
   }
 
-  const std::vector<std::string>& initialize_args() const {
-    return initialize_args_;
-  }
+  const std::vector<std::string>& initialize_args() const { return args(); }
 
   bool configure_incoming_connection_called() const {
     return configure_incoming_connection_called_;
   }
 
  private:
-  std::vector<std::string> initialize_args_;
   bool configure_incoming_connection_called_;
 };
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
@@ skipping 48 matching lines @@
   ApplicationManager am(ApplicationManager::Options(), &test_delegate_);
   GURL test_url("test:test");
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
   TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
-  std::vector<std::string> app_args = loader->GetArgs();
+  std::vector<std::string> app_args = loader->args();
   EXPECT_EQ(0U, app_args.size());
 }
 
 // Confirm that arguments are sent to an application.
 TEST_F(ApplicationManagerTest, Args) {
   ApplicationManager am(ApplicationManager::Options(), &test_delegate_);
   GURL test_url("test:test");
   std::vector<std::string> args;
   args.push_back("test_arg1");
   args.push_back("test_arg2");
   am.SetArgsForURL(args, test_url);
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
   TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
-  std::vector<std::string> app_args = loader->GetArgs();
+  std::vector<std::string> app_args = loader->args();
   ASSERT_EQ(args.size() + 1, app_args.size());
   EXPECT_EQ(args[0], app_args[1]);
   EXPECT_EQ(args[1], app_args[2]);
 }
 
 // Confirm that arguments are sent to an application in the presence of query
 // parameters.
 TEST_F(ApplicationManagerTest, ArgsWithQuery) {
   ApplicationManager am(ApplicationManager::Options(), &test_delegate_);
   GURL test_url("test:test");
   GURL test_url_with_query("test:test?foo=bar");
   std::vector<std::string> args;
   args.push_back("test_arg1");
   am.SetArgsForURL(args, test_url);
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url_with_query, &test_service);
   TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
-  std::vector<std::string> app_args = loader->GetArgs();
+  std::vector<std::string> app_args = loader->args();
   ASSERT_EQ(args.size() + 1, app_args.size());
   EXPECT_EQ(args[0], app_args[1]);
 }
 
 // Confirm that the URL is not duplicated when arguments are added in multiple
 // phases.
 TEST_F(ApplicationManagerTest, ArgsMultipleCalls) {
   ApplicationManager am(ApplicationManager::Options(), &test_delegate_);
   GURL test_url("test:test");
   std::vector<std::string> args1;
   args1.push_back("test_arg1");
   am.SetArgsForURL(args1, test_url);
   std::vector<std::string> args2;
   args2.push_back("test_arg2");
   am.SetArgsForURL(args2, test_url);
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
   TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
-  std::vector<std::string> app_args = loader->GetArgs();
+  std::vector<std::string> app_args = loader->args();
   ASSERT_EQ(args1.size() + args2.size() + 1, app_args.size());
   EXPECT_EQ(args1[0], app_args[1]);
   EXPECT_EQ(args2[0], app_args[2]);
 }
 
 // Confirm that arguments are aggregated through mappings.
 TEST_F(ApplicationManagerTest, ArgsAndMapping) {
   ApplicationManager am(ApplicationManager::Options(), &test_delegate_);
   GURL test_url("test:test");
   GURL test_url2("test:test2");
   test_delegate_.AddMapping(test_url, test_url2);
   std::vector<std::string> args;
   args.push_back("test_arg1");
   args.push_back("test_arg2");
   am.SetArgsForURL(args, test_url);
   std::vector<std::string> args2;
   args2.push_back("test_arg3");
   args2.push_back("test_arg4");
   am.SetArgsForURL(args2, test_url2);
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url2);
   {
     // Connext to the mapped url
     TestServicePtr test_service;
     am.ConnectToService(test_url, &test_service);
     TestClient test_client(test_service.Pass());
     test_client.Test("test");
     loop_.Run();
-    std::vector<std::string> app_args = loader->GetArgs();
+    std::vector<std::string> app_args = loader->args();
     ASSERT_EQ(args.size() + args2.size() + 1, app_args.size());
     EXPECT_EQ(args[0], app_args[1]);
     EXPECT_EQ(args[1], app_args[2]);
     EXPECT_EQ(args2[0], app_args[3]);
     EXPECT_EQ(args2[1], app_args[4]);
   }
   {
     // Connext to the target url
     TestServicePtr test_service;
     am.ConnectToService(test_url2, &test_service);
     TestClient test_client(test_service.Pass());
     test_client.Test("test");
     loop_.Run();
-    std::vector<std::string> app_args = loader->GetArgs();
+    std::vector<std::string> app_args = loader->args();
     ASSERT_EQ(args.size() + args2.size() + 1, app_args.size());
     EXPECT_EQ(args[0], app_args[1]);
     EXPECT_EQ(args[1], app_args[2]);
     EXPECT_EQ(args2[0], app_args[3]);
     EXPECT_EQ(args2[1], app_args[4]);
   }
 }
 
 TEST_F(ApplicationManagerTest, ClientError) {
   test_client_->Test("test");
@@ skipping 196 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