Add instrumentation to the MessagePumpMac family of classes.

base/message_loop/message_pump_mac.h

 // 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.
 
 // The basis for all native run loops on the Mac is the CFRunLoop.  It can be
 // used directly, it can be used as the driving force behind the similar
 // Foundation NSRunLoop, and it can be used to implement higher-level event
 // loops such as the NSApplication event loop.
 //
 // This file introduces a basic CFRunLoop-based implementation of the
@@ skipping 18 matching lines @@
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_
 
 #include "base/message_loop/message_pump.h"
 
 #include "base/basictypes.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include "base/memory/weak_ptr.h"
+
 #if !defined(__OBJC__)
 class NSAutoreleasePool;
 #else  // !defined(__OBJC__)
 #if defined(OS_IOS)
 #import <Foundation/Foundation.h>
 #else
 #import <AppKit/AppKit.h>
 
 // Clients must subclass NSApplication and implement this protocol if they use
 // MessagePumpMac.
 @protocol CrAppProtocol
 // Must return true if -[NSApplication sendEvent:] is currently on the stack.
 // See the comment for |CreateAutoreleasePool()| in the cc file for why this is
 // necessary.
 - (BOOL)isHandlingSendEvent;
 @end
 #endif  // !defined(OS_IOS)
 #endif  // !defined(__OBJC__)
 
 namespace base {
 
+class MessagePumpInstrumentation;
 class RunLoop;
 class TimeTicks;
 
 class MessagePumpCFRunLoopBase : public MessagePump {
   // Needs access to CreateAutoreleasePool.
   friend class MessagePumpScopedAutoreleasePool;
  public:
   MessagePumpCFRunLoopBase();
   virtual ~MessagePumpCFRunLoopBase();
 
@@ skipping 16 matching lines @@
   // Sets this pump's delegate.  Signals the appropriate sources if
   // |delegateless_work_| is true.  |delegate| can be NULL.
   void SetDelegate(Delegate* delegate);
 
   // Return an autorelease pool to wrap around any work being performed.
   // In some cases, CreateAutoreleasePool may return nil intentionally to
   // preventing an autorelease pool from being created, allowing any
   // objects autoreleased by work to fall into the current autorelease pool.
   virtual NSAutoreleasePool* CreateAutoreleasePool();
 
+  // Enables instrumentation of the MessagePump. See MessagePumpInstrumentation
+  // in the implementation for details.
+  void EnableInstrumentation();
+  WeakPtr<MessagePumpInstrumentation> instrumentation_;
+
  private:
   // Timer callback scheduled by ScheduleDelayedWork.  This does not do any
   // work, but it signals work_source_ so that delayed work can be performed
   // within the appropriate priority constraints.
   static void RunDelayedWorkTimer(CFRunLoopTimerRef timer, void* info);
 
   // Perform highest-priority work.  This is associated with work_source_
   // signalled by ScheduleWork or RunDelayedWorkTimer.  The static method calls
   // the instance method; the instance method returns true if it resignalled
   // work_source_ to be called again from the loop.
   static void RunWorkSource(void* info);
   bool RunWork();
 
-  // Perform idle-priority work.  This is normally called by PreWaitObserver,
-  // but is also associated with idle_work_source_.  When this function
-  // actually does perform idle work, it will resignal that source.  The
-  // static method calls the instance method; the instance method returns
-  // true if idle work was done.
+  // Perform idle-priority work.  This is normally called by
+  // StartOrEndWaitObserver, but is also associated with idle_work_source_. When
+  // this function actually does perform idle work, it will resignal that
+  // source.  The static method calls the instance method; the instance method
+  // returns true if idle work was done.
   static void RunIdleWorkSource(void* info);
   bool RunIdleWork();
 
   // Perform work that may have been deferred because it was not runnable
   // within a nested run loop.  This is associated with
   // nesting_deferred_work_source_ and is signalled by
   // MaybeScheduleNestingDeferredWork when returning from a nested loop,
   // so that an outer loop will be able to perform the necessary tasks if it
   // permits nestable tasks.
   static void RunNestingDeferredWorkSource(void* info);
   bool RunNestingDeferredWork();
 
   // Schedules possible nesting-deferred work to be processed before the run
   // loop goes to sleep, exits, or begins processing sources at the top of its
   // loop.  If this function detects that a nested loop had run since the
   // previous attempt to schedule nesting-deferred work, it will schedule a
   // call to RunNestingDeferredWorkSource.
   void MaybeScheduleNestingDeferredWork();
 
   // Observer callback responsible for performing idle-priority work, before
   // the run loop goes to sleep.  Associated with idle_work_observer_.
-  static void PreWaitObserver(CFRunLoopObserverRef observer,
-                              CFRunLoopActivity activity, void* info);
+  static void StartOrEndWaitObserver(CFRunLoopObserverRef observer,
+                                     CFRunLoopActivity activity, void* info);
 
   // Observer callback called before the run loop processes any sources.
   // Associated with pre_source_observer_.
   static void PreSourceObserver(CFRunLoopObserverRef observer,
                                 CFRunLoopActivity activity, void* info);
 
   // Observer callback called when the run loop starts and stops, at the
   // beginning and end of calls to CFRunLoopRun.  This is used to maintain
   // nesting_level_.  Associated with enter_exit_observer_.
   static void EnterExitObserver(CFRunLoopObserverRef observer,
@@ skipping 173 matching lines @@
   BASE_EXPORT static bool IsHandlingSendEvent();
 #endif  // !defined(OS_IOS)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MessagePumpMac);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_