Heap profiler should report implicit references

src/profile-generator.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 2764 matching lines @@
     group->info_ = NULL;  // Acquire info object ownership.
   }
   isolate->global_handles()->RemoveObjectGroups();
   isolate->heap()->CallGlobalGCEpilogueCallback();
   // Record objects that are not in ObjectGroups, but have class ID.
   GlobalHandlesExtractor extractor(this);
   isolate->global_handles()->IterateAllRootsWithClassIds(&extractor);
   embedder_queried_ = true;
 }
 
+void NativeObjectsExplorer::FillImplicitReferences() {
+  Isolate* isolate = Isolate::Current();
+  List<ImplicitRefGroup*>* groups =
+      isolate->global_handles()->implicit_ref_groups();
+  for (int i = 0; i < groups->length(); ++i) {
+    ImplicitRefGroup* group = groups->at(i);
+    HeapObject* parent = *group->parent_;
+    HeapEntry* parent_entry = filler_->FindOrAddEntry(parent, this);
+    ASSERT(parent_entry != NULL);
+    Object*** children = group->children_;
+    for (size_t j = 0; j < group->length_; ++j) {
+      Object* child = *children[j];
+      HeapEntry* child_entry = filler_->FindOrAddEntry(child, this);
+      filler_->SetNamedReference(
+          HeapGraphEdge::kInternal,
+          parent, parent_entry,
+          "native",

[mnaganov (inactive), 2012/02/03 13:57:19]

Does this look descriptive enough? If implicit refs are only for event handlers,
perhaps we can call this more specific?

[yurys, 2012/02/03 14:09:26]

For now it seems good enough. We cannot assume that all implicit references on
all embedders will always be for event handlers only even if it is so in
Chromium at the moment. We would like to extend information about such
references with e.g. event names and probably something else but for now just
having a strong reference reflected in the heap snapshot is enough.

+          child, child_entry);
+    }
+  }
+}
 
 List<HeapObject*>* NativeObjectsExplorer::GetListMaybeDisposeInfo(
     v8::RetainedObjectInfo* info) {
   HashMap::Entry* entry =
       objects_by_info_.Lookup(info, InfoHash(info), true);
   if (entry->value != NULL) {
     info->Dispose();
   } else {
     entry->value = new List<HeapObject*>(4);
   }
   return reinterpret_cast<List<HeapObject*>* >(entry->value);
 }
 
 
 bool NativeObjectsExplorer::IterateAndExtractReferences(
     SnapshotFillerInterface* filler) {
-  if (EstimateObjectsCount() <= 0) return true;
   filler_ = filler;
   FillRetainedObjects();
+  FillImplicitReferences();
+  if (EstimateObjectsCount() <= 0) {

[mnaganov (inactive), 2012/02/03 13:57:19]

Let's rewrite this as follows to avoid cleanup code duplication:

if (EstimateObjectsCount() > 0) {
  for(...) {
  }
  SetRootNative...
}
filler_ = NULL;
return true;

[yurys, 2012/02/03 14:09:26]

Done.

+    filler_ = NULL;
+    return true;
+  }
   for (HashMap::Entry* p = objects_by_info_.Start();
        p != NULL;
        p = objects_by_info_.Next(p)) {
     v8::RetainedObjectInfo* info =
         reinterpret_cast<v8::RetainedObjectInfo*>(p->key);
     SetNativeRootReference(info);
     List<HeapObject*>* objects =
         reinterpret_cast<List<HeapObject*>* >(p->value);
     for (int i = 0; i < objects->length(); ++i) {
       SetWrapperNativeReferences(objects->at(i), info);
@@ skipping 853 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