filler

src/heap-snapshot-generator.cc

Index: src/heap-snapshot-generator.cc
diff --git a/src/heap-snapshot-generator.cc b/src/heap-snapshot-generator.cc
index 0e3515c994db590cfc72e579114ae318e8a62abf..7ff714e15491cc1eb0fdc0bb0e352315ff52e68c 100644
--- a/src/heap-snapshot-generator.cc
+++ b/src/heap-snapshot-generator.cc
@@ -101,6 +101,21 @@ void HeapEntry::SetIndexedReference(HeapGraphEdge::Type type,
 }
 
 
+void HeapEntry::SetIndexedAutoIndexReference(HeapGraphEdge::Type type,
+                                             HeapEntry* child_entry) {
+  int index = children_count() + 1;
+  SetIndexedReference(type, index, child_entry);
+}
+
+
+void HeapEntry::SetNamedAutoIndexReference(HeapGraphEdge::Type type,
+                                           HeapEntry* child_entry,
+                                           StringsStorage* names) {
+  int index = children_count() + 1;
+  SetNamedReference(type, names->GetName(index), child_entry);
+}
+
+
 void HeapEntry::Print(
     const char* prefix, const char* edge_name, int max_depth, int indent) {
   STATIC_CHECK(sizeof(unsigned) == sizeof(id()));
@@ -987,7 +1002,7 @@ class IndexedReferencesExtractor : public ObjectVisitor {
  public:
   IndexedReferencesExtractor(V8HeapExplorer* generator,
                              HeapObject* parent_obj,
-                             int parent)
+                             HeapEntry* parent)
       : generator_(generator),
         parent_obj_(parent_obj),
         parent_(parent),
@@ -1025,15 +1040,14 @@ class IndexedReferencesExtractor : public ObjectVisitor {
   }
   V8HeapExplorer* generator_;
   HeapObject* parent_obj_;
-  int parent_;
+  HeapEntry* parent_;
   int next_index_;
 };
 
 
 void V8HeapExplorer::ExtractReferences(HeapObject* obj) {
-  HeapEntry* heap_entry = GetEntry(obj);
-  if (heap_entry == NULL) return;  // No interest in this object.
-  int entry = heap_entry->index();
+  HeapEntry* entry = GetEntry(obj);
+  if (entry == NULL) return;  // No interest in this object.
 
   if (obj->IsJSGlobalProxy()) {
     ExtractJSGlobalProxyReferences(entry, JSGlobalProxy::cast(obj));
@@ -1076,7 +1090,7 @@ void V8HeapExplorer::ExtractReferences(HeapObject* obj) {
 
 
 void V8HeapExplorer::ExtractJSGlobalProxyReferences(
-    int entry, JSGlobalProxy* proxy) {
+    HeapEntry* entry, JSGlobalProxy* proxy) {
   SetInternalReference(proxy, entry,
                        "native_context", proxy->native_context(),
                        JSGlobalProxy::kNativeContextOffset);
@@ -1084,7 +1098,7 @@ void V8HeapExplorer::ExtractJSGlobalProxyReferences(
 
 
 void V8HeapExplorer::ExtractJSObjectReferences(
-    int entry, JSObject* js_obj) {
+    HeapEntry* entry, JSObject* js_obj) {
   HeapObject* obj = js_obj;
   ExtractClosureReferences(js_obj, entry);
   ExtractPropertyReferences(js_obj, entry);
@@ -1169,7 +1183,7 @@ void V8HeapExplorer::ExtractJSObjectReferences(
 }
 
 
-void V8HeapExplorer::ExtractStringReferences(int entry, String* string) {
+void V8HeapExplorer::ExtractStringReferences(HeapEntry* entry, String* string) {
   if (string->IsConsString()) {
     ConsString* cs = ConsString::cast(string);
     SetInternalReference(cs, entry, "first", cs->first(),
@@ -1184,7 +1198,7 @@ void V8HeapExplorer::ExtractStringReferences(int entry, String* string) {
 }
 
 
-void V8HeapExplorer::ExtractContextReferences(int entry, Context* context) {
+void V8HeapExplorer::ExtractContextReferences(HeapEntry* entry, Context* context) {
   if (context == context->declaration_context()) {
     ScopeInfo* scope_info = context->closure()->shared()->scope_info();
     // Add context allocated locals.
@@ -1239,10 +1253,10 @@ void V8HeapExplorer::ExtractContextReferences(int entry, Context* context) {
 }
 
 
-void V8HeapExplorer::ExtractMapReferences(int entry, Map* map) {
+void V8HeapExplorer::ExtractMapReferences(HeapEntry* entry, Map* map) {
   if (map->HasTransitionArray()) {
     TransitionArray* transitions = map->transitions();
-    int transitions_entry = GetEntry(transitions)->index();
+    HeapEntry* transitions_entry = GetEntry(transitions);
     Object* back_pointer = transitions->back_pointer_storage();
     TagObject(back_pointer, "(back pointer)");
     SetInternalReference(transitions, transitions_entry,
@@ -1280,7 +1294,7 @@ void V8HeapExplorer::ExtractMapReferences(int entry, Map* map) {
 
 
 void V8HeapExplorer::ExtractSharedFunctionInfoReferences(
-    int entry, SharedFunctionInfo* shared) {
+    HeapEntry* entry, SharedFunctionInfo* shared) {
   HeapObject* obj = shared;
   String* shared_name = shared->DebugName();
   const char* name = NULL;
@@ -1333,7 +1347,7 @@ void V8HeapExplorer::ExtractSharedFunctionInfoReferences(
 }
 
 
-void V8HeapExplorer::ExtractScriptReferences(int entry, Script* script) {
+void V8HeapExplorer::ExtractScriptReferences(HeapEntry* entry, Script* script) {
   HeapObject* obj = script;
   SetInternalReference(obj, entry,
                        "source", script->source(),
@@ -1355,7 +1369,7 @@ void V8HeapExplorer::ExtractScriptReferences(int entry, Script* script) {
 
 
 void V8HeapExplorer::ExtractAccessorPairReferences(
-    int entry, AccessorPair* accessors) {
+    HeapEntry* entry, AccessorPair* accessors) {
   SetInternalReference(accessors, entry, "getter", accessors->getter(),
                        AccessorPair::kGetterOffset);
   SetInternalReference(accessors, entry, "setter", accessors->setter(),
@@ -1364,7 +1378,7 @@ void V8HeapExplorer::ExtractAccessorPairReferences(
 
 
 void V8HeapExplorer::ExtractCodeCacheReferences(
-    int entry, CodeCache* code_cache) {
+    HeapEntry* entry, CodeCache* code_cache) {
   TagObject(code_cache->default_cache(), "(default code cache)");
   SetInternalReference(code_cache, entry,
                        "default_cache", code_cache->default_cache(),
@@ -1390,7 +1404,7 @@ void V8HeapExplorer::TagCodeObject(Code* code) {
 }
 
 
-void V8HeapExplorer::ExtractCodeReferences(int entry, Code* code) {
+void V8HeapExplorer::ExtractCodeReferences(HeapEntry* entry, Code* code) {
   TagCodeObject(code);
   TagObject(code->relocation_info(), "(code relocation info)");
   SetInternalReference(code, entry,
@@ -1422,17 +1436,17 @@ void V8HeapExplorer::ExtractCodeReferences(int entry, Code* code) {
 }
 
 
-void V8HeapExplorer::ExtractBoxReferences(int entry, Box* box) {
+void V8HeapExplorer::ExtractBoxReferences(HeapEntry* entry, Box* box) {
   SetInternalReference(box, entry, "value", box->value(), Box::kValueOffset);
 }
 
 
-void V8HeapExplorer::ExtractCellReferences(int entry, Cell* cell) {
+void V8HeapExplorer::ExtractCellReferences(HeapEntry* entry, Cell* cell) {
   SetInternalReference(cell, entry, "value", cell->value(), Cell::kValueOffset);
 }
 
 
-void V8HeapExplorer::ExtractPropertyCellReferences(int entry,
+void V8HeapExplorer::ExtractPropertyCellReferences(HeapEntry* entry,
                                                    PropertyCell* cell) {
   ExtractCellReferences(entry, cell);
   SetInternalReference(cell, entry, "type", cell->type(),
@@ -1442,7 +1456,7 @@ void V8HeapExplorer::ExtractPropertyCellReferences(int entry,
 }
 
 
-void V8HeapExplorer::ExtractAllocationSiteReferences(int entry,
+void V8HeapExplorer::ExtractAllocationSiteReferences(HeapEntry* entry,
                                                      AllocationSite* site) {
   SetInternalReference(site, entry, "transition_info", site->transition_info(),
                        AllocationSite::kTransitionInfoOffset);
@@ -1475,7 +1489,7 @@ class JSArrayBufferDataEntryAllocator : public HeapEntriesAllocator {
 
 
 void V8HeapExplorer::ExtractJSArrayBufferReferences(
-    int entry, JSArrayBuffer* buffer) {
+    HeapEntry* entry, JSArrayBuffer* buffer) {
   SetWeakReference(buffer, entry, "weak_next", buffer->weak_next(),
                    JSArrayBuffer::kWeakNextOffset);
   SetWeakReference(buffer, entry,
@@ -1488,12 +1502,12 @@ void V8HeapExplorer::ExtractJSArrayBufferReferences(
   JSArrayBufferDataEntryAllocator allocator(data_size, this);
   HeapEntry* data_entry =
       filler_->FindOrAddEntry(buffer->backing_store(), &allocator);
-  filler_->SetNamedReference(HeapGraphEdge::kInternal,
-                             entry, "backing_store", data_entry);
+  entry->SetNamedReference(HeapGraphEdge::kInternal,
+                           "backing_store", data_entry);
 }
 
 
-void V8HeapExplorer::ExtractClosureReferences(JSObject* js_obj, int entry) {
+void V8HeapExplorer::ExtractClosureReferences(JSObject* js_obj, HeapEntry* entry) {
   if (!js_obj->IsJSFunction()) return;
 
   JSFunction* func = JSFunction::cast(js_obj);
@@ -1515,7 +1529,7 @@ void V8HeapExplorer::ExtractClosureReferences(JSObject* js_obj, int entry) {
 }
 
 
-void V8HeapExplorer::ExtractPropertyReferences(JSObject* js_obj, int entry) {
+void V8HeapExplorer::ExtractPropertyReferences(JSObject* js_obj, HeapEntry* entry) {
   if (js_obj->HasFastProperties()) {
     DescriptorArray* descs = js_obj->map()->instance_descriptors();
     int real_size = js_obj->map()->NumberOfOwnDescriptors();
@@ -1596,7 +1610,7 @@ void V8HeapExplorer::ExtractPropertyReferences(JSObject* js_obj, int entry) {
 
 
 bool V8HeapExplorer::ExtractAccessorPairProperty(
-    JSObject* js_obj, int entry, Object* key, Object* callback_obj) {
+    JSObject* js_obj, HeapEntry* entry, Object* key, Object* callback_obj) {
   if (!callback_obj->IsAccessorPair()) return false;
   AccessorPair* accessors = AccessorPair::cast(callback_obj);
   Object* getter = accessors->getter();
@@ -1611,7 +1625,7 @@ bool V8HeapExplorer::ExtractAccessorPairProperty(
 }
 
 
-void V8HeapExplorer::ExtractElementReferences(JSObject* js_obj, int entry) {
+void V8HeapExplorer::ExtractElementReferences(JSObject* js_obj, HeapEntry* entry) {
   if (js_obj->HasFastObjectElements()) {
     FixedArray* elements = FixedArray::cast(js_obj->elements());
     int length = js_obj->IsJSArray() ?
@@ -1637,7 +1651,7 @@ void V8HeapExplorer::ExtractElementReferences(JSObject* js_obj, int entry) {
 }
 
 
-void V8HeapExplorer::ExtractInternalReferences(JSObject* js_obj, int entry) {
+void V8HeapExplorer::ExtractInternalReferences(JSObject* js_obj, HeapEntry* entry) {
   int length = js_obj->GetInternalFieldCount();
   for (int i = 0; i < length; ++i) {
     Object* o = js_obj->GetInternalField(i);
@@ -1803,128 +1817,120 @@ bool V8HeapExplorer::IsEssentialObject(Object* object) {
 
 
 void V8HeapExplorer::SetContextReference(HeapObject* parent_obj,
-                                         int parent_entry,
+                                         HeapEntry* parent_entry,
                                          String* reference_name,
                                          Object* child_obj,
                                          int field_offset) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
-    filler_->SetNamedReference(HeapGraphEdge::kContextVariable,
-                               parent_entry,
-                               names_->GetName(reference_name),
-                               child_entry);
+    parent_entry->SetNamedReference(HeapGraphEdge::kContextVariable,
+                                    names_->GetName(reference_name),
+                                    child_entry);
     IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
   }
 }
 
 
 void V8HeapExplorer::SetNativeBindReference(HeapObject* parent_obj,
-                                            int parent_entry,
+                                            HeapEntry* parent_entry,
                                             const char* reference_name,
                                             Object* child_obj) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
-    filler_->SetNamedReference(HeapGraphEdge::kShortcut,
-                               parent_entry,
-                               reference_name,
-                               child_entry);
+    parent_entry->SetNamedReference(HeapGraphEdge::kShortcut,
+                                    reference_name,
+                                    child_entry);
   }
 }
 
 
 void V8HeapExplorer::SetElementReference(HeapObject* parent_obj,
-                                         int parent_entry,
+                                         HeapEntry* parent_entry,
                                          int index,
                                          Object* child_obj) {
   ASSERT(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
-    filler_->SetIndexedReference(HeapGraphEdge::kElement,
-                                 parent_entry,
-                                 index,
-                                 child_entry);
+    parent_entry->SetIndexedReference(HeapGraphEdge::kElement,
+                                      index,
+                                      child_entry);
   }
 }
 
 
 void V8HeapExplorer::SetInternalReference(HeapObject* parent_obj,
-                                          int parent_entry,
+                                          HeapEntry* parent_entry,
                                           const char* reference_name,
                                           Object* child_obj,
                                           int field_offset) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
-    filler_->SetNamedReference(HeapGraphEdge::kInternal,
-                               parent_entry,
-                               reference_name,
-                               child_entry);
+    parent_entry->SetNamedReference(HeapGraphEdge::kInternal,
+                                    reference_name,
+                                    child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }
 
 
 void V8HeapExplorer::SetInternalReference(HeapObject* parent_obj,
-                                          int parent_entry,
+                                          HeapEntry* parent_entry,
                                           int index,
                                           Object* child_obj,
                                           int field_offset) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
-    filler_->SetNamedReference(HeapGraphEdge::kInternal,
-                               parent_entry,
-                               names_->GetName(index),
-                               child_entry);
+    parent_entry->SetNamedReference(HeapGraphEdge::kInternal,
+                                    names_->GetName(index),
+                                    child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }
 
 
 void V8HeapExplorer::SetHiddenReference(HeapObject* parent_obj,
-                                        int parent_entry,
+                                        HeapEntry* parent_entry,
                                         int index,
                                         Object* child_obj) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL && IsEssentialObject(child_obj)) {
-    filler_->SetIndexedReference(HeapGraphEdge::kHidden,
-                                 parent_entry,
-                                 index,
-                                 child_entry);
+    parent_entry->SetIndexedReference(HeapGraphEdge::kHidden,
+                                      index,
+                                      child_entry);
   }
 }
 
 
 void V8HeapExplorer::SetWeakReference(HeapObject* parent_obj,
-                                      int parent_entry,
+                                      HeapEntry* parent_entry,
                                       const char* reference_name,
                                       Object* child_obj,
                                       int field_offset) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
-    filler_->SetNamedReference(HeapGraphEdge::kWeak,
-                               parent_entry,
-                               reference_name,
-                               child_entry);
+    parent_entry->SetNamedReference(
+        HeapGraphEdge::kWeak, reference_name, child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }
 
 
 void V8HeapExplorer::SetPropertyReference(HeapObject* parent_obj,
-                                          int parent_entry,
+                                          HeapEntry* parent_entry,
                                           Name* reference_name,
                                           Object* child_obj,
                                           const char* name_format_string,
                                           int field_offset) {
-  ASSERT(parent_entry == GetEntry(parent_obj)->index());
+  ASSERT(parent_entry == GetEntry(parent_obj));
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     HeapGraphEdge::Type type =
@@ -1937,19 +1943,15 @@ void V8HeapExplorer::SetPropertyReference(HeapObject* parent_obj,
                   DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).get()) :
         names_->GetName(reference_name);
 
-    filler_->SetNamedReference(type,
-                               parent_entry,
-                               name,
-                               child_entry);
+    parent_entry->SetNamedReference(type, name, child_entry);
     IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
   }
 }
 
 
 void V8HeapExplorer::SetRootGcRootsReference() {
-  filler_->SetIndexedAutoIndexReference(
+  snapshot_->root()->SetIndexedAutoIndexReference(
       HeapGraphEdge::kElement,
-      snapshot_->root()->index(),
       snapshot_->gc_roots());
 }
 
@@ -1957,17 +1959,16 @@ void V8HeapExplorer::SetRootGcRootsReference() {
 void V8HeapExplorer::SetUserGlobalReference(Object* child_obj) {
   HeapEntry* child_entry = GetEntry(child_obj);
   ASSERT(child_entry != NULL);
-  filler_->SetNamedAutoIndexReference(
+  snapshot_->root()->SetNamedAutoIndexReference(
       HeapGraphEdge::kShortcut,
-      snapshot_->root()->index(),
-      child_entry);
+      child_entry,
+      names_);
 }
 
 
 void V8HeapExplorer::SetGcRootsReference(VisitorSynchronization::SyncTag tag) {
-  filler_->SetIndexedAutoIndexReference(
+  snapshot_->gc_roots()->SetIndexedAutoIndexReference(
       HeapGraphEdge::kElement,
-      snapshot_->gc_roots()->index(),
       snapshot_->gc_subroot(tag));
 }
 
@@ -1978,21 +1979,19 @@ void V8HeapExplorer::SetGcSubrootReference(
   if (child_entry != NULL) {
     const char* name = GetStrongGcSubrootName(child_obj);
     if (name != NULL) {
-      filler_->SetNamedReference(
+      snapshot_->gc_subroot(tag)->SetNamedReference(
           HeapGraphEdge::kInternal,
-          snapshot_->gc_subroot(tag)->index(),
           name,
           child_entry);
     } else {
       if (is_weak) {
-        filler_->SetNamedAutoIndexReference(
+        snapshot_->gc_subroot(tag)->SetNamedAutoIndexReference(
             HeapGraphEdge::kWeak,
-            snapshot_->gc_subroot(tag)->index(),
-            child_entry);
+            child_entry,
+            names_);
       } else {
-        filler_->SetIndexedAutoIndexReference(
+        snapshot_->gc_subroot(tag)->SetIndexedAutoIndexReference(
             HeapGraphEdge::kElement,
-            snapshot_->gc_subroot(tag)->index(),
             child_entry);
       }
     }
@@ -2229,17 +2228,16 @@ void NativeObjectsExplorer::FillImplicitReferences() {
   for (int i = 0; i < groups->length(); ++i) {
     ImplicitRefGroup* group = groups->at(i);
     HeapObject* parent = *group->parent;
-    int parent_entry =
-        filler_->FindOrAddEntry(parent, native_entries_allocator_)->index();
-    ASSERT(parent_entry != HeapEntry::kNoEntry);
+    HeapEntry* parent_entry =
+        filler_->FindOrAddEntry(parent, native_entries_allocator_);
+    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, native_entries_allocator_);
-      filler_->SetNamedReference(
+      parent_entry->SetNamedReference(
           HeapGraphEdge::kInternal,
-          parent_entry,
           "native",
           child_entry);
     }
@@ -2337,10 +2335,10 @@ void NativeObjectsExplorer::SetNativeRootReference(
       FindOrAddGroupInfo(info->GetGroupLabel());
   HeapEntry* group_entry =
       filler_->FindOrAddEntry(group_info, synthetic_entries_allocator_);
-  filler_->SetNamedAutoIndexReference(
+  group_entry->SetNamedAutoIndexReference(
       HeapGraphEdge::kInternal,
-      group_entry->index(),
-      child_entry);
+      child_entry,
+      names_);
 }
 
 
@@ -2351,13 +2349,11 @@ void NativeObjectsExplorer::SetWrapperNativeReferences(
   HeapEntry* info_entry =
       filler_->FindOrAddEntry(info, native_entries_allocator_);
   ASSERT(info_entry != NULL);
-  filler_->SetNamedReference(HeapGraphEdge::kInternal,
-                             wrapper_entry->index(),
-                             "native",
-                             info_entry);
-  filler_->SetIndexedAutoIndexReference(HeapGraphEdge::kElement,
-                                        info_entry->index(),
-                                        wrapper_entry);
+  wrapper_entry->SetNamedReference(HeapGraphEdge::kInternal,
+                                   "native",
+                                   info_entry);
+  info_entry->SetIndexedAutoIndexReference(HeapGraphEdge::kElement,
+                                           wrapper_entry);
 }
 
 
@@ -2370,9 +2366,8 @@ void NativeObjectsExplorer::SetRootNativeRootsReference() {
     HeapEntry* group_entry =
         filler_->FindOrAddEntry(group_info, native_entries_allocator_);
     ASSERT(group_entry != NULL);
-    filler_->SetIndexedAutoIndexReference(
+    snapshot_->root()->SetIndexedAutoIndexReference(
         HeapGraphEdge::kElement,
-        snapshot_->root()->index(),
         group_entry);
   }
 }
@@ -2407,37 +2402,6 @@ class SnapshotFiller : public SnapshotFillerInterface {
     HeapEntry* entry = FindEntry(ptr);
     return entry != NULL ? entry : AddEntry(ptr, allocator);
   }
-  void SetIndexedReference(HeapGraphEdge::Type type,
-                           int parent,
-                           int index,
-                           HeapEntry* child_entry) {
-    HeapEntry* parent_entry = &snapshot_->entries()[parent];
-    parent_entry->SetIndexedReference(type, index, child_entry);
-  }
-  void SetIndexedAutoIndexReference(HeapGraphEdge::Type type,
-                                    int parent,
-                                    HeapEntry* child_entry) {
-    HeapEntry* parent_entry = &snapshot_->entries()[parent];
-    int index = parent_entry->children_count() + 1;
-    parent_entry->SetIndexedReference(type, index, child_entry);
-  }
-  void SetNamedReference(HeapGraphEdge::Type type,
-                         int parent,
-                         const char* reference_name,
-                         HeapEntry* child_entry) {
-    HeapEntry* parent_entry = &snapshot_->entries()[parent];
-    parent_entry->SetNamedReference(type, reference_name, child_entry);
-  }
-  void SetNamedAutoIndexReference(HeapGraphEdge::Type type,
-                                  int parent,
-                                  HeapEntry* child_entry) {
-    HeapEntry* parent_entry = &snapshot_->entries()[parent];
-    int index = parent_entry->children_count() + 1;
-    parent_entry->SetNamedReference(
-        type,
-        names_->GetName(index),
-        child_entry);
-  }
 
  private:
   HeapSnapshot* snapshot_;