predictors: Track whether resources have validators, and require validation.

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 272 matching lines @@
   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;
+  content::ResourceType actual_resource_type =
+      GetResourceType(resource_type, mime_type);
+  return actual_resource_type == content::RESOURCE_TYPE_STYLESHEET ||
+         actual_resource_type == content::RESOURCE_TYPE_SCRIPT ||
+         actual_resource_type == content::RESOURCE_TYPE_IMAGE ||
+         actual_resource_type == content::RESOURCE_TYPE_FONT_RESOURCE;
 }
 
 // static
+content::ResourceType ResourcePrefetchPredictor::GetResourceType(
+    content::ResourceType resource_type,
+    const std::string& mime_type) {
+  // 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) {
+    return GetResourceTypeFromMimeType(mime_type,
+                                       content::RESOURCE_TYPE_LAST_TYPE);
+  }
+  return resource_type;
+}
+
+// static
 bool ResourcePrefetchPredictor::IsNoStore(const net::URLRequest* response) {
   if (response->was_cached())
     return false;
 
   const net::HttpResponseInfo& response_info = response->response_info();
   if (!response_info.headers.get())
     return false;
   return response_info.headers->HasHeaderValue("cache-control", "no-store");
 }
 
@@ skipping 20 matching lines @@
   }
   return fallback;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ResourcePrefetchPredictor structs.
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary()
     : resource_type(content::RESOURCE_TYPE_LAST_TYPE),
       priority(net::IDLE),
-      was_cached(false) {}
+      was_cached(false),
+      has_validators(false),
+      always_revalidate(false) {}
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary(
     const URLRequestSummary& other)
     : navigation_id(other.navigation_id),
       resource_url(other.resource_url),
       resource_type(other.resource_type),
       priority(other.priority),
       mime_type(other.mime_type),
       was_cached(other.was_cached),
-      redirect_url(other.redirect_url) {}
+      redirect_url(other.redirect_url),
+      has_validators(other.has_validators),
+      always_revalidate(other.always_revalidate) {}
 
 ResourcePrefetchPredictor::URLRequestSummary::~URLRequestSummary() {
 }
 
 // static
 bool ResourcePrefetchPredictor::URLRequestSummary::SummarizeResponse(
     const net::URLRequest& request,
     URLRequestSummary* summary) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(&request);
   if (!info)
     return false;
 
   int render_process_id, render_frame_id;
   if (!info->GetAssociatedRenderFrame(&render_process_id, &render_frame_id))
     return false;
 
   summary->navigation_id = NavigationID(render_process_id, render_frame_id,
                                         request.first_party_for_cookies());
   summary->navigation_id.creation_time = request.creation_time();
   summary->resource_url = request.original_url();
-  summary->resource_type = info->GetResourceType();
+  content::ResourceType resource_type_from_request = info->GetResourceType();
   summary->priority = request.priority();
   request.GetMimeType(&summary->mime_type);
   summary->was_cached = request.was_cached();
+  summary->resource_type =
+      GetResourceType(resource_type_from_request, summary->mime_type);
+
+  scoped_refptr<net::HttpResponseHeaders> headers =
+      request.response_info().headers;
+  if (headers.get()) {
+    summary->has_validators = headers->HasValidators();
+    // RFC 2616, section 14.9.
+    summary->always_revalidate =
+        headers->HasHeaderValue("cache-control", "no-cache") ||
+        headers->HasHeaderValue("pragma", "no-cache") ||
+        headers->HasHeaderValue("vary", "*");
+  }
   return true;
 }
 
 ResourcePrefetchPredictor::Result::Result(
     PrefetchKeyType i_key_type,
     ResourcePrefetcher::RequestVector* i_requests)
     : key_type(i_key_type),
       requests(i_requests) {
 }
 
@@ skipping 552 matching lines @@
       if (resources_seen.find(new_resources[i].resource_url) !=
           resources_seen.end()) {
         continue;
       }
       ResourceRow row_to_add;
       row_to_add.resource_url = new_resources[i].resource_url;
       row_to_add.resource_type = new_resources[i].resource_type;
       row_to_add.number_of_hits = 1;
       row_to_add.average_position = i + 1;
       row_to_add.priority = new_resources[i].priority;
+      row_to_add.has_validators = new_resources[i].has_validators;
+      row_to_add.always_revalidate = new_resources[i].always_revalidate;
       cache_entry->second.resources.push_back(row_to_add);
       resources_seen.insert(new_resources[i].resource_url);
     }
   } else {
     ResourceRows& old_resources = cache_entry->second.resources;
     cache_entry->second.last_visit = base::Time::Now();
 
     // Build indices over the data.
     std::map<GURL, int> new_index, old_index;
     int new_resources_size = static_cast<int>(new_resources.size());
@@ skipping 41 matching lines @@
       if (old_index.find(summary.resource_url) != old_index.end())
         continue;
 
       // Only need to add new stuff.
       ResourceRow row_to_add;
       row_to_add.resource_url = summary.resource_url;
       row_to_add.resource_type = summary.resource_type;
       row_to_add.number_of_hits = 1;
       row_to_add.average_position = i + 1;
       row_to_add.priority = summary.priority;
+      row_to_add.has_validators = new_resources[i].has_validators;
+      row_to_add.always_revalidate = new_resources[i].always_revalidate;
       old_resources.push_back(row_to_add);
 
       // To ensure we dont add the same url twice.
       old_index[summary.resource_url] = 0;
     }
   }
 
   // Trim and sort the resources after the update.
   ResourceRows& resources = cache_entry->second.resources;
   for (ResourceRows::iterator it = resources.begin();
@@ skipping 369 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