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

chrome/test/ui/ui_test.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/ui/ui_test.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #endif
 
 #include <set>
 #include <vector>
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "app/sql/connection.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
-#include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/test/test_file_util.h"
+#include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/debug_flags.h"
 #include "chrome/common/logging_chrome.h"
@@ skipping 164 matching lines @@
                               TestTimeouts::command_execution_timeout_ms()));
   WaitForBrowserLaunch();
 }
 
 void UITestBase::WaitForBrowserLaunch() {
   ASSERT_EQ(AUTOMATION_SUCCESS, automation_proxy_->WaitForAppLaunch())
       << "Error while awaiting automation ping from browser process";
   if (wait_for_initial_loads_)
     ASSERT_TRUE(automation_proxy_->WaitForInitialLoads());
   else
-    PlatformThread::Sleep(sleep_timeout_ms());
+    base::PlatformThread::Sleep(sleep_timeout_ms());
 
   EXPECT_TRUE(automation()->SetFilteredInet(ShouldFilterInet()));
 }
 
 void UITestBase::CloseBrowserAndServer() {
   QuitBrowser();
   CleanupAppProcesses();
 
   // Suppress spammy failures that seem to be occurring when running
   // the UI tests in single-process mode.
@@ skipping 788 matching lines @@
   std::string cookie_value = WaitUntilCookieNonEmpty(tab.get(), url,
                                                      cookie_name.c_str(),
                                                      wait_time);
   EXPECT_EQ(expected_cookie_value, cookie_value);
 }
 
 bool UITest::EvictFileFromSystemCacheWrapper(const FilePath& path) {
   for (int i = 0; i < 10; i++) {
     if (file_util::EvictFileFromSystemCache(path))
       return true;
-    PlatformThread::Sleep(sleep_timeout_ms() / 10);
+    base::PlatformThread::Sleep(sleep_timeout_ms() / 10);
   }
   return false;
 }
 
 void UITest::WaitForGeneratedFileAndCheck(
     const FilePath& generated_file,
     const FilePath& original_file,
     bool compare_files,
     bool need_equal,
     bool delete_generated_file) {
   // Check whether the target file has been generated.
   base::PlatformFileInfo previous, current;
   bool exist = false;
   const int kCycles = 20;
   for (int i = 0; i < kCycles; ++i) {
     if (exist) {
       file_util::GetFileInfo(generated_file, &current);
       if (current.size == previous.size)
         break;
       previous = current;
     } else if (file_util::PathExists(generated_file)) {
       file_util::GetFileInfo(generated_file, &previous);
       exist = true;
     }
-    PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
+    base::PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
   }
   EXPECT_TRUE(exist);
 
   if (compare_files) {
     // Check whether the generated file is equal with original file according to
     // parameter: need_equal.
     int64 generated_file_size = 0;
     int64 original_file_size = 0;
 
     EXPECT_TRUE(file_util::GetFileSize(generated_file, &generated_file_size));
@@ skipping 148 matching lines @@
     incorrect_state_count++;
   }
 
   LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
             << " seconds"
             << " call failed " << fail_count << " times"
             << " state was incorrect " << incorrect_state_count << " times";
   ADD_FAILURE() << "Timeout reached in " << __FUNCTION__;
   return false;
 }