Remove wstring from autocomplete....

chrome/browser/autocomplete/autocomplete.h

 // Copyright (c) 2010 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_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/ref_counted.h"
+#include "base/string16.h"
 #include "base/timer.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 
 // The AutocompleteController is the center of the autocomplete system.  A
 // class creates an instance of the controller, which in turn creates a set of
 // AutocompleteProviders to serve it.  The owning class can ask the controller
 // to Start() a query; the controller in turn passes this call down to the
 // providers, each of which keeps track of its own matches and whether it has
 // finished processing the query.  When a provider gets more matches or finishes
@@ skipping 149 matching lines @@
     INVALID,        // Empty input
     UNKNOWN,        // Valid input whose type cannot be determined
     REQUESTED_URL,  // Input autodetected as UNKNOWN, which the user wants to
                     // treat as an URL by specifying a desired_tld
     URL,            // Input autodetected as a URL
     QUERY,          // Input autodetected as a query
     FORCED_QUERY,   // Input forced to be a query by an initial '?'
   };
 
   AutocompleteInput();
-  AutocompleteInput(const std::wstring& text,
-                    const std::wstring& desired_tld,
+  AutocompleteInput(const string16& text,
+                    const string16& desired_tld,
                     bool prevent_inline_autocomplete,
                     bool prefer_keyword,
                     bool allow_exact_keyword_match,
                     bool synchronous_only);
   ~AutocompleteInput();
 
   // If type is |FORCED_QUERY| and |text| starts with '?', it is removed.
-  static void RemoveForcedQueryStringIfNecessary(Type type, std::wstring* text);
+  static void 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 std::wstring& text,
-                    const std::wstring& desired_tld,
+  static Type Parse(const string16& text,
+                    const string16& desired_tld,
                     url_parse::Parsed* parts,
-                    std::wstring* scheme,
+                    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 std::wstring& text,
-                                          const std::wstring& desired_tld,
+  static void ParseForEmphasizeComponents(const string16& text,
+                                          const string16& desired_tld,
                                           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 std::wstring FormattedStringWithEquivalentMeaning(
+  static string16 FormattedStringWithEquivalentMeaning(
       const GURL& url,
-      const std::wstring& formatted_url);
+      const string16& formatted_url);
 
   // User-provided text to be completed.
-  const std::wstring& text() const { return text_; }
+  const string16& text() const { return text_; }
 
   // Use of this setter is risky, since no other internal state is updated
   // besides |text_|.  Only callers who know that they're not changing the
   // type/scheme/etc. should use this.
-  void set_text(const std::wstring& text) { text_ = text; }
+  void set_text(const string16& text) { text_ = text; }
 
   // 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 std::wstring& desired_tld() const { return desired_tld_; }
+  const string16& desired_tld() const { return desired_tld_; }
 
   // 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 std::wstring& scheme() const { return scheme_; }
+  const 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 the value of |prevent_inline_autocomplete| supplied to the
@@ skipping 18 matching lines @@
   // asynchronous work should be canceled, so no later callbacks are fired.
   bool synchronous_only() const { return synchronous_only_; }
 
   // operator==() by another name.
   bool Equals(const AutocompleteInput& other) const;
 
   // Resets all internal variables to the null-constructed state.
   void Clear();
 
  private:
-  std::wstring text_;
-  std::wstring desired_tld_;
+  string16 text_;
+  string16 desired_tld_;
   Type type_;
   url_parse::Parsed parts_;
-  std::wstring scheme_;
+  string16 scheme_;
   GURL canonicalized_url_;
   bool initial_prevent_inline_autocomplete_;
   bool prevent_inline_autocomplete_;
   bool prefer_keyword_;
   bool allow_exact_keyword_match_;
   bool synchronous_only_;
 };
 
 // AutocompleteProvider -------------------------------------------------------
 
@@ skipping 79 matching lines @@
   // we have good relevance heuristics; the controller should handle all
   // culling.
   static const size_t kMaxMatches;
 
  protected:
   friend class base::RefCountedThreadSafe<AutocompleteProvider>;
 
   virtual ~AutocompleteProvider();
 
   // Returns whether |input| begins "http:" or "view-source:http:".
-  static bool HasHTTPScheme(const std::wstring& input);
+  static bool HasHTTPScheme(const string16& input);
 
   // Updates the starred state of each of the matches in matches_ from the
   // profile's bookmark bar model.
   void UpdateStarredStateOfMatches();
 
   // A convenience function to call net::FormatUrl() with the current set of
   // "Accept Languages" when check_accept_lang is true.  Otherwise, it's called
   // with an empty list.
-  std::wstring StringForURLDisplay(const GURL& url,
-                                   bool check_accept_lang,
-                                   bool trim_http) const;
+  string16 StringForURLDisplay(const GURL& url,
+                               bool check_accept_lang,
+                               bool trim_http) const;
 
   // The profile associated with the AutocompleteProvider.  Reference is not
   // owned by us.
   Profile* profile_;
 
   ACProviderListener* listener_;
   ACMatches matches_;
   bool done_;
 
   // The name of this provider.  Used for logging.
@@ skipping 164 matching lines @@
   // return matches which are synchronously available, which should mean that
   // all providers will be done immediately.
   //
   // The controller will fire
   // AUTOCOMPLETE_CONTROLLER_SYNCHRONOUS_MATCHES_AVAILABLE from inside this
   // call, and unless the query is stopped, will fire at least one (and perhaps
   // more) AUTOCOMPLETE_CONTROLLER_RESULT_UPDATED later as more matches come in
   // (even if the query completes synchronously).  Listeners should use the
   // result set provided in the accompanying Details object to update
   // themselves.
-  void Start(const std::wstring& text,
-             const std::wstring& desired_tld,
+  void Start(const string16& text,
+             const string16& desired_tld,
              bool prevent_inline_autocomplete,
              bool prefer_keyword,
              bool allow_exact_keyword_match,
              bool synchronous_only);
 
   // Cancels the current query, ensuring there will be no future notifications
   // fired.  If new matches have come in since the most recent notification was
   // fired, they will be discarded.
   //
   // If |clear_result| is true, the controller will also erase the result set.
@@ skipping 92 matching lines @@
   base::RepeatingTimer<AutocompleteController> update_delay_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(AutocompleteController);
 };
 
 // AutocompleteLog ------------------------------------------------------------
 
 // The data to log (via the metrics service) when the user selects an item
 // from the omnibox popup.
 struct AutocompleteLog {
-  AutocompleteLog(std::wstring text,
+  AutocompleteLog(string16 text,
                   AutocompleteInput::Type input_type,
                   size_t selected_index,
                   size_t inline_autocompleted_length,
                   const AutocompleteResult& result)
       : text(text),
         input_type(input_type),
         selected_index(selected_index),
         inline_autocompleted_length(inline_autocompleted_length),
         result(result) {
   }
   // The user's input text in the omnibox.
-  std::wstring text;
+  string16 text;
   // The detected type of the user's input.
   AutocompleteInput::Type input_type;
   // Selected index (if selected) or -1 (AutocompletePopupModel::kNoMatch).
   size_t selected_index;
   // Inline autocompleted length (if displayed).
   size_t inline_autocompleted_length;
   // Result set.
   const AutocompleteResult& result;
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_H_