Remove Debug object from the user roots in heap profiler.

test/cctest/test-heap-profiler.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 //
 // Tests for heap profiler
 
 #include "v8.h"
 
 #include "cctest.h"
 #include "heap-profiler.h"
 #include "snapshot.h"
+#include "debug.h"
 #include "utils-inl.h"
 #include "../include/v8-profiler.h"
 
 namespace {
 
 class NamedEntriesDetector {
  public:
   NamedEntriesDetector()
       : has_A2(false), has_B2(false), has_C2(false) {
   }
@@ skipping 1536 matching lines @@
   CHECK_NE(NULL, global);
   const v8::HeapGraphNode* fun =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "fun");
   CHECK(HasWeakEdge(fun));
   const v8::HeapGraphNode* shared =
       GetProperty(fun, v8::HeapGraphEdge::kInternal, "shared");
   CHECK(HasWeakEdge(shared));
 }
 
 
+TEST(NoDebugObjectInSnapshot) {
+  v8::HandleScope scope;
+  LocalContext env;
+
+  v8::internal::Isolate::Current()->debug()->Load();
+  CompileRun("foo = {};");
+  const v8::HeapSnapshot* snapshot =
+      v8::HeapProfiler::TakeSnapshot(v8_str("snapshot"));
+  const v8::HeapGraphNode* root = snapshot->GetRoot();
+  int count_globals = 0;

[mnaganov (inactive), 2012/04/17 14:16:14]

nit: globals_count sounds more appropriate

[alexeif, 2012/04/17 15:30:10]

Done.

+  for (int i = 0; i < root->GetChildrenCount(); ++i) {
+    const v8::HeapGraphEdge* edge = root->GetChild(i);
+    if (edge->GetType() == v8::HeapGraphEdge::kShortcut) {

[mnaganov (inactive), 2012/04/17 14:16:14]

Perhaps, expose IsWindowReference to public and use it here?

[alexeif, 2012/04/17 15:30:10]

I don't think we need to make it public.

+      ++count_globals;
+      const v8::HeapGraphNode* global = edge->GetToNode();

[mnaganov (inactive), 2012/04/17 14:16:14]

You can use "GetProperty" helper function defined in this file.

[alexeif, 2012/04/17 15:30:10]

I don't know the name of the user global.

[mnaganov (inactive), 2012/04/17 15:35:52]

Sorry, I have misread your code.

+      const v8::HeapGraphNode* foo =
+          GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
+      CHECK_NE(NULL, foo);
+    }
+  }
+  CHECK_EQ(1, count_globals);
+}
+
+
 TEST(PersistentHandleCount) {
   v8::HandleScope scope;
   LocalContext env;
 
   // V8 also uses global handles internally, so we can't test for an absolute
   // number.
   int global_handle_count = v8::HeapProfiler::GetPersistentHandleCount();
 
   // Create some persistent handles.
   v8::Persistent<v8::String> p_AAA =
@@ skipping 12 matching lines @@
   // Dipose the persistent handles in a different order.
   p_AAA.Dispose();
   CHECK_EQ(global_handle_count + 2,
            v8::HeapProfiler::GetPersistentHandleCount());
   p_CCC.Dispose();
   CHECK_EQ(global_handle_count + 1,
            v8::HeapProfiler::GetPersistentHandleCount());
   p_BBB.Dispose();
   CHECK_EQ(global_handle_count, v8::HeapProfiler::GetPersistentHandleCount());
 }