Fix failing DCHECK in AutoCompleteInput()

components/omnibox/browser/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 "components/omnibox/browser/omnibox_edit_model.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 388 matching lines @@
   InternalSetUserText(base::string16());
   keyword_.clear();
   is_keyword_hint_ = false;
   has_temporary_text_ = false;
   view_->SetWindowTextAndCaretPos(permanent_text_,
                                   has_focus() ? permanent_text_.length() : 0,
                                   false, true);
   client_->OnRevert();
 }
 
-void OmniboxEditModel::StartAutocomplete(
-    bool has_selected_text,
-    bool prevent_inline_autocomplete,
-    bool entering_keyword_mode) {
+void OmniboxEditModel::StartAutocomplete(bool has_selected_text,
+                                         bool prevent_inline_autocomplete) {
+  const base::string16 input_text = MaybePrependKeyword(user_text_);
+
+  // Compute the cursor position.  There are three cases:
+  //   1. The user is in the midst of typing; there is no inline autocompletion.
+  //   2. The user is in the midst of typing; there is inline autocompletion.
+  //   3. The user is not in the midst of typing, but is triggering this some
+  //      other way, e.g. hitting ctrl-K while the view is showing the permanent
+  //      or temporary text.
   size_t cursor_position;
-  const base::string16 input_text = MaybePrependKeyword(user_text_);
-  if (inline_autocomplete_text_.empty()) {
-    // Cursor position is equivalent to the current selection's end.
+  if (!has_temporary_text_ && (user_text_ == view_->GetText())) {
+    // Case 1 above.  In this case there's a meaningful current cursor position,
+    // so we read it from the view.  (Note that if there is a selected range,
+    // the "cursor position" is considered to be the selection's end.)
     size_t start;
     view_->GetSelectionBounds(&start, &cursor_position);
+
     // For keyword searches, the text that AutocompleteInput expects is of the
-    // form "<keyword> <query>", where our query is |user_text_|.  So if we're
-    // in keyword mode, we need to adjust the cursor position forward by the
-    // length of "<keyword> ".  If we're just entering keyword mode, though, we
-    // have to avoid making this adjustment, because we haven't actually updated
-    // |user_text_| yet, but the caller has already cleared |is_keyword_hint_|,
-    // so MaybePrependKeyword() will believe we are already in keyword mode, and
-    // will thus mis-adjust the cursor position.
-    if (!entering_keyword_mode)
-      cursor_position += input_text.length() - user_text_.length();
+    // form "<keyword> <query>", where our query is |user_text_|.  So we need to
+    // adjust the cursor position forward by the length of any keyword added by
+    // MaybePrependKeyword() above.
+    cursor_position += input_text.length() - user_text_.length();
   } else {
-    // There are some cases where StartAutocomplete() may be called
-    // with non-empty |inline_autocomplete_text_|.  In such cases, we cannot
-    // use the current selection, because it could result with the cursor
-    // position past the last character from the user text.  Instead,
-    // we assume that the cursor is simply at the end of input.
-    // 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.
+    // Case 2 or 3 above.  In case 2, the existing inline autocompletion will be
+    // ignored for this next autocomplete run.  The current cursor position is
+    // always effectively "the end of the input text".  (If the user changes
+    // this cursor position by arrowing, it will accept the inline
+    // autocompletion, which would put us in case 1.)  In case 3, there is no
+    // meaningful current cursor position; the correct default behavior is to
+    // simply claim the cursor is at the end of the input.
     cursor_position = input_text.length();
   }
 
   GURL current_url;
   if (client_->CurrentPageExists())
     current_url = client_->GetURL();
   input_ = AutocompleteInput(
       input_text, cursor_position, std::string(), current_url, ClassifyPage(),
       prevent_inline_autocomplete || just_deleted_text_ ||
           (has_selected_text && inline_autocomplete_text_.empty()) ||
@@ skipping 109 matching lines @@
 void OmniboxEditModel::EnterKeywordModeForDefaultSearchProvider(
     KeywordModeEntryMethod entry_method) {
   autocomplete_controller()->Stop(false);
 
   user_input_in_progress_ = true;
   keyword_ = client_->GetTemplateURLService()->
       GetDefaultSearchProvider()->keyword();
   is_keyword_hint_ = false;
   keyword_mode_entry_method_ = entry_method;
 
-  StartAutocomplete(false, false, true);
+  StartAutocomplete(false, false);
 
   UMA_HISTOGRAM_ENUMERATION(
       kEnteredKeywordModeHistogram, static_cast<int>(entry_method),
       static_cast<int>(KeywordModeEntryMethod::NUM_ITEMS));
 }
 
 void OmniboxEditModel::OpenMatch(AutocompleteMatch match,
                                  WindowOpenDisposition disposition,
                                  const GURL& alternate_nav_url,
                                  const base::string16& pasted_text,
@@ skipping 160 matching lines @@
 
   is_keyword_hint_ = false;
   keyword_mode_entry_method_ = entry_method;
   user_text_ = MaybeStripKeyword(user_text_);
 
   user_text_ = MaybeStripKeyword(user_text_);
 
   if (PopupIsOpen())
     popup_model()->SetSelectedLineState(OmniboxPopupModel::KEYWORD);
   else
-    StartAutocomplete(false, true, true);
+    StartAutocomplete(false, true);
 
   // When entering keyword mode via tab, the new text to show is whatever the
   // newly-selected match in the dropdown is.  When entering via space, however,
   // we should make sure to use the actual |user_text_| as the basis for the new
   // text.  This ensures that if the user types "<keyword><space>" and the
   // default match would have inline autocompleted a further string (e.g.
   // because there's a past multi-word search beginning with this keyword), the
   // inline autocompletion doesn't get filled in as the keyword search query
   // text.
   //
@@ skipping 678 matching lines @@
   // 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();
 
   client_->OnFocusChanged(focus_state_, reason);
 }