Http cache: fix a bug that prevented the infinite cache simulation from saving

net/http/infinite_cache.cc

 // Copyright (c) 2012 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/http/infinite_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/bind.h"
@@ skipping 64 matching lines @@
   uint32 vary_hash;
   int32 headers_size;
   int32 response_size;
   uint32 headers_hash;
   uint32 response_hash;
 };
 const size_t kRecordSize = sizeof(Key) + sizeof(Details);
 
 // Some constants related to the database file.
 uint32 kMagicSignature = 0x1f00cace;
-uint32 kCurrentVersion = 0x10001;
+uint32 kCurrentVersion = 0x10002;
 
 // Basic limits for the experiment.
-int kMaxNumEntries = 500 * 1000;
+int kMaxNumEntries = 200 * 1000;

[tburkard, 2012/11/30 19:00:54]

Why reduce the size?

[rvargas (doing something else), 2012/11/30 19:12:23]

When I increased the size I was under the assumption that people were free to
reach the limit... knowing that most people have not really had a chance of
getting more than 100k entries means that we should be cautious again and see if
problems arise.

 int kMaxTrackingSize = 40 * 1024 * 1024;
 
 // Settings that control how we generate histograms.
 int kTimerMinutes = 5;
 int kReportSizeStep = 100 * 1024 * 1024;
 
 // Buffer to read and write the file.
 const size_t kBufferSize = 1024 * 1024;
 const size_t kMaxRecordsToRead = kBufferSize / kRecordSize;
 COMPILE_ASSERT(kRecordSize * kMaxRecordsToRead < kBufferSize, wrong_buffer);
@@ skipping 498 matching lines @@
 
   PlatformFile file = base::CreatePlatformFile(
       path_, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, NULL, NULL);
   if (file == base::kInvalidPlatformFileValue)
     return InitializeData();
   if (!ReadData(file))
     InitializeData();
   base::ClosePlatformFile(file);
   if (header_->disabled) {
     UMA_HISTOGRAM_BOOLEAN("InfiniteCache.Full", true);
-    map_.clear();
+    InitializeData();
   }
 }
 
 void InfiniteCache::Worker::StoreData() {
   if (!init_ || flushed_ || path_.empty())
     return;
 
   header_->update_time = Time::Now().ToInternalValue();
   header_->generation++;
   header_->header_hash = base::Hash(
@@ skipping 14 matching lines @@
     LOG(ERROR) << "Failed to write experiment data";
   }
 }
 
 void InfiniteCache::Worker::InitializeData() {
   header_.reset(new Header);
   memset(header_.get(), 0, sizeof(Header));
   header_->magic = kMagicSignature;
   header_->version = kCurrentVersion;
   header_->creation_time = Time::Now().ToInternalValue();
+  map_.clear();
 
   UMA_HISTOGRAM_BOOLEAN("InfiniteCache.Initialize", true);
   init_ = true;
 }
 
 bool InfiniteCache::Worker::ReadData(PlatformFile file) {
   if (!ReadAndVerifyHeader(file))
     return false;
 
   scoped_array<char> buffer(new char[kBufferSize]);
   size_t offset = sizeof(Header);
   uint32 hash = adler32(0, Z_NULL, 0);
 
   for (int remaining_records = header_->num_entries; remaining_records;) {
-    int num_records = std::min(header_->num_entries,
+    int num_records = std::min(remaining_records,
                                static_cast<int>(kMaxRecordsToRead));
     size_t num_bytes = num_records * kRecordSize;
     remaining_records -= num_records;
     if (!remaining_records)
       num_bytes += sizeof(uint32);  // Trailing hash.
     DCHECK_LE(num_bytes, kBufferSize);
 
     if (!ReadPlatformFile(file, offset, buffer.get(), num_bytes))
       return false;
 
@@ skipping 29 matching lines @@
   if (!WritePlatformFile(file, 0, header_.get(), sizeof(Header)))
     return false;
 
   scoped_array<char> buffer(new char[kBufferSize]);
   size_t offset = sizeof(Header);
   uint32 hash = adler32(0, Z_NULL, 0);
 
   DCHECK_EQ(header_->num_entries, static_cast<int32>(map_.size()));
   KeyMap::iterator iterator = map_.begin();
   for (int remaining_records = header_->num_entries; remaining_records;) {
-    int num_records = std::min(header_->num_entries,
+    int num_records = std::min(remaining_records,
                                static_cast<int>(kMaxRecordsToRead));
     size_t num_bytes = num_records * kRecordSize;
     remaining_records -= num_records;
 
     for (int i = 0; i < num_records; i++) {
       if (iterator == map_.end()) {
         NOTREACHED();
         return false;
       }
       char* record = buffer.get() + i * kRecordSize;
@@ skipping 80 matching lines @@
   if (header_->num_entries == kMaxNumEntries) {
     int use_hours = header_->use_minutes / 60;
     int age_hours = (Time::Now() -
                      Time::FromInternalValue(header_->creation_time)).InHours();
     UMA_HISTOGRAM_COUNTS_10000("InfiniteCache.MaxUseTime", use_hours);
     UMA_HISTOGRAM_COUNTS_10000("InfiniteCache.MaxAge", age_hours);
 
     int entry_size = static_cast<int>(header_->total_size / kMaxNumEntries);
     UMA_HISTOGRAM_COUNTS("InfiniteCache.FinalAvgEntrySize", entry_size);
     header_->disabled = 1;
+    header_->num_entries = 0;
     map_.clear();
   }
 }
 
 void InfiniteCache::Worker::Remove(const Details& details) {
   UpdateSize(details.headers_size, 0);
   UpdateSize(details.response_size, 0);
   header_->num_entries--;
 }
 
@@ skipping 332 matching lines @@
 int InfiniteCache::FlushDataForTest(const CompletionCallback& callback) {
   DCHECK(worker_);
   int* result = new int;
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&InfiniteCache::Worker::Flush, worker_, result),
       base::Bind(&OnComplete, callback, base::Owned(result)));
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace net