predictors: Use redirect data in prefetch.

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 401 matching lines @@
   if (initialization_state_ != INITIALIZED)
     return;
 
   StopPrefetching(response.navigation_id.main_frame_url);
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRedirect(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  // Stop any inflight prefetching. Remove the older navigation.
-  StopPrefetching(response.navigation_id.main_frame_url);
-
   std::unique_ptr<PageRequestSummary> summary;
   NavigationMap::iterator nav_it =
       inflight_navigations_.find(response.navigation_id);
   if (nav_it != inflight_navigations_.end()) {
     summary.reset(nav_it->second.release());
     inflight_navigations_.erase(nav_it);
   }
 
   // The redirect url may be empty if the URL was invalid.
   if (response.redirect_url.is_empty())
@@ skipping 51 matching lines @@
           navigation_id, std::move(summary),
           base::Bind(&ResourcePrefetchPredictor::OnVisitCountLookup,
                      AsWeakPtr()))),
       &history_lookup_consumer_);
 }
 
 bool ResourcePrefetchPredictor::GetPrefetchData(const GURL& main_frame_url,
                                                 std::vector<GURL>* urls) {
   DCHECK(urls);
 
+  if (GetURLPrefetchData(main_frame_url.spec(), urls))
+    return true;
+
+  if (GetHostPrefetchData(main_frame_url.host(), urls))
+    return true;
+
+  std::string final_redirect;
+  if (GetFinalRedirect(main_frame_url.spec(), url_redirect_table_cache_.get(),
+                       &final_redirect)) {
+    GURL redirect_url(final_redirect);
+
+    if (GetURLPrefetchData(redirect_url.spec(), urls))
+      return true;
+
+    if (GetHostPrefetchData(redirect_url.host(), urls))
+      return true;
+  }
+
+  return GetFinalRedirect(main_frame_url.host(),
+                          host_redirect_table_cache_.get(), &final_redirect) &&
+         GetHostPrefetchData(final_redirect, urls);
+}
+
+bool ResourcePrefetchPredictor::GetURLPrefetchData(
+    const std::string& main_frame_url,
+    std::vector<GURL>* urls) {
   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());
+        url_table_cache_->find(main_frame_url);
     if (iterator != url_table_cache_->end())
       PopulatePrefetcherRequest(iterator->second, urls);
   }
-  if (!urls->empty())
-    return true;
+  return !urls->empty();
+}
 
+bool ResourcePrefetchPredictor::GetHostPrefetchData(
+    const std::string& main_frame_host,
+    std::vector<GURL>* urls) {
   bool use_host_data = config_.IsPrefetchingEnabled(profile_) ?
       config_.IsHostPrefetchingEnabled(profile_) :
       config_.IsHostLearningEnabled();
   if (use_host_data) {
     PrefetchDataMap::const_iterator iterator =
-        host_table_cache_->find(main_frame_url.host());
+        host_table_cache_->find(main_frame_host);
     if (iterator != host_table_cache_->end())
       PopulatePrefetcherRequest(iterator->second, urls);
   }
-
   return !urls->empty();
 }
 
 void ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const PrefetchData& data,
     std::vector<GURL>* urls) {
   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 ||
         resource.number_of_hits() <
             config_.min_resource_hits_to_trigger_prefetch) {
       continue;
     }
 
     urls->push_back(GURL(resource.resource_url()));
   }
 }
 
+bool ResourcePrefetchPredictor::GetFinalRedirect(

[Benoit L, 2016/10/07 09:52:18]

The scoring code is duplicated, and it even seems that you don't really need the
scoring, since you're walking all the redirects here anyway.

If so, can you simplify the code?

[alexilin, 2016/10/07 10:49:07]

No, I'm not walking all the redirects here, where did you find it?
I pick first redirect from the list, with highest score.
But you are right about code duplication.
We have different notions of score and confidence in case of resources but they
are the same in this case. 

Probably it will be even better to don't sort redirects and just iterate over
all collection here each time.

WDYT?

[alexilin, 2016/10/07 13:09:29]

Scan all the redirects here instead of sort while recording. Thanks for the tip.

[Benoit L, 2016/10/07 13:55:15]

Sorry, wasn't clear enough. Thanks for reading between the lines, and
implementing it anyway.

+    const std::string& first_redirect,
+    RedirectDataMap* redirect_data_map,
+    std::string* final_redirect) {
+  DCHECK(final_redirect);
+
+  RedirectDataMap::const_iterator iterator =
+      redirect_data_map->find(first_redirect);
+  if (iterator == redirect_data_map->end())
+    return false;
+
+  DCHECK(iterator->second.redirect_endpoints_size() > 0);
+  const RedirectStat& best_redirect = iterator->second.redirect_endpoints(0);
+  float confidence =
+      (best_redirect.number_of_hits() + 0.0) /
+      (best_redirect.number_of_hits() + best_redirect.number_of_misses());
+
+  const float kMinRedirectConfidenceToTriggerPrefetch = 0.7f;
+  const int kMinRedirectHitsToTriggerPrefetch = 2;
+
+  if (confidence < kMinRedirectConfidenceToTriggerPrefetch ||
+      best_redirect.number_of_hits() < kMinRedirectHitsToTriggerPrefetch)
+    return false;
+
+  *final_redirect = best_redirect.url();
+  return true;
+}
+
 void ResourcePrefetchPredictor::StartPrefetching(const GURL& url) {
   if (!prefetch_manager_.get())  // Prefetching not enabled.
     return;
 
   std::vector<GURL> subresource_urls;
   if (!GetPrefetchData(url, &subresource_urls)) {
     // No prefetching data at host or URL level.
     return;
   }
 
@@ skipping 520 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