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

components/web_view/frame_apptest.cc

 // Copyright 2015 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 "components/web_view/frame.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "components/mus/public/cpp/window_tree_delegate.h"
 #include "components/mus/public/cpp/window_tree_host_factory.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/web_view/frame_connection.h"
 #include "components/web_view/frame_tree.h"
 #include "components/web_view/frame_tree_delegate.h"
 #include "components/web_view/frame_user_data.h"
 #include "components/web_view/test_frame_tree_delegate.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/application_test_base.h"
 #include "mojo/shell/public/cpp/service_provider_impl.h"
 
 using mus::Window;
 using mus::WindowTreeConnection;
 
 namespace web_view {
 
 namespace {
 
@@ skipping 27 matching lines @@
 }
 
 }  // namespace
 
 void OnGotIdCallback(base::RunLoop* run_loop) {
   run_loop->Quit();
 }
 
 // Creates a new FrameConnection. This runs a nested message loop until the
 // content handler id is obtained.
-scoped_ptr<FrameConnection> CreateFrameConnection(mojo::ApplicationImpl* app) {
+scoped_ptr<FrameConnection> CreateFrameConnection(mojo::Shell* shell,
+                                                  const std::string& url) {
   scoped_ptr<FrameConnection> frame_connection(new FrameConnection);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
-  request->url = mojo::String::From(app->url());
+  request->url = mojo::String::From(url);
   base::RunLoop run_loop;
-  frame_connection->Init(app, std::move(request),
+  frame_connection->Init(shell, std::move(request),
                          base::Bind(&OnGotIdCallback, &run_loop));
   run_loop.Run();
   return frame_connection;
 }
 
 class TestFrameClient : public mojom::FrameClient {
  public:
   TestFrameClient()
       : connect_count_(0), last_dispatch_load_event_frame_id_(0) {}
   ~TestFrameClient() override {}
@@ skipping 209 matching lines @@
   }
   FrameTree* frame_tree() { return frame_tree_.get(); }
   WindowAndFrame* root_window_and_frame() {
     return root_window_and_frame_.get();
   }
 
   scoped_ptr<WindowAndFrame> NavigateFrameWithStartTime(
       WindowAndFrame* window_and_frame,
       base::TimeTicks navigation_start_time) {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
-    request->url = mojo::String::From(application_impl()->url());
+    request->url = mojo::String::From(shell_url());
     request->originating_time_ticks = navigation_start_time.ToInternalValue();
     window_and_frame->server_frame()->RequestNavigate(
         mojom::NavigationTargetType::EXISTING_FRAME,
         window_and_frame->window()->id(), std::move(request));
     return WaitForViewAndFrame();
   }
 
   scoped_ptr<WindowAndFrame> NavigateFrame(WindowAndFrame* window_and_frame) {
     return NavigateFrameWithStartTime(window_and_frame, base::TimeTicks());
   }
@@ skipping 42 matching lines @@
   void OnEmbed(Window* root) override {
     most_recent_connection_ = root->connection();
     QuitRunLoop();
   }
   void OnConnectionLost(WindowTreeConnection* connection) override {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     ApplicationTestBase::SetUp();
 
-    mus::CreateWindowTreeHost(application_impl(), this, &host_, nullptr);
+    mus::CreateWindowTreeHost(shell(), this, &host_, nullptr);
 
     ASSERT_TRUE(DoRunLoopWithTimeout());
     std::swap(window_manager_, most_recent_connection_);
 
     // Creates a FrameTree, which creates a single frame. Wait for the
     // FrameClient to be connected to.
-    frame_tree_delegate_.reset(new TestFrameTreeDelegate(application_impl()));
+    frame_tree_delegate_.reset(new TestFrameTreeDelegate(shell()));
     scoped_ptr<FrameConnection> frame_connection =
-        CreateFrameConnection(application_impl());
+        CreateFrameConnection(shell(), shell_url());
     mojom::FrameClient* frame_client = frame_connection->frame_client();
     mus::mojom::WindowTreeClientPtr window_tree_client =
         frame_connection->GetWindowTreeClient();
     mus::Window* frame_root_view = window_manager()->NewWindow();
     (*window_manager()->GetRoots().begin())->AddChild(frame_root_view);
     frame_tree_.reset(new FrameTree(
         0u, frame_root_view, std::move(window_tree_client),
         frame_tree_delegate_.get(), frame_client, std::move(frame_connection),
         Frame::ClientPropertyMap(), base::TimeTicks::Now()));
     root_window_and_frame_ = WaitForViewAndFrame();
@@ skipping 177 matching lines @@
   base::TimeTicks navigation_start_time = base::TimeTicks::FromInternalValue(1);
   scoped_ptr<WindowAndFrame> navigated_child_view_and_frame =
       NavigateFrameWithStartTime(child_view_and_frame.get(),
                                  navigation_start_time);
   EXPECT_EQ(navigation_start_time,
             navigated_child_view_and_frame->test_frame_client()
                 ->last_navigation_start_time());
 }
 
 }  // namespace web_view