Make headless_shell target compile for 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 "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/files/file_proxy.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "headless/app/headless_shell_switches.h"
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/inspector.h"
 #include "headless/public/devtools/domains/page.h"
 #include "headless/public/devtools/domains/runtime.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
+#include "headless/public/headless_shell.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"
 
 namespace headless {
@@ skipping 56 matching lines @@
     browser_->SetDefaultBrowserContext(browser_context_);
 
     HeadlessWebContents::Builder builder(
         browser_context_->CreateWebContentsBuilder());
     base::CommandLine::StringVector args =
         base::CommandLine::ForCurrentProcess()->GetArgs();
 
     // TODO(alexclarke): Should we navigate to about:blank first if using
     // virtual time?
     if (args.empty())
+#if defined(OS_WIN)
+      args.push_back(L"about:blank");
+#else
       args.push_back("about:blank");
+#endif
     for (auto it = args.rbegin(); it != args.rend(); ++it) {
       GURL url(*it);
       HeadlessWebContents* web_contents = builder.SetInitialURL(url).Build();
       if (!web_contents) {
         LOG(ERROR) << "Navigation to " << url << " failed";
         browser_->Shutdown();
         return;
       }
       if (!web_contents_ && !RemoteDebuggingEnabled()) {
         // TODO(jzfeng): Support observing multiple targets.
@@ skipping 196 matching lines @@
 
   void OnScreenshotCaptured(
       std::unique_ptr<page::CaptureScreenshotResult> result) {
     base::FilePath file_name =
         base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
             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,
-                   weak_factory_.GetWeakPtr(), base::Passed(std::move(result)),
-                   file_name));
-    if (open_result != net::ERR_IO_PENDING) {
+    screenshot_file_proxy_.reset(
+        new base::FileProxy(browser_->BrowserFileThread().get()));
+    if (!screenshot_file_proxy_->CreateOrOpen(
+            file_name, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE,
+            base::Bind(&HeadlessShell::OnScreenshotFileOpened,
+                       weak_factory_.GetWeakPtr(), base::Passed(&result),

[Sami, 2017/02/09 17:51:40]

nit: Could you keep this base::Passed(std::move(result))? I find the shorter
form a bit misleading.

[dvallet, 2017/02/10 05:29:49]

Done

+                       file_name))) {
       // Operation could not be started.
-      OnScreenshotFileOpened(nullptr, file_name, open_result);
+      OnScreenshotFileOpened(nullptr, file_name, base::File::FILE_ERROR_FAILED);
     }
   }
 
   void OnScreenshotFileOpened(
       std::unique_ptr<page::CaptureScreenshotResult> result,
       const base::FilePath file_name,
-      const int open_result) {
-    if (open_result != net::OK) {
+      base::File::Error error_code) {
+    if (!screenshot_file_proxy_->IsValid()) {
       LOG(ERROR) << "Writing screenshot to file " << file_name.value()
                  << " was unsuccessful, could not open file: "
-                 << net::ErrorToString(open_result);
+                 << base::File::ErrorToString(error_code);
       return;
     }
 
     std::string decoded_png;
     base::Base64Decode(result->GetData(), &decoded_png);
     scoped_refptr<net::IOBufferWithSize> buf =
         new net::IOBufferWithSize(decoded_png.size());
     memcpy(buf->data(), decoded_png.data(), decoded_png.size());
-    const int write_result = screenshot_file_stream_->Write(
-        buf.get(), buf->size(),
-        base::Bind(&HeadlessShell::OnScreenshotFileWritten,
-                   weak_factory_.GetWeakPtr(), file_name, buf->size()));
-    if (write_result != net::ERR_IO_PENDING) {
+
+    if (!screenshot_file_proxy_->Write(
+            0, buf->data(), buf->size(),
+            base::Bind(&HeadlessShell::OnScreenshotFileWritten,
+                       weak_factory_.GetWeakPtr(), file_name, buf->size()))) {
       // Operation may have completed successfully or failed.
-      OnScreenshotFileWritten(file_name, buf->size(), write_result);
+      OnScreenshotFileWritten(file_name, buf->size(),
+                              base::File::FILE_ERROR_FAILED, 0);
     }
   }
 
   void OnScreenshotFileWritten(const base::FilePath file_name,
                                const int length,
-                               const int write_result) {
+                               base::File::Error error_code,
+                               int write_result) {
     if (write_result < length) {
       // TODO(eseckler): Support recovering from partial writes.
       LOG(ERROR) << "Writing screenshot to file " << file_name.value()
                  << " was unsuccessful: " << net::ErrorToString(write_result);
     } else {
       LOG(INFO) << "Screenshot written to file " << file_name.value() << "."
                 << std::endl;
     }
-    int close_result = screenshot_file_stream_->Close(base::Bind(
-        &HeadlessShell::OnScreenshotFileClosed, weak_factory_.GetWeakPtr()));
-    if (close_result != net::ERR_IO_PENDING) {
+    if (!screenshot_file_proxy_->Close(
+            base::Bind(&HeadlessShell::OnScreenshotFileClosed,
+                       weak_factory_.GetWeakPtr()))) {
       // Operation could not be started.
-      OnScreenshotFileClosed(close_result);
+      OnScreenshotFileClosed(base::File::FILE_ERROR_FAILED);
     }
   }
 
-  void OnScreenshotFileClosed(const int close_result) { Shutdown(); }
+  void OnScreenshotFileClosed(base::File::Error error_code) { Shutdown(); }
 
   bool RemoteDebuggingEnabled() const {
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
     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<base::FileProxy> screenshot_file_proxy_;
   HeadlessBrowserContext* browser_context_;
   std::unique_ptr<DeterministicDispatcher> deterministic_dispatcher_;
   base::WeakPtrFactory<HeadlessShell> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessShell);
 };
 
 bool ValidateCommandLine(const base::CommandLine& command_line) {
   if (!command_line.HasSwitch(switches::kRemoteDebuggingPort)) {
     if (command_line.GetArgs().size() <= 1)
@@ skipping 110 matching lines @@
     builder.SetOverrideWebPreferencesCallback(base::Bind([](
         WebPreferences* preferences) { preferences->hide_scrollbars = true; }));
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
 
 }  // namespace headless