Omnibox refactor, moved OnResultChanged to OmniboxController

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 102 matching lines @@
 OmniboxEditModel::State::~State() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OmniboxEditModel
 
 OmniboxEditModel::OmniboxEditModel(OmniboxView* view,
                                    OmniboxEditController* controller,
                                    Profile* profile)
     : view_(view),
-      popup_(NULL),
       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),
       is_instant_temporary_text_a_search_query_(false),
       paste_state_(NONE),
       control_key_state_(UP),
       is_keyword_hint_(false),
@@ skipping 92 matching lines @@
 
 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_->IsOpen()) {
+  } else 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);
       break;
 
     case INSTANT_COMPLETE_NEVER: {
       DCHECK_EQ(INSTANT_SUGGESTION_SEARCH, suggestion.type);
       view_->SetInstantSuggestion(suggestion.text);
-      autocomplete_controller()->search_provider()->ClearInstantSuggestion();
+      SearchProvider* search_provider =
+          autocomplete_controller()->search_provider();
+      if (search_provider)
+        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;
       is_instant_temporary_text_a_search_query_ =
           suggestion.type == INSTANT_SUGGESTION_SEARCH;
@@ skipping 67 matching lines @@
       // 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.
       if (current_match.destination_url != PermanentURL())
         delegate_->DoPrerender(current_match);
       break;
     case AutocompleteActionPredictor::ACTION_PRECONNECT:
-      DoPreconnect(current_match);
+      omnibox_controller_->DoPreconnect(current_match);
       break;
     case AutocompleteActionPredictor::ACTION_NONE:
       break;
   }
 
   controller_->OnChanged();
 }
 
 void OmniboxEditModel::GetDataForURLExport(GURL* url,
                                            string16* title,
@@ skipping 18 matching lines @@
 #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_->selected_line() != 0 ||
+  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
@@ skipping 92 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 {
-  ClearPopupKeywordMode();
+  omnibox_controller_->ClearPopupKeywordMode();
 
   bool keyword_is_selected = KeywordIsSelected();
-  popup_->SetHoveredLine(OmniboxPopupModel::kNoMatch);
+  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 =
@@ skipping 121 matching lines @@
   view_->OpenMatch(match, disposition, alternate_nav_url,
                    OmniboxPopupModel::kNoMatch);
 }
 
 void OmniboxEditModel::OpenMatch(const AutocompleteMatch& match,
                                  WindowOpenDisposition disposition,
                                  const GURL& alternate_nav_url,
                                  size_t index) {
   // We only care about cases where there is a selection (i.e. the popup is
   // open).
-  if (popup_->IsOpen()) {
+  if (popup_model()->IsOpen()) {
     const base::TimeTicks& now(base::TimeTicks::Now());
     // TODO(sreeram): Handle is_temporary_text_set_by_instant_ correctly.
     AutocompleteLog log(
         autocomplete_controller()->input().text(),
         just_deleted_text_,
         autocomplete_controller()->input().type(),
-        popup_->selected_line(),
+        popup_model()->selected_line(),
         -1,  // don't yet know tab ID; set later if appropriate
         delegate_->CurrentPageExists() ? ClassifyPage(delegate_->GetURL()) :
             metrics::OmniboxEventProto_PageClassification_OTHER,
         now - time_user_first_modified_omnibox_,
         string16::npos,  // completed_length; possibly set later
         now - autocomplete_controller()->last_time_default_match_changed(),
         result());
     DCHECK(user_input_in_progress_ ||
            match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST)
         << "We didn't get here through the expected series of calls. "
@@ skipping 98 matching lines @@
   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_->IsOpen())
-    popup_->SetSelectedLineState(OmniboxPopupModel::KEYWORD);
+  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;
   is_instant_temporary_text_a_search_query_ = false;
   view_->OnTemporaryTextMaybeChanged(
       DisplayTextFromUserText(CurrentMatch().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;
+  OnPopupBoundsChanged(gfx::Rect());
+  delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
+}
+
 void OmniboxEditModel::ClearKeyword(const string16& visible_text) {
   autocomplete_controller()->Stop(false);
-  ClearPopupKeywordMode();
+  omnibox_controller_->ClearPopupKeywordMode();
 
   const string16 window_text(keyword_ + visible_text);
 
   // Only reset the result if the edit text has changed since the
   // keyword was accepted, or if the popup is closed.
-  if (just_deleted_text_ || !visible_text.empty() || !popup_->IsOpen()) {
+  if (just_deleted_text_ || !visible_text.empty() || !popup_model()->IsOpen()) {
     view_->OnBeforePossibleChange();
     view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length(),
         false, false);
     keyword_.clear();
     is_keyword_hint_ = false;
     view_->OnAfterPossibleChange();
     just_deleted_text_ = true;  // OnAfterPossibleChange() fails to clear this
                                 // since the edit contents have actually grown
                                 // longer.
   } else {
     is_keyword_hint_ = true;
     view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length(),
         false, true);
   }
 }
 
-const AutocompleteResult& OmniboxEditModel::result() const {
-  return autocomplete_controller()->result();
-}
-
 void OmniboxEditModel::OnSetFocus(bool control_down) {
   // If the omnibox lost focus while the caret was hidden and then regained
   // focus, OnSetFocus() is called and should restore visibility. Note that
   // focus can be regained without an accompanying call to
   // OmniboxView::SetFocus(), e.g. by tabbing in.
   SetFocusState(OMNIBOX_FOCUS_VISIBLE, OMNIBOX_FOCUS_CHANGE_EXPLICIT);
   control_key_state_ = control_down ? DOWN_WITHOUT_CHANGE : UP;
 
   if (delegate_->CurrentPageExists()) {
     // TODO(jered): We may want to merge this into Start() and just call that
@@ skipping 81 matching lines @@
     ControlKeyState old_state = control_key_state_;
     control_key_state_ = pressed ? DOWN_WITHOUT_CHANGE : UP;
     if ((control_key_state_ == DOWN_WITHOUT_CHANGE) && has_temporary_text_) {
       // Arrowing down and then hitting control accepts the temporary text as
       // the input text.
       InternalSetUserText(UserTextFromDisplayText(view_->GetText()));
       has_temporary_text_ = false;
       is_temporary_text_set_by_instant_ = false;
       is_instant_temporary_text_a_search_query_ = false;
     }
-    if ((old_state != DOWN_WITH_CHANGE) && popup_->IsOpen()) {
+    if ((old_state != DOWN_WITH_CHANGE) && popup_model()->IsOpen()) {
       // Autocomplete history provider results may change, so refresh the
       // popup.  This will force user_input_in_progress_ to true, but if the
       // popup is open, that should have already been the case.
       view_->UpdatePopup();
     }
   }
 }
 
 void OmniboxEditModel::OnUpOrDownKeyPressed(int count) {
   // NOTE: This purposefully doesn't trigger any code that resets paste_state_.
-  if (!popup_->IsOpen()) {
+  if (!popup_model()->IsOpen()) {
     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
       // to interact with the popup, changing the permanent_text_ shouldn't
       // change the displayed text.
       // Note: This does not force the popup to open immediately.
       // 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();
     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_->Move(count);
+      popup_model()->Move(count);
     }
   }
 }
 
 void OmniboxEditModel::OnPopupDataChanged(
     const string16& text,
     GURL* destination_for_temporary_text_change,
     const string16& keyword,
     bool is_keyword_hint) {
+  DLOG(ERROR) << "A";

[Mathieu, 2013/05/03 19:09:02]

remove

[beaudoin, 2013/05/04 03:06:51]

/facepalm. :)

Done.

   // Update keyword/hint-related local state.
   bool keyword_state_changed = (keyword_ != keyword) ||
       ((is_keyword_hint_ != is_keyword_hint) && !keyword.empty());
   if (keyword_state_changed) {
     keyword_ = keyword;
     is_keyword_hint_ = is_keyword_hint;
 
     // |is_keyword_hint_| should always be false if |keyword_| is empty.
     DCHECK(!keyword_.empty() || !is_keyword_hint_);
   }
 
+  DLOG(ERROR) << "B";
   // 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;
       is_instant_temporary_text_a_search_query_ = false;
       original_url_ = *destination_for_temporary_text_change;
       inline_autocomplete_text_.clear();
     }
+    DLOG(ERROR) << "C";
     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
       // pressed, even though maybe it isn't any more.  There is no obvious
       // right answer here :(
     }
+    DLOG(ERROR) << "D";
     view_->OnTemporaryTextMaybeChanged(DisplayTextFromUserText(text),
                                        save_original_selection, true);
     return;
   }
+  DLOG(ERROR) << "E: " << keyword_state_changed;
 
   bool call_controller_onchanged = true;
   inline_autocomplete_text_ = text;
 
   if (keyword_state_changed && KeywordIsSelected()) {
     // If we reach here, the user most likely entered keyword mode by inserting
     // a space between a keyword name and a search string (as pressing space or
     // tab after the keyword name alone would have been be handled in
     // MaybeAcceptKeywordBySpace() by calling AcceptKeyword(), which won't reach
     // here).  In this case, we don't want to call
     // OnInlineAutocompleteTextMaybeChanged() as normal, because that will
     // correctly change the text (to the search string alone) but move the caret
     // to the end of the string; instead we want the caret at the start of the
     // search string since that's where it was in the original input.  So we set
     // the text and caret position directly.
     //
     // It may also be possible to reach here if we're reverting from having
     // temporary text back to a default match that's a keyword search, but in
     // that case the RevertTemporaryText() call below will reset the caret or
     // selection correctly so the caret positioning we do here won't matter.
+    DLOG(ERROR) << "F";
     view_->SetWindowTextAndCaretPos(DisplayTextFromUserText(user_text_), 0,
                                                             false, false);
   } else if (view_->OnInlineAutocompleteTextMaybeChanged(
              DisplayTextFromUserText(user_text_ + inline_autocomplete_text_),
              DisplayTextFromUserText(user_text_).length())) {
+    DLOG(ERROR) << "G";
     call_controller_onchanged = false;
   }
 
   // If |has_temporary_text_| is true, then we previously had a manual selection
   // but now don't (or |destination_for_temporary_text_change| would have been
   // non-NULL). This can happen when deleting the selected item in the popup.
   // In this case, we've already reverted the popup to the default match, so we
   // need to revert ourselves as well.
+  DLOG(ERROR) << "H";
   if (has_temporary_text_) {
     RevertTemporaryText(false);
     call_controller_onchanged = false;
   }
 
+  DLOG(ERROR) << "I";
   // We need to invoke OnChanged in case the destination url changed (as could
   // happen when control is toggled).
   if (call_controller_onchanged)
     OnChanged();
 }
 
 bool OmniboxEditModel::OnAfterPossibleChange(const string16& old_text,
                                              const string16& new_text,
                                              size_t selection_start,
                                              size_t selection_end,
@@ skipping 17 matching lines @@
   // Modifying the selection counts as accepting the autocompleted text.
   const bool user_text_changed =
       text_differs || (selection_differs && !inline_autocomplete_text_.empty());
 
   // If something has changed while the control key is down, prevent
   // "ctrl-enter" until the control key is released.  When we do this, we need
   // to update the popup if it's open, since the desired_tld will have changed.
   if ((text_differs || selection_differs) &&
       (control_key_state_ == DOWN_WITHOUT_CHANGE)) {
     control_key_state_ = DOWN_WITH_CHANGE;
-    if (!text_differs && !popup_->IsOpen())
+    if (!text_differs && !popup_model()->IsOpen())
       return false;  // Don't open the popup for no reason.
   } 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));
@@ skipping 51 matching lines @@
            MaybeAcceptKeywordBySpace(user_text_));
 }
 
 void OmniboxEditModel::OnPopupBoundsChanged(const gfx::Rect& bounds) {
   InstantController* instant = controller_->GetInstant();
   if (instant)
     instant->SetPopupBounds(bounds);
 }
 
 void OmniboxEditModel::OnResultChanged(bool default_match_changed) {
-  const bool was_open = popup_->IsOpen();
-  if (default_match_changed) {
-    string16 inline_autocomplete_text;
-    string16 keyword;
-    bool is_keyword_hint = false;
-    const AutocompleteResult& result = this->result();
-    const AutocompleteResult::const_iterator match(result.default_match());
-    if (match != result.end()) {
-      if ((match->inline_autocomplete_offset != string16::npos) &&
-          (match->inline_autocomplete_offset <
-           match->fill_into_edit.length())) {
-        inline_autocomplete_text =
-            match->fill_into_edit.substr(match->inline_autocomplete_offset);
-      }
-
-      if (!prerender::IsOmniboxEnabled(profile_))
-        DoPreconnect(*match);
-
-      // We could prefetch the alternate nav URL, if any, but because there
-      // can be many of these as a user types an initial series of characters,
-      // the OS DNS cache could suffer eviction problems for minimal gain.
-
-      match->GetKeywordUIState(profile_, &keyword, &is_keyword_hint);
-    }
-
-    popup_->OnResultChanged();
-    OnPopupDataChanged(inline_autocomplete_text, NULL, keyword,
-                       is_keyword_hint);
-  } else {
-    popup_->OnResultChanged();
-  }
-
-  if (popup_->IsOpen()) {
-    OnPopupBoundsChanged(popup_->view()->GetTargetBounds());
-
-    InstantController* instant = controller_->GetInstant();
-    if (instant && !in_revert_) {
-      instant->HandleAutocompleteResults(
-          *autocomplete_controller()->providers());
-    }
-  } else if (was_open) {
-    // Accepts the temporary text as the user text, because it makes little
-    // sense to have temporary text when the popup is closed.
-    InternalSetUserText(UserTextFromDisplayText(view_->GetText()));
-    has_temporary_text_ = false;
-    is_temporary_text_set_by_instant_ = false;
-    is_instant_temporary_text_a_search_query_ = false;
-    OnPopupBoundsChanged(gfx::Rect());
-    delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
-  }
 }
 
 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 {
-  if (popup_->IsOpen() &&
-      popup_->selected_line_state() == OmniboxPopupModel::KEYWORD)
-    popup_->SetSelectedLineState(OmniboxPopupModel::NORMAL);
-}
-
 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::InfoForCurrentSelection(AutocompleteMatch* match,
-                                               GURL* alternate_nav_url) const {
-  DCHECK(match != NULL);
-  const AutocompleteResult& result = this->result();
-  if (!autocomplete_controller()->done()) {
-    // 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();
-  } else {
-    CHECK(popup_->IsOpen());
-    // If there are no results, the popup should be closed (so we should have
-    // failed the CHECK above), and URLsForDefaultMatch() should have been
-    // called instead.
-    CHECK(!result.empty());
-    CHECK(popup_->selected_line() < result.size());
-    *match = result.match_at(popup_->selected_line());
-  }
-  if (alternate_nav_url && popup_->manually_selected_match().empty())
-    *alternate_nav_url = result.alternate_nav_url();
-}
-
 void OmniboxEditModel::GetInfoForCurrentText(AutocompleteMatch* match,
                                              GURL* alternate_nav_url) const {
   // 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 (is_temporary_text_set_by_instant_) {
-    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(profile_,
-            autocomplete_controller()->search_provider(), input, text, text, 0,
-            AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
-            TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, false,
-            default_provider->keyword());
-      } 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);
-    }
-  } else if (popup_->IsOpen() || query_in_progress()) {
+  // in the popup model, so classify the text anew.
+  if ((popup_model()->IsOpen() || query_in_progress()) &&
+      !is_temporary_text_set_by_instant_) {
     InfoForCurrentSelection(match, alternate_nav_url);
   } else {
     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
@@ skipping 17 matching lines @@
     // 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_);
   }
   if (revert_popup)
-    popup_->ResetToDefaultMatch();
+    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) &&
       IsSpaceCharForAcceptingKeyword(new_text[keyword_length]) &&
       !new_text.compare(0, keyword_length, keyword_, 0, keyword_length) &&
@@ skipping 50 matching lines @@
   // 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_->IsOpen(),
+      UseVerbatimInstant(), user_input_in_progress_, popup_model()->IsOpen(),
       in_escape_handler_, KeywordIsSelected());
 }
 
-void OmniboxEditModel::DoPreconnect(const AutocompleteMatch& match) {
-  if (!match.destination_url.SchemeIs(extensions::kExtensionScheme)) {
-    // Warm up DNS Prefetch cache, or preconnect to a search service.
-    UMA_HISTOGRAM_ENUMERATION("Autocomplete.MatchType", match.type,
-                              AutocompleteMatch::NUM_TYPES);
-    if (profile_->GetNetworkPredictor()) {
-      profile_->GetNetworkPredictor()->AnticipateOmniboxUrl(
-          match.destination_url,
-          AutocompleteActionPredictor::IsPreconnectable(match));
-    }
-    // We could prefetch the alternate nav URL, if any, but because there
-    // can be many of these as a user types an initial series of characters,
-    // the OS DNS cache could suffer eviction problems for minimal gain.
-  }
-}
-
 //  static
 bool OmniboxEditModel::IsSpaceCharForAcceptingKeyword(wchar_t c) {
   switch (c) {
     case 0x0020:  // Space
     case 0x3000:  // Ideographic Space
       return true;
     default:
       return false;
   }
 }
@@ skipping 31 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();
 }