Make Google Search autocomplete provider cursor aware.

chrome/browser/autocomplete/autocomplete_input.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_INPUT_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_INPUT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 29 matching lines @@
     BEST_MATCH,
 
     // Only synchronous matches should be returned.
     SYNCHRONOUS_MATCHES,
 
     // All matches should be fetched.
     ALL_MATCHES,
   };
 
   AutocompleteInput();
+  // |text| and |cursor_position| represent the input query and location of
+  // the cursor with the query respectively.

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

Nit: Add "|cursor_position| may be set to string16::npos if the input string
doesn't come directly from the user's typing."

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

Done.

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

Done.

+  //
+  // |prevent_inline_autocomplete| is true if the generated result set should
+  // not require inline autocomplete for the default match.  This is difficult
+  // to explain in the abstract; the practical use case is that after the user
+  // deletes text in the edit, the HistoryURLProvider should make sure not to
+  // promote a match requiring inline autocomplete too highly.
+  //
+  // |prefer_keyword| should be true when the keyword UI is onscreen; this will
+  // bias the autocomplete result set toward the keyword provider when the input
+  // string is a bare keyword.
+  //
+  // |allow_exact_keyword_match| should be false when triggering keyword mode on
+  // the input string would be surprising or wrong, e.g. when highlighting text
+  // in a page and telling the browser to search for it or navigate to it. This
+  // parameter only applies to substituting keywords.
+
+  // If |matches_requested| is BEST_MATCH or SYNCHRONOUS_MATCHES the controller
+  // asks the providers to only return matches which are synchronously
+  // available, which should mean that all providers will be done immediately.
   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);
   ~AutocompleteInput();
 
   // If type is |FORCED_QUERY| and |text| starts with '?', it is removed.
-  static void RemoveForcedQueryStringIfNecessary(Type type, string16* text);
+  // Returns number of leading characters removed.
+  static size_t RemoveForcedQueryStringIfNecessary(Type type, string16* text);
 
   // Converts |type| to a string representation.  Used in logging.
   static std::string TypeToString(Type type);
 
   // Parses |text| and returns the type of input this will be interpreted as.
   // The components of the input are stored in the output parameter |parts|, if
   // it is non-NULL. The scheme is stored in |scheme| if it is non-NULL. The
   // canonicalized URL is stored in |canonicalized_url|; however, this URL is
   // not guaranteed to be valid, especially if the parsed type is, e.g., QUERY.
   static Type Parse(const string16& text,
@@ skipping 20 matching lines @@
   static string16 FormattedStringWithEquivalentMeaning(
       const GURL& url,
       const string16& formatted_url);
 
   // Returns the number of non-empty components in |parts| besides the host.
   static int NumNonHostComponents(const url_parse::Parsed& parts);
 
   // User-provided text to be completed.
   const string16& text() const { return text_; }
 
+  // Returns 0-based cursor position within |text_| or string16::npos if not
+  // used or past the last character.

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

Seems like for a string "abc", we should allow the following:

|abc -> 0
a|bc -> 1
ab|c -> 2
abc| -> 3

This comment makes it sound like the last case isn't valid, and we just use npos
there.  Isn't there value in distinguishing "cursor at end" from "no cursor --
text didn't come from user typing"?

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

It isn't a bug, it was done intentionally. However, I consulted searchbox folks,
and it seems that cp is always send from JS (details omitted). We agreed to make
it consistent, so I've just changed the comment as well as the implementation.

+  size_t cursor_position() const { return cursor_position_; }
+
   // Use of this setter is risky, since no other internal state is updated
-  // besides |text_| and |parts_|.  Only callers who know that they're not
-  // changing the type/scheme/etc. should use this.
-  void UpdateText(const string16& text, const url_parse::Parsed& parts);
+  // besides |text_|, |cursor_position_| and |parts_|.  Only callers who know
+  // that they're not changing the type/scheme/etc. should use this.
+  void UpdateText(const string16& text, size_t cursor_position,

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

Nit: One arg per line

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

Done.

+                  const url_parse::Parsed& parts);
 
   // User's desired TLD, if one is not already present in the text to
   // autocomplete.  When this is non-empty, it also implies that "www." should
   // be prepended to the domain where possible.  This should not have a leading
   // '.' (use "com" instead of ".com").
   const string16& desired_tld() const { return desired_tld_; }
 
   // The type of input supplied.
   Type type() const { return type_; }
 
@@ skipping 25 matching lines @@
   MatchesRequested matches_requested() const { return matches_requested_; }
 
   // operator==() by another name.
   bool Equals(const AutocompleteInput& other) const;
 
   // Resets all internal variables to the null-constructed state.
   void Clear();
 
  private:
   string16 text_;
+  size_t cursor_position_;
   string16 desired_tld_;
   Type type_;
   url_parse::Parsed parts_;
   string16 scheme_;
   GURL canonicalized_url_;
   bool prevent_inline_autocomplete_;
   bool prefer_keyword_;
   bool allow_exact_keyword_match_;
   MatchesRequested matches_requested_;
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_INPUT_H_