Instant extended API: Make arrow up/down work.

chrome/browser/ui/omnibox/omnibox_edit_model.cc

 // Copyright (c) 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/format_macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 76 matching lines @@
     : ALLOW_THIS_IN_INITIALIZER_LIST(
         autocomplete_controller_(new AutocompleteController(profile, this,
             AutocompleteClassifier::kDefaultOmniboxProviders))),
       view_(view),
       popup_(NULL),
       controller_(controller),
       has_focus_(false),
       user_input_in_progress_(false),
       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),
       allow_exact_keyword_match_(false) {
 }
 
 OmniboxEditModel::~OmniboxEditModel() {
 }
@@ skipping 51 matching lines @@
 
 GURL OmniboxEditModel::PermanentURL() {
   return URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string());
 }
 
 void OmniboxEditModel::SetUserText(const string16& text) {
   SetInputInProgress(true);
   InternalSetUserText(text);
   paste_state_ = NONE;
   has_temporary_text_ = false;
+  is_temporary_text_set_by_instant_ = false;
 }
 
 void OmniboxEditModel::FinalizeInstantQuery(const string16& input_text,
                                             const string16& suggest_text,
                                             bool skip_inline_autocomplete) {
   if (skip_inline_autocomplete) {
     const string16 final_text = input_text + suggest_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();
     // There may be no providers during testing; guard against that.
     if (search_provider)
       search_provider->FinalizeInstantQuery(input_text, suggest_text);
   }
 }
 
 void OmniboxEditModel::SetSuggestedText(const string16& text,
                                         InstantCompleteBehavior behavior) {
-  if (behavior == INSTANT_COMPLETE_NOW) {
-    if (!text.empty())
-      FinalizeInstantQuery(view_->GetText(), text, false);
-    else
+  switch (behavior) {
+    case INSTANT_COMPLETE_NOW:
+      view_->SetInstantSuggestion(string16(), false);
+      if (!text.empty())
+        FinalizeInstantQuery(view_->GetText(), text, false);
+      break;
+
+    case INSTANT_COMPLETE_DELAYED:
+      // Starts out as gray text (i.e., INSTANT_COMPLETE_NEVER) and animates to
+      // completed blue text by way of CommitSuggestedText().
+      view_->SetInstantSuggestion(text, true);
+      break;
+
+    case INSTANT_COMPLETE_NEVER:
       view_->SetInstantSuggestion(text, false);
-  } else {
-    DCHECK((behavior == INSTANT_COMPLETE_DELAYED) ||
-           (behavior == INSTANT_COMPLETE_NEVER));
-    view_->SetInstantSuggestion(text, behavior == INSTANT_COMPLETE_DELAYED);
+      break;
+
+    case INSTANT_COMPLETE_REPLACE:
+      view_->SetInstantSuggestion(string16(), false);
+      has_temporary_text_ = true;
+      is_temporary_text_set_by_instant_ = true;
+      view_->SetWindowTextAndCaretPos(text, text.size(), false, false);
+      break;
   }
 }
 
 bool OmniboxEditModel::CommitSuggestedText(bool skip_inline_autocomplete) {
   if (!controller_->GetInstant())
     return false;
 
   const string16 suggestion = view_->GetInstantSuggestion();
   if (suggestion.empty())
     return false;
@@ skipping 193 matching lines @@
   NotifySearchTabHelper();
 }
 
 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;
   view_->SetWindowTextAndCaretPos(permanent_text_,
                                   has_focus_ ? permanent_text_.length() : 0,
                                   false, true);
   AutocompleteActionPredictor* action_predictor =
       AutocompleteActionPredictorFactory::GetForProfile(profile_);
   if (action_predictor)
     action_predictor->ClearTransitionalMatches();
 }
 
 void OmniboxEditModel::StartAutocomplete(
@@ skipping 88 matching lines @@
                    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()) {
+    // 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(),
         -1,  // don't yet know tab ID; set later if appropriate
         ClassifyPage(controller_->GetTabContents()->
                      web_contents()->GetURL()),
         base::TimeTicks::Now() - time_user_first_modified_omnibox_,
         0,  // inline autocomplete length; possibly set later
@@ skipping 113 matching lines @@
   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);
 
   content::RecordAction(UserMetricsAction("AcceptedKeywordHint"));
   return true;
 }
 
 void OmniboxEditModel::ClearKeyword(const string16& visible_text) {
   autocomplete_controller_->Stop(false);
@@ skipping 98 matching lines @@
 void OmniboxEditModel::OnControlKeyChanged(bool pressed) {
   // Don't change anything unless the key state is actually toggling.
   if (pressed == (control_key_state_ == UP)) {
     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;
       if (KeywordIsSelected())
         AcceptKeyword();
     }
     if ((old_state != DOWN_WITH_CHANGE) && popup_->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 don't trigger any code that resets paste_state_.
+  // 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.
+  InstantController* instant = controller_->GetInstant();
+  if (instant && instant->OnUpOrDownKeyPressed(count)) {
+    autocomplete_controller_->Stop(false);
+    return;
+  }
 
+  // NOTE: This purposefully doesn't trigger any code that resets paste_state_.
   if (!popup_->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.
@@ skipping 26 matching lines @@
     // |is_keyword_hint_| should always be false if |keyword_| is empty.
     DCHECK(!keyword_.empty() || !is_keyword_hint_);
   }
 
   // Handle changes to temporary text.
   if (destination_for_temporary_text_change != NULL) {
     const bool save_original_selection = !has_temporary_text_;
     if (save_original_selection) {
       // Save the original selection and URL so it can be reverted later.
       has_temporary_text_ = true;
+      is_temporary_text_set_by_instant_ = false;
       original_url_ = *destination_for_temporary_text_change;
       inline_autocomplete_text_.clear();
     }
     if (control_key_state_ == DOWN_WITHOUT_CHANGE) {
       // Arrowing around the popup cancels control-enter.
       control_key_state_ = DOWN_WITH_CHANGE;
       // Now things are a bit screwy: the desired_tld has changed, but if we
       // update the popup, the new order of entries won't match the old, so the
       // user's selection gets screwy; and if we don't update the popup, and the
       // user reverts, then the selected item will be as if control is still
@@ skipping 59 matching lines @@
   } else if (!user_text_changed) {
     return false;
   }
 
   // If the user text has not changed, we do not want to change the model's
   // state associated with the text.  Otherwise, we can get surprising behavior
   // where the autocompleted text unexpectedly reappears, e.g. crbug.com/55983
   if (user_text_changed) {
     InternalSetUserText(UserTextFromDisplayText(new_text));
     has_temporary_text_ = false;
+    is_temporary_text_set_by_instant_ = false;
 
     // Track when the user has deleted text so we won't allow inline
     // autocomplete.
     just_deleted_text_ = just_deleted_text;
   }
 
   const bool no_selection = selection_start == selection_end;
 
   // Update the popup for the change, in the process changing to keyword mode
   // if the user hit space in mid-string after a keyword.
@@ skipping 62 matching lines @@
     popup_->OnResultChanged();
   }
 
   if (popup_->IsOpen()) {
     PopupBoundsChangedTo(popup_->view()->GetTargetBounds());
   } 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;
     PopupBoundsChangedTo(gfx::Rect());
     NotifySearchTabHelper();
   }
 
   if (InstantController* instant = controller_->GetInstant())
     instant->HandleAutocompleteResults(*autocomplete_controller_->providers());
 }
 
 bool OmniboxEditModel::query_in_progress() const {
   return !autocomplete_controller_->done();
@@ skipping 45 matching lines @@
     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 (popup_->IsOpen() || query_in_progress()) {
+  // If there's temporary text and it has been set by Instant, we won't find it
+  // in the popup model, so classify the text anew.
+  if ((popup_->IsOpen() || query_in_progress()) &&
+      !is_temporary_text_set_by_instant_) {
     InfoForCurrentSelection(match, alternate_nav_url);
   } else {
     AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
         UserTextFromDisplayText(view_->GetText()), GetDesiredTLD(),
         KeywordIsSelected(), true, match, alternate_nav_url);
   }
 }
 
 void OmniboxEditModel::RevertTemporaryText(bool revert_popup) {
   // The user typed something, then selected a different item.  Restore the
   // text they typed and change back to the default item.
   // NOTE: This purposefully does not reset paste_state_.
   just_deleted_text_ = false;
   has_temporary_text_ = false;
+  is_temporary_text_set_by_instant_ = false;
   if (revert_popup)
     popup_->ResetToDefaultMatch();
   view_->OnRevertTemporaryText();
 }
 
 bool OmniboxEditModel::MaybeAcceptKeywordBySpace(const string16& new_text) {
   size_t keyword_length = new_text.length() - 1;
   return (paste_state_ == NONE) && is_keyword_hint_ && !keyword_.empty() &&
       inline_autocomplete_text_.empty() &&
       (keyword_.length() == keyword_length) &&
@@ skipping 141 matching lines @@
 }
 
 void OmniboxEditModel::ClassifyStringForPasteAndGo(
     const string16& text,
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   DCHECK(match);
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
       string16(), false, false, match, alternate_nav_url);
 }