add StdGlobalValueMap

BUG=

Review URL: https://codereview.chromium.org/1104463002

Cr-Commit-Position: refs/heads/master@{#27994}

include/v8-util.h

@@ -117,25 +117,25 @@ class DefaultGlobalMapTraits : public StdMapTraits<K, V> {
  public:
   // Weak callback & friends:
   static const PersistentContainerCallbackType kCallbackType = kNotWeak;
-  typedef PersistentValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
-  typedef void WeakCallbackInfoType;
+  typedef GlobalValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
+  typedef void WeakCallbackDataType;
 
-  static WeakCallbackInfoType* WeakCallbackParameter(MapType* map, const K& key,
+  static WeakCallbackDataType* WeakCallbackParameter(MapType* map, const K& key,
                                                      Local<V> value) {
     return nullptr;
   }
   static MapType* MapFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return nullptr;
   }
   static K KeyFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return K();
   }
-  static void DisposeCallbackData(WeakCallbackInfoType* data) {}
+  static void DisposeCallbackData(WeakCallbackDataType* data) {}
   static void Dispose(Isolate* isolate, Global<V> value, K key) {}
   // This is a second pass callback, so SetSecondPassCallback cannot be called.
-  static void DisposeWeak(const WeakCallbackInfo<WeakCallbackInfoType>& data) {}
+  static void DisposeWeak(const WeakCallbackInfo<WeakCallbackDataType>& data) {}
 
  private:
   template <typename T>
@@ -504,6 +504,22 @@ class StdPersistentValueMap : public PersistentValueMap<K, V, Traits> {
 };
 
 
+/**
+ * A map that uses Global as value and std::map as the backing
+ * implementation. Globals are held non-weak.
+ *
+ * C++11 embedders don't need this class, as they can use
+ * Global directly in std containers.
+ */
+template <typename K, typename V,
+          typename Traits = DefaultGlobalMapTraits<K, V> >
+class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
+ public:
+  explicit StdGlobalValueMap(Isolate* isolate)
+      : GlobalValueMap<K, V, Traits>(isolate) {}
+};
+
+
 class DefaultPersistentValueVectorTraits {
  public:
   typedef std::vector<PersistentContainerValue> Impl;

test/cctest/test-api.cc

@@ -3361,12 +3361,9 @@ class PhantomStdMapTraits : public v8::StdMapTraits<K, V> {
   }
 };
 
-}  // namespace
-
 
-TEST(GlobalValueMap) {
-  typedef v8::GlobalValueMap<int, v8::Object,
-                             PhantomStdMapTraits<int, v8::Object>> Map;
+template <typename Map>
+void TestGlobalValueMap() {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::Global<ObjectTemplate> templ;
@@ -3391,7 +3388,7 @@ TEST(GlobalValueMap) {
     obj = map.Get(7);
     CHECK(expected->Equals(obj));
     {
-      Map::PersistentValueReference ref = map.GetReference(7);
+      typename Map::PersistentValueReference ref = map.GetReference(7);
       CHECK(expected->Equals(ref.NewLocal(isolate)));
     }
     v8::Global<v8::Object> removed = map.Remove(7);
@@ -3404,7 +3401,7 @@ TEST(GlobalValueMap) {
     map.Set(8, expected);
     CHECK_EQ(1, static_cast<int>(map.Size()));
     {
-      Map::PersistentValueReference ref;
+      typename Map::PersistentValueReference ref;
       Local<v8::Object> expected2 = NewObjectForIntKey(isolate, templ, 8);
       removed = map.Set(8, v8::Global<v8::Object>(isolate, expected2), &ref);
       CHECK_EQ(1, static_cast<int>(map.Size()));
@@ -3413,8 +3410,12 @@ TEST(GlobalValueMap) {
     }
   }
   CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count());
-  CcTest::i_isolate()->heap()->CollectAllGarbage(
-      i::Heap::kAbortIncrementalMarkingMask);
+  if (map.IsWeak()) {
+    CcTest::i_isolate()->heap()->CollectAllGarbage(
+        i::Heap::kAbortIncrementalMarkingMask);
+  } else {
+    map.Clear();
+  }
   CHECK_EQ(0, static_cast<int>(map.Size()));
   CHECK_EQ(initial_handle_count, global_handles->global_handles_count());
   {
@@ -3427,6 +3428,19 @@ TEST(GlobalValueMap) {
   CHECK_EQ(initial_handle_count, global_handles->global_handles_count());
 }
 
+}  // namespace
+
+
+TEST(GlobalValueMap) {
+  // Default case, w/o weak callbacks:
+  TestGlobalValueMap<v8::StdGlobalValueMap<int, v8::Object>>();
+
+  // Custom traits with weak callbacks:
+  typedef v8::GlobalValueMap<int, v8::Object,
+                             PhantomStdMapTraits<int, v8::Object>> WeakMap;
+  TestGlobalValueMap<WeakMap>();
+}
+
 
 TEST(PersistentValueVector) {
   LocalContext env;