Rename ApplicationDelegate to ShellClient

mojo/shell/application_package_apptest.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 <utility>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 // the package's manifest and are thus registered with the PackageManager.
 
 namespace mojo {
 namespace shell {
 namespace {
 
 using GetNameCallback =
     test::mojom::ApplicationPackageApptestService::GetNameCallback;
 
 class ProvidedApplicationDelegate
-    : public ApplicationDelegate,
+    : public ShellClient,
       public InterfaceFactory<test::mojom::ApplicationPackageApptestService>,
       public test::mojom::ApplicationPackageApptestService,
       public base::SimpleThread {
  public:
   ProvidedApplicationDelegate(const std::string& name,
                               InterfaceRequest<mojom::Application> request,
                               const Callback<void()>& destruct_callback)
       : base::SimpleThread(name),
         name_(name),
         request_(std::move(request)),
         destruct_callback_(destruct_callback) {
     Start();
   }
   ~ProvidedApplicationDelegate() override {
     Join();
     destruct_callback_.Run();
   }
 
  private:
-  // ApplicationDelegate:
+  // mojo::ShellClient:
   void Initialize(Shell* shell, const std::string& url, uint32_t id) override {}
-  bool AcceptConnection(ApplicationConnection* connection) override {
+  bool AcceptConnection(Connection* connection) override {
     connection->AddService<test::mojom::ApplicationPackageApptestService>(this);
     return true;
   }
 
   // InterfaceFactory<test::mojom::ApplicationPackageApptestService>:
   void Create(
-      ApplicationConnection* connection,
+      Connection* connection,
       InterfaceRequest<test::mojom::ApplicationPackageApptestService> request)
           override {
     bindings_.AddBinding(this, std::move(request));
   }
 
   // test::mojom::ApplicationPackageApptestService:
   void GetName(const GetNameCallback& callback) override {
     callback.Run(name_);
   }
 
   // base::SimpleThread:
   void Run() override {
     ApplicationRunner(this).Run(request_.PassMessagePipe().release().value(),
                                 false);
     delete this;
   }
 
   const std::string name_;
   InterfaceRequest<mojom::Application> request_;
   const Callback<void()> destruct_callback_;
   WeakBindingSet<test::mojom::ApplicationPackageApptestService> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ProvidedApplicationDelegate);
 };
 
 class ApplicationPackageApptestDelegate
-    : public ApplicationDelegate,
+    : public ShellClient,
       public InterfaceFactory<mojom::ContentHandler>,
       public InterfaceFactory<test::mojom::ApplicationPackageApptestService>,
       public mojom::ContentHandler,
       public test::mojom::ApplicationPackageApptestService {
  public:
   ApplicationPackageApptestDelegate() {}
   ~ApplicationPackageApptestDelegate() override {}
 
  private:
-  // ApplicationDelegate:
+  // mojo::ShellClient:
   void Initialize(Shell* shell, const std::string& url, uint32_t id) override {}
-  bool AcceptConnection(ApplicationConnection* connection) override {
+  bool AcceptConnection(Connection* connection) override {
     connection->AddService<ContentHandler>(this);
     connection->AddService<test::mojom::ApplicationPackageApptestService>(this);
     return true;
   }
 
   // InterfaceFactory<mojom::ContentHandler>:
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<mojom::ContentHandler> request) override {
     content_handler_bindings_.AddBinding(this, std::move(request));
   }
 
   // InterfaceFactory<test::mojom::ApplicationPackageApptestService>:
-  void Create(ApplicationConnection* connection,
+  void Create(Connection* connection,
               InterfaceRequest<test::mojom::ApplicationPackageApptestService>
                   request) override {
     bindings_.AddBinding(this, std::move(request));
   }
 
   // mojom::ContentHandler:
   void StartApplication(InterfaceRequest<mojom::Application> request,
                         URLResponsePtr response,
                         const Callback<void()>& destruct_callback) override {
     const std::string url = response->url;
     if (url == "mojo://package_test_a/") {
       new ProvidedApplicationDelegate("A", std::move(request),
                                       destruct_callback);
     } else if (url == "mojo://package_test_b/") {
       new ProvidedApplicationDelegate("B", std::move(request),
                                       destruct_callback);
     }
   }
 
   // test::mojom::ApplicationPackageApptestService:
   void GetName(const GetNameCallback& callback) override {
     callback.Run("ROOT");
   }
 
-  std::vector<scoped_ptr<ApplicationDelegate>> delegates_;
+  std::vector<scoped_ptr<ShellClient>> delegates_;
   WeakBindingSet<mojom::ContentHandler> content_handler_bindings_;
   WeakBindingSet<test::mojom::ApplicationPackageApptestService> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationPackageApptestDelegate);
 };
 
 void ReceiveName(std::string* out_name,
                  base::RunLoop* loop,
                  const String& name) {
   *out_name = name;
   loop->Quit();
 }
 
 }  // namespace
 
 class ApplicationPackageApptest : public mojo::test::ApplicationTestBase {
  public:
   ApplicationPackageApptest() : delegate_(nullptr) {}
   ~ApplicationPackageApptest() override {}
 
  private:
   // test::ApplicationTestBase:
-  ApplicationDelegate* GetApplicationDelegate() override {
+  ShellClient* GetShellClient() override {
     delegate_ = new ApplicationPackageApptestDelegate;
     return delegate_;
   }
 
   ApplicationPackageApptestDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationPackageApptest);
 };
 
 TEST_F(ApplicationPackageApptest, Basic) {
@@ skipping 26 matching lines @@
     base::RunLoop run_loop;
     std::string b_name;
     service_b->GetName(base::Bind(&ReceiveName, &b_name, &run_loop));
     run_loop.Run();
     EXPECT_EQ("B", b_name);
   }
 }
 
 }  // namespace shell
 }  // namespace mojo