Disk cache: First pass to make it possible to have...

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2008 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/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 141 matching lines @@
 
 // If the initialization of the cache fails, and force is true, we will discard
 // the whole cache and create a new one. In order to process a potentially large
 // number of files, we'll rename the cache folder to old_ + original_name +
 // number, (located on the same parent folder), and spawn a worker thread to
 // delete all the files on all the stale cache folders. The whole process can
 // still fail if we are not able to rename the cache folder (for instance due to
 // a sharing violation), and in that case a cache for this profile (on the
 // desired path) cannot be created.
 Backend* CreateCacheBackend(const std::wstring& full_path, bool force,
-                            int max_bytes) {
+                            int max_bytes, net::CacheType type) {
   BackendImpl* cache = new BackendImpl(full_path);
   cache->SetMaxSize(max_bytes);
+  cache->SetType(type);
   if (cache->Init())
     return cache;
 
   delete cache;
   if (!force)
     return NULL;
 
   if (!DelayedCacheCleanup(full_path))
     return NULL;
 
   // The worker thread will start deleting files soon, but the original folder
   // is not there anymore... let's create a new set of files.
   cache = new BackendImpl(full_path);
   cache->SetMaxSize(max_bytes);
+  cache->SetType(type);
   if (cache->Init())
     return cache;
 
   delete cache;
   LOG(ERROR) << "Unable to create cache";
   return NULL;
 }
 
 // ------------------------------------------------------------------------
 
 bool BackendImpl::Init() {
   DCHECK(!init_);
   if (init_)
     return false;
 
 #ifdef USE_NEW_EVICTION
   new_eviction_ = true;
 #endif
 
   bool create_files = false;
   if (!InitBackingStore(&create_files)) {
     ReportError(ERR_STORAGE_ERROR);
     return false;
   }
 
   num_refs_ = num_pending_io_ = max_refs_ = 0;
 
   if (!restarted_) {
+    trace_object_ = TraceObject::GetTraceObject();
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
     timer_.Start(TimeDelta::FromMilliseconds(timer_delay), this,
                  &BackendImpl::OnStatsTimer);
   }
 
   init_ = true;
   if (data_)
     InitExperiment(&data_->header.experiment);
 
@@ skipping 304 matching lines @@
     return false;
 
   // Zero size means use the default.
   if (!max_bytes)
     return true;
 
   max_size_ = max_bytes;
   return true;
 }
 
+void BackendImpl::SetType(net::CacheType type) {
+  DCHECK(type != net::MEMORY_CACHE);
+  cache_type_ = type;
+}
+
 std::wstring BackendImpl::GetFileName(Addr address) const {
   if (!address.is_separate_file() || !address.is_initialized()) {
     NOTREACHED();
     return std::wstring();
   }
 
   std::wstring name(path_);
   std::wstring tmp = StringPrintf(L"f_%06x", address.FileNumber());
   file_util::AppendToPath(&name, tmp);
   return name;
@@ skipping 135 matching lines @@
   stats_.ModifyStorageStats(old_size, new_size);
 }
 
 void BackendImpl::TooMuchStorageRequested(int32 size) {
   stats_.ModifyStorageStats(0, size);
 }
 
 // We want to remove biases from some histograms so we only send data once per
 // week.
 bool BackendImpl::ShouldReportAgain() {
-  static bool first_time = true;
-  static bool should_send = false;
+  if (uma_report_)
+    return uma_report_ == 2;
 
-  if (!first_time)
-    return should_send;
-
-  first_time = false;
+  uma_report_++;
   int64 last_report = stats_.GetCounter(Stats::LAST_REPORT);
   Time last_time = Time::FromInternalValue(last_report);
   if (!last_report || (Time::Now() - last_time).InDays() >= 7) {
     stats_.SetCounter(Stats::LAST_REPORT, Time::Now().ToInternalValue());
-    should_send = true;
+    uma_report_++;
     return true;
   }
   return false;
 }
 
 void BackendImpl::FirstEviction() {
   DCHECK(data_->header.create_time);
 
   Time create_time = Time::FromInternalValue(data_->header.create_time);
   UMA_HISTOGRAM_HOURS("DiskCache.FillupAge",
                       (Time::Now() - create_time).InHours());
-  
+
   int64 use_hours = stats_.GetCounter(Stats::TIMER) / 120;
   UMA_HISTOGRAM_HOURS("DiskCache.FillupTime", static_cast<int>(use_hours));
   UMA_HISTOGRAM_PERCENTAGE("DiskCache.FirstHitRatio", stats_.GetHitRatio());
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   UMA_HISTOGRAM_COUNTS("DiskCache.FirstEntrySize", avg_size);
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / data_->header.num_bytes;
   UMA_HISTOGRAM_PERCENTAGE("DiskCache.FirstLargeEntriesRatio", large_ratio);
@@ skipping 33 matching lines @@
 void BackendImpl::OnStatsTimer() {
   stats_.OnEvent(Stats::TIMER);
   int64 current = stats_.GetCounter(Stats::OPEN_ENTRIES);
   int64 time = stats_.GetCounter(Stats::TIMER);
 
   current = current * (time - 1) + num_refs_;
   current /= time;
   stats_.SetCounter(Stats::OPEN_ENTRIES, current);
   stats_.SetCounter(Stats::MAX_ENTRIES, max_refs_);
 
-  static bool first_time = true;
   if (!data_)
-    first_time = false;
-  if (first_time) {
-    first_time = false;
+    first_timer_ = false;
+  if (first_timer_) {
+    first_timer_ = false;
     if (ShouldReportAgain())
       ReportStats();
   }
 
   // Save stats to disk at 5 min intervals.
   if (time % 10 == 0)
     stats_.Store();
 }
 
 void BackendImpl::IncrementIoCount() {
@@ skipping 522 matching lines @@
   }
 
   if (!data_->header.lru.filled)
     return;
 
   // This is an up to date client that will report FirstEviction() data. After
   // that event, start reporting this:
 
   int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   UMA_HISTOGRAM_HOURS("DiskCache.TotalTime", static_cast<int>(total_hours));
-  
+
   int64 use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
   if (!use_hours || !GetEntryCount() || !data_->header.num_bytes)
     return;
 
-  UMA_HISTOGRAM_HOURS("DiskCache.UseTime", static_cast<int>(use_hours)); 
+  UMA_HISTOGRAM_HOURS("DiskCache.UseTime", static_cast<int>(use_hours));
   UMA_HISTOGRAM_PERCENTAGE("DiskCache.HitRatio", stats_.GetHitRatio());
   UMA_HISTOGRAM_PERCENTAGE("DiskCache.ResurrectRatio",
                            stats_.GetResurrectRatio());
 
   int64 trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
   UMA_HISTOGRAM_COUNTS("DiskCache.TrimRate", static_cast<int>(trim_rate));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   UMA_HISTOGRAM_COUNTS("DiskCache.EntrySize", avg_size);
 
@@ skipping 122 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache