Move platform abstraction to base library

src/base/platform/mutex.h

 // Copyright 2013 the V8 project 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 V8_PLATFORM_MUTEX_H_
-#define V8_PLATFORM_MUTEX_H_
+#ifndef V8_BASE_PLATFORM_MUTEX_H_
+#define V8_BASE_PLATFORM_MUTEX_H_
 
 #include "src/base/lazy-instance.h"
 #if V8_OS_WIN
 #include "src/base/win32-headers.h"
 #endif
-#include "src/checks.h"
+#include "src/base/logging.h"
 
 #if V8_OS_POSIX
 #include <pthread.h>  // NOLINT
 #endif
 
 namespace v8 {
-namespace internal {
+namespace base {
 
 // ----------------------------------------------------------------------------
 // Mutex
 //
 // This class is a synchronization primitive that can be used to protect shared
 // data from being simultaneously accessed by multiple threads. A mutex offers
 // exclusive, non-recursive ownership semantics:
 // - A calling thread owns a mutex from the time that it successfully calls
 //   either |Lock()| or |TryLock()| until it calls |Unlock()|.
 // - When a thread owns a mutex, all other threads will block (for calls to
@@ skipping 64 matching lines @@
 
 // POD Mutex initialized lazily (i.e. the first time Pointer() is called).
 // Usage:
 //   static LazyMutex my_mutex = LAZY_MUTEX_INITIALIZER;
 //
 //   void my_function() {
 //     LockGuard<Mutex> guard(my_mutex.Pointer());
 //     // Do something.
 //   }
 //
-typedef v8::base::LazyStaticInstance<
-    Mutex, v8::base::DefaultConstructTrait<Mutex>,
-    v8::base::ThreadSafeInitOnceTrait>::type LazyMutex;
+typedef LazyStaticInstance<Mutex, DefaultConstructTrait<Mutex>,
+                           ThreadSafeInitOnceTrait>::type LazyMutex;
 
 #define LAZY_MUTEX_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER
 
 
 // -----------------------------------------------------------------------------
 // RecursiveMutex
 //
 // This class is a synchronization primitive that can be used to protect shared
 // data from being simultaneously accessed by multiple threads. A recursive
 // mutex offers exclusive, recursive ownership semantics:
@@ skipping 58 matching lines @@
 // POD RecursiveMutex initialized lazily (i.e. the first time Pointer() is
 // called).
 // Usage:
 //   static LazyRecursiveMutex my_mutex = LAZY_RECURSIVE_MUTEX_INITIALIZER;
 //
 //   void my_function() {
 //     LockGuard<RecursiveMutex> guard(my_mutex.Pointer());
 //     // Do something.
 //   }
 //
-typedef v8::base::LazyStaticInstance<
-    RecursiveMutex, v8::base::DefaultConstructTrait<RecursiveMutex>,
-    v8::base::ThreadSafeInitOnceTrait>::type LazyRecursiveMutex;
+typedef LazyStaticInstance<RecursiveMutex,
+                           DefaultConstructTrait<RecursiveMutex>,
+                           ThreadSafeInitOnceTrait>::type LazyRecursiveMutex;
 
 #define LAZY_RECURSIVE_MUTEX_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER
 
 
 // -----------------------------------------------------------------------------
 // LockGuard
 //
 // This class is a mutex wrapper that provides a convenient RAII-style mechanism
 // for owning a mutex for the duration of a scoped block.
 // When a LockGuard object is created, it attempts to take ownership of the
 // mutex it is given. When control leaves the scope in which the LockGuard
 // object was created, the LockGuard is destructed and the mutex is released.
 // The LockGuard class is non-copyable.
 
 template <typename Mutex>
 class LockGuard V8_FINAL {
  public:
   explicit LockGuard(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }
   ~LockGuard() { mutex_->Unlock(); }
 
  private:
   Mutex* mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(LockGuard);
 };
 
-} }  // namespace v8::internal
+} }  // namespace v8::base
 
-#endif  // V8_PLATFORM_MUTEX_H_
+#endif  // V8_BASE_PLATFORM_MUTEX_H_