Refactor the resource_prefetch_predictor.

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 541 matching lines @@
       PopulatePrefetcherRequest(iterator->second, prefetch_requests);
     }
   }
 
   return !prefetch_requests->empty();
 }
 
 void ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const PrefetchData& data,
     ResourcePrefetcher::RequestVector* requests) {
-  for (const ResourceRow& row : data.resources) {
-    float confidence = static_cast<float>(row.number_of_hits) /
-                       (row.number_of_hits + row.number_of_misses);
+  for (const ResourceData& resource : data.resources) {
+    float confidence =
+        static_cast<float>(resource.number_of_hits()) /
+        (resource.number_of_hits() + resource.number_of_misses());
     if (confidence < config_.min_resource_confidence_to_trigger_prefetch ||
-        row.number_of_hits < config_.min_resource_hits_to_trigger_prefetch) {
+        resource.number_of_hits() <
+            config_.min_resource_hits_to_trigger_prefetch) {
       continue;
     }
 
     ResourcePrefetcher::Request* req =
-        new ResourcePrefetcher::Request(row.resource_url);
+        new ResourcePrefetcher::Request(GURL(resource.resource_url()));
     requests->push_back(req);
   }
 }
 
 void ResourcePrefetchPredictor::StartPrefetching(
     const NavigationID& navigation_id) {
   if (!prefetch_manager_.get())  // Prefetching not enabled.
     return;
 
   // Prefer URL based data first.
@@ skipping 222 matching lines @@
     cache_entry = data_map->insert(std::make_pair(
         key, PrefetchData(key_type, key))).first;
     cache_entry->second.last_visit = base::Time::Now();
     size_t new_resources_size = new_resources.size();
     std::set<GURL> resources_seen;
     for (size_t i = 0; i < new_resources_size; ++i) {
       if (resources_seen.find(new_resources[i].resource_url) !=
           resources_seen.end()) {
         continue;
       }
-      ResourceRow row_to_add;
-      row_to_add.resource_url = new_resources[i].resource_url;
-      row_to_add.resource_type = new_resources[i].resource_type;
-      row_to_add.number_of_hits = 1;
-      row_to_add.average_position = i + 1;
-      row_to_add.priority = new_resources[i].priority;
-      row_to_add.has_validators = new_resources[i].has_validators;
-      row_to_add.always_revalidate = new_resources[i].always_revalidate;
-      cache_entry->second.resources.push_back(row_to_add);
+      ResourceData resource_to_add;
+      resource_to_add.set_resource_url(new_resources[i].resource_url.spec());
+      resource_to_add.set_resource_type(static_cast<ResourceData::ResourceType>(
+          new_resources[i].resource_type));
+      resource_to_add.set_number_of_hits(1);
+      resource_to_add.set_average_position(i + 1);
+      resource_to_add.set_priority(
+          static_cast<ResourceData::Priority>(new_resources[i].priority));
+      resource_to_add.set_has_validators(new_resources[i].has_validators);
+      resource_to_add.set_always_revalidate(new_resources[i].always_revalidate);
+      cache_entry->second.resources.push_back(resource_to_add);
       resources_seen.insert(new_resources[i].resource_url);
     }
   } else {
-    ResourceRows& old_resources = cache_entry->second.resources;
+    std::vector<ResourceData>& old_resources = cache_entry->second.resources;
     cache_entry->second.last_visit = base::Time::Now();
 
     // Build indices over the data.
     std::map<GURL, int> new_index, old_index;
     int new_resources_size = static_cast<int>(new_resources.size());
     for (int i = 0; i < new_resources_size; ++i) {
       const URLRequestSummary& summary = new_resources[i];
       // Take the first occurence of every url.
       if (new_index.find(summary.resource_url) == new_index.end())
         new_index[summary.resource_url] = i;
     }
     int old_resources_size = static_cast<int>(old_resources.size());
     for (int i = 0; i < old_resources_size; ++i) {
-      const ResourceRow& row = old_resources[i];
-      DCHECK(old_index.find(row.resource_url) == old_index.end());
-      old_index[row.resource_url] = i;
+      const ResourceData& resource = old_resources[i];
+      GURL resource_url(resource.resource_url());
+      DCHECK(old_index.find(resource_url) == old_index.end());
+      old_index[resource_url] = i;
     }
 
     // Go through the old urls and update their hit/miss counts.
     for (int i = 0; i < old_resources_size; ++i) {
-      ResourceRow& old_row = old_resources[i];
-      if (new_index.find(old_row.resource_url) == new_index.end()) {
-        ++old_row.number_of_misses;
-        ++old_row.consecutive_misses;
+      ResourceData& old_resource = old_resources[i];
+      GURL resource_url(old_resource.resource_url());
+      if (new_index.find(resource_url) == new_index.end()) {
+        old_resource.set_number_of_misses(old_resource.number_of_misses() + 1);
+        old_resource.set_consecutive_misses(old_resource.consecutive_misses() +
+                                            1);
       } else {
-        const URLRequestSummary& new_row =
-            new_resources[new_index[old_row.resource_url]];
+        const URLRequestSummary& new_summary =
+            new_resources[new_index[resource_url]];
 
         // Update the resource type since it could have changed.
-        if (new_row.resource_type != content::RESOURCE_TYPE_LAST_TYPE)
-          old_row.resource_type = new_row.resource_type;
+        if (new_summary.resource_type != content::RESOURCE_TYPE_LAST_TYPE)
+          old_resource.set_resource_type(
+              static_cast<ResourceData::ResourceType>(
+                  new_summary.resource_type));
 
-        old_row.priority = new_row.priority;
+        old_resource.set_priority(
+            static_cast<ResourceData::Priority>(new_summary.priority));
 
-        int position = new_index[old_row.resource_url] + 1;
-        int total = old_row.number_of_hits + old_row.number_of_misses;
-        old_row.average_position =
-            ((old_row.average_position * total) + position) / (total + 1);
-        ++old_row.number_of_hits;
-        old_row.consecutive_misses = 0;
+        int position = new_index[resource_url] + 1;
+        int total =
+            old_resource.number_of_hits() + old_resource.number_of_misses();
+        old_resource.set_average_position(
+            ((old_resource.average_position() * total) + position) /
+            (total + 1));
+        old_resource.set_number_of_hits(old_resource.number_of_hits() + 1);
+        old_resource.set_consecutive_misses(0);
       }
     }
 
     // Add the new ones that we have not seen before.
     for (int i = 0; i < new_resources_size; ++i) {
       const URLRequestSummary& summary = new_resources[i];
       if (old_index.find(summary.resource_url) != old_index.end())
         continue;
 
       // Only need to add new stuff.
-      ResourceRow row_to_add;
-      row_to_add.resource_url = summary.resource_url;
-      row_to_add.resource_type = summary.resource_type;
-      row_to_add.number_of_hits = 1;
-      row_to_add.average_position = i + 1;
-      row_to_add.priority = summary.priority;
-      row_to_add.has_validators = new_resources[i].has_validators;
-      row_to_add.always_revalidate = new_resources[i].always_revalidate;
-      old_resources.push_back(row_to_add);
+      ResourceData resource_to_add;
+      resource_to_add.set_resource_url(summary.resource_url.spec());
+      resource_to_add.set_resource_type(
+          static_cast<ResourceData::ResourceType>(summary.resource_type));
+      resource_to_add.set_number_of_hits(1);
+      resource_to_add.set_average_position(i + 1);
+      resource_to_add.set_priority(
+          static_cast<ResourceData::Priority>(summary.priority));
+      resource_to_add.set_has_validators(new_resources[i].has_validators);
+      resource_to_add.set_always_revalidate(new_resources[i].always_revalidate);
+      old_resources.push_back(resource_to_add);
 
       // To ensure we dont add the same url twice.
       old_index[summary.resource_url] = 0;
     }
   }
 
   // Trim and sort the resources after the update.
-  ResourceRows& resources = cache_entry->second.resources;
-  for (ResourceRows::iterator it = resources.begin();
-       it != resources.end();) {
-    it->UpdateScore();
-    if (it->consecutive_misses >= config_.max_consecutive_misses)
+  std::vector<ResourceData>& resources = cache_entry->second.resources;
+  for (auto it = resources.begin(); it != resources.end();) {
+    if (it->consecutive_misses() >= config_.max_consecutive_misses)
       it = resources.erase(it);
     else
       ++it;
   }
-  ResourcePrefetchPredictorTables::SortResourceRows(&resources);
+  ResourcePrefetchPredictorTables::SortResources(&resources);
   if (resources.size() > config_.max_resources_per_entry)
     resources.resize(config_.max_resources_per_entry);
 
   // If the row has no resources, remove it from the cache and delete the
   // entry in the database. Else update the database.
   if (resources.empty()) {
     data_map->erase(key);
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&ResourcePrefetchPredictorTables::DeleteSingleDataPoint,
@@ skipping 56 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