Add HttpCache.ExternallyConditionalized histogram.

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"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 220 matching lines @@
 
 void RecordNoStoreHeaderHistogram(int load_flags,
                                   const net::HttpResponseInfo* response) {
   if (load_flags & net::LOAD_MAIN_FRAME) {
     UMA_HISTOGRAM_BOOLEAN(
         "Net.MainFrameNoStore",
         response->headers->HasHeaderValue("cache-control", "no-store"));
   }
 }
 
+// TODO(ricea): Add CACHE_USABLE_STALE once stale-while-revalidate CL landed.
+// TODO(ricea): Either remove this histogram or make it permanent by M40.
+void RecordExternallyConditionalizedHistogram(bool requires_validation) {
+  enum ExternallyConditionalizedType {
+    EXTERNALLY_CONDITIONALIZED_CACHE_REQUIRES_VALIDATION,
+    EXTERNALLY_CONDITIONALIZED_CACHE_USABLE,
+    EXTERNALLY_CONDITIONALIZED_MAX
+  };
+  ExternallyConditionalizedType type =
+      requires_validation ? EXTERNALLY_CONDITIONALIZED_CACHE_REQUIRES_VALIDATION
+                          : EXTERNALLY_CONDITIONALIZED_CACHE_USABLE;
+  UMA_HISTOGRAM_ENUMERATION("HttpCache.ExternallyConditionalized",
+                            type,
+                            EXTERNALLY_CONDITIONALIZED_MAX);
+}
+
 }  // namespace
 
 namespace net {
 
 struct HeaderNameAndValue {
   const char* name;
   const char* value;
 };
 
 // If the request includes one of these request headers, then avoid caching
@@ skipping 1963 matching lines @@
     std::string validator;
     response_.headers->EnumerateHeader(
         NULL,
         kValidationHeaders[i].related_response_header_name,
         &validator);
 
     if (response_.headers->response_code() != 200 || truncated_ ||
         validator.empty() || validator != external_validation_.values[i]) {
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
       UpdateTransactionPattern(PATTERN_NOT_COVERED);

[rvargas (doing something else), 2014/09/04 01:45:12]

The description says that it tells whether the response could come from the
cache or not. This case cannot be served from the cache so it would be in the
wrong bucket.

[Adam Rice, 2014/09/04 15:19:41]

Sorry, I had some kind of tunnel vision and was convinced I couldn't get that
information for the histogram even though it is calculated directly above.

I have added it to the enum.

       DoneWritingToEntry(true);
     }
   }
 
+  // TODO(ricea): This calculation is expensive to perform just to collect
+  // statistics. Either remove it or use the result, depending on the result of
+  // the experiment.
+  RecordExternallyConditionalizedHistogram(RequiresValidation());
+
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
@@ skipping 630 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net