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 952 matching lines @@
   return cache_->OpenEntry(cache_key_, &new_entry_, this);
 }
 
 int HttpCache::Transaction::DoOpenEntryComplete(int result) {
   // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is
   // OK, otherwise the cache will end up with an active entry without any
   // transaction attached.
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY, result);
   cache_pending_ = false;
   if (result == OK) {
+    open_entry_last_used_ = new_entry_->disk_entry->GetLastUsed();
     next_state_ = STATE_ADD_TO_ENTRY;
     return OK;
   }
 
   if (result == ERR_CACHE_RACE) {
     next_state_ = STATE_INIT_ENTRY;
     return OK;
   }
 
   if (request_->method == "PUT" || request_->method == "DELETE" ||
@@ skipping 1200 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) {
+    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_);

[rkaplow, 2016/05/24 17:43:25]

instead of doing this, I think you want milliseconds, right? Why not use
inmilliseconds?

https://code.google.com/p/chromium/codesearch#chromium/src/base/time/time.h&q...

[jkarlin, 2016/05/24 17:57:40]

I see why the 1000 is making you think of milliseconds. But the metric is
recording a ratio, not a time. The * 1000 is just to make sure the integer
division has enough precision.

[jkarlin, 2016/05/24 18:38:30]

I've added a comment to clarify what's being recorded here.

+  }
+
   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