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 104 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),
       selected_instant_autocomplete_match_index_(OmniboxPopupModel::kNoMatch),
       is_instant_temporary_text_a_search_query_(false),
       paste_state_(NONE),
       control_key_state_(UP),
@@ skipping 94 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) {
@@ skipping 91 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 69 matching lines @@
 
   user_input_in_progress_ = in_progress;
   if (user_input_in_progress_) {
     time_user_first_modified_omnibox_ = base::TimeTicks::Now();
     content::RecordAction(content::UserMetricsAction("OmniboxInputInProgress"));
     autocomplete_controller()->ResetSession();
   }
   controller_->OnInputInProgress(in_progress);
 
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_,
-                                   popup_->IsOpen(), user_text_.empty());
+                                   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(
     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 134 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;
   selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
   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;
+  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);
-  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
     // here rather than having a special entry point for zero-suggest.  Note
     // that we avoid PermanentURL() here because it's not guaranteed to give us
     // the actual underlying current URL, e.g. if we're on the NTP and the
     // |permanent_text_| is empty.
     autocomplete_controller()->StartZeroSuggest(delegate_->GetURL(),
                                                 user_text_);
   }
 
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_,
-                                   popup_->IsOpen(), user_text_.empty());
+                                   popup_model()->IsOpen(), user_text_.empty());
 }
 
 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();
   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_->IsOpen(), user_text_.empty());
+                                   popup_model()->IsOpen(), user_text_.empty());
 }
 
 void OmniboxEditModel::OnKillFocus() {
   // TODO(samarth): determine if it is safe to move the call to
   // OmniboxFocusChanged() from OnWillKillFocus() to here, which would let us
   // just call SetFocusState() to handle the state change.
   focus_state_ = OMNIBOX_FOCUS_NONE;
   control_key_state_ = UP;
   paste_state_ = NONE;
 }
@@ skipping 42 matching lines @@
     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;
       selected_instant_autocomplete_match_index_ = OmniboxPopupModel::kNoMatch;
       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) {
   // Update keyword/hint-related local state.
@@ skipping 101 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 45 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::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(),
-          autocomplete_controller()->result());
-    }
-  } 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;
-    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_->IsOpen(), user_text_.empty());
-  }
 }
 
 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::GetInfoForCurrentText(AutocompleteMatch* match,
@@ skipping 57 matching lines @@
           // |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()) {
+  } 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();
     } else {
       // If there are no results, the popup should be closed, so we shouldn't
       // have gotten here.
       CHECK(!result().empty());
-      CHECK(popup_->selected_line() < result().size());
-      *match = result().match_at(popup_->selected_line());
+      CHECK(popup_model()->selected_line() < result().size());
+      *match = result().match_at(popup_model()->selected_line());
     }
-    if (alternate_nav_url && popup_->manually_selected_match().empty())
+    if (alternate_nav_url && popup_model()->manually_selected_match().empty())
       *alternate_nav_url = result().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 18 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,
-                              AutocompleteMatchType::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();
 }