predictors: Make the resource_prefetch_predictor accessible from Java.

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 390 matching lines @@
     prefetch_manager_ = NULL;
   }
   history_service_observer_.RemoveAll();
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
-  StartPrefetching(request.navigation_id);
+  StartPrefetching(request.navigation_id.main_frame_url);
 
   // Cleanup older navigations.
   CleanupAbandonedNavigations(request.navigation_id);
 
   // New empty navigation entry.
   inflight_navigations_.insert(std::make_pair(
       request.navigation_id,
       make_linked_ptr(new std::vector<URLRequestSummary>())));
 }
 
 void ResourcePrefetchPredictor::OnMainFrameResponse(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
     return;
 
-  StopPrefetching(response.navigation_id);
+  StopPrefetching(response.navigation_id.main_frame_url);
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRedirect(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // TODO(shishir): There are significant gains to be had here if we can use the
   // start URL in a redirect chain as the key to start prefetching. We can save
   // of redirect times considerably assuming that the redirect chains do not
   // change.
 
   // Stop any inflight prefetching. Remove the older navigation.
-  StopPrefetching(response.navigation_id);
+  StopPrefetching(response.navigation_id.main_frame_url);
   inflight_navigations_.erase(response.navigation_id);
 
   // A redirect will not lead to another OnMainFrameRequest call, so record the
   // redirect url as a new navigation.
 
   // The redirect url may be empty if the URL was invalid.
   if (response.redirect_url.is_empty())
     return;
 
   NavigationID navigation_id(response.navigation_id);
@@ skipping 37 matching lines @@
                                            ServiceAccessType::EXPLICIT_ACCESS);
   DCHECK(history_service);
   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,
-    std::vector<GURL>* urls,
-    PrefetchKeyType* key_type) {
+bool ResourcePrefetchPredictor::GetPrefetchData(const GURL& url,

[gone, 2016/09/28 18:18:15]

Can you use something more descriptive than url here, given that there's another
variable called urls afterward?  Don't know what the difference is without
looking over to the previous version or the callers for context.

[Benoit L, 2016/10/03 09:42:05]

Done.

+                                                std::vector<GURL>* urls) {
   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());
+        url_table_cache_->find(url.spec());
     if (iterator != url_table_cache_->end())
       PopulatePrefetcherRequest(iterator->second, urls);
   }
+  if (!urls->empty())
+    return true;
 
   bool use_host_data = config_.IsPrefetchingEnabled(profile_) ?
       config_.IsHostPrefetchingEnabled(profile_) :
       config_.IsHostLearningEnabled();
-  if (urls->empty() && use_host_data) {
+  if (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;
+        host_table_cache_->find(url.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()));
   }
 }
 
-void ResourcePrefetchPredictor::StartPrefetching(
-    const NavigationID& navigation_id) {
+void ResourcePrefetchPredictor::StartPrefetching(const GURL& url) {
   if (!prefetch_manager_.get())  // Prefetching not enabled.
     return;
 
-  // Prefer URL based data first.
-  std::vector<GURL> urls;
-  PrefetchKeyType key_type;
-  if (!GetPrefetchData(navigation_id, &urls, &key_type)) {
+  std::vector<GURL> subresource_urls;
+  if (!GetPrefetchData(url, &subresource_urls)) {
     // No prefetching data at host or URL level.
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeAddPrefetch,
-                 prefetch_manager_, navigation_id, urls));
+                 prefetch_manager_, url, subresource_urls));
 }
 
-void ResourcePrefetchPredictor::StopPrefetching(
-    const NavigationID& navigation_id) {
+void ResourcePrefetchPredictor::StopPrefetching(const GURL& url) {
   if (!prefetch_manager_.get())  // Not enabled.
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeRemovePrefetch,
-                 prefetch_manager_,
-                 navigation_id));
+                 prefetch_manager_, url));
 }
 
 void ResourcePrefetchPredictor::StartInitialization() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK_EQ(NOT_INITIALIZED, initialization_state_);
   initialization_state_ = INITIALIZING;
 
   // Create local caches using the database as loaded.
   std::unique_ptr<PrefetchDataMap> url_data_map(new PrefetchDataMap());
@@ skipping 349 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