[headless] Remove default browser context.

headless/lib/headless_browser_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/test/browser_test.h"
 #include "headless/public/domains/page.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/headless_web_contents.h"
 #include "headless/test/headless_browser_test.h"
 #include "headless/test/test_protocol_handler.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
 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());
 }
 
 class HeadlessBrowserTestWithProxy : public HeadlessBrowserTest {
  public:
   HeadlessBrowserTestWithProxy()
       : proxy_server_(net::SpawnedTestServer::TYPE_HTTP,
                       net::SpawnedTestServer::kLocalhost,
                       base::FilePath(FILE_PATH_LITERAL("headless/test/data"))) {
   }
 
   void SetUp() override {
     ASSERT_TRUE(proxy_server_.Start());
     HeadlessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     proxy_server_.Stop();
     HeadlessBrowserTest::TearDown();
   }
 
   net::SpawnedTestServer* proxy_server() { return &proxy_server_; }
 
  private:
   net::SpawnedTestServer proxy_server_;
 };
 
 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.
   //
   // 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));
 }
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpProtocolHandler) {
   const std::string kResponseBody = "<p>HTTP response body</p>";
   ProtocolHandlerMap protocol_handlers;
   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));
 
   std::string inner_html;
   EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML")
                   ->GetResult()
                   ->GetValue()
                   ->GetAsString(&inner_html));
   EXPECT_EQ(kResponseBody, inner_html);
 }
 
 IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, HttpsProtocolHandler) {
   const std::string kResponseBody = "<p>HTTPS response body</p>";
   ProtocolHandlerMap protocol_handlers;
   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));
 
   std::string inner_html;
   EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML")
                   ->GetResult()
                   ->GetValue()
                   ->GetAsString(&inner_html));
   EXPECT_EQ(kResponseBody, inner_html);
 }
 
 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(
       web_contents,
       "(document.createElement('canvas').getContext('webgl')"
       "    instanceof WebGLRenderingContext)")
                   ->GetResult()
                   ->GetValue()
                   ->GetAsBoolean(&webgl_supported));
   EXPECT_TRUE(webgl_supported);
 }
 
 }  // namespace headless