headless: Initial headless embedder API implementation

headless/lib/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/headless_web_contents_impl.h"
+
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "base/trace_event/trace_event.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/browser/web_contents_observer.h"
+#include "content/public/common/bindings_policy.h"
+#include "content/public/common/service_registry.h"
+#include "content/public/renderer/render_frame.h"
+#include "headless/public/headless_web_frame.h"
+#include "ui/aura/env.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+
+namespace headless {
+
+class HeadlessWebContentsImpl::Delegate : public content::WebContentsDelegate {
+};
+
+HeadlessWebContentsImpl::HeadlessWebContentsImpl(
+    content::BrowserContext* browser_context,
+    const gfx::Size& initial_size)
+    : web_contents_delegate_(new HeadlessWebContentsImpl::Delegate()) {
+  content::WebContents::CreateParams create_params(browser_context, nullptr);
+  create_params.initial_size = initial_size;
+
+  web_contents_.reset(content::WebContents::Create(create_params));
+  web_contents_->SetDelegate(web_contents_delegate_.get());
+
+  DCHECK(aura::Env::GetInstance());
+  window_tree_host_.reset(
+      aura::WindowTreeHost::Create(gfx::Rect(initial_size)));
+  window_tree_host_->InitHost();
+
+  aura::Window* contents = web_contents_->GetNativeView();
+  aura::Window* parent = window_tree_host_->window();
+
+  if (!parent->Contains(contents)) {
+    parent->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);
+}
+
+HeadlessWebContentsImpl::~HeadlessWebContentsImpl() {
+  web_contents_->Close();
+}
+
+HeadlessWebFrame* HeadlessWebContentsImpl::GetMainFrame() {
+  // TODO(skyostil): Create a RenderFrame for the renderer thread.
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+void HeadlessWebContentsImpl::OpenURL(const GURL& url) {
+  content::NavigationController::LoadURLParams params(url);
+  params.transition_type = ui::PageTransitionFromInt(
+      ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
+  web_contents_->GetController().LoadURLWithParams(params);
+  web_contents_->Focus();
+}
+
+void HeadlessWebContentsImpl::TakeScreenshot(
+    const ScreenshotCallback& callback) {
+  NOTIMPLEMENTED();
+}
+
+content::WebContents* HeadlessWebContentsImpl::web_contents() {
+  return web_contents_.get();
+}
+
+HeadlessWebContents::Settings* HeadlessWebContentsImpl::GetSettings() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+const HeadlessWebContents::Settings* HeadlessWebContentsImpl::GetSettings()
+    const {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+content::NavigationController* HeadlessWebContentsImpl::GetController() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+const content::NavigationController* HeadlessWebContentsImpl::GetController()
+    const {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+std::string HeadlessWebContentsImpl::GetTitle() const {
+  NOTIMPLEMENTED();
+  return std::string();
+}
+
+const GURL& HeadlessWebContentsImpl::GetVisibleURL() const {
+  return web_contents_->GetVisibleURL();
+}
+
+const GURL& HeadlessWebContentsImpl::GetLastCommittedURL() const {
+  return web_contents_->GetLastCommittedURL();
+}
+
+bool HeadlessWebContentsImpl::IsLoading() const {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+class HeadlessWebContents::Observer::ObserverImpl
+    : public content::WebContentsObserver {
+ public:
+  ObserverImpl(content::WebContents* web_contents,
+               HeadlessWebContents::Observer* observer)
+      : content::WebContentsObserver(web_contents), observer_(observer) {}
+  ObserverImpl(HeadlessWebContents::Observer* observer) : observer_(observer) {}
+
+  ~ObserverImpl() override {}
+
+  void ObserveWebContents(content::WebContents* web_contents) {
+    DCHECK(!this->web_contents());
+    Observe(web_contents);
+  }
+
+  void DocumentOnLoadCompletedInMainFrame() override {
+    observer_->DocumentOnLoadCompletedInMainFrame();
+  }
+
+ private:
+  HeadlessWebContents::Observer* observer_;
+};
+
+HeadlessWebContents::Observer::Observer(HeadlessWebContents* web_contents)
+    : observer_(new HeadlessWebContents::Observer::ObserverImpl(
+          static_cast<HeadlessWebContentsImpl*>(web_contents)->web_contents(),
+          this)) {}
+
+HeadlessWebContents::Observer::Observer()
+    : observer_(new HeadlessWebContents::Observer::ObserverImpl(this)) {}
+
+HeadlessWebContents::Observer::~Observer() {}
+
+void HeadlessWebContents::Observer::Observe(HeadlessWebContents* web_contents) {
+  observer_->ObserveWebContents(
+      static_cast<HeadlessWebContentsImpl*>(web_contents)->web_contents());
+}
+
+}  // namespace headless