Fix keyword search erroneously not triggering in two obscure cases:

chrome/browser/autocomplete/autocomplete_edit.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/autocomplete/autocomplete_edit.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/metrics/histogram.h"
@@ skipping 814 matching lines @@
     call_controller_onchanged = false;
   }
 
   // We need to invoke OnChanged in case the destination url changed (as could
   // happen when control is toggled).
   if (call_controller_onchanged)
     OnChanged();
 }
 
 bool AutocompleteEditModel::OnAfterPossibleChange(
+    const string16& old_text,
     const string16& new_text,
     size_t selection_start,
     size_t selection_end,
     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.
@@ skipping 11 matching lines @@
   // 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 string16 old_user_text = user_text_;
   // 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;
 
     // 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.
   // |allow_exact_keyword_match_| will be used by StartAutocomplete() method,
-  // which will be called by |view_->UpdatePopup()|. So we can safely clear
-  // this flag afterwards.
-  allow_exact_keyword_match_ =
-      text_differs && allow_keyword_ui_change &&
+  // which will be called by |view_->UpdatePopup()|; so after that returns we
+  // can safely reset this flag.
+  allow_exact_keyword_match_ = text_differs && allow_keyword_ui_change &&
       !just_deleted_text && no_selection &&
-      ShouldAllowExactKeywordMatch(old_user_text, user_text_, selection_start);
+      CreatedKeywordSearchByInsertingSpaceInMiddle(old_text, user_text_,
+                                                   selection_start);
   view_->UpdatePopup();
   allow_exact_keyword_match_ = false;
 
-  // Change to keyword mode if the user has typed a keyword name and is now
-  // pressing space after the name. Accepting the keyword will update our
-  // state, so in that case there's no need to also return true here.
+  // Change to keyword mode if the user is now pressing space after a keyword
+  // name.  Note that if this is the case, then even if there was no keyword
+  // hint when we entered this function (e.g. if the user has used space to
+  // replace some selected text that was adjoined to this keyword), there will
+  // be one now because of the call to UpdatePopup() above; so it's safe for
+  // MaybeAcceptKeywordBySpace() to look at |keyword_| and |is_keyword_hint_| to
+  // 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(old_user_text, user_text_));
+           no_selection && (selection_start == user_text_.length()) &&
+           MaybeAcceptKeywordBySpace(user_text_));
 }
 
 void AutocompleteEditModel::PopupBoundsChangedTo(const gfx::Rect& bounds) {
   InstantController* instant = controller_->GetInstant();
   if (instant)
     instant->SetOmniboxBounds(bounds);
 }
 
 void AutocompleteEditModel::OnResultChanged(bool default_match_changed) {
   const bool was_open = popup_->IsOpen();
@@ skipping 114 matching lines @@
   // 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;
   if (revert_popup)
     popup_->ResetToDefaultMatch();
   view_->OnRevertTemporaryText();
 }
 
 bool AutocompleteEditModel::MaybeAcceptKeywordBySpace(
-    const string16& old_user_text,
-    const string16& new_user_text) {
+    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() && new_user_text.length() >= 2 &&
-      IsSpaceCharForAcceptingKeyword(*new_user_text.rbegin()) &&
-      !IsWhitespace(*(new_user_text.rbegin() + 1)) &&
-      (old_user_text.length() + 1 >= new_user_text.length()) &&
-      !new_user_text.compare(0, new_user_text.length() - 1, old_user_text,
-                             0, new_user_text.length() - 1) &&
+      inline_autocomplete_text_.empty() &&
+      (keyword_.length() == keyword_length) &&
+      IsSpaceCharForAcceptingKeyword(new_text[keyword_length]) &&
+      !new_text.compare(0, keyword_length, keyword_, 0, keyword_length) &&
       AcceptKeyword();
 }
 
-bool AutocompleteEditModel::ShouldAllowExactKeywordMatch(
-    const string16& old_user_text,
-    const string16& new_user_text,
-    size_t caret_position) {
+bool AutocompleteEditModel::CreatedKeywordSearchByInsertingSpaceInMiddle(
+    const string16& old_text,
+    const string16& new_text,
+    size_t caret_position) const {
+  DCHECK_GE(new_text.length(), caret_position);
+
   // Check simple conditions first.
-  if (paste_state_ != NONE || caret_position < 2 ||
-      new_user_text.length() <= caret_position ||
-      old_user_text.length() < caret_position ||
-      !IsSpaceCharForAcceptingKeyword(new_user_text[caret_position - 1]) ||
-      IsSpaceCharForAcceptingKeyword(new_user_text[caret_position - 2]) ||
-      new_user_text.compare(0, caret_position - 1, old_user_text,
-                            0, caret_position - 1) ||
-      !new_user_text.compare(caret_position - 1,
-                             new_user_text.length() - caret_position + 1,
-                             old_user_text, caret_position - 1,
-                             old_user_text.length() - caret_position + 1)) {
+  if ((paste_state_ != NONE) || (caret_position < 2) ||
+      (old_text.length() < caret_position) ||
+      (new_text.length() == caret_position))
+    return false;
+  size_t space_position = caret_position - 1;
+  if (!IsSpaceCharForAcceptingKeyword(new_text[space_position]) ||
+      IsWhitespace(new_text[space_position - 1]) ||
+      new_text.compare(0, space_position, old_text, 0, space_position) ||
+      !new_text.compare(space_position, new_text.length() - space_position,
+                        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_user_text.substr(0, caret_position - 1),
-                 TRIM_LEADING, &keyword);
-
-  // Only allow exact keyword match if |keyword| represents a keyword hint.
-  return keyword.length() &&
+  TrimWhitespace(new_text.substr(0, space_position), TRIM_LEADING, &keyword);
+  return !keyword.empty() &&
       !autocomplete_controller_->keyword_provider()->
           GetKeywordForText(keyword).empty();
 }
 
 bool AutocompleteEditModel::DoInstant(const AutocompleteMatch& match,
                                       string16* suggested_text) {
   DCHECK(suggested_text);
 
   if (in_revert_)
     return false;
@@ skipping 57 matching lines @@
 //  static
 bool AutocompleteEditModel::IsSpaceCharForAcceptingKeyword(wchar_t c) {
   switch (c) {
     case 0x0020:  // Space
     case 0x3000:  // Ideographic Space
       return true;
     default:
       return false;
   }
 }