[Mac] Execute as many MessageLoop tasks as possible.

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"
 
 #include <dlfcn.h>
 #import <Foundation/Foundation.h>
 
 #include <limits>
@@ skipping 535 matching lines @@
   if (instrumentation_)
     instrumentation_->WorkSourceEntered(delegate_);
 
   // The NSApplication-based run loop only drains the autorelease pool at each
   // UI event (NSEvent).  The autorelease pool is not drained for each
   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased
   // objects if the app is not currently handling a UI event to ensure they're
   // released promptly even in the absence of UI events.
   MessagePumpScopedAutoreleasePool autorelease_pool(this);
 
-  // Call DoWork and DoDelayedWork once, and if something was done, arrange to
-  // come back here again as long as the loop is still running.
-  bool did_work = delegate_->DoWork();
-  bool resignal_work_source = did_work;
+  // Allocate a time slice in which as many tasks as possible will be run.
+  // Performing only one task per run loop tick is potentially inefficient in
+  // the face of a large backlog of pending tasks. https://crbug.com/264886
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeTicks time_slice_end = now + base::TimeDelta::FromMilliseconds(50);
+  int ran_task_count = 0;
+  bool did_work = false, did_work_last_slice = true;
+  for ( ;
+       now < time_slice_end && did_work_last_slice;
+       now = base::TimeTicks::Now()) {
+    quit_was_called_ = false;
+    did_work_last_slice = delegate_->DoWork();
+    did_work |= did_work_last_slice;
+    if (quit_was_called_)
+      break;
+    if (did_work_last_slice)
+      ++ran_task_count;
+  }
+
+  // Record how many tasks were accomplished in the time slice, and by how
+  // much the work overran the time slice deadline.
+  UMA_HISTOGRAM_CUSTOM_TIMES("MessagePumpMac.TimeSliceOverRun",
+                             time_slice_end - base::TimeTicks::Now(),
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromSeconds(5),
+                             100);
+  UMA_HISTOGRAM_COUNTS("MessagePumpMac.TimeSliceTaskCount", ran_task_count);
+
+  if (quit_was_called_)
+    return false;
+
+  // If the time slice expired and work was done in the last fraction of the
+  // time slice, arrange to come back here to execute more tasks.
+  bool resignal_work_source = did_work_last_slice;
 
   TimeTicks next_time;
   delegate_->DoDelayedWork(&next_time);
   if (!did_work) {
     // Determine whether there's more delayed work, and if so, if it needs to
     // be done at some point in the future or if it's already time to do it.
     // Only do these checks if did_work is false. If did_work is true, this
     // function, and therefore any additional delayed work, will get another
     // chance to run before the loop goes to sleep.
     bool more_delayed_work = !next_time.is_null();
@@ skipping 218 matching lines @@
   do {
     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() {
+  quit_was_called_ = true;
   // Stop the innermost run loop managed by this MessagePumpCFRunLoop object.
   if (nesting_level() == run_nesting_level()) {
     // This object is running the innermost loop, just stop it.
     CFRunLoopStop(run_loop());
   } else {
     // There's another loop running inside the loop managed by this object.
     // In other words, someone else called CFRunLoopRunInMode on the same
     // thread, deeper on the stack than the deepest Run call.  Don't preempt
     // other run loops, just mark this object to quit the innermost Run as
     // soon as the other inner loops not managed by Run are done.
@@ skipping 34 matching lines @@
   while (keep_running_) {
     // NSRunLoop manages autorelease pools itself.
     [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
                              beforeDate:[NSDate distantFuture]];
   }
 
   keep_running_ = true;
 }
 
 void MessagePumpNSRunLoop::Quit() {
+  quit_was_called_ = true;
   keep_running_ = false;
   CFRunLoopSourceSignal(quit_source_);
   CFRunLoopWakeUp(run_loop());
 }
 
 #if defined(OS_IOS)
 MessagePumpUIApplication::MessagePumpUIApplication()
     : run_loop_(NULL) {
 }
 
@@ skipping 54 matching lines @@
         [NSApp sendEvent:event];
       }
     }
     keep_running_ = true;
   }
 
   running_own_loop_ = last_running_own_loop_;
 }
 
 void MessagePumpNSApplication::Quit() {
+  quit_was_called_ = true;
   if (!running_own_loop_) {
     [[NSApplication sharedApplication] stop:nil];
   } else {
     keep_running_ = false;
   }
 
   // Send a fake event to wake the loop up.
   [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined
                                       location:NSZeroPoint
                                  modifierFlags:0
@@ skipping 88 matching lines @@
     [NSApplication sharedApplication];
     g_not_using_cr_app = true;
     return new MessagePumpNSApplication;
 #endif
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base