headless: Librarify Headless Shell

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 15 matching lines @@
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/headless_web_contents.h"
 #include "headless/public/util/deterministic_dispatcher.h"
 #include "headless/public/util/deterministic_http_protocol_handler.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 emulation = headless::emulation;
-namespace page = headless::page;
-namespace runtime = headless::runtime;
-
+namespace headless {
 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";
 
 bool ParseWindowSize(std::string window_size, gfx::Size* parsed_window_size) {
   int width, height = 0;
   if (sscanf(window_size.c_str(), "%dx%d", &width, &height) >= 2 &&
       width >= 0 && height >= 0) {
     parsed_window_size->set_width(width);
     parsed_window_size->set_height(height);
     return true;
   }
   return false;
 }
 }  // namespace
 
-// A sample application which demonstrates the use of the headless API.
+// An application which implements a simple headless browser.
 class HeadlessShell : public HeadlessWebContents::Observer,
                       emulation::ExperimentalObserver,
                       page::Observer {
  public:
   HeadlessShell()
       : browser_(nullptr),
         devtools_client_(HeadlessDevToolsClient::Create()),
         web_contents_(nullptr),
         processed_page_ready_(false),
         browser_context_(nullptr) {}
   ~HeadlessShell() override {}
 
   void OnStart(HeadlessBrowser* browser) {
     browser_ = browser;
 
     HeadlessBrowserContext::Builder context_builder =
         browser_->CreateBrowserContextBuilder();
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            headless::switches::kDeterministicFetch)) {
+            switches::kDeterministicFetch)) {
       deterministic_dispatcher_.reset(
-          new headless::DeterministicDispatcher(browser_->BrowserIOThread()));
+          new DeterministicDispatcher(browser_->BrowserIOThread()));
 
-      headless::ProtocolHandlerMap protocol_handlers;
+      ProtocolHandlerMap protocol_handlers;
       protocol_handlers[url::kHttpScheme] =
-          base::MakeUnique<headless::DeterministicHttpProtocolHandler>(
+          base::MakeUnique<DeterministicHttpProtocolHandler>(
               deterministic_dispatcher_.get(), browser->BrowserIOThread());
       protocol_handlers[url::kHttpsScheme] =
-          base::MakeUnique<headless::DeterministicHttpProtocolHandler>(
+          base::MakeUnique<DeterministicHttpProtocolHandler>(
               deterministic_dispatcher_.get(), browser->BrowserIOThread());
 
       context_builder.SetProtocolHandlers(std::move(protocol_handlers));
     }
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            headless::switches::kHideScrollbars)) {
+            switches::kHideScrollbars)) {
       context_builder.SetOverrideWebPreferencesCallback(
-          base::Bind([](headless::WebPreferences* preferences) {
+          base::Bind([](WebPreferences* preferences) {
             preferences->hide_scrollbars = true;
           }));
     }
     browser_context_ = context_builder.Build();
 
     HeadlessWebContents::Builder builder(
         browser_context_->CreateWebContentsBuilder());
     base::CommandLine::StringVector args =
         base::CommandLine::ForCurrentProcess()->GetArgs();
 
@@ skipping 31 matching lines @@
       return;
     web_contents_->GetDevToolsTarget()->AttachClient(devtools_client_.get());
     devtools_client_->GetPage()->AddObserver(this);
     devtools_client_->GetPage()->Enable();
     // Check if the document had already finished loading by the time we
     // attached.
 
     devtools_client_->GetEmulation()->GetExperimental()->AddObserver(this);
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            headless::switches::kVirtualTimeBudget)) {
+            switches::kVirtualTimeBudget)) {
       std::string budget_ms_ascii =
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              headless::switches::kVirtualTimeBudget);
+              switches::kVirtualTimeBudget);
       int budget_ms;
       CHECK(base::StringToInt(budget_ms_ascii, &budget_ms))
           << "Expected an integer value for --virtual-time-budget=";
       devtools_client_->GetEmulation()->GetExperimental()->SetVirtualTimePolicy(
           emulation::SetVirtualTimePolicyParams::Builder()
               .SetPolicy(emulation::VirtualTimePolicy::
                              PAUSE_IF_NETWORK_FETCHES_PENDING)
               .SetBudget(budget_ms)
               .Build());
     } else {
@@ skipping 29 matching lines @@
 
   // emulation::Observer implementation:
   void OnVirtualTimeBudgetExpired(
       const emulation::VirtualTimeBudgetExpiredParams& params) override {
     OnPageReady();
   }
 
   // page::Observer implementation:
   void OnLoadEventFired(const page::LoadEventFiredParams& params) override {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            headless::switches::kVirtualTimeBudget)) {
+            switches::kVirtualTimeBudget)) {
       return;
     }
     OnPageReady();
   }
 
   void OnPageReady() {
     if (processed_page_ready_)
       return;
     processed_page_ready_ = true;
 
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            headless::switches::kDumpDom)) {
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpDom)) {
       FetchDom();
     } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-                   headless::switches::kRepl)) {
+                   switches::kRepl)) {
       std::cout
           << "Type a Javascript expression to evaluate or \"quit\" to exit."
           << std::endl;
       InputExpression();
     } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-                   headless::switches::kScreenshot)) {
+                   switches::kScreenshot)) {
       CaptureScreenshot();
     } else {
       Shutdown();
     }
   }
 
   void FetchDom() {
     devtools_client_->GetRuntime()->Evaluate(
         "document.body.innerHTML",
         base::Bind(&HeadlessShell::OnDomFetched, base::Unretained(this)));
@@ skipping 39 matching lines @@
     devtools_client_->GetPage()->GetExperimental()->CaptureScreenshot(
         page::CaptureScreenshotParams::Builder().Build(),
         base::Bind(&HeadlessShell::OnScreenshotCaptured,
                    base::Unretained(this)));
   }
 
   void OnScreenshotCaptured(
       std::unique_ptr<page::CaptureScreenshotResult> result) {
     base::FilePath file_name =
         base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-            headless::switches::kScreenshot);
+            switches::kScreenshot);
     if (file_name.empty()) {
       file_name = base::FilePath().AppendASCII(kDefaultScreenshotFileName);
     }
 
     screenshot_file_stream_.reset(
         new net::FileStream(browser_->BrowserFileThread()));
     const int open_result = screenshot_file_stream_->Open(
         file_name, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
                        base::File::FLAG_ASYNC,
         base::Bind(&HeadlessShell::OnScreenshotFileOpened,
@@ skipping 48 matching lines @@
       // Operation could not be started.
       OnScreenshotFileClosed(close_result);
     }
   }
 
   void OnScreenshotFileClosed(const int close_result) { Shutdown(); }
 
   bool RemoteDebuggingEnabled() const {
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
-    return command_line.HasSwitch(switches::kRemoteDebuggingPort);
+    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_;
   HeadlessBrowserContext* browser_context_;
-  std::unique_ptr<headless::DeterministicDispatcher> deterministic_dispatcher_;
+  std::unique_ptr<DeterministicDispatcher> deterministic_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessShell);
 };
 
-int main(int argc, const char** argv) {
-  headless::RunChildProcessIfNeeded(argc, argv);
+int HeadlessShellMain(int argc, const char** argv) {
+  RunChildProcessIfNeeded(argc, argv);
   HeadlessShell shell;
   HeadlessBrowser::Options::Builder builder(argc, argv);
 
   // Enable devtools if requested.
   base::CommandLine command_line(argc, argv);
-  if (command_line.HasSwitch(switches::kRemoteDebuggingPort)) {
+  if (command_line.HasSwitch(::switches::kRemoteDebuggingPort)) {
     std::string address = kDevToolsHttpServerAddress;
-    if (command_line.HasSwitch(headless::switches::kRemoteDebuggingAddress)) {
-      address = command_line.GetSwitchValueASCII(
-          headless::switches::kRemoteDebuggingAddress);
+    if (command_line.HasSwitch(switches::kRemoteDebuggingAddress)) {
+      address =
+          command_line.GetSwitchValueASCII(switches::kRemoteDebuggingAddress);
       net::IPAddress parsed_address;
       if (!net::ParseURLHostnameToAddress(address, &parsed_address)) {
         LOG(ERROR) << "Invalid devtools server address";
         return EXIT_FAILURE;
       }
     }
     int parsed_port;
     std::string port_str =
-        command_line.GetSwitchValueASCII(switches::kRemoteDebuggingPort);
+        command_line.GetSwitchValueASCII(::switches::kRemoteDebuggingPort);
     if (!base::StringToInt(port_str, &parsed_port) ||
         !base::IsValueInRangeForNumericType<uint16_t>(parsed_port)) {
       LOG(ERROR) << "Invalid devtools server port";
       return EXIT_FAILURE;
     }
     net::IPAddress devtools_address;
     bool result = devtools_address.AssignFromIPLiteral(address);
     DCHECK(result);
     builder.EnableDevToolsServer(net::IPEndPoint(
         devtools_address, base::checked_cast<uint16_t>(parsed_port)));
   }
 
-  if (command_line.HasSwitch(headless::switches::kProxyServer)) {
+  if (command_line.HasSwitch(switches::kProxyServer)) {
     std::string proxy_server =
-        command_line.GetSwitchValueASCII(headless::switches::kProxyServer);
+        command_line.GetSwitchValueASCII(switches::kProxyServer);
     net::HostPortPair parsed_proxy_server =
         net::HostPortPair::FromString(proxy_server);
     if (parsed_proxy_server.host().empty() || !parsed_proxy_server.port()) {
       LOG(ERROR) << "Malformed proxy server url";
       return EXIT_FAILURE;
     }
     builder.SetProxyServer(parsed_proxy_server);
   }
 
-  if (command_line.HasSwitch(switches::kHostResolverRules)) {
+  if (command_line.HasSwitch(::switches::kHostResolverRules)) {
     builder.SetHostResolverRules(
-        command_line.GetSwitchValueASCII(switches::kHostResolverRules));
+        command_line.GetSwitchValueASCII(::switches::kHostResolverRules));
   }
 
-  if (command_line.HasSwitch(headless::switches::kUseGL)) {
+  if (command_line.HasSwitch(switches::kUseGL)) {
     builder.SetGLImplementation(
-        command_line.GetSwitchValueASCII(headless::switches::kUseGL));
+        command_line.GetSwitchValueASCII(switches::kUseGL));
   }
 
-  if (command_line.HasSwitch(headless::switches::kUserDataDir)) {
+  if (command_line.HasSwitch(switches::kUserDataDir)) {
     builder.SetUserDataDir(
-        command_line.GetSwitchValuePath(headless::switches::kUserDataDir));
+        command_line.GetSwitchValuePath(switches::kUserDataDir));
     builder.SetIncognitoMode(false);
   }
 
-  if (command_line.HasSwitch(headless::switches::kWindowSize)) {
+  if (command_line.HasSwitch(switches::kWindowSize)) {
     std::string window_size =
-        command_line.GetSwitchValueASCII(headless::switches::kWindowSize);
+        command_line.GetSwitchValueASCII(switches::kWindowSize);
     gfx::Size parsed_window_size;
     if (!ParseWindowSize(window_size, &parsed_window_size)) {
       LOG(ERROR) << "Malformed window size";
       return EXIT_FAILURE;
     }
     builder.SetWindowSize(parsed_window_size);
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
+
+}  // namespace headless