predictors: Add resource type to manifest.

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 <map>
 #include <set>
 #include <utility>
 
@@ skipping 960 matching lines @@
 
   // Don't prefetch resource if it has false bit in any of the following
   // bitsets. All bits assumed to be true if an optional has no value.
   base::Optional<std::vector<bool>> not_unused =
       precache::GetResourceBitset(manifest, internal::kUnusedRemovedExperiment);
   base::Optional<std::vector<bool>> not_versioned = precache::GetResourceBitset(
       manifest, internal::kVersionedRemovedExperiment);
   base::Optional<std::vector<bool>> not_no_store = precache::GetResourceBitset(
       manifest, internal::kNoStoreRemovedExperiment);
 
+  std::vector<const precache::PrecacheResource*> filtered_resources;
+
   bool has_prefetchable_resource = false;
   for (int i = 0; i < manifest.resource_size(); ++i) {
     const precache::PrecacheResource& resource = manifest.resource(i);
     if (resource.weight_ratio() > kMinWeight &&
         (!not_unused.has_value() || not_unused.value()[i]) &&
         (!not_versioned.has_value() || not_versioned.value()[i]) &&
         (!not_no_store.has_value() || not_no_store.value()[i])) {
       has_prefetchable_resource = true;
       if (urls)
-        urls->emplace_back(resource.url());
+        filtered_resources.push_back(&resource);
     }
   }
 
+  if (urls) {
+    std::sort(
+        filtered_resources.begin(), filtered_resources.end(),
+        [](const precache::PrecacheResource* x,
+           const precache::PrecacheResource* y) {
+          return ResourcePrefetchPredictorTables::ComputePrecacheResourceScore(

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

nit: use a local "using" to make this a bit easier to read?

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

C++ doesn't have using declaration for static class methods. I could use
function pointer alias, do you think it's better?

float (&compute_score)(const precache::PrecacheResource&) = 
    ResourcePrefetchPredictorTables::ComputePrecacheResourceScore;
return compute_score(*x) > compute_score(*y);

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

Ah, too bad. Let's keep it simple then.

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

Acknowledged.

+                     *x) >
+                 ResourcePrefetchPredictorTables::ComputePrecacheResourceScore(
+                     *y);
+        });
+    for (auto* resource : filtered_resources)
+      urls->emplace_back(resource->url());
+  }
+
   return has_prefetchable_resource;
 }
 
 void ResourcePrefetchPredictor::CreateCaches(
     std::unique_ptr<PrefetchDataMap> url_data_map,
     std::unique_ptr<PrefetchDataMap> host_data_map,
     std::unique_ptr<RedirectDataMap> url_redirect_data_map,
     std::unique_ptr<RedirectDataMap> host_redirect_data_map,
     std::unique_ptr<ManifestDataMap> manifest_data_map,
     std::unique_ptr<OriginDataMap> origin_data_map) {
@@ skipping 711 matching lines @@
   // The manifest is too large to store.
   if (host.length() > ResourcePrefetchPredictorTables::kMaxStringLength ||
       static_cast<uint32_t>(manifest.ByteSize()) > kMaxManifestByteSize) {
     return;
   }
 
   auto cache_entry = manifest_table_cache_->find(host);
   if (cache_entry == manifest_table_cache_->end()) {
     if (manifest_table_cache_->size() >= config_.max_hosts_to_track)
       RemoveOldestEntryInManifestDataMap(manifest_table_cache_.get());
-    cache_entry =
-        manifest_table_cache_->insert(std::make_pair(host, manifest)).first;
+    cache_entry = manifest_table_cache_->insert({host, manifest}).first;
   } else {
     cache_entry->second = manifest;
   }
 
-  precache::RemoveUnknownFields(&cache_entry->second);
+  auto& data = cache_entry->second;
+  precache::RemoveUnknownFields(&data);
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(&ResourcePrefetchPredictorTables::UpdateManifestData,
-                     tables_, host, cache_entry->second));
+                     tables_, host, data));
 }
 
 void ResourcePrefetchPredictor::UpdatePrefetchDataByManifest(
     const std::string& key,
     PrefetchKeyType key_type,
     PrefetchDataMap* data_map,
     const precache::PrecacheManifest& manifest) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
@@ skipping 53 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors