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

chrome/browser/autocomplete/history_url_provider.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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 83 matching lines @@
   const GURL& url = match.url_info.url();
   if (!url.is_valid() || !url.IsStandard() || url.SchemeIsFile())
     return GURL();
 
   // Transform to a host-only match.  Bail if the host no longer matches the
   // user input (e.g. because the user typed more than just a host).
   GURL host = url.GetWithEmptyPath();
   if ((host.spec().length() < (match.input_location + input.length())))
     return GURL();  // User typing is longer than this host suggestion.
 
-  const base::string16 spec = UTF8ToUTF16(host.spec());
+  const base::string16 spec = base::UTF8ToUTF16(host.spec());
   if (spec.compare(match.input_location, input.length(), input))
     return GURL();  // User typing is no longer a prefix.
 
   return host;
 }
 
 // Acts like the > operator for URLInfo classes.
 bool CompareHistoryMatch(const history::HistoryMatch& a,
                          const history::HistoryMatch& b) {
   // A promoted match is better than non-promoted.
@@ skipping 308 matching lines @@
                                                                 display_string);
     match.allowed_to_be_default_match = true;
     // NOTE: Don't set match.inline_autocompletion to something non-empty here;
     // it's surprising and annoying.
 
     // Try to highlight "innermost" match location.  If we fix up "w" into
     // "www.w.com", we want to highlight the fifth character, not the first.
     // This relies on match.destination_url being the non-prefix-trimmed version
     // of match.contents.
     match.contents = display_string;
-    const URLPrefix* best_prefix =
-        URLPrefix::BestURLPrefix(UTF8ToUTF16(destination_url.spec()), text);
+    const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
+        base::UTF8ToUTF16(destination_url.spec()), text);
     // It's possible for match.destination_url to not contain the user's input
     // at all (so |best_prefix| is NULL), for example if the input is
     // "view-source:x" and |destination_url| has an inserted "http://" in the
     // middle.
     if (best_prefix == NULL) {
       AutocompleteMatch::ClassifyMatchInString(text, match.contents,
                                                ACMatchClassification::URL,
                                                &match.contents_class);
     } else {
       AutocompleteMatch::ClassifyLocationInString(
@@ skipping 69 matching lines @@
       if (params->cancel_flag.IsSet())
         return;  // Canceled in the middle of a query, give up.
       // We only need kMaxMatches results in the end, but before we
       // get there we need to promote lower-quality matches that are
       // prefixes of higher-quality matches, and remove lower-quality
       // redirects.  So we ask for more results than we need, of every
       // prefix type, in hopes this will give us far more than enough
       // to work with.  CullRedirects() will then reduce the list to
       // the best kMaxMatches results.
       db->AutocompleteForPrefix(
-          UTF16ToUTF8(i->prefix + params->input.text()),
+          base::UTF16ToUTF8(i->prefix + params->input.text()),
           kMaxMatches * 2,
           (backend == NULL),
           &url_matches);
       for (history::URLRows::const_iterator j(url_matches.begin());
            j != url_matches.end(); ++j) {
         const URLPrefix* best_prefix =
-            URLPrefix::BestURLPrefix(UTF8ToUTF16(j->url().spec()),
+            URLPrefix::BestURLPrefix(base::UTF8ToUTF16(j->url().spec()),
                                      base::string16());
         DCHECK(best_prefix != NULL);
         history_matches.push_back(history::HistoryMatch(*j, i->prefix.length(),
             i->num_components == 0,
             i->num_components >= best_prefix->num_components));
       }
     }
   }
 
   // Create sorted list of suggestions.
@@ skipping 294 matching lines @@
     history::URLDatabase* db,
     const AutocompleteInput& input) const {
   // Normally passing the first two conditions below ought to guarantee the
   // third condition, but because FixupUserInput() can run and modify the
   // input's text and parts between Parse() and here, it seems better to be
   // paranoid and check.
   if ((input.type() != AutocompleteInput::UNKNOWN) ||
       !LowerCaseEqualsASCII(input.scheme(), content::kHttpScheme) ||
       !input.parts().host.is_nonempty())
     return false;
-  const std::string host(UTF16ToUTF8(
+  const std::string host(base::UTF16ToUTF8(
       input.text().substr(input.parts().host.begin, input.parts().host.len)));
   const size_t registry_length =
       net::registry_controlled_domains::GetRegistryLength(
           host,
           net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   return registry_length == 0 && db->IsTypedHost(host);
 }
 
 bool HistoryURLProvider::PromoteMatchForInlineAutocomplete(
@@ skipping 247 matching lines @@
       history::MatchTermInString(input_text, clean_description, 0)));
   history::WordStarts description_word_starts;
   history::String16VectorFromString16(
       clean_description, false, &description_word_starts);
   description_matches =
       history::ScoredHistoryMatch::FilterTermMatchesByWordStarts(
           description_matches, description_word_starts, 0, std::string::npos);
   return SpansFromTermMatch(
       description_matches, clean_description.length(), false);
 }