predictors: Put manifests for ResourcePrefetchPredictor behind a flag.

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/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 "components/prefs/pref_service.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 kEnableUrlLearningParamName[] = "enable-url-learning";
+const char kEnableManifestsParamName[] = "enable-manifests";
 
 const base::Feature kSpeculativeResourcePrefetchingFeature =
     base::Feature(kSpeculativeResourcePrefetchingFeatureName,
                   base::FEATURE_DISABLED_BY_DEFAULT);
 
 namespace {
 
 bool IsPrefetchingEnabledInternal(Profile* profile, int mode, int mask) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if ((mode & mask) == 0)
@@ skipping 18 matching lines @@
   // 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 enable_url_learning_value =
       base::GetFieldTrialParamValueByFeature(
           kSpeculativeResourcePrefetchingFeature, kEnableUrlLearningParamName);
-  if (enable_url_learning_value == "true") {
+  if (enable_url_learning_value == "true")
     config->is_url_learning_enabled = true;
-  }
+
+  std::string enable_manifests_value = base::GetFieldTrialParamValueByFeature(
+      kSpeculativeResourcePrefetchingFeature, kEnableManifestsParamName);
+  if (enable_manifests_value == "true")
+    config->is_manifests_enabled = true;
 
   // Ensure that a resource that was only seen once is never prefetched. This
   // prevents the easy mistake of trying to prefetch an ephemeral url.
   DCHECK_GT(config->min_resource_hits_to_trigger_prefetch, 1U);
   if (config->min_resource_hits_to_trigger_prefetch < 2)
     config->min_resource_hits_to_trigger_prefetch = 2;
 
   std::string mode_value = base::GetFieldTrialParamValueByFeature(
       kSpeculativeResourcePrefetchingFeature, kModeParamName);
   if (mode_value == kLearningMode) {
@@ skipping 52 matching lines @@
       max_navigation_lifetime_seconds(60),
       max_urls_to_track(500),
       max_hosts_to_track(200),
       min_url_visit_count(2),
       max_resources_per_entry(50),
       max_consecutive_misses(3),
       min_resource_confidence_to_trigger_prefetch(0.7f),
       min_resource_hits_to_trigger_prefetch(2),
       max_prefetches_inflight_per_navigation(5),
       max_prefetches_inflight_per_host_per_navigation(3),
-      is_url_learning_enabled(false) {
-}
+      is_url_learning_enabled(false),
+      is_manifests_enabled(false) {}
 
 ResourcePrefetchPredictorConfig::ResourcePrefetchPredictorConfig(
     const ResourcePrefetchPredictorConfig& other) = default;
 
 ResourcePrefetchPredictorConfig::~ResourcePrefetchPredictorConfig() {
 }
 
 bool ResourcePrefetchPredictorConfig::IsLearningEnabled() const {
   return (mode & LEARNING) > 0;
 }
@@ skipping 33 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