Rename ApplicationDelegate to ShellClient

mojo/shell/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 "mojo/shell/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 "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/package_manager.h"
-#include "mojo/shell/public/cpp/application_connection.h"
-#include "mojo/shell/public/cpp/application_delegate.h"
 #include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
+#include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/interfaces/service_provider.mojom.h"
 #include "mojo/shell/test.mojom.h"
 #include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace test {
 
 const char kTestURLString[] = "test:testService";
@@ skipping 54 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 ShellClient,
                               public InterfaceFactory<TestService> {
  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 GURL& last_requestor_url() const { return last_requestor_url_; }
 
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
             InterfaceRequest<mojom::Application> application_request) override {
     ++num_loads_;
     test_app_.reset(new ApplicationImpl(this, std::move(application_request)));
   }
 
-  // ApplicationDelegate implementation.
-  bool AcceptConnection(ApplicationConnection* connection) override {
+  // mojo::ShellClient implementation.
+  bool AcceptConnection(Connection* connection) override {
     connection->AddService<TestService>(this);
     last_requestor_url_ = GURL(connection->GetRemoteApplicationURL());
     return true;
   }
 
   // InterfaceFactory<TestService> implementation.
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, std::move(request));
   }
 
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   GURL last_requestor_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
@@ skipping 129 matching lines @@
   void CallCFromB() override {
     b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void Quit() {
     base::MessageLoop::current()->QuitWhenIdle();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
-  scoped_ptr<ApplicationConnection> connection_;
+  scoped_ptr<Connection> connection_;
   TesterContext* test_context_;
   TestBPtr b_;
   StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
-  TestBImpl(ApplicationConnection* connection,
+  TestBImpl(Connection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestB> request)
       : test_context_(test_context), binding_(this, std::move(request)) {
     connection->ConnectToService(&c_);
   }
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 11 matching lines @@
     c_->C(callback);
   }
 
   TesterContext* test_context_;
   TestCPtr c_;
   StrongBinding<TestB> binding_;
 };
 
 class TestCImpl : public TestC {
  public:
-  TestCImpl(ApplicationConnection* connection,
+  TestCImpl(Connection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestC> request)
       : test_context_(test_context), binding_(this, std::move(request)) {}
 
   ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
 
  private:
   void C(const Callback<void()>& callback) override {
     test_context_->IncrementNumCCalls();
     callback.Run();
   }
 
   TesterContext* test_context_;
   StrongBinding<TestC> binding_;
 };
 
-class Tester : public ApplicationDelegate,
+class Tester : public ShellClient,
                public ApplicationLoader,
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
   void Load(const GURL& url,
             InterfaceRequest<mojom::Application> application_request) override {
     app_.reset(new ApplicationImpl(this, std::move(application_request)));
   }
 
-  bool AcceptConnection(ApplicationConnection* connection) override {
+  bool AcceptConnection(Connection* connection) override {
     if (!requestor_url_.empty() &&
         requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<TestA> request) override {
     a_bindings_.push_back(
         new TestAImpl(app_.get(), context_, std::move(request), this));
   }
 
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<TestB> request) override {
     new TestBImpl(connection, context_, std::move(request));
   }
 
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<TestC> request) override {
     new TestCImpl(connection, context_, std::move(request));
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
@@ skipping 231 matching lines @@
 
   // A different identity because the domain is different.
   ConnectToService(application_manager_.get(),
                    GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo