Update uses of UTF conversions in chrome_frame/, chromeos/, components/ to use the base:: namespace.

chrome_frame/test/test_with_web_server.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_frame/test/test_with_web_server.h"
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 105 matching lines @@
   CFInstall_src_path = chrome_frame_source_path.AppendASCII("CFInstall.js");
   CFInstall_path_ = test_file_path_.AppendASCII("CFInstall.js");
 
   ASSERT_TRUE(base::CopyFile(CFInstall_src_path, CFInstall_path_));
 
   loop_ = new chrome_frame_test::TimedMsgLoop();
   loop_->set_snapshot_on_timeout(true);
   local_address_ = chrome_frame_test::GetLocalIPv4Address();
   listener_mock_ = new testing::StrictMock<MockWebServerListener>();
   server_mock_ = new testing::StrictMock<MockWebServer>(
-      1337, ASCIIToWide(local_address_),
+      1337, base::ASCIIToWide(local_address_),
       chrome_frame_test::GetTestDataFolder());
   server_mock_->set_listener(listener_mock_);
 }
 
 // static
 void ChromeFrameTestWithWebServer::TearDownTestCase() {
   delete server_mock_;
   server_mock_ = NULL;
   delete listener_mock_;
   listener_mock_ = NULL;
@@ skipping 30 matching lines @@
   loop().RunUntilIdle();
   testing::Mock::VerifyAndClear(listener_mock_);
   testing::Mock::VerifyAndClear(server_mock_);
 }
 
 bool ChromeFrameTestWithWebServer::LaunchBrowser(BrowserKind browser,
                                                  const wchar_t* page) {
   std::wstring url = page;
 
   // We should resolve the URL only if it is a relative url.
-  GURL parsed_url(WideToUTF8(page));
+  GURL parsed_url(base::WideToUTF8(page));
   if (!parsed_url.has_scheme()) {
     url = server_mock().Resolve(page);
   }
 
   browser_ = browser;
   if (browser == IE) {
     browser_handle_.Set(chrome_frame_test::LaunchIE(url));
   } else if (browser == CHROME) {
     const base::FilePath& user_data_dir = GetChromeUserDataDirectory();
     chrome_frame_test::OverrideDataDirectoryForThisTest(user_data_dir.value());
@@ skipping 119 matching lines @@
   if (!version_info) {
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     base::Version ver_system;
     InstallUtil::GetChromeVersion(dist, true, &ver_system);
     base::Version ver_user;
     InstallUtil::GetChromeVersion(dist, false, &ver_system);
     ASSERT_TRUE(ver_system.IsValid() || ver_user.IsValid());
 
     bool system_install = ver_system.IsValid();
     base::FilePath cf_dll_path(installer::GetChromeInstallPath(system_install, dist));
-    cf_dll_path = cf_dll_path.Append(UTF8ToWide(
+    cf_dll_path = cf_dll_path.Append(base::UTF8ToWide(
         ver_system.IsValid() ? ver_system.GetString() : ver_user.GetString()));
     cf_dll_path = cf_dll_path.Append(kChromeFrameDllName);
     version_info = FileVersionInfo::CreateFileVersionInfo(cf_dll_path);
     if (version_info)
       version = version_info->product_version();
   }
 
-  server_mock().set_expected_result(WideToUTF8(version));
+  server_mock().set_expected_result(base::WideToUTF8(version));
 
   EXPECT_TRUE(version_info);
   EXPECT_FALSE(version.empty());
 
   SimpleBrowserTestExpectedResult(browser, page, WideToASCII(version).c_str());
 }
 
 // MockWebServer methods
 void MockWebServer::ExpectAndServeRequest(CFInvocation invocation,
                                           const std::wstring& url) {
@@ skipping 41 matching lines @@
     const test_server::Request& request,
     CFInvocation invocation,
     bool add_no_cache_header) {
   static const wchar_t kEchoHeader[] = L"/echoheader?";
   if (request_uri.find(kEchoHeader) != std::wstring::npos) {
     std::wstring header = request_uri.substr(
         wcslen(kEchoHeader),
         request_uri.length() - wcslen(kEchoHeader));
 
     std::string header_value = http_utils::GetHttpHeaderFromHeaderList(
-        WideToUTF8(header), request.headers());
+        base::WideToUTF8(header), request.headers());
     connection->Send(header_value, "");
     return;
   }
   // Convert |request_uri| to a path.
   std::wstring path = request_uri;
   size_t query_index = request_uri.find(L"?");
   if (query_index != std::string::npos) {
     path = path.erase(query_index);
   }
   base::FilePath file_path = root_dir_;
   if (path.size())
     file_path = file_path.Append(path.substr(1));  // remove first '/'
 
   std::string headers, body;
   std::string content_type;
   if (base::PathExists(file_path) &&
       !base::DirectoryExists(file_path)) {
     base::FilePath mock_http_headers(file_path.value() + L".mock-http-headers");
     if (base::PathExists(mock_http_headers)) {
       headers = GetMockHttpHeaders(mock_http_headers);
       content_type = http_utils::GetHttpHeaderFromHeaderList("Content-type",
                                                              headers);
     } else {
       EXPECT_TRUE(net::GetMimeTypeFromFile(file_path, &content_type));
-      VLOG(1) << "Going to send file (" << WideToUTF8(file_path.value())
+      VLOG(1) << "Going to send file (" << base::WideToUTF8(file_path.value())
               << ") with content type (" << content_type << ")";
       headers = CreateHttpHeaders(invocation, add_no_cache_header,
                                   content_type);
     }
 
     EXPECT_FALSE(headers.empty());
 
     EXPECT_TRUE(base::ReadFileToString(file_path, &body))
-        << "Could not read file (" << WideToUTF8(file_path.value()) << ")";
+        << "Could not read file ("
+        << base::WideToUTF8(file_path.value()) << ")";
     if (invocation.type() == CFInvocation::META_TAG &&
         StartsWithASCII(content_type, "text/html", false)) {
       EXPECT_TRUE(chrome_frame_test::AddCFMetaTag(&body)) << "Could not add "
           << "meta tag to HTML file.";
     }
   } else {
     VLOG(1) << "Going to send 404 for non-existent file ("
-            << WideToUTF8(file_path.value()) << ")";
+            << base::WideToUTF8(file_path.value()) << ")";
     headers = "HTTP/1.1 404 Not Found";
     body = "";
   }
   connection->Send(headers, body);
 }
 
 const wchar_t kPostMessageBasicPage[] = L"postmessage_basic_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_PostMessageBasic) {
   SimpleBrowserTest(IE, kPostMessageBasicPage);
@@ skipping 504 matching lines @@
   loop().RunFor(kChromeFrameLongNavigationTimeout);
 
   test_server::SimpleWebServer* ws = server.web_server();
   const test_server::ConnectionList& connections = ws->connections();
   test_server::ConnectionList::const_iterator it = connections.begin();
   int requests_for_first_page = 0;
   for (; it != connections.end(); ++it) {
     test_server::Connection* c = (*it);
     const test_server::Request& r = c->request();
     if (!r.path().empty() &&
-        ASCIIToWide(r.path().substr(1)).compare(kPages[0]) == 0) {
+        base::ASCIIToWide(r.path().substr(1)).compare(kPages[0]) == 0) {
       requests_for_first_page++;
       std::string ua(GetHeaderValue(r.headers(), "User-Agent"));
       EXPECT_NE(std::string::npos, ua.find("chromeframe"));
     }
   }
   EXPECT_GT(requests_for_first_page, 1);
 }
 
 // See bug 36694 for details.  http://crbug.com/36694
 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_TestDownloadFromForm) {
@@ skipping 126 matching lines @@
 // This test loads a large page and ensures that the full page contents are
 // actually loaded via a self-validating HTML page. This is done due to a bug
 // whereby the middle of the response stream would sometimes be truncated when
 // loading a CF document. See http://crbug.com/178421 for details.
 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_LargePageLoad) {
   const wchar_t kLargePageLoadPage[] =
       L"chrome_frame_large_page.html";
 
   SimpleBrowserTest(IE, kLargePageLoadPage);
 }