Http cache: Measure back navigations on the infinite cache simulation.

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 257 matching lines @@
   const std::string cache_key = cache_->GenerateKey(request);
   if (cache_key == kGaJsHttpUrl) {
     resource_data_->details.flags |= GA_JS_HTTP;
   } else if (cache_key == kGaJsHttpsUrl) {
     resource_data_->details.flags |= GA_JS_HTTPS;
   }
 
   CryptoHash(cache_key, &resource_data_->key);
 }
 
+void InfiniteCacheTransaction::OnBackForwardNavigation() {
+  if (!cache_)
+    return;
+  UMA_HISTOGRAM_BOOLEAN("InfiniteCache.BackForwardNavigation", true);
+}
+
 void InfiniteCacheTransaction::OnResponseReceived(
     const HttpResponseInfo* response) {
   if (!cache_)
     return;
 
   Details& details = resource_data_->details;
 
   // Store the old flag values that we want to preserve.
   const uint32 kPreserveFlagsBitMask = (GA_JS_HTTP | GA_JS_HTTPS | DOOM_METHOD);
   uint32 old_flag_values = details.flags & kPreserveFlagsBitMask;
@@ skipping 227 matching lines @@
   if (!init_)
     return;
 
   if (data->details.response_size > kMaxTrackingSize)
     return;
 
   if (header_->num_entries == kMaxNumEntries || header_->disabled)
     return;
 
   UMA_HISTOGRAM_BOOLEAN("InfiniteCache.TotalRequests", true);
+  if (data->details.flags & NO_STORE)
+    UMA_HISTOGRAM_BOOLEAN("InfiniteCache.NoStore", true);
+
   header_->num_requests++;
   KeyMap::iterator i = map_.find(data->key);
   if (i != map_.end()) {
     if (data->details.flags & DOOM_METHOD) {
+      UMA_HISTOGRAM_BOOLEAN("InfiniteCache.DoomMethodHit", true);
       Remove(i->second);
       map_.erase(i);
       return;
     }
     data->details.use_count = i->second.use_count;
     data->details.update_count = i->second.update_count;
     bool reused = CanReuse(i->second, data->details);
     bool data_changed = DataChanged(i->second, data->details);
     bool headers_changed = HeadersChanged(i->second, data->details);
 
@@ skipping 15 matching lines @@
       return;
     }
 
     map_[data->key] = data->details;
     return;
   }
 
   if (data->details.flags & NO_STORE)
     return;
 
-  if (data->details.flags & DOOM_METHOD)
+  if (data->details.flags & DOOM_METHOD) {
+    UMA_HISTOGRAM_BOOLEAN("InfiniteCache.DoomMethodHit", false);
     return;
+  }
 
   map_[data->key] = data->details;
   Add(data->details);
 }
 
 void InfiniteCache::Worker::LoadData() {
   if (path_.empty())
-    return InitializeData();;
+    return InitializeData();
 
   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);
@@ skipping 506 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