Move atomic-utils.h into base/

src/profiler/sampler.cc

 // 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.
 
 #include "src/profiler/sampler.h"
 
 #if V8_OS_POSIX && !V8_OS_CYGWIN
 
 #define USE_SIGNALS
 
@@ skipping 24 matching lines @@
     !defined(__BIONIC_HAVE_STRUCT_SIGCONTEXT)
 #include <asm/sigcontext.h>  // NOLINT
 #endif
 
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
 #include "src/base/win32-headers.h"
 
 #endif
 
-#include "src/atomic-utils.h"
+#include "src/base/atomic-utils.h"
 #include "src/base/platform/platform.h"
 #include "src/flags.h"
 #include "src/frames-inl.h"
 #include "src/log.h"
 #include "src/profiler/cpu-profiler-inl.h"
 #include "src/simulator.h"
 #include "src/v8threads.h"
 #include "src/vm-state-inl.h"
 
 
@@ skipping 179 matching lines @@
     }
   }
   return false;
 }
 
 typedef List<Sampler*> SamplerList;
 
 #if defined(USE_SIGNALS)
 class AtomicGuard {
  public:
-  explicit AtomicGuard(AtomicValue<int>* atomic, bool is_block = true)
+  explicit AtomicGuard(base::AtomicValue<int>* atomic, bool is_block = true)
       : atomic_(atomic),
         is_success_(false) {
     do {
       // Use Acquire_Load to gain mutual exclusion.
       USE(atomic_->Value());
       is_success_ = atomic_->TrySetValue(0, 1);
     } while (is_block && !is_success_);
   }
 
   bool is_success() { return is_success_; }
 
   ~AtomicGuard() {
     if (is_success_) {
       atomic_->SetValue(0);
     }
     atomic_ = NULL;
   }
 
  private:
-  AtomicValue<int>* atomic_;
+  base::AtomicValue<int>* atomic_;
   bool is_success_;
 };
 
 
 // Returns key for hash map.
 void* ThreadKey(pthread_t thread_id) {
   return reinterpret_cast<void*>(thread_id);
 }
 
 
@@ skipping 464 matching lines @@
 
 #if defined(USE_SIGNALS)
   struct HashMapCreateTrait {
     static void Construct(HashMap* allocated_ptr) {
       new (allocated_ptr) HashMap(HashMap::PointersMatch);
     }
   };
   friend class SignalHandler;
   static base::LazyInstance<HashMap, HashMapCreateTrait>::type
       thread_id_to_samplers_;
-  static AtomicValue<int> sampler_list_access_counter_;
+  static base::AtomicValue<int> sampler_list_access_counter_;
   static void AddSampler(Sampler* sampler) {
     AtomicGuard atomic_guard(&sampler_list_access_counter_);
     // Add sampler into map if needed.
     pthread_t thread_id = sampler->platform_data()->vm_tid();
     HashMap::Entry *entry =
         thread_id_to_samplers_.Pointer()->LookupOrInsert(ThreadKey(thread_id),
                                                          ThreadHash(thread_id));
     if (entry->value == NULL) {
       SamplerList* samplers = new SamplerList();
       samplers->Add(sampler);
@@ skipping 11 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SamplerThread);
 };
 
 
 base::Mutex* SamplerThread::mutex_ = NULL;
 SamplerThread* SamplerThread::instance_ = NULL;
 #if defined(USE_SIGNALS)
 base::LazyInstance<HashMap, SamplerThread::HashMapCreateTrait>::type
     SamplerThread::thread_id_to_samplers_ = LAZY_INSTANCE_INITIALIZER;
-AtomicValue<int> SamplerThread::sampler_list_access_counter_(0);
+base::AtomicValue<int> SamplerThread::sampler_list_access_counter_(0);
 
 // As Native Client does not support signal handling, profiling is disabled.
 #if !V8_OS_NACL
 void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info,
                                          void* context) {
   USE(info);
   if (signal != SIGPROF) return;
   AtomicGuard atomic_guard(&SamplerThread::sampler_list_access_counter_, false);
   if (!atomic_guard.is_success()) return;
   pthread_t thread_id = pthread_self();
@@ skipping 237 matching lines @@
     SampleStack(state);
   }
   ResumeThread(profiled_thread);
 }
 
 #endif  // USE_SIGNALS
 
 
 }  // namespace internal
 }  // namespace v8