Add a new 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"
@@ skipping 157 matching lines @@
 
   const TemplateURL* template_url = match.template_url;
   DCHECK(template_url);  // ShouldUseInstant returns false if no turl.
   if (!loader_.get())
     loader_.reset(new InstantLoader(this, template_url->id()));
 
   // 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::IsHiddenExperiment(tab_contents->profile())) {
-    // For the HIDDEN field trial we process |user_text| at commit time, which
+  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.
     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(
@@ skipping 39 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 field trial, return the status of the preview.
-  if (!InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile()))
+  // If we are not in the HIDDEN or SILENT field trials, return the status of
+  // the preview.
+  if (!InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile()) &&
+      !InstantFieldTrial::IsSilentExperiment(tab_contents_->profile())) {
     return IsCurrent();
+  }
 
   TemplateURLService* model = TemplateURLServiceFactory::GetForProfile(
       tab_contents_->profile());
   if (!model)
     return false;
 
   const TemplateURL* template_url = model->GetDefaultSearchProvider();
   if (!IsValidInstantTemplateURL(template_url) ||
       loader_->template_url_id() != template_url->id() ||
       loader_->IsNavigationPending() ||
@@ skipping 160 matching lines @@
 
 void InstantController::InstantStatusChanged(InstantLoader* loader) {
   DCHECK(loader_.get());
   UpdateIsDisplayable();
 }
 
 void InstantController::SetSuggestedTextFor(
     InstantLoader* loader,
     const string16& text,
     InstantCompleteBehavior behavior) {
-  delegate_->SetSuggestedText(text, behavior);
+  if (!is_out_of_date_ &&
+      !InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile())) {
+    delegate_->SetSuggestedText(text, behavior);
+  }
 }
 
 gfx::Rect InstantController::GetInstantBounds() {
   return delegate_->GetInstantBounds();
 }
 
 bool InstantController::ShouldCommitInstantOnMouseUp() {
   return commit_on_mouse_up_;
 }
 
@@ skipping 20 matching lines @@
   // Don't attempt to use instant for this search engine again.
   BlacklistFromInstant();
 }
 
 void InstantController::SwappedTabContents(InstantLoader* loader) {
   if (is_displayable_)
     delegate_->ShowInstant(loader->preview_contents());
 }
 
 void InstantController::UpdateIsDisplayable() {
+  if (!is_out_of_date_ &&
+      InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile())) {
+    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;
   loader_->SetOmniboxBounds(omnibox_bounds_);
   loader_->Update(tab_contents_, template_url, url, transition_type, user_text,
                   verbatim, suggested_text);
   UpdateIsDisplayable();
+  // For the HIDDEN field trial, don't send back suggestions to the omnibox.
+  if (InstantFieldTrial::IsHiddenExperiment(tab_contents_->profile()))
+    suggested_text->clear();
 }
 
 bool InstantController::ShouldUseInstant(const AutocompleteMatch& match) {
   TemplateURLService* model = TemplateURLServiceFactory::GetForProfile(
       tab_contents_->profile());
   if (!model)
     return false;
 
   const TemplateURL* default_t_url = model->GetDefaultSearchProvider();
   const TemplateURL* match_t_url = match.template_url;
@@ skipping 35 matching lines @@
   if (destroy_factory_.empty()) {
     MessageLoop::current()->PostTask(
         FROM_HERE, destroy_factory_.NewRunnableMethod(
             &InstantController::DestroyLoaders));
   }
 }
 
 void InstantController::DestroyLoaders() {
   loaders_to_destroy_.reset();
 }