[HttpCache] Measure causes for cache validation requests

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 148 matching lines @@
       done_reading_(false),
       vary_mismatch_(false),
       couldnt_conditionalize_request_(false),
       bypass_lock_for_test_(false),
       fail_conditionalization_for_test_(false),
       io_buf_len_(0),
       read_offset_(0),
       effective_load_flags_(0),
       write_len_(0),
       transaction_pattern_(PATTERN_UNDEFINED),
+      validation_cause_(VALIDATION_CAUSE_UNDEFINED),
       total_received_bytes_(0),
       total_sent_bytes_(0),
       websocket_handshake_stream_base_create_helper_(NULL),
       weak_factory_(this) {
   static_assert(HttpCache::Transaction::kNumValidationHeaders ==
                     arraysize(kValidationHeaders),
                 "invalid number of validation headers");
 
   io_callback_ = base::Bind(&Transaction::OnIOComplete,
                               weak_factory_.GetWeakPtr());
@@ skipping 1972 matching lines @@
 
 ValidationType HttpCache::Transaction::RequiresValidation() {
   // TODO(darin): need to do more work here:
   //  - make sure we have a matching request method
   //  - watch out for cached responses that depend on authentication
 
   if (response_.vary_data.is_valid() &&
       !response_.vary_data.MatchesRequest(*request_,
                                           *response_.headers.get())) {
     vary_mismatch_ = true;
+    validation_cause_ = VALIDATION_CAUSE_VARY_MISMATCH;
     return VALIDATION_SYNCHRONOUS;
   }
 
   if (effective_load_flags_ & LOAD_PREFERRING_CACHE)
     return VALIDATION_NONE;
 
   if (response_.unused_since_prefetch &&
       !(effective_load_flags_ & LOAD_PREFETCH) &&
       response_.headers->GetCurrentAge(
           response_.request_time, response_.response_time,
           cache_->clock_->Now()) < TimeDelta::FromMinutes(kPrefetchReuseMins)) {
     // The first use of a resource after prefetch within a short window skips
     // validation.
     return VALIDATION_NONE;
   }
 
-  if (effective_load_flags_ & LOAD_VALIDATE_CACHE)
+  if (effective_load_flags_ & LOAD_VALIDATE_CACHE) {
+    validation_cause_ = VALIDATION_CAUSE_VALIDATE_FLAG;
     return VALIDATION_SYNCHRONOUS;
+  }
 
   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;
+  }
+
   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;
 }
 
 bool HttpCache::Transaction::ConditionalizeRequest() {
@@ skipping 500 matching lines @@
 }
 
 void HttpCache::Transaction::RecordHistograms() {
   DCHECK_NE(PATTERN_UNDEFINED, transaction_pattern_);
   if (!cache_.get() || !cache_->GetCurrentBackend() ||
       cache_->GetCurrentBackend()->GetCacheType() != DISK_CACHE ||
       cache_->mode() != NORMAL || request_->method != "GET") {
     return;
   }
 
+  bool validation_request =
+      transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
+      transaction_pattern_ == PATTERN_ENTRY_UPDATED ||
+      transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE;
   std::string mime_type;
   HttpResponseHeaders* response_headers = GetResponseInfo()->headers.get();
   if (response_headers && response_headers->GetMimeType(&mime_type)) {
     // Record the cache pattern by resource type. The type is inferred by
     // response header mime type, which could be incorrect, so this is just an
     // estimate.
     if (mime_type == "text/html" && (request_->load_flags & LOAD_MAIN_FRAME)) {
-      UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.MainFrameHTML"),

[gavinp, 2016/05/12 15:02:01]

What was this stuff?

[jkarlin, 2016/05/13 15:06:51]

Why was std::string there? It's leftover cruft from a local experiment I was
doing that I failed to edit out in the previous CL.

+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.MainFrameHTML",
                                 transaction_pattern_, PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.MainFrameHTML",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     } else if (mime_type == "text/html") {
-      UMA_HISTOGRAM_ENUMERATION(
-          std::string("HttpCache.Pattern.NonMainFrameHTML"),
-          transaction_pattern_, PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.NonMainFrameHTML",
+                                transaction_pattern_, PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.NonMainFrameHTML",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     } else if (mime_type == "text/css") {
-      UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.CSS"),
-                                transaction_pattern_, PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.CSS", transaction_pattern_,
+                                PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.CSS",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     } else if (base::StartsWith(mime_type, "image/",
                                 base::CompareCase::SENSITIVE)) {
       int64_t content_length = response_headers->GetContentLength();
       if (content_length >= 0 && content_length < 100) {
-        UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.TinyImage"),
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.TinyImage",
                                   transaction_pattern_, PATTERN_MAX);
+        if (validation_request) {
+          UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.TinyImage",
+                                    validation_cause_, VALIDATION_CAUSE_MAX);
+        }
       } else if (content_length >= 100) {
-        UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.NonTinyImage"),
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.NonTinyImage",
                                   transaction_pattern_, PATTERN_MAX);
+        if (validation_request) {
+          UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.NonTinyImage",
+                                    validation_cause_, VALIDATION_CAUSE_MAX);
+        }
       }
-      UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.Image"),
-                                transaction_pattern_, PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Image", transaction_pattern_,
+                                PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.Image",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     } else if (base::EndsWith(mime_type, "javascript",
                               base::CompareCase::SENSITIVE) ||
                base::EndsWith(mime_type, "ecmascript",
                               base::CompareCase::SENSITIVE)) {
-      UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.JavaScript"),
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.JavaScript",
                                 transaction_pattern_, PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.JavaScript",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     } else if (mime_type.find("font") != std::string::npos) {
-      UMA_HISTOGRAM_ENUMERATION(std::string("HttpCache.Pattern.Font"),
-                                transaction_pattern_, PATTERN_MAX);
+      UMA_HISTOGRAM_ENUMERATION("HttpCache.Pattern.Font", transaction_pattern_,
+                                PATTERN_MAX);
+      if (validation_request) {
+        UMA_HISTOGRAM_ENUMERATION("HttpCache.ValidationCause.Font",
+                                  validation_cause_, VALIDATION_CAUSE_MAX);
+      }
     }
   }
 
   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_NOT_COVERED)
     return;
   DCHECK(!range_requested_);
   DCHECK(!first_cache_access_since_.is_null());
 
   TimeDelta total_time = base::TimeTicks::Now() - first_cache_access_since_;
 
   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone", total_time);
 
   bool did_send_request = !send_request_since_.is_null();
@@ skipping 55 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net