predictors: Disable URL-based learning by default.

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>
 
-#include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/url_constants.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/mime_util/mime_util.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
-#include "net/base/mime_util.h"
-#include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
-#include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace predictors {
 
 namespace {
 
 // Sorted by decreasing likelihood according to HTTP archive.
 const char* kFontMimeTypes[] = {"font/woff2",
                                 "application/x-font-woff",
@@ skipping 726 matching lines @@
 
 bool ResourcePrefetchPredictor::GetPrefetchData(
     const GURL& main_frame_url,
     ResourcePrefetchPredictor::Prediction* prediction) const {
   std::vector<GURL>* urls =
       prediction ? &prediction->subresource_urls : nullptr;
   DCHECK(!urls || urls->empty());
 
   // Fetch URLs based on a redirect endpoint for URL/host first.
   std::string redirect_endpoint;
-  if (GetRedirectEndpoint(main_frame_url.spec(), *url_redirect_table_cache_,
+  if (config_.is_url_learning_enabled &&
+      GetRedirectEndpoint(main_frame_url.spec(), *url_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *url_table_cache_, urls)) {
     if (prediction) {
       prediction->is_host = false;
       prediction->is_redirected = true;
       prediction->main_frame_key = redirect_endpoint;
     }
     return true;
   }
 
   if (GetRedirectEndpoint(main_frame_url.host(), *host_redirect_table_cache_,
                           &redirect_endpoint) &&
       PopulatePrefetcherRequest(redirect_endpoint, *host_table_cache_, urls)) {
     if (prediction) {
       prediction->is_host = true;
       prediction->is_redirected = true;
       prediction->main_frame_key = redirect_endpoint;
     }
     return true;
   }
 
   // Fallback to fetching URLs based on the incoming URL/host.
-  if (PopulatePrefetcherRequest(main_frame_url.spec(), *url_table_cache_,
+  if (config_.is_url_learning_enabled &&
+      PopulatePrefetcherRequest(main_frame_url.spec(), *url_table_cache_,
                                 urls)) {
     if (prediction) {
       prediction->is_host = false;
       prediction->is_redirected = false;
       prediction->main_frame_key = main_frame_url.spec();
     }
     return true;
   }
 
   if (PopulatePrefetcherRequest(main_frame_url.host(), *host_table_cache_,
@@ skipping 213 matching lines @@
 void ResourcePrefetchPredictor::OnVisitCountLookup(
     size_t url_visit_count,
     const PageRequestSummary& summary) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HistoryVisitCountForUrl",
                        url_visit_count);
 
   // 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 (config_.is_url_learning_enabled) {
+    // 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) {
-    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());
+    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.
   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);
@@ skipping 328 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors