Update some uses of UTF conversions in chrome/browser to use the base:: namespace.

chrome/browser/autocomplete/autocomplete_input.cc

 // 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.
 
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/profiles/profile_io_data.h"
@@ skipping 131 matching lines @@
   // 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 base::string16 parsed_scheme(URLFixerUpper::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
   if (canonicalized_url) {
-    *canonicalized_url = URLFixerUpper::FixupURL(UTF16ToUTF8(text),
-                                                 UTF16ToUTF8(desired_tld));
+    *canonicalized_url = URLFixerUpper::FixupURL(
+        base::UTF16ToUTF8(text), base::UTF16ToUTF8(desired_tld));
   }
 
   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 (LowerCaseEqualsASCII(parsed_scheme, content::kFileSystemScheme)) {
@@ skipping 26 matching lines @@
         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.
     ExternalProtocolHandler::BlockState block_state =
-        ExternalProtocolHandler::GetBlockState(UTF16ToUTF8(parsed_scheme));
+        ExternalProtocolHandler::GetBlockState(
+            base::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 base::string16 http_scheme_prefix =
-            ASCIIToUTF16(std::string(content::kHttpScheme) +
-                         content::kStandardSchemeSeparator);
+            base::ASCIIToUTF16(std::string(content::kHttpScheme) +
+                               content::kStandardSchemeSeparator);
         url_parse::Parsed http_parts;
         base::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(std::string(content::kHttpScheme), UTF16ToUTF8(http_scheme));
+        DCHECK_EQ(std::string(content::kHttpScheme),
+                  base::UTF16ToUTF8(http_scheme));
 
         if (http_type == 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 34 matching lines @@
 
   // 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 base::string16 host(text.substr(parts->host.begin, parts->host.len));
   const size_t registry_length =
       net::registry_controlled_domains::GetRegistryLength(
-          UTF16ToUTF8(host),
+          base::UTF16ToUTF8(host),
           net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   if (registry_length == std::string::npos) {
     // Try to append the desired_tld.
     if (!desired_tld.empty()) {
       base::string16 host_with_tld(host);
       if (host[host.length() - 1] != '.')
         host_with_tld += '.';
       host_with_tld += desired_tld;
       const size_t tld_length =
           net::registry_controlled_domains::GetRegistryLength(
-              UTF16ToUTF8(host_with_tld),
+              base::UTF16ToUTF8(host_with_tld),
               net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
               net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
       if (tld_length != std::string::npos)
         return 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(UTF16ToUTF8(host),
-                                                             &host_info));
+  const std::string canonicalized_host(net::CanonicalizeHost(
+      base::UTF16ToUTF8(host), &host_info));
   if ((host_info.family == url_canon::CanonHostInfo::NEUTRAL) &&
       !net::IsCanonicalizedHostCompliant(canonicalized_host,
-                                         UTF16ToUTF8(desired_tld))) {
+                                         base::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
@@ skipping 66 matching lines @@
   // If the host has a known TLD or a port, it's probably a URL, with the
   // following exceptions:
   // * Any "IP addresses" that make it here are more likely searches
   //   (see above).
   // * If we reach here with a username, our input looks like "user@host[.tld]".
   //   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.
   // Note that we special-case "localhost" as a known hostname.
   if ((host_info.family != url_canon::CanonHostInfo::IPV4) &&
-      ((registry_length != 0) || (host == ASCIIToUTF16("localhost") ||
+      ((registry_length != 0) || (host == base::ASCIIToUTF16("localhost") ||
        parts->port.is_nonempty())))
     return parts->username.is_nonempty() ? UNKNOWN : URL;
 
   // If we reach this point, we know there's no known TLD on the input, so if
   // the user wishes to add a desired_tld, the fixup code will oblige; thus this
   // is a URL.
   if (!desired_tld.empty())
     return URL;
 
   // No scheme, password, port, path, and no known TLD on the host.
@@ skipping 88 matching lines @@
     ++num_nonhost_components;
   if (parts.query.is_nonempty())
     ++num_nonhost_components;
   if (parts.ref.is_nonempty())
     ++num_nonhost_components;
   return num_nonhost_components;
 }
 
 // static
 bool AutocompleteInput::HasHTTPScheme(const base::string16& input) {
-  std::string utf8_input(UTF16ToUTF8(input));
+  std::string utf8_input(base::UTF16ToUTF8(input));
   url_parse::Component scheme;
   if (url_util::FindAndCompareScheme(utf8_input, content::kViewSourceScheme,
                                      &scheme))
     utf8_input.erase(0, scheme.end() + 1);
   return url_util::FindAndCompareScheme(utf8_input, content::kHttpScheme, NULL);
 }
 
 void AutocompleteInput::UpdateText(const base::string16& text,
                                    size_t cursor_position,
                                    const url_parse::Parsed& parts) {
@@ skipping 12 matching lines @@
   current_page_classification_ = AutocompleteInput::INVALID_SPEC;
   type_ = INVALID;
   parts_ = url_parse::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   matches_requested_ = ALL_MATCHES;
 }