Replace string16 with base::string16.

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 115 matching lines @@
   // 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,
+  AutocompleteInput(const base::string16& text,
                     size_t cursor_position,
-                    const string16& desired_tld,
+                    const base::string16& desired_tld,
                     const GURL& current_url,
                     PageClassification current_page_classification,
                     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.
   // Returns number of leading characters removed.
-  static size_t RemoveForcedQueryStringIfNecessary(Type type, string16* text);
+  static size_t RemoveForcedQueryStringIfNecessary(Type type,
+                                                   base::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,
-                    const string16& desired_tld,
+  static Type Parse(const base::string16& text,
+                    const base::string16& desired_tld,
                     url_parse::Parsed* parts,
-                    string16* scheme,
+                    base::string16* scheme,
                     GURL* canonicalized_url);
 
   // Parses |text| and fill |scheme| and |host| by the positions of them.
   // The results are almost as same as the result of Parse(), but if the scheme
   // is view-source, this function returns the positions of scheme and host
   // in the URL qualified by "view-source:" prefix.
-  static void ParseForEmphasizeComponents(const string16& text,
+  static void ParseForEmphasizeComponents(const base::string16& text,
                                           url_parse::Component* scheme,
                                           url_parse::Component* host);
 
   // Code that wants to format URLs with a format flag including
   // net::kFormatUrlOmitTrailingSlashOnBareHostname risk changing the meaning if
   // the result is then parsed as AutocompleteInput.  Such code can call this
   // function with the URL and its formatted string, and it will return a
   // formatted string with the same meaning as the original URL (i.e. it will
   // re-append a slash if necessary).
-  static string16 FormattedStringWithEquivalentMeaning(
+  static base::string16 FormattedStringWithEquivalentMeaning(
       const GURL& url,
-      const string16& formatted_url);
+      const base::string16& formatted_url);
 
   // Returns the number of non-empty components in |parts| besides the host.
   static int NumNonHostComponents(const url_parse::Parsed& parts);
 
   // Returns whether |text| begins "http:" or "view-source:http:".
-  static bool HasHTTPScheme(const string16& text);
+  static bool HasHTTPScheme(const base::string16& text);
 
   // User-provided text to be completed.
-  const string16& text() const { return text_; }
+  const base::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_|, |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,
+  void UpdateText(const base::string16& text,
                   size_t cursor_position,
                   const url_parse::Parsed& parts);
 
   // The current URL, or an invalid GURL if query refinement is not desired.
   const GURL& current_url() const { return current_url_; }
 
   // The type of page that is currently behind displayed and how it is
   // displayed (e.g., with search term replacement or without).
   AutocompleteInput::PageClassification current_page_classification() const {
     return current_page_classification_;
   }
 
   // The type of input supplied.
   Type type() const { return type_; }
 
   // Returns parsed URL components.
   const url_parse::Parsed& parts() const { return parts_; }
 
   // The scheme parsed from the provided text; only meaningful when type_ is
   // URL.
-  const string16& scheme() const { return scheme_; }
+  const base::string16& scheme() const { return scheme_; }
 
   // The input as an URL to navigate to, if possible.
   const GURL& canonicalized_url() const { return canonicalized_url_; }
 
   // Returns whether inline autocompletion should be prevented.
   bool prevent_inline_autocomplete() const {
     return prevent_inline_autocomplete_;
   }
 
   // Returns whether, given an input string consisting solely of a substituting
   // keyword, we should score it like a non-substituting keyword.
   bool prefer_keyword() const { return prefer_keyword_; }
 
   // Returns whether this input is allowed to be treated as an exact
   // keyword match.  If not, the default result is guaranteed not to be a
   // keyword search, even if the input is "<keyword> <search string>".
   bool allow_exact_keyword_match() const { return allow_exact_keyword_match_; }
 
   // See description of enum for details.
   MatchesRequested matches_requested() const { return matches_requested_; }
 
   // Resets all internal variables to the null-constructed state.
   void Clear();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(AutocompleteProviderTest, GetDestinationURL);
 
   // NOTE: Whenever adding a new field here, please make sure to update Clear()
   // method.
-  string16 text_;
+  base::string16 text_;
   size_t cursor_position_;
   GURL current_url_;
   AutocompleteInput::PageClassification current_page_classification_;
   Type type_;
   url_parse::Parsed parts_;
-  string16 scheme_;
+  base::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_