Move hashmap into base/.

src/libsampler/v8-sampler.cc

 // Copyright 2016 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/libsampler/v8-sampler.h"
 
 #if V8_OS_POSIX && !V8_OS_CYGWIN
 
 #define USE_SIGNALS
 
@@ skipping 29 matching lines @@
 
 #include "src/base/win32-headers.h"
 
 #endif
 
 #include <algorithm>
 #include <vector>
 #include <map>
 
 #include "src/base/atomic-utils.h"
+#include "src/base/hashmap.h"
 #include "src/base/platform/platform.h"
-#include "src/libsampler/hashmap.h"
-
 
 #if V8_OS_ANDROID && !defined(__BIONIC_HAVE_UCONTEXT_T)
 
 // Not all versions of Android's C library provide ucontext_t.
 // Detect this and provide custom but compatible definitions. Note that these
 // follow the GLibc naming convention to access register values from
 // mcontext_t.
 //
 // See http://code.google.com/p/android/issues/detail?id=34784
 
@@ skipping 159 matching lines @@
 };
 
 
 class SamplerManager {
  public:
   static void AddSampler(Sampler* sampler) {
     AtomicGuard atomic_guard(&samplers_access_counter_);
     DCHECK(sampler->IsActive() || !sampler->IsRegistered());
     // Add sampler into map if needed.
     pthread_t thread_id = sampler->platform_data()->vm_tid();
-    HashMap::Entry* entry =
-        sampler_map_.Pointer()->LookupOrInsert(ThreadKey(thread_id),
-                                               ThreadHash(thread_id));
+    base::HashMap::Entry* entry = sampler_map_.Pointer()->LookupOrInsert(
+        ThreadKey(thread_id), ThreadHash(thread_id));
     DCHECK(entry != NULL);
     if (entry->value == NULL) {
       SamplerList* samplers = new SamplerList();
       samplers->push_back(sampler);
       entry->value = samplers;
     } else {
       SamplerList* samplers = reinterpret_cast<SamplerList*>(entry->value);
       bool exists = false;
       for (SamplerListIterator iter = samplers->begin();
            iter != samplers->end(); ++iter) {
         if (*iter == sampler) {
           exists = true;
           break;
         }
       }
       if (!exists) {
         samplers->push_back(sampler);
       }
     }
   }
 
   static void RemoveSampler(Sampler* sampler) {
     AtomicGuard atomic_guard(&samplers_access_counter_);
     DCHECK(sampler->IsActive() || sampler->IsRegistered());
     // Remove sampler from map.
     pthread_t thread_id = sampler->platform_data()->vm_tid();
     void* thread_key = ThreadKey(thread_id);
     uint32_t thread_hash = ThreadHash(thread_id);
-    HashMap::Entry* entry = sampler_map_.Get().Lookup(thread_key, thread_hash);
+    base::HashMap::Entry* entry =
+        sampler_map_.Get().Lookup(thread_key, thread_hash);
     DCHECK(entry != NULL);
     SamplerList* samplers = reinterpret_cast<SamplerList*>(entry->value);
     for (SamplerListIterator iter = samplers->begin(); iter != samplers->end();
          ++iter) {
       if (*iter == sampler) {
         samplers->erase(iter);
         break;
       }
     }
     if (samplers->empty()) {
       sampler_map_.Pointer()->Remove(thread_key, thread_hash);
       delete samplers;
     }
   }
 
  private:
   struct HashMapCreateTrait {
-    static void Construct(HashMap* allocated_ptr) {
-      new (allocated_ptr) HashMap(HashMap::PointersMatch);
+    static void Construct(base::HashMap* allocated_ptr) {
+      new (allocated_ptr) base::HashMap(base::HashMap::PointersMatch);
     }
   };
   friend class SignalHandler;
-  static base::LazyInstance<HashMap, HashMapCreateTrait>::type
+  static base::LazyInstance<base::HashMap, HashMapCreateTrait>::type
       sampler_map_;
   static base::AtomicValue<int> samplers_access_counter_;
 };
 
-base::LazyInstance<HashMap, SamplerManager::HashMapCreateTrait>::type
+base::LazyInstance<base::HashMap, SamplerManager::HashMapCreateTrait>::type
     SamplerManager::sampler_map_ = LAZY_INSTANCE_INITIALIZER;
 base::AtomicValue<int> SamplerManager::samplers_access_counter_(0);
 
 
 #elif V8_OS_WIN || V8_OS_CYGWIN
 
 // ----------------------------------------------------------------------------
 // Win32 profiler support. On Cygwin we use the same sampler implementation as
 // on Win32.
 
@@ skipping 92 matching lines @@
 
 // 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(&SamplerManager::samplers_access_counter_, false);
   if (!atomic_guard.is_success()) return;
   pthread_t thread_id = pthread_self();
-  HashMap::Entry* entry =
-      SamplerManager::sampler_map_.Pointer()->Lookup(ThreadKey(thread_id),
-                                                     ThreadHash(thread_id));
+  base::HashMap::Entry* entry = SamplerManager::sampler_map_.Pointer()->Lookup(
+      ThreadKey(thread_id), ThreadHash(thread_id));
   if (entry == NULL) return;
   SamplerList* samplers = reinterpret_cast<SamplerList*>(entry->value);
 
   v8::RegisterState state;
   FillRegisterState(context, &state);
 
   for (int i = 0; i < samplers->size(); ++i) {
     Sampler* sampler = (*samplers)[i];
     Isolate* isolate = sampler->isolate();
 
@@ skipping 253 matching lines @@
 #endif
     SampleStack(state);
   }
   ResumeThread(profiled_thread);
 }
 
 #endif  // USE_SIGNALS
 
 }  // namespace sampler
 }  // namespace v8