headless: Introduce a browser context

headless/lib/browser/headless_browser_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_impl.h"
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/app/content_main.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
-#include "headless/lib/browser/headless_browser_context.h"
+#include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_main_parts.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/lib/browser/headless_window_tree_client.h"
 #include "headless/lib/headless_content_main_delegate.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace headless {
 
 HeadlessBrowserImpl::HeadlessBrowserImpl(
     const base::Callback<void(HeadlessBrowser*)>& on_start_callback,
     HeadlessBrowser::Options options)
     : on_start_callback_(on_start_callback),
       options_(std::move(options)),
       browser_main_parts_(nullptr) {
   DCHECK(!on_start_callback_.is_null());
 }
 
 HeadlessBrowserImpl::~HeadlessBrowserImpl() {}
 
+HeadlessWebContents::Builder HeadlessBrowserImpl::CreateWebContentsBuilder() {
+  DCHECK(BrowserMainThread()->BelongsToCurrentThread());
+  return HeadlessWebContents::Builder(this);
+}
+
+HeadlessBrowserContext::Builder
+HeadlessBrowserImpl::CreateBrowserContextBuilder() {
+  DCHECK(BrowserMainThread()->BelongsToCurrentThread());
+  return HeadlessBrowserContext::Builder(this);
+}
+
 HeadlessWebContents* HeadlessBrowserImpl::CreateWebContents(
-    const GURL& initial_url,
-    const gfx::Size& size) {
+    HeadlessWebContents::Builder* builder) {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
+  HeadlessBrowserContextImpl* browser_context_impl;
+  if (builder->browser_context_) {
+    browser_context_impl = reinterpret_cast<HeadlessBrowserContextImpl*>(

[alex clarke (OOO till 29th), 2016/06/09 09:15:08]

Nit: Elsewhere we've used the style
HeadlessBrowserContextImpl::From(builder->browser_context_) consider using that
here.

[Sami, 2016/06/09 11:14:39]

Thanks for the reminder, done.

+        builder->browser_context_);
+  } else {
+    browser_context_impl = browser_main_parts_->default_browser_context();
+  }
+
   std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents =
-      HeadlessWebContentsImpl::Create(browser_context(),
-                                      window_tree_host_->window(), size, this);
+      HeadlessWebContentsImpl::Create(browser_context_impl,

[alex clarke (OOO till 29th), 2016/06/09 09:15:08]

I wonder if it would be cleaner to pass the builder into the constructor,
particularly as the number of parameters grows.

You'd need to change the builder's constructor to initially set
browser_main_parts_->default_browser_context() as the default for
builder->browser_context_

[Sami, 2016/06/09 11:14:39]

Yeah, I think that will be more maintainable in the long term. Done.

+                                      window_tree_host_->window(),
+                                      builder->window_size_, this);
 
-  if (!headless_web_contents->OpenURL(initial_url))
+  if (!headless_web_contents->OpenURL(builder->initial_url_))
     return nullptr;
 
   return RegisterWebContents(std::move(headless_web_contents));
 }
 
+HeadlessWebContents* HeadlessBrowserImpl::CreateWebContents(
+    const GURL& initial_url,
+    const gfx::Size& size) {
+  return CreateWebContentsBuilder()
+      .SetInitialURL(initial_url)
+      .SetWindowSize(size)
+      .Build();
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 HeadlessBrowserImpl::BrowserMainThread() const {
   return content::BrowserThread::GetMessageLoopProxyForThread(
       content::BrowserThread::UI);
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 HeadlessBrowserImpl::BrowserFileThread() const {
   return content::BrowserThread::GetMessageLoopProxyForThread(
       content::BrowserThread::FILE);
 }
 
 void HeadlessBrowserImpl::Shutdown() {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   BrowserMainThread()->PostTask(FROM_HERE,
                                 base::MessageLoop::QuitWhenIdleClosure());
 }
 
 std::vector<HeadlessWebContents*> HeadlessBrowserImpl::GetAllWebContents() {
   std::vector<HeadlessWebContents*> result;
   result.reserve(web_contents_.size());
 
   for (const auto& web_contents_pair : web_contents_) {
     result.push_back(web_contents_pair.first);
   }
 
   return result;
 }
 
-HeadlessBrowserContext* HeadlessBrowserImpl::browser_context() const {
-  DCHECK(BrowserMainThread()->BelongsToCurrentThread());
-  DCHECK(browser_main_parts());
-  return browser_main_parts()->browser_context();
-}
-
 HeadlessBrowserMainParts* HeadlessBrowserImpl::browser_main_parts() const {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   return browser_main_parts_;
 }
 
 void HeadlessBrowserImpl::set_browser_main_parts(
     HeadlessBrowserMainParts* browser_main_parts) {
   DCHECK(!browser_main_parts_);
   browser_main_parts_ = browser_main_parts;
 }
@@ skipping 23 matching lines @@
 void HeadlessBrowserImpl::DestroyWebContents(
     HeadlessWebContentsImpl* web_contents) {
   auto it = web_contents_.find(web_contents);
   DCHECK(it != web_contents_.end());
   web_contents_.erase(it);
 }
 
 void HeadlessBrowserImpl::SetOptionsForTesting(
     HeadlessBrowser::Options options) {
   options_ = std::move(options);
-  browser_context()->SetOptionsForTesting(&options_);
+  browser_main_parts()->default_browser_context()->SetOptionsForTesting(
+      &options_);
 }
 
 int HeadlessBrowserMain(
     HeadlessBrowser::Options options,
     const base::Callback<void(HeadlessBrowser*)>& on_browser_start_callback) {
   content::ContentMainParams params(nullptr);
   params.argc = options.argc;
   params.argv = options.argv;
 
   // TODO(skyostil): Implement custom message pumps.
   DCHECK(!options.message_pump);
 
   std::unique_ptr<HeadlessBrowserImpl> browser(
       new HeadlessBrowserImpl(on_browser_start_callback, std::move(options)));
   headless::HeadlessContentMainDelegate delegate(std::move(browser));
   params.delegate = &delegate;
   return content::ContentMain(params);
 }
 
 }  // namespace headless