Adds support for headless chrome embedder mojo services

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 "base/bind.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 "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/browser/web_contents_observer.h"
@@ skipping 52 matching lines @@
     HeadlessBrowserImpl* browser) {
   content::BrowserContext* context =
       HeadlessBrowserContextImpl::From(builder->browser_context_);
   content::WebContents::CreateParams create_params(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), browser));
 
+  headless_web_contents->InstallMojoServices(builder->embedder_mojo_services_);
   headless_web_contents->InitializeScreen(parent_window, 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,
@@ skipping 11 matching lines @@
   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::InstallMojoServices(
+    std::list<EmbedderMojoService>& embedder_mojo_services) {
+  embedder_mojo_services_ = std::move(embedder_mojo_services);
+
+  if (embedder_mojo_services_.empty())
+    return;
+
+  web_contents_->GetRenderViewHost()->AllowBindings(
+      content::BINDINGS_POLICY_MOJO);
+  content::ServiceRegistry* service_registry =
+      web_contents_->GetRenderViewHost()->GetMainFrame()->GetServiceRegistry();
+
+  for (const EmbedderMojoService& service : embedder_mojo_services_) {
+    service_registry->AddService(service.service_name,
+                                 std::move(service.service_factory),
+                                 browser_->BrowserMainThread());
+  }
+}
+
+void HeadlessWebContentsImpl::DocumentOnLoadCompletedInMainFrame() {

[Sami, 2016/06/10 10:27:38]

Is there an earlier event we could use? It might be surprising if I create a
frame pointing at some JS which excepts to use the mojo bindings, but they won't
be there yet.

[alex clarke (OOO till 29th), 2016/06/11 20:51:50]

I've refactored this to:

1.  Install the mojo.define shim at the earliest possible override
HeadlessContentRendererClient::RunScriptsAtDocumentStart.
2. Use the layout-test-mojom// protocol handler.  I realized that although we
want each WebContents to have it's own mojo instance, the  generated JS bindings
are made at compile time and hence the protocol is fine actually.  Besides it
simplifies the browser test considerably.

+  if (embedder_mojo_services_.empty())
+    return;
+
+  // content::BINDINGS_POLICY_MOJO causes 'mojo.define' to be installed in the
+  // global v8 context.  However the autogenerated mojo bindings assume 'define'
+  // is installed.  We run some JS here to implement the expected 'define'
+  // method.
+  content::RenderFrameHost* render_frame_host = web_contents_->GetMainFrame();
+  render_frame_host->ExecuteJavaScriptForTests(base::UTF8ToUTF16(R"(

[Sami, 2016/06/10 10:27:38]

Was there a non-test interface we could use for this?

[alex clarke (OOO till 29th), 2016/06/11 20:51:50]

Yes. this has been moved.

+      window.define = (function() {
+        let moduleCache = new Map();
+        return function(name, deps, factory) {
+          let promise = moduleCache.get(name);
+          if (promise === undefined) {
+            // This promise must be cached as mojo.define will only call the
+            // factory function the first time the module is defined.
+            promise = new Promise(resolve => {
+              mojo.define(name, deps, (...modules) => {
+                let result = factory(...modules);
+                resolve(result);
+                return result;

[Sami, 2016/06/10 10:27:38]

Do you need both resolve and return?

[alex clarke (OOO till 29th), 2016/06/11 20:51:50]

Apparently the resolve isn't needed?!

+              });
+            });
+            moduleCache.set(name, promise);
+          }
+          return promise;
+        }
+      })(); )"));
+
+  for (const EmbedderMojoService& service : embedder_mojo_services_) {
+    render_frame_host->ExecuteJavaScript(base::UTF8ToUTF16(service.js_binding));
+  }
+}
+
 HeadlessWebContentsImpl::HeadlessWebContentsImpl(
     content::WebContents* web_contents,
     HeadlessBrowserImpl* browser)
-    : web_contents_delegate_(new HeadlessWebContentsImpl::Delegate(browser)),
+    : content::WebContentsObserver(web_contents),
+      web_contents_delegate_(new HeadlessWebContentsImpl::Delegate(browser)),
       web_contents_(web_contents),
       browser_(browser) {
   web_contents_->SetDelegate(web_contents_delegate_.get());
 }
 
 HeadlessWebContentsImpl::~HeadlessWebContentsImpl() {
   web_contents_->Close();
 }
 
 bool HeadlessWebContentsImpl::OpenURL(const GURL& url) {
@@ skipping 62 matching lines @@
   window_size_ = size;
   return *this;
 }
 
 HeadlessWebContents::Builder& HeadlessWebContents::Builder::SetBrowserContext(
     HeadlessBrowserContext* browser_context) {
   browser_context_ = browser_context;
   return *this;
 }
 
+HeadlessWebContents::Builder&
+HeadlessWebContents::Builder::AddEmbedderMojoService(
+    const std::string& service_name,
+    const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory,
+    const std::string& js_binding) {
+  embedder_mojo_services_.emplace_back(service_name, service_factory,
+                                       js_binding);
+  return *this;
+}
+
 HeadlessWebContents* HeadlessWebContents::Builder::Build() {
   return browser_->CreateWebContents(this);
 }
 
+HeadlessWebContents::Builder::EmbedderMojoService::EmbedderMojoService() {}
+
+HeadlessWebContents::Builder::EmbedderMojoService::EmbedderMojoService(
+    const std::string& service_name,
+    const base::Callback<void(mojo::ScopedMessagePipeHandle)>& service_factory,
+    const std::string& js_binding)
+    : service_name(service_name),
+      service_factory(service_factory),
+      js_binding(js_binding) {}
+
+HeadlessWebContents::Builder::EmbedderMojoService::~EmbedderMojoService() {}
+
 }  // namespace headless