Add --headless flag to Windows

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 <memory>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
+#include "content/public/app/content_main.h"
 #include "content/public/common/content_switches.h"
 #include "headless/app/headless_shell.h"
 #include "headless/app/headless_shell_switches.h"
 #include "headless/lib/browser/headless_devtools.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/util/deterministic_http_protocol_handler.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "ui/gfx/geometry/size.h"
 
+#if defined(OS_WIN)
+#include "sandbox/win/src/sandbox_types.h"
+#endif
+
 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";
 // Default file name for pdf. Can be overriden by "--print-to-pdf" switch.
 const char kDefaultPDFFileName[] = "output.pdf";
 
 bool ParseWindowSize(std::string window_size, gfx::Size* parsed_window_size) {
@@ skipping 12 matching lines @@
     : browser_(nullptr),
       devtools_client_(HeadlessDevToolsClient::Create()),
       web_contents_(nullptr),
       processed_page_ready_(false),
       browser_context_(nullptr),
       weak_factory_(this) {}
 
 HeadlessShell::~HeadlessShell() {}
 
 void HeadlessShell::OnStart(HeadlessBrowser* browser) {
+#if !defined(CHROME_MULTIPLE_DLL_CHILD)

[alex clarke (OOO till 29th), 2017/05/12 11:31:28]

It's kind of a shame about all the #ifs although that might just be the way of
things.

Anyway I have't really thought this through but I wonder if it's worth making
this virtual and adding a headless_shell_win.cc (GN supports platform specific
compilation based on file suffix) which overrides it with an empty
implementation?  Can do something similar for Shutdown and DevToolsTargetReady. 
WDYT?

[dvallet, 2017/05/12 21:12:03]

That's a good idea Alex! 
I'll look into it and will definitely think of making this more streamlined. I
still want to land as is to check that this solves the size regression and will
cleanup afterwards. Also, I want to avoid keep breaking the Windows build.

I added a TODO

   browser_ = browser;
 
   HeadlessBrowserContext::Builder context_builder =
       browser_->CreateBrowserContextBuilder();
   // TODO(eseckler): These switches should also affect BrowserContexts that
   // are created via DevTools later.
-  DeterministicHttpProtocolHandler* http_handler;
-  DeterministicHttpProtocolHandler* https_handler;
+  DeterministicHttpProtocolHandler* http_handler = nullptr;
+  DeterministicHttpProtocolHandler* https_handler = nullptr;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDeterministicFetch)) {
     deterministic_dispatcher_.reset(
         new DeterministicDispatcher(browser_->BrowserIOThread()));
 
     ProtocolHandlerMap protocol_handlers;
     protocol_handlers[url::kHttpScheme] =
         base::MakeUnique<DeterministicHttpProtocolHandler>(
             deterministic_dispatcher_.get(), browser->BrowserIOThread());
     http_handler = static_cast<DeterministicHttpProtocolHandler*>(
@@ skipping 35 matching lines @@
       browser_->Shutdown();
       return;
     }
     if (!web_contents_ && !RemoteDebuggingEnabled()) {
       // TODO(jzfeng): Support observing multiple targets.
       url_ = url;
       web_contents_ = web_contents;
       web_contents_->AddObserver(this);
     }
   }
+#endif  // !defined(CHROME_MULTIPLE_DLL_CHILD)
 }
 
 void HeadlessShell::Shutdown() {
+#if !defined(CHROME_MULTIPLE_DLL_CHILD)
   if (!web_contents_)
     return;
   if (!RemoteDebuggingEnabled()) {
     devtools_client_->GetEmulation()->GetExperimental()->RemoveObserver(this);
     devtools_client_->GetInspector()->GetExperimental()->RemoveObserver(this);
     devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
     if (web_contents_->GetDevToolsTarget()) {
       web_contents_->GetDevToolsTarget()->DetachClient(devtools_client_.get());
     }
   }
   web_contents_->RemoveObserver(this);
   web_contents_ = nullptr;
   browser_context_->Close();
   browser_->Shutdown();
+#endif  // !defined(CHROME_MULTIPLE_DLL_CHILD)
 }
 
 void HeadlessShell::DevToolsTargetReady() {
+#if !defined(CHROME_MULTIPLE_DLL_CHILD)
   web_contents_->GetDevToolsTarget()->AttachClient(devtools_client_.get());
   devtools_client_->GetInspector()->GetExperimental()->AddObserver(this);
   devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
   devtools_client_->GetPage()->Enable();
 
   devtools_client_->GetEmulation()->GetExperimental()->AddObserver(this);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDeterministicFetch)) {
     devtools_client_->GetPage()->GetExperimental()->SetControlNavigations(
@@ skipping 51 matching lines @@
     int timeout_ms;
     CHECK(base::StringToInt(timeout_ms_ascii, &timeout_ms))
         << "Expected an integer value for --timeout=";
     browser_->BrowserMainThread()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&HeadlessShell::FetchTimeout, weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(timeout_ms));
   }
 
   // TODO(skyostil): Implement more features to demonstrate the devtools API.
+#endif  // !defined(CHROME_MULTIPLE_DLL_CHILD)
 }
 
 void HeadlessShell::FetchTimeout() {
   LOG(INFO) << "Timeout.";
   devtools_client_->GetPage()->GetExperimental()->StopLoading(
       page::StopLoadingParams::Builder().Build());
 }
 
 void HeadlessShell::OnTargetCrashed(
     const inspector::TargetCrashedParams& params) {
@@ skipping 204 matching lines @@
   if (!file_proxy_->Write(
           0, buf->data(), buf->size(),
           base::Bind(&HeadlessShell::OnFileWritten, weak_factory_.GetWeakPtr(),
                      file_name, buf->size()))) {
     // Operation may have completed successfully or failed.
     OnFileWritten(file_name, buf->size(), base::File::FILE_ERROR_FAILED, 0);
   }
 }
 
 void HeadlessShell::OnFileWritten(const base::FilePath file_name,
-                                  const int length,
+                                  const size_t length,
                                   base::File::Error error_code,
                                   int write_result) {
-  if (write_result < length) {
+  if (write_result < static_cast<int>(length)) {
     // TODO(eseckler): Support recovering from partial writes.
     LOG(ERROR) << "Writing to file " << file_name.value()
                << " was unsuccessful: "
                << base::File::ErrorToString(error_code);
   } else {
     LOG(INFO) << "Written to file " << file_name.value() << ".";
   }
   if (!file_proxy_->Close(base::Bind(&HeadlessShell::OnFileClosed,
                                      weak_factory_.GetWeakPtr()))) {
     // Operation could not be started.
@@ skipping 63 matching lines @@
     return false;
   }
   if (command_line.HasSwitch(switches::kVirtualTimeBudget)) {
     LOG(ERROR) << "Virtual time budget is disabled "
                << "when remote debugging is enabled.";
     return false;
   }
   return true;
 }
 
+#if defined(OS_WIN)
+int HeadlessShellMain(HINSTANCE instance,
+                      sandbox::SandboxInterfaceInfo* sandbox_info) {
+  base::CommandLine::Init(0, nullptr);
+  RunChildProcessIfNeeded(instance, sandbox_info);
+  HeadlessBrowser::Options::Builder builder(0, nullptr);
+  builder.SetInstance(instance);
+  builder.SetSandboxInfo(std::move(sandbox_info));
+#else
 int HeadlessShellMain(int argc, const char** argv) {
   base::CommandLine::Init(argc, argv);
   RunChildProcessIfNeeded(argc, argv);
+  HeadlessBrowser::Options::Builder builder(argc, argv);
+#endif  // defined(OS_WIN)
   HeadlessShell shell;
-  HeadlessBrowser::Options::Builder builder(argc, argv);
 
   const base::CommandLine& command_line(
       *base::CommandLine::ForCurrentProcess());
   if (!ValidateCommandLine(command_line))
     return EXIT_FAILURE;
 
-  if (command_line.HasSwitch(::switches::kEnableCrashReporter))
+  if (command_line.HasSwitch(switches::kEnableCrashReporter))
     builder.SetCrashReporterEnabled(true);
   if (command_line.HasSwitch(switches::kCrashDumpsDir)) {
     builder.SetCrashDumpsDir(
         command_line.GetSwitchValuePath(switches::kCrashDumpsDir));
   }
 
   // Enable devtools if requested, either by specifying a port (and optional
   // address), or by specifying the fd of an already-open socket.
   if (command_line.HasSwitch(::switches::kRemoteDebuggingPort)) {
     std::string address = kDevToolsHttpServerAddress;
@@ skipping 80 matching lines @@
     std::string ua = command_line.GetSwitchValueASCII(switches::kUserAgent);
     if (net::HttpUtil::IsValidHeaderValue(ua))
       builder.SetUserAgent(ua);
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
 
+int HeadlessShellMain(const content::ContentMainParams& params) {
+#if defined(OS_WIN)
+  return HeadlessShellMain(params.instance, params.sandbox_info);
+#else
+  return HeadlessShellMain(params.argc, params.argv);
+#endif
+}
+
 }  // namespace headless