DO NOT SUBMIT. Hacky trace event data for MessagePumpMac.

base/message_loop/message_pump_mac.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "base/message_loop/message_pump_mac.h"
 
 #import <Foundation/Foundation.h>
 
 #include <limits>
 
+#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 
 #if !defined(OS_IOS)
 #import <AppKit/AppKit.h>
 #endif  // !defined(OS_IOS)
 
 namespace {
 
@@ skipping 73 matching lines @@
   source_context.perform = RunNestingDeferredWorkSource;
   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                                         0,     // priority
                                                         &source_context);
   CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
                      kCFRunLoopCommonModes);
 
   CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();
   observer_context.info = this;
   pre_wait_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
-                                               kCFRunLoopBeforeWaiting,
+                                               kCFRunLoopBeforeWaiting |
+                                                  kCFRunLoopAfterWaiting,
                                                true,  // repeat
                                                0,     // priority
                                                PreWaitObserver,
                                                &observer_context);
   CFRunLoopAddObserver(run_loop_, pre_wait_observer_, kCFRunLoopCommonModes);
 
   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopBeforeSources,
                                                  true,  // repeat
                                                  0,     // priority
@@ skipping 104 matching lines @@
   // CFRunLoopTimers fire outside of the priority scheme for CFRunLoopSources.
   // In order to establish the proper priority in which work and delayed work
   // are processed one for one, the timer used to schedule delayed work must
   // signal a CFRunLoopSource used to dispatch both work and delayed work.
   CFRunLoopSourceSignal(self->work_source_);
 }
 
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::RunWorkSource(void* info) {
+  TRACE_EVENT0("CFRunLoop", "RunWorkSource");
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
   self->RunWork();
 }
 
 // Called by MessagePumpCFRunLoopBase::RunWorkSource.
 bool MessagePumpCFRunLoopBase::RunWork() {
   if (!delegate_) {
     // This point can be reached with a NULL delegate_ if Run is not on the
     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back
     // here when a delegate is available.
@@ skipping 39 matching lines @@
   if (resignal_work_source) {
     CFRunLoopSourceSignal(work_source_);
   }
 
   return resignal_work_source;
 }
 
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::RunIdleWorkSource(void* info) {
+  TRACE_EVENT0("CFRunLoop", "RunWorkIdleSource");
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
   self->RunIdleWork();
 }
 
 // Called by MessagePumpCFRunLoopBase::RunIdleWorkSource.
 bool MessagePumpCFRunLoopBase::RunIdleWork() {
   if (!delegate_) {
     // This point can be reached with a NULL delegate_ if Run is not on the
     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back
     // here when a delegate is available.
@@ skipping 14 matching lines @@
   if (did_work) {
     CFRunLoopSourceSignal(idle_work_source_);
   }
 
   return did_work;
 }
 
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource(void* info) {
+  TRACE_EVENT0("CFRunLoop", "RunNestingDeferredWorkSource");
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
   self->RunNestingDeferredWork();
 }
 
 // Called by MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource.
 bool MessagePumpCFRunLoopBase::RunNestingDeferredWork() {
   if (!delegate_) {
     // This point can be reached with a NULL delegate_ if Run is not on the
     // stack but foreign code is spinning the CFRunLoop.  There's no sense in
     // attempting to do any work or signalling the work sources because
@@ skipping 29 matching lines @@
   }
 }
 
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::PreWaitObserver(CFRunLoopObserverRef observer,
                                                CFRunLoopActivity activity,
                                                void* info) {
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 
+  static uint32 last_id = 0;
+  if (activity == kCFRunLoopBeforeWaiting)
+    self->nesting_stack_.push(++last_id);
+  uint64_t trace_id = ((uintptr_t)observer << sizeof(uint32)) | self->nesting_stack_.top();
+  if (activity == kCFRunLoopAfterWaiting) {
+    TRACE_EVENT_ASYNC_END0("CFRunLoop", "Waiting", trace_id);
+    self->nesting_stack_.pop();
+    return;
+  } else {
+    TRACE_EVENT_ASYNC_BEGIN0("CFRunLoop", "Waiting", trace_id);
+  }
+
   // Attempt to do some idle work before going to sleep.
   self->RunIdleWork();
 
   // The run loop is about to go to sleep.  If any of the work done since it
   // started or woke up resulted in a nested run loop running,
   // nesting-deferred work may have accumulated.  Schedule it for processing
   // if appropriate.
   self->MaybeScheduleNestingDeferredWork();
 }
 
@@ skipping 11 matching lines @@
   // appropriate.
   self->MaybeScheduleNestingDeferredWork();
 }
 
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::EnterExitObserver(CFRunLoopObserverRef observer,
                                                  CFRunLoopActivity activity,
                                                  void* info) {
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
+  static uint32 last_id = 0;
+
+  if (activity == kCFRunLoopEntry)
+    self->nesting_stack_.push(++last_id);
+
+  uint64_t trace_id = ((uintptr_t)observer << sizeof(uint32)) | self->nesting_stack_.top();
 
   switch (activity) {
     case kCFRunLoopEntry:
+      TRACE_EVENT_ASYNC_BEGIN0("CFRunLoop", "LoopCycle", trace_id);
       ++self->nesting_level_;
       if (self->nesting_level_ > self->deepest_nesting_level_) {
         self->deepest_nesting_level_ = self->nesting_level_;
       }
       break;
 
     case kCFRunLoopExit:
       // Not all run loops go to sleep.  If a run loop is stopped before it
       // goes to sleep due to a CFRunLoopStop call, or if the timeout passed
       // to CFRunLoopRunInMode expires, the run loop may proceed directly from
       // handling sources to exiting without any sleep.  This most commonly
       // occurs when CFRunLoopRunInMode is passed a timeout of 0, causing it
       // to make a single pass through the loop and exit without sleep.  Some
       // native loops use CFRunLoop in this way.  Because PreWaitObserver will
       // not be called in these case, MaybeScheduleNestingDeferredWork needs
       // to be called here, as the run loop exits.
       //
       // MaybeScheduleNestingDeferredWork consults self->nesting_level_
       // to determine whether to schedule nesting-deferred work.  It expects
       // the nesting level to be set to the depth of the loop that is going
       // to sleep or exiting.  It must be called before decrementing the
       // value so that the value still corresponds to the level of the exiting
       // loop.
       self->MaybeScheduleNestingDeferredWork();
       --self->nesting_level_;
+      TRACE_EVENT_ASYNC_END0("CFRunLoop", "LoopCycle", trace_id);
+      self->nesting_stack_.pop();
       break;
 
     default:
       break;
   }
 
   self->EnterExitRunLoop(activity);
 }
 
 // Called by MessagePumpCFRunLoopBase::EnterExitRunLoop.  The default
@@ skipping 14 matching lines @@
 
 // Called by MessagePumpCFRunLoopBase::DoRun.  If other CFRunLoopRun loops were
 // running lower on the run loop thread's stack when this object was created,
 // the same number of CFRunLoopRun loops must be running for the outermost call
 // to Run.  Run/DoRun are reentrant after that point.
 void MessagePumpCFRunLoop::DoRun(Delegate* delegate) {
   // This is completely identical to calling CFRunLoopRun(), except autorelease
   // pool management is introduced.
   int result;
   do {
+    TRACE_EVENT0("CFRunLoop", "DoRun");
     MessagePumpScopedAutoreleasePool autorelease_pool(this);
     result = CFRunLoopRunInMode(kCFRunLoopDefaultMode,
                                 kCFTimeIntervalMax,
                                 false);
   } while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished);
 }
 
 // Must be called on the run loop thread.
 void MessagePumpCFRunLoop::Quit() {
   // Stop the innermost run loop managed by this MessagePumpCFRunLoop object.
@@ skipping 34 matching lines @@
   CFRunLoopAddSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
   CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
   CFRelease(quit_source_);
 }
 
 void MessagePumpNSRunLoop::DoRun(Delegate* delegate) {
   while (keep_running_) {
+    TRACE_EVENT0("NSRunLoop", "DoRun");
     // NSRunLoop manages autorelease pools itself.
     [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
                              beforeDate:[NSDate distantFuture]];
   }
 
   keep_running_ = true;
 }
 
 void MessagePumpNSRunLoop::Quit() {
   keep_running_ = false;
@@ skipping 43 matching lines @@
   CHECK(NSApp);
 
   if (![NSApp isRunning]) {
     running_own_loop_ = false;
     // NSApplication manages autorelease pools itself when run this way.
     [NSApp run];
   } else {
     running_own_loop_ = true;
     NSDate* distant_future = [NSDate distantFuture];
     while (keep_running_) {
+      TRACE_EVENT0("NSApplication", "DoRun");
       MessagePumpScopedAutoreleasePool autorelease_pool(this);
       NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
                                           untilDate:distant_future
                                              inMode:NSDefaultRunLoopMode
                                             dequeue:YES];
       if (event) {
         [NSApp sendEvent:event];
       }
     }
     keep_running_ = true;
@@ skipping 104 matching lines @@
     [NSApplication sharedApplication];
     g_not_using_cr_app = true;
     return new MessagePumpNSApplication;
 #endif
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base