Remove Instant v1 API.

chrome/browser/ui/omnibox/omnibox_edit_model.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/ui/omnibox/omnibox_edit_model.h"
 
 #include <string>
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 77 matching lines @@
       controller_(controller),
       has_focus_(false),
       user_input_in_progress_(false),
       just_deleted_text_(false),
       has_temporary_text_(false),
       paste_state_(NONE),
       control_key_state_(UP),
       is_keyword_hint_(false),
       profile_(profile),
       in_revert_(false),
-      allow_exact_keyword_match_(false),
-      instant_complete_behavior_(INSTANT_COMPLETE_DELAYED) {
+      allow_exact_keyword_match_(false) {
 }
 
 OmniboxEditModel::~OmniboxEditModel() {
 }
 
 const OmniboxEditModel::State OmniboxEditModel::GetStateForTabSwitch() {
   // Like typing, switching tabs "accepts" the temporary text as the user
   // text, because it makes little sense to have temporary text when the
   // popup is closed.
   if (user_input_in_progress_) {
@@ skipping 67 matching lines @@
     SearchProvider* search_provider =
         autocomplete_controller_->search_provider();
     // There may be no providers during testing; guard against that.
     if (search_provider)
       search_provider->FinalizeInstantQuery(input_text, suggest_text);
   }
 }
 
 void OmniboxEditModel::SetSuggestedText(const string16& text,
                                         InstantCompleteBehavior behavior) {
-  instant_complete_behavior_ = behavior;
-  if (instant_complete_behavior_ == INSTANT_COMPLETE_NOW) {
+  if (behavior == INSTANT_COMPLETE_NOW) {
     if (!text.empty())
       FinalizeInstantQuery(view_->GetText(), text, false);
     else
       view_->SetInstantSuggestion(text, false);
   } else {
     DCHECK((behavior == INSTANT_COMPLETE_DELAYED) ||
            (behavior == INSTANT_COMPLETE_NEVER));
     view_->SetInstantSuggestion(text, behavior == INSTANT_COMPLETE_DELAYED);
   }
 }
 
 bool OmniboxEditModel::CommitSuggestedText(bool skip_inline_autocomplete) {
   if (!controller_->GetInstant())
     return false;
 
   const string16 suggestion = view_->GetInstantSuggestion();
   if (suggestion.empty())
     return false;
 
   FinalizeInstantQuery(view_->GetText(), suggestion, skip_inline_autocomplete);
   return true;
 }
 
 bool OmniboxEditModel::AcceptCurrentInstantPreview() {
   InstantController* instant = controller_->GetInstant();
-  return instant && instant->CommitIfCurrent();
+  return instant && instant->IsCurrent() &&
+         instant->CommitCurrentPreview(INSTANT_COMMIT_PRESSED_ENTER);
 }
 
 void OmniboxEditModel::OnChanged() {
   // Don't call CurrentMatch() when there's no editing, as in this case we'll
   // never actually use it.  This avoids running the autocomplete providers (and
   // any systems they then spin up) during startup.
   const AutocompleteMatch& current_match = user_input_in_progress_ ?
       CurrentMatch() : AutocompleteMatch();
 
   AutocompleteActionPredictor::Action recommended_action =
       AutocompleteActionPredictor::ACTION_NONE;
   AutocompleteActionPredictor* action_predictor =
       user_input_in_progress_ ?
       AutocompleteActionPredictorFactory::GetForProfile(profile_) : NULL;
   if (action_predictor) {
     action_predictor->RegisterTransitionalMatches(user_text_, result());
     // Confer with the AutocompleteActionPredictor to determine what action, if
     // any, we should take. Get the recommended action here even if we don't
     // need it so we can get stats for anyone who is opted in to UMA, but only
     // get it if the user has actually typed something to avoid constructing it
     // before it's needed. Note: This event is triggered as part of startup when
     // the initial tab transitions to the start page.
     recommended_action =
         action_predictor->RecommendAction(user_text_, current_match);
   }
 
   UMA_HISTOGRAM_ENUMERATION("AutocompleteActionPredictor.Action",
                             recommended_action,
                             AutocompleteActionPredictor::LAST_PREDICT_ACTION);
+
   string16 suggested_text;
+  InstantCompleteBehavior complete_behavior = INSTANT_COMPLETE_NOW;
 
-  if (DoInstant(current_match, &suggested_text)) {
-    SetSuggestedText(suggested_text, instant_complete_behavior_);
+  if (DoInstant(current_match, &suggested_text, &complete_behavior)) {
+    SetSuggestedText(suggested_text, complete_behavior);
   } else {
     switch (recommended_action) {
       case AutocompleteActionPredictor::ACTION_PRERENDER:
         DoPrerender(current_match);
         break;
       case AutocompleteActionPredictor::ACTION_PRECONNECT:
         DoPreconnect(current_match);
         break;
       case AutocompleteActionPredictor::ACTION_NONE:
         break;
@@ skipping 175 matching lines @@
       (has_selected_text && inline_autocomplete_text_.empty()) ||
       (paste_state_ != NONE), keyword_is_selected,
       keyword_is_selected || allow_exact_keyword_match_,
       AutocompleteInput::ALL_MATCHES);
 }
 
 void OmniboxEditModel::StopAutocomplete() {
   if (popup_->IsOpen() && !in_revert_) {
     InstantController* instant = controller_->GetInstant();
     if (instant && !instant->commit_on_pointer_release())
-      instant->DestroyPreviewContents();
+      instant->Hide();
   }
 
   autocomplete_controller_->Stop(true);
 }
 
 bool OmniboxEditModel::CanPasteAndGo(const string16& text) const {
   if (!view_->GetCommandUpdater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
     return false;
 
   AutocompleteMatch match;
@@ skipping 151 matching lines @@
   } else {
     controller_->OnAutocompleteAccept(match.destination_url, disposition,
                                       match.transition, alternate_nav_url);
   }
 
   if (match.starred)
     bookmark_utils::RecordBookmarkLaunch(bookmark_utils::LAUNCH_OMNIBOX);
 
   InstantController* instant = controller_->GetInstant();
   if (instant && !popup_->IsOpen())
-    instant->DestroyPreviewContents();
+    instant->Hide();
   in_revert_ = false;
 }
 
 bool OmniboxEditModel::AcceptKeyword() {
   DCHECK(is_keyword_hint_ && !keyword_.empty());
 
   autocomplete_controller_->Stop(false);
   is_keyword_hint_ = false;
 
   if (popup_->IsOpen())
@@ skipping 49 matching lines @@
   InstantController* instant = controller_->GetInstant();
   if (instant)
     instant->OnAutocompleteGotFocus();
 
   NotifySearchTabHelper();
 }
 
 void OmniboxEditModel::OnWillKillFocus(gfx::NativeView view_gaining_focus) {
   SetSuggestedText(string16(), INSTANT_COMPLETE_NOW);
 
-  InstantController* instant = controller_->GetInstant();
-  if (instant)
+  if (InstantController* instant = controller_->GetInstant())
     instant->OnAutocompleteLostFocus(view_gaining_focus);
 
   NotifySearchTabHelper();
 }
 
 void OmniboxEditModel::OnKillFocus() {
   has_focus_ = false;
   control_key_state_ = UP;
   paste_state_ = NONE;
 }
@@ skipping 382 matching lines @@
           GetKeywordForText(keyword).empty();
 }
 
 void OmniboxEditModel::NotifySearchTabHelper() {
   if (controller_->GetTabContents()) {
     controller_->GetTabContents()->search_tab_helper()->
         OmniboxEditModelChanged(this);
   }
 }
 
-bool OmniboxEditModel::DoInstant(const AutocompleteMatch& match,
-                                 string16* suggested_text) {
+bool OmniboxEditModel::DoInstant(
+    const AutocompleteMatch& match,
+    string16* suggested_text,
+    InstantCompleteBehavior* complete_behavior) {
   DCHECK(suggested_text);
+  DCHECK(complete_behavior);
 
   if (in_revert_)
     return false;
 
   InstantController* instant = controller_->GetInstant();
 
   if (!instant)
     return false;
 
   if (user_input_in_progress_ && popup_->IsOpen()) {
-    return instant->Update(match, view_->GetText(), UseVerbatimInstant(),
-                           suggested_text);
+    string16 text = view_->GetText();
+    AutocompleteInput::RemoveForcedQueryStringIfNecessary(
+      autocomplete_controller_->input().type(), &text);
+
+    // If there's any inline autocompletion, split it out from |text|.
+    if (!inline_autocomplete_text_.empty()) {
+      DCHECK_GE(text.size(), inline_autocomplete_text_.size());
+      text.resize(text.size() - inline_autocomplete_text_.size());
+      *suggested_text = inline_autocomplete_text_;
+    }
+
+    return instant->Update(match, text, UseVerbatimInstant(), suggested_text,
+                           complete_behavior);
   }
 
   // It's possible DoInstant() was called due to an OnChanged() event from the
   // omnibox view if the user clicked the renderer while IME composition was
   // active. In that case we still want to commit on mouse up, so don't call
   // Hide().
   if (!instant->commit_on_pointer_release())
     instant->Hide();
   return false;
 }
@@ skipping 59 matching lines @@
 }
 
 void OmniboxEditModel::ClassifyStringForPasteAndGo(
     const string16& text,
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   DCHECK(match);
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
       string16(), false, false, match, alternate_nav_url);
 }