predictors: Disable URL-based learning by default.

chrome/browser/predictors/resource_prefetch_common.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_common.h"
 
 #include <string>
 #include <tuple>
 
-#include "base/command_line.h"
-#include "base/metrics/field_trial.h"
+#include "base/feature_list.h"
+#include "base/metrics/field_trial_params.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
-#include "chrome/common/chrome_switches.h"
 #include "components/prefs/pref_service.h"
-#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 
 namespace predictors {
 
 const char kSpeculativeResourcePrefetchingFeatureName[] =
     "SpeculativeResourcePrefetching";
 const char kModeParamName[] = "mode";
 const char kLearningMode[] = "learning";
 const char kExternalPrefetchingMode[] = "external-prefetching";
 const char kPrefetchingMode[] = "prefetching";
+const char kKeyTypeParamName[] = "key-type";
+const char kUrlKeyType[] = "url";
+const char kHostKeyType[] = "host";
+const char kBothKeyType[] = "both";
 
 namespace {
 
 const base::Feature kSpeculativeResourcePrefetchingFeature{
     kSpeculativeResourcePrefetchingFeatureName,
     base::FEATURE_DISABLED_BY_DEFAULT};
 
 bool IsPrefetchingEnabledInternal(Profile* profile, int mode, int mask) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if ((mode & mask) == 0)
@@ skipping 15 matching lines @@
     ResourcePrefetchPredictorConfig* config) {
   DCHECK(config);
 
   // Disabled for of-the-record. Policy choice, not a technical limitation.
   if (!profile || profile->IsOffTheRecord())
     return false;
 
   if (!base::FeatureList::IsEnabled(kSpeculativeResourcePrefetchingFeature))
     return false;
 
-  std::string mode_value = variations::GetVariationParamValueByFeature(
+  std::string key_type_value = base::GetFieldTrialParamValueByFeature(

[Benoit L, 2017/03/01 16:04:41]

Do we really want URL-only?

If not, can we simplify the code (and the settings). We then just need something
to force host and url, since the default is host only.

[alexilin, 2017/03/01 16:55:56]

Done.

+      kSpeculativeResourcePrefetchingFeature, kKeyTypeParamName);
+  if (key_type_value == kUrlKeyType) {
+    config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
+  } else if (key_type_value == kHostKeyType) {
+    config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
+  } else if (key_type_value == kBothKeyType) {
+    config->mode |= ResourcePrefetchPredictorConfig::URL_LEARNING |
+                    ResourcePrefetchPredictorConfig::HOST_LEARNING;
+  } else {
+    // Only host learning by default.
+    config->mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
+  }
+
+  std::string mode_value = base::GetFieldTrialParamValueByFeature(
       kSpeculativeResourcePrefetchingFeature, kModeParamName);
   if (mode_value == kLearningMode) {
-    config->mode |= ResourcePrefetchPredictorConfig::LEARNING;
     return true;
   } else if (mode_value == kExternalPrefetchingMode) {
-    config->mode |= ResourcePrefetchPredictorConfig::LEARNING |
-                    ResourcePrefetchPredictorConfig::PREFETCHING_FOR_EXTERNAL;
+    config->mode |= ResourcePrefetchPredictorConfig::PREFETCHING_FOR_EXTERNAL;
     return true;
   } else if (mode_value == kPrefetchingMode) {
-    config->mode |= ResourcePrefetchPredictorConfig::LEARNING |
-                    ResourcePrefetchPredictorConfig::PREFETCHING_FOR_EXTERNAL |
+    config->mode |= ResourcePrefetchPredictorConfig::PREFETCHING_FOR_EXTERNAL |
                     ResourcePrefetchPredictorConfig::PREFETCHING_FOR_NAVIGATION;
     return true;
   }
 
   return false;
 }
 
 NavigationID::NavigationID() : tab_id(-1) {}
 
 NavigationID::NavigationID(const NavigationID& other)
@@ skipping 42 matching lines @@
       max_prefetches_inflight_per_host_per_navigation(3) {
 }
 
 ResourcePrefetchPredictorConfig::ResourcePrefetchPredictorConfig(
     const ResourcePrefetchPredictorConfig& other) = default;
 
 ResourcePrefetchPredictorConfig::~ResourcePrefetchPredictorConfig() {
 }
 
 bool ResourcePrefetchPredictorConfig::IsLearningEnabled() const {
-  return (mode & LEARNING) > 0;
+  return IsURLLearningEnabled() || IsHostLearningEnabled();
+}
+
+bool ResourcePrefetchPredictorConfig::IsURLLearningEnabled() const {
+  return (mode & URL_LEARNING) > 0;
+}
+
+bool ResourcePrefetchPredictorConfig::IsHostLearningEnabled() const {
+  return (mode & HOST_LEARNING) > 0;
 }
 
 bool ResourcePrefetchPredictorConfig::IsPrefetchingEnabledForSomeOrigin(
     Profile* profile) const {
   int mask = PREFETCHING_FOR_NAVIGATION | PREFETCHING_FOR_EXTERNAL;
   return IsPrefetchingEnabledInternal(profile, mode, mask);
 }
 
 bool ResourcePrefetchPredictorConfig::IsPrefetchingEnabledForOrigin(
     Profile* profile,
@@ skipping 24 matching lines @@
 
 bool ResourcePrefetchPredictorConfig::IsMoreResourcesEnabledForTest() const {
   return max_resources_per_entry == 100;
 }
 
 bool ResourcePrefetchPredictorConfig::IsSmallDBEnabledForTest() const {
   return max_urls_to_track == 200 && max_hosts_to_track == 100;
 }
 
 }  // namespace predictors