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

chrome/browser/autocomplete/history_url_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/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/net/url_fixer_upper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 using content::TestBrowserThreadBundle;
 
 struct TestURLInfo {
   const char* url;
   const char* title;
   int visit_count;
   int typed_count;
@@ skipping 199 matching lines @@
   // be more recent than the "archived history" threshold for the data to go
   // into the main database.
   //
   // TODO(brettw) It would be nice if we could test this behavior, in which
   // case the time would be specifed in the test_db structure.
   Time visit_time = Time::Now() - TimeDelta::FromDays(80);
 
   for (size_t i = 0; i < arraysize(test_db); ++i) {
     const TestURLInfo& cur = test_db[i];
     const GURL current_url(cur.url);
-    history_service_->AddPageWithDetails(current_url, UTF8ToUTF16(cur.title),
+    history_service_->AddPageWithDetails(current_url,
+                                         base::UTF8ToUTF16(cur.title),
                                          cur.visit_count, cur.typed_count,
                                          visit_time, false,
                                          history::SOURCE_BROWSED);
   }
 
   history_service_->AddPageWithDetails(
-      GURL("http://p/"), UTF8ToUTF16("p"), 0, 0,
+      GURL("http://p/"), base::UTF8ToUTF16("p"), 0, 0,
       Time::Now() -
       TimeDelta::FromDays(history::kLowQualityMatchAgeLimitInDays - 1),
       false, history::SOURCE_BROWSED);
 }
 
 void HistoryURLProviderTest::RunTest(
     const base::string16 text,
     const base::string16& desired_tld,
     bool prevent_inline_autocomplete,
     const UrlAndLegalDefault* expected_urls,
@@ skipping 152 matching lines @@
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"http://redirects/A", 30},
     {"http://redirects/B", 20},
     {"http://redirects/C", 10}
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     history_service_->AddPageWithDetails(GURL(test_cases[i].url),
-        UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
+        ASCIIToUTF16("Title"), test_cases[i].count, test_cases[i].count,
         Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // Create a B->C->A redirect chain, but set the visit counts such that they
   // will appear in A,B,C order in the results. The autocomplete query will
   // search for the most recent visit when looking for redirects, so this will
   // be found even though the previous visits had no redirects.
   history::RedirectList redirects_to_a;
   redirects_to_a.push_back(GURL(test_cases[1].url));
   redirects_to_a.push_back(GURL(test_cases[2].url));
   redirects_to_a.push_back(GURL(test_cases[0].url));
   history_service_->AddPage(GURL(test_cases[0].url), base::Time::Now(),
       NULL, 0, GURL(), redirects_to_a, content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, true);
 
   // Because all the results are part of a redirect chain with other results,
   // all but the first one (A) should be culled. We should get the default
   // "what you typed" result, plus this one.
   const base::string16 typing(ASCIIToUTF16("http://redirects/"));
   const UrlAndLegalDefault expected_results[] = {
-    { UTF16ToUTF8(typing), true },
+    { base::UTF16ToUTF8(typing), true },
     { test_cases[0].url, false }
   };
   RunTest(typing, base::string16(), true, expected_results,
           arraysize(expected_results));
 }
 
 TEST_F(HistoryURLProviderTest, WhatYouTyped) {
   // Make sure we suggest a What You Typed match at the right times.
   RunTest(ASCIIToUTF16("wytmatch"), base::string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("wytmatch foo bar"), base::string16(), false, NULL, 0);
@@ skipping 21 matching lines @@
 }
 
 TEST_F(HistoryURLProviderTest, Fixup) {
   // Test for various past crashes we've had.
   RunTest(ASCIIToUTF16("\\"), base::string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("#"), base::string16(), false, NULL, 0);
   RunTest(ASCIIToUTF16("%20"), base::string16(), false, NULL, 0);
   const UrlAndLegalDefault fixup_crash[] = {
     { "http://%EF%BD%A5@s/", true }
   };
-  RunTest(WideToUTF16(L"\uff65@s"), base::string16(), false, fixup_crash,
+  RunTest(base::WideToUTF16(L"\uff65@s"), base::string16(), false, fixup_crash,
           arraysize(fixup_crash));
-  RunTest(WideToUTF16(L"\u2015\u2015@ \uff7c"), base::string16(), false,
+  RunTest(base::WideToUTF16(L"\u2015\u2015@ \uff7c"), base::string16(), false,
           NULL, 0);
 
   // Fixing up "file:" should result in an inline autocomplete offset of just
   // after "file:", not just after "file://".
   const base::string16 input_1(ASCIIToUTF16("file:"));
   const UrlAndLegalDefault fixup_1[] = {
     { "file:///C:/foo.txt", true }
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(input_1, base::string16(), false, fixup_1,
                                   arraysize(fixup_1)));
@@ skipping 293 matching lines @@
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"https://testsearch.com/", 30},
     {"https://testsearch.com/?q=foobar", 20},
     {"http://foobar.com/", 10}
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     history_service_->AddPageWithDetails(GURL(test_cases[i].url),
-        UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
+        base::UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
         Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // We should not see search URLs when typing a previously used query.
   const UrlAndLegalDefault expected_when_searching_query[] = {
     { test_cases[2].url, false }
   };
   RunTest(ASCIIToUTF16("foobar"), base::string16(), true,
       expected_when_searching_query, arraysize(expected_when_searching_query));
 
@@ skipping 80 matching lines @@
       EXPECT_EQ(test_cases[i].offsets[match_index],
                 match.contents_class[match_index].offset);
       EXPECT_EQ(ACMatchClassification::URL |
                 (match_index == test_cases[i].match_classification_index ?
                  ACMatchClassification::MATCH : 0),
                 match.contents_class[match_index].style);
     }
     EXPECT_EQ(npos, test_cases[i].offsets[match.contents_class.size()]);
   }
 }