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

chrome/browser/autocomplete/autocomplete_provider_unittest.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_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 70 matching lines @@
                          bool minimal_changes) {
   if (minimal_changes)
     return;
 
   matches_.clear();
 
   // Generate 4 results synchronously, the rest later.
   AddResults(0, 1);
   AddResultsWithSearchTermsArgs(
       1, 1, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("echo")));
+      TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("echo")));
   AddResultsWithSearchTermsArgs(
       2, 1, AutocompleteMatchType::NAVSUGGEST,
-      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("nav")));
+      TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("nav")));
   AddResultsWithSearchTermsArgs(
       3, 1, AutocompleteMatchType::SEARCH_SUGGEST,
-      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("query")));
+      TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("query")));
 
   if (input.matches_requested() == AutocompleteInput::ALL_MATCHES) {
     done_ = false;
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&TestProvider::Run, this));
   }
 }
 
 void TestProvider::Run() {
   DCHECK_GT(kResultsPerProvider, 0U);
@@ skipping 12 matching lines @@
 }
 
 void TestProvider::AddResultsWithSearchTermsArgs(
     int start_at,
     int num,
     AutocompleteMatch::Type type,
     const TemplateURLRef::SearchTermsArgs& search_terms_args) {
   for (int i = start_at; i < num; i++) {
     AutocompleteMatch match(this, relevance_ - i, false, type);
 
-    match.fill_into_edit = prefix_ + UTF8ToUTF16(base::IntToString(i));
-    match.destination_url = GURL(UTF16ToUTF8(match.fill_into_edit));
+    match.fill_into_edit = prefix_ + base::UTF8ToUTF16(base::IntToString(i));
+    match.destination_url = GURL(base::UTF16ToUTF8(match.fill_into_edit));
     match.allowed_to_be_default_match = true;
 
     match.contents = match.fill_into_edit;
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     match.description = match.fill_into_edit;
     match.description_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     match.search_terms_args.reset(
         new TemplateURLRef::SearchTermsArgs(search_terms_args));
@@ skipping 93 matching lines @@
   // TODO: Move it outside this method, after refactoring the existing
   // unit tests.  Specifically:
   //   (1) Make sure that AutocompleteMatch.keyword is set iff there is
   //       a corresponding call to RegisterTemplateURL; otherwise the
   //       controller flow will crash; this practically means that
   //       RunTests/ResetControllerXXX/RegisterTemplateURL should
   //       be coordinated with each other.
   //   (2) Inject test arguments rather than rely on the hardcoded values, e.g.
   //       don't rely on kResultsPerProvided and default relevance ordering
   //       (B > A).
-  RegisterTemplateURL(ASCIIToUTF16(kTestTemplateURLKeyword),
+  RegisterTemplateURL(base::ASCIIToUTF16(kTestTemplateURLKeyword),
                       "http://aqs/{searchTerms}/{google:assistedQueryStats}");
 
   ACProviders providers;
 
   // Construct two new providers, with either the same or different prefixes.
   TestProvider* provider1 = new TestProvider(
       kResultsPerProvider,
-      ASCIIToUTF16("http://a"),
+      base::ASCIIToUTF16("http://a"),
       &profile_,
-      ASCIIToUTF16(kTestTemplateURLKeyword));
+      base::ASCIIToUTF16(kTestTemplateURLKeyword));
   provider1->AddRef();
   providers.push_back(provider1);
 
   TestProvider* provider2 = new TestProvider(
       kResultsPerProvider * 2,
-      same_destinations ? ASCIIToUTF16("http://a") : ASCIIToUTF16("http://b"),
+      same_destinations ? base::ASCIIToUTF16("http://a")
+                        : base::ASCIIToUTF16("http://b"),
       &profile_,
       base::string16());
   provider2->AddRef();
   providers.push_back(provider2);
 
   // Reset the controller to contain our new providers.
   controller_.reset(new AutocompleteController(&profile_, NULL, 0));
   // We're going to swap the providers vector, but the old vector should be
   // empty so no elements need to be freed at this point.
   EXPECT_TRUE(controller_->providers_.empty());
@@ skipping 23 matching lines @@
   data.SetURL("http://defaultturl/{searchTerms}");
   TemplateURL* default_t_url = new TemplateURL(&profile_, data);
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
   turl_model->Add(default_t_url);
   turl_model->SetDefaultSearchProvider(default_t_url);
   TemplateURLID default_provider_id = default_t_url->id();
   ASSERT_NE(0, default_provider_id);
 
   // Create another TemplateURL for KeywordProvider.
-  data.short_name = ASCIIToUTF16("k");
-  data.SetKeyword(ASCIIToUTF16("k"));
+  data.short_name = base::ASCIIToUTF16("k");
+  data.SetKeyword(base::ASCIIToUTF16("k"));
   data.SetURL("http://keyword/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   controller_.reset(new AutocompleteController(
       &profile_, NULL,
       AutocompleteProvider::TYPE_KEYWORD | AutocompleteProvider::TYPE_SEARCH));
 }
 
 void AutocompleteProviderTest::ResetControllerWithKeywordProvider() {
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
 
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
 
   // Create a TemplateURL for KeywordProvider.
   TemplateURLData data;
-  data.short_name = ASCIIToUTF16("foo.com");
-  data.SetKeyword(ASCIIToUTF16("foo.com"));
+  data.short_name = base::ASCIIToUTF16("foo.com");
+  data.SetKeyword(base::ASCIIToUTF16("foo.com"));
   data.SetURL("http://foo.com/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   // Create another TemplateURL for KeywordProvider.
-  data.short_name = ASCIIToUTF16("bar.com");
-  data.SetKeyword(ASCIIToUTF16("bar.com"));
+  data.short_name = base::ASCIIToUTF16("bar.com");
+  data.SetKeyword(base::ASCIIToUTF16("bar.com"));
   data.SetURL("http://bar.com/{searchTerms}");
   keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   controller_.reset(new AutocompleteController(
       &profile_, NULL, AutocompleteProvider::TYPE_KEYWORD));
 }
 
 void AutocompleteProviderTest::RunTest() {
-  RunQuery(ASCIIToUTF16("a"));
+  RunQuery(base::ASCIIToUTF16("a"));
 }
 
 void AutocompleteProviderTest::RunRedundantKeywordTest(
     const KeywordTestData* match_data,
     size_t size) {
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
     AutocompleteMatch match;
     match.relevance = 1000;  // Arbitrary non-zero value.
     match.allowed_to_be_default_match = true;
@@ skipping 16 matching lines @@
 void AutocompleteProviderTest::RunAssistedQueryStatsTest(
     const AssistedQueryStatsTestData* aqs_test_data,
     size_t size) {
   // Prepare input.
   const size_t kMaxRelevance = 1000;
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
     AutocompleteMatch match(NULL, kMaxRelevance - i, false,
                             aqs_test_data[i].match_type);
     match.allowed_to_be_default_match = true;
-    match.keyword = ASCIIToUTF16(kTestTemplateURLKeyword);
+    match.keyword = base::ASCIIToUTF16(kTestTemplateURLKeyword);
     match.search_terms_args.reset(
         new TemplateURLRef::SearchTermsArgs(base::string16()));
     matches.push_back(match);
   }
   result_.Reset();
   result_.AppendMatches(matches);
 
   // Update AQS.
   controller_->UpdateAssistedQueryStats(&result_);
 
@@ skipping 19 matching lines @@
 
 void AutocompleteProviderTest::RunExactKeymatchTest(
     bool allow_exact_keyword_match) {
   // Send the controller input which exactly matches the keyword provider we
   // created in ResetControllerWithKeywordAndSearchProviders().  The default
   // match should thus be a search-other-engine match iff
   // |allow_exact_keyword_match| is true.  Regardless, the match should
   // be from SearchProvider.  (It provides all verbatim search matches,
   // keyword or not.)
   controller_->Start(AutocompleteInput(
-      ASCIIToUTF16("k test"), base::string16::npos, base::string16(), GURL(),
-      AutocompleteInput::INVALID_SPEC, true, false, allow_exact_keyword_match,
-      AutocompleteInput::SYNCHRONOUS_MATCHES));
+      base::ASCIIToUTF16("k test"), base::string16::npos, base::string16(),
+      GURL(), AutocompleteInput::INVALID_SPEC, true, false,
+      allow_exact_keyword_match, AutocompleteInput::SYNCHRONOUS_MATCHES));
   EXPECT_TRUE(controller_->done());
   EXPECT_EQ(AutocompleteProvider::TYPE_SEARCH,
       controller_->result().default_match()->provider->type());
   EXPECT_EQ(allow_exact_keyword_match ?
       AutocompleteMatchType::SEARCH_OTHER_ENGINE :
       AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
       controller_->result().default_match()->type);
 }
 
 void AutocompleteProviderTest::CopyResults() {
@@ skipping 85 matching lines @@
   EXPECT_EQ("http://defaultturl/k%20test?a=b",
             result_.match_at(1)->destination_url.possibly_invalid_spec());
 }
 
 // Test that redundant associated keywords are removed.
 TEST_F(AutocompleteProviderTest, RedundantKeywordsIgnoredInResult) {
   ResetControllerWithKeywordProvider();
 
   {
     KeywordTestData duplicate_url[] = {
-      { ASCIIToUTF16("fo"), base::string16(), false },
-      { ASCIIToUTF16("foo.com"), base::string16(), true },
-      { ASCIIToUTF16("foo.com"), base::string16(), false }
+      { base::ASCIIToUTF16("fo"), base::string16(), false },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), true },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), false }
     };
 
     SCOPED_TRACE("Duplicate url");
     RunRedundantKeywordTest(duplicate_url, ARRAYSIZE_UNSAFE(duplicate_url));
   }
 
   {
     KeywordTestData keyword_match[] = {
-      { ASCIIToUTF16("foo.com"), ASCIIToUTF16("foo.com"), false },
-      { ASCIIToUTF16("foo.com"), base::string16(), false }
+      { base::ASCIIToUTF16("foo.com"), base::ASCIIToUTF16("foo.com"), false },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), false }
     };
 
     SCOPED_TRACE("Duplicate url with keyword match");
     RunRedundantKeywordTest(keyword_match, ARRAYSIZE_UNSAFE(keyword_match));
   }
 
   {
     KeywordTestData multiple_keyword[] = {
-      { ASCIIToUTF16("fo"), base::string16(), false },
-      { ASCIIToUTF16("foo.com"), base::string16(), true },
-      { ASCIIToUTF16("foo.com"), base::string16(), false },
-      { ASCIIToUTF16("bar.com"), base::string16(), true },
+      { base::ASCIIToUTF16("fo"), base::string16(), false },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), true },
+      { base::ASCIIToUTF16("foo.com"), base::string16(), false },
+      { base::ASCIIToUTF16("bar.com"), base::string16(), true },
     };
 
     SCOPED_TRACE("Duplicate url with multiple keywords");
     RunRedundantKeywordTest(multiple_keyword,
         ARRAYSIZE_UNSAFE(multiple_keyword));
   }
 }
 
 TEST_F(AutocompleteProviderTest, UpdateAssistedQueryStats) {
   ResetControllerWithTestProviders(false, NULL, NULL);
@@ skipping 44 matching lines @@
   ResetControllerWithKeywordAndSearchProviders();
 
   // For the destination URL to have aqs parameters for query formulation time
   // and the field trial triggered bit, many conditions need to be satisfied.
   AutocompleteMatch match(NULL, 1100, false,
                           AutocompleteMatchType::SEARCH_SUGGEST);
   GURL url(GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456)));
   EXPECT_TRUE(url.path().empty());
 
   // The protocol needs to be https.
-  RegisterTemplateURL(ASCIIToUTF16(kTestTemplateURLKeyword),
+  RegisterTemplateURL(base::ASCIIToUTF16(kTestTemplateURLKeyword),
                       "https://aqs/{searchTerms}/{google:assistedQueryStats}");
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // There needs to be a keyword provider.
-  match.keyword = ASCIIToUTF16(kTestTemplateURLKeyword);
+  match.keyword = base::ASCIIToUTF16(kTestTemplateURLKeyword);
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // search_terms_args needs to be set.
   match.search_terms_args.reset(
       new TemplateURLRef::SearchTermsArgs(base::string16()));
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_TRUE(url.path().empty());
 
   // assisted_query_stats needs to have been previously set.
@@ skipping 17 matching lines @@
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j4&", url.path());
 
   // Test page classification and field trial triggered set.
   controller_->search_provider_->field_trial_triggered_in_session_ = true;
   EXPECT_TRUE(
       controller_->search_provider_->field_trial_triggered_in_session());
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j4&", url.path());
 }