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

chrome/test/mini_installer_test/mini_installer_test_util.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/mini_installer_test_util.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
-#include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/test/test_timeouts.h"
+#include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Change current directory so that chrome.dll from current folder
 // will not be used as fall back.
 bool MiniInstallerTestUtil::ChangeCurrentDirectory(FilePath* current_path) {
   FilePath backup_path;
   if (!file_util::GetCurrentDirectory(&backup_path))
     return false;
 
   if (!file_util::SetCurrentDirectory(backup_path.DirName()))
     return false;
   *current_path = backup_path;
   return true;
 }
 
 // Checks for all requested running processes and kills them.
 void MiniInstallerTestUtil::CloseProcesses(
     const std::wstring& executable_name) {
   int timer = 0;
   while ((base::GetProcessCount(executable_name, NULL) > 0) &&
          (timer < 20000)) {
     base::KillProcesses(executable_name, 1, NULL);
-    PlatformThread::Sleep(200);
+    base::PlatformThread::Sleep(200);
     timer = timer + 200;
   }
   ASSERT_EQ(0, base::GetProcessCount(executable_name, NULL));
 }
 
 bool MiniInstallerTestUtil::CloseWindow(const wchar_t* window_name,
                                         UINT message) {
   int timer = 0;
   bool return_val = false;
   HWND hndl = FindWindow(NULL, window_name);
   while (hndl == NULL && (timer < 60000)) {
     hndl = FindWindow(NULL, window_name);
-    PlatformThread::Sleep(200);
+    base::PlatformThread::Sleep(200);
     timer = timer + 200;
   }
   if (hndl != NULL) {
     LRESULT _result = SendMessage(hndl, message, 1, 0);
     return_val = true;
   }
   return return_val;
 }
 
 bool IsNewer(const FileInfo& file_rbegin, const FileInfo& file_rend) {
@@ skipping 204 matching lines @@
 
 
 void MiniInstallerTestUtil::VerifyProcessLaunch(
     const wchar_t* process_name, bool expected_status) {
   int timer = 0, wait_time = 60000;
   if (!expected_status)
     wait_time = 8000;
 
   while ((base::GetProcessCount(process_name, NULL) == 0) &&
          (timer < wait_time)) {
-    PlatformThread::Sleep(200);
+    base::PlatformThread::Sleep(200);
     timer = timer + 200;
   }
 
   if (expected_status)
     ASSERT_NE(0, base::GetProcessCount(process_name, NULL));
   else
     ASSERT_EQ(0, base::GetProcessCount(process_name, NULL));
 }
 
 bool MiniInstallerTestUtil::VerifyProcessClose(
     const wchar_t* process_name) {
   int timer = 0;
   if (base::GetProcessCount(process_name, NULL) > 0) {
     VLOG(1) << "Waiting for this process to end: " << process_name;
     while ((base::GetProcessCount(process_name, NULL) > 0) &&
            (timer < TestTimeouts::large_test_timeout_ms())) {
-      PlatformThread::Sleep(200);
+      base::PlatformThread::Sleep(200);
       timer = timer + 200;
     }
   } else {
     if (base::GetProcessCount(process_name, NULL) != 0)
       return false;
   }
   return true;
 }
 
 bool MiniInstallerTestUtil::VerifyProcessHandleClosed(
     base::ProcessHandle handle) {
   DWORD result = WaitForSingleObject(handle,
       TestTimeouts::large_test_timeout_ms());
   return result == WAIT_OBJECT_0;
 }