Move hashmap into base/.

src/d8.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_D8_H_
 #define V8_D8_H_
 
 #ifndef V8_SHARED
 #include "src/allocation.h"
+#include "src/base/hashmap.h"
 #include "src/base/platform/time.h"
-#include "src/hashmap.h"
 #include "src/list.h"
 #else
 #include "include/v8.h"
 #include "src/base/compiler-specific.h"
 #endif  // !V8_SHARED
 
 #include "src/base/once.h"
 
 
 namespace v8 {
@@ skipping 32 matching lines @@
   uint32_t max_name_size_;
   uint32_t counters_in_use_;
   Counter counters_[kMaxCounters];
 };
 
 
 class CounterMap {
  public:
   CounterMap(): hash_map_(Match) { }
   Counter* Lookup(const char* name) {
-    i::HashMap::Entry* answer =
+    base::HashMap::Entry* answer =
         hash_map_.Lookup(const_cast<char*>(name), Hash(name));
     if (!answer) return NULL;
     return reinterpret_cast<Counter*>(answer->value);
   }
   void Set(const char* name, Counter* value) {
-    i::HashMap::Entry* answer =
+    base::HashMap::Entry* answer =
         hash_map_.LookupOrInsert(const_cast<char*>(name), Hash(name));
     DCHECK(answer != NULL);
     answer->value = value;
   }
   class Iterator {
    public:
     explicit Iterator(CounterMap* map)
         : map_(&map->hash_map_), entry_(map_->Start()) { }
     void Next() { entry_ = map_->Next(entry_); }
     bool More() { return entry_ != NULL; }
     const char* CurrentKey() { return static_cast<const char*>(entry_->key); }
     Counter* CurrentValue() { return static_cast<Counter*>(entry_->value); }
    private:
-    i::HashMap* map_;
-    i::HashMap::Entry* entry_;
+    base::HashMap* map_;
+    base::HashMap::Entry* entry_;
   };
 
  private:
   static int Hash(const char* name);
   static bool Match(void* key1, void* key2);
-  i::HashMap hash_map_;
+  base::HashMap hash_map_;
 };
 #endif  // !V8_SHARED
 
 
 class SourceGroup {
  public:
   SourceGroup() :
 #ifndef V8_SHARED
       next_semaphore_(0),
       done_semaphore_(0),
@@ skipping 241 matching lines @@
   static Local<Context> CreateEvaluationContext(Isolate* isolate);
   static int RunMain(Isolate* isolate, int argc, char* argv[], bool last_run);
   static int Main(int argc, char* argv[]);
   static void Exit(int exit_code);
   static void OnExit(Isolate* isolate);
   static void CollectGarbage(Isolate* isolate);
   static void EmptyMessageQueues(Isolate* isolate);
 
 #ifndef V8_SHARED
   // TODO(binji): stupid implementation for now. Is there an easy way to hash an
-  // object for use in i::HashMap? By pointer?
+  // object for use in base::HashMap? By pointer?
   typedef i::List<Local<Object>> ObjectList;
   static bool SerializeValue(Isolate* isolate, Local<Value> value,
                              const ObjectList& to_transfer,
                              ObjectList* seen_objects,
                              SerializationData* out_data);
   static MaybeLocal<Value> DeserializeValue(Isolate* isolate,
                                             const SerializationData& data,
                                             int* offset);
   static void CleanupWorkers();
   static int* LookupCounter(const char* name);
@@ skipping 109 matching lines @@
   static Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
   static MaybeLocal<Context> CreateRealm(
       const v8::FunctionCallbackInfo<v8::Value>& args);
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_