Update from chromium https://crrev.com/302282

net/disk_cache/simple/simple_index_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 "net/disk_cache/simple/simple_index_file.h"
 
 #include <vector>
 
+#include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/disk_cache/simple/simple_backend_version.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_index.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "third_party/zlib/zlib.h"
 
+using base::File;
+
 namespace disk_cache {
 namespace {
 
 const int kEntryFilesHashLength = 16;
 const int kEntryFilesSuffixLength = 2;
 
 const uint64 kMaxEntiresInIndex = 100000000;
 
 uint32 CalculatePickleCRC(const Pickle& pickle) {
   return crc32(crc32(0, Z_NULL, 0),
@@ skipping 24 matching lines @@
 };
 
 void UmaRecordIndexInitMethod(IndexInitMethod method,
                               net::CacheType cache_type) {
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "IndexInitializeMethod", cache_type,
                    method, INITIALIZE_METHOD_MAX);
 }
 
 bool WritePickleFile(Pickle* pickle, const base::FilePath& file_name) {
-  int bytes_written = base::WriteFile(
-      file_name, static_cast<const char*>(pickle->data()), pickle->size());
+  File file(
+      file_name,
+      File::FLAG_CREATE | File::FLAG_WRITE | File::FLAG_SHARE_DELETE);
+  if (!file.IsValid())
+    return false;
+
+  int bytes_written =
+      file.Write(0, static_cast<const char*>(pickle->data()), pickle->size());
   if (bytes_written != implicit_cast<int>(pickle->size())) {
-    base::DeleteFile(file_name, /* recursive = */ false);
+    simple_util::SimpleCacheDeleteFile(file_name);
     return false;
   }
   return true;
 }
 
 // Called for each cache directory traversal iteration.
 void ProcessEntryFile(SimpleIndex::EntrySet* entries,
                       const base::FilePath& file_path) {
   static const size_t kEntryFilesLength =
       kEntryFilesHashLength + kEntryFilesSuffixLength;
   // Converting to std::string is OK since we never use UTF8 wide chars in our
   // file names.
   const base::FilePath::StringType base_name = file_path.BaseName().value();
   const std::string file_name(base_name.begin(), base_name.end());
   if (file_name.size() != kEntryFilesLength)
     return;
   const base::StringPiece hash_string(
       file_name.begin(), file_name.begin() + kEntryFilesHashLength);
   uint64 hash_key = 0;
   if (!simple_util::GetEntryHashKeyFromHexString(hash_string, &hash_key)) {
     LOG(WARNING) << "Invalid entry hash key filename while restoring index from"
                  << " disk: " << file_name;
     return;
   }
 
-  base::File::Info file_info;
+  File::Info file_info;
   if (!base::GetFileInfo(file_path, &file_info)) {
     LOG(ERROR) << "Could not get file info for " << file_path.value();
     return;
   }
   base::Time last_used_time;
 #if defined(OS_POSIX)
   // For POSIX systems, a last access time is available. However, it's not
   // guaranteed to be more accurate than mtime. It is no worse though.
   last_used_time = file_info.last_accessed;
 #endif
@@ skipping 97 matching lines @@
       LOG(ERROR) << "Could not create a directory to hold the index file";
       return;
     }
     if (!WritePickleFile(pickle.get(), temp_index_filename)) {
       LOG(ERROR) << "Failed to write the temporary index file";
       return;
     }
   }
 
   // Atomically rename the temporary index file to become the real one.
-  bool result = base::ReplaceFile(temp_index_filename, index_filename, NULL);
-  DCHECK(result);
+  // TODO(gavinp): DCHECK when not shutting down, since that is very strange.
+  // The rename failing during shutdown is legal because it's legal to begin
+  // erasing a cache as soon as the destructor has been called.
+  if (!base::ReplaceFile(temp_index_filename, index_filename, NULL))
+    return;
 
   if (app_on_background) {
     SIMPLE_CACHE_UMA(TIMES,
                      "IndexWriteToDiskTime.Background", cache_type,
                      (base::TimeTicks::Now() - start_time));
   } else {
     SIMPLE_CACHE_UMA(TIMES,
                      "IndexWriteToDiskTime.Foreground", cache_type,
                      (base::TimeTicks::Now() - start_time));
   }
@@ skipping 97 matching lines @@
                      out_result->entries.size());
   }
 }
 
 // static
 void SimpleIndexFile::SyncLoadFromDisk(const base::FilePath& index_filename,
                                        base::Time* out_last_cache_seen_by_index,
                                        SimpleIndexLoadResult* out_result) {
   out_result->Reset();
 
+  File file(index_filename,
+            File::FLAG_OPEN | File::FLAG_READ | File::FLAG_SHARE_DELETE);
+  if (!file.IsValid())
+    return;
+
   base::MemoryMappedFile index_file_map;
-  if (!index_file_map.Initialize(index_filename)) {
-    LOG(WARNING) << "Could not map Simple Index file.";
-    base::DeleteFile(index_filename, false);
+  if (!index_file_map.Initialize(file.Pass())) {
+    simple_util::SimpleCacheDeleteFile(index_filename);
     return;
   }
 
   SimpleIndexFile::Deserialize(
       reinterpret_cast<const char*>(index_file_map.data()),
       index_file_map.length(),
       out_last_cache_seen_by_index,
       out_result);
 
   if (!out_result->did_load)
-    base::DeleteFile(index_filename, false);
+    simple_util::SimpleCacheDeleteFile(index_filename);
 }
 
 // static
 scoped_ptr<Pickle> SimpleIndexFile::Serialize(
     const SimpleIndexFile::IndexMetadata& index_metadata,
     const SimpleIndex::EntrySet& entries) {
   scoped_ptr<Pickle> pickle(new Pickle(sizeof(SimpleIndexFile::PickleHeader)));
 
   index_metadata.Serialize(pickle.get());
   for (SimpleIndex::EntrySet::const_iterator it = entries.begin();
@@ skipping 67 matching lines @@
 
   out_result->did_load = true;
 }
 
 // static
 void SimpleIndexFile::SyncRestoreFromDisk(
     const base::FilePath& cache_directory,
     const base::FilePath& index_file_path,
     SimpleIndexLoadResult* out_result) {
   VLOG(1) << "Simple Cache Index is being restored from disk.";
-  base::DeleteFile(index_file_path, /* recursive = */ false);
+  simple_util::SimpleCacheDeleteFile(index_file_path);
   out_result->Reset();
   SimpleIndex::EntrySet* entries = &out_result->entries;
 
   const bool did_succeed = TraverseCacheDirectory(
       cache_directory, base::Bind(&ProcessEntryFile, entries));
   if (!did_succeed) {
     LOG(ERROR) << "Could not reconstruct index from disk";
     return;
   }
   out_result->did_load = true;
   // When we restore from disk we write the merged index file to disk right
   // away, this might save us from having to restore again next time.
   out_result->flush_required = true;
 }
 
 // static
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache