Remove Debug object from the user roots in heap profiler.

src/profile-generator.cc

 // Copyright 2012 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 16 matching lines @@
 
 #include "v8.h"
 
 #include "profile-generator-inl.h"
 
 #include "global-handles.h"
 #include "heap-profiler.h"
 #include "scopeinfo.h"
 #include "unicode.h"
 #include "zone-inl.h"
+#include "debug.h"
 
 namespace v8 {
 namespace internal {
 
 
 TokenEnumerator::TokenEnumerator()
     : token_locations_(4),
       token_removed_(4) {
 }
 
@@ skipping 913 matching lines @@
 void HeapEntry::Init(HeapSnapshot* snapshot,
                      Type type,
                      const char* name,
                      SnapshotObjectId id,
                      int self_size,
                      int children_count,
                      int retainers_count) {
   snapshot_ = snapshot;
   type_ = type;
   painted_ = false;
-  reachable_from_window_ = false;
+  user_reachable_ = false;
   name_ = name;
   self_size_ = self_size;
   retained_size_ = 0;
   entry_index_ = -1;
   children_count_ = children_count;
   retainers_count_ = retainers_count;
   dominator_ = NULL;
   id_ = id;
 }
 
@@ skipping 998 matching lines @@
 void V8HeapExplorer::ExtractReferences(HeapObject* obj) {
   HeapEntry* entry = GetEntry(obj);
   if (entry == NULL) return;  // No interest in this object.
 
   bool extract_indexed_refs = true;
   if (obj->IsJSGlobalProxy()) {
     // We need to reference JS global objects from snapshot's root.
     // We use JSGlobalProxy because this is what embedder (e.g. browser)
     // uses for the global object.
     JSGlobalProxy* proxy = JSGlobalProxy::cast(obj);
-    SetWindowReference(proxy->map()->prototype());
+    Object* object = proxy->map()->prototype();
+    bool is_debug_object = false;
+#ifdef ENABLE_DEBUGGER_SUPPORT
+    is_debug_object = object->IsGlobalObject() &&
+        Isolate::Current()->debug()->IsDebugGlobal(GlobalObject::cast(object));
+#endif
+    if (!is_debug_object) {
+      SetUserGlobalReference(object);
+    }
   } else if (obj->IsJSObject()) {
     JSObject* js_obj = JSObject::cast(obj);
     ExtractClosureReferences(js_obj, entry);
     ExtractPropertyReferences(js_obj, entry);
     ExtractElementReferences(js_obj, entry);
     ExtractInternalReferences(js_obj, entry);
     SetPropertyReference(
         obj, entry, heap_->Proto_symbol(), js_obj->GetPrototype());
     if (obj->IsJSFunction()) {
       JSFunction* js_fun = JSFunction::cast(js_obj);
@@ skipping 624 matching lines @@
 
 
 void V8HeapExplorer::SetRootGcRootsReference() {
   filler_->SetIndexedAutoIndexReference(
       HeapGraphEdge::kElement,
       kInternalRootObject, snapshot_->root(),
       kGcRootsObject, snapshot_->gc_roots());
 }
 
 
-void V8HeapExplorer::SetWindowReference(Object* child_obj) {
+void V8HeapExplorer::SetUserGlobalReference(Object* child_obj) {
   HeapEntry* child_entry = GetEntry(child_obj);
   ASSERT(child_entry != NULL);
   filler_->SetNamedAutoIndexReference(
       HeapGraphEdge::kShortcut,
       kInternalRootObject, snapshot_->root(),
       child_obj, child_entry);
 }
 
 
 void V8HeapExplorer::SetGcRootsReference(VisitorSynchronization::SyncTag tag) {
@@ skipping 615 matching lines @@
   // in turn may relocate objects in property maps thus changing the heap
   // layout and affecting retainer counts. This is not acceptable because
   // number of retainers must not change between count and fill passes.
   // To avoid this there's a separate postpass that set object names.
   return v8_heap_explorer_.IterateAndExtractReferences(&filler)
       && dom_explorer_.IterateAndExtractReferences(&filler)
       && v8_heap_explorer_.IterateAndSetObjectNames(&filler);
 }
 
 
-bool HeapSnapshotGenerator::IsWindowReference(const HeapGraphEdge& edge) {
+bool HeapSnapshotGenerator::IsUserGlobalReference(const HeapGraphEdge& edge) {
   ASSERT(edge.from() == snapshot_->root());
   return edge.type() == HeapGraphEdge::kShortcut;
 }
 
 
-void HeapSnapshotGenerator::MarkWindowReachableObjects() {
+void HeapSnapshotGenerator::MarkUserReachableObjects() {
   List<HeapEntry*> worklist;
 
   Vector<HeapGraphEdge> children = snapshot_->root()->children();
   for (int i = 0; i < children.length(); ++i) {
-    if (IsWindowReference(children[i])) {
+    if (IsUserGlobalReference(children[i])) {
       worklist.Add(children[i].to());
     }
   }
 
   while (!worklist.is_empty()) {
     HeapEntry* entry = worklist.RemoveLast();
-    if (entry->reachable_from_window()) continue;
-    entry->set_reachable_from_window();
+    if (entry->user_reachable()) continue;
+    entry->set_user_reachable();
     Vector<HeapGraphEdge> children = entry->children();
     for (int i = 0; i < children.length(); ++i) {
       HeapEntry* child = children[i].to();
-      if (!child->reachable_from_window()) {
+      if (!child->user_reachable()) {
         worklist.Add(child);
       }
     }
   }
 }
 
 
 static bool IsRetainingEdge(HeapGraphEdge* edge) {
   if (edge->type() == HeapGraphEdge::kShortcut) return false;
   // The edge is not retaining if it goes from system domain
   // (i.e. an object not reachable from window) to the user domain
   // (i.e. a reachable object).
-  return edge->from()->reachable_from_window()
-      || !edge->to()->reachable_from_window();
+  return edge->from()->user_reachable()
+      || !edge->to()->user_reachable();
 }
 
 
 void HeapSnapshotGenerator::FillPostorderIndexes(
     Vector<HeapEntry*>* entries) {
   snapshot_->ClearPaint();
   int current_entry = 0;
   List<HeapEntry*> nodes_to_visit;
   HeapEntry* root = snapshot_->root();
   nodes_to_visit.Add(root);
@@ skipping 87 matching lines @@
           affected[children[j].to()->ordered_index()] = true;
         }
       }
     }
   }
   return true;
 }
 
 
 bool HeapSnapshotGenerator::SetEntriesDominators() {
-  MarkWindowReachableObjects();
+  MarkUserReachableObjects();
   // This array is used for maintaining postorder of nodes.
   ScopedVector<HeapEntry*> ordered_entries(snapshot_->entries()->length());
   FillPostorderIndexes(&ordered_entries);
   ScopedVector<int> dominators(ordered_entries.length());
   if (!BuildDominatorTree(ordered_entries, &dominators)) return false;
   for (int i = 0; i < ordered_entries.length(); ++i) {
     ASSERT(dominators[i] >= 0);
     ordered_entries[i]->set_dominator(ordered_entries[dominators[i]]);
   }
   return true;
@@ skipping 473 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal