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

base/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug_util.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
-#include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
+#include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_LINUX)
 #include <errno.h>
 #include <malloc.h>
 #include <glib.h>
 #endif
 #if defined(OS_POSIX)
@@ skipping 30 matching lines @@
 const int kExpectedStillRunningExitCode = 0;
 #endif
 
 // The longest we'll wait for a process, in milliseconds.
 const int kMaxWaitTimeMs = TestTimeouts::action_max_timeout_ms();
 
 // Sleeps until file filename is created.
 void WaitToDie(const char* filename) {
   FILE *fp;
   do {
-    PlatformThread::Sleep(10);
+    base::PlatformThread::Sleep(10);
     fp = fopen(filename, "r");
   } while (!fp);
   fclose(fp);
 }
 
 // Signals children they should die now.
 void SignalChildren(const char* filename) {
   FILE *fp = fopen(filename, "w");
   fclose(fp);
 }
 
 // Using a pipe to the child to wait for an event was considered, but
 // there were cases in the past where pipes caused problems (other
 // libraries closing the fds, child deadlocking). This is a simple
 // case, so it's not worth the risk.  Using wait loops is discouraged
 // in most instances.
 base::TerminationStatus WaitForChildTermination(base::ProcessHandle handle,
                                                 int* exit_code) {
   // Now we wait until the result is something other than STILL_RUNNING.
   base::TerminationStatus status = base::TERMINATION_STATUS_STILL_RUNNING;
   const int kIntervalMs = 20;
   int waited = 0;
   do {
     status = base::GetTerminationStatus(handle, exit_code);
-    PlatformThread::Sleep(kIntervalMs);
+    base::PlatformThread::Sleep(kIntervalMs);
     waited += kIntervalMs;
   } while (status == base::TERMINATION_STATUS_STILL_RUNNING &&
            waited < kMaxWaitTimeMs);
 
   return status;
 }
 
 }  // namespace
 
 class ProcessUtilTest : public base::MultiProcessTest {
@@ skipping 813 matching lines @@
   ASSERT_DEATH({
       SetUpInDeathAssert();
       while ((value_ = base::AllocatePsychoticallyBigObjCObject())) {}
     }, "");
 }
 
 #endif  // !ARCH_CPU_64_BITS
 #endif  // OS_MACOSX
 
 #endif  // !defined(OS_WIN)