Introduce a field trial for Instant.

chrome/browser/instant/instant_controller.cc

 // Copyright (c) 2011 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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/rand_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/instant/instant_delegate.h"
+#include "chrome/browser/instant/instant_field_trial.h"
 #include "chrome/browser/instant/instant_loader.h"
 #include "chrome/browser/instant/instant_loader_manager.h"
 #include "chrome/browser/instant/promo_counter.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
@@ skipping 19 matching lines @@
 InstantController::InstantController(Profile* profile,
                                      InstantDelegate* delegate)
     : delegate_(delegate),
       tab_contents_(NULL),
       is_active_(false),
       displayable_loader_(NULL),
       commit_on_mouse_up_(false),
       last_transition_type_(PageTransition::LINK),
       ALLOW_THIS_IN_INITIALIZER_LIST(destroy_factory_(this)) {
   PrefService* service = profile->GetPrefs();
-  if (service) {
-    // kInstantWasEnabledOnce was added after instant, set it now to make sure
-    // it is correctly set.
+  if (service &&
+      InstantFieldTrial::GetGroup(profile) == InstantFieldTrial::INACTIVE) {
+    // kInstantEnabledOnce was added after instant, set it now to make sure it
+    // is correctly set.
     service->SetBoolean(prefs::kInstantEnabledOnce, true);
   }
 }
 
 InstantController::~InstantController() {
 }
 
 // static
 void InstantController::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kInstantEnabled,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kInstantEnabledOnce,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kInstantEnabledTime,
                            false,
                            PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kInstantFieldTrialRandomDraw,
+                             base::RandInt(0, 9999),
+                             PrefService::UNSYNCABLE_PREF);
   PromoCounter::RegisterUserPrefs(prefs, prefs::kInstantPromo);
 }
 
 // static
 void InstantController::RecordMetrics(Profile* profile) {
   if (!IsEnabled(profile))
     return;
 
   PrefService* service = profile->GetPrefs();
   if (service) {
     int64 enable_time = service->GetInt64(prefs::kInstantEnabledTime);
     if (!enable_time) {
       service->SetInt64(prefs::kInstantEnabledTime,
                         base::Time::Now().ToInternalValue());
     } else {
       base::TimeDelta delta =
           base::Time::Now() - base::Time::FromInternalValue(enable_time);
       // Histogram from 1 hour to 30 days.
       UMA_HISTOGRAM_CUSTOM_COUNTS("Instant.EnabledTime.Predictive",
                                   delta.InHours(), 1, 30 * 24, 50);
     }
   }
 }
 
 // static
 bool InstantController::IsEnabled(Profile* profile) {
   PrefService* prefs = profile->GetPrefs();
-  return prefs->GetBoolean(prefs::kInstantEnabled);
+  return prefs->GetBoolean(prefs::kInstantEnabled) ||
+         InstantFieldTrial::IsExperimentGroup(profile);
 }
 
 // static
 void InstantController::Enable(Profile* profile) {
   PromoCounter* promo_counter = profile->GetInstantPromoCounter();
   if (promo_counter)
     promo_counter->Hide();
 
   PrefService* service = profile->GetPrefs();
   if (!service)
     return;
 
+  service->SetBoolean(prefs::kInstantEnabledOnce, true);
   service->SetBoolean(prefs::kInstantEnabled, true);
   service->SetBoolean(prefs::kInstantConfirmDialogShown, true);
   service->SetInt64(prefs::kInstantEnabledTime,
                     base::Time::Now().ToInternalValue());
-  service->SetBoolean(prefs::kInstantEnabledOnce, true);
 }
 
 // static
 void InstantController::Disable(Profile* profile) {
   PrefService* service = profile->GetPrefs();
   if (!service || !IsEnabled(profile))
     return;
 
   int64 enable_time = service->GetInt64(prefs::kInstantEnabledTime);
   if (enable_time) {
     base::TimeDelta delta =
         base::Time::Now() - base::Time::FromInternalValue(enable_time);
     // Histogram from 1 minute to 10 days.
     UMA_HISTOGRAM_CUSTOM_COUNTS("Instant.TimeToDisable.Predictive",
                                 delta.InMinutes(), 1, 60 * 24 * 10, 50);
   }
 
+  if (InstantFieldTrial::IsExperimentGroup(profile)) {
+    UMA_HISTOGRAM_COUNTS(
+        "Instant.FieldTrialOptOut." + InstantFieldTrial::GetGroupName(profile),
+        1);
+  }
+
   service->SetBoolean(prefs::kInstantEnabledOnce, true);
   service->SetBoolean(prefs::kInstantEnabled, false);
 }
 
 // static
 bool InstantController::CommitIfCurrent(InstantController* controller) {
   if (controller && controller->IsCurrent()) {
     controller->CommitCurrentPreview(INSTANT_COMMIT_PRESSED_ENTER);
     return true;
   }
@@ skipping 222 matching lines @@
     return;
   }
 
   DestroyPreviewContents();
 }
 #endif
 
 void InstantController::OnAutocompleteGotFocus(
     TabContentsWrapper* tab_contents) {
   CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (!cl->HasSwitch(switches::kPreloadInstantSearch))
+  if (!cl->HasSwitch(switches::kPreloadInstantSearch) &&
+      !InstantFieldTrial::IsExperimentGroup(tab_contents->profile())) {
     return;
+  }
 
   if (is_active_)
     return;
 
   TemplateURLService* model = TemplateURLServiceFactory::GetForProfile(
       tab_contents->profile());
   if (!model)
     return;
 
   const TemplateURL* template_url = model->GetDefaultSearchProvider();
@@ skipping 306 matching lines @@
 
   // Extension keywords don't have a real destination URL.
   if (match.template_url && match.template_url->IsExtensionKeyword())
     return PREVIEW_CONDITION_EXTENSION_KEYWORD;
 
   // Was the host blacklisted?
   if (host_blacklist_ && host_blacklist_->count(match.destination_url.host()))
     return PREVIEW_CONDITION_BLACKLISTED;
 
   const CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (cl->HasSwitch(switches::kRestrictInstantToSearch) &&
+  if ((cl->HasSwitch(switches::kRestrictInstantToSearch) ||
+       InstantFieldTrial::IsExperimentGroup(tab_contents_->profile())) &&
       match.type != AutocompleteMatch::SEARCH_WHAT_YOU_TYPED &&
       match.type != AutocompleteMatch::SEARCH_HISTORY &&
       match.type != AutocompleteMatch::SEARCH_SUGGEST &&
       match.type != AutocompleteMatch::SEARCH_OTHER_ENGINE) {
     return PREVIEW_CONDITION_INSTANT_SEARCH_ONLY;
   }
 
   return PREVIEW_CONDITION_SUCCESS;
 }
 
@@ skipping 14 matching lines @@
   if (destroy_factory_.empty()) {
     MessageLoop::current()->PostTask(
         FROM_HERE, destroy_factory_.NewRunnableMethod(
             &InstantController::DestroyLoaders));
   }
 }
 
 void InstantController::DestroyLoaders() {
   loaders_to_destroy_.reset();
 }