Disk Cache: Add more corruption tracking histograms.

net/disk_cache/backend_impl.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/disk_cache/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 429 matching lines @@
   if (!(user_flags_ & kNoRandom)) {
     // The unit test controls directly what to test.
     new_eviction_ = (cache_type_ == net::DISK_CACHE);
   }
 
   if (!CheckIndex()) {
     ReportError(ERR_INIT_FAILED);
     return net::ERR_FAILED;
   }
 
+  if (create_files || !data_->header.num_entries)
+    ReportError(ERR_CACHE_CREATED);
+
   if (!(user_flags_ & kNoRandom) &&
       cache_type_ == net::DISK_CACHE && !InitExperiment(&data_->header))
     return net::ERR_FAILED;
 
   // We don't care if the value overflows. The only thing we care about is that
   // the id cannot be zero, because that value is used as "not dirty".
   // Increasing the value once per second gives us many years before we start
   // having collisions.
   data_->header.this_id++;
   if (!data_->header.this_id)
     data_->header.this_id++;
 
   if (data_->header.crash) {
     ReportError(ERR_PREVIOUS_CRASH);
   } else {
-    ReportError(0);
+    ReportError(ERR_NO_ERROR);
     data_->header.crash = 1;
   }
 
   if (!block_files_.Init(create_files))
     return net::ERR_FAILED;
 
   // We want to minimize the changes to cache for an AppCache.
   if (cache_type() == net::APP_CACHE) {
     DCHECK(!new_eviction_);
     read_only_ = true;
   }
 
   eviction_.Init(this);
 
   // stats_ and rankings_ may end up calling back to us so we better be enabled.
   disabled_ = false;
   if (!stats_.Init(this, &data_->header.stats))
     return net::ERR_FAILED;
 
   disabled_ = !rankings_.Init(this, new_eviction_);
 
+  if (!disabled_ && !(user_flags_ & kNoRandom) && base::RandInt(0, 99) < 2)
+    rankings_.SelfCheck();  // Ignore return value for now.
+
 #if defined(STRESS_CACHE_EXTENDED_VALIDATION)
   trace_object_->EnableTracing(false);
   int sc = SelfCheck();
   if (sc < 0 && sc != ERR_NUM_ENTRIES_MISMATCH)
     NOTREACHED();
   trace_object_->EnableTracing(true);
 #endif
 
   return disabled_ ? net::ERR_FAILED : net::OK;
 }
@@ skipping 1044 matching lines @@
   if (it != open_entries_.end()) {
     // Easy job. This entry is already in memory.
     EntryImpl* this_entry = it->second;
     this_entry->AddRef();
     *entry = this_entry;
     return 0;
   }
 
   STRESS_DCHECK(block_files_.IsValid(address));
 
-  if (!address.is_initialized() || address.is_separate_file() ||
-      address.file_type() != BLOCK_256) {
+  if (!address.SanityCheckForEntry()) {
     LOG(WARNING) << "Wrong entry address.";
     STRESS_NOTREACHED();
     return ERR_INVALID_ADDRESS;
   }
 
   scoped_refptr<EntryImpl> cache_entry(
       new EntryImpl(this, address, read_only_));
   IncreaseNumRefs();
   *entry = NULL;
 
@@ skipping 606 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache