Convert most of base and net to use base::File

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>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/sha1.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_backend_version.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "third_party/zlib/zlib.h"
 
-using base::kInvalidPlatformFileValue;
-using base::ClosePlatformFile;
+using base::File;
 using base::FilePath;
-using base::GetPlatformFileInfo;
-using base::PlatformFileError;
-using base::PlatformFileInfo;
-using base::PLATFORM_FILE_CREATE;
-using base::PLATFORM_FILE_ERROR_EXISTS;
-using base::PLATFORM_FILE_ERROR_NOT_FOUND;
-using base::PLATFORM_FILE_OK;
-using base::PLATFORM_FILE_OPEN;
-using base::PLATFORM_FILE_OPEN_ALWAYS;
-using base::PLATFORM_FILE_READ;
-using base::PLATFORM_FILE_WRITE;
-using base::ReadPlatformFile;
 using base::Time;
-using base::TruncatePlatformFile;
-using base::WritePlatformFile;
 
 namespace {
 
 // Used in histograms, please only add entries at the end.
 enum OpenEntryResult {
   OPEN_ENTRY_SUCCESS = 0,
   OPEN_ENTRY_PLATFORM_FILE_ERROR = 1,
   OPEN_ENTRY_CANT_READ_HEADER = 2,
   OPEN_ENTRY_BAD_MAGIC_NUMBER = 3,
   OPEN_ENTRY_BAD_VERSION = 4,
@@ skipping 240 matching lines @@
                                       int* out_result) const {
   DCHECK(initialized_);
   DCHECK_NE(0, in_entry_op.index);
   const int64 file_offset =
       entry_stat->GetOffsetInFile(key_, in_entry_op.offset, in_entry_op.index);
   int file_index = GetFileIndexFromStreamIndex(in_entry_op.index);
   // Zero-length reads and reads to the empty streams of omitted files should
   // be handled in the SimpleEntryImpl.
   DCHECK_LT(0, in_entry_op.buf_len);
   DCHECK(!empty_file_omitted_[file_index]);
-  int bytes_read = ReadPlatformFile(
-      files_[file_index], file_offset, out_buf->data(), in_entry_op.buf_len);
+  File* file = const_cast<File*>(&files_[file_index]);
+  int bytes_read =
+      file->Read(file_offset, out_buf->data(), in_entry_op.buf_len);
   if (bytes_read > 0) {
     entry_stat->set_last_used(Time::Now());
     *out_crc32 = crc32(crc32(0L, Z_NULL, 0),
                        reinterpret_cast<const Bytef*>(out_buf->data()),
                        bytes_read);
   }
   if (bytes_read >= 0) {
     *out_result = bytes_read;
   } else {
     *out_result = net::ERR_CACHE_READ_FAILURE;
@@ skipping 20 matching lines @@
   if (empty_file_omitted_[file_index]) {
     // Don't create a new file if the entry has been doomed, to avoid it being
     // mixed up with a newly-created entry with the same key.
     if (doomed) {
       DLOG(WARNING) << "Rejecting write to lazily omitted stream "
                     << in_entry_op.index << " of doomed cache entry.";
       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_STREAM_ENTRY_DOOMED);
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
-    PlatformFileError error;
+    File::Error error;
     if (!MaybeCreateFile(file_index, FILE_REQUIRED, &error)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_CREATE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
     CreateEntryResult result;
     if (!InitializeCreatedFile(file_index, &result)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_LAZY_INITIALIZE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
   }
   DCHECK(!empty_file_omitted_[file_index]);
 
   if (extending_by_write) {
     // The EOF record and the eventual stream afterward need to be zeroed out.
     const int64 file_eof_offset =
         out_entry_stat->GetEOFOffsetInFile(key_, index);
-    if (!TruncatePlatformFile(files_[file_index], file_eof_offset)) {
+    if (!files_[file_index].SetLength(file_eof_offset)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_PRETRUNCATE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
   }
   if (buf_len > 0) {
-    if (WritePlatformFile(
-            files_[file_index], file_offset, in_buf->data(), buf_len) !=
+    if (files_[file_index].Write(file_offset, in_buf->data(), buf_len) !=
         buf_len) {
       RecordWriteResult(cache_type_, WRITE_RESULT_WRITE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
   }
   if (!truncate && (buf_len > 0 || !extending_by_write)) {
     out_entry_stat->set_data_size(
         index, std::max(out_entry_stat->data_size(index), offset + buf_len));
   } else {
     out_entry_stat->set_data_size(index, offset + buf_len);
     int file_eof_offset = out_entry_stat->GetLastEOFOffsetInFile(key_, index);
-    if (!TruncatePlatformFile(files_[file_index], file_eof_offset)) {
+    if (!files_[file_index].SetLength(file_eof_offset)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_TRUNCATE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
   }
 
   RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
   base::Time modification_time = Time::Now();
   out_entry_stat->set_last_used(modification_time);
@@ skipping 80 matching lines @@
 
   if (!sparse_file_open() && !CreateSparseFile()) {
     *out_result = net::ERR_CACHE_WRITE_FAILURE;
     return;
   }
 
   int64 sparse_data_size = out_entry_stat->sparse_data_size();
   // This is a pessimistic estimate; it assumes the entire buffer is going to
   // be appended as a new range, not written over existing ranges.
   if (sparse_data_size + buf_len > max_sparse_data_size) {
-    DLOG(INFO) << "Truncating sparse data file (" << sparse_data_size << " + "
-               << buf_len << " > " << max_sparse_data_size << ")";
+    DVLOG(1) << "Truncating sparse data file (" << sparse_data_size << " + "
+             << buf_len << " > " << max_sparse_data_size << ")";
     TruncateSparseFile();
   }
 
   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 
   if (it != sparse_ranges_.begin()) {
     --it;
     SparseRange* found_range = &it->second;
     if (found_range->offset + found_range->length > offset) {
       DCHECK_LE(0, found_range->length);
@@ skipping 114 matching lines @@
   uint32 crc32;
   bool has_crc32;
   int stream_size;
   *out_result =
       GetEOFRecordData(index, entry_stat, &has_crc32, &crc32, &stream_size);
   if (*out_result != net::OK) {
     Doom();
     return;
   }
   if (has_crc32 && crc32 != expected_crc32) {
-    DLOG(INFO) << "EOF record had bad crc.";
+    DVLOG(1) << "EOF record had bad crc.";

[Nico, 2014/01/08 23:40:16]

Is this ever interesting? Can all these log statements just be removed?

[rvargas (doing something else), 2014/01/09 04:11:46]

I don't think they are interesting. That's a good follow up question :)

     *out_result = net::ERR_CACHE_CHECKSUM_MISMATCH;
     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
     Doom();
     return;
   }
   RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
 }
 
 void SimpleSynchronousEntry::Close(
     const SimpleEntryStat& entry_stat,
     scoped_ptr<std::vector<CRCRecord> > crc32s_to_write,
     net::GrowableIOBuffer* stream_0_data) {
   DCHECK(stream_0_data);
   // Write stream 0 data.
   int stream_0_offset = entry_stat.GetOffsetInFile(key_, 0, 0);
-  if (WritePlatformFile(files_[0],
-                        stream_0_offset,
-                        stream_0_data->data(),
-                        entry_stat.data_size(0)) != entry_stat.data_size(0)) {
+  if (files_[0].Write(stream_0_offset, stream_0_data->data(),
+                      entry_stat.data_size(0)) !=
+      entry_stat.data_size(0)) {
     RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
-    DLOG(INFO) << "Could not write stream 0 data.";
+    DVLOG(1) << "Could not write stream 0 data.";
     Doom();
   }
 
   for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin();
        it != crc32s_to_write->end(); ++it) {
     const int stream_index = it->index;
     const int file_index = GetFileIndexFromStreamIndex(stream_index);
     if (empty_file_omitted_[file_index])
       continue;
 
     SimpleFileEOF eof_record;
     eof_record.stream_size = entry_stat.data_size(stream_index);
     eof_record.final_magic_number = kSimpleFinalMagicNumber;
     eof_record.flags = 0;
     if (it->has_crc32)
       eof_record.flags |= SimpleFileEOF::FLAG_HAS_CRC32;
     eof_record.data_crc32 = it->data_crc32;
     int eof_offset = entry_stat.GetEOFOffsetInFile(key_, stream_index);
     // If stream 0 changed size, the file needs to be resized, otherwise the
     // next open will yield wrong stream sizes. On stream 1 and stream 2 proper
     // resizing of the file is handled in SimpleSynchronousEntry::WriteData().
     if (stream_index == 0 &&
-        !TruncatePlatformFile(files_[file_index], eof_offset)) {
+        !files_[file_index].SetLength(eof_offset)) {
       RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
-      DLOG(INFO) << "Could not truncate stream 0 file.";
+      DVLOG(1) << "Could not truncate stream 0 file.";
       Doom();
       break;
     }
-    if (WritePlatformFile(files_[file_index],
-                          eof_offset,
-                          reinterpret_cast<const char*>(&eof_record),
-                          sizeof(eof_record)) != sizeof(eof_record)) {
+    if (files_[file_index].Write(eof_offset,
+                                 reinterpret_cast<const char*>(&eof_record),
+                                 sizeof(eof_record)) !=
+        sizeof(eof_record)) {
       RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
-      DLOG(INFO) << "Could not write eof record.";
+      DVLOG(1) << "Could not write eof record.";
       Doom();
       break;
     }
   }
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     if (empty_file_omitted_[i])
       continue;
 
-    bool did_close_file = ClosePlatformFile(files_[i]);
-    DCHECK(did_close_file);
+    files_[i].Close();
     const int64 file_size = entry_stat.GetFileSize(key_, i);
     SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
                      "LastClusterSize", cache_type_,
                      file_size % 4096, 0, 4097, 50);
     const int64 cluster_loss = file_size % 4096 ? 4096 - file_size % 4096 : 0;
     SIMPLE_CACHE_UMA(PERCENTAGE,
                      "LastClusterLossPercent", cache_type_,
                      cluster_loss * 100 / (cluster_loss + file_size));
   }
 
-  if (sparse_file_open()) {
-    bool did_close_file = ClosePlatformFile(sparse_file_);
-    CHECK(did_close_file);
-  }
+  if (sparse_file_open())
+    sparse_file_.Close();
 
   if (files_created_) {
     const int stream2_file_index = GetFileIndexFromStreamIndex(2);
     SIMPLE_CACHE_UMA(BOOLEAN, "EntryCreatedAndStream2Omitted", cache_type_,
                      empty_file_omitted_[stream2_file_index]);
   }
   RecordCloseResult(cache_type_, CLOSE_RESULT_SUCCESS);
   have_open_files_ = false;
   delete this;
 }
 
 SimpleSynchronousEntry::SimpleSynchronousEntry(net::CacheType cache_type,
                                                const FilePath& path,
                                                const std::string& key,
                                                const uint64 entry_hash)
     : cache_type_(cache_type),
       path_(path),
       entry_hash_(entry_hash),
       key_(key),
       have_open_files_(false),
-      initialized_(false),
-      sparse_file_(kInvalidPlatformFileValue) {
-  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
-    files_[i] = kInvalidPlatformFileValue;
+      initialized_(false) {
+  for (int i = 0; i < kSimpleEntryFileCount; ++i)
     empty_file_omitted_[i] = false;
-  }
 }
 
 SimpleSynchronousEntry::~SimpleSynchronousEntry() {
   DCHECK(!(have_open_files_ && initialized_));
   if (have_open_files_)
     CloseFiles();
 }
 
 bool SimpleSynchronousEntry::MaybeOpenFile(
     int file_index,
-    PlatformFileError* out_error) {
+    File::Error* out_error) {
   DCHECK(out_error);
 
   FilePath filename = GetFilenameFromFileIndex(file_index);
-  int flags = PLATFORM_FILE_OPEN | PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
-  files_[file_index] = CreatePlatformFile(filename, flags, NULL, out_error);
+  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
+  files_[file_index].Initialize(filename, flags);
+  *out_error = files_[file_index].error_details();
 
-  if (CanOmitEmptyFile(file_index) &&
-      *out_error == PLATFORM_FILE_ERROR_NOT_FOUND) {
+  if (CanOmitEmptyFile(file_index) && !files_[file_index].IsValid() &&
+      *out_error == File::FILE_ERROR_NOT_FOUND) {
     empty_file_omitted_[file_index] = true;
     return true;
   }
 
-  return *out_error == PLATFORM_FILE_OK;
+  return files_[file_index].IsValid();
 }
 
 bool SimpleSynchronousEntry::MaybeCreateFile(
     int file_index,
     FileRequired file_required,
-    PlatformFileError* out_error) {
+    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 = PLATFORM_FILE_CREATE | PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
-  files_[file_index] = CreatePlatformFile(filename, flags, NULL, out_error);
+  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
+  files_[file_index].Initialize(filename, flags);
+  *out_error = files_[file_index].error_details();
 
   empty_file_omitted_[file_index] = false;
 
-  return *out_error == PLATFORM_FILE_OK;
+  return files_[file_index].IsValid();
 }
 
 bool SimpleSynchronousEntry::OpenFiles(
     bool had_index,
     SimpleEntryStat* out_entry_stat) {
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
-    PlatformFileError error;
+    File::Error error;
     if (!MaybeOpenFile(i, &error)) {
       // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms.
       // We can calculate the third as the sum or difference of the other two.
       RecordSyncOpenResult(
           cache_type_, OPEN_ENTRY_PLATFORM_FILE_ERROR, had_index);
       SIMPLE_CACHE_UMA(ENUMERATION,
                        "SyncOpenPlatformFileError", cache_type_,
                        -error, -base::PLATFORM_FILE_ERROR_MAX);
       if (had_index) {
         SIMPLE_CACHE_UMA(ENUMERATION,
@@ skipping 13 matching lines @@
 
   have_open_files_ = true;
 
   base::TimeDelta entry_age = base::Time::Now() - base::Time::UnixEpoch();
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     if (empty_file_omitted_[i]) {
       out_entry_stat->set_data_size(i + 1, 0);
       continue;
     }
 
-    PlatformFileInfo file_info;
-    bool success = GetPlatformFileInfo(files_[i], &file_info);
+    File::Info file_info;
+    bool success = files_[i].GetInfo(&file_info);
     base::Time file_last_modified;
     if (!success) {
       DLOG(WARNING) << "Could not get platform file info.";
       continue;
     }
     out_entry_stat->set_last_used(file_info.last_accessed);
     if (simple_util::GetMTime(path_, &file_last_modified))
       out_entry_stat->set_last_modified(file_last_modified);
     else
       out_entry_stat->set_last_modified(file_info.last_modified);
@@ skipping 24 matching lines @@
 
   files_created_ = false;
 
   return true;
 }
 
 bool SimpleSynchronousEntry::CreateFiles(
     bool had_index,
     SimpleEntryStat* out_entry_stat) {
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
-    PlatformFileError error;
+    File::Error error;
     if (!MaybeCreateFile(i, FILE_NOT_REQUIRED, &error)) {
       // TODO(ttuttle,gavinp): Remove one each of these triplets of histograms.
       // We can calculate the third as the sum or difference of the other two.
       RecordSyncCreateResult(CREATE_ENTRY_PLATFORM_FILE_ERROR, had_index);
       SIMPLE_CACHE_UMA(ENUMERATION,
                        "SyncCreatePlatformFileError", cache_type_,
                        -error, -base::PLATFORM_FILE_ERROR_MAX);
       if (had_index) {
         SIMPLE_CACHE_UMA(ENUMERATION,
                          "SyncCreatePlatformFileError_WithIndex", cache_type_,
@@ skipping 20 matching lines @@
 
   files_created_ = true;
 
   return true;
 }
 
 void SimpleSynchronousEntry::CloseFile(int index) {
   if (empty_file_omitted_[index]) {
     empty_file_omitted_[index] = false;
   } else {
-    DCHECK_NE(kInvalidPlatformFileValue, files_[index]);
-    bool did_close = ClosePlatformFile(files_[index]);
-    DCHECK(did_close);
-    files_[index] = kInvalidPlatformFileValue;
+    DCHECK(files_[index].IsValid());
+    files_[index].Close();
   }
 
-  if (sparse_file_open()) {
-    bool did_close = CloseSparseFile();
-    DCHECK(did_close);
-  }
+  if (sparse_file_open())
+    CloseSparseFile();
 }
 
 void SimpleSynchronousEntry::CloseFiles() {
   for (int i = 0; i < kSimpleEntryFileCount; ++i)
     CloseFile(i);
 }
 
 int SimpleSynchronousEntry::InitializeForOpen(
     bool had_index,
     SimpleEntryStat* out_entry_stat,
     scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
     uint32* out_stream_0_crc32) {
   DCHECK(!initialized_);
   if (!OpenFiles(had_index, out_entry_stat)) {
     DLOG(WARNING) << "Could not open platform files for entry.";
     return net::ERR_FAILED;
   }
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     if (empty_file_omitted_[i])
       continue;
 
     SimpleFileHeader header;
     int header_read_result =
-        ReadPlatformFile(files_[i], 0, reinterpret_cast<char*>(&header),
-                         sizeof(header));
+        files_[i].Read(0, reinterpret_cast<char*>(&header), sizeof(header));
     if (header_read_result != sizeof(header)) {
       DLOG(WARNING) << "Cannot read header from entry.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_HEADER, had_index);
       return net::ERR_FAILED;
     }
 
     if (header.initial_magic_number != kSimpleInitialMagicNumber) {
       // TODO(gavinp): This seems very bad; for now we log at WARNING, but we
       // should give consideration to not saturating the log with these if that
       // becomes a problem.
       DLOG(WARNING) << "Magic number did not match.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_MAGIC_NUMBER, had_index);
       return net::ERR_FAILED;
     }
 
     if (header.version != kSimpleEntryVersionOnDisk) {
       DLOG(WARNING) << "Unreadable version.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_VERSION, had_index);
       return net::ERR_FAILED;
     }
 
     scoped_ptr<char[]> key(new char[header.key_length]);
-    int key_read_result = ReadPlatformFile(files_[i], sizeof(header),
-                                           key.get(), header.key_length);
+    int key_read_result = files_[i].Read(sizeof(header), key.get(),
+                                         header.key_length);
     if (key_read_result != implicit_cast<int>(header.key_length)) {
       DLOG(WARNING) << "Cannot read key from entry.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_KEY, had_index);
       return net::ERR_FAILED;
     }
 
     key_ = std::string(key.get(), header.key_length);
     if (i == 0) {
       // File size for stream 0 has been stored temporarily in data_size[1].
       int total_data_size =
@@ skipping 25 matching lines @@
         cache_type_, OPEN_ENTRY_SPARSE_OPEN_FAILED, had_index);
     return net::ERR_FAILED;
   }
   out_entry_stat->set_sparse_data_size(sparse_data_size);
 
   bool removed_stream2 = false;
   const int stream2_file_index = GetFileIndexFromStreamIndex(2);
   DCHECK(CanOmitEmptyFile(stream2_file_index));
   if (!empty_file_omitted_[stream2_file_index] &&
       out_entry_stat->data_size(2) == 0) {
-    DLOG(INFO) << "Removing empty stream 2 file.";
+    DVLOG(1) << "Removing empty stream 2 file.";
     CloseFile(stream2_file_index);
     DeleteFileForEntryHash(path_, entry_hash_, stream2_file_index);
     empty_file_omitted_[stream2_file_index] = true;
     removed_stream2 = true;
   }
 
   SIMPLE_CACHE_UMA(BOOLEAN, "EntryOpenedAndStream2Removed", cache_type_,
                    removed_stream2);
 
   RecordSyncOpenResult(cache_type_, OPEN_ENTRY_SUCCESS, had_index);
   initialized_ = true;
   return net::OK;
 }
 
 bool SimpleSynchronousEntry::InitializeCreatedFile(
     int file_index,
     CreateEntryResult* out_result) {
   SimpleFileHeader header;
   header.initial_magic_number = kSimpleInitialMagicNumber;
   header.version = kSimpleEntryVersionOnDisk;
 
   header.key_length = key_.size();
   header.key_hash = base::Hash(key_);
 
-  int bytes_written = WritePlatformFile(
-      files_[file_index], 0, reinterpret_cast<char*>(&header), sizeof(header));
+  int bytes_written = files_[file_index].Write(
+      0, reinterpret_cast<char*>(&header), sizeof(header));
   if (bytes_written != sizeof(header)) {
     *out_result = CREATE_ENTRY_CANT_WRITE_HEADER;
     return false;
   }
 
-  bytes_written = WritePlatformFile(
-      files_[file_index], sizeof(header), key_.data(), key_.size());
+  bytes_written = files_[file_index].Write(sizeof(header), key_.data(),
+                                           key_.size());
   if (bytes_written != implicit_cast<int>(key_.size())) {
     *out_result = CREATE_ENTRY_CANT_WRITE_KEY;
     return false;
   }
 
   return true;
 }
 
 int SimpleSynchronousEntry::InitializeForCreate(
     bool had_index,
@@ skipping 41 matching lines @@
 
   // These are the real values of data size.
   out_entry_stat->set_data_size(0, stream_0_size);
   out_entry_stat->set_data_size(
       1, out_entry_stat->data_size(1) - stream_0_size);
 
   // Put stream 0 data in memory.
   *stream_0_data = new net::GrowableIOBuffer();
   (*stream_0_data)->SetCapacity(stream_0_size);
   int file_offset = out_entry_stat->GetOffsetInFile(key_, 0, 0);
-  int bytes_read = ReadPlatformFile(
-      files_[0], file_offset, (*stream_0_data)->data(), stream_0_size);
+  File* file = const_cast<File*>(&files_[0]);
+  int bytes_read =
+      file->Read(file_offset, (*stream_0_data)->data(), stream_0_size);
   if (bytes_read != stream_0_size)
     return net::ERR_FAILED;
 
   // Check the CRC32.
   uint32 expected_crc32 =
       stream_0_size == 0
           ? crc32(0, Z_NULL, 0)
           : crc32(crc32(0, Z_NULL, 0),
                   reinterpret_cast<const Bytef*>((*stream_0_data)->data()),
                   stream_0_size);
   if (has_crc32 && read_crc32 != expected_crc32) {
-    DLOG(INFO) << "EOF record had bad crc.";
+    DVLOG(1) << "EOF record had bad crc.";
     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
     return net::ERR_FAILED;
   }
   *out_stream_0_crc32 = expected_crc32;
   RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
   return net::OK;
 }
 
 int SimpleSynchronousEntry::GetEOFRecordData(int index,
                                              const SimpleEntryStat& entry_stat,
                                              bool* out_has_crc32,
                                              uint32* out_crc32,
                                              int* out_data_size) const {
   SimpleFileEOF eof_record;
   int file_offset = entry_stat.GetEOFOffsetInFile(key_, index);
   int file_index = GetFileIndexFromStreamIndex(index);
-  if (ReadPlatformFile(files_[file_index],
-                       file_offset,
-                       reinterpret_cast<char*>(&eof_record),
-                       sizeof(eof_record)) != sizeof(eof_record)) {
+  File* file = const_cast<File*>(&files_[file_index]);
+  if (file->Read(file_offset, reinterpret_cast<char*>(&eof_record),
+                 sizeof(eof_record)) !=
+      sizeof(eof_record)) {
     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_READ_FAILURE);
     return net::ERR_CACHE_CHECKSUM_READ_FAILURE;
   }
 
   if (eof_record.final_magic_number != kSimpleFinalMagicNumber) {
     RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH);
-    DLOG(INFO) << "EOF record had bad magic number.";
+    DVLOG(1) << "EOF record had bad magic number.";
     return net::ERR_CACHE_CHECKSUM_READ_FAILURE;
   }
 
   *out_has_crc32 = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) ==
                    SimpleFileEOF::FLAG_HAS_CRC32;
   *out_crc32 = eof_record.data_crc32;
   *out_data_size = eof_record.stream_size;
   SIMPLE_CACHE_UMA(BOOLEAN, "SyncCheckEOFHasCrc", cache_type_, *out_has_crc32);
   return net::OK;
 }
@@ skipping 47 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 = PLATFORM_FILE_OPEN | PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
-  bool created;
-  PlatformFileError error;
-  sparse_file_ = CreatePlatformFile(filename, flags, &created, &error);
-  if (error == PLATFORM_FILE_ERROR_NOT_FOUND)
-    return true;
+  int flags = File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE;
+  sparse_file_.Initialize(filename, flags);
+  if (sparse_file_.IsValid())
+    return ScanSparseFile(out_sparse_data_size);
 
-  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 = PLATFORM_FILE_CREATE | PLATFORM_FILE_READ | PLATFORM_FILE_WRITE;
-  bool created;
-  PlatformFileError error;
-  sparse_file_ = CreatePlatformFile(filename, flags, &created, &error);
-  if (error != PLATFORM_FILE_OK)
+  int flags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE;
+  sparse_file_.Initialize(filename, flags);
+  if (!sparse_file_.IsValid())
     return false;
 
   return InitializeSparseFile();
 }
 
-bool SimpleSynchronousEntry::CloseSparseFile() {
+void SimpleSynchronousEntry::CloseSparseFile() {
   DCHECK(sparse_file_open());
-
-  bool did_close = ClosePlatformFile(sparse_file_);
-  if (did_close)
-    sparse_file_ = kInvalidPlatformFileValue;
-  return did_close;
+  sparse_file_.Close();
 }
 
 bool SimpleSynchronousEntry::TruncateSparseFile() {
   DCHECK(sparse_file_open());
 
   int64 header_and_key_length = sizeof(SimpleFileHeader) + key_.size();
-  if (!TruncatePlatformFile(sparse_file_, header_and_key_length)) {
+  if (!sparse_file_.SetLength(header_and_key_length)) {
     DLOG(WARNING) << "Could not truncate sparse file";
     return false;
   }
 
   sparse_ranges_.clear();
 
   return true;
 }
 
 bool SimpleSynchronousEntry::InitializeSparseFile() {
   DCHECK(sparse_file_open());
 
   SimpleFileHeader header;
   header.initial_magic_number = kSimpleInitialMagicNumber;
   header.version = kSimpleVersion;
   header.key_length = key_.size();
   header.key_hash = base::Hash(key_);
 
   int header_write_result =
-      WritePlatformFile(sparse_file_, 0, reinterpret_cast<char*>(&header),
-                        sizeof(header));
+      sparse_file_.Write(0, reinterpret_cast<char*>(&header), sizeof(header));
   if (header_write_result != sizeof(header)) {
     DLOG(WARNING) << "Could not write sparse file header";
     return false;
   }
 
-  int key_write_result = WritePlatformFile(sparse_file_, sizeof(header),
-                                           key_.data(), key_.size());
+  int key_write_result = sparse_file_.Write(sizeof(header), key_.data(),
+                                            key_.size());
   if (key_write_result != implicit_cast<int>(key_.size())) {
     DLOG(WARNING) << "Could not write sparse file key";
     return false;
   }
 
   sparse_ranges_.clear();
   sparse_tail_offset_ = sizeof(header) + key_.size();
 
   return true;
 }
 
 bool SimpleSynchronousEntry::ScanSparseFile(int32* out_sparse_data_size) {
   DCHECK(sparse_file_open());
 
   int32 sparse_data_size = 0;
 
   SimpleFileHeader header;
   int header_read_result =
-      ReadPlatformFile(sparse_file_, 0, reinterpret_cast<char*>(&header),
-                       sizeof(header));
+      sparse_file_.Read(0, reinterpret_cast<char*>(&header), sizeof(header));
   if (header_read_result != sizeof(header)) {
     DLOG(WARNING) << "Could not read header from sparse file.";
     return false;
   }
 
   if (header.initial_magic_number != kSimpleInitialMagicNumber) {
     DLOG(WARNING) << "Sparse file magic number did not match.";
     return false;
   }
 
   if (header.version != kSimpleVersion) {
     DLOG(WARNING) << "Sparse file unreadable version.";
     return false;
   }
 
   sparse_ranges_.clear();
 
   int64 range_header_offset = sizeof(header) + key_.size();
   while (1) {
     SimpleFileSparseRangeHeader range_header;
     int range_header_read_result =
-        ReadPlatformFile(sparse_file_,
-                         range_header_offset,
-                         reinterpret_cast<char*>(&range_header),
-                         sizeof(range_header));
+        sparse_file_.Read(range_header_offset,
+                          reinterpret_cast<char*>(&range_header),
+                          sizeof(range_header));
     if (range_header_read_result == 0)
       break;
     if (range_header_read_result != sizeof(range_header)) {
       DLOG(WARNING) << "Could not read sparse range header.";
       return false;
     }
 
     if (range_header.sparse_range_magic_number !=
         kSimpleSparseRangeMagicNumber) {
       DLOG(WARNING) << "Invalid sparse range header magic number.";
@@ skipping 19 matching lines @@
   return true;
 }
 
 bool SimpleSynchronousEntry::ReadSparseRange(const SparseRange* range,
                                              int offset, int len, char* buf) {
   DCHECK(range);
   DCHECK(buf);
   DCHECK_GE(range->length, offset);
   DCHECK_GE(range->length, offset + len);
 
-  int bytes_read = ReadPlatformFile(sparse_file_,
-                                    range->file_offset + offset,
-                                    buf, len);
+  int bytes_read = sparse_file_.Read(range->file_offset + offset, buf, len);
   if (bytes_read < len) {
     DLOG(WARNING) << "Could not read sparse range.";
     return false;
   }
 
   // If we read the whole range and we have a crc32, check it.
   if (offset == 0 && len == range->length && range->data_crc32 != 0) {
     uint32 actual_crc32 = crc32(crc32(0L, Z_NULL, 0),
                                 reinterpret_cast<const Bytef*>(buf),
                                 len);
@@ skipping 24 matching lines @@
 
   if (new_crc32 != range->data_crc32) {
     range->data_crc32 = new_crc32;
 
     SimpleFileSparseRangeHeader header;
     header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
     header.offset = range->offset;
     header.length = range->length;
     header.data_crc32 = range->data_crc32;
 
-    int bytes_written = WritePlatformFile(sparse_file_,
-                                          range->file_offset - sizeof(header),
-                                          reinterpret_cast<char*>(&header),
-                                          sizeof(header));
+    int bytes_written = sparse_file_.Write(range->file_offset - sizeof(header),
+                                           reinterpret_cast<char*>(&header),
+                                           sizeof(header));
     if (bytes_written != implicit_cast<int>(sizeof(header))) {
       DLOG(WARNING) << "Could not rewrite sparse range header.";
       return false;
     }
   }
 
-  int bytes_written = WritePlatformFile(sparse_file_,
-                                        range->file_offset + offset,
-                                        buf, len);
+  int bytes_written = sparse_file_.Write(range->file_offset + offset, buf, len);
   if (bytes_written < len) {
     DLOG(WARNING) << "Could not write sparse range.";
     return false;
   }
 
   return true;
 }
 
 bool SimpleSynchronousEntry::AppendSparseRange(int64 offset,
                                                int len,
                                                const char* buf) {
   DCHECK_LE(0, offset);
   DCHECK_LT(0, len);
   DCHECK(buf);
 
   uint32 data_crc32 = crc32(crc32(0L, Z_NULL, 0),
                             reinterpret_cast<const Bytef*>(buf),
                             len);
 
   SimpleFileSparseRangeHeader header;
   header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
   header.offset = offset;
   header.length = len;
   header.data_crc32 = data_crc32;
 
-  int bytes_written = WritePlatformFile(sparse_file_,
-                                        sparse_tail_offset_,
-                                        reinterpret_cast<char*>(&header),
-                                        sizeof(header));
+  int bytes_written = sparse_file_.Write(sparse_tail_offset_,
+                                         reinterpret_cast<char*>(&header),
+                                         sizeof(header));
   if (bytes_written != implicit_cast<int>(sizeof(header))) {
     DLOG(WARNING) << "Could not append sparse range header.";
     return false;
   }
   sparse_tail_offset_ += bytes_written;
 
-  bytes_written = WritePlatformFile(sparse_file_,
-                                    sparse_tail_offset_,
-                                    buf,
-                                    len);
+  bytes_written = sparse_file_.Write(sparse_tail_offset_, buf, len);
   if (bytes_written < len) {
     DLOG(WARNING) << "Could not append sparse range data.";
     return false;
   }
   int64 data_file_offset = sparse_tail_offset_;
   sparse_tail_offset_ += bytes_written;
 
   SparseRange range;
   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