Make headless_shell target compile for Windows

headless/app/headless_shell.cc

Index: headless/app/headless_shell.cc
diff --git a/headless/app/headless_shell.cc b/headless/app/headless_shell.cc
index 942fb9bbad7084131d5f94af51c8bdb28cc6e313..e03c6e9ca00d6fbb5b813ec97866585d034c57f3 100644
--- a/headless/app/headless_shell.cc
+++ b/headless/app/headless_shell.cc
@@ -11,6 +11,7 @@
 #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"
@@ -26,6 +27,7 @@
 #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"
@@ -102,7 +104,11 @@ class HeadlessShell : public HeadlessWebContents::Observer,
     // 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();
@@ -319,28 +325,26 @@ class HeadlessShell : public HeadlessWebContents::Observer,
       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;
     }
 
@@ -349,19 +353,21 @@ class HeadlessShell : public HeadlessWebContents::Observer,
     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()
@@ -370,15 +376,15 @@ class HeadlessShell : public HeadlessWebContents::Observer,
       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 =
@@ -392,7 +398,7 @@ class HeadlessShell : public HeadlessWebContents::Observer,
   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_;