Make Google Search autocomplete provider cursor aware.

chrome/browser/autocomplete/autocomplete_input.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_input.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/url_canon_ip.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
+namespace {
+
+void AdjustCursorPositionIfNecessary(size_t num_leading_chars_removed,

[Peter Kasting, 2012/12/05 20:49:38]

You should be able to get by without this by using the OffsetAdjuster class (and
possibly the LimitOffset class) found in base/utf_offset_string_conversions.h,
which are designed to help adjust offsets into strings as those strings get
transformed.

One difference between that class' behavior and this function's is that it will
set an offset to npos if the offset points into a section of string that is
removed.  This is probably more correct in this case; otherwise we'll treat the
cursor the same before/after leading whitespace/question mark, which seems
slightly wrong to me.

[Bart N., 2012/12/06 21:43:32]

In this particular case, I strongly disagree with you. I looked at the class you
mentioned and it seems overkill to use it in this particular case. Using the
class requires defining a vector of offsets and I don't think it was intended to
be used in simple cases like this. This sounds like asking to replace
std::min(a,b) with a vector of two elements, then calling std::sort and picking
the first element :)
So this is about what to do in my case below - whether to have *cursor_position
= 0 or *cursor_position = string::npos.

The reason why I prefer 0 is because this is the current behavior of
searchbox+CS. searchbox doesn't alter query in any way and sends it along with
raw cursor position. Then, we normalize the query on the server side (CS) and
set it to 0 if <=0 after normalization.

+                                     size_t* cursor_position) {
+  if (*cursor_position == string16::npos)
+    return;
+  if (num_leading_chars_removed < *cursor_position)
+    *cursor_position -= num_leading_chars_removed;
+  else
+    *cursor_position = 0;
+}
+
+}  // namespace
+
 AutocompleteInput::AutocompleteInput()
-  : type_(INVALID),
-    prevent_inline_autocomplete_(false),
-    prefer_keyword_(false),
-    allow_exact_keyword_match_(true),
-    matches_requested_(ALL_MATCHES) {
+    : cursor_position_(string16::npos),
+      type_(INVALID),
+      prevent_inline_autocomplete_(false),
+      prefer_keyword_(false),
+      allow_exact_keyword_match_(true),
+      matches_requested_(ALL_MATCHES) {
 }
 
 AutocompleteInput::AutocompleteInput(const string16& text,
+                                     size_t cursor_position,
                                      const string16& desired_tld,
                                      bool prevent_inline_autocomplete,
                                      bool prefer_keyword,
                                      bool allow_exact_keyword_match,
                                      MatchesRequested matches_requested)
-    : desired_tld_(desired_tld),
+    : cursor_position_(cursor_position),
+      desired_tld_(desired_tld),
       prevent_inline_autocomplete_(prevent_inline_autocomplete),
       prefer_keyword_(prefer_keyword),
       allow_exact_keyword_match_(allow_exact_keyword_match),
       matches_requested_(matches_requested) {
+  // Initial cursor normalization not yet adjusted for possible text trimming.
+  if (cursor_position >= text.length()) {
+    cursor_position_ = string16::npos;
+  }
   // None of the providers care about leading white space so we always trim it.
   // Providers that care about trailing white space handle trimming themselves.
-  TrimWhitespace(text, TRIM_LEADING, &text_);
+  if ((TrimWhitespace(text, TRIM_LEADING, &text_) & TRIM_LEADING) != 0)
+    AdjustCursorPositionIfNecessary(text.length() - text_.length(),
+                                    &cursor_position_);
 
   GURL canonicalized_url;
   type_ = Parse(text_, desired_tld, &parts_, &scheme_, &canonicalized_url);
 
   if (type_ == INVALID)
     return;
 
   if (((type_ == UNKNOWN) || (type_ == REQUESTED_URL) || (type_ == URL)) &&
       canonicalized_url.is_valid() &&
       (!canonicalized_url.IsStandard() || canonicalized_url.SchemeIsFile() ||
        canonicalized_url.SchemeIsFileSystem() ||
        !canonicalized_url.host().empty()))
     canonicalized_url_ = canonicalized_url;
 
-  RemoveForcedQueryStringIfNecessary(type_, &text_);
+  size_t chars_removed = RemoveForcedQueryStringIfNecessary(type_, &text_);
+  AdjustCursorPositionIfNecessary(chars_removed, &cursor_position_);
 }
 
 AutocompleteInput::~AutocompleteInput() {
 }
 
 // static
-void AutocompleteInput::RemoveForcedQueryStringIfNecessary(Type type,
+size_t AutocompleteInput::RemoveForcedQueryStringIfNecessary(Type type,
                                                            string16* text) {

[Peter Kasting, 2012/12/05 20:49:38]

Nit: Fix alignment

[Bart N., 2012/12/06 21:43:32]

Done.

-  if (type == FORCED_QUERY && !text->empty() && (*text)[0] == L'?')
+  if (type == FORCED_QUERY && !text->empty() && (*text)[0] == L'?') {

[Peter Kasting, 2012/12/05 20:49:38]

Nit: Reverse conditional and early-return to eliminate {}

[Bart N., 2012/12/06 21:43:32]

Done.

[Bart N., 2012/12/06 21:43:32]

Done.

     text->erase(0, 1);
+    return 1;
+  }
+  return 0;
 }
 
 // static
 std::string AutocompleteInput::TypeToString(Type type) {
   switch (type) {
     case INVALID:       return "invalid";
     case UNKNOWN:       return "unknown";
     case REQUESTED_URL: return "requested-url";
     case URL:           return "url";
     case QUERY:         return "query";
@@ skipping 375 matching lines @@
   if (parts.path.is_nonempty())
     ++num_nonhost_components;
   if (parts.query.is_nonempty())
     ++num_nonhost_components;
   if (parts.ref.is_nonempty())
     ++num_nonhost_components;
   return num_nonhost_components;
 }
 
 void AutocompleteInput::UpdateText(const string16& text,
+                                   size_t cursor_position,
                                    const url_parse::Parsed& parts) {
   text_ = text;
+  cursor_position_ = cursor_position;
   parts_ = parts;
 }
 
 bool AutocompleteInput::Equals(const AutocompleteInput& other) const {
   return (text_ == other.text_) &&
+         (cursor_position_ == other.cursor_position_) &&
          (type_ == other.type_) &&
          (desired_tld_ == other.desired_tld_) &&
          (scheme_ == other.scheme_) &&
          (prevent_inline_autocomplete_ == other.prevent_inline_autocomplete_) &&
          (prefer_keyword_ == other.prefer_keyword_) &&
          (matches_requested_ == other.matches_requested_);
 }
 
 void AutocompleteInput::Clear() {
   text_.clear();
+  cursor_position_ = string16::npos;
   type_ = INVALID;
   parts_ = url_parse::Parsed();
   scheme_.clear();
   desired_tld_.clear();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
 }