Omnibox refactor. OmniboxController now holds an AutocompleteMatch.

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 166 matching lines @@
     // NOTE: Be sure and set keyword-related state BEFORE invoking
     // DisplayTextFromUserText(), as its result depends upon this state.
     keyword_ = state.keyword;
     is_keyword_hint_ = state.is_keyword_hint;
     view_->SetUserText(state.user_text,
         DisplayTextFromUserText(state.user_text), false);
     view_->SetInstantSuggestion(state.instant_suggestion);
   }
 }
 
-AutocompleteMatch OmniboxEditModel::CurrentMatch() {
+AutocompleteMatch OmniboxEditModel::CurrentMatch(
+    GURL* alternate_nav_url) const {
+  // If we have a valid match use it. Otherwise get one for the current text.
+  if (omnibox_controller_->current_match().destination_url.is_valid()) {
+    AutocompleteMatch match = omnibox_controller_->current_match();
+    if (alternate_nav_url && AutocompleteMatch::IsSearchType(match.type)) {
+      // Compute the |alternate_nav_url| if needed.
+      *alternate_nav_url = URLFixerUpper::FixupURL(
+          UTF16ToUTF8(match.fill_into_edit), std::string());
+      if (*alternate_nav_url == match.destination_url)
+        *alternate_nav_url = GURL();
+    }
+    return match;
+  }
+
   AutocompleteMatch match;
-  GetInfoForCurrentText(&match, NULL);
+  GetInfoForCurrentText(&match, alternate_nav_url);
   return match;
 }
 
 bool OmniboxEditModel::UpdatePermanentText(const string16& new_permanent_text) {
   // When there's a new URL, and the user is not editing anything or the edit
   // doesn't have focus, we want to revert the edit to show the new URL.  (The
   // common case where the edit doesn't have focus is when the user has started
   // an edit and then abandoned it and clicked a link on the page.)
   //
   // If the page is auto-committing an instant suggestion, however, we generally
@@ skipping 13 matching lines @@
   return visibly_changed_permanent_text;
 }
 
 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::FinalizeInstantQuery(
-    const string16& input_text,
-    const InstantSuggestion& suggestion) {
-// Should only get called for the HTML popup.
-#if defined(HTML_INSTANT_EXTENDED_POPUP)
-  if (!popup_model()->result().empty()) {
-    // When a IME is active and a candidate window is open, we don't show
-    // the omnibox popup, though |result()| may be available.  Thus we check
-    // whether result().empty() or not instead of whether IsOpen() or not.
-    // We need the finalization of instant query when result() is available.
-    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);
-  }
-#endif
-}
-
 void OmniboxEditModel::SetInstantSuggestion(
     const InstantSuggestion& suggestion) {
 // Should only get called for the HTML popup.
 #if defined(HTML_INSTANT_EXTENDED_POPUP)
-  switch (suggestion.behavior) {
-    case INSTANT_COMPLETE_NOW:
-      view_->SetInstantSuggestion(string16());
-      if (!suggestion.text.empty())
-        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;
-    }
-  }
+  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();
   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();
+      CurrentMatch(NULL) : AutocompleteMatch();
 
   AutocompleteActionPredictor::Action recommended_action =
       AutocompleteActionPredictor::ACTION_NONE;
   AutocompleteActionPredictor* action_predictor =
       user_input_in_progress_ ?
       AutocompleteActionPredictorFactory::GetForProfile(profile_) : NULL;
   if (action_predictor) {
     action_predictor->RegisterTransitionalMatches(user_text_, result());
     // Confer with the AutocompleteActionPredictor to determine what action, if
     // any, we should take. Get the recommended action here even if we don't
@@ skipping 21 matching lines @@
         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());
+    omnibox_controller_->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
       // current URL.
       if (current_match.destination_url != PermanentURL())
         delegate_->DoPrerender(current_match);
       break;
     case AutocompleteActionPredictor::ACTION_PRECONNECT:
       omnibox_controller_->DoPreconnect(current_match);
       break;
     case AutocompleteActionPredictor::ACTION_NONE:
       break;
   }
 
   controller_->OnChanged();
 }
 
 void OmniboxEditModel::GetDataForURLExport(GURL* url,
                                            string16* title,
                                            gfx::Image* favicon) {
-  AutocompleteMatch match;
-  GetInfoForCurrentText(&match, NULL);
-  *url = match.destination_url;
+  *url = CurrentMatch(NULL).destination_url;
   if (*url == URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_),
                                       std::string())) {
     *title = controller_->GetTitle();
     *favicon = controller_->GetFavicon();
   }
 }
 
 bool OmniboxEditModel::CurrentTextIsURL() const {
   if (view_->toolbar_model()->WouldReplaceSearchURLWithSearchTerms())
     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.
   if (!user_input_in_progress_)
     return true;
 
-  AutocompleteMatch match;
-  GetInfoForCurrentText(&match, NULL);
-  return !AutocompleteMatch::IsSearchType(match.type);
+  return !AutocompleteMatch::IsSearchType(CurrentMatch(NULL).type);
 }
 
 AutocompleteMatch::Type OmniboxEditModel::CurrentTextType() const {
-  AutocompleteMatch match;
-  GetInfoForCurrentText(&match, NULL);
-  return match.type;
+  return CurrentMatch(NULL).type;
 }
 
 void OmniboxEditModel::AdjustTextForCopy(int sel_min,
                                          bool is_all_selected,
                                          string16* text,
                                          GURL* url,
                                          bool* write_url) {
   *write_url = false;
 
   // Do not adjust if selection did not start at the beginning of the field, or
@@ skipping 137 matching lines @@
 
 bool OmniboxEditModel::IsPasteAndSearch(const string16& text) const {
   AutocompleteMatch match;
   ClassifyStringForPasteAndGo(text, &match, NULL);
   return AutocompleteMatch::IsSearchType(match.type);
 }
 
 void OmniboxEditModel::AcceptInput(WindowOpenDisposition disposition,
                                    bool for_drop) {
   // Get the URL and transition type for the selected entry.
-  AutocompleteMatch match;
   GURL alternate_nav_url;
-  GetInfoForCurrentText(&match, &alternate_nav_url);
+  AutocompleteMatch match = CurrentMatch(&alternate_nav_url);
 
   // If CTRL is down it means the user wants to append ".com" to the text he
   // typed. If we can successfully generate a URL_WHAT_YOU_TYPED match doing
   // that, then we use this. These matches are marked as generated by the
   // HistoryURLProvider so we only generate them if this provider is present.
   if (control_key_state_ == DOWN_WITHOUT_CHANGE && !KeywordIsSelected() &&
       autocomplete_controller()->history_url_provider()) {
     // Generate a new AutocompleteInput, copying the latest one but using "com"
     // as the desired TLD. Then use this autocomplete input to generate a
     // URL_WHAT_YOU_TYPED AutocompleteMatch. Note that using the most recent
@@ skipping 59 matching lines @@
   if (popup_model()->IsOpen()) {
     const base::TimeTicks& now(base::TimeTicks::Now());
     base::TimeDelta elapsed_time_since_user_first_modified_omnibox(
         now - time_user_first_modified_omnibox_);
     base::TimeDelta elapsed_time_since_last_change_to_default_match(
         now - autocomplete_controller()->last_time_default_match_changed());
     // These elapsed times don't really make sense for ZeroSuggest matches
     // (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->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST) {
+    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
         elapsed_time_since_last_change_to_default_match,
         result());
-    DCHECK(user_input_in_progress_ ||
-           match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST)
+
+    DCHECK(user_input_in_progress_ || (match.provider &&
+           match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST))
         << "We didn't get here through the expected series of calls. "
         << "time_user_first_modified_omnibox_ is not set correctly and other "
-        << "things may be wrong. Match provider: " << match.provider->GetName();
+        << "things may be wrong. Match provider: "
+        << (match.provider ? match.provider->GetName() : "NULL");
     DCHECK(log.elapsed_time_since_user_first_modified_omnibox >=
            log.elapsed_time_since_last_change_to_default_match)
         << "We should've got the notification that the user modified the "
         << "omnibox text at same time or before the most recent time the "
         << "default match changed.";
+
     if (index != OmniboxPopupModel::kNoMatch)
       log.selected_index = index;
     if (match.inline_autocomplete_offset != string16::npos) {
       DCHECK_GE(match.fill_into_edit.length(),
                 match.inline_autocomplete_offset);
       log.completed_length =
           match.fill_into_edit.length() - match.inline_autocomplete_offset;
     }
 
     if ((disposition == CURRENT_TAB) && delegate_->CurrentPageExists()) {
       // If we know the destination is being opened in the current tab,
       // we can easily get the tab ID.  (If it's being opened in a new
       // tab, we don't know the tab ID yet.)
       log.tab_id = delegate_->GetSessionID().id();
     }
     autocomplete_controller()->AddProvidersInfo(&log.providers_info);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
         content::Source<Profile>(profile_),
         content::Details<OmniboxLog>(&log));
     HISTOGRAM_ENUMERATION("Omnibox.EventCount", 1, 2);
   }
 
   TemplateURL* template_url = match.GetTemplateURL(profile_, false);
   if (template_url) {
     if (match.transition == content::PAGE_TRANSITION_KEYWORD) {
       // The user is using a non-substituting keyword or is explicitly in
       // keyword mode.
-
-      AutocompleteMatch current_match;
-      GetInfoForCurrentText(&current_match, NULL);
       const AutocompleteMatch& match = (index == OmniboxPopupModel::kNoMatch) ?
-          current_match : result().match_at(index);
+          CurrentMatch(NULL) : result().match_at(index);
 
       // Don't increment usage count for extension keywords.
       if (delegate_->ProcessExtensionKeyword(template_url, match,
                                              disposition)) {
         if (disposition != NEW_BACKGROUND_TAB)
           view_->RevertAll();
         return;
       }
 
       content::RecordAction(UserMetricsAction("AcceptedKeyword"));
@@ skipping 65 matching lines @@
 
   // 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),
+      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() {
@@ skipping 81 matching lines @@
   // 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;
 }
 
 bool OmniboxEditModel::OnEscapeKeyPressed() {
   if (has_temporary_text_) {
-    AutocompleteMatch match;
-    GetInfoForCurrentText(&match, NULL);
-    if (match.destination_url != original_url_) {
+    if (CurrentMatch(NULL).destination_url != original_url_) {
       RevertTemporaryText(true);
       return true;
     }
   }
 
   // We do not clear the pending entry from the omnibox when a load is first
   // stopped.  If the user presses Escape while stopped, we clear it.
   if (delegate_->CurrentPageExists() && !delegate_->IsLoading()) {
     delegate_->GetNavigationController().DiscardNonCommittedEntries();
     view_->Update(NULL);
@@ skipping 78 matching lines @@
       popup_model()->Move(count);
     }
   }
 }
 
 void OmniboxEditModel::OnPopupDataChanged(
     const string16& text,
     GURL* destination_for_temporary_text_change,
     const string16& keyword,
     bool is_keyword_hint) {
+  // The popup changed its data, the match in the controller is no longer valid.
+  omnibox_controller_->InvalidateCurrentMatch();
+
   // 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_);
   }
@@ skipping 158 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::OnResultChanged(bool default_match_changed) {
+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;
+
+  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 {
+    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_);
+  }
+}
+
+void OmniboxEditModel::OnGrayTextChanged() {
+  view_->SetInstantSuggestion(omnibox_controller_->gray_suggestion());
+}
+
+string16 OmniboxEditModel::GetViewText() const {
+  return view_->GetText();
 }
 
 InstantController* OmniboxEditModel::GetInstantController() const {
   return controller_->GetInstant();
 }
 
 bool OmniboxEditModel::query_in_progress() const {
   return !autocomplete_controller()->done();
 }
 
@@ skipping 240 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();
 }