Move platform abstraction to base library

src/optimizing-compiler-thread.h

 // Copyright 2012 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_OPTIMIZING_COMPILER_THREAD_H_
 #define V8_OPTIMIZING_COMPILER_THREAD_H_
 
 #include "src/base/atomicops.h"
+#include "src/base/platform/mutex.h"
+#include "src/base/platform/platform.h"
+#include "src/base/platform/time.h"
 #include "src/flags.h"
 #include "src/list.h"
-#include "src/platform.h"
-#include "src/platform/mutex.h"
-#include "src/platform/time.h"
 #include "src/unbound-queue-inl.h"
 
 namespace v8 {
 namespace internal {
 
 class HOptimizedGraphBuilder;
 class OptimizedCompileJob;
 class SharedFunctionInfo;
 
-class OptimizingCompilerThread : public Thread {
+class OptimizingCompilerThread : public base::Thread {
  public:
   explicit OptimizingCompilerThread(Isolate *isolate) :
       Thread("OptimizingCompilerThread"),
 #ifdef DEBUG
       thread_id_(0),
 #endif
       isolate_(isolate),
       stop_semaphore_(0),
       input_queue_semaphore_(0),
       input_queue_capacity_(FLAG_concurrent_recompilation_queue_length),
@@ skipping 22 matching lines @@
   void QueueForOptimization(OptimizedCompileJob* optimizing_compiler);
   void Unblock();
   void InstallOptimizedFunctions();
   OptimizedCompileJob* FindReadyOSRCandidate(Handle<JSFunction> function,
                                              BailoutId osr_ast_id);
   bool IsQueuedForOSR(Handle<JSFunction> function, BailoutId osr_ast_id);
 
   bool IsQueuedForOSR(JSFunction* function);
 
   inline bool IsQueueAvailable() {
-    LockGuard<Mutex> access_input_queue(&input_queue_mutex_);
+    base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_);
     return input_queue_length_ < input_queue_capacity_;
   }
 
   inline void AgeBufferedOsrJobs() {
     // Advance cursor of the cyclic buffer to next empty slot or stale OSR job.
     // Dispose said OSR job in the latter case.  Calling this on every GC
     // should make sure that we do not hold onto stale jobs indefinitely.
     AddToOsrBuffer(NULL);
   }
 
@@ skipping 21 matching lines @@
 
   inline int InputQueueIndex(int i) {
     int result = (i + input_queue_shift_) % input_queue_capacity_;
     ASSERT_LE(0, result);
     ASSERT_LT(result, input_queue_capacity_);
     return result;
   }
 
 #ifdef DEBUG
   int thread_id_;
-  Mutex thread_id_mutex_;
+  base::Mutex thread_id_mutex_;
 #endif
 
   Isolate* isolate_;
-  Semaphore stop_semaphore_;
-  Semaphore input_queue_semaphore_;
+  base::Semaphore stop_semaphore_;
+  base::Semaphore input_queue_semaphore_;
 
   // Circular queue of incoming recompilation tasks (including OSR).
   OptimizedCompileJob** input_queue_;
   int input_queue_capacity_;
   int input_queue_length_;
   int input_queue_shift_;
-  Mutex input_queue_mutex_;
+  base::Mutex input_queue_mutex_;
 
   // Queue of recompilation tasks ready to be installed (excluding OSR).
   UnboundQueue<OptimizedCompileJob*> output_queue_;
 
   // Cyclic buffer of recompilation tasks for OSR.
   OptimizedCompileJob** osr_buffer_;
   int osr_buffer_capacity_;
   int osr_buffer_cursor_;
 
   volatile base::AtomicWord stop_thread_;
-  TimeDelta time_spent_compiling_;
-  TimeDelta time_spent_total_;
+  base::TimeDelta time_spent_compiling_;
+  base::TimeDelta time_spent_total_;
 
   int osr_hits_;
   int osr_attempts_;
 
   int blocked_jobs_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OPTIMIZING_COMPILER_THREAD_H_