Provide extra logging for GN's write_file on Windows

tools/gn/function_write_file.cc

 // Copyright (c) 2013 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 <sstream>
 
 #include "base/files/file_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 
 namespace functions {
 
+namespace {
+
+// On Windows, provide a custom implementation of base::WriteFile. Sometimes
+// the base version would fail, and this alternate implementation provides
+// additional logging. See http://crbug.com/468437
+#if defined(OS_WIN)
+int DoWriteFile(const base::FilePath& filename, const char* data, int size) {
+  base::win::ScopedHandle file(CreateFile(

[cpu_(ooo_6.6-7.5), 2015/04/23 20:55:05]

::CreateFile

for consistency with ::WriteFile.  :)

+      filename.value().c_str(),
+      GENERIC_WRITE,
+      FILE_SHARE_READ,  // Not present in the base version, speculative fix.
+      NULL,
+      CREATE_ALWAYS,
+      0,
+      NULL));
+  if (!file.IsValid()) {
+    PLOG(ERROR) << "CreateFile failed for path "
+                  << base::UTF16ToUTF8(filename.value());
+    return -1;
+  }
+
+  DWORD written;
+  BOOL result = ::WriteFile(file.Get(), data, size, &written, NULL);
+  if (result && static_cast<int>(written) == size)
+    return written;
+
+  if (!result) {
+    // WriteFile failed.
+    PLOG(ERROR) << "writing file " << base::UTF16ToUTF8(filename.value())
+                << " failed";
+  } else {
+    // Didn't write all the bytes.
+    LOG(ERROR) << "wrote" << written << " bytes to "
+               << base::UTF16ToUTF8(filename.value()) << " expected " << size;
+  }
+  return -1;
+}
+#else
+int DoWriteFile(const FilePath& filename, const char* data, int size) {
+  return base::WriteFile(filename, data, size);
+}
+#endif
+
+}  // namespace
+
 const char kWriteFile[] = "write_file";
 const char kWriteFile_HelpShort[] =
     "write_file: Write a file to disk.";
 const char kWriteFile_Help[] =
     "write_file: Write a file to disk.\n"
     "\n"
     "  write_file(filename, data)\n"
     "\n"
     "  If data is a list, the list will be written one-item-per-line with no\n"
     "  quoting or brackets.\n"
@@ skipping 54 matching lines @@
     return Value();  // Nothing to do.
 
   // Write file, creating the directory if necessary.
   if (!base::CreateDirectory(file_path.DirName())) {
     *err = Err(function->function(), "Unable to create directory.",
                "I was using \"" + FilePathToUTF8(file_path.DirName()) + "\".");
     return Value();
   }
 
   int int_size = static_cast<int>(new_contents.size());
-  if (base::WriteFile(file_path, new_contents.c_str(), int_size)
+  if (DoWriteFile(file_path, new_contents.c_str(), int_size)
       != int_size) {
     *err = Err(function->function(), "Unable to write file.",
                "I was writing \"" + FilePathToUTF8(file_path) + "\".");
     return Value();
   }
   return Value();
 }
 
 }  // namespace functions