Feature to disable field trials in old versions of Chromium. Field trials...

chrome/browser/net/predictor_api.cc

 // Copyright (c) 2010 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/net/predictor_api.h"
 
 #include <map>
 #include <string>
 
 #include "base/metrics/field_trial.h"
@@ skipping 533 matching lines @@
 PredictorInit::PredictorInit(PrefService* user_prefs,
                              PrefService* local_state,
                              bool preconnect_enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Set up a field trial to see what disabling DNS pre-resolution does to
   // latency of page loads.
   base::FieldTrial::Probability kDivisor = 1000;
   // For each option (i.e., non-default), we have a fixed probability.
   base::FieldTrial::Probability kProbabilityPerGroup = 100;  // 10% probability.
 
-  trial_ = new base::FieldTrial("DnsImpact", kDivisor);
+  // After June 30, 2011 builds, it will always be in default group
+  // (default_enabled_prefetch).
+  trial_ = new base::FieldTrial("DnsImpact", kDivisor,
+                                "default_enabled_prefetch", 2011, 6, 30);
 
   // First option is to disable prefetching completely.
   int disabled_prefetch = trial_->AppendGroup("disabled_prefetch",
                                               kProbabilityPerGroup);
 
-
   // We're running two experiments at the same time.  The first set of trials
   // modulates the delay-time until we declare a congestion event (and purge
   // our queue).  The second modulates the number of concurrent resolutions
   // we do at any time.  Users are in exactly one trial (or the default) during
   // any one run, and hence only one experiment at a time.
   // Experiment 1:
   // Set congestion detection at 250, 500, or 750ms, rather than the 1 second
   // default.
   int max_250ms_prefetch = trial_->AppendGroup("max_250ms_queue_prefetch",
                                                kProbabilityPerGroup);
   int max_500ms_prefetch = trial_->AppendGroup("max_500ms_queue_prefetch",
                                                kProbabilityPerGroup);
   int max_750ms_prefetch = trial_->AppendGroup("max_750ms_queue_prefetch",
                                                kProbabilityPerGroup);
   // Set congestion detection at 2 seconds instead of the 1 second default.
   int max_2s_prefetch = trial_->AppendGroup("max_2s_queue_prefetch",
                                             kProbabilityPerGroup);
   // Experiment 2:
   // Set max simultaneous resoultions to 2, 4, or 6, and scale the congestion
   // limit proportionally (so we don't impact average probability of asserting
   // congesion very much).
   int max_2_concurrent_prefetch = trial_->AppendGroup(
       "max_2 concurrent_prefetch", kProbabilityPerGroup);
   int max_4_concurrent_prefetch = trial_->AppendGroup(
       "max_4 concurrent_prefetch", kProbabilityPerGroup);
   int max_6_concurrent_prefetch = trial_->AppendGroup(
       "max_6 concurrent_prefetch", kProbabilityPerGroup);
 
-  trial_->AppendGroup("default_enabled_prefetch",
-      base::FieldTrial::kAllRemainingProbability);
-
   // We will register the incognito observer regardless of whether prefetching
   // is enabled, as it is also used to clear the host cache.
   g_off_the_record_observer.Get().Register();
 
   if (trial_->group() != disabled_prefetch) {
     // Initialize the DNS prefetch system.
     size_t max_parallel_resolves = kMaxSpeculativeParallelResolves;
     int max_queueing_delay_ms = kMaxSpeculativeResolveQueueDelayMs;
 
     if (trial_->group() == max_2_concurrent_prefetch)
@@ skipping 23 matching lines @@
     DCHECK(!g_predictor);
     InitNetworkPredictor(max_queueing_delay, max_parallel_resolves, user_prefs,
                          local_state, preconnect_enabled);
   }
 }
 
 PredictorInit::~PredictorInit() {
 }
 
 }  // namespace chrome_browser_net