Add timeline event for weak handle processing.

runtime/vm/gc_marker.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/gc_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 634 matching lines @@
 
 
 void GCMarker::MarkObjects(Isolate* isolate,
                            PageSpace* page_space,
                            bool invoke_api_callbacks,
                            bool collect_code) {
   Prologue(isolate, invoke_api_callbacks);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
-    StackZone stack_zone(Thread::Current());
+    Thread* thread = Thread::Current();
+    StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     MarkingStack marking_stack;
     marked_bytes_ = 0;
     const int num_tasks = FLAG_marker_tasks;
     if (num_tasks == 0) {
       // Mark everything on main thread.
       SkippedCodeFunctions* skipped_code_functions =
           collect_code ? new(zone) SkippedCodeFunctions() : NULL;
       UnsyncMarkingVisitor mark(isolate, heap_, page_space, &marking_stack,
                                 skipped_code_functions);
       IterateRoots(isolate, &mark, 0, 1);
       mark.DrainMarkingStack();
-      MarkingWeakVisitor mark_weak;
-      IterateWeakRoots(isolate, &mark_weak);
+      {
+        TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
+        MarkingWeakVisitor mark_weak;
+        IterateWeakRoots(isolate, &mark_weak);
+      }
       // All marking done; detach code, etc.
       FinalizeResultsFrom(&mark);
     } else {
       ThreadBarrier barrier(num_tasks + 1,
                             heap_->barrier(),
                             heap_->barrier_done());
       // Used to coordinate draining among tasks; all start out as 'busy'.
       uintptr_t num_busy = num_tasks;
       // Phase 1: Iterate over roots and drain marking stack in tasks.
       for (intptr_t i = 0; i < num_tasks; ++i) {
         MarkTask* mark_task =
             new MarkTask(this, isolate, heap_, page_space, &marking_stack,
                          &barrier, collect_code,
                          i, num_tasks, &num_busy);
         ThreadPool* pool = Dart::thread_pool();
         pool->Run(mark_task);
       }
       barrier.Sync();
 
       // Phase 2: Weak processing on main thread.
-      MarkingWeakVisitor mark_weak;
-      IterateWeakRoots(isolate, &mark_weak);
+      {
+        TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
+        MarkingWeakVisitor mark_weak;
+        IterateWeakRoots(isolate, &mark_weak);
+      }
       barrier.Sync();
 
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart