Record the number of freshness periods since a stale HttpCache entry was last used

net/http/http_cache_transaction.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/http_cache_transaction.h"
 
 #include "build/build_config.h"  // For OS_POSIX
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1116 matching lines @@
     // The cache is busy, bypass it for this transaction.
     mode_ = NONE;
     next_state_ = STATE_SEND_REQUEST;
     if (partial_) {
       partial_->RestoreHeaders(&custom_request_->extra_headers);
       partial_.reset();
     }
     return OK;
   }
 
+  open_entry_last_used_ = entry_->disk_entry->GetLastUsed();
+
   if (result != OK) {
     NOTREACHED();
     return result;
   }
 
   if (mode_ == WRITE) {
     if (partial_)
       partial_->RestoreHeaders(&custom_request_->extra_headers);
     next_state_ = STATE_SEND_REQUEST;
   } else {
@@ skipping 1036 matching lines @@
 
   if (request_->method == "PUT" || request_->method == "DELETE")
     return VALIDATION_SYNCHRONOUS;
 
   ValidationType validation_required_by_headers =
       response_.headers->RequiresValidation(response_.request_time,
                                             response_.response_time,
                                             cache_->clock_->Now());
 
   if (validation_required_by_headers != VALIDATION_NONE) {
-    validation_cause_ =
-        response_.headers->GetFreshnessLifetimes(response_.response_time)
-                    .freshness == base::TimeDelta()
-            ? VALIDATION_CAUSE_ZERO_FRESHNESS
-            : VALIDATION_CAUSE_STALE;
+    HttpResponseHeaders::FreshnessLifetimes lifetimes =
+        response_.headers->GetFreshnessLifetimes(response_.response_time);
+    if (lifetimes.freshness == base::TimeDelta()) {
+      validation_cause_ = VALIDATION_CAUSE_ZERO_FRESHNESS;
+    } else {
+      validation_cause_ = VALIDATION_CAUSE_STALE;
+      stale_entry_freshness_ = lifetimes.freshness;
+    }
   }
 
   if (validation_required_by_headers == VALIDATION_ASYNCHRONOUS) {
     // Asynchronous revalidation is only supported for GET methods.
     if (request_->method != "GET")
       return VALIDATION_SYNCHRONOUS;
   }
 
   return validation_required_by_headers;
 }
@@ skipping 575 matching lines @@
     } else if (mime_type.find("font") != std::string::npos) {
       UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Font", transaction_pattern_,
                                 PATTERN_MAX);
       if (validation_request) {
         UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.Font",
                                   validation_cause_, VALIDATION_CAUSE_MAX);
       }
     }
   }
 
+  if ((validation_request ||
+       transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE) &&
+      validation_cause_ == VALIDATION_CAUSE_STALE) {
+    // For stale entries, record how many freshness periods have elapsed since
+    // the entry was last used.
+    DCHECK(!open_entry_last_used_.is_null());
+    DCHECK(!stale_entry_freshness_.is_zero());
+
+    base::TimeDelta time_since_use = base::Time::Now() - open_entry_last_used_;
+    UMA_HISTOGRAM_COUNTS("HttpCache.StaleEntry.FreshnessPeriodsSinceLastUsed",
+                         (time_since_use * 1000) / stale_entry_freshness_);
+  }
+
   UMA_HISTOGRAM_ENUMERATION(
       "HttpCache.Pattern", transaction_pattern_, PATTERN_MAX);
 
   if (validation_request) {
     UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause", validation_cause_,
                               VALIDATION_CAUSE_MAX);
   }
 
   if (transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE) {
     UMA_HISTOGRAM_ENUMERATION("HttpCache.CantConditionalizeCause",
@@ skipping 68 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net