Heap profiler: remove context checks for objects.

test/cctest/test-heap-profiler.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 //
 // Tests for heap profiler
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #include "v8.h"
 #include "heap-profiler.h"
 #include "snapshot.h"
 #include "string-stream.h"
@@ skipping 370 matching lines @@
   CHECK_EQ("(global property);2", printer.GetRetainers("B"));
   CHECK_EQ("(global property);1", printer.GetRetainers("C"));
 }
 
 
 namespace {
 
 class NamedEntriesDetector {
  public:
   NamedEntriesDetector()
-      : has_A1(false), has_B1(false), has_C1(false),
-        has_A2(false), has_B2(false), has_C2(false) {
+      : has_A2(false), has_B2(false), has_C2(false) {
   }
 
   void Apply(i::HeapEntry** entry_ptr) {
-    if (IsReachableNodeWithName(*entry_ptr, "A1")) has_A1 = true;
-    if (IsReachableNodeWithName(*entry_ptr, "B1")) has_B1 = true;
-    if (IsReachableNodeWithName(*entry_ptr, "C1")) has_C1 = true;
     if (IsReachableNodeWithName(*entry_ptr, "A2")) has_A2 = true;
     if (IsReachableNodeWithName(*entry_ptr, "B2")) has_B2 = true;
     if (IsReachableNodeWithName(*entry_ptr, "C2")) has_C2 = true;
   }
 
   static bool IsReachableNodeWithName(i::HeapEntry* entry, const char* name) {
     return strcmp(name, entry->name()) == 0 && entry->painted_reachable();
   }
 
-  bool has_A1;
-  bool has_B1;
-  bool has_C1;
   bool has_A2;
   bool has_B2;
   bool has_C2;
 };
 
 }  // namespace
 
 
 static const v8::HeapGraphNode* GetGlobalObject(
     const v8::HeapSnapshot* snapshot) {
@@ skipping 36 matching lines @@
       v8::String::AsciiValue node_name(node->GetName());
       if (strcmp(contents, *node_name) == 0) return true;
     }
   }
   return false;
 }
 
 
 TEST(HeapSnapshot) {
   v8::HandleScope scope;
-  v8::Handle<v8::String> token1 = v8::String::New("token1");
-  LocalContext env1;
-  env1->SetSecurityToken(token1);
-
-  CompileRun(
-      "function A1() {}\n"
-      "function B1(x) { this.x = x; }\n"
-      "function C1(x) { this.x1 = x; this.x2 = x; }\n"
-      "var a1 = new A1();\n"
-      "var b1_1 = new B1(a1), b1_2 = new B1(a1);\n"
-      "var c1 = new C1(a1);");
-
-  v8::Handle<v8::String> token2 = v8::String::New("token2");
   LocalContext env2;
-  env2->SetSecurityToken(token2);
 
   CompileRun(
       "function A2() {}\n"
       "function B2(x) { return function() { return typeof x; }; }\n"
       "function C2(x) { this.x1 = x; this.x2 = x; this[1] = x; }\n"
       "var a2 = new A2();\n"
       "var b2_1 = new B2(a2), b2_2 = new B2(a2);\n"
       "var c2 = new C2(a2);");
   const v8::HeapSnapshot* snapshot_env2 =
       v8::HeapProfiler::TakeSnapshot(v8::String::New("env2"));
   i::HeapSnapshot* i_snapshot_env2 =
       const_cast<i::HeapSnapshot*>(
           reinterpret_cast<const i::HeapSnapshot*>(snapshot_env2));
   const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2);
   // Paint all nodes reachable from global object.
   i_snapshot_env2->ClearPaint();
   const_cast<i::HeapEntry*>(
       reinterpret_cast<const i::HeapEntry*>(global_env2))->PaintAllReachable();
 
-  // Verify, that JS global object of env2 doesn't have '..1'
-  // properties, but has '..2' properties.
-  CHECK_EQ(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a1"));
-  CHECK_EQ(
-      NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b1_1"));
-  CHECK_EQ(
-      NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b1_2"));
-  CHECK_EQ(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c1"));
+  // Verify, that JS global object of env2 has '..2' properties.
   const v8::HeapGraphNode* a2_node =
       GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a2");
   CHECK_NE(NULL, a2_node);
   CHECK_NE(
       NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1"));
   CHECK_NE(
       NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2"));
   CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2"));
 
   // Verify that anything related to '[ABC]1' is not reachable.
   NamedEntriesDetector det;
   i_snapshot_env2->IterateEntries(&det);
-  CHECK(!det.has_A1);
-  CHECK(!det.has_B1);
-  CHECK(!det.has_C1);
   CHECK(det.has_A2);
   CHECK(det.has_B2);
   CHECK(det.has_C2);
 
   // Verify 'a2' object retainers. They are:
   //  - (global object).a2
   //  - c2.x1, c2.x2, c2[1]
   //  - b2_1 and b2_2 closures: via 'x' variable
   CHECK_EQ(6, a2_node->GetRetainingPathsCount());
   bool has_global_obj_a2_ref = false;
@@ skipping 641 matching lines @@
   LocalContext env;
   const v8::HeapSnapshot* snapshot =
       v8::HeapProfiler::TakeSnapshot(v8::String::New("abort"));
   TestJSONStream stream(5);
   snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);
   CHECK_GT(stream.size(), 0);
   CHECK_EQ(0, stream.eos_signaled());
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING