predictors: Refactor the prefetcher in 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 300 matching lines @@
     summary->has_validators = headers->HasValidators();
     // RFC 2616, section 14.9.
     summary->always_revalidate =
         headers->HasHeaderValue("cache-control", "no-cache") ||
         headers->HasHeaderValue("pragma", "no-cache") ||
         headers->HasHeaderValue("vary", "*");
   }
   return true;
 }
 
-ResourcePrefetchPredictor::Result::Result(
-    PrefetchKeyType i_key_type,
-    ResourcePrefetcher::RequestVector* i_requests)
-    : key_type(i_key_type),
-      requests(i_requests) {
-}
-
-ResourcePrefetchPredictor::Result::~Result() {
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // ResourcePrefetchPredictor.
 
 ResourcePrefetchPredictor::ResourcePrefetchPredictor(
     const ResourcePrefetchPredictorConfig& config,
     Profile* profile)
     : profile_(profile),
       config_(config),
       initialization_state_(NOT_INITIALIZED),
       tables_(PredictorDatabaseFactory::GetForProfile(profile)
@@ skipping 57 matching lines @@
       // corresponding to the navigation has not been created yet.
       if (!navigation_id.main_frame_url.is_empty())
         OnNavigationComplete(navigation_id);
       break;
     default:
       NOTREACHED() << "Unexpected initialization_state_: "
                    << initialization_state_;
   }
 }
 
-void ResourcePrefetchPredictor::FinishedPrefetchForNavigation(
-    const NavigationID& navigation_id,
-    PrefetchKeyType key_type,
-    ResourcePrefetcher::RequestVector* requests) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  std::unique_ptr<Result> result(new Result(key_type, requests));
-  // Add the results to the results map.
-  if (!results_map_.insert(std::make_pair(navigation_id, std::move(result)))
-           .second)
-    DLOG(FATAL) << "Returning results for existing navigation.";
-}
-
 void ResourcePrefetchPredictor::Shutdown() {
   if (prefetch_manager_.get()) {
     prefetch_manager_->ShutdownOnUIThread();
     prefetch_manager_ = NULL;
   }
   history_service_observer_.RemoveAll();
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
@@ skipping 83 matching lines @@
   history_service->ScheduleDBTask(
       std::unique_ptr<history::HistoryDBTask>(new GetUrlVisitCountTask(
           navigation_id, requests,
           base::Bind(&ResourcePrefetchPredictor::OnVisitCountLookup,
                      AsWeakPtr()))),
       &history_lookup_consumer_);
 }
 
 bool ResourcePrefetchPredictor::GetPrefetchData(
     const NavigationID& navigation_id,
-    ResourcePrefetcher::RequestVector* prefetch_requests,
+    std::vector<GURL>* urls,
     PrefetchKeyType* key_type) {
-  DCHECK(prefetch_requests);
+  DCHECK(urls);
   DCHECK(key_type);
 
   *key_type = PREFETCH_KEY_TYPE_URL;
   const GURL& main_frame_url = navigation_id.main_frame_url;
 
   bool use_url_data = config_.IsPrefetchingEnabled(profile_) ?
       config_.IsURLPrefetchingEnabled(profile_) :
       config_.IsURLLearningEnabled();
   if (use_url_data) {
     PrefetchDataMap::const_iterator iterator =
         url_table_cache_->find(main_frame_url.spec());
     if (iterator != url_table_cache_->end())
-      PopulatePrefetcherRequest(iterator->second, prefetch_requests);
+      PopulatePrefetcherRequest(iterator->second, urls);
   }
-  if (!prefetch_requests->empty())
-    return true;

[pasko, 2016/09/22 13:21:05]

why is this early return removed? guaranteed to be non-empty? DCHECK?

[Benoit L, 2016/09/22 14:42:49]

No, but the return re-arrangement is equivalent. Just less code.

 
   bool use_host_data = config_.IsPrefetchingEnabled(profile_) ?
       config_.IsHostPrefetchingEnabled(profile_) :
       config_.IsHostLearningEnabled();
-  if (use_host_data) {
+  if (urls->empty() && use_host_data) {
     PrefetchDataMap::const_iterator iterator =
         host_table_cache_->find(main_frame_url.host());
     if (iterator != host_table_cache_->end()) {
       *key_type = PREFETCH_KEY_TYPE_HOST;
-      PopulatePrefetcherRequest(iterator->second, prefetch_requests);
+      PopulatePrefetcherRequest(iterator->second, urls);
     }
   }
 
-  return !prefetch_requests->empty();
+  return !urls->empty();
 }
 
 void ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const PrefetchData& data,
-    ResourcePrefetcher::RequestVector* requests) {
+    std::vector<GURL>* urls) {
   for (const ResourceRow& row : data.resources) {
     float confidence = static_cast<float>(row.number_of_hits) /
                        (row.number_of_hits + row.number_of_misses);
     if (confidence < config_.min_resource_confidence_to_trigger_prefetch ||
         row.number_of_hits < config_.min_resource_hits_to_trigger_prefetch) {
       continue;
     }
 
-    ResourcePrefetcher::Request* req =
-        new ResourcePrefetcher::Request(row.resource_url);
-    requests->push_back(req);
+    urls->push_back(row.resource_url);
   }
 }
 
 void ResourcePrefetchPredictor::StartPrefetching(
     const NavigationID& navigation_id) {
   if (!prefetch_manager_.get())  // Prefetching not enabled.
     return;
 
   // Prefer URL based data first.
-  std::unique_ptr<ResourcePrefetcher::RequestVector> requests(
-      new ResourcePrefetcher::RequestVector);
+  std::vector<GURL> urls;
   PrefetchKeyType key_type;
-  if (!GetPrefetchData(navigation_id, requests.get(), &key_type)) {
+  if (!GetPrefetchData(navigation_id, &urls, &key_type)) {
     // No prefetching data at host or URL level.
     return;
   }
 
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeAddPrefetch,
-                 prefetch_manager_,
-                 navigation_id,
-                 key_type,
-                 base::Passed(&requests)));
+                 prefetch_manager_, navigation_id, key_type, urls));
 }
 
 void ResourcePrefetchPredictor::StopPrefetching(
     const NavigationID& navigation_id) {
   if (!prefetch_manager_.get())  // Not enabled.
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeRemovePrefetch,
@@ skipping 62 matching lines @@
   base::TimeTicks time_now = base::TimeTicks::Now();
   for (NavigationMap::iterator it = inflight_navigations_.begin();
        it != inflight_navigations_.end();) {
     if (it->first.IsSameRenderer(navigation_id) ||
         (time_now - it->first.creation_time > max_navigation_age)) {
       inflight_navigations_.erase(it++);
     } else {
       ++it;
     }
   }
-  for (ResultsMap::const_iterator it = results_map_.begin();
-       it != results_map_.end();) {
-    if (it->first.IsSameRenderer(navigation_id) ||
-        (time_now - it->first.creation_time > max_navigation_age)) {
-      results_map_.erase(it++);
-    } else {
-      ++it;
-    }
-  }
 }
 
 void ResourcePrefetchPredictor::DeleteAllUrls() {
   inflight_navigations_.clear();
   url_table_cache_->clear();
   host_table_cache_->clear();
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::DeleteAllData, tables_));
 }
@@ skipping 73 matching lines @@
   }
 
   // Host level data - no cutoff, always learn the navigation if enabled.
   if (config_.IsHostLearningEnabled()) {
     LearnNavigation(navigation_id.main_frame_url.host(),
                     PREFETCH_KEY_TYPE_HOST,
                     requests,
                     config_.max_hosts_to_track,
                     host_table_cache_.get());
   }
-
-  // Remove the navigation from the results map.
-  results_map_.erase(navigation_id);
 }
 
 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);
 
@@ skipping 176 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