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.  |cursor_position| may be set to
+  // string16::npos if the input |text| doesn't come directly from the user's
+  // typing.
+  //
+  // See AutocompleteInput::desired_tld() for meaning of |desired_tld|.
+  //
+  // |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.
+  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,
+                  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_