Revert "Support ES6 Map and Set in heap profiler"

test/cctest/test-heap-profiler.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 484 matching lines @@
 }
 
 
 TEST(HeapSnapshotWeakCollection) {
   i::FLAG_harmony_collections = true;
 
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
-  CompileRun(
-      "k = {}; v = {}; s = 'str';\n"
-      "ws = new WeakSet(); ws.add(k); ws.add(v); ws[s] = s;\n"
-      "wm = new WeakMap(); wm.set(k, v); wm[s] = s;\n");
+  CompileRun("k = {}; v = {};\n"
+             "ws = new WeakSet(); ws.add(k); ws.add(v);\n"
+             "wm = new WeakMap(); wm.set(k, v);\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("WeakCollections"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* k =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
   CHECK_NE(NULL, k);
   const v8::HeapGraphNode* v =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
   CHECK_NE(NULL, v);
-  const v8::HeapGraphNode* s =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
-  CHECK_NE(NULL, s);
 
   const v8::HeapGraphNode* ws =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "ws");
   CHECK_NE(NULL, ws);
   CHECK_EQ(v8::HeapGraphNode::kObject, ws->GetType());
   CHECK_EQ(v8_str("WeakSet"), ws->GetName());
 
   const v8::HeapGraphNode* ws_table =
       GetProperty(ws, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, ws_table->GetType());
   CHECK_GT(ws_table->GetChildrenCount(), 0);
   int weak_entries = 0;
   for (int i = 0, count = ws_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = ws_table->GetChild(i);
     if (prop->GetType() != v8::HeapGraphEdge::kWeak) continue;
     if (k->GetId() == prop->GetToNode()->GetId()) {
       ++weak_entries;
     }
   }
   CHECK_EQ(1, weak_entries);
-  const v8::HeapGraphNode* ws_s =
-      GetProperty(ws, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, ws_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(ws_s->GetId()));
 
   const v8::HeapGraphNode* wm =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "wm");
   CHECK_NE(NULL, wm);
   CHECK_EQ(v8::HeapGraphNode::kObject, wm->GetType());
   CHECK_EQ(v8_str("WeakMap"), wm->GetName());
 
   const v8::HeapGraphNode* wm_table =
       GetProperty(wm, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, wm_table->GetType());
   CHECK_GT(wm_table->GetChildrenCount(), 0);
   weak_entries = 0;
   for (int i = 0, count = wm_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = wm_table->GetChild(i);
     if (prop->GetType() != v8::HeapGraphEdge::kWeak) continue;
     const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
     if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
       ++weak_entries;
     }
   }
   CHECK_EQ(2, weak_entries);
-  const v8::HeapGraphNode* wm_s =
-      GetProperty(wm, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, wm_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(wm_s->GetId()));
 }
 
 
-TEST(HeapSnapshotCollection) {
-  i::FLAG_harmony_collections = true;
-
-  LocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
-  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
-
-  CompileRun(
-      "k = {}; v = {}; s = 'str';\n"
-      "set = new Set(); set.add(k); set.add(v); set[s] = s;\n"
-      "map = new Map(); map.set(k, v); map[s] = s;\n");
-  const v8::HeapSnapshot* snapshot =
-      heap_profiler->TakeHeapSnapshot(v8_str("Collections"));
-  CHECK(ValidateSnapshot(snapshot));
-  const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  const v8::HeapGraphNode* k =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
-  CHECK_NE(NULL, k);
-  const v8::HeapGraphNode* v =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
-  CHECK_NE(NULL, v);
-  const v8::HeapGraphNode* s =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
-  CHECK_NE(NULL, s);
-
-  const v8::HeapGraphNode* set =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "set");
-  CHECK_NE(NULL, set);
-  CHECK_EQ(v8::HeapGraphNode::kObject, set->GetType());
-  CHECK_EQ(v8_str("Set"), set->GetName());
-
-  const v8::HeapGraphNode* set_table =
-      GetProperty(set, v8::HeapGraphEdge::kInternal, "table");
-  CHECK_EQ(v8::HeapGraphNode::kArray, set_table->GetType());
-  CHECK_GT(set_table->GetChildrenCount(), 0);
-  int entries = 0;
-  for (int i = 0, count = set_table->GetChildrenCount(); i < count; ++i) {
-    const v8::HeapGraphEdge* prop = set_table->GetChild(i);
-    const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
-    if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
-      ++entries;
-    }
-  }
-  CHECK_EQ(2, entries);
-  const v8::HeapGraphNode* set_s =
-      GetProperty(set, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, set_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(set_s->GetId()));
-
-  const v8::HeapGraphNode* map =
-      GetProperty(global, v8::HeapGraphEdge::kProperty, "map");
-  CHECK_NE(NULL, map);
-  CHECK_EQ(v8::HeapGraphNode::kObject, map->GetType());
-  CHECK_EQ(v8_str("Map"), map->GetName());
-
-  const v8::HeapGraphNode* map_table =
-      GetProperty(map, v8::HeapGraphEdge::kInternal, "table");
-  CHECK_EQ(v8::HeapGraphNode::kArray, map_table->GetType());
-  CHECK_GT(map_table->GetChildrenCount(), 0);
-  entries = 0;
-  for (int i = 0, count = map_table->GetChildrenCount(); i < count; ++i) {
-    const v8::HeapGraphEdge* prop = map_table->GetChild(i);
-    const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
-    if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
-      ++entries;
-    }
-  }
-  CHECK_EQ(2, entries);
-  const v8::HeapGraphNode* map_s =
-      GetProperty(map, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, map_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(map_s->GetId()));
-}
-
-
 TEST(HeapSnapshotInternalReferences) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetInternalFieldCount(2);
   LocalContext env(NULL, global_template);
   v8::Handle<v8::Object> global_proxy = env->Global();
   v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
   CHECK_EQ(2, global->InternalFieldCount());
@@ skipping 2104 matching lines @@
   map.AddRange(ToAddress(0x180), 0x80, 6U);
   map.AddRange(ToAddress(0x180), 0x80, 7U);
   CHECK_EQ(7, map.GetTraceNodeId(ToAddress(0x180)));
   CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
   CHECK_EQ(3, static_cast<int>(map.size()));
 
   map.Clear();
   CHECK_EQ(0, static_cast<int>(map.size()));
   CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x400)));
 }