[headless] Remove default browser context.

headless/lib/headless_browser_browsertest.cc

Index: headless/lib/headless_browser_browsertest.cc
diff --git a/headless/lib/headless_browser_browsertest.cc b/headless/lib/headless_browser_browsertest.cc
index 75ae5133006aef82ba6f7c8568817cf9c256f47c..84be35b373e570ec523372d4b24d1383435df1b8 100644
--- a/headless/lib/headless_browser_browsertest.cc
+++ b/headless/lib/headless_browser_browsertest.cc
@@ -20,23 +20,103 @@
 
 namespace headless {
 
+namespace {
+
+template <class T>
+std::vector<T> Sorted(std::vector<T> vector) {
+  std::sort(vector.begin(), vector.end());
+  return vector;
+}
+
+}  // namespace
+
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateAndDestroyWebContents) {
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()->CreateBrowserContextBuilder().Build();
   HeadlessWebContents* web_contents =
-      browser()->CreateWebContentsBuilder().Build();
+      browser_context->CreateWebContentsBuilder().Build();
   EXPECT_TRUE(web_contents);
 
-  EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size());
-  EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]);
+  EXPECT_EQ(browser()->GetAllWebContents(),

[Sami, 2016/08/03 11:20:31]

Should we change this to GetAllBrowserContexts to better reflect the hierarchy?
You could still use it to iterate over all tabs.

[altimin, 2016/08/03 11:54:10]

The problem is that we do not own browser contexts and so it can be tricky. Weak
pointers can solve the problem, however.

[Sami, 2016/08/03 13:46:14]

Sure, we don't own them but we can tell when they are created and deleted. I
think we should either change this to GetAllBrowserContexts() or remove it
completely since the user can iterate their own browser contexts. WDYT?

[altimin, 2016/08/03 14:18:51]

I was planning to do it in a next patch today or tomorrow. This one is already
too big.

[Sami, 2016/08/03 14:25:49]

Sounds good.

+            std::vector<HeadlessWebContents*>({web_contents}));
+  EXPECT_EQ(browser_context->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents}));
+
   // TODO(skyostil): Verify viewport dimensions once we can.
+
   web_contents->Close();
 
   EXPECT_TRUE(browser()->GetAllWebContents().empty());
+  EXPECT_TRUE(browser_context->GetAllWebContents().empty());
+}
+
+IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest,
+                       WebContentsAreDestroyedWithContext) {
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()->CreateBrowserContextBuilder().Build();
+  HeadlessWebContents* web_contents =
+      browser_context->CreateWebContentsBuilder().Build();
+  EXPECT_TRUE(web_contents);
+
+  EXPECT_EQ(browser()->GetAllWebContents(),

[Sami, 2016/08/03 11:20:31]

nit: I'm happy with this but another alternative would be ASSERT_THAT(...,
ElementsAre(...));

[altimin, 2016/08/03 11:54:10]

Acknowledged.

[alex clarke (OOO till 29th), 2016/08/03 11:55:19]

I'd prefer that, it has better error message on failure

[altimin, 2016/08/03 12:46:18]

Vox Populi, Vox Dei.
Done.

+            std::vector<HeadlessWebContents*>({web_contents}));
+
+  EXPECT_EQ(browser_context->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents}));
+
+  // TODO(skyostil): Verify viewport dimensions once we can.

[Sami, 2016/08/03 11:20:31]

No need to do this in every test :)

[altimin, 2016/08/03 11:54:10]

Amongst our weaponry are such diverse elements as: copy and paste.
Done. 

+
+  browser_context.reset();
+
+  EXPECT_TRUE(browser()->GetAllWebContents().empty());
+}
+
+IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, DestroyAndCreateTwoWebContents) {
+  std::unique_ptr<HeadlessBrowserContext> browser_context1 =
+      browser()->CreateBrowserContextBuilder().Build();
+  HeadlessWebContents* web_contents1 =
+      browser_context1->CreateWebContentsBuilder().Build();
+
+  EXPECT_EQ(browser()->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents1}));
+  EXPECT_EQ(browser_context1->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents1}));
+
+  std::unique_ptr<HeadlessBrowserContext> browser_context2 =
+      browser()->CreateBrowserContextBuilder().Build();
+  HeadlessWebContents* web_contents2 =
+      browser_context2->CreateWebContentsBuilder().Build();
+
+  EXPECT_EQ(Sorted(browser()->GetAllWebContents()),
+            Sorted(std::vector<HeadlessWebContents*>(
+                {web_contents1, web_contents2})));
+  EXPECT_EQ(browser_context1->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents1}));
+  EXPECT_EQ(browser_context2->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents2}));
+
+  browser_context1.reset();
+
+  EXPECT_EQ(browser()->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents2}));
+  EXPECT_EQ(browser_context2->GetAllWebContents(),
+            std::vector<HeadlessWebContents*>({web_contents2}));
+
+  browser_context2.reset();
+
+  EXPECT_TRUE(browser()->GetAllWebContents().empty());
 }
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, CreateWithBadURL) {
   GURL bad_url("not_valid");
+
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()->CreateBrowserContextBuilder().Build();
   HeadlessWebContents* web_contents =
-      browser()->CreateWebContentsBuilder().SetInitialURL(bad_url).Build();
+      browser_context->CreateWebContentsBuilder()
+          .SetInitialURL(bad_url)
+          .Build();
+
   EXPECT_FALSE(web_contents);
   EXPECT_TRUE(browser()->GetAllWebContents().empty());
 }
@@ -66,9 +146,11 @@ class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest {
 };
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) {
-  HeadlessBrowser::Options::Builder builder;
-  builder.SetProxyServer(proxy_server()->host_port_pair());
-  SetBrowserOptions(builder.Build());
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()
+          ->CreateBrowserContextBuilder()
+          .SetProxyServer(proxy_server()->host_port_pair())
+          .Build();
 
   // Load a page which doesn't actually exist, but for which the our proxy
   // returns valid content anyway.
@@ -76,32 +158,37 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTestWithProxy, SetProxyServer) {
   // TODO(altimin): Currently this construction does not serve hello.html
   // from headless/test/data as expected. We should fix this.
   HeadlessWebContents* web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html"))
           .Build();
   EXPECT_TRUE(WaitForLoad(web_contents));
-  EXPECT_EQ(static_cast<size_t>(1), browser()->GetAllWebContents().size());
-  EXPECT_EQ(web_contents, browser()->GetAllWebContents()[0]);
+  EXPECT_EQ(
+      browser()->GetAllWebContents(),
+      std::vector<HeadlessWebContents*>({web_contents}));
   web_contents->Close();
   EXPECT_TRUE(browser()->GetAllWebContents().empty());
 }
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, SetHostResolverRules) {
   EXPECT_TRUE(embedded_test_server()->Start());
-  HeadlessBrowser::Options::Builder builder;
-  builder.SetHostResolverRules(
+
+  std::string host_resolver_rules =
       base::StringPrintf("MAP not-an-actual-domain.tld 127.0.0.1:%d",
-                         embedded_test_server()->host_port_pair().port()));
-  SetBrowserOptions(builder.Build());
+                         embedded_test_server()->host_port_pair().port());
+
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()
+          ->CreateBrowserContextBuilder()
+          .SetHostResolverRules(host_resolver_rules)
+          .Build();
 
   // Load a page which doesn't actually exist, but which is turned into a valid
   // address by our host resolver rules.
   HeadlessWebContents* web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html"))
           .Build();
+
   EXPECT_TRUE(WaitForLoad(web_contents));
 }
 
@@ -111,15 +198,16 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) {
   protocol_handlers[url::kHttpScheme] =
       base::WrapUnique(new TestProtocolHandler(kResponseBody));
 
-  HeadlessBrowser::Options::Builder builder;
-  builder.SetProtocolHandlers(std::move(protocol_handlers));
-  SetBrowserOptions(builder.Build());
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()
+          ->CreateBrowserContextBuilder()
+          .SetProtocolHandlers(std::move(protocol_handlers))
+          .Build();
 
   // Load a page which doesn't actually exist, but which is fetched by our
   // custom protocol handler.
   HeadlessWebContents* web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html"))
           .Build();
   EXPECT_TRUE(WaitForLoad(web_contents));
@@ -138,15 +226,16 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) {
   protocol_handlers[url::kHttpsScheme] =
       base::WrapUnique(new TestProtocolHandler(kResponseBody));
 
-  HeadlessBrowser::Options::Builder builder;
-  builder.SetProtocolHandlers(std::move(protocol_handlers));
-  SetBrowserOptions(builder.Build());
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()
+          ->CreateBrowserContextBuilder()
+          .SetProtocolHandlers(std::move(protocol_handlers))
+          .Build();
 
   // Load a page which doesn't actually exist, but which is fetched by our
   // custom protocol handler.
   HeadlessWebContents* web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("https://not-an-actual-domain.tld/hello.html"))
           .Build();
   EXPECT_TRUE(WaitForLoad(web_contents));
@@ -160,8 +249,11 @@ IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) {
 }
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, WebGLSupported) {
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()->CreateBrowserContextBuilder().Build();
+
   HeadlessWebContents* web_contents =
-      browser()->CreateWebContentsBuilder().Build();
+      browser_context->CreateWebContentsBuilder().Build();
 
   bool webgl_supported;
   EXPECT_TRUE(EvaluateScript(