Adds support for headless chrome embedder mojo services

headless/lib/browser/headless_browser_context_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_browser_context_impl.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "headless/lib/browser/headless_browser_impl.h"
 #include "headless/lib/browser/headless_url_request_context_getter.h"
+#include "headless/public/util/black_hole_protocol_handler.h"
+#include "headless/public/util/in_memory_protocol_handler.h"
 #include "net/url_request/url_request_context.h"
 
 namespace headless {
 
+namespace {
+const char kHeadlessMojomProtocol[] = "headless-mojom";
+}
+
 // Contains net::URLRequestContextGetter required for resource loading.
 // Must be destructed on the IO thread as per content::ResourceContext
 // requirements.
 class HeadlessResourceContext : public content::ResourceContext {
  public:
   HeadlessResourceContext();
   ~HeadlessResourceContext() override;
 
   // ResourceContext implementation:
   net::HostResolver* GetHostResolver() override;
@@ skipping 153 matching lines @@
     bool in_memory) {
   return nullptr;
 }
 
 void HeadlessBrowserContextImpl::SetOptionsForTesting(
     HeadlessBrowser::Options* options) {
   options_ = options;
 }
 
 HeadlessBrowserContext::Builder::Builder(HeadlessBrowserImpl* browser)
-    : browser_(browser) {}
+    : browser_(browser), enable_http_and_https_if_mojo_used_(false) {}
 
 HeadlessBrowserContext::Builder::~Builder() = default;
 
 HeadlessBrowserContext::Builder::Builder(Builder&&) = default;
 
 HeadlessBrowserContext::Builder&
 HeadlessBrowserContext::Builder::SetProtocolHandlers(
     ProtocolHandlerMap protocol_handlers) {
   protocol_handlers_ = std::move(protocol_handlers);
   return *this;
 }
 
+HeadlessBrowserContext::Builder&
+HeadlessBrowserContext::Builder::AddJsMojoBindings(
+    const std::string& mojom_name,
+    const std::string& js_bindings) {
+  mojo_bindings_.emplace_back(mojom_name, js_bindings);
+  return *this;
+}
+
+HeadlessBrowserContext::Builder&
+HeadlessBrowserContext::Builder::EnableUnsafeNetworkAccessWithMojoBindings(
+    bool enable_http_and_https_if_mojo_used) {
+  enable_http_and_https_if_mojo_used_ = enable_http_and_https_if_mojo_used;
+  return *this;
+}
+
 std::unique_ptr<HeadlessBrowserContext>
 HeadlessBrowserContext::Builder::Build() {
+  if (!mojo_bindings_.empty()) {
+    std::unique_ptr<InMemoryProtocolHandler> headless_mojom_protocol_handler(
+        new InMemoryProtocolHandler());
+    for (const MojoBindings& binding : mojo_bindings_) {
+      headless_mojom_protocol_handler->InsertResponse(
+          binding.mojom_name,
+          InMemoryProtocolHandler::Response(binding.js_bindings,
+                                            "application/javascript"));
+    }
+    DCHECK(protocol_handlers_.find(kHeadlessMojomProtocol) ==
+           protocol_handlers_.end());
+    protocol_handlers_[kHeadlessMojomProtocol] =
+        std::move(headless_mojom_protocol_handler);
+
+    // Unless you know what you're doing it's unsafe to allow http/https for a
+    // context with mojo bindings.
+    if (!enable_http_and_https_if_mojo_used_) {
+      protocol_handlers_[url::kHttpScheme] =
+          base::WrapUnique(new BlackHoleProtocolHandler());
+      protocol_handlers_[url::kHttpsScheme] =
+          base::WrapUnique(new BlackHoleProtocolHandler());
+    }
+  }
+
   return base::WrapUnique(new HeadlessBrowserContextImpl(
       std::move(protocol_handlers_), browser_->options()));
 }
 
+HeadlessBrowserContext::Builder::MojoBindings::MojoBindings() {}
+
+HeadlessBrowserContext::Builder::MojoBindings::MojoBindings(
+    const std::string& mojom_name,
+    const std::string& js_bindings)
+    : mojom_name(mojom_name), js_bindings(js_bindings) {}
+
+HeadlessBrowserContext::Builder::MojoBindings::~MojoBindings() {}
+
 }  // namespace headless