predictors: Take the priority into account for scoring resources.

chrome/browser/predictors/resource_prefetch_predictor_tables.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_tables.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 116 matching lines @@
 
 }  // namespace
 
 namespace predictors {
 
 // static
 void ResourcePrefetchPredictorTables::SortResources(
     std::vector<ResourceData>* resources) {
   std::sort(resources->begin(), resources->end(),
             [](const ResourceData& x, const ResourceData& y) {
+              // Decreasing score ordering.
               return ComputeResourceScore(x) > ComputeResourceScore(y);
             });
 }
 
 // static
 void ResourcePrefetchPredictorTables::SortRedirects(
     std::vector<RedirectStat>* redirects) {
   std::sort(redirects->begin(), redirects->end(),
             [](const RedirectStat& x, const RedirectStat& y) {
+              // Decreasing score ordering.
               return ComputeRedirectScore(x) > ComputeRedirectScore(y);
             });
 }
 
 ResourcePrefetchPredictorTables::PrefetchData::PrefetchData(
     PrefetchKeyType i_key_type,
     const std::string& i_primary_key)
     : key_type(i_key_type),
       primary_key(i_primary_key) {
 }
@@ skipping 315 matching lines @@
   for (const RedirectStat& redirect : data.redirect_endpoints()) {
     if (redirect.url().length() > kMaxStringLength)
       return false;
   }
   return true;
 }
 
 // static
 float ResourcePrefetchPredictorTables::ComputeResourceScore(
     const ResourceData& data) {
-  // The score is calculated so that when the rows are sorted, stylesheets,
-  // scripts and fonts appear first, sorted by position(ascending) and then the
-  // rest of the resources sorted by position (ascending).
-  static const int kMaxResourcesPerType = 100;
+  // The ranking is done by considering, in this order:
+  // 1. Resource Priority
+  // 2. Request resource type
+  // 3. Finally, the average position, giving a higher priotity to earlier
+  //    resources.
+
+  int priority_multiplier;
+  switch (data.priority()) {
+    case ResourceData::REQUEST_PRIORITY_HIGHEST:
+      priority_multiplier = 3;
+      break;
+    case ResourceData::REQUEST_PRIORITY_MEDIUM:
+      priority_multiplier = 2;
+      break;
+    case ResourceData::REQUEST_PRIORITY_LOW:
+    case ResourceData::REQUEST_PRIORITY_LOWEST:
+    case ResourceData::REQUEST_PRIORITY_IDLE:
+    default:
+      priority_multiplier = 1;
+      break;
+  }
+
+  int type_multiplier;
   switch (data.resource_type()) {
     case ResourceData::RESOURCE_TYPE_STYLESHEET:
     case ResourceData::RESOURCE_TYPE_SCRIPT:
+      type_multiplier = 3;
+      break;
     case ResourceData::RESOURCE_TYPE_FONT_RESOURCE:
-      return (2 * kMaxResourcesPerType) - data.average_position();
-
+      type_multiplier = 2;
+      break;
     case ResourceData::RESOURCE_TYPE_IMAGE:
     default:
-      return kMaxResourcesPerType - data.average_position();
+      type_multiplier = 1;
   }
-  // TODO(lizeb): Take priority into account.
+
+  constexpr int kMaxResourcesPerType = 100;
+  return kMaxResourcesPerType *
+             (priority_multiplier * 100 + type_multiplier * 10) -
+         data.average_position();
 }
 
 // static
 float ResourcePrefetchPredictorTables::ComputeRedirectScore(
     const RedirectStat& data) {
   // TODO(alexilin): Invent some scoring.
   return 0.0;
 }
 
 // static
@@ skipping 172 matching lines @@
       return is_host ? kHostRedirectTableName : kUrlRedirectTableName;
     case PrefetchDataType::METADATA:
       return is_host ? kHostMetadataTableName : kUrlMetadataTableName;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace predictors