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

components/mus/ws/window_tree_apptest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/test_change_tracker.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/shell/public/cpp/application_delegate.h"
-#include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/application_test_base.h"
 
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::Array;
 using mojo::Callback;
 using mojo::InterfaceRequest;
 using mojo::RectPtr;
 using mojo::String;
 using mus::mojom::ErrorCode;
@@ skipping 27 matching lines @@
 void EmbedCallbackImpl(base::RunLoop* run_loop,
                        bool* result_cache,
                        bool result,
                        ConnectionSpecificId connection_id) {
   *result_cache = result;
   run_loop->Quit();
 }
 
 // -----------------------------------------------------------------------------
 
-bool EmbedUrl(mojo::ApplicationImpl* app,
+bool EmbedUrl(mojo::Shell* shell,
               WindowTree* ws,
               const String& url,
               Id root_id) {
   bool result = false;
   base::RunLoop run_loop;
   {
     mojom::WindowTreeClientPtr client;
-    app->ConnectToService(url.get(), &client);
+    shell->ConnectToService(url.get(), &client);
     ws->Embed(root_id, std::move(client),
               mojom::WindowTree::kAccessPolicyDefault,
               base::Bind(&EmbedCallbackImpl, &run_loop, &result));
   }
   run_loop.Run();
   return result;
 }
 
 bool Embed(WindowTree* ws, Id root_id, mojom::WindowTreeClientPtr client) {
   bool result = false;
@@ skipping 448 matching lines @@
       int* connection_id) {
     return EstablishConnectionViaEmbedWithPolicyBitmask(
         owner, root_id, mojom::WindowTree::kAccessPolicyDefault, connection_id);
   }
 
   scoped_ptr<TestWindowTreeClientImpl>
   EstablishConnectionViaEmbedWithPolicyBitmask(WindowTree* owner,
                                                Id root_id,
                                                uint32_t policy_bitmask,
                                                int* connection_id) {
-    if (!EmbedUrl(application_impl(), owner, application_impl()->url(),
-                  root_id)) {
+    if (!EmbedUrl(shell(), owner, shell_url(), root_id)) {
       ADD_FAILURE() << "Embed() failed";
       return nullptr;
     }
     scoped_ptr<TestWindowTreeClientImpl> client =
         client_factory_->WaitForInstance();
     if (!client.get()) {
       ADD_FAILURE() << "WaitForInstance failed";
       return nullptr;
     }
     client->WaitForOnEmbed();
 
     EXPECT_EQ("OnEmbed",
               SingleChangeToDescription(*client->tracker()->changes()));
     if (connection_id)
       *connection_id = (*client->tracker()->changes())[0].connection_id;
     return client;
   }
 
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
   void SetUp() override {
     ApplicationTestBase::SetUp();
     client_factory_.reset(new WindowTreeClientFactory());
 
     mojom::WindowTreeHostFactoryPtr factory;
-    application_impl()->ConnectToService("mojo:mus", &factory);
+    shell()->ConnectToService("mojo:mus", &factory);
 
     mojom::WindowTreeClientPtr tree_client_ptr;
     ws_client1_.reset(new TestWindowTreeClientImpl());
     ws_client1_->Bind(GetProxy(&tree_client_ptr));
 
     factory->CreateWindowTreeHost(GetProxy(&host_),
                                   std::move(tree_client_ptr));
 
     // Next we should get an embed call on the "window manager" client.
     ws_client1_->WaitForIncomingMethodCall();
@@ skipping 1130 matching lines @@
   ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
 
   Id window_3_3 = ws_client3()->NewWindow(3);
   ASSERT_TRUE(window_3_3);
   ASSERT_TRUE(ws_client3()->AddWindow(window_2_1, window_3_3));
 
   // 2 should not be able to embed in window_3_3 as window_3_3 was not created
   // by
   // 2.
-  EXPECT_FALSE(EmbedUrl(application_impl(), ws2(), application_impl()->url(),
-                        window_3_3));
+  EXPECT_FALSE(EmbedUrl(shell(), ws2(), shell_url(), window_3_3));
 }
 
 // Verifies Embed() from window manager on another connections window works.
 TEST_F(WindowTreeAppTest, EmbedFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_1 = ws_client2()->NewWindow(1);
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
 
   changes2()->clear();
 
   // Establish a third connection in window_2_1.
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_2_1));
 
   ASSERT_TRUE(ws_client2()->WaitForAllMessages());
   EXPECT_EQ(std::string(), SingleChangeToDescription(*changes2()));
 }
 
 TEST_F(WindowTreeAppTest, CantEmbedFromConnectionRoot) {
   // Shouldn't be able to embed into the root.
-  ASSERT_FALSE(EmbedUrl(application_impl(), ws1(), application_impl()->url(),
-                        root_window_id()));
+  ASSERT_FALSE(EmbedUrl(shell(), ws1(), shell_url(), root_window_id()));
 
   // Even though the call above failed a WindowTreeClient was obtained. We need
   // to
   // wait for it else we throw off the next connect.
   WaitForWindowTreeClient();
 
   // Don't allow a connection to embed into its own root.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
-  EXPECT_FALSE(EmbedUrl(application_impl(), ws2(), application_impl()->url(),
+  EXPECT_FALSE(EmbedUrl(shell(), ws2(), shell_url(),
                         BuildWindowId(connection_id_1(), 1)));
 
   // Need to wait for a WindowTreeClient for same reason as above.
   WaitForWindowTreeClient();
 
   Id window_1_2 = ws_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(
       ws_client1()->AddWindow(BuildWindowId(connection_id_1(), 1), window_1_2));
   ASSERT_TRUE(ws_client3_.get() == nullptr);
   ws_client3_ = EstablishConnectionViaEmbedWithPolicyBitmask(
       ws1(), window_1_2, mojom::WindowTree::kAccessPolicyEmbedRoot, nullptr);
   ASSERT_TRUE(ws_client3_.get() != nullptr);
 
   // window_1_2 is ws3's root, so even though v3 is an embed root it should not
   // be able to Embed into itself.
-  ASSERT_FALSE(EmbedUrl(application_impl(), ws3(), application_impl()->url(),
-                        window_1_2));
+  ASSERT_FALSE(EmbedUrl(shell(), ws3(), shell_url(), window_1_2));
 }
 
 // Verifies that a transient window tracks its parent's lifetime.
 TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
   Id window_2_1 = ws_client2()->NewWindow(1);
   Id window_2_2 = ws_client2()->NewWindow(2);
   Id window_2_3 = ws_client2()->NewWindow(3);
@@ skipping 84 matching lines @@
 // originating connection.
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace ws
 }  // namespace mus