predictors: Also track "no-cache" and "must-revalidate" resources.

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 45 matching lines @@
                                 "application/font-ttf"};
 
 // For reporting whether a subresource is handled or not, and for what reasons.
 enum ResourceStatus {
   RESOURCE_STATUS_HANDLED = 0,
   RESOURCE_STATUS_NOT_HTTP_OR_HTTPS_PAGE = 1,
   RESOURCE_STATUS_NOT_HTTP_OR_HTTPS_RESOURCE = 2,
   RESOURCE_STATUS_UNSUPPORTED_RESOURCE_TYPE = 4,
   RESOURCE_STATUS_NOT_GET = 8,
   RESOURCE_STATUS_URL_TOO_LONG = 16,
-  RESOURCE_STATUS_NOT_CACHEABLE = 32,
+  RESOURCE_STATUS_NO_STORE = 32,

[pasko, 2016/08/09 09:31:11]

this enum is used in a histogram, hence it should not be updated, fields can
only be added, otherwise it is not possible to make a histograms.xml that serves
all datapoints.

I found that this histogram has data collected on 2015-06-09.

[Benoit L, 2016/08/09 12:24:38]

Acknowledged.

   RESOURCE_STATUS_HEADERS_MISSING = 64,
   RESOURCE_STATUS_MAX = 128,
 };
 
 // For reporting various interesting events that occur during the loading of a
 // single main frame.
 enum NavigationEvent {
   NAVIGATION_EVENT_REQUEST_STARTED = 0,
   NAVIGATION_EVENT_REQUEST_REDIRECTED = 1,
   NAVIGATION_EVENT_REQUEST_REDIRECTED_EMPTY_URL = 2,
@@ skipping 196 matching lines @@
     resource_status |= RESOURCE_STATUS_NOT_GET;
 
   if (response->original_url().spec().length() >
       ResourcePrefetchPredictorTables::kMaxStringLength) {
     resource_status |= RESOURCE_STATUS_URL_TOO_LONG;
   }
 
   if (!response->response_info().headers.get())
     resource_status |= RESOURCE_STATUS_HEADERS_MISSING;
 
-  if (!IsCacheable(response))
-    resource_status |= RESOURCE_STATUS_NOT_CACHEABLE;
+  if (IsNoStore(response))
+    resource_status |= RESOURCE_STATUS_NO_STORE;
 
   UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ResourceStatus",

[pasko, 2016/08/09 09:31:11]

do we actually need all of this histogram? Alternatively we could record counts
for each resource status. We could have interesting combinations as well, like
3, 7, 35, 36 and 39. They would be more readable this way on the dashboard. 

[Benoit L, 2016/08/09 12:24:38]

Per offline discussion, removed the histogram (but kept the enum for now, used
for debugging).
Done.

                             resource_status,
                             RESOURCE_STATUS_MAX);
 
   return resource_status == 0;
 }
 
 // static
 bool ResourcePrefetchPredictor::IsHandledResourceType(
     content::ResourceType resource_type,
     const std::string& mime_type) {
   bool handled = resource_type == content::RESOURCE_TYPE_STYLESHEET ||
                  resource_type == content::RESOURCE_TYPE_SCRIPT ||
                  resource_type == content::RESOURCE_TYPE_IMAGE ||
                  resource_type == content::RESOURCE_TYPE_FONT_RESOURCE;
   // Restricts content::RESOURCE_TYPE_{PREFETCH,SUB_RESOURCE} to a small set of
   // mime types, because these resource types don't communicate how the
   // resources
   // will be used.
   if ((resource_type == content::RESOURCE_TYPE_PREFETCH ||
        resource_type == content::RESOURCE_TYPE_SUB_RESOURCE)) {
     content::ResourceType resource_type_from_mime = GetResourceTypeFromMimeType(
         mime_type, content::RESOURCE_TYPE_LAST_TYPE);
     handled = resource_type_from_mime != content::RESOURCE_TYPE_LAST_TYPE;
   }
   return handled;
 }
 
 // static
-bool ResourcePrefetchPredictor::IsCacheable(const net::URLRequest* response) {
+bool ResourcePrefetchPredictor::IsNoStore(const net::URLRequest* response) {
   if (response->was_cached())
-    return true;
+    return false;
 
-  // For non cached responses, we will ensure that the freshness lifetime is
-  // some sane value.
   const net::HttpResponseInfo& response_info = response->response_info();
   if (!response_info.headers.get())
     return false;
-  base::Time response_time(response_info.response_time);
-  response_time += base::TimeDelta::FromSeconds(1);
-  base::TimeDelta freshness =
-      response_info.headers->GetFreshnessLifetimes(response_time).freshness;
-  return freshness > base::TimeDelta();
+  return response_info.headers->HasHeaderValue("cache-control", "no-store");
 }
 
 // static
 content::ResourceType ResourcePrefetchPredictor::GetResourceTypeFromMimeType(
     const std::string& mime_type,
     content::ResourceType fallback) {
   if (mime_type.empty()) {
     return fallback;
   } else if (mime_util::IsSupportedImageMimeType(mime_type)) {
     return content::RESOURCE_TYPE_IMAGE;
@@ skipping 1046 matching lines @@
     // HistoryService is already loaded. Continue with Initialization.
     OnHistoryAndCacheLoaded();
     return;
   }
   DCHECK(!history_service_observer_.IsObserving(history_service));
   history_service_observer_.Add(history_service);
   return;
 }
 
 }  // namespace predictors