predictors: Support fonts in resource_prefetch_predictors.

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>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 16 matching lines @@
 #include "net/base/mime_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace {
 
+// Sorted by decreasing likelihood according to HTTP archive.
+const char* kFontMimeTypes[] = {"font/woff2",
+                                "application/x-font-woff",
+                                "application/font-woff",
+                                "application/font-woff2",
+                                "font/x-woff",
+                                "application/x-font-ttf",
+                                "font/woff",
+                                "font/ttf",
+                                "application/x-font-otf",
+                                "x-font/woff",
+                                "application/font-sfnt",
+                                "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_MIME_TYPE = 4,
+  RESOURCE_STATUS_UNSUPPORTED_RESOURCE_TYPE = 4,
   RESOURCE_STATUS_NOT_GET = 8,
   RESOURCE_STATUS_URL_TOO_LONG = 16,
   RESOURCE_STATUS_NOT_CACHEABLE = 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 {
@@ skipping 145 matching lines @@
 bool ResourcePrefetchPredictor::ShouldRecordResponse(
     net::URLRequest* response) {
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(response);
   if (!request_info)
     return false;
 
   if (!request_info->IsMainFrame())
     return false;
 
-  return request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME ?
-      IsHandledMainPage(response) : IsHandledSubresource(response);
+  content::ResourceType resource_type = request_info->GetResourceType();
+  return resource_type == content::RESOURCE_TYPE_MAIN_FRAME
+             ? IsHandledMainPage(response)
+             : IsHandledSubresource(response, resource_type);
 }
 
 // static
 bool ResourcePrefetchPredictor::ShouldRecordRedirect(
     net::URLRequest* response) {
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(response);
   if (!request_info)
     return false;
 
   if (!request_info->IsMainFrame())
     return false;
 
   return request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME &&
       IsHandledMainPage(response);
 }
 
 // static
 bool ResourcePrefetchPredictor::IsHandledMainPage(net::URLRequest* request) {
   return request->url().SchemeIsHTTPOrHTTPS();
 }
 
 // static
 bool ResourcePrefetchPredictor::IsHandledSubresource(
-    net::URLRequest* response) {
+    net::URLRequest* response,
+    content::ResourceType resource_type) {
   int resource_status = 0;
 
   if (!response->first_party_for_cookies().SchemeIsHTTPOrHTTPS())
     resource_status |= RESOURCE_STATUS_NOT_HTTP_OR_HTTPS_PAGE;
 
   if (!response->url().SchemeIsHTTPOrHTTPS())
     resource_status |= RESOURCE_STATUS_NOT_HTTP_OR_HTTPS_RESOURCE;
 
   std::string mime_type;
   response->GetMimeType(&mime_type);
-  if (!mime_type.empty() && !mime_util::IsSupportedImageMimeType(mime_type) &&
-      !mime_util::IsSupportedJavascriptMimeType(mime_type) &&
-      !net::MatchesMimeType("text/css", mime_type)) {
-    resource_status |= RESOURCE_STATUS_UNSUPPORTED_MIME_TYPE;
-  }
+  if (!IsHandledResourceType(resource_type, mime_type))
+    resource_status |= RESOURCE_STATUS_UNSUPPORTED_RESOURCE_TYPE;
 
   if (response->method() != "GET")
     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);
 
   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) {
   if (response->was_cached())
     return true;
 
   // 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();
 }
 
 // static
 content::ResourceType ResourcePrefetchPredictor::GetResourceTypeFromMimeType(
     const std::string& mime_type,
     content::ResourceType fallback) {
-  if (mime_util::IsSupportedImageMimeType(mime_type))
+  if (mime_type.empty()) {
+    return fallback;
+  } else if (mime_util::IsSupportedImageMimeType(mime_type)) {
     return content::RESOURCE_TYPE_IMAGE;
-  else if (mime_util::IsSupportedJavascriptMimeType(mime_type))
+  } else if (mime_util::IsSupportedJavascriptMimeType(mime_type)) {
     return content::RESOURCE_TYPE_SCRIPT;
-  else if (net::MatchesMimeType("text/css", mime_type))
+  } else if (net::MatchesMimeType("text/css", mime_type)) {
     return content::RESOURCE_TYPE_STYLESHEET;
-  else
-    return fallback;
+  } else {
+    bool found =
+        std::any_of(std::begin(kFontMimeTypes), std::end(kFontMimeTypes),
+                    [&mime_type](const std::string& mime) {
+                      return net::MatchesMimeType(mime, mime_type);
+                    });
+    if (found)
+      return content::RESOURCE_TYPE_FONT_RESOURCE;
+  }
+  return fallback;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ResourcePrefetchPredictor structs.
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary()
     : resource_type(content::RESOURCE_TYPE_LAST_TYPE),
       was_cached(false) {
 }
 
@@ skipping 1018 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