predictors: Add a origin for prefetch requests, remove the URL/host settings.

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 365 matching lines @@
       observer_(nullptr),
       config_(config),
       initialization_state_(NOT_INITIALIZED),
       tables_(PredictorDatabaseFactory::GetForProfile(profile)
                   ->resource_prefetch_tables()),
       history_service_observer_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Some form of learning has to be enabled.
   DCHECK(config_.IsLearningEnabled());
-  if (config_.IsURLPrefetchingEnabled(profile_))
-    DCHECK(config_.IsURLLearningEnabled());
-  if (config_.IsHostPrefetchingEnabled(profile_))
-    DCHECK(config_.IsHostLearningEnabled());
 }
 
 ResourcePrefetchPredictor::~ResourcePrefetchPredictor() {}
 
 void ResourcePrefetchPredictor::StartInitialization() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::StartInitialization");
 
   if (initialization_state_ != NOT_INITIALIZED)
     return;
@@ skipping 68 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::StartPrefetching(const GURL& url) {
+void ResourcePrefetchPredictor::StartPrefetching(const GURL& url,
+                                                 PrefetchOrigin origin) {
   TRACE_EVENT1("browser", "ResourcePrefetchPredictor::StartPrefetching", "url",
                url.spec());
   if (!prefetch_manager_.get())  // Prefetching not enabled.
     return;
+  if (!config_.IsPrefetchingEnabledForOrigin(profile_, origin))
+    return;
 
   std::vector<GURL> subresource_urls;
-  if (!GetPrefetchData(url, &subresource_urls)) {
-    // No prefetching data at host or URL level.
+  if (!GetPrefetchData(url, &subresource_urls))
     return;
-  }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeAddPrefetch,
                  prefetch_manager_, url, subresource_urls));
 }
 
 void ResourcePrefetchPredictor::StopPrefetching(const GURL& url) {
   TRACE_EVENT1("browser", "ResourcePrefetchPredictor::StopPrefetching", "url",
                url.spec());
@@ skipping 17 matching lines @@
   }
   history_service_observer_.RemoveAll();
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
   const GURL& main_frame_url = request.navigation_id.main_frame_url;
-  StartPrefetching(main_frame_url);
+  StartPrefetching(main_frame_url, PrefetchOrigin::NAVIGATION);
 
   // Cleanup older navigations.
   CleanupAbandonedNavigations(request.navigation_id);
 
   // New empty navigation entry.
   inflight_navigations_.insert(
       std::make_pair(request.navigation_id,
                      base::MakeUnique<PageRequestSummary>(main_frame_url)));
 }
 
@@ skipping 73 matching lines @@
           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);
   DCHECK(urls->empty());
-  bool use_url_data = config_.IsPrefetchingEnabled(profile_) ?
-      config_.IsURLPrefetchingEnabled(profile_) :
-      config_.IsURLLearningEnabled();
-  bool use_host_data = config_.IsPrefetchingEnabled(profile_) ?
-      config_.IsHostPrefetchingEnabled(profile_) :
-      config_.IsHostLearningEnabled();
 
   // Fetch URLs based on a redirect endpoint for URL/host first.
   std::string redirect_endpoint;
-  if (use_url_data &&
-      GetRedirectEndpoint(main_frame_url.spec(), *url_redirect_table_cache_,
+  if (GetRedirectEndpoint(main_frame_url.spec(), *url_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *url_table_cache_, urls)) {
     return true;
   }
 
-  if (use_host_data &&
-      GetRedirectEndpoint(main_frame_url.host(), *host_redirect_table_cache_,
+  if (GetRedirectEndpoint(main_frame_url.host(), *host_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *host_table_cache_, urls)) {
     return true;
   }
 
   // Fallback to fetching URLs based on the incoming URL/host.
-  if (use_url_data && PopulatePrefetcherRequest(main_frame_url.spec(),
-                                                *url_table_cache_, urls)) {
+  if (PopulatePrefetcherRequest(main_frame_url.spec(), *url_table_cache_,
+                                urls)) {
     return true;
   }
 
-  return use_host_data && PopulatePrefetcherRequest(main_frame_url.host(),
-                                                    *host_table_cache_, urls);
+  return PopulatePrefetcherRequest(main_frame_url.host(), *host_table_cache_,
+                                   urls);
 }
 
 bool ResourcePrefetchPredictor::PopulatePrefetcherRequest(
     const std::string& main_frame_key,
     const PrefetchDataMap& data_map,
     std::vector<GURL>* urls) {
   DCHECK(urls);
   PrefetchDataMap::const_iterator it = data_map.find(main_frame_key);
   if (it == data_map.end())
     return false;
@@ skipping 39 matching lines @@
                        host_table_cache_->size());
 
   ConnectToHistoryService();
 }
 
 void ResourcePrefetchPredictor::OnHistoryAndCacheLoaded() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZING, initialization_state_);
 
   // Initialize the prefetch manager only if prefetching is enabled.
-  if (config_.IsPrefetchingEnabled(profile_)) {
+  if (config_.IsPrefetchingEnabledForSomeOrigin(profile_)) {
     prefetch_manager_ = new ResourcePrefetcherManager(
         this, config_, profile_->GetRequestContext());
   }
   initialization_state_ = INITIALIZED;
 
   if (observer_)
     observer_->OnPredictorInitialized();
 }
 
 void ResourcePrefetchPredictor::CleanupAbandonedNavigations(
@@ skipping 130 matching lines @@
   // TODO(alexilin): make only one request to DB thread.
 
   // URL level data - merge only if we already saved the data, or it
   // meets the cutoff requirement.
   const std::string url_spec = summary.main_frame_url.spec();
   bool already_tracking = url_table_cache_->find(url_spec) !=
       url_table_cache_->end();
   bool should_track_url =
       already_tracking || (url_visit_count >= config_.min_url_visit_count);
 
-  if (should_track_url && config_.IsURLLearningEnabled()) {
+  if (should_track_url) {
     LearnNavigation(url_spec, PREFETCH_KEY_TYPE_URL,
                     summary.subresource_requests, config_.max_urls_to_track,
                     url_table_cache_.get(), summary.initial_url.spec(),
                     url_redirect_table_cache_.get());
   }
 
   // Host level data - no cutoff, always learn the navigation if enabled.
-  if (config_.IsHostLearningEnabled()) {
-    const std::string host = summary.main_frame_url.host();
-    LearnNavigation(host, PREFETCH_KEY_TYPE_HOST, summary.subresource_requests,
-                    config_.max_hosts_to_track, host_table_cache_.get(),
-                    summary.initial_url.host(),
-                    host_redirect_table_cache_.get());
-  }
+  const std::string host = summary.main_frame_url.host();
+  LearnNavigation(host, PREFETCH_KEY_TYPE_HOST, summary.subresource_requests,
+                  config_.max_hosts_to_track, host_table_cache_.get(),
+                  summary.initial_url.host(), host_redirect_table_cache_.get());
 
   if (observer_)
     observer_->OnNavigationLearned(url_visit_count, summary);
 }
 
 void ResourcePrefetchPredictor::LearnNavigation(
     const std::string& key,
     PrefetchKeyType key_type,
     const std::vector<URLRequestSummary>& new_resources,
     size_t max_data_map_size,
@@ skipping 284 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors