Extract shell methods from ApplicationImpl into a base class, and pass this to Initialize() instead.

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"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/threading/simple_thread.h"
 #include "mojo/common/weak_binding_set.h"
 #include "mojo/shell/application_package_apptest.mojom.h"
-#include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/application_runner.h"
 #include "mojo/shell/public/cpp/application_test_base.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/interfaces/content_handler.mojom.h"
 
 // Tests that multiple applications can be packaged in a single Mojo application
 // implementing ContentHandler; that these applications can be specified by
 // the package's manifest and are thus registered with the PackageManager.
 
 namespace mojo {
@@ skipping 18 matching lines @@
         destruct_callback_(destruct_callback) {
     Start();
   }
   ~ProvidedApplicationDelegate() override {
     Join();
     destruct_callback_.Run();
   }
 
  private:
   // ApplicationDelegate:
-  void Initialize(ApplicationImpl* app) override {}
+  void Initialize(Shell* shell, const std::string& url, uint32_t id) override {}
   bool AcceptConnection(ApplicationConnection* connection) override {
     connection->AddService<test::mojom::ApplicationPackageApptestService>(this);
     return true;
   }
 
   // InterfaceFactory<test::mojom::ApplicationPackageApptestService>:
   void Create(
       ApplicationConnection* connection,
       InterfaceRequest<test::mojom::ApplicationPackageApptestService> request)
           override {
@@ skipping 25 matching lines @@
       public InterfaceFactory<mojom::ContentHandler>,
       public InterfaceFactory<test::mojom::ApplicationPackageApptestService>,
       public mojom::ContentHandler,
       public test::mojom::ApplicationPackageApptestService {
  public:
   ApplicationPackageApptestDelegate() {}
   ~ApplicationPackageApptestDelegate() override {}
 
  private:
   // ApplicationDelegate:
-  void Initialize(ApplicationImpl* app) override {}
+  void Initialize(Shell* shell, const std::string& url, uint32_t id) override {}
   bool AcceptConnection(ApplicationConnection* connection) override {
     connection->AddService<ContentHandler>(this);
     connection->AddService<test::mojom::ApplicationPackageApptestService>(this);
     return true;
   }
 
   // InterfaceFactory<mojom::ContentHandler>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<mojom::ContentHandler> request) override {
     content_handler_bindings_.AddBinding(this, std::move(request));
@@ skipping 56 matching lines @@
   ApplicationPackageApptestDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationPackageApptest);
 };
 
 TEST_F(ApplicationPackageApptest, Basic) {
   {
     // We need to do this to force the shell to read the test app's manifest and
     // register aliases.
     test::mojom::ApplicationPackageApptestServicePtr root_service;
-    application_impl()->ConnectToService("mojo:mojo_shell_apptests",
-                                         &root_service);
+    shell()->ConnectToService("mojo:mojo_shell_apptests", &root_service);
     base::RunLoop run_loop;
     std::string root_name;
     root_service->GetName(base::Bind(&ReceiveName, &root_name, &run_loop));
     run_loop.Run();
   }
 
   {
     // Now subsequent connects to applications provided by the root app will be
     // resolved correctly.
     test::mojom::ApplicationPackageApptestServicePtr service_a;
-    application_impl()->ConnectToService("mojo:package_test_a", &service_a);
+    shell()->ConnectToService("mojo:package_test_a", &service_a);
     base::RunLoop run_loop;
     std::string a_name;
     service_a->GetName(base::Bind(&ReceiveName, &a_name, &run_loop));
     run_loop.Run();
     EXPECT_EQ("A", a_name);
   }
 
   {
     test::mojom::ApplicationPackageApptestServicePtr service_b;
-    application_impl()->ConnectToService("mojo:package_test_b", &service_b);
+    shell()->ConnectToService("mojo:package_test_b", &service_b);
     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