Unlaunch the HIDDEN mode.

chrome/browser/instant/instant_controller.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 28 matching lines @@
                                      InstantDelegate* delegate)
     : delegate_(delegate),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
       tab_contents_(NULL),
       is_displayable_(false),
       is_out_of_date_(true),
       commit_on_mouse_up_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(template_url_service_);
-  PrefService* service = profile->GetPrefs();
-  if (service && !InstantFieldTrial::IsInstantExperiment(profile)) {
-    // kInstantEnabledOnce was added after instant, set it now to make sure it
+  PrefService* prefs = profile->GetPrefs();
+  if (prefs && prefs->GetBoolean(prefs::kInstantEnabled)) {
+    // kInstantEnabledOnce was added after Instant, set it now to make sure it
     // is correctly set.
-    service->SetBoolean(prefs::kInstantEnabledOnce, true);
+    prefs->SetBoolean(prefs::kInstantEnabledOnce, true);
   }
 }
 
 InstantController::~InstantController() {
 }
 
 // static
 void InstantController::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kInstantConfirmDialogShown,
                              false,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kInstantEnabled,
                              false,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kInstantEnabledOnce,
                              false,
                              PrefService::SYNCABLE_PREF);
 }
 
 // static
 void InstantController::RecordMetrics(Profile* profile) {
   UMA_HISTOGRAM_ENUMERATION("Instant.Status", IsEnabled(profile), 2);
 }
 
 // static
 bool InstantController::IsEnabled(Profile* profile) {
-  PrefService* prefs = profile->GetPrefs();
-  return prefs->GetBoolean(prefs::kInstantEnabled) ||
-         InstantFieldTrial::IsInstantExperiment(profile);
+  return InstantFieldTrial::GetMode(profile) != InstantFieldTrial::CONTROL;
 }
 
 // static
 void InstantController::Enable(Profile* profile) {
   PrefService* service = profile->GetPrefs();
   if (!service)
     return;
 
   base::Histogram* histogram = base::LinearHistogram::FactoryGet(
-      "Instant.Preference" + InstantFieldTrial::GetGroupName(profile), 1, 2, 3,
-      base::Histogram::kUmaTargetedHistogramFlag);
+      "Instant.Preference" + InstantFieldTrial::GetModeAsString(profile),
+      1, 2, 3, base::Histogram::kUmaTargetedHistogramFlag);
   histogram->Add(1);
 
   service->SetBoolean(prefs::kInstantEnabledOnce, true);
   service->SetBoolean(prefs::kInstantEnabled, true);
   service->SetBoolean(prefs::kInstantConfirmDialogShown, true);
 }
 
 // static
 void InstantController::Disable(Profile* profile) {
   PrefService* service = profile->GetPrefs();
   if (!service || !IsEnabled(profile))
     return;
 
   base::Histogram* histogram = base::LinearHistogram::FactoryGet(
-      "Instant.Preference" + InstantFieldTrial::GetGroupName(profile), 1, 2, 3,
-      base::Histogram::kUmaTargetedHistogramFlag);
+      "Instant.Preference" + InstantFieldTrial::GetModeAsString(profile),
+      1, 2, 3, base::Histogram::kUmaTargetedHistogramFlag);
   histogram->Add(0);
 
   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);
@@ skipping 19 matching lines @@
   const TemplateURL* default_t_url =
       template_url_service_->GetDefaultSearchProvider();
   if (!IsValidInstantTemplateURL(template_url) || !default_t_url ||
       (template_url->id() != default_t_url->id())) {
     Hide();
     return false;
   }
 
   if (!loader_.get()) {
     loader_.reset(new InstantLoader(this, template_url->id(),
-        InstantFieldTrial::GetGroupName(tab_contents->profile())));
+        InstantFieldTrial::GetModeAsString(tab_contents->profile())));
   }
 
   // In some rare cases (involving group policy), Instant can go from the field
   // trial to normal mode, with no intervening call to DestroyPreviewContents().
   // This would leave the loader in a weird state, which would manifest if the
   // user pressed <Enter> without calling Update(). TODO(sreeram): Handle it.
-  if (InstantFieldTrial::IsSilentExperiment(tab_contents->profile())) {
-    // For the SILENT field trial we process |user_text| at commit time, which
-    // means we're never really out of date.
+  if (InstantFieldTrial::GetMode(tab_contents->profile()) ==
+          InstantFieldTrial::SILENT) {
+    // For the SILENT mode, we process |user_text| at commit time, which means
+    // we're never really out of date.
     is_out_of_date_ = false;
     loader_->MaybeLoadInstantURL(tab_contents, template_url);
     return true;
   }
 
   UpdateLoader(template_url, match.destination_url, match.transition, user_text,
                verbatim, suggested_text);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
       content::Source<InstantController>(this),
       content::NotificationService::NoDetails());
   return true;
 }
 
 void InstantController::SetOmniboxBounds(const gfx::Rect& bounds) {
   if (omnibox_bounds_ == bounds)
     return;
 
   // Always track the omnibox bounds. That way if Update is later invoked the
   // bounds are in sync.
   omnibox_bounds_ = bounds;
 
   if (loader_.get() && !is_out_of_date_ &&
-      !InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile())) {
+      InstantFieldTrial::GetMode(tab_contents_->profile()) ==
+          InstantFieldTrial::INSTANT) {
     loader_->SetOmniboxBounds(bounds);
   }
 }
 
 void InstantController::DestroyPreviewContents() {
   if (!loader_.get()) {
     // We're not showing anything, nothing to do.
     return;
   }
 
@@ skipping 16 matching lines @@
   return is_displayable_ && !loader_->IsNavigationPending() &&
       !loader_->needs_reload();
 }
 
 bool InstantController::PrepareForCommit() {
   // Basic checks to prevent accessing a dangling |tab_contents_| pointer.
   // http://crbug.com/100521.
   if (is_out_of_date_ || !loader_.get())
     return false;
 
-  // If we are not in the HIDDEN or SILENT field trials, return the status of
-  // the preview.
-  if (!InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile()))
+  const InstantFieldTrial::Mode mode =
+      InstantFieldTrial::GetMode(tab_contents_->profile());
+
+  // If we are in the visible (INSTANT) mode, return the status of the preview.
+  if (mode == InstantFieldTrial::INSTANT)
     return IsCurrent();
 
   const TemplateURL* template_url =
       template_url_service_->GetDefaultSearchProvider();
   if (!IsValidInstantTemplateURL(template_url) ||
       loader_->template_url_id() != template_url->id() ||
       loader_->IsNavigationPending() ||
       loader_->is_determining_if_page_supports_instant()) {
     return false;
   }
 
-  // In the HIDDEN and SUGGEST experiments (but not SILENT), we must have sent
-  // an Update() by now, so check if the loader failed to process it.
-  if (!InstantFieldTrial::IsSilentExperiment(tab_contents_->profile()) &&
-      (!loader_->ready() || !loader_->http_status_ok())) {
+  // In the SUGGEST and HIDDEN modes, we must have sent an Update() by now, so
+  // check if the loader failed to process it.
+  if ((mode == InstantFieldTrial::SUGGEST || mode == InstantFieldTrial::HIDDEN)
+      && (!loader_->ready() || !loader_->http_status_ok())) {
     return false;
   }
 
   // Ignore the suggested text, as we are about to commit the verbatim query.
   string16 suggested_text;
   UpdateLoader(template_url, last_url_, last_transition_type_, last_user_text_,
                true, &suggested_text);
   return true;
 }
 
@@ skipping 94 matching lines @@
     CommitCurrentPreview(INSTANT_COMMIT_FOCUS_LOST);
     return;
   }
 
   DestroyPreviewContents();
 }
 #endif
 
 void InstantController::OnAutocompleteGotFocus(
     TabContentsWrapper* tab_contents) {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (!cl->HasSwitch(switches::kPreloadInstantSearch) &&
-      !InstantFieldTrial::IsInstantExperiment(tab_contents->profile())) {
-    return;
-  }
-
   const TemplateURL* template_url =
       template_url_service_->GetDefaultSearchProvider();
   if (!IsValidInstantTemplateURL(template_url))
     return;
 
   tab_contents_ = tab_contents;
 
   if (!loader_.get()) {
     loader_.reset(new InstantLoader(this, template_url->id(),
-        InstantFieldTrial::GetGroupName(tab_contents->profile())));
+        InstantFieldTrial::GetModeAsString(tab_contents->profile())));
   }
   loader_->MaybeLoadInstantURL(tab_contents, template_url);
 }
 
 TabContentsWrapper* InstantController::ReleasePreviewContents(
     InstantCommitType type,
     TabContentsWrapper* current_tab) {
   if (!loader_.get())
     return NULL;
 
@@ skipping 17 matching lines @@
 
 void InstantController::InstantStatusChanged(InstantLoader* loader) {
   DCHECK(loader_.get());
   UpdateIsDisplayable();
 }
 
 void InstantController::SetSuggestedTextFor(
     InstantLoader* loader,
     const string16& text,
     InstantCompleteBehavior behavior) {
-  if (!is_out_of_date_ &&
-      InstantFieldTrial::ShouldSetSuggestedText(tab_contents_->profile())) {
+  if (is_out_of_date_)
+    return;
+
+  const InstantFieldTrial::Mode mode =
+      InstantFieldTrial::GetMode(tab_contents_->profile());
+  if (mode == InstantFieldTrial::INSTANT || mode == InstantFieldTrial::SUGGEST)
     delegate_->SetSuggestedText(text, behavior);
-  }
 }
 
 gfx::Rect InstantController::GetInstantBounds() {
   return delegate_->GetInstantBounds();
 }
 
 bool InstantController::ShouldCommitInstantOnMouseUp() {
   return commit_on_mouse_up_;
 }
 
@@ skipping 23 matching lines @@
 
 void InstantController::SwappedTabContents(InstantLoader* loader) {
   if (is_displayable_)
     delegate_->ShowInstant(loader->preview_contents());
 }
 
 void InstantController::InstantLoaderContentsFocused() {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
-  if (!InstantFieldTrial::IsSilentExperiment(tab_contents_->profile()))
+  if (InstantFieldTrial::GetMode(tab_contents_->profile()) !=
+          InstantFieldTrial::SILENT) {

[sreeram, 2012/05/03 21:06:21]

@sky: Should this instead be:
if (InstantFieldTrial::GetMode(...) == InstantFieldTrial::INSTANT) {

I.e., send the focus for only the visible INSTANT mode, since neither HIDDEN nor
SUGGEST show a preview (just like SILENT). However, I'm not sure why this was
added, so please advise.

[sky, 2012/05/03 21:22:09]

Yes, this should only matter for visible INSTANT mode, so your suggestion seems
right. The instant tests running on chromeos exercise this code, so as long as
those tests still pass you're good.

     delegate_->InstantPreviewFocused();
+  }
 #endif
 }
 
 void InstantController::UpdateIsDisplayable() {
   if (!is_out_of_date_ &&
-      InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile())) {
+      InstantFieldTrial::GetMode(tab_contents_->profile()) !=
+          InstantFieldTrial::INSTANT) {
     return;
   }
 
   bool displayable =
       (!is_out_of_date_ && loader_.get() && loader_->ready() &&
        loader_->http_status_ok());
   if (displayable == is_displayable_)
     return;
 
   is_displayable_ = displayable;
   if (!is_displayable_) {
     delegate_->HideInstant();
   } else {
     delegate_->ShowInstant(loader_->preview_contents());
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_INSTANT_CONTROLLER_SHOWN,
         content::Source<InstantController>(this),
         content::NotificationService::NoDetails());
   }
 }
 
 void InstantController::UpdateLoader(const TemplateURL* template_url,
                                      const GURL& url,
                                      content::PageTransition transition_type,
                                      const string16& user_text,
                                      bool verbatim,
                                      string16* suggested_text) {
   is_out_of_date_ = false;
-  if (!InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile()))
+  const InstantFieldTrial::Mode mode =
+      InstantFieldTrial::GetMode(tab_contents_->profile());
+  if (mode == InstantFieldTrial::INSTANT)
     loader_->SetOmniboxBounds(omnibox_bounds_);
   loader_->Update(tab_contents_, template_url, url, transition_type, user_text,
                   verbatim, suggested_text);
   UpdateIsDisplayable();
   // For the HIDDEN and SILENT field trials, don't send back suggestions.
-  if (!InstantFieldTrial::ShouldSetSuggestedText(tab_contents_->profile()))
+  if (mode == InstantFieldTrial::HIDDEN || mode == InstantFieldTrial::SILENT)
     suggested_text->clear();
 }
 
 // Returns true if |template_url| is a valid TemplateURL for use by instant.
 bool InstantController::IsValidInstantTemplateURL(
     const TemplateURL* template_url) {
   return template_url && template_url->id() &&
       template_url->instant_url_ref().SupportsReplacement() &&
       !IsBlacklistedFromInstant(template_url->id());
 }
@@ skipping 23 matching lines @@
   if (!weak_factory_.HasWeakPtrs()) {
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&InstantController::DestroyLoaders,
                               weak_factory_.GetWeakPtr()));
   }
 }
 
 void InstantController::DestroyLoaders() {
   loaders_to_destroy_.reset();
 }