Remove wstring from autocomplete.

chrome/browser/autocomplete/autocomplete.cc

 // 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.
 
 #include "chrome/browser/autocomplete/autocomplete.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 33 matching lines @@
 
 AutocompleteInput::AutocompleteInput()
   : type_(INVALID),
     initial_prevent_inline_autocomplete_(false),
     prevent_inline_autocomplete_(false),
     prefer_keyword_(false),
     allow_exact_keyword_match_(true),
     synchronous_only_(false) {
 }
 
-AutocompleteInput::AutocompleteInput(const std::wstring& text,
-                                     const std::wstring& desired_tld,
+AutocompleteInput::AutocompleteInput(const string16& text,
+                                     const string16& desired_tld,
                                      bool prevent_inline_autocomplete,
                                      bool prefer_keyword,
                                      bool allow_exact_keyword_match,
                                      bool synchronous_only)
     : desired_tld_(desired_tld),
       initial_prevent_inline_autocomplete_(prevent_inline_autocomplete),
       prevent_inline_autocomplete_(prevent_inline_autocomplete),
       prefer_keyword_(prefer_keyword),
       allow_exact_keyword_match_(allow_exact_keyword_match),
       synchronous_only_(synchronous_only) {
@@ skipping 15 matching lines @@
     canonicalized_url_ = canonicalized_url;
 
   RemoveForcedQueryStringIfNecessary(type_, &text_);
 }
 
 AutocompleteInput::~AutocompleteInput() {
 }
 
 // static
 void AutocompleteInput::RemoveForcedQueryStringIfNecessary(Type type,
-                                                           std::wstring* text) {
+                                                           string16* text) {
   if (type == FORCED_QUERY && !text->empty() && (*text)[0] == L'?')
     text->erase(0, 1);
 }
 
 // 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";
     case FORCED_QUERY:  return "forced-query";
 
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 // static
 AutocompleteInput::Type AutocompleteInput::Parse(
-    const std::wstring& text,
-    const std::wstring& desired_tld,
+    const string16& text,
+    const string16& desired_tld,
     url_parse::Parsed* parts,
-    std::wstring* scheme,
+    string16* scheme,
     GURL* canonicalized_url) {
-  const size_t first_non_white = text.find_first_not_of(kWhitespaceWide, 0);
-  if (first_non_white == std::wstring::npos)
+  const size_t first_non_white = text.find_first_not_of(kWhitespaceUTF16, 0);
+  if (first_non_white == string16::npos)
     return INVALID;  // All whitespace.
 
   if (text.at(first_non_white) == L'?') {
     // If the first non-whitespace character is a '?', we magically treat this
     // as a query.
     return FORCED_QUERY;
   }
 
   // Ask our parsing back-end to help us understand what the user typed.  We
   // use the URLFixerUpper here because we want to be smart about what we
   // consider a scheme.  For example, we shouldn't consider www.google.com:80
   // to have a scheme.
   url_parse::Parsed local_parts;
   if (!parts)
     parts = &local_parts;
-  const std::wstring parsed_scheme(URLFixerUpper::SegmentURL(text, parts));
+  const string16 parsed_scheme(URLFixerUpper::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
   if (canonicalized_url) {
-    *canonicalized_url = URLFixerUpper::FixupURL(WideToUTF8(text),
-                                                 WideToUTF8(desired_tld));
+    *canonicalized_url = URLFixerUpper::FixupURL(UTF16ToUTF8(text),
+                                                 UTF16ToUTF8(desired_tld));
   }
 
-  if (parsed_scheme == L"file") {
+  if (LowerCaseEqualsASCII(parsed_scheme, chrome::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme| will tell us that this is a file URL, but
     // |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
     return URL;
   }
 
   // If the user typed a scheme, and it's HTTP or HTTPS, we know how to parse it
   // well enough that we can fall through to the heuristics below.  If it's
   // something else, we can just determine our action based on what we do with
   // any input of this scheme.  In theory we could do better with some schemes
   // (e.g. "ftp" or "view-source") but I'll wait to spend the effort on that
   // until I run into some cases that really need it.
   if (parts->scheme.is_nonempty() &&
-      (parsed_scheme != L"http") && (parsed_scheme != L"https")) {
+      !LowerCaseEqualsASCII(parsed_scheme, chrome::kHttpScheme) &&
+      !LowerCaseEqualsASCII(parsed_scheme, chrome::kHttpsScheme)) {
     // See if we know how to handle the URL internally.
-    if (net::URLRequest::IsHandledProtocol(WideToASCII(parsed_scheme)))
+    if (net::URLRequest::IsHandledProtocol(UTF16ToASCII(parsed_scheme)))
       return URL;
 
     // There are also some schemes that we convert to other things before they
     // reach the renderer or else the renderer handles internally without
     // reaching the net::URLRequest logic.  We thus won't catch these above, but
     // we should still claim to handle them.
     if (LowerCaseEqualsASCII(parsed_scheme, chrome::kViewSourceScheme) ||
         LowerCaseEqualsASCII(parsed_scheme, chrome::kJavaScriptScheme) ||
         LowerCaseEqualsASCII(parsed_scheme, chrome::kDataScheme))
       return URL;
 
     // Finally, check and see if the user has explicitly opened this scheme as
     // a URL before, or if the "scheme" is actually a username.  We need to do
     // this last because some schemes (e.g. "javascript") may be treated as
     // "blocked" by the external protocol handler because we don't want pages to
     // open them, but users still can.
     // TODO(viettrungluu): get rid of conversion.
-    switch (ExternalProtocolHandler::GetBlockState(WideToUTF8(parsed_scheme))) {
+    ExternalProtocolHandler::BlockState block_state =
+        ExternalProtocolHandler::GetBlockState(UTF16ToUTF8(parsed_scheme));
+    switch (block_state) {
       case ExternalProtocolHandler::DONT_BLOCK:
         return URL;
 
       case ExternalProtocolHandler::BLOCK:
         // If we don't want the user to open the URL, don't let it be navigated
         // to at all.
         return QUERY;
 
       default: {
         // We don't know about this scheme.  It might be that the user typed a
         // URL of the form "username:password@foo.com".
-        const std::wstring http_scheme_prefix = L"http://";
+        const string16 http_scheme_prefix =
+            ASCIIToUTF16(std::string(chrome::kHttpScheme) +
+                         chrome::kStandardSchemeSeparator);
         url_parse::Parsed http_parts;
-        std::wstring http_scheme;
+        string16 http_scheme;
         GURL http_canonicalized_url;
         Type http_type = Parse(http_scheme_prefix + text, desired_tld,
                                &http_parts, &http_scheme,
                                &http_canonicalized_url);
-        DCHECK_EQ("http", WideToUTF8(http_scheme));
+        DCHECK_EQ(std::string(chrome::kHttpScheme), UTF16ToUTF8(http_scheme));
 
         if ((http_type == URL || http_type == REQUESTED_URL) &&
             http_parts.username.is_nonempty() &&
             http_parts.password.is_nonempty()) {
           // Manually re-jigger the parsed parts to match |text| (without the
           // http scheme added).
           http_parts.scheme.reset();
           url_parse::Component* components[] = {
             &http_parts.username,
             &http_parts.password,
@@ skipping 31 matching lines @@
   // Either the user didn't type a scheme, in which case we need to distinguish
   // between an HTTP URL and a query, or the scheme is HTTP or HTTPS, in which
   // case we should reject invalid formulations.
 
   // If we have an empty host it can't be a URL.
   if (!parts->host.is_nonempty())
     return QUERY;
 
   // Likewise, the RCDS can reject certain obviously-invalid hosts.  (We also
   // use the registry length later below.)
-  const std::wstring host(text.substr(parts->host.begin, parts->host.len));
+  const string16 host(text.substr(parts->host.begin, parts->host.len));
   const size_t registry_length =
-      net::RegistryControlledDomainService::GetRegistryLength(host, false);
-  if (registry_length == std::wstring::npos) {
+      net::RegistryControlledDomainService::GetRegistryLength(UTF16ToUTF8(host),
+                                                              false);
+  if (registry_length == std::string::npos) {
     // Try to append the desired_tld.
     if (!desired_tld.empty()) {
-      std::wstring host_with_tld(host);
+      string16 host_with_tld(host);
       if (host[host.length() - 1] != '.')
         host_with_tld += '.';
       host_with_tld += desired_tld;
       if (net::RegistryControlledDomainService::GetRegistryLength(
-          host_with_tld, false) != std::wstring::npos)
+          UTF16ToUTF8(host_with_tld), false) != std::string::npos)
         return REQUESTED_URL;  // Something like "99999999999" that looks like a
                                // bad IP address, but becomes valid on attaching
                                // a TLD.
     }
     return QUERY;  // Could be a broken IP address, etc.
   }
 
 
   // See if the hostname is valid.  While IE and GURL allow hostnames to contain
   // many other characters (perhaps for weird intranet machines), it's extremely
   // unlikely that a user would be trying to type those in for anything other
   // than a search query.
   url_canon::CanonHostInfo host_info;
-  const std::string canonicalized_host(net::CanonicalizeHost(host, &host_info));
+  const std::string canonicalized_host(net::CanonicalizeHost(UTF16ToUTF8(host),
+                                                             &host_info));
   if ((host_info.family == url_canon::CanonHostInfo::NEUTRAL) &&
       !net::IsCanonicalizedHostCompliant(canonicalized_host,
-                                         WideToUTF8(desired_tld))) {
+                                         UTF16ToUTF8(desired_tld))) {
     // Invalid hostname.  There are several possible cases:
     // * Our checker is too strict and the user pasted in a real-world URL
     //   that's "invalid" but resolves.  To catch these, we return UNKNOWN when
     //   the user explicitly typed a scheme, so we'll still search by default
     //   but we'll show the accidental search infobar if necessary.
     // * The user is typing a multi-word query.  If we see a space anywhere in
     //   the hostname we assume this is a search and return QUERY.
     // * Our checker is too strict and the user is typing a real-world hostname
     //   that's "invalid" but resolves.  We return UNKNOWN if the TLD is known.
     //   Note that we explicitly excluded hosts with spaces above so that
     //   "toys at amazon.com" will be treated as a search.
     // * The user is typing some garbage string.  Return QUERY.
     //
     // Thus we fall down in the following cases:
     // * Trying to navigate to a hostname with spaces
     // * Trying to navigate to a hostname with invalid characters and an unknown
     //   TLD
     // These are rare, though probably possible in intranets.
     return (parts->scheme.is_nonempty() ||
-           ((registry_length != 0) && (host.find(' ') == std::wstring::npos))) ?
+           ((registry_length != 0) && (host.find(' ') == string16::npos))) ?
         UNKNOWN : QUERY;
   }
 
   // A port number is a good indicator that this is a URL.  However, it might
   // also be a query like "1.66:1" that looks kind of like an IP address and
   // port number. So here we only check for "port numbers" that are illegal and
   // thus mean this can't be navigated to (e.g. "1.2.3.4:garbage"), and we save
   // handling legal port numbers until after the "IP address" determination
   // below.
   if (parts->port.is_nonempty()) {
     int port;
-    if (!base::StringToInt(WideToUTF8(
-            text.substr(parts->port.begin, parts->port.len)), &port) ||
+    if (!base::StringToInt(text.substr(parts->port.begin, parts->port.len),
+                           &port) ||
         (port < 0) || (port > 65535))
       return QUERY;
   }
 
   // Now that we've ruled out all schemes other than http or https and done a
   // little more sanity checking, the presence of a scheme means this is likely
   // a URL.
   if (parts->scheme.is_nonempty())
     return URL;
 
@@ skipping 28 matching lines @@
   if (parts->path.is_nonempty()) {
     // Most inputs with paths are URLs, even ones without known registries (e.g.
     // intranet URLs).  However, if there's no known registry and the path has
     // a space, this is more likely a query with a slash in the first term
     // (e.g. "ps/2 games") than a URL.  We can still open URLs with spaces in
     // the path by escaping the space, and we will still inline autocomplete
     // them if users have typed them in the past, but we default to searching
     // since that's the common case.
     return ((registry_length == 0) &&
             (text.substr(parts->path.begin, parts->path.len).find(' ') !=
-                std::wstring::npos)) ? UNKNOWN : URL;
+                string16::npos)) ? UNKNOWN : URL;
   }
 
   // If we reach here with a username, our input looks like "user@host".
   // Because there is no scheme explicitly specified, we think this is more
   // likely an email address than an HTTP auth attempt.  Hence, we search by
   // default and let users correct us on a case-by-case basis.
   if (parts->username.is_nonempty())
     return UNKNOWN;
 
   // We have a bare host string.  If it has a known TLD, it's probably a URL.
@@ skipping 15 matching lines @@
   //   "browser.tabs.closeButtons" or "java.awt.event.*").  This is ideally a
   //   QUERY.  Since the above case and this one are indistinguishable, and this
   //   case is likely to be much more common, just say these are both UNKNOWN,
   //   which should default to the right thing and let users correct us on a
   //   case-by-case basis.
   return desired_tld.empty() ? UNKNOWN : REQUESTED_URL;
 }
 
 // static
 void AutocompleteInput::ParseForEmphasizeComponents(
-    const std::wstring& text,
-    const std::wstring& desired_tld,
+    const string16& text,
+    const string16& desired_tld,
     url_parse::Component* scheme,
     url_parse::Component* host) {
   url_parse::Parsed parts;
-  std::wstring scheme_str;
+  string16 scheme_str;
   Parse(text, desired_tld, &parts, &scheme_str, NULL);
 
   *scheme = parts.scheme;
   *host = parts.host;
 
   int after_scheme_and_colon = parts.scheme.end() + 1;
   // For the view-source scheme, we should emphasize the scheme and host of the
   // URL qualified by the view-source prefix.
   if (LowerCaseEqualsASCII(scheme_str, chrome::kViewSourceScheme) &&
       (static_cast<int>(text.length()) > after_scheme_and_colon)) {
     // Obtain the URL prefixed by view-source and parse it.
-    std::wstring real_url(text.substr(after_scheme_and_colon));
+    string16 real_url(text.substr(after_scheme_and_colon));
     url_parse::Parsed real_parts;
     AutocompleteInput::Parse(real_url, desired_tld, &real_parts, NULL, NULL);
     if (real_parts.scheme.is_nonempty() || real_parts.host.is_nonempty()) {
       if (real_parts.scheme.is_nonempty()) {
         *scheme = url_parse::Component(
             after_scheme_and_colon + real_parts.scheme.begin,
             real_parts.scheme.len);
       } else {
         scheme->reset();
       }
       if (real_parts.host.is_nonempty()) {
         *host = url_parse::Component(
             after_scheme_and_colon + real_parts.host.begin,
             real_parts.host.len);
       } else {
         host->reset();
       }
     }
   }
 }
 
 // static
-std::wstring AutocompleteInput::FormattedStringWithEquivalentMeaning(
+string16 AutocompleteInput::FormattedStringWithEquivalentMeaning(
     const GURL& url,
-    const std::wstring& formatted_url) {
+    const string16& formatted_url) {
   if (!net::CanStripTrailingSlash(url))
     return formatted_url;
-  const std::wstring url_with_path(formatted_url + L"/");
-  return (AutocompleteInput::Parse(formatted_url, std::wstring(), NULL, NULL,
+  const string16 url_with_path(formatted_url + char16('/'));
+  return (AutocompleteInput::Parse(formatted_url, string16(), NULL, NULL,
                                    NULL) ==
-          AutocompleteInput::Parse(url_with_path, std::wstring(), NULL, NULL,
+          AutocompleteInput::Parse(url_with_path, string16(), NULL, NULL,
                                    NULL)) ?
       formatted_url : url_with_path;
 }
 
 
 bool AutocompleteInput::Equals(const AutocompleteInput& other) const {
   return (text_ == other.text_) &&
          (type_ == other.type_) &&
          (desired_tld_ == other.desired_tld_) &&
          (scheme_ == other.scheme_) &&
@@ skipping 40 matching lines @@
 }
 
 void AutocompleteProvider::DeleteMatch(const AutocompleteMatch& match) {
 }
 
 AutocompleteProvider::~AutocompleteProvider() {
   Stop();
 }
 
 // static
-bool AutocompleteProvider::HasHTTPScheme(const std::wstring& input) {
-  std::string utf8_input(WideToUTF8(input));
+bool AutocompleteProvider::HasHTTPScheme(const string16& input) {
+  std::string utf8_input(UTF16ToUTF8(input));
   url_parse::Component scheme;
   if (url_util::FindAndCompareScheme(utf8_input, chrome::kViewSourceScheme,
                                      &scheme))
     utf8_input.erase(0, scheme.end() + 1);
   return url_util::FindAndCompareScheme(utf8_input, chrome::kHttpScheme, NULL);
 }
 
 void AutocompleteProvider::UpdateStarredStateOfMatches() {
   if (matches_.empty())
     return;
 
   if (!profile_)
     return;
   BookmarkModel* bookmark_model = profile_->GetBookmarkModel();
   if (!bookmark_model || !bookmark_model->IsLoaded())
     return;
 
   for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i)
     i->starred = bookmark_model->IsBookmarked(GURL(i->destination_url));
 }
 
-std::wstring AutocompleteProvider::StringForURLDisplay(const GURL& url,
-                                                       bool check_accept_lang,
-                                                       bool trim_http) const {
+string16 AutocompleteProvider::StringForURLDisplay(const GURL& url,
+                                                   bool check_accept_lang,
+                                                   bool trim_http) const {
   std::string languages = (check_accept_lang && profile_) ?
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages) : std::string();
-  return UTF16ToWideHack(net::FormatUrl(
+  return net::FormatUrl(
       url,
       languages,
       net::kFormatUrlOmitAll & ~(trim_http ? 0 : net::kFormatUrlOmitHTTP),
-      UnescapeRule::SPACES, NULL, NULL, NULL));
+      UnescapeRule::SPACES, NULL, NULL, NULL);
 }
 
 // AutocompleteResult ---------------------------------------------------------
 
 // static
 const size_t AutocompleteResult::kMaxMatches = 6;
 
 void AutocompleteResult::Selection::Clear() {
   destination_url = GURL();
   provider_affinity = NULL;
@@ skipping 159 matching lines @@
 }
 
 void AutocompleteController::SetProfile(Profile* profile) {
   Stop(true);
   for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
     (*i)->SetProfile(profile);
   input_.Clear();  // Ensure we don't try to do a "minimal_changes" query on a
                    // different profile.
 }
 
-void AutocompleteController::Start(const std::wstring& text,
-                                   const std::wstring& desired_tld,
+void AutocompleteController::Start(const string16& text,
+                                   const string16& desired_tld,
                                    bool prevent_inline_autocomplete,
                                    bool prefer_keyword,
                                    bool allow_exact_keyword_match,
                                    bool synchronous_only) {
-  const std::wstring old_input_text(input_.text());
+  const string16 old_input_text(input_.text());
   const bool old_synchronous_only = input_.synchronous_only();
   input_ = AutocompleteInput(text, desired_tld, prevent_inline_autocomplete,
       prefer_keyword, allow_exact_keyword_match, synchronous_only);
 
   // See if we can avoid rerunning autocomplete when the query hasn't changed
   // much.  When the user presses or releases the ctrl key, the desired_tld
   // changes, and when the user finishes an IME composition, inline autocomplete
   // may no longer be prevented.  In both these cases the text itself hasn't
   // changed since the last query, and some providers can do much less work (and
   // get matches back more quickly).  Taking advantage of this reduces flicker.
@@ skipping 155 matching lines @@
 void AutocompleteController::CheckIfDone() {
   for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     if (!(*i)->done()) {
       done_ = false;
       return;
     }
   }
   done_ = true;
 }