Accept keyword by pressing space.

chrome/browser/autocomplete/autocomplete_edit.cc

 // Copyright (c) 2011 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/autocomplete/autocomplete_edit.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/metrics/histogram.h"
@@ skipping 27 matching lines @@
 
 AutocompleteEditController::~AutocompleteEditController() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditModel::State
 
 AutocompleteEditModel::State::State(bool user_input_in_progress,
                                     const std::wstring& user_text,
                                     const std::wstring& keyword,
-                                    bool is_keyword_hint,
-                                    KeywordUIState keyword_ui_state)
+                                    bool is_keyword_hint)
     : user_input_in_progress(user_input_in_progress),
       user_text(user_text),
       keyword(keyword),
-      is_keyword_hint(is_keyword_hint),
-      keyword_ui_state(keyword_ui_state) {
+      is_keyword_hint(is_keyword_hint) {
 }
 
 AutocompleteEditModel::State::~State() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditModel
 
 AutocompleteEditModel::AutocompleteEditModel(
     AutocompleteEditView* view,
     AutocompleteEditController* controller,
     Profile* profile)
     : view_(view),
       popup_(NULL),
       controller_(controller),
       has_focus_(false),
       user_input_in_progress_(false),
       just_deleted_text_(false),
       has_temporary_text_(false),
-      original_keyword_ui_state_(NORMAL),
       paste_state_(NONE),
       control_key_state_(UP),
       is_keyword_hint_(false),
-      keyword_ui_state_(NORMAL),
       paste_and_go_transition_(PageTransition::TYPED),
       profile_(profile) {
 }
 
 AutocompleteEditModel::~AutocompleteEditModel() {
 }
 
 void AutocompleteEditModel::SetPopupModel(AutocompletePopupModel* popup_model) {
   popup_ = popup_model;
   registrar_.Add(this,
@@ skipping 18 matching lines @@
     // on switching back, typing will "just work").
     const std::wstring user_text(UserTextFromDisplayText(view_->GetText()));
     if (user_text.empty()) {
       view_->RevertAll();
       view_->SelectAll(true);
     } else {
       InternalSetUserText(user_text);
     }
   }
 
-  return State(user_input_in_progress_, user_text_, keyword_, is_keyword_hint_,
-               keyword_ui_state_);
+  return State(user_input_in_progress_, user_text_, keyword_, is_keyword_hint_);
 }
 
 void AutocompleteEditModel::RestoreState(const State& state) {
   // Restore any user editing.
   if (state.user_input_in_progress) {
     // 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;
-    keyword_ui_state_ = state.keyword_ui_state;
     view_->SetUserText(state.user_text,
         DisplayTextFromUserText(state.user_text), false);
   }
 }
 
 AutocompleteMatch AutocompleteEditModel::CurrentMatch() {
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   return match;
 }
@@ skipping 150 matching lines @@
   user_input_in_progress_ = in_progress;
   controller_->OnInputInProgress(in_progress);
 }
 
 void AutocompleteEditModel::Revert() {
   SetInputInProgress(false);
   paste_state_ = NONE;
   InternalSetUserText(std::wstring());
   keyword_.clear();
   is_keyword_hint_ = false;
-  keyword_ui_state_ = NORMAL;
   has_temporary_text_ = false;
   view_->SetWindowTextAndCaretPos(permanent_text_,
                                   has_focus_ ? permanent_text_.length() : 0);
 }
 
 void AutocompleteEditModel::StartAutocomplete(
     bool has_selected_text,
     bool prevent_inline_autocomplete) const {
+  bool keyword_is_selected = KeywordIsSelected();
   popup_->StartAutocomplete(user_text_, GetDesiredTLD(),
       prevent_inline_autocomplete || just_deleted_text_ ||
       (has_selected_text && inline_autocomplete_text_.empty()) ||
-      (paste_state_ != NONE), keyword_ui_state_ == KEYWORD,
-      keyword_ui_state_ != NO_KEYWORD);
+      (paste_state_ == REPLACED_ALL), keyword_is_selected, keyword_is_selected);

[Peter Kasting, 2011/01/20 00:04:22]

Let's go ahead and leave the check here as "paste_state_ != NONE" so that we
prevent autocompletion immediately after any type of paste.

[James Su, 2011/01/20 06:49:31]

Done.

 }
 
 bool AutocompleteEditModel::CanPasteAndGo(const std::wstring& text) const {
   if (!view_->GetCommandUpdater()->IsCommandEnabled(IDC_OPEN_CURRENT_URL))
     return false;
 
   AutocompleteMatch match;
   profile_->GetAutocompleteClassifier()->Classify(text, std::wstring(), false,
       &match, &paste_and_go_alternate_nav_url_);
   paste_and_go_url_ = match.destination_url;
@@ skipping 26 matching lines @@
     // When the user hit enter on the existing permanent URL, treat it like a
     // reload for scoring purposes.  We could detect this by just checking
     // user_input_in_progress_, but it seems better to treat "edits" that end
     // up leaving the URL unchanged (e.g. deleting the last character and then
     // retyping it) as reloads too.  We exclude non-TYPED transitions because if
     // the transition is GENERATED, the user input something that looked
     // different from the current URL, even if it wound up at the same place
     // (e.g. manually retyping the same search query), and it seems wrong to
     // treat this as a reload.
     match.transition = PageTransition::RELOAD;
-  } else if (for_drop || ((paste_state_ != NONE) &&
+  } else if (for_drop || ((paste_state_ == REPLACED_ALL) &&
                           match.is_history_what_you_typed_match)) {
     // When the user pasted in a URL and hit enter, score it like a link click
     // rather than a normal typed URL, so it doesn't get inline autocompleted
     // as aggressively later.
     match.transition = PageTransition::LINK;
   }
 
   if (match.type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED ||
       match.type == AutocompleteMatch::SEARCH_HISTORY ||
       match.type == AutocompleteMatch::SEARCH_SUGGEST) {
@@ skipping 62 matching lines @@
 
   if (disposition != NEW_BACKGROUND_TAB) {
     controller_->OnAutocompleteWillAccept();
     view_->RevertAll();  // Revert the box to its unedited state
   }
   controller_->OnAutocompleteAccept(url, disposition, transition,
                                     alternate_nav_url);
 }
 
 void AutocompleteEditModel::AcceptKeyword() {
+  DCHECK(is_keyword_hint_ && !keyword_.empty());
+
   view_->OnBeforePossibleChange();
   view_->SetWindowTextAndCaretPos(std::wstring(), 0);
   is_keyword_hint_ = false;
-  keyword_ui_state_ = KEYWORD;
   view_->OnAfterPossibleChange();
   just_deleted_text_ = false;  // OnAfterPossibleChange() erroneously sets this
                                // since the edit contents have disappeared.  It
                                // doesn't really matter, but we clear it to be
                                // consistent.
   UserMetrics::RecordAction(UserMetricsAction("AcceptedKeywordHint"), profile_);
 }
 
 void AutocompleteEditModel::ClearKeyword(const std::wstring& visible_text) {
   view_->OnBeforePossibleChange();
   const std::wstring window_text(keyword_ + visible_text);
   view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length());
   keyword_.clear();
-  keyword_ui_state_ = NORMAL;
+  is_keyword_hint_ = false;
   view_->OnAfterPossibleChange();
   just_deleted_text_ = true;  // OnAfterPossibleChange() fails to clear this
                               // since the edit contents have actually grown
                               // longer.
 }
 
 bool AutocompleteEditModel::query_in_progress() const {
   return !popup_->autocomplete_controller()->done();
 }
 
@@ skipping 25 matching lines @@
 bool AutocompleteEditModel::OnEscapeKeyPressed() {
   if (has_temporary_text_) {
     AutocompleteMatch match;
     popup_->InfoForCurrentSelection(&match, NULL);
     if (match.destination_url != original_url_) {
       // 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;
-      keyword_ui_state_ = original_keyword_ui_state_;
       popup_->ResetToDefaultMatch();
       view_->OnRevertTemporaryText();
       return true;
     }
   }
 
   // If the user wasn't editing, but merely had focus in the edit, allow <esc>
   // to be processed as an accelerator, so it can still be used to stop a load.
   // When the permanent text isn't all selected we still fall through to the
   // SelectAll() call below so users can arrow around in the text and then hit
@@ skipping 21 matching lines @@
     }
     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 AutocompleteEditModel::OnPaste(bool replacing_all) {
+  paste_state_ = replacing_all ? REPLACING_ALL : PASTING;
+}
+
 void AutocompleteEditModel::OnUpOrDownKeyPressed(int count) {
   // NOTE: This purposefully don'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.
@@ skipping 12 matching lines @@
     // normally.
     popup_->Move(count);
   }
 }
 
 void AutocompleteEditModel::OnPopupDataChanged(
     const std::wstring& text,
     GURL* destination_for_temporary_text_change,
     const std::wstring& keyword,
     bool is_keyword_hint) {
-  KeywordUIState old_keyword_ui_state = keyword_ui_state_;
-
   // 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;
-  }
 
-  // Update |keyword_ui_state_| only when necessary. It may be changed even if
-  // |keyword_state_changed| is false.
-  if (keyword_ui_state_ != NO_KEYWORD) {
-    keyword_ui_state_ = (is_keyword_hint_ || keyword_.empty()) ?
-        NORMAL : KEYWORD;
+    // |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;
       original_url_ = *destination_for_temporary_text_change;
-      original_keyword_ui_state_ = old_keyword_ui_state;
       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
       // pressed, even though maybe it isn't any more.  There is no obvious
@@ skipping 24 matching lines @@
     const std::wstring& new_text,
     bool selection_differs,
     bool text_differs,
     bool just_deleted_text,
     bool allow_keyword_ui_change) {
   // Update the paste state as appropriate: if we're just finishing a paste
   // that replaced all the text, preserve that information; otherwise, if we've
   // made some other edit, clear paste tracking.
   if (paste_state_ == REPLACING_ALL)
     paste_state_ = REPLACED_ALL;
+  else if (paste_state_ == PASTING)
+    paste_state_ = PASTED;
   else if (text_differs)
     paste_state_ = NONE;
 
   // 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())
       return false;  // Don't open the popup for no reason.
   } else if (!user_text_changed) {
     return false;
   }
 
-  const bool had_keyword = KeywordIsSelected();
-
   // 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));
+    const std::wstring new_user_text = UserTextFromDisplayText(new_text);
+
+    // Try to accept the current keyword if the user only typed a space at the
+    // end of content. Model's state and popup will be updated when the keyword
+    // is accepted. So we just need to return false here.
+    if (allow_keyword_ui_change && !selection_differs &&
+        MaybeAcceptKeywordBySpace(new_user_text))
+      return false;
+
+    InternalSetUserText(new_user_text);
     has_temporary_text_ = false;
 
     // Track when the user has deleted text so we won't allow inline
     // autocomplete.
     just_deleted_text_ = just_deleted_text;
   }
 
-  // Disable the fancy keyword UI if the user didn't already have a visible
-  // keyword and the view doesn't want us to change the keyword UI state.
-  // This prevents us from showing the fancy UI and interrupting the user's
-  // editing if, for example, the user happens to have a keyword for 'a',
-  // types 'ab' then puts a space between the 'a' and the 'b'.
-  // If |keyword_ui_state_| is set to NORMAL here, then it will be updated
-  // to a proper value in OnPopupDataChanged() method according to the new
-  // match result.
-  if (!had_keyword)
-    keyword_ui_state_ = allow_keyword_ui_change ? NORMAL : NO_KEYWORD;
-
   view_->UpdatePopup();
   return true;
 }
 
 void AutocompleteEditModel::PopupBoundsChangedTo(const gfx::Rect& bounds) {
   controller_->OnPopupBoundsChanged(bounds);
 }
 
 void AutocompleteEditModel::ResultsUpdated() {
   UpdateSuggestedSearchText();
@@ skipping 53 matching lines @@
   OnPopupDataChanged(inline_autocomplete_text, NULL, keyword, is_keyword_hint);
 }
 
 void AutocompleteEditModel::InternalSetUserText(const std::wstring& text) {
   user_text_ = text;
   just_deleted_text_ = false;
   inline_autocomplete_text_.clear();
 }
 
 bool AutocompleteEditModel::KeywordIsSelected() const {
-  return keyword_ui_state_ == KEYWORD;
+  return !is_keyword_hint_ && !keyword_.empty();
 }
 
 std::wstring AutocompleteEditModel::DisplayTextFromUserText(
     const std::wstring& text) const {
   return KeywordIsSelected() ?
       KeywordProvider::SplitReplacementStringFromInput(text, false) : text;
 }
 
 std::wstring AutocompleteEditModel::UserTextFromDisplayText(
     const std::wstring& text) const {
@@ skipping 51 matching lines @@
             i->inline_autocomplete_offset != std::wstring::npos) {
           suggested_text = WideToUTF16(i->fill_into_edit.substr(
                                            i->inline_autocomplete_offset));
           break;
         }
       }
     }
   }
   controller_->OnSetSuggestedSearchText(suggested_text);
 }
+
+bool AutocompleteEditModel::MaybeAcceptKeywordBySpace(
+    const std::wstring& new_user_text) {
+  if (paste_state_ != NONE || !is_keyword_hint_ || keyword_.empty() ||

[Peter Kasting, 2011/01/20 00:04:22]

Nit: This file puts parens around boolean subconditions.

With one change elsewhere*, we can condense this whole function to a single
conditional:

  return (paste_state_ == NONE) && is_keyword_hint_ && !keyword_.empty() &&
      inline_autocomplete_text_.empty() && (user_text_ == keyword_) &&
      (new_user_text_.length() == user_text_.length() + 1) &&
      !new_user_text_.compare(0, user_text_.length(), user_text_) &&
      (new_user_text_.find_first_of(L" XYZ", user_text_.length()) !=
          std::wstring::npos) && AcceptKeyword();

...where "XYZ" is replaced by the escapes for the various space characters you
want, e.g. U+3000.

This purposefully avoids using IsWhitespace() because characters like \t, \r,
\n, etc. shouldn't be treated as triggering keyword mode.

*Namely, make AcceptKeyword() return a bool (always true) and document it as
returning true for caller convenience.

[James Su, 2011/01/20 06:49:31]

Done with slightly different logic, because:
1. the |user_text_| may not be same as the |keyword_|, eg. "www.google.com" may
trigger keyword "google.com"
2. the keyword may contain space characters in the middle (issue 6867), so we
need to check the last character explicitly.

[Peter Kasting, 2011/01/20 18:49:23]

That's why my find_first_of() call had a second argument.  You must have missed
that.  Oh well, no big deal.

+      !inline_autocomplete_text_.empty())
+    return false;
+
+  const size_t old_length = user_text_.length();
+  const size_t new_length = new_user_text.length();
+  if (old_length && old_length + 1 == new_length &&
+      user_text_ == new_user_text.substr(0, old_length) &&
+      IsWhitespace(new_user_text[old_length]) &&
+      !IsWhitespace(user_text_[old_length - 1])) {
+    AcceptKeyword();
+    return true;
+  }
+  return false;
+}