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

net/disk_cache/simple/simple_synchronous_entry.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_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <limits>
@@ skipping 701 matching lines @@
   if (have_open_files_)
     CloseFiles();
 }
 
 bool SimpleSynchronousEntry::MaybeOpenFile(
     int file_index,
     File::Error* out_error) {
   DCHECK(out_error);
 
   FilePath filename = GetFilenameFromFileIndex(file_index);
-  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
+  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE |
+              File::FLAG_SHARE_DELETE;
   files_[file_index].Initialize(filename, flags);
   *out_error = files_[file_index].error_details();
 
   if (CanOmitEmptyFile(file_index) && !files_[file_index].IsValid() &&
       *out_error == File::FILE_ERROR_NOT_FOUND) {
     empty_file_omitted_[file_index] = true;
     return true;
   }
 
   return files_[file_index].IsValid();
 }
 
 bool SimpleSynchronousEntry::MaybeCreateFile(
     int file_index,
     FileRequired file_required,
     File::Error* out_error) {
   DCHECK(out_error);
 
   if (CanOmitEmptyFile(file_index) && file_required == FILE_NOT_REQUIRED) {
     empty_file_omitted_[file_index] = true;
     return true;
   }
 
   FilePath filename = GetFilenameFromFileIndex(file_index);
-  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
+  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE |
+              File::FLAG_SHARE_DELETE;
   files_[file_index].Initialize(filename, flags);
   *out_error = files_[file_index].error_details();
 
   empty_file_omitted_[file_index] = false;
 
   return files_[file_index].IsValid();
 }
 
 bool SimpleSynchronousEntry::OpenFiles(
     bool had_index,
@@ skipping 371 matching lines @@
   DeleteFilesForEntryHash(path_, entry_hash_);
 }
 
 // static
 bool SimpleSynchronousEntry::DeleteFileForEntryHash(
     const FilePath& path,
     const uint64 entry_hash,
     const int file_index) {
   FilePath to_delete = path.AppendASCII(
       GetFilenameFromEntryHashAndFileIndex(entry_hash, file_index));
-  return base::DeleteFile(to_delete, false);
+  return simple_util::SimpleCacheDeleteFile(to_delete);
 }
 
 // static
 bool SimpleSynchronousEntry::DeleteFilesForEntryHash(
     const FilePath& path,
     const uint64 entry_hash) {
   bool result = true;
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     if (!DeleteFileForEntryHash(path, entry_hash, i) && !CanOmitEmptyFile(i))
       result = false;
   }
   FilePath to_delete = path.AppendASCII(
       GetSparseFilenameFromEntryHash(entry_hash));
-  base::DeleteFile(to_delete, false);
+  simple_util::SimpleCacheDeleteFile(to_delete);
   return result;
 }
 
 void SimpleSynchronousEntry::RecordSyncCreateResult(CreateEntryResult result,
                                                     bool had_index) {
   DCHECK_LT(result, CREATE_ENTRY_MAX);
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "SyncCreateResult", cache_type_, result, CREATE_ENTRY_MAX);
   if (had_index) {
     SIMPLE_CACHE_UMA(ENUMERATION,
@@ skipping 10 matching lines @@
   return path_.AppendASCII(
       GetFilenameFromEntryHashAndFileIndex(entry_hash_, file_index));
 }
 
 bool SimpleSynchronousEntry::OpenSparseFileIfExists(
     int32* out_sparse_data_size) {
   DCHECK(!sparse_file_open());
 
   FilePath filename = path_.AppendASCII(
       GetSparseFilenameFromEntryHash(entry_hash_));
-  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
+  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE |
+              File::FLAG_SHARE_DELETE;
   sparse_file_.Initialize(filename, flags);
   if (sparse_file_.IsValid())
     return ScanSparseFile(out_sparse_data_size);
 
   return sparse_file_.error_details() == File::FILE_ERROR_NOT_FOUND;
 }
 
 bool SimpleSynchronousEntry::CreateSparseFile() {
   DCHECK(!sparse_file_open());
 
   FilePath filename = path_.AppendASCII(
       GetSparseFilenameFromEntryHash(entry_hash_));
-  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
+  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE |
+              File::FLAG_SHARE_DELETE;
   sparse_file_.Initialize(filename, flags);
   if (!sparse_file_.IsValid())
     return false;
 
   return InitializeSparseFile();
 }
 
 void SimpleSynchronousEntry::CloseSparseFile() {
   DCHECK(sparse_file_open());
   sparse_file_.Close();
@@ skipping 214 matching lines @@
   range.offset = offset;
   range.length = len;
   range.data_crc32 = data_crc32;
   range.file_offset = data_file_offset;
   sparse_ranges_.insert(std::make_pair(offset, range));
 
   return true;
 }
 
 }  // namespace disk_cache