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 376 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.
   const GURL& initial_url = request.navigation_id.main_frame_url;
   inflight_navigations_.insert(
       std::make_pair(request.navigation_id,
                      base::MakeUnique<PageRequestSummary>(initial_url)));
 }
 
 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);
 
   // Stop any inflight prefetching. Remove the older navigation.
-  StopPrefetching(response.navigation_id);
+  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.
@@ skipping 48 matching lines @@
                                            ServiceAccessType::EXPLICIT_ACCESS);
   DCHECK(history_service);
   history_service->ScheduleDBTask(
       std::unique_ptr<history::HistoryDBTask>(new GetUrlVisitCountTask(
           navigation_id, std::move(summary),
           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& main_frame_url,
+                                                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());
     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;
+    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.
   auto url_data_map = base::MakeUnique<PrefetchDataMap>();
@@ skipping 503 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