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

base/task.h

 // Copyright (c) 2009 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.
 
 #ifndef BASE_TASK_H_
 #define BASE_TASK_H_
 #pragma once
 
 #include "base/non_thread_safe.h"
 #include "base/raw_scoped_refptr_mismatch_checker.h"
@@ skipping 210 matching lines @@
 // live longer than the RunnableMethod object, then a RunnableMethodTraits
 // struct could be defined with empty RetainCallee and ReleaseCallee methods.
 //
 // The DISABLE_RUNNABLE_METHOD_REFCOUNT macro is provided as a convenient way
 // for declaring a RunnableMethodTraits that disables refcounting.
 
 template <class T>
 struct RunnableMethodTraits {
   RunnableMethodTraits() {
 #ifndef NDEBUG
-    origin_thread_id_ = PlatformThread::CurrentId();
+    origin_thread_id_ = base::PlatformThread::CurrentId();
 #endif
   }
 
   ~RunnableMethodTraits() {
 #ifndef NDEBUG
     // If destroyed on a separate thread, then we had better have been using
     // thread-safe reference counting!
-    if (origin_thread_id_ != PlatformThread::CurrentId())
+    if (origin_thread_id_ != base::PlatformThread::CurrentId())
       DCHECK(T::ImplementsThreadSafeReferenceCounting());
 #endif
   }
 
   void RetainCallee(T* obj) {
 #ifndef NDEBUG
     // Catch NewRunnableMethod being called in an object's constructor.  This
     // isn't safe since the method can be invoked before the constructor
     // completes, causing the object to be deleted.
     obj->AddRef();
     obj->Release();
 #endif
     obj->AddRef();
   }
 
   void ReleaseCallee(T* obj) {
     obj->Release();
   }
 
  private:
 #ifndef NDEBUG
-  PlatformThreadId origin_thread_id_;
+  base::PlatformThreadId origin_thread_id_;
 #endif
 };
 
 // Convenience macro for declaring a RunnableMethodTraits that disables
 // refcounting of a class.  This is useful if you know that the callee
 // will outlive the RunnableMethod object and thus do not need the ref counts.
 //
 // The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the
 // global namespace scope.  Example:
 //
@@ skipping 251 matching lines @@
 inline CancelableTask* NewRunnableFunction(Function function,
                                            const A& a, const B& b,
                                            const C& c, const D& d,
                                            const E& e, const F& f,
                                            const G& g, const H& h) {
   return new RunnableFunction<Function, Tuple8<A, B, C, D, E, F, G, H> >(
       function, MakeTuple(a, b, c, d, e, f, g, h));
 }
 
 #endif  // BASE_TASK_H_