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

chrome/browser/search_engines/template_url.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/search_engines/template_url.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 112 matching lines @@
                  const char* encoding,
                  bool is_in_query,
                  base::string16* escaped_terms,
                  base::string16* escaped_original_query) {
   DCHECK(escaped_terms);
   DCHECK(escaped_original_query);
   std::string encoded_terms;
   if (!base::UTF16ToCodepage(terms, encoding,
       base::OnStringConversionError::SKIP, &encoded_terms))
     return false;
-  *escaped_terms = UTF8ToUTF16(is_in_query ?
+  *escaped_terms = base::UTF8ToUTF16(is_in_query ?
       net::EscapeQueryParamValue(encoded_terms, true) :
       net::EscapePath(encoded_terms));
   if (original_query.empty())
     return true;
   std::string encoded_original_query;
   if (!base::UTF16ToCodepage(original_query, encoding,
       base::OnStringConversionError::SKIP, &encoded_original_query))
     return false;
-  *escaped_original_query =
-      UTF8ToUTF16(net::EscapeQueryParamValue(encoded_original_query, true));
+  *escaped_original_query = base::UTF8ToUTF16(
+      net::EscapeQueryParamValue(encoded_original_query, true));
   return true;
 }
 
 // Extract query key and host given a list of parameters coming from the URL
 // query or ref.
 std::string FindSearchTermsKey(const std::string& params) {
   if (params.empty())
     return std::string();
   url_parse::Component query, key, value;
   query.len = static_cast<int>(params.size());
@@ skipping 218 matching lines @@
 }
 
 bool TemplateURLRef::IsValidUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessaryUsingTermsData(search_terms_data);
   return valid_;
 }
 
 base::string16 TemplateURLRef::DisplayURL() const {
   ParseIfNecessary();
-  base::string16 result(UTF8ToUTF16(GetURL()));
+  base::string16 result(base::UTF8ToUTF16(GetURL()));
   if (valid_ && !replacements_.empty()) {
     ReplaceSubstringsAfterOffset(&result, 0,
-                                 ASCIIToUTF16(kSearchTermsParameterFull),
-                                 ASCIIToUTF16(kDisplaySearchTerms));
+                                 base::ASCIIToUTF16(kSearchTermsParameterFull),
+                                 base::ASCIIToUTF16(kDisplaySearchTerms));
     ReplaceSubstringsAfterOffset(&result, 0,
-        ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
-        ASCIIToUTF16(kDisplayUnescapedSearchTerms));
+        base::ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull),
+        base::ASCIIToUTF16(kDisplayUnescapedSearchTerms));
   }
   return result;
 }
 
 // static
 std::string TemplateURLRef::DisplayURLToURLRef(
     const base::string16& display_url) {
   base::string16 result = display_url;
-  ReplaceSubstringsAfterOffset(&result, 0, ASCIIToUTF16(kDisplaySearchTerms),
-                               ASCIIToUTF16(kSearchTermsParameterFull));
+  ReplaceSubstringsAfterOffset(&result, 0,
+                               base::ASCIIToUTF16(kDisplaySearchTerms),
+                               base::ASCIIToUTF16(kSearchTermsParameterFull));
   ReplaceSubstringsAfterOffset(
       &result, 0,
-      ASCIIToUTF16(kDisplayUnescapedSearchTerms),
-      ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull));
-  return UTF16ToUTF8(result);
+      base::ASCIIToUTF16(kDisplayUnescapedSearchTerms),
+      base::ASCIIToUTF16(kGoogleUnescapedSearchTermsParameterFull));
+  return base::UTF16ToUTF8(result);
 }
 
 const std::string& TemplateURLRef::GetHost() const {
   ParseIfNecessary();
   return host_;
 }
 
 const std::string& TemplateURLRef::GetPath() const {
   ParseIfNecessary();
   return path_;
@@ skipping 20 matching lines @@
   }
 
   // Always fall back on UTF-8 if it works.
   if (base::CodepageToUTF16(unescaped, base::kCodepageUTF8,
                             base::OnStringConversionError::FAIL, &result))
     return result;
 
   // When nothing worked, just use the escaped text. We have no idea what the
   // encoding is. We need to substitute spaces for pluses ourselves since we're
   // not sending it through an unescaper.
-  result = UTF8ToUTF16(term);
+  result = base::UTF8ToUTF16(term);
   std::replace(result.begin(), result.end(), '+', ' ');
   return result;
 }
 
 bool TemplateURLRef::HasGoogleBaseURLs() const {
   ParseIfNecessary();
   for (size_t i = 0; i < replacements_.size(); ++i) {
     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
       return true;
@@ skipping 462 matching lines @@
               *i,
               &url);
         }
         break;
 
       case GOOGLE_ORIGINAL_QUERY_FOR_SUGGESTION:
         DCHECK(!i->is_post_param);
         if (search_terms_args.accepted_suggestion >= 0 ||
             !search_terms_args.assisted_query_stats.empty()) {
           HandleReplacement(
-              "oq", UTF16ToUTF8(encoded_original_query), *i, &url);
+              "oq", base::UTF16ToUTF8(encoded_original_query), *i, &url);
         }
         break;
 
       case GOOGLE_PAGE_CLASSIFICATION:
         if (search_terms_args.page_classification !=
             AutocompleteInput::INVALID_SPEC) {
           HandleReplacement(
               "pgcl", base::IntToString(search_terms_args.page_classification),
               *i, &url);
         }
         break;
 
       case GOOGLE_RLZ: {
         DCHECK(!i->is_post_param);
         // On platforms that don't have RLZ, we still want this branch
         // to happen so that we replace the RLZ template with the
         // empty string.  (If we don't handle this case, we hit a
         // NOTREACHED below.)
         base::string16 rlz_string = search_terms_data.GetRlzParameterValue();
         if (!rlz_string.empty()) {
-          HandleReplacement("rlz", UTF16ToUTF8(rlz_string), *i, &url);
+          HandleReplacement("rlz", base::UTF16ToUTF8(rlz_string), *i, &url);
         }
         break;
       }
 
       case GOOGLE_SEARCH_CLIENT: {
         DCHECK(!i->is_post_param);
         std::string client = search_terms_data.GetSearchClient();
         if (!client.empty())
           HandleReplacement("client", client, *i, &url);
         break;
@@ skipping 25 matching lines @@
         HandleReplacement(std::string(), unescaped_terms, *i, &url);
         break;
       }
 
       case LANGUAGE:
         HandleReplacement(
             std::string(), search_terms_data.GetApplicationLocale(), *i, &url);
         break;
 
       case SEARCH_TERMS:
-        HandleReplacement(std::string(), UTF16ToUTF8(encoded_terms), *i, &url);
+        HandleReplacement(
+            std::string(), base::UTF16ToUTF8(encoded_terms), *i, &url);
         break;
 
       case GOOGLE_IMAGE_THUMBNAIL:
         HandleReplacement(
             std::string(), search_terms_args.image_thumbnail_content, *i, &url);
         break;
 
       case GOOGLE_IMAGE_URL:
         if (search_terms_args.image_url.is_valid()) {
           HandleReplacement(
@@ skipping 37 matching lines @@
 TemplateURLData::TemplateURLData()
     : show_in_default_list(false),
       safe_for_autoreplace(false),
       id(0),
       date_created(base::Time::Now()),
       last_modified(base::Time::Now()),
       created_by_policy(false),
       usage_count(0),
       prepopulate_id(0),
       sync_guid(base::GenerateGUID()),
-      keyword_(ASCIIToUTF16("dummy")),
+      keyword_(base::ASCIIToUTF16("dummy")),
       url_("x") {
 }
 
 TemplateURLData::~TemplateURLData() {
 }
 
 void TemplateURLData::SetKeyword(const base::string16& keyword) {
   DCHECK(!keyword.empty());
 
   // Case sensitive keyword matching is confusing. As such, we force all
@@ skipping 61 matching lines @@
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURL::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   return url_ref_.SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURL::IsGoogleSearchURLWithReplaceableKeyword() const {
   return (GetType() == NORMAL) && url_ref_.HasGoogleBaseURLs() &&
-      google_util::IsGoogleHostname(UTF16ToUTF8(data_.keyword()),
+      google_util::IsGoogleHostname(base::UTF16ToUTF8(data_.keyword()),
                                     google_util::DISALLOW_SUBDOMAIN);
 }
 
 bool TemplateURL::HasSameKeywordAs(const TemplateURL& other) const {
   return (data_.keyword() == other.data_.keyword()) ||
       (IsGoogleSearchURLWithReplaceableKeyword() &&
        other.IsGoogleSearchURLWithReplaceableKeyword());
 }
 
 TemplateURL::Type TemplateURL::GetType() const {
@@ skipping 89 matching lines @@
   // and ref are encoded in the same way.
   std::string input_encoding;
   base::string16 encoded_terms;
   base::string16 encoded_original_query;
   EncodeSearchTerms(search_terms_args, true, &input_encoding,
                     &encoded_terms, &encoded_original_query);
 
   std::string old_params((search_term_component == url_parse::Parsed::REF) ?
       url.ref() : url.query());
   std::string new_params(old_params, 0, search_terms_position.begin);
-  new_params += UTF16ToUTF8(search_terms_args.search_terms);
+  new_params += base::UTF16ToUTF8(search_terms_args.search_terms);
   new_params += old_params.substr(search_terms_position.end());
   url_canon::StdStringReplacements<std::string> replacements;
   if (search_term_component == url_parse::Parsed::REF)
     replacements.SetRefStr(new_params);
   else
     replacements.SetQueryStr(new_params);
   *result = url.ReplaceComponents(replacements);
   return true;
 }
 
@@ skipping 73 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }