Omnibox refactor. Move StartAutocomplete and DoInstant to controller.

chrome/browser/ui/omnibox/omnibox_edit_model.cc

 // Copyright 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/auto_reset.h"
 #include "base/format_macros.h"
@@ skipping 209 matching lines @@
 void OmniboxEditModel::SetUserText(const string16& text) {
   SetInputInProgress(true);
   InternalSetUserText(text);
   paste_state_ = NONE;
   has_temporary_text_ = false;
   is_temporary_text_set_by_instant_ = false;
   selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
   is_instant_temporary_text_a_search_query_ = false;
 }
 
-void OmniboxEditModel::FinalizeInstantQuery(const string16& input_text,
-                                            const InstantSuggestion& suggestion,
-                                            bool skip_inline_autocomplete) {
-  if (skip_inline_autocomplete) {
-    const string16 final_text = input_text + suggestion.text;
-    view_->OnBeforePossibleChange();
-    view_->SetWindowTextAndCaretPos(final_text, final_text.length(), false,
-        false);
-    view_->OnAfterPossibleChange();
-  } else if (popup_model()->IsOpen()) {
+void OmniboxEditModel::FinalizeInstantQuery(
+    const string16& input_text,
+    const InstantSuggestion& suggestion) {
+  if (popup_model()->IsOpen()) {
     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, suggestion);
   }
 }
 
 void OmniboxEditModel::SetInstantSuggestion(
     const InstantSuggestion& suggestion) {
   switch (suggestion.behavior) {
     case INSTANT_COMPLETE_NOW:
       view_->SetInstantSuggestion(string16());
       if (!suggestion.text.empty())
-        FinalizeInstantQuery(view_->GetText(), suggestion, false);
+        FinalizeInstantQuery(view_->GetText(), suggestion);
       break;
 
     case INSTANT_COMPLETE_NEVER: {
       DCHECK_EQ(INSTANT_SUGGESTION_SEARCH, suggestion.type);
       view_->SetInstantSuggestion(suggestion.text);
       autocomplete_controller()->search_provider()->ClearInstantSuggestion();
       break;
     }
 
     case INSTANT_COMPLETE_REPLACE: {
       const bool save_original_selection = !has_temporary_text_;
       view_->SetInstantSuggestion(string16());
       has_temporary_text_ = true;
       is_temporary_text_set_by_instant_ = true;
       selected_instant_autocomplete_match_index_ =
           suggestion.autocomplete_match_index;
       is_instant_temporary_text_a_search_query_ =
           suggestion.type == INSTANT_SUGGESTION_SEARCH;
       // Instant suggestions are never a keyword.
       keyword_ = string16();
       is_keyword_hint_ = false;
       view_->OnTemporaryTextMaybeChanged(suggestion.text,
                                          save_original_selection, true);
       break;
     }
   }
 }
 
-bool OmniboxEditModel::CommitSuggestedText(bool skip_inline_autocomplete) {
-  if (!controller_->GetInstant())
-    return false;
-
+bool OmniboxEditModel::CommitSuggestedText() {
   const string16 suggestion = view_->GetInstantSuggestion();
   if (suggestion.empty())
     return false;
 
   // Assume that the gray text we are committing is a search suggestion.
-  FinalizeInstantQuery(view_->GetText(),
-                       InstantSuggestion(suggestion,
-                                         INSTANT_COMPLETE_NOW,
-                                         INSTANT_SUGGESTION_SEARCH,
-                                         string16(),
-                                         OmniboxPopupModel::kNoMatch),
-                       skip_inline_autocomplete);
+  const string16 final_text = view_->GetText() + suggestion;
+  view_->OnBeforePossibleChange();
+  view_->SetWindowTextAndCaretPos(final_text, final_text.length(), false,
+      false);
+  view_->OnAfterPossibleChange();
   return true;
 }
 
 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();
 
@@ skipping 11 matching lines @@
     // 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);
 
-  if (!DoInstant(current_match)) {
+  // Do not perform instant if we're currently reverting or the change is the
+  // result of an INSTANT_COMPLETE_REPLACE instant suggestion.
+  bool performed_instant = false;
+  if (!in_revert_ && !is_temporary_text_set_by_instant_) {
+    size_t start, end;
+    view_->GetSelectionBounds(&start, &end);
+    string16 user_text = DisplayTextFromUserText(user_text_);
+    performed_instant = omnibox_controller_->DoInstant(
+        current_match, user_text, view_->GetText(), start, end,
+        user_input_in_progress_, in_escape_handler_,
+        view_->DeleteAtEndPressed() || just_deleted_text_,
+        KeywordIsSelected());
+  }
+
+  if (!performed_instant) {
     // Hide any suggestions we might be showing.
     view_->SetInstantSuggestion(string16());
 
     // No need to wait any longer for Instant.
-    FinalizeInstantQuery(string16(), InstantSuggestion(), false);
+    FinalizeInstantQuery(string16(), InstantSuggestion());
   }
 
   switch (recommended_action) {
     case AutocompleteActionPredictor::ACTION_PRERENDER:
       // It's possible that there is no current page, for instance if the tab
       // has been closed or on return from a sleep state.
       // (http://crbug.com/105689)
       if (!delegate_->CurrentPageExists())
         break;
       // Ask for prerendering if the destination URL is different than the
@@ skipping 17 matching lines @@
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   *url = match.destination_url;
   if (*url == URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_),
                                       std::string())) {
     *title = controller_->GetTitle();
     *favicon = controller_->GetFavicon();
   }
 }
 
-bool OmniboxEditModel::UseVerbatimInstant() {
-#if defined(OS_MACOSX)
-  // TODO(suzhe): Fix Mac port to display Instant suggest in a separated NSView,
-  // so that we can display Instant suggest along with composition text.
-  const AutocompleteInput& input = autocomplete_controller()->input();
-  if (input.prevent_inline_autocomplete())
-    return true;
-#endif
-
-  // The value of input.prevent_inline_autocomplete() is determined by the
-  // following conditions:
-  // 1. If the caret is at the end of the text.
-  // 2. If it's in IME composition mode.
-  // We send the caret position to Instant (so it can determine #1 itself), and
-  // we use a separated widget for displaying the Instant suggest (so it doesn't
-  // interfere with #2). So, we don't need to care about the value of
-  // input.prevent_inline_autocomplete() here.
-  return view_->DeleteAtEndPressed() || popup_model()->selected_line() != 0 ||
-      just_deleted_text_;
-}
-
 bool OmniboxEditModel::CurrentTextIsURL() const {
   if (view_->toolbar_model()->GetSearchTermsType() !=
       ToolbarModel::NO_SEARCH_TERMS)
     return false;
 
   // If current text is not composed of replaced search terms and
   // !user_input_in_progress_, then permanent text is showing and should be a
   // URL, so no further checking is needed.  By avoiding checking in this case,
   // we avoid calling into the autocomplete providers, and thus initializing the
   // history system, as long as possible, which speeds startup.
@@ skipping 91 matching lines @@
                                   false, true);
   AutocompleteActionPredictor* action_predictor =
       AutocompleteActionPredictorFactory::GetForProfile(profile_);
   if (action_predictor)
     action_predictor->ClearTransitionalMatches();
 }
 
 void OmniboxEditModel::StartAutocomplete(
     bool has_selected_text,
     bool prevent_inline_autocomplete) const {
-  omnibox_controller_->ClearPopupKeywordMode();
-
-  bool keyword_is_selected = KeywordIsSelected();
-  popup_model()->SetHoveredLine(OmniboxPopupModel::kNoMatch);
-
   size_t cursor_position;
   if (inline_autocomplete_text_.empty()) {
     // Cursor position is equivalent to the current selection's end.
     size_t start;
     view_->GetSelectionBounds(&start, &cursor_position);
     // Adjust cursor position taking into account possible keyword in the user
     // text.  We rely on DisplayTextFromUserText() method which is consistent
     // with keyword extraction done in KeywordProvider/SearchProvider.
     const size_t cursor_offset =
         user_text_.length() - DisplayTextFromUserText(user_text_).length();
     cursor_position += cursor_offset;
   } else {
     // There are some cases where StartAutocomplete() may be called
     // with non-empty |inline_autocomplete_text_|.  In such cases, we cannot
     // use the current selection, because it could result with the cursor
     // position past the last character from the user text.  Instead,
     // we assume that the cursor is simply at the end of input.
     // One example is when user presses Ctrl key while having a highlighted
     // inline autocomplete text.
     // TODO: Rethink how we are going to handle this case to avoid
     // inconsistent behavior when user presses Ctrl key.
     // See http://crbug.com/165961 and http://crbug.com/165968 for more details.
     cursor_position = user_text_.length();
   }
 
-  InstantController* instant = controller_->GetInstant();
-  if (instant) {
-    instant->OnAutocompleteStart();
-    // If the embedded page for InstantExtended is fetching its own suggestions,
-    // suppress search suggestions from SearchProvider. We still need
-    // SearchProvider to run for FinalizeInstantQuery.
-    // TODO(dcblack): Once we are done refactoring the omnibox so we don't need
-    // to use FinalizeInstantQuery anymore, we can take out this check and
-    // remove this provider from kInstantExtendedOmniboxProviders.
-    if (instant->WillFetchCompletions())
-      autocomplete_controller()->search_provider()->SuppressSearchSuggestions();
-  }
-
-  // We don't explicitly clear OmniboxPopupModel::manually_selected_match, as
-  // Start ends up invoking OmniboxPopupModel::OnResultChanged which clears it.
-  autocomplete_controller()->Start(AutocompleteInput(
-      user_text_, cursor_position, string16(), GURL(),
+  bool keyword_is_selected = KeywordIsSelected();
+  omnibox_controller_->StartAutocomplete(
+      user_text_,
+      cursor_position,
       prevent_inline_autocomplete || just_deleted_text_ ||
       (has_selected_text && inline_autocomplete_text_.empty()) ||
-      (paste_state_ != NONE), keyword_is_selected,
-      keyword_is_selected || allow_exact_keyword_match_,
-      AutocompleteInput::ALL_MATCHES));
+      (paste_state_ != NONE),
+      keyword_is_selected,
+      keyword_is_selected || allow_exact_keyword_match_);
 }
 
 void OmniboxEditModel::StopAutocomplete() {
   autocomplete_controller()->Stop(true);
 }
 
 bool OmniboxEditModel::CanPasteAndGo(const string16& text) const {
   if (!view_->command_updater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
     return false;
 
@@ skipping 191 matching lines @@
     const GURL destination_url = autocomplete_controller()->
         GetDestinationURL(match, query_formulation_time);
 
     // If running with instant, notify the instant controller that a navigation
     // is about to take place if we are navigating to a URL. This can be
     // determined by inspecting the transition type. To ensure that this is only
     // done on Enter key press, check that the disposition is CURRENT_TAB. This
     // is the same heuristic used by BrowserInstantController::OpenInstant
     if (match.transition == content::PAGE_TRANSITION_TYPED &&
         disposition == CURRENT_TAB) {
-      InstantController* instant = controller_->GetInstant();
+      InstantController* instant = GetInstantController();
       if (instant)
         instant->OmniboxNavigateToURL();
     }
 
     // This calls RevertAll again.
     base::AutoReset<bool> tmp(&in_revert_, true);
     controller_->OnAutocompleteAccept(destination_url, disposition,
                                       match.transition, alternate_nav_url);
   }
 
@@ skipping 91 matching lines @@
 
 void OmniboxEditModel::SetCaretVisibility(bool visible) {
   // Caret visibility only matters if the omnibox has focus.
   if (focus_state_ != OMNIBOX_FOCUS_NONE) {
     SetFocusState(visible ? OMNIBOX_FOCUS_VISIBLE : OMNIBOX_FOCUS_INVISIBLE,
                   OMNIBOX_FOCUS_CHANGE_EXPLICIT);
   }
 }
 
 void OmniboxEditModel::OnWillKillFocus(gfx::NativeView view_gaining_focus) {
-  InstantController* instant = controller_->GetInstant();
+  InstantController* instant = GetInstantController();
   if (instant) {
     instant->OmniboxFocusChanged(OMNIBOX_FOCUS_NONE,
                                  OMNIBOX_FOCUS_CHANGE_EXPLICIT,
                                  view_gaining_focus);
   }
 
   // TODO(jered): Rip this out along with StartZeroSuggest.
   autocomplete_controller()->StopZeroSuggest();
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_,
                                    popup_model()->IsOpen(), user_text_.empty());
@@ skipping 81 matching lines @@
       // TODO(pkasting): We should, in fact, force this particular query to open
       // the popup immediately.
       if (!user_input_in_progress_)
         InternalSetUserText(permanent_text_);
       view_->UpdatePopup();
     } else {
       // TODO(pkasting): The popup is working on a query but is not open.  We
       // should force it to open immediately.
     }
   } else {
-    InstantController* instant = controller_->GetInstant();
+    InstantController* instant = GetInstantController();
     if (instant && instant->OnUpOrDownKeyPressed(count)) {
       // If Instant handles the key press, it's showing a list of suggestions
       // that it's stepping through. In that case, our popup model is
       // irrelevant, so don't process the key press ourselves. However, do stop
       // the autocomplete system from changing the results.
       autocomplete_controller()->Stop(false);
     } else {
       // The popup is open, so the user should be able to interact with it
       // normally.
       popup_model()->Move(count);
@@ skipping 180 matching lines @@
   // will have updated our state already, so in that case we don't also return
   // true from this function.
   return !(text_differs && allow_keyword_ui_change && !just_deleted_text &&
            no_selection && (selection_start == user_text_.length()) &&
            MaybeAcceptKeywordBySpace(user_text_));
 }
 
 void OmniboxEditModel::OnResultChanged(bool default_match_changed) {
 }
 
+InstantController* OmniboxEditModel::GetInstantController() const {
+  return controller_->GetInstant();
+}
+
 bool OmniboxEditModel::query_in_progress() const {
   return !autocomplete_controller()->done();
 }
 
 void OmniboxEditModel::InternalSetUserText(const string16& text) {
   user_text_ = text;
   just_deleted_text_ = false;
   inline_autocomplete_text_.clear();
 }
 
 bool OmniboxEditModel::KeywordIsSelected() const {
   return !is_keyword_hint_ && !keyword_.empty();
 }
 
+void OmniboxEditModel::ClearPopupKeywordMode() const {
+  omnibox_controller_->ClearPopupKeywordMode();
+}
+
 string16 OmniboxEditModel::DisplayTextFromUserText(const string16& text) const {
   return KeywordIsSelected() ?
       KeywordProvider::SplitReplacementStringFromInput(text, false) : text;
 }
 
 string16 OmniboxEditModel::UserTextFromDisplayText(const string16& text) const {
   return KeywordIsSelected() ? (keyword_ + char16(' ') + text) : text;
 }
 
 void OmniboxEditModel::GetInfoForCurrentText(AutocompleteMatch* match,
@@ skipping 94 matching lines @@
   // The user typed something, then selected a different item.  Restore the
   // text they typed and change back to the default item.
   // NOTE: This purposefully does not reset paste_state_.
   bool notify_instant = is_temporary_text_set_by_instant_;
   just_deleted_text_ = false;
   has_temporary_text_ = false;
   is_temporary_text_set_by_instant_ = false;
   selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
   is_instant_temporary_text_a_search_query_ = false;
 
-  InstantController* instant = controller_->GetInstant();
+  InstantController* instant = GetInstantController();
   if (instant && notify_instant) {
     // Normally, popup_->ResetToDefaultMatch() will cause the view text to be
     // updated. In Instant Extended mode however, the popup_ is not used, so it
     // won't do anything. So, update the view ourselves. Even if Instant is not
     // in extended mode (i.e., it's enabled in non-extended mode, or disabled
     // altogether), this is okay to do, since the call to
     // popup_->ResetToDefaultMatch() will just override whatever we do here.
     //
     // The two "false" arguments make sure that our shenanigans don't cause any
     // previously saved selection to be erased nor OnChanged() to be called.
@@ skipping 43 matching lines @@
   // Then check if the text before the inserted space matches a keyword.
   string16 keyword;
   TrimWhitespace(new_text.substr(0, space_position), TRIM_LEADING, &keyword);
   // TODO(sreeram): Once the Instant extended API supports keywords properly,
   // keyword_provider() should never be NULL. Remove that clause.
   return !keyword.empty() && autocomplete_controller()->keyword_provider() &&
       !autocomplete_controller()->keyword_provider()->
           GetKeywordForText(keyword).empty();
 }
 
-bool OmniboxEditModel::DoInstant(const AutocompleteMatch& match) {
-  InstantController* instant = controller_->GetInstant();
-  if (!instant || in_revert_)
-    return false;
-
-  // Don't call Update() if the change is the result of an
-  // INSTANT_COMPLETE_REPLACE instant suggestion.
-  if (is_temporary_text_set_by_instant_)
-    return false;
-
-  // The two pieces of text we want to send Instant, viz., what the user has
-  // typed, and the full omnibox text including any inline autocompletion.
-  string16 user_text = has_temporary_text_ ?
-      match.fill_into_edit : DisplayTextFromUserText(user_text_);
-  string16 full_text = view_->GetText();
-
-  // Remove "?" if we're in forced query mode.
-  AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-      autocomplete_controller()->input().type(), &user_text);
-  AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-      autocomplete_controller()->input().type(), &full_text);
-
-  size_t start, end;
-  view_->GetSelectionBounds(&start, &end);
-
-  return instant->Update(match, user_text, full_text, start, end,
-      UseVerbatimInstant(), user_input_in_progress_, popup_model()->IsOpen(),
-      in_escape_handler_, KeywordIsSelected());
-}
-
 //  static
 bool OmniboxEditModel::IsSpaceCharForAcceptingKeyword(wchar_t c) {
   switch (c) {
     case 0x0020:  // Space
     case 0x3000:  // Ideographic Space
       return true;
     default:
       return false;
   }
 }
@@ skipping 19 matching lines @@
   DCHECK(match);
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
       false, false, match, alternate_nav_url);
 }
 
 void OmniboxEditModel::SetFocusState(OmniboxFocusState state,
                                      OmniboxFocusChangeReason reason) {
   if (state == focus_state_)
     return;
 
-  InstantController* instant = controller_->GetInstant();
+  InstantController* instant = GetInstantController();
   if (instant)
     instant->OmniboxFocusChanged(state, reason, NULL);
 
   // Update state and notify view if the omnibox has focus and the caret
   // visibility changed.
   const bool was_caret_visible = is_caret_visible();
   focus_state_ = state;
   if (focus_state_ != OMNIBOX_FOCUS_NONE &&
       is_caret_visible() != was_caret_visible)
     view_->ApplyCaretVisibility();
 }