A64: Synchronize with r18256.

test/cctest/test-heap-profiler.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 1745 matching lines @@
   const v8::HeapGraphNode* gc_roots = GetNode(
       snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "(GC roots)");
   CHECK_NE(NULL, gc_roots);
   const v8::HeapGraphNode* global_handles = GetNode(
       gc_roots, v8::HeapGraphNode::kSynthetic, "(Global handles)");
   CHECK_NE(NULL, global_handles);
   return HasWeakEdge(global_handles);
 }
 
 
-static void PersistentHandleCallback(v8::Isolate* isolate,
-                                     v8::Persistent<v8::Value>* handle,
-                                     void*) {
-  handle->Reset();
+static void PersistentHandleCallback(
+    const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
+  data.GetParameter()->Reset();
+  delete data.GetParameter();
 }
 
 
 TEST(WeakGlobalHandle) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   CHECK(!HasWeakGlobalHandle());
 
-  v8::Persistent<v8::Object> handle(env->GetIsolate(), v8::Object::New());
-  handle.MakeWeak<v8::Value, void>(NULL, PersistentHandleCallback);
+  v8::Persistent<v8::Object>* handle =
+      new v8::Persistent<v8::Object>(env->GetIsolate(), v8::Object::New());
+  handle->SetWeak(handle, PersistentHandleCallback);
 
   CHECK(HasWeakGlobalHandle());
 }
 
 
 TEST(SfiAndJsFunctionWeakRefs) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
@@ skipping 257 matching lines @@
     CHECK(false);
     return v8::Handle<v8::FunctionTemplate>();
   }
 }
 
 
 void HeapProfilerExtension::FindUntrackedObjects(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   i::HeapProfiler* heap_profiler =
       reinterpret_cast<i::HeapProfiler*>(args.GetIsolate()->GetHeapProfiler());
-  int untracked_objects = heap_profiler->FindUntrackedObjects();
+  int untracked_objects =
+      heap_profiler->heap_object_map()->FindUntrackedObjects();
   args.GetReturnValue().Set(untracked_objects);
   CHECK_EQ(0, untracked_objects);
 }
 
 
 static HeapProfilerExtension kHeapProfilerExtension;
 v8::DeclareExtension kHeapProfilerExtensionDeclaration(
     &kHeapProfilerExtension);
 
 
-// This is an example of using checking of JS allocations tracking in a test.
-TEST(HeapObjectsTracker) {
-  const char* extensions[] = { HeapProfilerExtension::kName };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
-  v8::HandleScope scope(env->GetIsolate());
-  HeapObjectsTracker tracker;
-  CompileRun("var a = 1.2");
-  CompileRun("var a = 1.2; var b = 1.0; var c = 1.0;");
-  CompileRun(
-    "var a = [];\n"
-    "for (var i = 0; i < 5; ++i)\n"
-    "    a[i] = i;\n"
-    "findUntrackedObjects();\n"
-    "for (var i = 0; i < 3; ++i)\n"
-    "    a.shift();\n"
-    "findUntrackedObjects();\n");
-}
-
-
 static const v8::HeapGraphNode* GetNodeByPath(const v8::HeapSnapshot* snapshot,
                                               const char* path[],
                                               int depth) {
   const v8::HeapGraphNode* node = snapshot->GetRoot();
   for (int current_depth = 0; current_depth < depth; ++current_depth) {
     int i, count = node->GetChildrenCount();
     for (i = 0; i < count; ++i) {
       const v8::HeapGraphEdge* edge = node->GetChild(i);
       const v8::HeapGraphNode* to_node = edge->GetToNode();
       v8::String::Utf8Value edge_name(edge->GetName());
@@ skipping 75 matching lines @@
 "var instances = [];\n"
 "function start() {\n"
 "  for (var i = 0; i < width; i++) {\n"
 "    instances.push(topFunctions[i](0));\n"
 "  }\n"
 "}\n"
 "\n"
 "for (var i = 0; i < 100; i++) start();\n";
 
 
-static i::HeapSnapshot* ToInternal(const v8::HeapSnapshot* snapshot) {
-  return const_cast<i::HeapSnapshot*>(
-      reinterpret_cast<const i::HeapSnapshot*>(snapshot));
-}
-
-
 static AllocationTraceNode* FindNode(
     AllocationTracker* tracker, const Vector<const char*>& names) {
   AllocationTraceNode* node = tracker->trace_tree()->root();
   for (int i = 0; node != NULL && i < names.length(); i++) {
     const char* name = names[i];
     Vector<AllocationTraceNode*> children = node->children();
     node = NULL;
     for (int j = 0; j < children.length(); j++) {
       v8::SnapshotObjectId id = children[j]->function_id();
       AllocationTracker::FunctionInfo* info = tracker->GetFunctionInfo(id);
       if (info && strcmp(info->name, name) == 0) {
         node = children[j];
         break;
       }
     }
   }
   return node;
 }
 
 
+TEST(ArrayGrowLeftTrim) {
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+  heap_profiler->StartTrackingHeapObjects(true);
+
+  CompileRun(
+    "var a = [];\n"
+    "for (var i = 0; i < 5; ++i)\n"
+    "    a[i] = i;\n"
+    "for (var i = 0; i < 3; ++i)\n"
+    "    a.shift();\n");
+
+  const char* names[] = { "(anonymous function)" };
+  AllocationTracker* tracker =
+      reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
+  CHECK_NE(NULL, tracker);
+  // Resolve all function locations.
+  tracker->PrepareForSerialization();
+  // Print for better diagnostics in case of failure.
+  tracker->trace_tree()->Print(tracker);
+
+  AllocationTraceNode* node =
+      FindNode(tracker, Vector<const char*>(names, ARRAY_SIZE(names)));
+  CHECK_NE(NULL, node);
+  CHECK_GE(node->allocation_count(), 2);
+  CHECK_GE(node->allocation_size(), 4 * 5);
+  heap_profiler->StopTrackingHeapObjects();
+}
+
+
 TEST(TrackHeapAllocations) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   LocalContext env;
 
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
-  heap_profiler->StartRecordingHeapAllocations();
+  heap_profiler->StartTrackingHeapObjects(true);
 
   CompileRun(record_trace_tree_source);
 
-  const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot(
-      v8::String::NewFromUtf8(env->GetIsolate(), "Test"));
-  i::HeapSnapshotsCollection* collection = ToInternal(snapshot)->collection();
-  AllocationTracker* tracker = collection->allocation_tracker();
+  AllocationTracker* tracker =
+      reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
   CHECK_NE(NULL, tracker);
   // Resolve all function locations.
   tracker->PrepareForSerialization();
   // Print for better diagnostics in case of failure.
   tracker->trace_tree()->Print(tracker);
 
   const char* names[] =
       { "(anonymous function)", "start", "f_0_0", "f_0_1", "f_0_2" };
   AllocationTraceNode* node =
       FindNode(tracker, Vector<const char*>(names, ARRAY_SIZE(names)));
   CHECK_NE(NULL, node);
   CHECK_GE(node->allocation_count(), 100);
   CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
-  heap_profiler->StopRecordingHeapAllocations();
+  heap_profiler->StopTrackingHeapObjects();
 }
 
 
 static const char* inline_heap_allocation_source =
 "function f_0(x) {\n"
 "  return f_1(x+1);\n"
 "}\n"
 "%NeverOptimizeFunction(f_0);\n"
 "function f_1(x) {\n"
 "  return new f_2(x+1);\n"
@@ skipping 11 matching lines @@
 
 TEST(TrackBumpPointerAllocations) {
   i::FLAG_allow_natives_syntax = true;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   LocalContext env;
 
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const char* names[] = { "(anonymous function)", "start", "f_0", "f_1" };
   // First check that normally all allocations are recorded.
   {
-    heap_profiler->StartRecordingHeapAllocations();
+    heap_profiler->StartTrackingHeapObjects(true);
 
     CompileRun(inline_heap_allocation_source);
 
-    const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot(
-        v8::String::NewFromUtf8(env->GetIsolate(), "Test2"));
-    i::HeapSnapshotsCollection* collection = ToInternal(snapshot)->collection();
-    AllocationTracker* tracker = collection->allocation_tracker();
+    AllocationTracker* tracker =
+        reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
     CHECK_NE(NULL, tracker);
     // Resolve all function locations.
     tracker->PrepareForSerialization();
     // Print for better diagnostics in case of failure.
     tracker->trace_tree()->Print(tracker);
 
     AllocationTraceNode* node =
         FindNode(tracker, Vector<const char*>(names, ARRAY_SIZE(names)));
     CHECK_NE(NULL, node);
     CHECK_GE(node->allocation_count(), 100);
     CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
-    heap_profiler->StopRecordingHeapAllocations();
+    heap_profiler->StopTrackingHeapObjects();
   }
 
   {
-    heap_profiler->StartRecordingHeapAllocations();
+    heap_profiler->StartTrackingHeapObjects(true);
 
     // Now check that not all allocations are tracked if we manually reenable
     // inline allocations.
     CHECK(CcTest::heap()->inline_allocation_disabled());
     CcTest::heap()->EnableInlineAllocation();
 
     CompileRun(inline_heap_allocation_source);
 
-    const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot(
-        v8::String::NewFromUtf8(env->GetIsolate(), "Test1"));
-    i::HeapSnapshotsCollection* collection = ToInternal(snapshot)->collection();
-    AllocationTracker* tracker = collection->allocation_tracker();
+    AllocationTracker* tracker =
+        reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
     CHECK_NE(NULL, tracker);
     // Resolve all function locations.
     tracker->PrepareForSerialization();
     // Print for better diagnostics in case of failure.
     tracker->trace_tree()->Print(tracker);
 
     AllocationTraceNode* node =
         FindNode(tracker, Vector<const char*>(names, ARRAY_SIZE(names)));
     CHECK_NE(NULL, node);
     CHECK_LT(node->allocation_count(), 100);
 
     CcTest::heap()->DisableInlineAllocation();
-    heap_profiler->StopRecordingHeapAllocations();
+    heap_profiler->StopTrackingHeapObjects();
   }
 }