[headless] Remove default browser context.

headless/lib/embedder_mojo_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/optional.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/test/browser_test.h"
 #include "headless/grit/headless_browsertest_resources.h"
 #include "headless/lib/embedder_test.mojom.h"
 #include "headless/public/domains/network.h"
 #include "headless/public/domains/page.h"
 #include "headless/public/domains/runtime.h"
 #include "headless/public/headless_browser.h"
@@ skipping 62 matching lines @@
 
  protected:
   void RunTest() {
     // Using a pak file is idiomatic chromium style, but most embedders probably
     // wouln't load the javascript bindings file this way.
     std::string embedder_test_mojom_js =
         ResourceBundle::GetSharedInstance()
             .GetRawDataResource(IDR_HEADLESS_EMBEDDER_TEST_MOJOM_JS)
             .as_string();
 
+    HeadlessBrowserContext::Builder builder =
+        browser()->CreateBrowserContextBuilder();
+    builder.AddJsMojoBindings("headless/lib/embedder_test.mojom",
+                              embedder_test_mojom_js);
     if (http_policy_ == HttpPolicy::ENABLE_HTTP) {
-      browser_context_ =
-          browser()
-              ->CreateBrowserContextBuilder()
-              .AddJsMojoBindings("headless/lib/embedder_test.mojom",
-                                 embedder_test_mojom_js)
-              .EnableUnsafeNetworkAccessWithMojoBindings(true)
-              .Build();
-    } else {
-      browser_context_ =
-          browser()
-              ->CreateBrowserContextBuilder()
-              .AddJsMojoBindings("headless/lib/embedder_test.mojom",
-                                 embedder_test_mojom_js)
-              .Build();
+      builder.EnableUnsafeNetworkAccessWithMojoBindings(true);
+    }
+    if (host_resolver_rules_) {
+      builder.SetHostResolverRules(*host_resolver_rules_);
     }
 
+    browser_context_ = builder.Build();
+
     web_contents_ =
-        browser()
-            ->CreateWebContentsBuilder()
+        browser_context_->CreateWebContentsBuilder()
             .SetInitialURL(GURL(GetInitialUrl()))
-            .SetBrowserContext(browser_context_.get())
             .AddMojoService(base::Bind(&EmbedderMojoTest::CreateTestMojoService,
                                        base::Unretained(this)))
             .Build();
 
     web_contents_->AddObserver(this);
     RunAsynchronousTest();
 
     web_contents_->GetDevToolsTarget()->DetachClient(devtools_client_.get());
     web_contents_->RemoveObserver(this);
     web_contents_->Close();
     web_contents_ = nullptr;
 
     browser_context_.reset();
   }
 
   void CreateTestMojoService(
       mojo::InterfaceRequest<embedder_test::TestEmbedderService> request) {
     test_embedder_mojo_bindings_.AddBinding(this, std::move(request));
   }
 
   std::unique_ptr<HeadlessBrowserContext> browser_context_;
   HeadlessWebContents* web_contents_;
   std::unique_ptr<HeadlessDevToolsClient> devtools_client_;
 
   mojo::BindingSet<embedder_test::TestEmbedderService>
       test_embedder_mojo_bindings_;
 
   HttpPolicy http_policy_;
+  base::Optional<std::string> host_resolver_rules_;
 };
 
 class MojoBindingsTest : public EmbedderMojoTest {
  public:
   void RunMojoTest() override {
     devtools_client_->GetRuntime()->Evaluate(
         "// Note define() defines a module in the mojo module dependency     \n"
         "// system. While we don't expose our module, the callback below only\n"
         "// fires after the requested modules have been loaded.              \n"
         "define([                                                            \n"
@@ skipping 27 matching lines @@
 class MojoBindingsReinstalledAfterNavigation : public EmbedderMojoTest {
  public:
   MojoBindingsReinstalledAfterNavigation()
       : EmbedderMojoTest(HttpPolicy::ENABLE_HTTP), seen_page_one_(false) {
     EXPECT_TRUE(embedded_test_server()->Start());
   }
 
   void SetUpOnMainThread() override {
     // We want to make sure bindings work across browser initiated cross-origin
     // navigation, which is why we're setting up this fake tld.
-    HeadlessBrowser::Options::Builder builder;
-    builder.SetHostResolverRules(
+    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());
 
     EmbedderMojoTest::SetUpOnMainThread();
   }
 
   void RunMojoTest() override {}
 
   GURL GetInitialUrl() const override {
     return embedded_test_server()->GetURL("/page_one.html");
   }
 
@@ skipping 42 matching lines @@
   void OnLoadingFailed(const network::LoadingFailedParams& params) override {
     // The navigation should fail since HTTP requests are blackholed.
     EXPECT_EQ(params.GetErrorText(), "net::ERR_FILE_NOT_FOUND");
     FinishAsynchronousTest();
   }
 };
 
 DEVTOOLS_CLIENT_TEST_F(HttpDisabledByDefaultWhenMojoBindingsUsed);
 
 }  // namespace headless