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 292 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) {

[alexilin, 2017/04/21 12:07:28]

Resources are written to the database already sorted. There is no sense to
resort them when loading.

[Benoit L, 2017/04/25 08:59:21]

Unless the sorting function changes, right?

[alexilin, 2017/04/25 13:04:25]

We could return this statement back if sorting function changes. There was no
such a change since the last version bumping.
If you want to keep it, then we need to add the similar statement for the
origins table because it also keeps entries sorted.

[Benoit L, 2017/04/25 15:12:39]

Acknowledged.

-    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 81 matching lines @@
     default:
       type_multiplier = 1;
   }
 
   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;
+  switch (resource.type()) {

[Benoit L, 2017/04/25 08:59:21]

Can we make that consistent with the other scoring function without duplication?
Since these are separate enums, it may cost more than what it brings (for
instance, converting types to:
(is_blink_resource_type << 16 + resource_type), and matching several cases)...
Not sure about that.

However, it would be best to have the same resource type ordering.

Also, can you add a comment explaining that this means a strict ordering, since
the weight ratio is in [0, 1)?

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

Done.

+    case precache::PrecacheResource::RESOURCE_TYPE_FONT:
+      type_multiplier = 4;
+      break;
+    case precache::PrecacheResource::RESOURCE_TYPE_STYLESHEET:
+      type_multiplier = 3;
+      break;
+    case precache::PrecacheResource::RESOURCE_TYPE_SCRIPT:
+      type_multiplier = 2;
+      break;
+    case precache::PrecacheResource::RESOURCE_TYPE_IMAGE:
+      type_multiplier = 1;
+      break;
+    default:
+      type_multiplier = 0;
+  }
+
+  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