Minimize headless code that refers to aura.

headless/lib/browser/headless_web_contents_impl.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 "headless/lib/browser/headless_web_contents_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "components/security_state/content/content_utils.h"
 #include "components/security_state/core/security_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
-#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/origin_util.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_impl.h"
 #include "headless/lib/browser/headless_browser_main_parts.h"
 #include "headless/lib/browser/headless_devtools_client_impl.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
-#include "ui/aura/window.h"
 
 namespace headless {
 
 // static
 HeadlessWebContentsImpl* HeadlessWebContentsImpl::From(
     HeadlessWebContents* web_contents) {
   // This downcast is safe because there is only one implementation of
   // HeadlessWebContents.
   return static_cast<HeadlessWebContentsImpl*>(web_contents);
 }
@@ skipping 54 matching lines @@
                                             security_style_explanations);
   }
 
  private:
   HeadlessBrowserContextImpl* browser_context_;  // Not owned.
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 // static
 std::unique_ptr<HeadlessWebContentsImpl> HeadlessWebContentsImpl::Create(
-    HeadlessWebContents::Builder* builder,
-    aura::Window* parent_window) {
+    HeadlessWebContents::Builder* builder) {
   content::WebContents::CreateParams create_params(builder->browser_context_,
                                                    nullptr);
   create_params.initial_size = builder->window_size_;
 
   std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents =
       base::WrapUnique(new HeadlessWebContentsImpl(
           content::WebContents::Create(create_params),
           builder->browser_context_));
 
   headless_web_contents->mojo_services_ = std::move(builder->mojo_services_);
-  headless_web_contents->InitializeScreen(parent_window, builder->window_size_);
+  headless_web_contents->InitializeScreen(builder->window_size_);
   if (!headless_web_contents->OpenURL(builder->initial_url_))
     return nullptr;
   return headless_web_contents;
 }
 
 // static
 std::unique_ptr<HeadlessWebContentsImpl>
 HeadlessWebContentsImpl::CreateFromWebContents(
     content::WebContents* web_contents,
     HeadlessBrowserContextImpl* browser_context) {
   std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents =
       base::WrapUnique(
           new HeadlessWebContentsImpl(web_contents, browser_context));
 
   return headless_web_contents;
 }
 
-void HeadlessWebContentsImpl::InitializeScreen(aura::Window* parent_window,
-                                               const gfx::Size& initial_size) {
-  aura::Window* contents = web_contents_->GetNativeView();
-  DCHECK(!parent_window->Contains(contents));
-  parent_window->AddChild(contents);
-  contents->Show();
-
-  contents->SetBounds(gfx::Rect(initial_size));
-  content::RenderWidgetHostView* host_view =
-      web_contents_->GetRenderWidgetHostView();
-  if (host_view)
-    host_view->SetSize(initial_size);
+void HeadlessWebContentsImpl::InitializeScreen(const gfx::Size& initial_size) {
+  browser()->PlatformSetWebContents(initial_size, web_contents_.get());
 }
 
 HeadlessWebContentsImpl::HeadlessWebContentsImpl(
     content::WebContents* web_contents,
     HeadlessBrowserContextImpl* browser_context)
     : content::WebContentsObserver(web_contents),
       web_contents_delegate_(
           new HeadlessWebContentsImpl::Delegate(browser_context)),
       web_contents_(web_contents),
       agent_host_(content::DevToolsAgentHost::GetOrCreateFor(web_contents)),
@@ skipping 146 matching lines @@
 HeadlessWebContents::Builder::MojoService::MojoService() {}
 
 HeadlessWebContents::Builder::MojoService::MojoService(
     const std::string& service_name,
     const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory)
     : service_name(service_name), service_factory(service_factory) {}
 
 HeadlessWebContents::Builder::MojoService::~MojoService() {}
 
 }  // namespace headless