Omnibox refactor, introduced 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 116 matching lines @@
       just_deleted_text_(false),
       has_temporary_text_(false),
       is_temporary_text_set_by_instant_(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) {
-  // Use a restricted subset of the autocomplete providers if we're using the
-  // Instant Extended API, as it doesn't support them all.
-  autocomplete_controller_.reset(new AutocompleteController(profile, this,
-      chrome::IsInstantExtendedAPIEnabled() ?
-          AutocompleteClassifier::kInstantExtendedOmniboxProviders :
-          AutocompleteClassifier::kDefaultOmniboxProviders));
+  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
   // text, because it makes little sense to have temporary text when the
   // popup is closed.
@@ skipping 78 matching lines @@
                                             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()) {
     SearchProvider* search_provider =
-        autocomplete_controller_->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);
       SearchProvider* search_provider =
-          autocomplete_controller_->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;
@@ skipping 93 matching lines @@
                                       std::string())) {
     *title = controller_->GetTitle();
     *favicon = controller_->GetFavicon();
   }
 }
 
 bool OmniboxEditModel::UseVerbatimInstant() {
 #if defined(OS_MACOSX)
   // TODO(suzhe): Fix Mac port to display Instant suggest in a separated NSView,
   // so that we can display Instant suggest along with composition text.
-  const AutocompleteInput& input = autocomplete_controller_->input();
+  const AutocompleteInput& input = autocomplete_controller()->input();
   if (input.prevent_inline_autocomplete())
     return true;
 #endif
 
   // The value of input.prevent_inline_autocomplete() is determined by the
   // following conditions:
   // 1. If the caret is at the end of the text.
   // 2. If it's in IME composition mode.
   // We send the caret position to Instant (so it can determine #1 itself), and
   // we use a separated widget for displaying the Instant suggest (so it doesn't
@@ skipping 75 matching lines @@
 }
 
 void OmniboxEditModel::SetInputInProgress(bool in_progress) {
   if (user_input_in_progress_ == in_progress)
     return;
 
   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();
+    autocomplete_controller()->ResetSession();
   }
   controller_->OnInputInProgress(in_progress);
 
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
 }
 
 void OmniboxEditModel::Revert() {
   SetInputInProgress(false);
   paste_state_ = NONE;
   InternalSetUserText(string16());
@@ skipping 38 matching lines @@
     // One example is when user presses Ctrl key while having a highlighted
     // inline autocomplete text.
     // TODO: Rethink how we are going to handle this case to avoid
     // inconsistent behavior when user presses Ctrl key.
     // See http://crbug.com/165961 and http://crbug.com/165968 for more details.
     cursor_position = user_text_.length();
   }
 
   // We don't explicitly clear OmniboxPopupModel::manually_selected_match, as
   // Start ends up invoking OmniboxPopupModel::OnResultChanged which clears it.
-  autocomplete_controller_->Start(AutocompleteInput(
+  autocomplete_controller()->Start(AutocompleteInput(
       user_text_, cursor_position, string16(), GURL(),
       prevent_inline_autocomplete || just_deleted_text_ ||
       (has_selected_text && inline_autocomplete_text_.empty()) ||
       (paste_state_ != NONE), keyword_is_selected,
       keyword_is_selected || allow_exact_keyword_match_,
       AutocompleteInput::ALL_MATCHES));
 }
 
 void OmniboxEditModel::StopAutocomplete() {
-  autocomplete_controller_->Stop(true);
+  autocomplete_controller()->Stop(true);
 }
 
 bool OmniboxEditModel::CanPasteAndGo(const string16& text) const {
   if (!view_->command_updater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
     return false;
 
   AutocompleteMatch match;
   ClassifyStringForPasteAndGo(text, &match, NULL);
   return match.destination_url.is_valid();
 }
@@ skipping 19 matching lines @@
   // Get the URL and transition type for the selected entry.
   AutocompleteMatch match;
   GURL alternate_nav_url;
   GetInfoForCurrentText(&match, &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()) {
+      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
     // input instead of the currently visible text means we'll ignore any
     // visible inline autocompletion: if a user types "foo" and is autocompleted
     // to "foodnetwork.com", ctrl-enter will  navigate to "foo.com", not
     // "foodnetwork.com".  At the time of writing, this behavior matches
     // Internet Explorer, but not Firefox.
-    const AutocompleteInput& old_input = autocomplete_controller_->input();
+    const AutocompleteInput& old_input = autocomplete_controller()->input();
     AutocompleteInput input(
       old_input.text(), old_input.cursor_position(), ASCIIToUTF16("com"),
       GURL(), old_input.prevent_inline_autocomplete(),
       old_input.prefer_keyword(), old_input.allow_exact_keyword_match(),
       old_input.matches_requested());
     AutocompleteMatch url_match = HistoryURLProvider::SuggestExactInput(
-        autocomplete_controller_->history_url_provider(), input, true);
+        autocomplete_controller()->history_url_provider(), input, true);
 
     if (url_match.destination_url.is_valid()) {
       // We have a valid URL, we use this newly generated AutocompleteMatch.
       match = url_match;
       alternate_nav_url = GURL();
     }
   }
 
   if (!match.destination_url.is_valid())
     return;
@@ skipping 30 matching lines @@
 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()) {
     const base::TimeTicks& now(base::TimeTicks::Now());
     // TODO(sreeram): Handle is_temporary_text_set_by_instant_ correctly.
     AutocompleteLog log(
-        autocomplete_controller_->input().text(),
+        autocomplete_controller()->input().text(),
         just_deleted_text_,
-        autocomplete_controller_->input().type(),
+        autocomplete_controller()->input().type(),
         popup_->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(),
+        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. "
         << "time_user_first_modified_omnibox_ is not set correctly and other "
         << "things may be wrong. Match provider: " << match.provider->GetName();
     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);
+    autocomplete_controller()->AddProvidersInfo(&log.providers_info);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
         content::Source<Profile>(profile_),
         content::Details<AutocompleteLog>(&log));
     HISTOGRAM_ENUMERATION("Omnibox.EventCount", 1, 2);
   }
 
   TemplateURL* template_url = match.GetTemplateURL(profile_, false);
   if (template_url) {
     if (match.transition == content::PAGE_TRANSITION_KEYWORD) {
@@ skipping 34 matching lines @@
   if (disposition != NEW_BACKGROUND_TAB) {
     base::AutoReset<bool> tmp(&in_revert_, true);
     view_->RevertAll();  // Revert the box to its unedited state
   }
 
   if (match.type == AutocompleteMatch::EXTENSION_APP) {
     ExtensionAppProvider::LaunchAppFromOmnibox(match, profile_, disposition);
   } else {
     base::TimeDelta query_formulation_time =
         base::TimeTicks::Now() - time_user_first_modified_omnibox_;
-    const GURL destination_url = autocomplete_controller_->
+    const GURL destination_url = autocomplete_controller()->
         GetDestinationURL(match, query_formulation_time);
 
     // If running with instant, notify the instant controller that a navigation
     // is about to take place if we are navigating to a URL. This can be
     // determined by inspecting the transition type. To ensure that this is only
     // done on Enter key press, check that the disposition is CURRENT_TAB. This
     // is the same heuristic used by BrowserInstantController::OpenInstant
     if (match.transition == content::PAGE_TRANSITION_TYPED &&
         disposition == CURRENT_TAB) {
       InstantController* instant = controller_->GetInstant();
       if (instant)
         instant->OmniboxNavigateToURL();
     }
 
     // This calls RevertAll again.
     base::AutoReset<bool> tmp(&in_revert_, true);
     controller_->OnAutocompleteAccept(destination_url, disposition,
                                       match.transition, alternate_nav_url);
   }
 
   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);
+  autocomplete_controller()->Stop(false);
   is_keyword_hint_ = false;
 
   if (popup_->IsOpen())
     popup_->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;
   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::ClearKeyword(const string16& visible_text) {
-  autocomplete_controller_->Stop(false);
+  autocomplete_controller()->Stop(false);
   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()) {
     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();
+  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_);
+    autocomplete_controller()->StartZeroSuggest(delegate_->GetURL(),
+                                                user_text_);
   }
 
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
 }
 
 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();
+  autocomplete_controller()->StopZeroSuggest();
   delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
 }
 
 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 76 matching lines @@
       // 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);
+      autocomplete_controller()->Stop(false);
     } else {
       // The popup is open, so the user should be able to interact with it
       // normally.
       popup_->Move(count);
     }
   }
 }
 
 void OmniboxEditModel::OnPopupDataChanged(
     const string16& text,
@@ skipping 212 matching lines @@
   } 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()->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;
     OnPopupBoundsChanged(gfx::Rect());
     delegate_->NotifySearchTabHelper(user_input_in_progress_, !in_revert_);
   }
 }
 
 bool OmniboxEditModel::query_in_progress() const {
-  return !autocomplete_controller_->done();
+  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();
@@ skipping 11 matching lines @@
 }
 
 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()) {
+  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());
@@ skipping 83 matching lines @@
                         old_text, space_position,
                         old_text.length() - space_position)) {
     return false;
   }
 
   // Then check if the text before the inserted space matches a keyword.
   string16 keyword;
   TrimWhitespace(new_text.substr(0, space_position), TRIM_LEADING, &keyword);
   // TODO(sreeram): Once the Instant extended API supports keywords properly,
   // keyword_provider() should never be NULL. Remove that clause.
-  return !keyword.empty() && autocomplete_controller_->keyword_provider() &&
-      !autocomplete_controller_->keyword_provider()->
+  return !keyword.empty() && autocomplete_controller()->keyword_provider() &&
+      !autocomplete_controller()->keyword_provider()->
           GetKeywordForText(keyword).empty();
 }
 
 bool OmniboxEditModel::DoInstant(const AutocompleteMatch& match) {
   InstantController* instant = controller_->GetInstant();
   if (!instant || in_revert_)
     return false;
 
   // Don't call Update() if the change is a result of a
   // INSTANT_COMPLETE_REPLACE instant suggestion.
   if (has_temporary_text_ && is_temporary_text_set_by_instant_)
     return false;
 
   // The two pieces of text we want to send Instant, viz., what the user has
   // typed, and the full omnibox text including any inline autocompletion.
   string16 user_text = has_temporary_text_ ?
       match.fill_into_edit : DisplayTextFromUserText(user_text_);
   string16 full_text = view_->GetText();
 
   // Remove "?" if we're in forced query mode.
   AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-      autocomplete_controller_->input().type(), &user_text);
+      autocomplete_controller()->input().type(), &user_text);
   AutocompleteInput::RemoveForcedQueryStringIfNecessary(
-      autocomplete_controller_->input().type(), &full_text);
+      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(),
       in_escape_handler_, KeywordIsSelected());
 }
 
 void OmniboxEditModel::DoPreconnect(const AutocompleteMatch& match) {
@@ skipping 56 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();
 }