headless: Initial headless embedder API implementation

headless/lib/browser/headless_browser_context.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.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_url_request_context_getter.h"
+#include "net/url_request/url_request_context.h"
+
+namespace headless {
+
+HeadlessBrowserContext::HeadlessBrowserContext(
+    const HeadlessBrowser::Options& options)
+    : resource_context_(new HeadlessResourceContext), options_(options) {
+  InitWhileIOAllowed();
+}
+
+HeadlessBrowserContext::~HeadlessBrowserContext() {
+  if (resource_context_) {
+    content::BrowserThread::DeleteSoon(content::BrowserThread::IO, FROM_HERE,
+                                       resource_context_.release());
+  }
+}
+
+HeadlessBrowserContext::HeadlessResourceContext::HeadlessResourceContext()
+    : getter_(nullptr) {}
+
+HeadlessBrowserContext::HeadlessResourceContext::~HeadlessResourceContext() {}
+
+net::HostResolver*
+HeadlessBrowserContext::HeadlessResourceContext::GetHostResolver() {
+  CHECK(getter_);
+  return getter_->GetURLRequestContext()->host_resolver();
+}
+
+net::URLRequestContext*
+HeadlessBrowserContext::HeadlessResourceContext::GetRequestContext() {
+  CHECK(getter_);
+  return getter_->GetURLRequestContext();
+}
+
+void HeadlessBrowserContext::InitWhileIOAllowed() {
+  // TODO(skyostil): Allow the embedder to override this.
+  PathService::Get(base::DIR_EXE, &path_);
+}
+
+scoped_ptr<content::ZoomLevelDelegate>
+HeadlessBrowserContext::CreateZoomLevelDelegate(
+    const base::FilePath& partition_path) {
+  return scoped_ptr<content::ZoomLevelDelegate>();
+}
+
+base::FilePath HeadlessBrowserContext::GetPath() const {
+  return path_;
+}
+
+bool HeadlessBrowserContext::IsOffTheRecord() const {
+  return false;
+}
+
+net::URLRequestContextGetter* HeadlessBrowserContext::GetRequestContext() {
+  return GetDefaultStoragePartition(this)->GetURLRequestContext();
+}
+
+net::URLRequestContextGetter*
+HeadlessBrowserContext::GetRequestContextForRenderProcess(
+    int renderer_child_id) {
+  return GetRequestContext();
+}
+
+net::URLRequestContextGetter* HeadlessBrowserContext::GetMediaRequestContext() {
+  return GetRequestContext();
+}
+
+net::URLRequestContextGetter*
+HeadlessBrowserContext::GetMediaRequestContextForRenderProcess(
+    int renderer_child_id) {
+  return GetRequestContext();
+}
+
+net::URLRequestContextGetter*
+HeadlessBrowserContext::GetMediaRequestContextForStoragePartition(
+    const base::FilePath& partition_path,
+    bool in_memory) {
+  return GetRequestContext();
+}
+
+content::ResourceContext* HeadlessBrowserContext::GetResourceContext() {
+  return resource_context_.get();
+}
+
+content::DownloadManagerDelegate*
+HeadlessBrowserContext::GetDownloadManagerDelegate() {
+  return nullptr;
+}
+
+content::BrowserPluginGuestManager* HeadlessBrowserContext::GetGuestManager() {
+  // TODO(altimin): Should be non-null? (is null in content/shell).
+  return nullptr;
+}
+
+storage::SpecialStoragePolicy*
+HeadlessBrowserContext::GetSpecialStoragePolicy() {
+  return nullptr;
+}
+
+content::PushMessagingService*
+HeadlessBrowserContext::GetPushMessagingService() {
+  return nullptr;
+}
+
+content::SSLHostStateDelegate*
+HeadlessBrowserContext::GetSSLHostStateDelegate() {
+  return nullptr;
+}
+
+content::PermissionManager* HeadlessBrowserContext::GetPermissionManager() {
+  return nullptr;
+}
+
+content::BackgroundSyncController*
+HeadlessBrowserContext::GetBackgroundSyncController() {
+  return nullptr;
+}
+
+scoped_refptr<net::URLRequestContextGetter>
+HeadlessBrowserContext::CreateRequestContext(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  DCHECK(!url_request_getter_.get());
+  if (options().url_request_context_getter) {
+    url_request_getter_ = options().url_request_context_getter;
+  } else {
+    url_request_getter_ = CreateURLRequestContextGetter(
+        protocol_handlers, std::move(request_interceptors));
+  }

[Ryan Sleevi, 2016/02/22 22:01:21]

This leaves me really uncomfortable, from an API design standpoint. Are you sure
allowing consumers to override the URLRequestContextGetter is the right thing?

This is single-handedly the most complicated portion of the //net API, from
lifetime and assurances, and it feels somewhat hand-waved away, and that makes
it hard to reason about.

It also means that, from an API contract perspective, you're ignoring
|protocol_handlers| and |request_interceptors|.

[Sami, 2016/02/23 20:19:07]

Agreed on all points. I think we're still finding out what the best way to let
the embedder customize networking, so I've now left that out of this patch so
they only get the default plumbing for now.

+  resource_context_->set_url_request_context_getter(url_request_getter_.get());
+  return url_request_getter_;
+}
+
+HeadlessURLRequestContextGetter*
+HeadlessBrowserContext::CreateURLRequestContextGetter(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  return new HeadlessURLRequestContextGetter(
+      true /* ignore_certificate_errors */, GetPath(),

[Ryan Sleevi, 2016/02/22 21:11:13]

SECURITY: *woah* this is a really really scary flag that I'd much prefer not be
introduced.

I've been pushing back on any CL that attempts to short-circuit security for
rapid iteration, because time and time again, the shortcut ends up being a
cowpath and isn't backed out.

[Sami, 2016/02/23 20:19:07]

Wow, I'm not sure why this flag was set this way -- it's definitely not what we
want or need. Thanks for pointing it out!

+      content::BrowserThread::UnsafeGetMessageLoopForThread(
+          content::BrowserThread::IO),
+      content::BrowserThread::UnsafeGetMessageLoopForThread(
+          content::BrowserThread::FILE),

[Ryan Sleevi, 2016/02/22 21:11:13]

DESIGN: I cannot see any reason for you to pass the naked (unsafe) message loop,
as opposed to calling "GetMessageLoopProxyForThread". The very name of these
methods was meant to discourage any new code from using it.

[Sami, 2016/02/23 20:19:07]

Hmm, looks like this was some relic in Content Shell. I'll put together another
patch to fix it over there too: https://codereview.chromium.org/1730533002

+      protocol_handlers, std::move(request_interceptors), nullptr /* net_log */,
+      options());
+}
+
+}  // namespace headless