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

components/html_viewer/html_frame.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/html_viewer/html_frame.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <limits>
 #include <utility>
@@ skipping 24 matching lines @@
 #include "components/html_viewer/web_layer_tree_view_impl.h"
 #include "components/html_viewer/web_storage_namespace_impl.h"
 #include "components/html_viewer/web_url_loader_impl.h"
 #include "components/mus/public/cpp/scoped_window_ptr.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/ws/ids.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/blink/blink_input_events_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
-#include "mojo/shell/public/cpp/application_impl.h"
-#include "mojo/shell/public/cpp/connect.h"
-#include "mojo/shell/public/interfaces/shell.mojom.h"
+#include "mojo/shell/public/cpp/shell.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 #include "third_party/WebKit/public/web/WebFrameOwnerProperties.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
@@ skipping 112 matching lines @@
             GetValueFromClientProperties("devtools-state", params->properties);
         std::string devtools_state_str = devtools_state.To<std::string>();
         devtools_agent_.reset(new DevToolsAgentImpl(
             web_frame_->toWebLocalFrame(), devtools_id.To<std::string>(),
             devtools_state.is_null() ? nullptr : &devtools_state_str));
       }
 
       // Collect startup perf data for local main frames in test environments.
       // Child frames aren't tracked, and tracking remote frames is redundant.
       startup_performance_data_collector_ =
-          StatsCollectionController::Install(web_frame_, GetApp());
+          StatsCollectionController::Install(web_frame_, GetShell());
     }
   } else if (!params->is_local_create_child && params->window &&
              id_ == params->window->id()) {
     // Frame represents the local frame, and it isn't the root of the tree.
     HTMLFrame* previous_sibling = GetPreviousSibling(this);
     blink::WebFrame* previous_web_frame =
         previous_sibling ? previous_sibling->web_frame() : nullptr;
     CHECK(!parent_->IsLocal());
     web_frame_ = parent_->web_frame()->toWebRemoteFrame()->createLocalChild(
         state_.tree_scope, state_.name, state_.sandbox_flags, this,
@@ skipping 121 matching lines @@
 blink::WebMediaPlayer* HTMLFrame::createMediaPlayer(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayer::LoadType load_type,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     blink::WebContentDecryptionModule* initial_cdm,
     const blink::WebString& sink_id,
     blink::WebMediaSession* media_session) {
   return global_state()->media_factory()->CreateMediaPlayer(
-      frame, url, client, encrypted_client, initial_cdm, GetApp()->shell());
+      frame, url, client, encrypted_client, initial_cdm, GetShell());
 }
 
 blink::WebFrame* HTMLFrame::createChildFrame(
     blink::WebLocalFrame* parent,
     blink::WebTreeScopeType scope,
     const blink::WebString& frame_name,
     blink::WebSandboxFlags sandbox_flags,
     const blink::WebFrameOwnerProperties& frame_owner_properties) {
   DCHECK(IsLocal());  // Can't create children of remote frames.
   DCHECK_EQ(parent, web_frame_);
@@ skipping 232 matching lines @@
   }
 }
 
 HTMLFrame* HTMLFrame::GetFirstAncestorWithDelegate() {
   HTMLFrame* frame = this;
   while (frame && !frame->delegate_)
     frame = frame->parent_;
   return frame;
 }
 
-mojo::ApplicationImpl* HTMLFrame::GetApp() {
-  return GetFirstAncestorWithDelegate()->delegate_->GetApp();
+mojo::Shell* HTMLFrame::GetShell() {
+  return GetFirstAncestorWithDelegate()->delegate_->GetShell();
 }
 
 web_view::mojom::Frame* HTMLFrame::GetServerFrame() {
   // Prefer an ancestor with a server Frame.
   for (HTMLFrame* frame = this; frame; frame = frame->parent_) {
     if (frame->server_.get())
       return frame->server_.get();
   }
 
   // We're a remote frame with no local frame ancestors. Use the server Frame
   // from the local frame of the HTMLFrameTreeManager.
   return frame_tree_manager_->local_frame_->server_.get();
 }
 
 void HTMLFrame::SetWindow(mus::Window* window) {
   if (window_) {
     window_->set_input_event_handler(nullptr);
     window_->RemoveObserver(this);
   }
   window_ = window;
   if (window_) {
     window_->AddObserver(this);
     window_->set_input_event_handler(this);
   }
 }
 
 void HTMLFrame::CreateRootWebWidget() {
   DCHECK(!html_widget_);
   if (window_) {
-    HTMLWidgetRootLocal::CreateParams create_params(GetApp(), global_state(),
+    HTMLWidgetRootLocal::CreateParams create_params(GetShell(), global_state(),
                                                     window_);
     html_widget_.reset(
         delegate_->GetHTMLFactory()->CreateHTMLWidgetRootLocal(&create_params));
   } else {
     html_widget_.reset(new HTMLWidgetRootRemote(global_state()));
   }
 }
 
 void HTMLFrame::CreateLocalRootWebWidget(blink::WebLocalFrame* local_frame) {
   DCHECK(!html_widget_);
   DCHECK(IsLocal());
-  html_widget_.reset(
-      new HTMLWidgetLocalRoot(GetApp(), global_state(), window_, local_frame));
+  html_widget_.reset(new HTMLWidgetLocalRoot(GetShell(), global_state(),
+                                             window_, local_frame));
 }
 
 void HTMLFrame::UpdateFocus() {
   blink::WebWidget* web_widget = GetWebWidget();
   if (!web_widget || !window_)
     return;
   const bool is_focused = window_ && window_->HasFocus();
   web_widget->setFocus(is_focused);
   if (web_widget->isWebView())
     static_cast<blink::WebView*>(web_widget)->setIsActive(is_focused);
@@ skipping 413 matching lines @@
 
   if (!surface_layer_)
     return;
 
   surface_layer_->SetSurfaceId(cc::SurfaceId(owned_window_->window()->id()),
                                global_state()->device_pixel_ratio(),
                                owned_window_->window()->bounds().size());
 }
 
 }  // namespace mojo