Headless demo

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/environment.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/browser/resource_context.h"
+#include "headless/lib/browser/headless_url_request_context_getter.h"
+#include "content/public/browser/browser_thread.h"
+
+#if defined(OS_WIN)
+#include "base/base_paths_win.h"
+#elif defined(OS_LINUX)
+#include "base/nix/xdg_util.h"
+#elif defined(OS_MACOSX)
+#include "base/base_paths_mac.h"
+#endif
+
+namespace headless {
+
+HeadlessBrowserContext::HeadlessBrowserContext()
+    : resource_context_(new HeadlessResourceContext) {
+        InitWhileIOAllowed();
+}
+
+HeadlessBrowserContext::~HeadlessBrowserContext() {
+  if (resource_context_) {
+    content::BrowserThread::DeleteSoon(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        resource_context_.release());
+  }
+}
+
+HeadlessBrowserContext::HeadlessResourceContext::HeadlessResourceContext()
+    : getter_(NULL) { }
+
+HeadlessBrowserContext::HeadlessResourceContext::~HeadlessResourceContext() { }
+
+net::HostResolver*
+HeadlessBrowserContext::HeadlessResourceContext::GetHostResolver() {
+  CHECK(getter_);
+  return getter_->host_resolver();
+}
+
+net::URLRequestContext*
+HeadlessBrowserContext::HeadlessResourceContext::GetRequestContext() {
+  CHECK(getter_);
+  return getter_->GetURLRequestContext();
+}
+
+
+void HeadlessBrowserContext::InitWhileIOAllowed() {
+  #if defined(OS_WIN)
+  CHECK(PathService::Get(base::DIR_LOCAL_APP_DATA, &path_));
+  path_ = path_.Append(std::wstring(L"headless_shell"));
+#elif defined(OS_LINUX)
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  base::FilePath config_dir(
+      base::nix::GetXDGDirectory(env.get(),
+                                 base::nix::kXdgConfigHomeEnvVar,
+                                 base::nix::kDotConfigDir));
+  path_ = config_dir.Append("headless_shell");
+#elif defined(OS_MACOSX)
+  CHECK(PathService::Get(base::DIR_APP_DATA, &path_));
+
+  path_ = path_.Append("Headless Chromium Shell");
+#elif defined(OS_ANDROID)
+  CHECK(PathService::Get(base::DIR_ANDROID_APP_DATA, &path_));
+  path_ = path_.Append(FILE_PATH_LITERAL("headless_shell"));
+#else
+  NOTIMPLEMENTED();
+#endif
+}
+
+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;
+}
+
+net::URLRequestContextGetter* HeadlessBrowserContext::CreateRequestContext(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  DCHECK(!url_request_getter_.get());
+  url_request_getter_ = CreateURLRequestContextGetter(
+      protocol_handlers, request_interceptors.Pass());
+  resource_context_->set_url_request_context_getter(url_request_getter_.get());
+  return url_request_getter_.get();
+}
+
+HeadlessURLRequestContextGetter*
+HeadlessBrowserContext::CreateURLRequestContextGetter(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  return new HeadlessURLRequestContextGetter(
+      true /* ignore_certificate_errors */,
+      GetPath(),
+      content::BrowserThread::UnsafeGetMessageLoopForThread(content::BrowserThread::IO),
+      content::BrowserThread::UnsafeGetMessageLoopForThread(content::BrowserThread::FILE),
+      protocol_handlers,
+      request_interceptors.Pass(),
+      NULL);
+}
+
+} // namespace headless