Add utf_string_conversions to base namespace.

chrome/installer/util/installer_state_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 <windows.h>
 
 #include <fstream>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 258 matching lines @@
   Version new_version(kNewVersion);
   Version old_version(kOldVersion);
   ASSERT_TRUE(new_version.IsValid());
   ASSERT_TRUE(old_version.IsValid());
 
   base::FilePath installer_dir(
       installer_state.GetInstallerDirectory(new_version));
   EXPECT_FALSE(installer_dir.empty());
 
   base::FilePath new_version_dir(installer_state.target_path().Append(
-      UTF8ToWide(new_version.GetString())));
+      base::UTF8ToWide(new_version.GetString())));
   base::FilePath old_version_dir(installer_state.target_path().Append(
-      UTF8ToWide(old_version.GetString())));
+      base::UTF8ToWide(old_version.GetString())));
 
   EXPECT_FALSE(file_util::PathExists(new_version_dir));
   EXPECT_FALSE(file_util::PathExists(old_version_dir));
 
   EXPECT_FALSE(file_util::PathExists(installer_dir));
   file_util::CreateDirectory(installer_dir);
   EXPECT_TRUE(file_util::PathExists(new_version_dir));
 
   file_util::CreateDirectory(old_version_dir);
   EXPECT_TRUE(file_util::PathExists(old_version_dir));
@@ skipping 62 matching lines @@
 
   {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root, L"root_pit");
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
     RegKey chrome_key(root, dist->GetVersionKey().c_str(), KEY_ALL_ACCESS);
     EXPECT_TRUE(chrome_key.Valid());
     if (chrome_key.Valid()) {
       chrome_key.WriteValue(google_update::kRegVersionField,
-                            UTF8ToWide(current_version.GetString()).c_str());
+                            base::UTF8ToWide(
+                                current_version.GetString()).c_str());
       machine_state.Initialize();
       // TODO(tommi): Also test for when there exists a new_chrome.exe.
       Version found_version(*installer_state.GetCurrentVersion(machine_state));
       EXPECT_TRUE(found_version.IsValid());
       if (found_version.IsValid())
         EXPECT_TRUE(current_version.Equals(found_version));
     }
   }
 }
 
@@ skipping 150 matching lines @@
   ASSERT_TRUE(old_version.IsValid());
   ASSERT_TRUE(old_chrome_exe_version.IsValid());
   ASSERT_TRUE(chrome_exe_version.IsValid());
   ASSERT_TRUE(new_chrome_exe_version.IsValid());
 
   // Set up a bunch of version dir paths.
   base::FilePath version_dirs[] = {
     installer_state.target_path().Append(L"1.2.3.4"),
     installer_state.target_path().Append(L"1.2.3.5"),
     installer_state.target_path().Append(L"1.2.3.6"),
-    installer_state.target_path().Append(ASCIIToWide(kOldVersion)),
-    installer_state.target_path().Append(ASCIIToWide(kOldChromeExeVersion)),
+    installer_state.target_path().Append(base::ASCIIToWide(kOldVersion)),
+    installer_state.target_path().Append(
+        base::ASCIIToWide(kOldChromeExeVersion)),
     installer_state.target_path().Append(L"2.1.1.0"),
-    installer_state.target_path().Append(ASCIIToWide(kChromeExeVersion)),
-    installer_state.target_path().Append(ASCIIToWide(kNewVersion)),
+    installer_state.target_path().Append(base::ASCIIToWide(kChromeExeVersion)),
+    installer_state.target_path().Append(base::ASCIIToWide(kNewVersion)),
     installer_state.target_path().Append(L"3.9.1.1"),
   };
 
   // Create the version directories.
   for (int i = 0; i < arraysize(version_dirs); i++) {
     file_util::CreateDirectory(version_dirs[i]);
     EXPECT_TRUE(file_util::PathExists(version_dirs[i]));
   }
 
   // Create exes with the appropriate version resource.
@@ skipping 40 matching lines @@
   expected_remaining_dirs.insert(kOldChromeExeVersion);
   expected_remaining_dirs.insert(kChromeExeVersion);
   expected_remaining_dirs.insert(kNewChromeExeVersion);
 
   // Enumerate dirs in target_path(), ensure only desired remain.
   file_util::FileEnumerator version_enum(installer_state.target_path(), false,
       file_util::FileEnumerator::DIRECTORIES);
   for (base::FilePath next_version = version_enum.Next(); !next_version.empty();
        next_version = version_enum.Next()) {
     base::FilePath dir_name(next_version.BaseName());
-    Version version(WideToASCII(dir_name.value()));
+    Version version(base::WideToASCII(dir_name.value()));
     if (version.IsValid()) {
       EXPECT_TRUE(expected_remaining_dirs.erase(version.GetString()))
           << "Unexpected version dir found: " << version.GetString();
     }
   }
 
   std::set<std::string>::const_iterator iter(
       expected_remaining_dirs.begin());
   for (; iter != expected_remaining_dirs.end(); ++iter)
     ADD_FAILURE() << "Expected to find version dir for " << *iter;
@@ skipping 25 matching lines @@
   }
 
   // Initializes the InstallerState to use for a test run.  The returned
   // instance's critical update version is set to |version|.  |version| may be
   // NULL, in which case the critical update version is unset.
   MockInstallerState& Initialize(const Version* version) {
     cmd_line_ = version == NULL ?
         CommandLine::FromString(L"setup.exe") :
         CommandLine::FromString(
             L"setup.exe --critical-update-version=" +
-            ASCIIToWide(version->GetString()));
+            base::ASCIIToWide(version->GetString()));
     prefs_.reset(new MasterPreferences(cmd_line_));
     machine_state_.Initialize();
     installer_state_.Initialize(cmd_line_, *prefs_, machine_state_);
     return installer_state_;
   }
 
   static Version* low_version_;
   static Version* opv_version_;
   static Version* middle_version_;
   static Version* pv_version_;
@@ skipping 99 matching lines @@
   // Critical update newer than the new version.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }