[headless] Remove default browser context.

headless/app/headless_shell.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 <iostream>
 #include <memory>
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/headless_web_contents.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "ui/gfx/geometry/size.h"
 
 using headless::HeadlessBrowser;
+using headless::HeadlessBrowserContext;
 using headless::HeadlessDevToolsClient;
 using headless::HeadlessWebContents;
 namespace page = headless::page;
 namespace runtime = headless::runtime;
 
 namespace {
 // Address where to listen to incoming DevTools connections.
 const char kDevToolsHttpServerAddress[] = "127.0.0.1";
 // Default file name for screenshot. Can be overriden by "--screenshot" switch.
 const char kDefaultScreenshotFileName[] = "screenshot.png";
 }
 
 // A sample application which demonstrates the use of the headless API.
 class HeadlessShell : public HeadlessWebContents::Observer, page::Observer {
  public:
   HeadlessShell()
       : browser_(nullptr),
         devtools_client_(HeadlessDevToolsClient::Create()),
         web_contents_(nullptr),
         processed_page_ready_(false) {}
   ~HeadlessShell() override {}
 
   void OnStart(HeadlessBrowser* browser) {
     browser_ = browser;
 
-    HeadlessWebContents::Builder builder(browser_->CreateWebContentsBuilder());
+    browser_context_ = browser_->CreateBrowserContextBuilder().Build();
+
+    HeadlessWebContents::Builder builder(
+        browser_context_->CreateWebContentsBuilder());
     base::CommandLine::StringVector args =
         base::CommandLine::ForCurrentProcess()->GetArgs();
 
     if (!args.empty() && !args[0].empty())
       builder.SetInitialURL(GURL(args[0]));
 
     web_contents_ = builder.Build();
     if (!web_contents_) {
       LOG(ERROR) << "Navigation failed";
       browser_->Shutdown();
       return;
     }
     web_contents_->AddObserver(this);
   }
 
   void Shutdown() {
     if (!web_contents_)
       return;
     if (!RemoteDebuggingEnabled()) {
       devtools_client_->GetPage()->RemoveObserver(this);
       web_contents_->GetDevToolsTarget()->DetachClient(devtools_client_.get());
     }
     web_contents_->RemoveObserver(this);
     web_contents_ = nullptr;
+    browser_context_.reset();
     browser_->Shutdown();
   }
 
   // HeadlessWebContents::Observer implementation:
   void DevToolsTargetReady() override {
     if (RemoteDebuggingEnabled())
       return;
     web_contents_->GetDevToolsTarget()->AttachClient(devtools_client_.get());
     devtools_client_->GetPage()->AddObserver(this);
     devtools_client_->GetPage()->Enable();
@@ skipping 179 matching lines @@
     return command_line.HasSwitch(switches::kRemoteDebuggingPort);
   }
 
  private:
   GURL url_;
   HeadlessBrowser* browser_;  // Not owned.
   std::unique_ptr<HeadlessDevToolsClient> devtools_client_;
   HeadlessWebContents* web_contents_;
   bool processed_page_ready_;
   std::unique_ptr<net::FileStream> screenshot_file_stream_;
+  std::unique_ptr<HeadlessBrowserContext> browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessShell);
 };
 
 int main(int argc, const char** argv) {
   headless::RunChildProcessIfNeeded(argc, argv);
   HeadlessShell shell;
   HeadlessBrowser::Options::Builder builder(argc, argv);
 
   // Enable devtools if requested.
@@ skipping 39 matching lines @@
   if (command_line.HasSwitch(switches::kHostResolverRules)) {
     builder.SetHostResolverRules(
         command_line.GetSwitchValueASCII(switches::kHostResolverRules));
   }
 
   if (command_line.HasSwitch(headless::switches::kUseGL)) {
     builder.SetGLImplementation(
         command_line.GetSwitchValueASCII(headless::switches::kUseGL));
   }
 
+  if (command_line.HasSwitch(headless::switches::kUserDataDir)) {
+    builder.SetUserDataDir(
+        command_line.GetSwitchValuePath(headless::switches::kUserDataDir));
+  }
+
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }