Add instrumentation to the MessagePumpMac family of classes.

base/message_loop/message_loop.cc

 // Copyright 2013 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.
 
 #include "base/message_loop/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 638 matching lines @@
 bool MessageLoop::DoIdleWork() {
   if (ProcessNextDelayedNonNestableTask())
     return true;
 
   if (run_loop_->quit_when_idle_received_)
     pump_->Quit();
 
   return false;
 }
 
+void MessageLoop::GetQueueingInformation(size_t* queue_size,
+                                         TimeDelta* queueing_delay) {
+  size_t size = work_queue_.size();

[jar (doing other things), 2013/08/22 23:03:39]

Note that the "work_queue" is not really the full queue, but is only the portion
of the queue that is visible without a lock, and accessed locally on this
thread.

See ReloadWorkQueue() if you care about seeing what else is queued.

Under heavy load, I'd expect the work_queue.size() to be about half the actual
(combined) queue size... but things will vary.

[Robert Sesek, 2013/08/23 16:58:24]

Yes, I know the incoming_queue_ is not included in this count, but I did not
want to take a lock to get that information.

+  *queue_size = size + delayed_work_queue_.size();

[jar (doing other things), 2013/08/22 23:03:39]

Why is it interesting to add together pending (ready to run) queue size, plus
the delayed_work_queue (which probably mostly can't be run for a while... can be
an arbitrarily queue large... and would have no significant impact on
performance)?

[Robert Sesek, 2013/08/23 16:58:24]

Fair point. I did not count this in my initial investigation, so removed.

+
+  if (size == 0) {
+    *queueing_delay = TimeDelta();
+    return;
+  }
+
+  const PendingTask& next_to_run = work_queue_.front();

[jar (doing other things), 2013/08/22 23:03:39]

The work_queue_ could be empty... so you should test first.

[Robert Sesek, 2013/08/23 16:58:24]

Already checking size above.

[jar (doing other things), 2013/08/27 22:16:55]

<doh>... I thought you checked the sum of the sizes (queue_size).  You are
correct.

+  tracked_objects::Duration duration =
+      tracked_objects::TrackedTime::Now() - next_to_run.EffectiveTimePosted();
+  *queueing_delay = TimeDelta::FromMilliseconds(duration.InMilliseconds());
+}
+
 void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here,
                                      void(*deleter)(const void*),
                                      const void* object) {
   PostNonNestableTask(from_here, Bind(deleter, object));
 }
 
 void MessageLoop::ReleaseSoonInternal(
     const tracked_objects::Location& from_here,
     void(*releaser)(const void*),
     const void* object) {
@@ skipping 76 matching lines @@
       fd,
       persistent,
       mode,
       controller,
       delegate);
 }
 
 #endif
 
 }  // namespace base