[headless] Remove default browser context.

headless/lib/headless_browser_context_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/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/thread_restrictions.h"
 #include "content/public/test/browser_test.h"
 #include "headless/public/domains/runtime.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_browser_context.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/base/io_buffer.h"
@@ skipping 29 matching lines @@
   HeadlessBrowserContextIsolationTest()
       : web_contents2_(nullptr),
         devtools_client2_(HeadlessDevToolsClient::Create()) {
     EXPECT_TRUE(embedded_test_server()->Start());
   }
 
   // HeadlessWebContentsObserver implementation:
   void DevToolsTargetReady() override {
     if (!web_contents2_) {
       browser_context_ = browser()->CreateBrowserContextBuilder().Build();
-      web_contents2_ = browser()
-                           ->CreateWebContentsBuilder()
-                           .SetBrowserContext(browser_context_.get())
-                           .Build();
+      web_contents2_ = browser_context_->CreateWebContentsBuilder().Build();
       web_contents2_->AddObserver(this);
       return;
     }
 
     web_contents2_->GetDevToolsTarget()->AttachClient(devtools_client2_.get());
     HeadlessAsyncDevTooledBrowserTest::DevToolsTargetReady();
   }
 
   void RunDevTooledTest() override {
     load_observer_.reset(new LoadObserver(
@@ skipping 91 matching lines @@
       base::WrapUnique(new TestProtocolHandler(kResponseBody));
 
   // Load a page which doesn't actually exist, but which is fetched by our
   // custom protocol handler.
   std::unique_ptr<HeadlessBrowserContext> browser_context =
       browser()
           ->CreateBrowserContextBuilder()
           .SetProtocolHandlers(std::move(protocol_handlers))
           .Build();
   HeadlessWebContents* web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html"))
-          .SetBrowserContext(browser_context.get())
           .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);
   web_contents->Close();
 
-  // Loading the same non-existent page using a tab with the default context
+  std::unique_ptr<HeadlessBrowserContext> another_browser_context =
+      browser()->CreateBrowserContextBuilder().Build();
+
+  // Loading the same non-existent page using a tab with a different context
   // should not work since the protocol handler only exists on the custom
   // context.
   web_contents =
-      browser()
-          ->CreateWebContentsBuilder()
+      another_browser_context->CreateWebContentsBuilder()
           .SetInitialURL(GURL("http://not-an-actual-domain.tld/hello.html"))
           .Build();
   EXPECT_TRUE(WaitForLoad(web_contents));
   EXPECT_TRUE(EvaluateScript(web_contents, "document.body.innerHTML")
                   ->GetResult()
                   ->GetValue()
                   ->GetAsString(&inner_html));
   EXPECT_EQ("", inner_html);
   web_contents->Close();
 }
 
+IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, UserDataDir) {
+  // We do not want to bother with posting tasks to create a temp dir.
+  // Just allow IO from main thread for now.
+  base::ThreadRestrictions::SetIOAllowed(true);
+
+  EXPECT_TRUE(embedded_test_server()->Start());
+
+  base::ScopedTempDir user_data_dir;
+  ASSERT_TRUE(user_data_dir.CreateUniqueTempDir());
+
+  // Newly created temp directory should be empty.
+  EXPECT_TRUE(base::IsDirectoryEmpty(user_data_dir.path()));
+
+  std::unique_ptr<HeadlessBrowserContext> browser_context =
+      browser()
+          ->CreateBrowserContextBuilder()
+          .SetUserDataDir(user_data_dir.path())
+          .Build();
+
+  HeadlessWebContents* web_contents =
+      browser_context->CreateWebContentsBuilder()
+          .SetInitialURL(embedded_test_server()->GetURL("/hello.html"))
+          .Build();
+
+  EXPECT_TRUE(WaitForLoad(web_contents));
+
+  // Something should be written to this directory.
+  // If it is not the case, more complex page may be needed.
+  // ServiceWorkers may be a good option.
+  EXPECT_FALSE(base::IsDirectoryEmpty(user_data_dir.path()));
+}
+
 }  // namespace headless