Add an interface for an embedder to provide information about native

src/heap-profiler.cc

 // Copyright 2009-2010 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 346 matching lines @@
 
 
 HeapSnapshot* HeapProfiler::TakeSnapshot(String* name,
                                          int type,
                                          v8::ActivityControl* control) {
   ASSERT(singleton_ != NULL);
   return singleton_->TakeSnapshotImpl(name, type, control);
 }
 
 
+void HeapProfiler::DefineWrapperClass(
+    uint16_t class_id, v8::HeapProfiler::WrapperInfoCallback callback) {

[Vitaly Repeshko, 2011/03/09 19:10:08]

Assert class_id is not kNoClassId.

[mnaganov (inactive), 2011/03/10 12:23:35]

Done.

+  ASSERT(singleton_ != NULL);
+  if (singleton_->wrapper_callbacks_.length() <= class_id) {
+    singleton_->wrapper_callbacks_.AddBlock(
+        NULL, class_id - singleton_->wrapper_callbacks_.length() + 1);
+  }
+  singleton_->wrapper_callbacks_[class_id] = callback;
+}
+
+
+v8::RetainedObjectInfo* HeapProfiler::ExecuteWrapperClassCallback(
+    uint16_t class_id, Object** wrapper) {
+  ASSERT(singleton_ != NULL);
+  if (singleton_->wrapper_callbacks_.length() <= class_id) return NULL;
+  return singleton_->wrapper_callbacks_[class_id](
+      class_id, Utils::ToLocal(Handle<Object>(wrapper)));
+}
+
+
 HeapSnapshot* HeapProfiler::TakeSnapshotImpl(const char* name,
                                              int type,
                                              v8::ActivityControl* control) {
   HeapSnapshot::Type s_type = static_cast<HeapSnapshot::Type>(type);
   HeapSnapshot* result =
       snapshots_->NewSnapshot(s_type, name, next_snapshot_uid_++);
   bool generation_completed = true;
   switch (s_type) {
     case HeapSnapshot::kFull: {
       Heap::CollectAllGarbage(true);
@@ skipping 17 matching lines @@
     result = NULL;
   }
   snapshots_->SnapshotGenerationFinished(result);
   return result;
 }
 
 
 HeapSnapshot* HeapProfiler::TakeSnapshotImpl(String* name,
                                              int type,
                                              v8::ActivityControl* control) {
-  return TakeSnapshotImpl(snapshots_->GetName(name), type, control);
+  return TakeSnapshotImpl(snapshots_->names()->GetName(name), type, control);
 }
 
 
 int HeapProfiler::GetSnapshotsCount() {
   ASSERT(singleton_ != NULL);
   return singleton_->snapshots_->snapshots()->length();
 }
 
 
 HeapSnapshot* HeapProfiler::GetSnapshot(int index) {
@@ skipping 450 matching lines @@
   AllocatingConstructorHeapProfileIterator(HeapSnapshot* snapshot,
                                   int* root_child_index)
       : snapshot_(snapshot),
         root_child_index_(root_child_index) {
   }
 
   void Call(const JSObjectsCluster& cluster,
             const NumberAndSizeInfo& number_and_size) {
     const char* name = cluster.GetSpecialCaseName();
     if (name == NULL) {
-      name = snapshot_->collection()->GetFunctionName(cluster.constructor());
+      name = snapshot_->collection()->names()->GetFunctionName(
+          cluster.constructor());
     }
     AddEntryFromAggregatedSnapshot(snapshot_,
                                    root_child_index_,
                                    HeapEntry::kObject,
                                    name,
                                    number_and_size.number(),
                                    number_and_size.bytes(),
                                    0,
                                    0);
   }
@@ skipping 120 matching lines @@
       : snapshot_(snapshot), root_child_index_(root_child_index) {
   }
   ~AggregatedRetainerTreeAllocator() { }
 
   HeapEntry* AllocateEntry(
       HeapThing ptr, int children_count, int retainers_count) {
     HeapObject* obj = reinterpret_cast<HeapObject*>(ptr);
     JSObjectsCluster cluster = HeapObjectAsCluster(obj);
     const char* name = cluster.GetSpecialCaseName();
     if (name == NULL) {
-      name = snapshot_->collection()->GetFunctionName(cluster.constructor());
+      name = snapshot_->collection()->names()->GetFunctionName(
+          cluster.constructor());
     }
     return AddEntryFromAggregatedSnapshot(
         snapshot_, root_child_index_, HeapEntry::kObject, name,
         0, 0, children_count, retainers_count);
   }
 
  private:
   HeapSnapshot* snapshot_;
   int* root_child_index_;
 };
@@ skipping 92 matching lines @@
   GlobalHandles::MakeWeak(handle.location(),
                           static_cast<void*>(stack.start()),
                           StackWeakReferenceCallback);
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 } }  // namespace v8::internal