InstantExtended: Remove overlay control code.

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 109 matching lines @@
 
 OmniboxEditModel::OmniboxEditModel(OmniboxView* view,
                                    OmniboxEditController* controller,
                                    Profile* profile)
     : view_(view),
       controller_(controller),
       focus_state_(OMNIBOX_FOCUS_NONE),
       user_input_in_progress_(false),
       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),
       paste_state_(NONE),
       control_key_state_(UP),
       is_keyword_hint_(false),
       profile_(profile),
       in_revert_(false),
-      in_escape_handler_(false),
       allow_exact_keyword_match_(false) {
   omnibox_controller_.reset(new OmniboxController(this, profile));
   delegate_.reset(new OmniboxCurrentPageDelegateImpl(controller, profile));
 }
 
 OmniboxEditModel::~OmniboxEditModel() {
 }
 
 const OmniboxEditModel::State OmniboxEditModel::GetStateForTabSwitch() {
   // Like typing, switching tabs "accepts" the temporary text as the user
@@ skipping 76 matching lines @@
 GURL OmniboxEditModel::PermanentURL() {
   return URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string());
 }
 
 void OmniboxEditModel::SetUserText(const string16& text) {
   SetInputInProgress(true);
   InternalSetUserText(text);
   omnibox_controller_->InvalidateCurrentMatch();
   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::SetInstantSuggestion(
     const InstantSuggestion& suggestion) {
-// Should only get called for the HTML popup.
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-  omnibox_controller_->SetInstantSuggestion(suggestion);
-#endif
 }
 
 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.
   const string16 final_text = view_->GetText() + suggestion;
   view_->OnBeforePossibleChange();
@@ skipping 24 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);
 
-  // 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());
-  }
+  // Hide any suggestions we might be showing.
+  view_->SetInstantSuggestion(string16());
 
   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
       // current URL.
@@ skipping 104 matching lines @@
                                    popup_model()->IsOpen(), user_text_.empty());
 }
 
 void OmniboxEditModel::Revert() {
   SetInputInProgress(false);
   paste_state_ = NONE;
   InternalSetUserText(string16());
   keyword_.clear();
   is_keyword_hint_ = 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;
   view_->SetWindowTextAndCaretPos(permanent_text_,
                                   has_focus() ? permanent_text_.length() : 0,
                                   false, true);
   AutocompleteActionPredictor* action_predictor =
       AutocompleteActionPredictorFactory::GetForProfile(profile_);
   if (action_predictor)
     action_predictor->ClearTransitionalMatches();
 }
 
 void OmniboxEditModel::StartAutocomplete(
@@ skipping 153 matching lines @@
     // (because the user does not modify the omnibox for ZeroSuggest), so for
     // those we set the elapsed times to something that will be ignored by
     // metrics_log.cc.
     if (match.provider &&
         match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST) {
       elapsed_time_since_user_first_modified_omnibox =
           base::TimeDelta::FromMilliseconds(-1);
       elapsed_time_since_last_change_to_default_match =
           base::TimeDelta::FromMilliseconds(-1);
     }
-    // TODO(sreeram): Handle is_temporary_text_set_by_instant_ correctly.
     OmniboxLog log(
         autocomplete_controller()->input().text(),
         just_deleted_text_,
         autocomplete_controller()->input().type(),
         popup_model()->selected_line(),
         -1,  // don't yet know tab ID; set later if appropriate
         delegate_->CurrentPageExists() ? ClassifyPage(delegate_->GetURL()) :
             metrics::OmniboxEventProto_PageClassification_OTHER,
         elapsed_time_since_user_first_modified_omnibox,
         string16::npos,  // completed_length; possibly set later
@@ skipping 85 matching lines @@
 
     // Track whether the destination URL sends us to a search results page
     // using the default search provider.
     TemplateURL* default_provider =
         TemplateURLServiceFactory::GetForProfile(profile_)->
             GetDefaultSearchProvider();
     if (default_provider && default_provider->IsSearchURL(destination_url))
       content::RecordAction(UserMetricsAction(
           "OmniboxDestinationURLMatchesDefaultSearchProvider"));
 
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-    // 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 = GetInstantController();
-      if (instant)
-        instant->OmniboxNavigateToURL();
-    }
-#endif
-
     // This calls RevertAll again.
     base::AutoReset<bool> tmp(&in_revert_, true);
     controller_->OnAutocompleteAccept(destination_url, disposition,
                                       match.transition, alternate_nav_url);
   }
 
   if (match.starred)
     bookmark_utils::RecordBookmarkLaunch(bookmark_utils::LAUNCH_OMNIBOX);
 }
 
 bool OmniboxEditModel::AcceptKeyword(EnteredKeywordModeMethod entered_method) {
   DCHECK(is_keyword_hint_ && !keyword_.empty());
 
   autocomplete_controller()->Stop(false);
   is_keyword_hint_ = false;
 
   if (popup_model()->IsOpen())
     popup_model()->SetSelectedLineState(OmniboxPopupModel::KEYWORD);
   else
     StartAutocomplete(false, true);
 
   // Ensure the current selection is saved before showing keyword mode
   // so that moving to another line and then reverting the text will restore
   // the current state properly.
   bool save_original_selection = !has_temporary_text_;
   has_temporary_text_ = true;
-  is_temporary_text_set_by_instant_ = false;
-  selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
-  is_instant_temporary_text_a_search_query_ = false;
   view_->OnTemporaryTextMaybeChanged(
       DisplayTextFromUserText(CurrentMatch(NULL).fill_into_edit),
       save_original_selection, true);
 
   content::RecordAction(UserMetricsAction("AcceptedKeywordHint"));
   UMA_HISTOGRAM_ENUMERATION(kEnteredKeywordModeHistogram, entered_method,
                             ENTERED_KEYWORD_MODE_NUM_ITEMS);
 
   return true;
 }
 
 void OmniboxEditModel::AcceptTemporaryTextAsUserText() {
   InternalSetUserText(UserTextFromDisplayText(view_->GetText()));
   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;
-  OnPopupBoundsChanged(gfx::Rect());
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_,
                                    popup_model()->IsOpen(), user_text_.empty());
 }
 
 void OmniboxEditModel::ClearKeyword(const string16& visible_text) {
   autocomplete_controller()->Stop(false);
   omnibox_controller_->ClearPopupKeywordMode();
 
   const string16 window_text(keyword_ + visible_text);
 
@@ skipping 85 matching lines @@
   }
 
   // If the user wasn't editing, but merely had focus in the edit, allow <esc>
   // to be processed as an accelerator, so it can still be used to stop a load.
   // When the permanent text isn't all selected we still fall through to the
   // SelectAll() call below so users can arrow around in the text and then hit
   // <esc> to quickly replace all the text; this matches IE.
   if (!user_input_in_progress_ && view_->IsSelectAll())
     return false;
 
-  in_escape_handler_ = true;
   if (!user_text_.empty()) {
     UMA_HISTOGRAM_ENUMERATION(kOmniboxUserTextClearedHistogram,
                               OMNIBOX_USER_TEXT_CLEARED_WITH_ESCAPE,
                               OMNIBOX_USER_TEXT_CLEARED_NUM_OF_ITEMS);
   }
   view_->RevertAll();
-  in_escape_handler_ = false;
   view_->SelectAll(true);
   return true;
 }
 
 void OmniboxEditModel::OnControlKeyChanged(bool pressed) {
   if (pressed == (control_key_state_ == UP))
     control_key_state_ = pressed ? DOWN_WITHOUT_CHANGE : UP;
 }
 
 void OmniboxEditModel::OnUpOrDownKeyPressed(int count) {
   // NOTE: This purposefully doesn't trigger any code that resets paste_state_.
   if (popup_model()->IsOpen()) {
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-    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);
-      return;
-    }
-#endif
-
     // The popup is open, so the user should be able to interact with it
     // normally.
     popup_model()->Move(count);
     return;
   }
 
   if (!query_in_progress()) {
     // The popup is neither open nor working on a query already.  So, start an
     // autocomplete query for the current text.  This also sets
     // user_input_in_progress_ to true, which we want: if the user has started
@@ skipping 30 matching lines @@
     // |is_keyword_hint_| should always be false if |keyword_| is empty.
     DCHECK(!keyword_.empty() || !is_keyword_hint_);
   }
 
   // Handle changes to temporary text.
   if (destination_for_temporary_text_change != NULL) {
     const bool save_original_selection = !has_temporary_text_;
     if (save_original_selection) {
       // Save the original selection and URL so it can be reverted later.
       has_temporary_text_ = true;
-      is_temporary_text_set_by_instant_ = false;
-      selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
-      is_instant_temporary_text_a_search_query_ = false;
       original_url_ = *destination_for_temporary_text_change;
       inline_autocomplete_text_.clear();
     }
     if (control_key_state_ == DOWN_WITHOUT_CHANGE) {
       // Arrowing around the popup cancels control-enter.
       control_key_state_ = DOWN_WITH_CHANGE;
       // Now things are a bit screwy: the desired_tld has changed, but if we
       // update the popup, the new order of entries won't match the old, so the
       // user's selection gets screwy; and if we don't update the popup, and the
       // user reverts, then the selected item will be as if control is still
@@ skipping 85 matching lines @@
   } else if (!user_text_changed) {
     return false;
   }
 
   // If the user text has not changed, we do not want to change the model's
   // state associated with the text.  Otherwise, we can get surprising behavior
   // where the autocompleted text unexpectedly reappears, e.g. crbug.com/55983
   if (user_text_changed) {
     InternalSetUserText(UserTextFromDisplayText(new_text));
     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;
 
     // Track when the user has deleted text so we won't allow inline
     // autocomplete.
     just_deleted_text_ = just_deleted_text;
 
     if (user_input_in_progress_ && user_text_.empty()) {
       // Log cases where the user started editing and then subsequently cleared
       // all the text.  Note that this explicitly doesn't catch cases like
       // "hit ctrl-l to select whole edit contents, then hit backspace", because
       // in such cases, |user_input_in_progress| won't be true here.
@@ skipping 31 matching lines @@
   // determine what keyword, if any, is applicable.
   //
   // If MaybeAcceptKeywordBySpace() accepts the keyword and returns true, that
   // 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::OnCurrentMatchChanged(bool is_temporary_set_by_instant) {
-  has_temporary_text_ = is_temporary_set_by_instant;
-  is_temporary_text_set_by_instant_ = is_temporary_set_by_instant;
+void OmniboxEditModel::OnCurrentMatchChanged() {
+  has_temporary_text_ = false;
 
   const AutocompleteMatch& match = omnibox_controller_->current_match();
 
-  if (is_temporary_set_by_instant) {
-    view_->OnTemporaryTextMaybeChanged(
-        DisplayTextFromUserText(match.fill_into_edit), !has_temporary_text_,
-        false);
-  } else {
-    // We store |keyword| and |is_keyword_hint| in temporary variables since
-    // OnPopupDataChanged use their previous state to detect changes.
-    string16 keyword;
-    bool is_keyword_hint;
-    match.GetKeywordUIState(profile_, &keyword, &is_keyword_hint);
-    string16 inline_autocomplete_text;
-    if (match.inline_autocomplete_offset < match.fill_into_edit.length()) {
-      // We have blue text, go through OnPopupDataChanged.
-      // TODO(beaudoin): Merge OnPopupDataChanged with this method once the
-      // popup handling has completely migrated to omnibox_controller.
-      inline_autocomplete_text =
-          match.fill_into_edit.substr(match.inline_autocomplete_offset);
-    }
-    popup_model()->OnResultChanged();
-    OnPopupDataChanged(inline_autocomplete_text, NULL, keyword,
-                       is_keyword_hint);
+  // We store |keyword| and |is_keyword_hint| in temporary variables since
+  // OnPopupDataChanged use their previous state to detect changes.
+  string16 keyword;
+  bool is_keyword_hint;
+  match.GetKeywordUIState(profile_, &keyword, &is_keyword_hint);
+  string16 inline_autocomplete_text;
+  if (match.inline_autocomplete_offset < match.fill_into_edit.length()) {
+    // We have blue text, go through OnPopupDataChanged.
+    // TODO(beaudoin): Merge OnPopupDataChanged with this method once the
+    // popup handling has completely migrated to omnibox_controller.
+    inline_autocomplete_text =
+        match.fill_into_edit.substr(match.inline_autocomplete_offset);
   }
-}
-
-void OmniboxEditModel::OnGrayTextChanged() {
-  view_->SetInstantSuggestion(omnibox_controller_->gray_suggestion());
+  popup_model()->OnResultChanged();
+  OnPopupDataChanged(inline_autocomplete_text, NULL, keyword,
+                     is_keyword_hint);
 }
 
 string16 OmniboxEditModel::GetViewText() const {
   return view_->GetText();
 }
 
 InstantController* OmniboxEditModel::GetInstantController() const {
   return controller_->GetInstant();
 }
 
@@ skipping 37 matching lines @@
     // explicitly set up a match that will reload here.
 
     // It's important that we fetch the current visible URL to reload instead of
     // just getting a "search what you typed" URL from
     // SearchProvider::CreateSearchSuggestion(), since the user may be in a
     // non-default search mode such as image search.
     match->type = AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED;
     match->destination_url =
         delegate_->GetNavigationController().GetVisibleEntry()->GetURL();
     match->transition = content::PAGE_TRANSITION_RELOAD;
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-  } else if (is_temporary_text_set_by_instant_) {
-    // If there's temporary text and it has been set by Instant, we won't find
-    // it in the popup model, so create the match based on the type Instant told
-    // us (SWYT for queries and UWYT for URLs). We do this instead of
-    // classifying the text ourselves because the text may look like a URL, but
-    // Instant may expect it to be a search (e.g.: a query for "amazon.com").
-    if (selected_instant_autocomplete_match_index_ !=
-            OmniboxPopupModel::kNoMatch) {
-      // Great, we know the exact match struct. Just use that.
-      const AutocompleteResult& result = this->result();
-      *match = result.match_at(selected_instant_autocomplete_match_index_);
-    } else {
-      const string16& text = view_->GetText();
-      AutocompleteInput input(text, string16::npos, string16(), GURL(), false,
-                              false, false, AutocompleteInput::BEST_MATCH);
-      // Only the destination_url and the transition of the match will be be
-      // used (to either navigate to the URL or let Instant commit its preview).
-      // The match won't be used for logging, displaying in the dropdown, etc.
-      // So, it's okay to pass in mostly bogus params (such as relevance = 0).
-      // TODO(sreeram): Always using NO_SUGGESTIONS_AVAILABLE is wrong when
-      // Instant is using the local fallback overlay. Fix.
-      if (is_instant_temporary_text_a_search_query_) {
-        const TemplateURL* default_provider =
-            TemplateURLServiceFactory::GetForProfile(profile_)->
-                GetDefaultSearchProvider();
-        if (default_provider && default_provider->SupportsReplacement()) {
-          *match = SearchProvider::CreateSearchSuggestion(
-              autocomplete_controller()->search_provider(), 0,
-              AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, default_provider,
-              text, text, input, false,
-              TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
-              controller_->GetOmniboxBounds().x(), true);
-        } else {
-          // Can't create a new search match. Leave |match| as is, with an
-          // invalid destination_url. This shouldn't ever happen. For example,
-          // even if a group policy update in the midst of interacting with
-          // Instant leaves us without a valid search provider, Instant
-          // should've observed the update and reset
-          // |is_temporary_text_set_by_instant_|, so we still shouldn't get
-          // here. However, as protection against the unknowns and Instant
-          // regressions, we simply return an invalid match instead of crashing
-          // (hence no DCHECK).
-        }
-      } else {
-        *match = HistoryURLProvider::SuggestExactInput(
-            autocomplete_controller()->history_url_provider(), input, false);
-      }
-    }
-#endif
   } else if (popup_model()->IsOpen() || query_in_progress()) {
     if (query_in_progress()) {
       // It's technically possible for |result| to be empty if no provider
       // returns a synchronous result but the query has not completed
       // synchronously; pratically, however, that should never actually happen.
       if (result().empty())
         return;
       // The user cannot have manually selected a match, or the query would have
       // stopped. So the default match must be the desired selection.
       *match = *result().default_match();
@@ skipping 10 matching lines @@
     AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
         UserTextFromDisplayText(view_->GetText()), KeywordIsSelected(), true,
         match, alternate_nav_url);
   }
 }
 
 void OmniboxEditModel::RevertTemporaryText(bool revert_popup) {
   // 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_.
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-  bool notify_instant = is_temporary_text_set_by_instant_;
-#endif
   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;
 
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-  InstantController* instant = GetInstantController();
-  if (instant && notify_instant) {
-    // Normally, popup_model()->ResetToDefaultMatch() will cause the view text
-    // to be updated. In Instant Extended mode however, the popup_model() 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_model()->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.
-    view_->OnTemporaryTextMaybeChanged(user_text_ + inline_autocomplete_text_,
-        false, false);
-    AutocompleteResult::const_iterator match(result().default_match());
-    instant->OnCancel(match != result().end() ? *match : AutocompleteMatch(),
-                      user_text_,
-                      user_text_ + inline_autocomplete_text_);
-  }
-#endif
   if (revert_popup)
     popup_model()->ResetToDefaultMatch();
   view_->OnRevertTemporaryText();
 }
 
 bool OmniboxEditModel::MaybeAcceptKeywordBySpace(const string16& new_text) {
   size_t keyword_length = new_text.length() - 1;
   return (paste_state_ == NONE) && is_keyword_hint_ && !keyword_.empty() &&
       inline_autocomplete_text_.empty() &&
       (keyword_.length() == keyword_length) &&
@@ skipping 77 matching lines @@
     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();
 }