predictors: Add resource type to manifest.

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 <algorithm>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 51 matching lines @@
   *key = statement->ColumnString(0);
 
   int size = statement->ColumnByteLength(1);
   const void* blob = statement->ColumnBlob(1);
   DCHECK(blob);
   data->ParseFromArray(blob, size);
 
   return true;
 }
 
+predictors::ResourceData::ResourceType PrecacheResourceTypeToResourceType(
+    precache::PrecacheResource::Type resource_type) {
+  using precache::PrecacheResource;
+  using predictors::ResourceData;
+  switch (resource_type) {
+    case PrecacheResource::RESOURCE_TYPE_IMAGE:
+      return ResourceData::RESOURCE_TYPE_IMAGE;
+    case PrecacheResource::RESOURCE_TYPE_FONT:
+      return ResourceData::RESOURCE_TYPE_FONT_RESOURCE;
+    case PrecacheResource::RESOURCE_TYPE_STYLESHEET:
+      return ResourceData::RESOURCE_TYPE_STYLESHEET;
+    case PrecacheResource::RESOURCE_TYPE_SCRIPT:
+      return ResourceData::RESOURCE_TYPE_SCRIPT;
+    case PrecacheResource::RESOURCE_TYPE_OTHER:
+    case PrecacheResource::RESOURCE_TYPE_UNKNOWN:
+    default:
+      return ResourceData::RESOURCE_TYPE_SUB_RESOURCE;
+  }
+}
+
+int GetResourceTypeMultiplier(
+    predictors::ResourceData::ResourceType resource_type) {
+  switch (resource_type) {
+    case predictors::ResourceData::RESOURCE_TYPE_STYLESHEET:
+      return 4;
+    case predictors::ResourceData::RESOURCE_TYPE_SCRIPT:
+      return 3;
+    case predictors::ResourceData::RESOURCE_TYPE_FONT_RESOURCE:

[alexilin, 2017/04/25 17:37:05]

Actually, I'm also thinking about prioritizing fonts above scripts. Rationale:
Resource Fetch Prioritization in Chromium
https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuM....
Not preloaded fonts have higher priority than any script.
Again, there is almost no changes for non-manifest db but it'd make difference
for manifests.

[Benoit L, 2017/04/27 08:54:15]

Well, this is because we start fetching font at the point where we needed them
yesterday.
Here we are fetching stuff ahead of time, and we will surely need CSS and
blocking scripts before the font, since we cannot reach layout before executing
these scripts.

[alexilin, 2017/04/27 15:32:23]

Agree. Thanks for the explanation!

+      return 2;
+    case predictors::ResourceData::RESOURCE_TYPE_IMAGE:
+    default:
+      return 1;
+  }
+}
+
 }  // namespace
 
 namespace predictors {
 
 using content::BrowserThread;
 
 // static
 void ResourcePrefetchPredictorTables::TrimResources(
     PrefetchData* data,
     size_t max_consecutive_misses) {
@@ skipping 221 matching lines @@
     PrefetchKeyType key_type,
     PrefetchDataMap* data_map) {
   // Read the resources table and organize it per primary key.
   const char* table_name = GetTableName(key_type, PrefetchDataType::RESOURCE);
   sql::Statement resource_reader(DB()->GetUniqueStatement(
       base::StringPrintf(kSelectAllStatementTemplate, table_name).c_str()));
 
   PrefetchData data;
   std::string key;
   while (StepAndInitializeProtoData(&resource_reader, &key, &data)) {
-    data_map->insert(std::make_pair(key, data));
+    data_map->insert({key, data});
     DCHECK_EQ(data.primary_key(), key);
   }
-
-  // Sort each of the resource vectors by score.
-  for (auto& kv : *data_map) {
-    SortResources(&(kv.second));
-  }
 }
 
 void ResourcePrefetchPredictorTables::GetAllRedirectDataHelper(
     PrefetchKeyType key_type,
     RedirectDataMap* data_map) {
   // Read the redirects table and organize it per primary key.
   const char* table_name = GetTableName(key_type, PrefetchDataType::REDIRECT);
   sql::Statement redirect_reader(DB()->GetUniqueStatement(
       base::StringPrintf(kSelectAllStatementTemplate, table_name).c_str()));
 
   RedirectData data;
   std::string key;
   while (StepAndInitializeProtoData(&redirect_reader, &key, &data)) {
-    data_map->insert(std::make_pair(key, data));
+    data_map->insert({key, data});
     DCHECK_EQ(data.primary_key(), key);
   }
 }
 
 void ResourcePrefetchPredictorTables::GetAllManifestDataHelper(
     ManifestDataMap* manifest_map) {
   sql::Statement manifest_reader(DB()->GetUniqueStatement(
       base::StringPrintf(kSelectAllStatementTemplate, kManifestTableName)
           .c_str()));
 
   precache::PrecacheManifest data;
   std::string key;
   while (StepAndInitializeProtoData(&manifest_reader, &key, &data)) {
-    manifest_map->insert(std::make_pair(key, data));
+    manifest_map->insert({key, data});
   }
 }
 
 void ResourcePrefetchPredictorTables::GetAllOriginDataHelper(
     OriginDataMap* origin_map) {
   sql::Statement reader(DB()->GetUniqueStatement(
       base::StringPrintf(kSelectAllStatementTemplate, kOriginTableName)
           .c_str()));
 
   OriginData data;
@@ skipping 61 matching lines @@
       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:
-      type_multiplier = 2;
-      break;
-    case ResourceData::RESOURCE_TYPE_IMAGE:
-    default:
-      type_multiplier = 1;
-  }
+  int type_multiplier = GetResourceTypeMultiplier(data.resource_type());
 
   constexpr int kMaxResourcesPerType = 100;
   return kMaxResourcesPerType *
              (priority_multiplier * 100 + type_multiplier * 10) -
          data.average_position();
 }
 
+// static
+float ResourcePrefetchPredictorTables::ComputePrecacheResourceScore(
+    const precache::PrecacheResource& resource) {
+  int type_multiplier = GetResourceTypeMultiplier(
+      PrecacheResourceTypeToResourceType(resource.type()));
+  // This means a strict ordering, since the weight_ratio is in [0,1).
+  return type_multiplier * 10 + resource.weight_ratio();
+}
+
+// static
 float ResourcePrefetchPredictorTables::ComputeOriginScore(
     const OriginStat& origin) {
   // The ranking is done by considering, in this order:
   // 1. High confidence resources (>75% and more than 10 hits)
   // 2. Mandatory network access
   // 3. Network accessed
   // 4. Average position (decreasing)
   float score = 0;
   float confidence = static_cast<float>(origin.number_of_hits()) /
                      (origin.number_of_hits() + origin.number_of_misses());
@@ skipping 149 matching lines @@
       return kManifestTableName;
     case PrefetchDataType::ORIGIN:
       return kOriginTableName;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace predictors