Revert of [GN] Don't rewrite files with the same contents

tools/gn/visual_studio_writer.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 "tools/gn/visual_studio_writer.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
+#include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_extractors.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/path_output.h"
@@ skipping 123 matching lines @@
 // outlive the output.
 base::StringPiece FindParentDir(const std::string* path) {
   DCHECK(path && !path->empty());
   for (int i = static_cast<int>(path->size()) - 2; i >= 0; --i) {
     if (IsSlash((*path)[i]))
       return base::StringPiece(path->data(), i);
   }
   return base::StringPiece();
 }
 
+bool HasSameContent(std::stringstream& data_1, const base::FilePath& data_2) {
+  // Compare file sizes first. Quick and will save us some time if they are
+  // different sizes.
+  int64_t data_1_len = data_1.tellp();
+
+  int64_t data_2_len;
+  if (!base::GetFileSize(data_2, &data_2_len) || data_1_len != data_2_len)
+    return false;
+
+  std::string data_2_data;
+  data_2_data.resize(data_2_len);
+  if (!base::ReadFileToString(data_2, &data_2_data))
+    return false;
+
+  std::string data_1_data;
+  data_1_data = data_1.str();
+
+  return data_1_data == data_2_data;
+}
+
 }  // namespace
 
 VisualStudioWriter::SolutionEntry::SolutionEntry(const std::string& _name,
                                                  const std::string& _path,
                                                  const std::string& _guid)
     : name(_name), path(_path), guid(_guid), parent_folder(nullptr) {}
 
 VisualStudioWriter::SolutionEntry::~SolutionEntry() = default;
 
 VisualStudioWriter::VisualStudioWriter(const BuildSettings* build_settings)
@@ skipping 79 matching lines @@
   std::stringstream vcxproj_string_out;
   if (!WriteProjectFileContents(vcxproj_string_out, *projects_.back(), target,
                                 err)) {
     projects_.pop_back();
     return false;
   }
 
   // Only write the content to the file if it's different. That is
   // both a performance optimization and more importantly, prevents
   // Visual Studio from reloading the projects.
-  if (!WriteFileIfChanged(vcxproj_path, vcxproj_string_out.str(), err))
-    return false;
+  if (!HasSameContent(vcxproj_string_out, vcxproj_path)) {
+    std::string content = vcxproj_string_out.str();
+    int size = static_cast<int>(content.size());
+    if (base::WriteFile(vcxproj_path, content.c_str(), size) != size) {
+      *err = Err(Location(), "Couldn't open " + target->label().name() +
+                                 ".vcxproj for writing");
+      return false;
+    }
+  }
 
   base::FilePath filters_path = UTF8ToFilePath(vcxproj_path_str + ".filters");
+
   std::stringstream filters_string_out;
   WriteFiltersFileContents(filters_string_out, target);
-  return WriteFileIfChanged(filters_path, filters_string_out.str(), err);
+
+  if (!HasSameContent(filters_string_out, filters_path)) {
+    std::string content = filters_string_out.str();
+    int size = static_cast<int>(content.size());
+    if (base::WriteFile(filters_path, content.c_str(), size) != size) {
+      *err = Err(Location(), "Couldn't open " + target->label().name() +
+                                 ".vcxproj.filters for writing");
+      return false;
+    }
+  }
+
+  return true;
 }
 
 bool VisualStudioWriter::WriteProjectFileContents(
     std::ostream& out,
     const SolutionEntry& solution_project,
     const Target* target,
     Err* err) {
   PathOutput path_output(GetTargetOutputDir(target),
                          build_settings_->root_path_utf8(),
                          EscapingMode::ESCAPE_NONE);
@@ skipping 275 matching lines @@
     return false;
 
   base::FilePath sln_path = build_settings_->GetFullPath(sln_file);
 
   std::stringstream string_out;
   WriteSolutionFileContents(string_out, sln_path.DirName());
 
   // Only write the content to the file if it's different. That is
   // both a performance optimization and more importantly, prevents
   // Visual Studio from reloading the projects.
-  return WriteFileIfChanged(sln_path, string_out.str(), err);
+  if (HasSameContent(string_out, sln_path))
+    return true;
+
+  std::string content = string_out.str();
+  int size = static_cast<int>(content.size());
+  if (base::WriteFile(sln_path, content.c_str(), size) != size) {
+    *err = Err(Location(), "Couldn't open all.sln for writing");
+    return false;
+  }
+
+  return true;
 }
 
 void VisualStudioWriter::WriteSolutionFileContents(
     std::ostream& out,
     const base::FilePath& solution_dir_path) {
   out << "Microsoft Visual Studio Solution File, Format Version 12.00"
       << std::endl;
   out << "# Visual Studio 2015" << std::endl;
 
   SourceDir solution_dir(FilePathToUTF8(solution_dir_path));
@@ skipping 135 matching lines @@
                            base::CompareCase::SENSITIVE)) {
         folder->parent_folder = parents.back();
         break;
       } else {
         parents.pop_back();
       }
     }
     parents.push_back(folder);
   }
 }