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

chrome/browser/search_engines/template_url_service.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_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 310 matching lines @@
 
 // static
 base::string16 TemplateURLService::GenerateKeyword(const GURL& url) {
   DCHECK(url.is_valid());
   // Strip "www." off the front of the keyword; otherwise the keyword won't work
   // properly.  See http://code.google.com/p/chromium/issues/detail?id=6984 .
   // Special case: if the host was exactly "www." (not sure this can happen but
   // perhaps with some weird intranet and custom DNS server?), ensure we at
   // least don't return the empty string.
   base::string16 keyword(net::StripWWWFromHost(url));
-  return keyword.empty() ? ASCIIToUTF16("www") : keyword;
+  return keyword.empty() ? base::ASCIIToUTF16("www") : keyword;
 }
 
 // static
 base::string16 TemplateURLService::CleanUserInputKeyword(
     const base::string16& keyword) {
   // Remove the scheme.
   base::string16 result(base::i18n::ToLower(keyword));
   TrimWhitespace(result, TRIM_ALL, &result);
   url_parse::Component scheme_component;
-  if (url_parse::ExtractScheme(UTF16ToUTF8(keyword).c_str(),
+  if (url_parse::ExtractScheme(base::UTF16ToUTF8(keyword).c_str(),
                                static_cast<int>(keyword.length()),
                                &scheme_component)) {
     // If the scheme isn't "http" or "https", bail.  The user isn't trying to
     // type a web address, but rather an FTP, file:, or other scheme URL, or a
     // search query with some sort of initial operator (e.g. "site:").
     if (result.compare(0, scheme_component.end(),
-                       ASCIIToUTF16(content::kHttpScheme)) &&
+                       base::ASCIIToUTF16(content::kHttpScheme)) &&
         result.compare(0, scheme_component.end(),
-                       ASCIIToUTF16(content::kHttpsScheme)))
+                       base::ASCIIToUTF16(content::kHttpsScheme)))
       return base::string16();
 
     // Include trailing ':'.
     result.erase(0, scheme_component.end() + 1);
     // Many schemes usually have "//" after them, so strip it too.
-    const base::string16 after_scheme(ASCIIToUTF16("//"));
+    const base::string16 after_scheme(base::ASCIIToUTF16("//"));
     if (result.compare(0, after_scheme.length(), after_scheme) == 0)
       result.erase(0, after_scheme.length());
   }
 
   // Remove leading "www.".
   result = net::StripWWW(result);
 
   // Remove trailing "/".
   return (result.length() > 0 && result[result.length() - 1] == '/') ?
       result.substr(0, result.length() - 1) : result;
@@ skipping 18 matching lines @@
 
   if (!search_ref.SupportsReplacementUsingTermsData(search_terms_data))
     return GURL(t_url->url());
 
   // Use something obscure for the search terms argument so that in the rare
   // case the term replaces the URL it's unlikely another keyword would have the
   // same url.
   // TODO(jnd): Add additional parameters to get post data when the search URL
   // has post parameters.
   return GURL(search_ref.ReplaceSearchTermsUsingTermsData(
-      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("blah.blah.blah.blah.blah")),
+      TemplateURLRef::SearchTermsArgs(
+          base::ASCIIToUTF16("blah.blah.blah.blah.blah")),
       search_terms_data, NULL));
 }
 
 bool TemplateURLService::CanReplaceKeyword(
     const base::string16& keyword,
     const GURL& url,
     TemplateURL** template_url_to_replace) {
   DCHECK(!keyword.empty());  // This should only be called for non-empty
                              // keywords. If we need to support empty kewords
                              // the code needs to change slightly.
@@ skipping 862 matching lines @@
 
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 // static
 syncer::SyncData TemplateURLService::CreateSyncDataFromTemplateURL(
     const TemplateURL& turl) {
   sync_pb::EntitySpecifics specifics;
   sync_pb::SearchEngineSpecifics* se_specifics =
       specifics.mutable_search_engine();
-  se_specifics->set_short_name(UTF16ToUTF8(turl.short_name()));
-  se_specifics->set_keyword(UTF16ToUTF8(turl.keyword()));
+  se_specifics->set_short_name(base::UTF16ToUTF8(turl.short_name()));
+  se_specifics->set_keyword(base::UTF16ToUTF8(turl.keyword()));
   se_specifics->set_favicon_url(turl.favicon_url().spec());
   se_specifics->set_url(turl.url());
   se_specifics->set_safe_for_autoreplace(turl.safe_for_autoreplace());
   se_specifics->set_originating_url(turl.originating_url().spec());
   se_specifics->set_date_created(turl.date_created().ToInternalValue());
   se_specifics->set_input_encodings(JoinString(turl.input_encodings(), ';'));
   se_specifics->set_show_in_default_list(turl.show_in_default_list());
   se_specifics->set_suggestions_url(turl.suggestions_url());
   se_specifics->set_prepopulate_id(turl.prepopulate_id());
   se_specifics->set_instant_url(turl.instant_url());
@@ skipping 40 matching lines @@
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_DELETE,
                            sync_data));
     UMA_HISTOGRAM_ENUMERATION(kDeleteSyncedEngineHistogramName,
         DELETE_ENGINE_EMPTY_FIELD, DELETE_ENGINE_MAX);
     return NULL;
   }
 
   TemplateURLData data(existing_turl ?
       existing_turl->data() : TemplateURLData());
-  data.short_name = UTF8ToUTF16(specifics.short_name());
+  data.short_name = base::UTF8ToUTF16(specifics.short_name());
   data.originating_url = GURL(specifics.originating_url());
-  base::string16 keyword(UTF8ToUTF16(specifics.keyword()));
+  base::string16 keyword(base::UTF8ToUTF16(specifics.keyword()));
   // NOTE: Once this code has shipped in a couple of stable releases, we can
   // probably remove the migration portion, comment out the
   // "autogenerate_keyword" field entirely in the .proto file, and fold the
   // empty keyword case into the "delete data" block above.
   bool reset_keyword =
       specifics.autogenerate_keyword() || specifics.keyword().empty();
   if (reset_keyword)
-    keyword = ASCIIToUTF16("dummy");  // Will be replaced below.
+    keyword = base::ASCIIToUTF16("dummy");  // Will be replaced below.
   DCHECK(!keyword.empty());
   data.SetKeyword(keyword);
   data.SetURL(specifics.url());
   data.suggestions_url = specifics.suggestions_url();
   data.instant_url = specifics.instant_url();
   data.image_url = specifics.image_url();
   data.new_tab_url = specifics.new_tab_url();
   data.search_url_post_params = specifics.search_url_post_params();
   data.suggestions_url_post_params = specifics.suggestions_url_post_params();
   data.instant_url_post_params = specifics.instant_url_post_params();
@@ skipping 102 matching lines @@
 
     // Add specific initializers, if any.
     for (int i(0); i < num_initializers; ++i) {
       DCHECK(initializers[i].keyword);
       DCHECK(initializers[i].url);
       DCHECK(initializers[i].content);
 
       // TemplateURLService ends up owning the TemplateURL, don't try and free
       // it.
       TemplateURLData data;
-      data.short_name = UTF8ToUTF16(initializers[i].content);
-      data.SetKeyword(UTF8ToUTF16(initializers[i].keyword));
+      data.short_name = base::UTF8ToUTF16(initializers[i].content);
+      data.SetKeyword(base::UTF8ToUTF16(initializers[i].keyword));
       data.SetURL(initializers[i].url);
       TemplateURL* template_url = new TemplateURL(profile_, data);
       AddNoNotify(template_url, true);
 
       // Set the first provided identifier to be the default.
       if (i == 0)
         SetDefaultSearchProviderNoNotify(template_url);
     }
   }
 
@@ skipping 152 matching lines @@
     image_url = t_url->image_url();
     new_tab_url = t_url->new_tab_url();
     search_url_post_params = t_url->search_url_post_params();
     suggest_url_post_params = t_url->suggestions_url_post_params();
     instant_url_post_params = t_url->instant_url_post_params();
     image_url_post_params = t_url->image_url_post_params();
     GURL icon_gurl = t_url->favicon_url();
     if (!icon_gurl.is_empty())
       icon_url = icon_gurl.spec();
     encodings = JoinString(t_url->input_encodings(), ';');
-    short_name = UTF16ToUTF8(t_url->short_name());
-    keyword = UTF16ToUTF8(t_url->keyword());
+    short_name = base::UTF16ToUTF8(t_url->short_name());
+    keyword = base::UTF16ToUTF8(t_url->keyword());
     id_string = base::Int64ToString(t_url->id());
     prepopulate_id = base::Int64ToString(t_url->prepopulate_id());
     for (size_t i = 0; i < t_url->alternate_urls().size(); ++i)
       alternate_urls.AppendString(t_url->alternate_urls()[i]);
     search_terms_replacement_key = t_url->search_terms_replacement_key();
   }
   prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, enabled);
   prefs->SetString(prefs::kDefaultSearchProviderSearchURL, search_url);
   prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, suggest_url);
   prefs->SetString(prefs::kDefaultSearchProviderInstantURL, instant_url);
@@ skipping 29 matching lines @@
       prefs->FindPreference(prefs::kDefaultSearchProviderSearchURL);
   *is_managed = pref && pref->IsManaged();
 
   if (!prefs->GetBoolean(prefs::kDefaultSearchProviderEnabled)) {
     // The user doesn't want a default search provider.
     default_provider->reset(NULL);
     return true;
   }
 
   base::string16 name =
-      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderName));
+      base::UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderName));
   base::string16 keyword =
-      UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
+      base::UTF8ToUTF16(prefs->GetString(prefs::kDefaultSearchProviderKeyword));
   // Force keyword to be non-empty.
   // TODO(pkasting): This is only necessary as long as we're potentially loading
   // older prefs where empty keywords are theoretically possible.  Eventually
   // this code can be replaced with a DCHECK(!keyword.empty());.
   bool update_keyword = keyword.empty();
   if (update_keyword)
-    keyword = ASCIIToUTF16("dummy");
+    keyword = base::ASCIIToUTF16("dummy");
   std::string search_url =
       prefs->GetString(prefs::kDefaultSearchProviderSearchURL);
   // Force URL to be non-empty.  We've never supported this case, but past bugs
   // might have resulted in it slipping through; eventually this code can be
   // replaced with a DCHECK(!search_url.empty());.
   if (search_url.empty())
     return false;
   std::string suggest_url =
       prefs->GetString(prefs::kDefaultSearchProviderSuggestURL);
   std::string instant_url =
@@ skipping 239 matching lines @@
     return;
 
   if (!profile_)
     return;
 
   HistoryService* history =
       HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   if (!history)
     return;
 
-  GURL url(URLFixerUpper::FixupURL(UTF16ToUTF8(t_url.keyword()),
+  GURL url(URLFixerUpper::FixupURL(base::UTF16ToUTF8(t_url.keyword()),
                                    std::string()));
   if (!url.is_valid())
     return;
 
   // Synthesize a visit for the keyword. This ensures the url for the keyword is
   // autocompleted even if the user doesn't type the url in directly.
   history->AddPage(url, base::Time::Now(), NULL, 0, GURL(),
                    history::RedirectList(),
                    content::PAGE_TRANSITION_KEYWORD_GENERATED,
                    history::SOURCE_BROWSED, false);
@@ skipping 399 matching lines @@
       if (!GetTemplateURLForKeyword(keyword_candidate))
         return keyword_candidate;
     }
   }
 
   // We try to uniquify the keyword by appending a special character to the end.
   // This is a best-effort approach where we try to preserve the original
   // keyword and let the user do what they will after our attempt.
   base::string16 keyword_candidate(turl.keyword());
   do {
-    keyword_candidate.append(ASCIIToUTF16("_"));
+    keyword_candidate.append(base::ASCIIToUTF16("_"));
   } while (GetTemplateURLForKeyword(keyword_candidate));
 
   return keyword_candidate;
 }
 
 bool TemplateURLService::IsLocalTemplateURLBetter(
     const TemplateURL* local_turl,
     const TemplateURL* sync_turl) {
   DCHECK(GetTemplateURLForGUID(local_turl->sync_guid()));
   return local_turl->last_modified() > sync_turl->last_modified() ||
@@ skipping 279 matching lines @@
           "Search.DefaultSearchProvider",
           default_search_provider_->prepopulate_id(),
           TemplateURLPrepopulateData::kMaxPrepopulatedEngineID);
     }
   }
 }
 
 TemplateURL* TemplateURLService::CreateTemplateURLForExtension(
     const ExtensionKeyword& extension_keyword) const {
   TemplateURLData data;
-  data.short_name = UTF8ToUTF16(extension_keyword.extension_name);
-  data.SetKeyword(UTF8ToUTF16(extension_keyword.extension_keyword));
+  data.short_name = base::UTF8ToUTF16(extension_keyword.extension_name);
+  data.SetKeyword(base::UTF8ToUTF16(extension_keyword.extension_keyword));
   // This URL is not actually used for navigation. It holds the extension's
   // ID, as well as forcing the TemplateURL to be treated as a search keyword.
   data.SetURL(std::string(extensions::kExtensionScheme) + "://" +
       extension_keyword.extension_id + "/?q={searchTerms}");
   return new TemplateURL(profile_, data);
 }
 
 TemplateURL* TemplateURLService::FindTemplateURLForExtension(
     const std::string& extension_id,
     TemplateURL::Type type) const {
@@ skipping 39 matching lines @@
           new_dse = *i;
           break;
         }
       }
     }
   }
   if (!new_dse)
     new_dse = FindNewDefaultSearchProvider();
   SetDefaultSearchProviderNoNotify(new_dse);
 }