Make synchronous methods on disk_cache::SimpleEntryImpl() reentrant.

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 <limits>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/sha1.h"
 #include "base/stringprintf.h"
 #include "base/task_runner.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/disk_cache/simple/simple_disk_format.h"
 
 using base::ClosePlatformFile;
 using base::FilePath;
 using base::GetPlatformFileInfo;
 using base::PlatformFileError;
 using base::PlatformFileInfo;
 using base::PLATFORM_FILE_CREATE;
 using base::PLATFORM_FILE_OK;
 using base::PLATFORM_FILE_OPEN;
 using base::PLATFORM_FILE_READ;
@@ skipping 63 matching lines @@
   }
   callback_runner->PostTask(FROM_HERE, base::Bind(callback, sync_entry));
 }
 
 // static
 void SimpleSynchronousEntry::DoomEntry(
     const FilePath& path,
     const std::string& key,
     scoped_refptr<TaskRunner> callback_runner,
     const net::CompletionCallback& callback) {
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     FilePath to_delete = path.AppendASCII(GetFilenameForKeyAndIndex(key, i));
     bool ALLOW_UNUSED result = file_util::Delete(to_delete, false);
     DLOG_IF(ERROR, !result) << "Could not delete " << to_delete.MaybeAsASCII();
   }
   if (!callback.is_null())
     callback_runner->PostTask(FROM_HERE, base::Bind(callback, net::OK));
 }
 
 void SimpleSynchronousEntry::DoomAndClose() {
   scoped_refptr<TaskRunner> callback_runner = callback_runner_;
   FilePath path = path_;
   std::string key = key_;
 
   Close();
   // |this| is now deleted.
 
   DoomEntry(path, key, callback_runner, net::CompletionCallback());
 }
 
 void SimpleSynchronousEntry::Close() {
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     bool ALLOW_UNUSED result = ClosePlatformFile(files_[i]);
     DLOG_IF(INFO, !result) << "Could not Close() file.";
   }
   delete this;
 }
 
 void SimpleSynchronousEntry::ReadData(
     int index,
     int offset,
     net::IOBuffer* buf,
@@ skipping 48 matching lines @@
     : callback_runner_(callback_runner),
       path_(path),
       key_(key),
       initialized_(false) {
 }
 
 SimpleSynchronousEntry::~SimpleSynchronousEntry() {
 }
 
 bool SimpleSynchronousEntry::OpenOrCreateFiles(bool create) {
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     FilePath filename = path_.AppendASCII(GetFilenameForKeyAndIndex(key_, i));
     int flags = PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
     if (create)
       flags |= PLATFORM_FILE_CREATE;
     else
       flags |= PLATFORM_FILE_OPEN;
     PlatformFileError error;
     files_[i] = CreatePlatformFile(filename, flags, NULL, &error);
     if (error != PLATFORM_FILE_OK) {
       DVLOG(8) << "CreatePlatformFile error " << error << " while "
                << (create ? "creating " : "opening ")
                << filename.MaybeAsASCII();
       while (--i >= 0) {
         bool ALLOW_UNUSED did_close = ClosePlatformFile(files_[i]);
         DLOG_IF(INFO, !did_close) << "Could not close file "
                                   << filename.MaybeAsASCII();
       }
       return false;
     }
   }
 
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     PlatformFileInfo file_info;
     bool success = GetPlatformFileInfo(files_[i], &file_info);
     if (!success) {
       DLOG(WARNING) << "Could not get platform file info.";
       continue;
     }
     last_used_ = std::max(last_used_, file_info.last_accessed);
     last_modified_ = std::max(last_modified_, file_info.last_modified);
     data_size_[i] = DataSizeFromKeyAndFileSize(key_.size(), file_info.size);
   }
 
   return true;
 }
 
 bool SimpleSynchronousEntry::InitializeForOpen() {
   DCHECK(!initialized_);
   if (!OpenOrCreateFiles(false))
     return false;
 
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     SimpleFileHeader header;
     int header_read_result =
         ReadPlatformFile(files_[i], 0, reinterpret_cast<char*>(&header),
                          sizeof(header));
     if (header_read_result != sizeof(header)) {
       DLOG(WARNING) << "Cannot read header from entry.";
       return false;
     }
 
     if (header.initial_magic_number != kSimpleInitialMagicNumber) {
@@ skipping 35 matching lines @@
   return true;
 }
 
 bool SimpleSynchronousEntry::InitializeForCreate() {
   DCHECK(!initialized_);
   if (!OpenOrCreateFiles(true)) {
     DLOG(WARNING) << "Could not create platform files.";
     return false;
   }
 
-  for (int i = 0; i < kIndexCount; ++i) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     SimpleFileHeader header;
     header.initial_magic_number = kSimpleInitialMagicNumber;
     header.version = kSimpleVersion;
 
     header.key_length = key_.size();
     header.key_hash = base::Hash(key_);
 
     if (WritePlatformFile(files_[i], 0, reinterpret_cast<char*>(&header),
                           sizeof(header)) != sizeof(header)) {
       // TODO(gavinp): Clean up created files.
       DLOG(WARNING) << "Could not write headers to new cache entry.";
       return false;
     }
 
     if (WritePlatformFile(files_[i], sizeof(header), key_.data(),
                           key_.size()) != implicit_cast<int>(key_.size())) {
       // TODO(gavinp): Clean up created files.
       DLOG(WARNING) << "Could not write keys to new cache entry.";
       return false;
     }
   }
 
   initialized_ = true;
   return true;
 }
 
 }  // namespace disk_cache