Move atomic ops and related files to base library

src/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_
 
+#include "src/base/lazy-instance.h"
+#if V8_OS_WIN
+#include "src/base/win32-headers.h"
+#endif
 #include "src/checks.h"
-#include "src/lazy-instance.h"
-#if V8_OS_WIN
-#include "src/win32-headers.h"
-#endif
 
 #if V8_OS_POSIX
 #include <pthread.h>  // NOLINT
 #endif
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // Mutex
@@ skipping 71 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 LazyStaticInstance<Mutex,
-                           DefaultConstructTrait<Mutex>,
-                           ThreadSafeInitOnceTrait>::type LazyMutex;
+typedef v8::base::LazyStaticInstance<
+    Mutex, v8::base::DefaultConstructTrait<Mutex>,
+    v8::base::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 LazyStaticInstance<RecursiveMutex,
-                           DefaultConstructTrait<RecursiveMutex>,
-                           ThreadSafeInitOnceTrait>::type LazyRecursiveMutex;
+typedef v8::base::LazyStaticInstance<
+    RecursiveMutex, v8::base::DefaultConstructTrait<RecursiveMutex>,
+    v8::base::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
 
 #endif  // V8_PLATFORM_MUTEX_H_