SimpleCache: merge the first and second stream in one 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>
@@ skipping 128 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 using simple_util::ConvertEntryHashKeyToHexString;
 using simple_util::GetEntryHashKey;
 using simple_util::GetFilenameFromEntryHashAndIndex;
 using simple_util::GetDataSizeFromKeyAndFileSize;
 using simple_util::GetFileSizeFromKeyAndDataSize;
-using simple_util::GetFileOffsetFromKeyAndDataOffset;
+using simple_util::GetFileIndexFromStreamIndex;
+using simple_util::GetMaximumDataOffset;
+using simple_util::GetFileOffsetFromDataOffset;
 
 SimpleEntryStat::SimpleEntryStat() {}
 
 SimpleEntryStat::SimpleEntryStat(base::Time last_used_p,
                                  base::Time last_modified_p,
                                  const int32 data_size_p[])
     : last_used(last_used_p),
       last_modified(last_modified_p) {
   memcpy(data_size, data_size_p, sizeof(data_size));
 }
 
 SimpleEntryCreationResults::SimpleEntryCreationResults(
     SimpleEntryStat entry_stat)
     : sync_entry(NULL),
       entry_stat(entry_stat),
       result(net::OK) {

[pasko, 2013/09/09 20:01:22]

please initialize the new field here

[clamy, 2013/09/10 14:35:59]

I thought we were supposed to omit default constructors in list initialization.
The default constructor initializes the pointer to NULL, which is what I want.

 }
 
 SimpleEntryCreationResults::~SimpleEntryCreationResults() {
 }
 
 SimpleSynchronousEntry::CRCRecord::CRCRecord() : index(-1),
                                                  has_crc32(false),
                                                  data_crc32(0) {
 }
 
@@ skipping 23 matching lines @@
 // static
 void SimpleSynchronousEntry::OpenEntry(
     net::CacheType cache_type,
     const FilePath& path,
     const uint64 entry_hash,
     bool had_index,
     SimpleEntryCreationResults *out_results) {
   SimpleSynchronousEntry* sync_entry =
       new SimpleSynchronousEntry(cache_type, path, "", entry_hash);
   out_results->result = sync_entry->InitializeForOpen(
-      had_index, &out_results->entry_stat);
+      had_index, &out_results->entry_stat, &out_results->stream_0_data);
   if (out_results->result != net::OK) {
     sync_entry->Doom();
     delete sync_entry;
     out_results->sync_entry = NULL;
+    out_results->stream_0_data = NULL;
     return;
   }
   out_results->sync_entry = sync_entry;
 }
 
 // static
 void SimpleSynchronousEntry::CreateEntry(
     net::CacheType cache_type,
     const FilePath& path,
     const std::string& key,
@@ skipping 49 matching lines @@
     const FilePath& path) {
   const size_t did_delete_count = std::count_if(
       key_hashes->begin(), key_hashes->end(), std::bind1st(
           std::ptr_fun(SimpleSynchronousEntry::DeleteFilesForEntryHash), path));
   return (did_delete_count == key_hashes->size()) ? net::OK : net::ERR_FAILED;
 }
 
 void SimpleSynchronousEntry::ReadData(const EntryOperationData& in_entry_op,
                                       net::IOBuffer* out_buf,
                                       uint32* out_crc32,
-                                      base::Time* out_last_used,
+                                      SimpleEntryStat* out_entry_stat,
                                       int* out_result) const {
   DCHECK(initialized_);
-  int64 file_offset =
-      GetFileOffsetFromKeyAndDataOffset(key_, in_entry_op.offset);
-  int bytes_read = ReadPlatformFile(files_[in_entry_op.index],
-                                    file_offset,
-                                    out_buf->data(),
-                                    in_entry_op.buf_len);
+  int64 file_offset = GetFileOffsetFromDataOffset(
+      key_,
+      in_entry_op.offset,
+      in_entry_op.index,
+      out_entry_stat->data_size[1]);
+  int file_index = GetFileIndexFromStreamIndex(in_entry_op.index);
+  int bytes_read = ReadPlatformFile(
+      files_[file_index], file_offset, out_buf->data(), in_entry_op.buf_len);
   if (bytes_read > 0) {
-    *out_last_used = Time::Now();
+    out_entry_stat->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;
     Doom();
   }
 }
 
 void SimpleSynchronousEntry::WriteData(const EntryOperationData& in_entry_op,
                                        net::IOBuffer* in_buf,
                                        SimpleEntryStat* out_entry_stat,
                                        int* out_result) const {
   DCHECK(initialized_);
   int index = in_entry_op.index;
+  int file_index = GetFileIndexFromStreamIndex(index);
   int offset = in_entry_op.offset;
   int buf_len = in_entry_op.buf_len;
   int truncate = in_entry_op.truncate;
-
+  const int64 file_offset = GetFileOffsetFromDataOffset(
+      key_, offset, index, out_entry_stat->data_size[1]);
   bool extending_by_write = offset + buf_len > out_entry_stat->data_size[index];
   if (extending_by_write) {
-    // We are extending the file, and need to insure the EOF record is zeroed.
-    const int64 file_eof_offset = GetFileOffsetFromKeyAndDataOffset(
-        key_, out_entry_stat->data_size[index]);
-    if (!TruncatePlatformFile(files_[index], file_eof_offset)) {
+    // The EOF record and the eventual stream afterward need to be zeroed out.
+    const int64 file_eof_offset = GetFileOffsetFromDataOffset(
+        key_, out_entry_stat->data_size[index],
+        index, out_entry_stat->data_size[1]);
+    if (!TruncatePlatformFile(files_[file_index], file_eof_offset)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_PRETRUNCATE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
   }
-  const int64 file_offset = GetFileOffsetFromKeyAndDataOffset(key_, offset);
   if (buf_len > 0) {
     if (WritePlatformFile(
-            files_[index], file_offset, in_buf->data(), buf_len) != buf_len) {
+            files_[file_index], 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->data_size[index] =
         std::max(out_entry_stat->data_size[index], offset + buf_len);
   } else {
-    if (!TruncatePlatformFile(files_[index], file_offset + buf_len)) {
+    out_entry_stat->data_size[index] = offset + buf_len;
+    int file_max_offset = GetFileOffsetFromDataOffset(
+        key_,
+        GetMaximumDataOffset(file_index, out_entry_stat->data_size),
+        index,
+        out_entry_stat->data_size[1]);
+    if (!TruncatePlatformFile(files_[file_index], file_max_offset)) {
       RecordWriteResult(cache_type_, WRITE_RESULT_TRUNCATE_FAILURE);
       Doom();
       *out_result = net::ERR_CACHE_WRITE_FAILURE;
       return;
     }
-    out_entry_stat->data_size[index] = offset + buf_len;
   }
 
   RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
   out_entry_stat->last_used = out_entry_stat->last_modified = Time::Now();
   *out_result = buf_len;
 }
 
 void SimpleSynchronousEntry::CheckEOFRecord(int index,
-                                            int32 data_size,
+                                            const int32 data_size[],
                                             uint32 expected_crc32,
                                             int* out_result) const {
   DCHECK(initialized_);
-
-  SimpleFileEOF eof_record;
-  int64 file_offset = GetFileOffsetFromKeyAndDataOffset(key_, data_size);
-  if (ReadPlatformFile(files_[index],
-                       file_offset,
-                       reinterpret_cast<char*>(&eof_record),
-                       sizeof(eof_record)) != sizeof(eof_record)) {
-    RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_READ_FAILURE);
+  *out_result = CheckEOFRecordInternal(index, data_size, expected_crc32);
+  if (*out_result != net::OK)
     Doom();
-    *out_result = net::ERR_CACHE_CHECKSUM_READ_FAILURE;
-    return;
-  }
-
-  if (eof_record.final_magic_number != kSimpleFinalMagicNumber) {
-    RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_MAGIC_NUMBER_MISMATCH);
-    DLOG(INFO) << "eof record had bad magic number.";
-    Doom();
-    *out_result = net::ERR_CACHE_CHECKSUM_READ_FAILURE;
-    return;
-  }
-
-  const bool has_crc = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) ==
-                       SimpleFileEOF::FLAG_HAS_CRC32;
-  SIMPLE_CACHE_UMA(BOOLEAN, "SyncCheckEOFHasCrc", cache_type_, has_crc);
-  if (has_crc && eof_record.data_crc32 != expected_crc32) {
-    RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
-    DLOG(INFO) << "eof record had bad crc.";
-    Doom();
-    *out_result = net::ERR_CACHE_CHECKSUM_MISMATCH;
-    return;
-  }
-
-  RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
-  *out_result = net::OK;
 }
 
 void SimpleSynchronousEntry::Close(
     const SimpleEntryStat& entry_stat,
-    scoped_ptr<std::vector<CRCRecord> > crc32s_to_write) {
+    scoped_ptr<std::vector<CRCRecord> > crc32s_to_write,
+    net::IOBuffer* stream_0_data) {
+  if (!stream_0_data) {
+    if (entry_stat.data_size[0])
+      Doom();
+  } else {
+    // Write stream 0 data.
+    int stream_0_offset =
+        GetFileOffsetFromDataOffset(key_, 0, 0, entry_stat.data_size[1]);
+    if (WritePlatformFile(files_[0],
+                          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.";
+      Doom();
+    }
+  }
+  // Write updated header for stream 0 and stream 1 file.
+  if (WriteHeader(0, entry_stat.data_size[0], entry_stat.data_size[1]) !=
+      net::OK) {
+    RecordCloseResult(cache_type_, CLOSE_RESULT_WRITE_FAILURE);
+    DLOG(INFO) << "Could not write updated header.";
+    Doom();
+  }
+
   for (std::vector<CRCRecord>::const_iterator it = crc32s_to_write->begin();
        it != crc32s_to_write->end(); ++it) {
     SimpleFileEOF eof_record;
+    int index = it->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;
-    int64 file_offset = GetFileOffsetFromKeyAndDataOffset(
-        key_, entry_stat.data_size[it->index]);
-    if (WritePlatformFile(files_[it->index],
+    int file_index = GetFileIndexFromStreamIndex(index);
+    int64 file_offset = GetFileOffsetFromDataOffset(
+        key_, entry_stat.data_size[index], index, entry_stat.data_size[1]);
+    if (WritePlatformFile(files_[file_index],
                           file_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.";
       Doom();
       break;
     }
-    const int64 file_size = file_offset + sizeof(eof_record);
+  }
+  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
+    bool did_close_file = ClosePlatformFile(files_[i]);
+    CHECK(did_close_file);
+    const int64 file_size = GetFileSizeFromKeyAndDataSize(
+        key_, GetMaximumDataOffset(i, entry_stat.data_size));
     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));
   }
-
-  for (int i = 0; i < kSimpleEntryFileCount; ++i) {
-    bool did_close_file = ClosePlatformFile(files_[i]);
-    CHECK(did_close_file);
-  }
   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),
@@ skipping 68 matching lines @@
         DLOG_IF(INFO, !did_close) << "Could not close file "
                                   << filename.MaybeAsASCII();
       }
       return false;
     }
   }
 
   have_open_files_ = true;
   if (create) {
     out_entry_stat->last_modified = out_entry_stat->last_used = Time::Now();
-    for (int i = 0; i < kSimpleEntryFileCount; ++i)
+    for (int i = 0; i < kSimpleEntryStreamCount; ++i)
       out_entry_stat->data_size[i] = 0;
   } else {
     for (int i = 0; i < kSimpleEntryFileCount; ++i) {
       PlatformFileInfo file_info;
       bool success = GetPlatformFileInfo(files_[i], &file_info);
       base::Time file_last_modified;
       if (!success) {
         DLOG(WARNING) << "Could not get platform file info.";
         continue;
       }
       out_entry_stat->last_used = file_info.last_accessed;
       if (simple_util::GetMTime(path_, &file_last_modified))
         out_entry_stat->last_modified = file_last_modified;
       else
         out_entry_stat->last_modified = file_info.last_modified;
 
       base::TimeDelta entry_age =
           base::Time::Now() - out_entry_stat->last_modified;
       SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
                        "SyncOpenEntryAge", cache_type_,
                        entry_age.InHours(), 1, 1000, 50);
 
-      // Keep the file size in |data size_| briefly until the key is initialized
-      // properly.
-      out_entry_stat->data_size[i] = file_info.size;
+      // Keep the file size in |data size_| temporarily until the data sizes are
+      // initialized correctly.
+      out_entry_stat->data_size[i + 1] = file_info.size;
     }
   }
 
   return true;
 }
 
 void SimpleSynchronousEntry::CloseFiles() {
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     DCHECK_NE(kInvalidPlatformFileValue, files_[i]);
     bool did_close = ClosePlatformFile(files_[i]);
     DCHECK(did_close);
   }
 }
 
-int SimpleSynchronousEntry::InitializeForOpen(bool had_index,
-                                              SimpleEntryStat* out_entry_stat) {
+int SimpleSynchronousEntry::InitializeForOpen(
+    bool had_index,
+    SimpleEntryStat* out_entry_stat,
+    scoped_refptr<net::IOBuffer>* stream_0_data) {
   DCHECK(!initialized_);
   if (!OpenOrCreateFiles(false, had_index, out_entry_stat))
     return net::ERR_FAILED;
 
   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)) {
@@ skipping 20 matching lines @@
     scoped_ptr<char[]> key(new char[header.key_length]);
     int key_read_result = ReadPlatformFile(files_[i], 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);
-    out_entry_stat->data_size[i] =
-        GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size[i]);
-    if (out_entry_stat->data_size[i] < 0) {
-      // This entry can't possibly be valid, as it does not have enough space to
-      // store a valid SimpleFileEOF record.
+    // The data size needs to be updated. For stream 0 and 1 it is included in
+    // the header, for stream 2 it is computed from the file size temporarily
+    // stored in |out_entry_stat|.
+    int data_size_current_file = 0;
+    int min_data_size = 0;
+    if (i == 0) {
+      // File size for stream 0 has been stored temporarily in data_size[1].
+      data_size_current_file =
+          GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size[1]);
+      min_data_size =
+          header.stream_0_size + header.stream_1_size + sizeof(SimpleFileEOF);
+      out_entry_stat->data_size[0] = header.stream_0_size;
+      out_entry_stat->data_size[1] = header.stream_1_size;
+    } else {
+      out_entry_stat->data_size[2] =
+          GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size[2]);
+      data_size_current_file = out_entry_stat->data_size[2];
+    }
+    if (data_size_current_file < min_data_size)
       return net::ERR_FAILED;
-    }
 
     if (base::Hash(key.get(), header.key_length) != header.key_hash) {
       DLOG(WARNING) << "Hash mismatch on key.";
       RecordSyncOpenResult(
           cache_type_, OPEN_ENTRY_KEY_HASH_MISMATCH, had_index);
       return net::ERR_FAILED;
     }
+
+    // Stream 0 needs to be read and put in memory
+    if (i == 0) {
+      *stream_0_data = NULL;
+      if (header.stream_0_size == 0)
+        break;
+      int ret_value_stream_0 =
+          ReadAndValidateStream0(out_entry_stat->data_size, stream_0_data);
+      if (ret_value_stream_0 != net::OK)
+        return ret_value_stream_0;
+    }
   }
   RecordSyncOpenResult(cache_type_, OPEN_ENTRY_SUCCESS, had_index);
   initialized_ = true;
   return net::OK;
 }
 
 int SimpleSynchronousEntry::InitializeForCreate(
     bool had_index,
     SimpleEntryStat* out_entry_stat) {
   DCHECK(!initialized_);
   if (!OpenOrCreateFiles(true, had_index, out_entry_stat)) {
     DLOG(WARNING) << "Could not create platform files.";
     return net::ERR_FILE_EXISTS;
   }
   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)) {
-      DLOG(WARNING) << "Could not write headers to new cache entry.";
+    if (WriteHeader(i, 0, 0) != net::OK) {
       RecordSyncCreateResult(
           cache_type_, CREATE_ENTRY_CANT_WRITE_HEADER, had_index);
       return net::ERR_FAILED;
     }
 
-    if (WritePlatformFile(files_[i], sizeof(header), key_.data(),
-                          key_.size()) != implicit_cast<int>(key_.size())) {
+    if (WritePlatformFile(
+            files_[i], sizeof(SimpleFileHeader), key_.data(), key_.size()) !=
+        implicit_cast<int>(key_.size())) {
       DLOG(WARNING) << "Could not write keys to new cache entry.";
       RecordSyncCreateResult(
           cache_type_, CREATE_ENTRY_CANT_WRITE_KEY, had_index);
       return net::ERR_FAILED;
     }
   }
   RecordSyncCreateResult(cache_type_, CREATE_ENTRY_SUCCESS, had_index);
   initialized_ = true;
   return net::OK;
 }
 
+int SimpleSynchronousEntry::ReadAndValidateStream0(
+    int data_size[],
+    scoped_refptr<net::IOBuffer>* stream_0_data) const {
+  *stream_0_data = new net::IOBuffer(data_size[0]);
+  int64 file_offset = GetFileOffsetFromDataOffset(key_, 0, 0, data_size[1]);
+  int bytes_read = ReadPlatformFile(
+      files_[0], file_offset, (*stream_0_data)->data(), data_size[0]);
+  if (bytes_read != data_size[0])
+    return net::ERR_FAILED;
+  // Check the CRC32.
+  uint32 expected_crc32 =
+      crc32(crc32(0L, Z_NULL, 0),
+            reinterpret_cast<const Bytef*>((*stream_0_data)->data()),
+            data_size[0]);
+  return CheckEOFRecordInternal(0, data_size, expected_crc32);
+}
+
+int SimpleSynchronousEntry::WriteHeader(int file_index,
+                                        int stream_0_size,
+                                        int stream_1_size) const {
+  SimpleFileHeader header;
+  header.initial_magic_number = kSimpleInitialMagicNumber;
+  header.version = kSimpleVersion;
+
+  header.key_length = key_.size();
+  header.key_hash = base::Hash(key_);

[pasko, 2013/09/09 20:01:22]

why not entry_hash_?

[clamy, 2013/09/10 14:35:59]

Strangely, key_hash is defined as an int32 in SimpleFileHeader, but entry_hash_
is an int64. Using entry_hash_ causes all entries to fail because of a hash
mismatch, while using base::Hash works. I suspect some conversion error of some
sort. Wdt?

+  header.stream_0_size = stream_0_size;
+  header.stream_1_size = stream_1_size;
+
+  if (WritePlatformFile(files_[file_index],
+                        0,
+                        reinterpret_cast<char*>(&header),
+                        sizeof(header)) != sizeof(header)) {
+    DLOG(WARNING) << "Could not write headers to cache entry.";

[pasko, 2013/09/09 20:01:22]

'headers' may be misread as HTTP headers, better refer to something like 'cache
file header'

[clamy, 2013/09/10 14:35:59]

Done.

+    return net::ERR_FAILED;
+  }
+  return net::OK;
+}
+
+int SimpleSynchronousEntry::CheckEOFRecordInternal(
+    int index,
+    const int data_size[],
+    uint32 expected_crc32) const {
+  SimpleFileEOF eof_record;
+  int64 file_offset =
+      GetFileOffsetFromDataOffset(key_, data_size[index], index, data_size[1]);
+  int file_index = GetFileIndexFromStreamIndex(index);
+  if (ReadPlatformFile(files_[file_index],
+                       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.";
+    return net::ERR_CACHE_CHECKSUM_READ_FAILURE;
+  }
+
+  const bool has_crc = (eof_record.flags & SimpleFileEOF::FLAG_HAS_CRC32) ==
+                       SimpleFileEOF::FLAG_HAS_CRC32;
+  SIMPLE_CACHE_UMA(BOOLEAN, "SyncCheckEOFHasCrc", cache_type_, has_crc);
+  if (has_crc && eof_record.data_crc32 != expected_crc32) {
+    RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_CRC_MISMATCH);
+    DLOG(INFO) << "Eof record had bad crc.";
+    return net::ERR_CACHE_CHECKSUM_MISMATCH;
+  }
+
+  RecordCheckEOFResult(cache_type_, CHECK_EOF_RESULT_SUCCESS);
+  return net::OK;
+}
+
 void SimpleSynchronousEntry::Doom() const {
   // TODO(gavinp): Consider if we should guard against redundant Doom() calls.
   DeleteFilesForEntryHash(path_, entry_hash_);
 }
 
 }  // namespace disk_cache