predictors: Refactor the resource_prefetch_predictor database handling.

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>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
+#include "chrome/browser/predictors/resource_prefetch_predictor.pb.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/mime_util/mime_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/mime_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
+using chrome_browser_predictors::ResourceData;
 
 namespace {
 
 // Sorted by decreasing likelihood according to HTTP archive.
 const char* kFontMimeTypes[] = {"font/woff2",
                                 "application/x-font-woff",
                                 "application/font-woff",
                                 "application/font-woff2",
                                 "font/x-woff",
                                 "application/x-font-ttf",
@@ skipping 650 matching lines @@
       PopulatePrefetcherRequest(iterator->second, prefetch_requests);
     }
   }
 
   return !prefetch_requests->empty();
 }
 
 void ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const PrefetchData& data,
     ResourcePrefetcher::RequestVector* requests) {
-  for (ResourceRows::const_iterator it = data.resources.begin();
-       it != data.resources.end(); ++it) {
-    float confidence = static_cast<float>(it->number_of_hits) /
-        (it->number_of_hits + it->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 ||
-        it->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(
-        it->resource_url);
+    ResourcePrefetcher::Request* req =
+        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 208 matching lines @@
 }
 
 void ResourcePrefetchPredictor::LearnNavigation(
     const std::string& key,
     PrefetchKeyType key_type,
     const std::vector<URLRequestSummary>& new_resources,
     size_t max_data_map_size,
     PrefetchDataMap* data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  using ResourceType = ::chrome_browser_predictors::ResourceData_ResourceType;
+  using Priority = ::chrome_browser_predictors::ResourceData_Priority;
+
   // If the primary key is too long reject it.
   if (key.length() > ResourcePrefetchPredictorTables::kMaxStringLength) {
     if (key_type == PREFETCH_KEY_TYPE_HOST)
       RecordNavigationEvent(NAVIGATION_EVENT_HOST_TOO_LONG);
     else
       RecordNavigationEvent(NAVIGATION_EVENT_MAIN_FRAME_URL_TOO_LONG);
     return;
   }
 
   PrefetchDataMap::iterator cache_entry = data_map->find(key);
   if (cache_entry == data_map->end()) {
     if (data_map->size() >= max_data_map_size) {
       // The table is full, delete an entry.
       RemoveOldestEntryInPrefetchDataMap(key_type, data_map);
     }
 
     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<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<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[GURL(old_resource.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;
+        // Update the resource type and priority.
+        if (new_summary.resource_type != content::RESOURCE_TYPE_LAST_TYPE)
+          old_resource.set_resource_type(
+              static_cast<ResourceType>(new_summary.resource_type));
+        old_resource.set_priority(static_cast<Priority>(new_summary.priority));
 
-        old_row.priority = new_row.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<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<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();
+  std::vector<ResourceData>& resources = cache_entry->second.resources;
+  for (std::vector<ResourceData>::iterator it = resources.begin();
        it != resources.end();) {
-    it->UpdateScore();
-    if (it->consecutive_misses >= config_.max_consecutive_misses)
+    ResourcePrefetchPredictorTables::UpdateResourceScore(&(*it));
+    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 350 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