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,
   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;
-
-  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ResourceStatus",
-                            resource_status,
-                            RESOURCE_STATUS_MAX);
+  if (IsNoStore(response))
+    resource_status |= RESOURCE_STATUS_NO_STORE;
 
   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