Move platform_thread to base/threading and put in the base namespace. I left ...

chrome/test/mini_installer_test/chrome_mini_installer.cc

 // Copyright (c) 2010 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/test/mini_installer_test/chrome_mini_installer.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
-#include "base/platform_thread.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/threading/platform_thread.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
 
 ChromeMiniInstaller::ChromeMiniInstaller(const std::wstring& install_type,
@@ skipping 275 matching lines @@
 bool ChromeMiniInstaller::CloseUninstallWindow() {
   HWND hndl = NULL;
   int timer = 0;
   std::wstring window_name;
   if (is_chrome_frame_)
     window_name = mini_installer_constants::kChromeFrameAppName;
   else
     window_name = mini_installer_constants::kChromeUninstallDialogName;
   while (hndl == NULL && timer < 5000) {
     hndl = FindWindow(NULL, window_name.c_str());
-    PlatformThread::Sleep(200);
+    base::PlatformThread::Sleep(200);
     timer = timer + 200;
   }
 
   if (!is_chrome_frame_) {
     if (hndl == NULL)
       hndl = FindWindow(NULL, mini_installer_constants::kChromeBuildType);
 
     if (hndl == NULL)
       return false;
 
@@ skipping 10 matching lines @@
   // This loop iterates through all of the top-level Windows
   // named Chrome_WidgetWin_0 and closes them
   while ((base::GetProcessCount(installer::kChromeExe, NULL) > 0) &&
          (timer < 40000)) {
     // Chrome may have been launched, but the window may not have appeared
     // yet. Wait for it to appear for 10 seconds, but exit if it takes longer
     // than that.
     while (!handle && timer < 10000) {
       handle = FindWindowEx(NULL, handle, L"Chrome_WidgetWin_0", NULL);
       if (!handle) {
-        PlatformThread::Sleep(100);
+        base::PlatformThread::Sleep(100);
         timer = timer + 100;
       }
     }
     if (!handle)
       return false;
     SetForegroundWindow(handle);
     LRESULT _result = SendMessage(handle, WM_CLOSE, 1, 0);
     if (_result != 0)
       return false;
-    PlatformThread::Sleep(1000);
+    base::PlatformThread::Sleep(1000);
     timer = timer + 1000;
   }
   if (base::GetProcessCount(installer::kChromeExe, NULL) > 0) {
     printf("Chrome.exe is still running even after closing all windows\n");
     return false;
   }
   if (base::GetProcessCount(installer::kNaClExe, NULL) > 0) {
     printf("NaCl.exe is still running even after closing all windows\n");
     return false;
   }
@@ skipping 13 matching lines @@
   return true;
 }
 
 // Checks for Chrome registry keys on uninstall.
 bool ChromeMiniInstaller::CheckRegistryKeyOnUninstall(
     const std::wstring& key_path) {
   RegKey key;
   int timer = 0;
   while ((key.Open(GetRootRegistryKey(), key_path.c_str(), KEY_ALL_ACCESS)) &&
          (timer < 20000)) {
-    PlatformThread::Sleep(200);
+    base::PlatformThread::Sleep(200);
     timer = timer + 200;
   }
   return CheckRegistryKey(key_path);
 }
 
 // Deletes Installer folder from Applications directory.
 void ChromeMiniInstaller::DeleteFolder(const wchar_t* folder_name) {
   FilePath install_path(GetChromeInstallDirectoryLocation());
   std::wstring temp_chrome_dir;
   if (is_chrome_frame_) {
@@ skipping 198 matching lines @@
 // Verifies Chrome/Chrome Frame install.
 void ChromeMiniInstaller::VerifyInstall(bool over_install) {
   if (is_chrome_frame_) {
     VerifyChromeFrameInstall();
   } else {
     if ((install_type_ == mini_installer_constants::kUserInstall) &&
         (!over_install)) {
       MiniInstallerTestUtil::VerifyProcessLaunch(
           installer::kChromeExe, true);
     }
-    PlatformThread::Sleep(800);
+    base::PlatformThread::Sleep(800);
     FindChromeShortcut();
     LaunchAndCloseChrome(over_install);
   }
 }
 
 // This method will verify if ChromeFrame installed successfully. It will
 // launch IE with cf:about:version, then check if
 // chrome.exe process got spawned.
 void ChromeMiniInstaller::VerifyChromeFrameInstall() {
   FilePath browser_path;
@@ skipping 23 matching lines @@
   ASSERT_TRUE(file_util::PathExists(path));
 }
 
 // This method will launch any requested browser.
 void ChromeMiniInstaller::LaunchBrowser(const std::wstring& launch_path,
                                         const std::wstring& launch_args,
                                         const std::wstring& process_name,
                                         bool expected_status) {
   base::LaunchApp(L"\"" + launch_path + L"\"" + L" " + launch_args,
       false, false, NULL);
-  PlatformThread::Sleep(1000);
+  base::PlatformThread::Sleep(1000);
   MiniInstallerTestUtil::VerifyProcessLaunch(process_name.c_str(),
                                              expected_status);
 }
 
 // This method compares the registry keys after overinstall.
 bool ChromeMiniInstaller::VerifyOverInstall(
     const std::wstring& value_before_overinstall,
     const std::wstring& value_after_overinstall) {
   int64 reg_key_value_before_overinstall;
   base::StringToInt64(value_before_overinstall,
@@ skipping 17 matching lines @@
 // This method will verify if the installed build is correct.
 bool ChromeMiniInstaller::VerifyStandaloneInstall() {
   std::wstring reg_key_value_returned, standalone_installer_version;
   MiniInstallerTestUtil::GetStandaloneVersion(&standalone_installer_version);
   GetChromeVersionFromRegistry(&reg_key_value_returned);
   if (standalone_installer_version.compare(reg_key_value_returned) == 0)
     return true;
   else
     return false;
 }