Improve support for a host owned message pump (issue #1805)

- Add new CefSettings.external_message_pump option and
  CefBrowserProcessHandler::OnScheduleMessagePumpWork() callback.
- Improve documentation related to CefDoMessageLoopWork().
- Pass `--external-message-pump` command-line flag to cefclient or
  cef_unittests to test the new mode.

tests/cefclient/browser/client_app_browser.cc

@@ -6,6 +6,7 @@
 
 #include "include/base/cef_logging.h"
 #include "include/cef_cookie.h"
+#include "cefclient/browser/main_message_loop_external_pump.h"
 #include "cefclient/common/client_switches.h"
 
 namespace client {
@@ -82,4 +83,12 @@ void ClientAppBrowser::OnRenderProcessThreadCreated(
     (*it)->OnRenderProcessThreadCreated(this, extra_info);
 }
 
+void ClientAppBrowser::OnScheduleMessagePumpWork(int64 delay) {
+  // Only used when `--external-message-pump` is passed via the command-line.
+  MainMessageLoopExternalPump* message_pump =
+      MainMessageLoopExternalPump::Get();
+  if (message_pump)
+    message_pump->OnScheduleMessagePumpWork(delay);
+}
+
 }  // namespace client

tests/cefclient/browser/client_app_browser.h

@@ -66,6 +66,7 @@ class ClientAppBrowser : public ClientApp,
   CefRefPtr<CefPrintHandler> GetPrintHandler() OVERRIDE {
     return print_handler_;
   }
+  void OnScheduleMessagePumpWork(int64 delay) OVERRIDE;
 
   // Set of supported Delegates.
   DelegateSet delegates_;

tests/cefclient/browser/main_context_impl.cc

@@ -113,6 +113,11 @@ void MainContextImpl::PopulateSettings(CefSettings* settings) {
       command_line_->HasSwitch(switches::kMultiThreadedMessageLoop);
 #endif
 
+  if (!settings->multi_threaded_message_loop) {
+    settings->external_message_pump =
+        command_line_->HasSwitch(switches::kExternalMessagePump);
+  }
+
   CefString(&settings->cache_path) =
       command_line_->GetSwitchValue(switches::kCachePath);
 

tests/cefclient/browser/main_message_loop.h

@@ -51,7 +51,7 @@ class MainMessageLoop {
 
  protected:
   // Only allow deletion via scoped_ptr.
-  friend struct base::DefaultDeleter<MainMessageLoop>;
+  friend DEFAULT_DELETER(MainMessageLoop);
 
   MainMessageLoop();
   virtual ~MainMessageLoop();

tests/cefclient/browser/main_message_loop_external_pump.cc

@@ -0,0 +1,108 @@
+// Copyright (c) 2016 The Chromium Embedded Framework 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 "cefclient/browser/main_message_loop_external_pump.h"
+
+#include <climits>
+
+#include "include/cef_app.h"
+#include "include/wrapper/cef_helpers.h"
+#include "cefclient/browser/main_message_loop.h"
+
+namespace client {
+
+namespace {
+
+// Special timer delay placeholder value. Intentionally 32-bit for Windows and
+// OS X platform API compatibility.
+const int32 kTimerDelayPlaceholder = INT_MAX;
+
+// The maximum number of milliseconds we're willing to wait between calls to
+// DoWork().
+const int64 kMaxTimerDelay = 1000 / 30;  // 30fps
+
+client::MainMessageLoopExternalPump* g_external_message_pump = NULL;
+
+} // namespace
+
+MainMessageLoopExternalPump::MainMessageLoopExternalPump()
+  : is_active_(false),
+    reentrancy_detected_(false) {
+  DCHECK(!g_external_message_pump);
+  g_external_message_pump = this;
+}
+
+MainMessageLoopExternalPump::~MainMessageLoopExternalPump() {
+  g_external_message_pump = NULL;
+}
+
+MainMessageLoopExternalPump* MainMessageLoopExternalPump::Get() {
+  return g_external_message_pump;
+}
+
+void MainMessageLoopExternalPump::OnScheduleWork(int64 delay_ms) {
+  REQUIRE_MAIN_THREAD();
+
+  if (delay_ms == kTimerDelayPlaceholder && IsTimerPending()) {
+    // Don't set the maximum timer requested from DoWork() if a timer event is
+    // currently pending.
+    return;
+  }
+
+  KillTimer();
+
+  if (delay_ms <= 0) {
+    // Execute the work immediately.
+    DoWork();
+  } else {
+    // Never wait longer than the maximum allowed time.
+    if (delay_ms > kMaxTimerDelay)
+      delay_ms = kMaxTimerDelay;
+
+    // Results in call to OnTimerTimeout() after the specified delay.
+    SetTimer(delay_ms);
+  }
+}
+
+void MainMessageLoopExternalPump::OnTimerTimeout() {
+  REQUIRE_MAIN_THREAD();
+
+  KillTimer();
+  DoWork();
+}
+
+void MainMessageLoopExternalPump::DoWork() {
+  const bool was_reentrant = PerformMessageLoopWork();
+  if (was_reentrant) {
+    // Execute the remaining work as soon as possible.
+    OnScheduleMessagePumpWork(0);
+  } else if (!IsTimerPending()) {
+    // Schedule a timer event at the maximum allowed time. This may be dropped
+    // in OnScheduleWork() if another timer event is already in-flight.
+    OnScheduleMessagePumpWork(kTimerDelayPlaceholder);
+  }
+}
+
+bool MainMessageLoopExternalPump::PerformMessageLoopWork() {
+  if (is_active_) {
+    // When CefDoMessageLoopWork() is called there may be various callbacks
+    // (such as paint and IPC messages) that result in additional calls to this
+    // method. If re-entrancy is detected we must repost a request again to the
+    // owner thread to ensure that the discarded call is executed in the future.
+    reentrancy_detected_ = true;
+    return false;
+  }
+
+  reentrancy_detected_ = false;
+
+  is_active_ = true;
+  CefDoMessageLoopWork();
+  is_active_ = false;
+
+  // |reentrancy_detected_| may have changed due to re-entrant calls to this
+  // method.
+  return reentrancy_detected_;
+}
+
+}  // namespace client

tests/cefclient/browser/main_message_loop_external_pump.h

@@ -0,0 +1,70 @@
+// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#ifndef CEF_TESTS_CEFCLIENT_BROWSER_MAIN_MESSAGE_LOOP_EXTERNAL_PUMP_H_
+#define CEF_TESTS_CEFCLIENT_BROWSER_MAIN_MESSAGE_LOOP_EXTERNAL_PUMP_H_
+#pragma once
+
+#include "cefclient/browser/main_message_loop_std.h"
+
+namespace client {
+
+// This MessageLoop implementation simulates the embedding of CEF into an
+// existing host application that runs its own message loop. The scheduling
+// implementation provided by this class is very simplistic and does not handle
+// all cases (for example, nested message loops on Windows will not function
+// correctly). See comments in Chromium's platform-specific
+// base/message_loop/message_pump_* source files for additional guidance when
+// implementing CefBrowserProcessHandler::OnScheduleMessagePumpWork() in your
+// application. Run cefclient or cef_unittests with the
+// "--external-message-pump" command-line flag to test this mode.
+class MainMessageLoopExternalPump : public MainMessageLoopStd {
+ public:
+  // Creates the singleton instance of this object. Must be called on the main
+  // application thread.
+  static scoped_ptr<MainMessageLoopExternalPump> Create();
+
+  // Returns the singleton instance of this object. Safe to call from any
+  // thread.
+  static MainMessageLoopExternalPump* Get();
+
+  // Called from CefBrowserProcessHandler::OnScheduleMessagePumpWork() on any
+  // thread. The platform subclass must implement this method and schedule a
+  // call to OnScheduleWork() on the main application thread.
+  virtual void OnScheduleMessagePumpWork(int64 delay_ms) = 0;
+
+ protected:
+  // Only allow deletion via scoped_ptr.
+  friend DEFAULT_DELETER(MainMessageLoopExternalPump);
+
+  // Construct and destruct this object on the main application thread.
+  MainMessageLoopExternalPump();
+  ~MainMessageLoopExternalPump();
+
+  // The platform subclass calls this method on the main application thread in
+  // response to the OnScheduleMessagePumpWork() call.
+  void OnScheduleWork(int64 delay_ms);
+
+  // The platform subclass calls this method on the main application thread when
+  // the pending work timer times out.
+  void OnTimerTimeout();
+
+  // Control the pending work timer in the platform subclass. Only called on
+  // the main application thread.
+  virtual void SetTimer(int64 delay_ms) = 0;
+  virtual void KillTimer() = 0;
+  virtual bool IsTimerPending() = 0;
+
+ private:
+  // Handle work processing.
+  void DoWork();
+  bool PerformMessageLoopWork();
+
+  bool is_active_;
+  bool reentrancy_detected_;
+};
+
+}  // namespace client
+
+#endif  // CEF_TESTS_CEFCLIENT_BROWSER_MAIN_MESSAGE_LOOP_EXTERNAL_PUMP_H_

tests/cefclient/browser/main_message_loop_external_pump_linux.cc

@@ -0,0 +1,304 @@
+// Copyright (c) 2016 The Chromium Embedded Framework 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 "cefclient/browser/main_message_loop_external_pump.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <math.h>
+
+#include <glib.h>
+
+#include "include/cef_app.h"
+
+// From base/posix/eintr_wrapper.h.
+// This provides a wrapper around system calls which may be interrupted by a
+// signal and return EINTR. See man 7 signal.
+// To prevent long-lasting loops (which would likely be a bug, such as a signal
+// that should be masked) to go unnoticed, there is a limit after which the
+// caller will nonetheless see an EINTR in Debug builds.
+#if !defined(HANDLE_EINTR)
+#if defined(NDEBUG)
+
+#define HANDLE_EINTR(x) ({ \
+  decltype(x) eintr_wrapper_result; \
+  do { \
+    eintr_wrapper_result = (x); \
+  } while (eintr_wrapper_result == -1 && errno == EINTR); \
+  eintr_wrapper_result; \
+})
+
+#else
+
+#define HANDLE_EINTR(x) ({ \
+  int eintr_wrapper_counter = 0; \
+  decltype(x) eintr_wrapper_result; \
+  do { \
+    eintr_wrapper_result = (x); \
+  } while (eintr_wrapper_result == -1 && errno == EINTR && \
+           eintr_wrapper_counter++ < 100); \
+  eintr_wrapper_result; \
+})
+
+#endif  // defined(NDEBUG)
+#endif  // !defined(HANDLE_EINTR)
+
+namespace client {
+
+namespace {
+
+class MainMessageLoopExternalPumpLinux : public MainMessageLoopExternalPump {
+ public:
+  MainMessageLoopExternalPumpLinux();
+  ~MainMessageLoopExternalPumpLinux();
+
+  // MainMessageLoopStd methods:
+  void Quit() OVERRIDE;
+  int Run() OVERRIDE;
+
+  // MainMessageLoopExternalPump methods:
+  void OnScheduleMessagePumpWork(int64 delay_ms) OVERRIDE;
+
+  // Internal methods used for processing the pump callbacks. They are public
+  // for simplicity but should not be used directly. HandlePrepare is called
+  // during the prepare step of glib, and returns a timeout that will be passed
+  // to the poll. HandleCheck is called after the poll has completed, and
+  // returns whether or not HandleDispatch should be called. HandleDispatch is
+  // called if HandleCheck returned true.
+  int HandlePrepare();
+  bool HandleCheck();
+  void HandleDispatch();
+
+ protected:
+  // MainMessageLoopExternalPump methods:
+  void SetTimer(int64 delay_ms) OVERRIDE;
+  void KillTimer() OVERRIDE;
+  bool IsTimerPending() OVERRIDE;
+
+ private:
+  // Used to flag that the Run() invocation should return ASAP.
+  bool should_quit_;
+
+  // A GLib structure that we can add event sources to. We use the default GLib
+  // context, which is the one to which all GTK events are dispatched.
+  GMainContext* context_;
+
+  // The work source. It is destroyed when the message pump is destroyed.
+  GSource* work_source_;
+
+  // The time when we need to do delayed work.
+  CefTime delayed_work_time_;
+
+  // We use a wakeup pipe to make sure we'll get out of the glib polling phase
+  // when another thread has scheduled us to do some work. There is a glib
+  // mechanism g_main_context_wakeup, but this won't guarantee that our event's
+  // Dispatch() will be called.
+  int wakeup_pipe_read_;
+  int wakeup_pipe_write_;
+
+  // Use a scoped_ptr to avoid needing the definition of GPollFD in the header.
+  scoped_ptr<GPollFD> wakeup_gpollfd_;
+};
+
+// Return a timeout suitable for the glib loop, -1 to block forever,
+// 0 to return right away, or a timeout in milliseconds from now.
+int GetTimeIntervalMilliseconds(const CefTime& from) {
+  if (from.GetDoubleT() == 0.0)
+    return -1;
+
+  CefTime now;
+  now.Now();
+
+  // Be careful here. CefTime has a precision of microseconds, but we want a
+  // value in milliseconds. If there are 5.5ms left, should the delay be 5 or
+  // 6?  It should be 6 to avoid executing delayed work too early.
+  int delay = static_cast<int>(
+      ceil((from.GetDoubleT() - now.GetDoubleT()) * 1000.0));
+
+  // If this value is negative, then we need to run delayed work soon.
+  return delay < 0 ? 0 : delay;
+}
+
+struct WorkSource : public GSource {
+  MainMessageLoopExternalPumpLinux* pump;
+};
+
+gboolean WorkSourcePrepare(GSource* source,
+                           gint* timeout_ms) {
+  *timeout_ms = static_cast<WorkSource*>(source)->pump->HandlePrepare();
+  // We always return FALSE, so that our timeout is honored.  If we were
+  // to return TRUE, the timeout would be considered to be 0 and the poll
+  // would never block.  Once the poll is finished, Check will be called.
+  return FALSE;
+}
+
+gboolean WorkSourceCheck(GSource* source) {
+  // Only return TRUE if Dispatch should be called.
+  return static_cast<WorkSource*>(source)->pump->HandleCheck();
+}
+
+gboolean WorkSourceDispatch(GSource* source,
+                            GSourceFunc unused_func,
+                            gpointer unused_data) {
+
+  static_cast<WorkSource*>(source)->pump->HandleDispatch();
+  // Always return TRUE so our source stays registered.
+  return TRUE;
+}
+
+// I wish these could be const, but g_source_new wants non-const.
+GSourceFuncs WorkSourceFuncs = {
+  WorkSourcePrepare,
+  WorkSourceCheck,
+  WorkSourceDispatch,
+  NULL
+};
+
+MainMessageLoopExternalPumpLinux::MainMessageLoopExternalPumpLinux()
+  : should_quit_(false),
+    context_(g_main_context_default()),
+    wakeup_gpollfd_(new GPollFD) {
+  // Create our wakeup pipe, which is used to flag when work was scheduled.
+  int fds[2];
+  int ret = pipe(fds);
+  DCHECK_EQ(ret, 0);
+  (void)ret;  // Prevent warning in release mode.
+
+  wakeup_pipe_read_  = fds[0];
+  wakeup_pipe_write_ = fds[1];
+  wakeup_gpollfd_->fd = wakeup_pipe_read_;
+  wakeup_gpollfd_->events = G_IO_IN;
+
+  work_source_ = g_source_new(&WorkSourceFuncs, sizeof(WorkSource));
+  static_cast<WorkSource*>(work_source_)->pump = this;
+  g_source_add_poll(work_source_, wakeup_gpollfd_.get());
+  // Use a low priority so that we let other events in the queue go first.
+  g_source_set_priority(work_source_, G_PRIORITY_DEFAULT_IDLE);
+  // This is needed to allow Run calls inside Dispatch.
+  g_source_set_can_recurse(work_source_, TRUE);
+  g_source_attach(work_source_, context_);
+}
+
+MainMessageLoopExternalPumpLinux::~MainMessageLoopExternalPumpLinux() {
+  g_source_destroy(work_source_);
+  g_source_unref(work_source_);
+  close(wakeup_pipe_read_);
+  close(wakeup_pipe_write_);
+}
+
+void MainMessageLoopExternalPumpLinux::Quit() {
+  should_quit_ = true;
+}
+
+int MainMessageLoopExternalPumpLinux::Run() {
+  // We really only do a single task for each iteration of the loop. If we
+  // have done something, assume there is likely something more to do. This
+  // will mean that we don't block on the message pump until there was nothing
+  // more to do. We also set this to true to make sure not to block on the
+  // first iteration of the loop.
+  bool more_work_is_plausible = true;
+
+  // We run our own loop instead of using g_main_loop_quit in one of the
+  // callbacks. This is so we only quit our own loops, and we don't quit
+  // nested loops run by others.
+  for (;;) {
+    // Don't block if we think we have more work to do.
+    bool block = !more_work_is_plausible;
+
+    more_work_is_plausible = g_main_context_iteration(context_, block);
+    if (should_quit_)
+      break;
+  }
+
+  // We need to run the message pump until it is idle. However we don't have
+  // that information here so we run the message loop "for a while".
+  for (int i = 0; i < 10; ++i) {
+    // Do some work.
+    CefDoMessageLoopWork();
+
+    // Sleep to allow the CEF proc to do work.
+    usleep(50000);
+  }
+
+  return 0;
+}
+
+void MainMessageLoopExternalPumpLinux::OnScheduleMessagePumpWork(
+    int64 delay_ms) {
+  // This can be called on any thread, so we don't want to touch any state
+  // variables as we would then need locks all over. This ensures that if we
+  // are sleeping in a poll that we will wake up.
+  if (HANDLE_EINTR(write(wakeup_pipe_write_, &delay_ms, sizeof(int64))) !=
+                   sizeof(int64)) {
+    NOTREACHED() << "Could not write to the UI message loop wakeup pipe!";
+  }
+}
+
+// Return the timeout we want passed to poll.
+int MainMessageLoopExternalPumpLinux::HandlePrepare() {
+  // We don't think we have work to do, but make sure not to block longer than
+  // the next time we need to run delayed work.
+  return GetTimeIntervalMilliseconds(delayed_work_time_);
+}
+
+bool MainMessageLoopExternalPumpLinux::HandleCheck() {
+  // We usually have a single message on the wakeup pipe, since we are only
+  // signaled when the queue went from empty to non-empty, but there can be
+  // two messages if a task posted a task, hence we read at most two bytes.
+  // The glib poll will tell us whether there was data, so this read shouldn't
+  // block.
+  if (wakeup_gpollfd_->revents & G_IO_IN) {
+    int64 delay_ms[2];
+    const size_t num_bytes =
+        HANDLE_EINTR(read(wakeup_pipe_read_, delay_ms, sizeof(int64) * 2));
+    if (num_bytes < sizeof(int64)) {
+      NOTREACHED() << "Error reading from the wakeup pipe.";
+    }
+    if (num_bytes == sizeof(int64))
+      OnScheduleWork(delay_ms[0]);
+    if (num_bytes == sizeof(int64) * 2)
+      OnScheduleWork(delay_ms[1]);
+  }
+
+  if (GetTimeIntervalMilliseconds(delayed_work_time_) == 0) {
+    // The timer has expired. That condition will stay true until we process
+    // that delayed work, so we don't need to record this differently.
+    return true;
+  }
+
+  return false;
+}
+
+void MainMessageLoopExternalPumpLinux::HandleDispatch() {
+  OnTimerTimeout();
+}
+
+void MainMessageLoopExternalPumpLinux::SetTimer(int64 delay_ms) {
+  DCHECK_GT(delay_ms, 0);
+
+  CefTime now;
+  now.Now();
+
+  delayed_work_time_ =
+      CefTime(now.GetDoubleT() + static_cast<double>(delay_ms) / 1000.0);
+}
+
+void MainMessageLoopExternalPumpLinux::KillTimer() {
+  delayed_work_time_ = CefTime();
+}
+
+bool MainMessageLoopExternalPumpLinux::IsTimerPending() {
+  return GetTimeIntervalMilliseconds(delayed_work_time_) > 0;
+}
+
+} // namespace
+
+// static
+scoped_ptr<MainMessageLoopExternalPump>
+MainMessageLoopExternalPump::Create() {
+  return make_scoped_ptr<MainMessageLoopExternalPump>(
+      new MainMessageLoopExternalPumpLinux());
+}
+
+}  // namespace client

tests/cefclient/browser/main_message_loop_external_pump_mac.mm

@@ -0,0 +1,171 @@
+// Copyright (c) 2016 The Chromium Embedded Framework 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 "cefclient/browser/main_message_loop_external_pump.h"
+
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+
+#include "include/cef_app.h"
+
+@class EventHandler;
+
+namespace client {
+
+class MainMessageLoopExternalPumpMac : public MainMessageLoopExternalPump {
+ public:
+  MainMessageLoopExternalPumpMac();
+  ~MainMessageLoopExternalPumpMac();
+
+  // MainMessageLoopStd methods:
+  void Quit() OVERRIDE;
+  int Run() OVERRIDE;
+
+  // MainMessageLoopExternalPump methods:
+  void OnScheduleMessagePumpWork(int64 delay_ms) OVERRIDE;
+
+  // Internal methods used for processing the event callbacks. They are public
+  // for simplicity but should not be used directly.
+  void HandleScheduleWork(int64 delay_ms);
+  void HandleTimerTimeout();
+
+ protected:
+  // MainMessageLoopExternalPump methods:
+  void SetTimer(int64 delay_ms) OVERRIDE;
+  void KillTimer() OVERRIDE;
+  bool IsTimerPending() OVERRIDE { return timer_ != nil; }
+
+ private:
+  // Owner thread that will run events.
+  NSThread* owner_thread_;
+
+  // Pending work timer.
+  NSTimer* timer_;
+
+  // Used to handle event callbacks on the owner thread.
+  EventHandler* event_handler_;
+};
+
+}  // namespace client
+
+// Object that handles event callbacks on the owner thread.
+@interface EventHandler : NSObject {
+ @private
+  client::MainMessageLoopExternalPumpMac* pump_;
+}
+
+- (id)initWithPump:(client::MainMessageLoopExternalPumpMac*)pump;
+- (void)scheduleWork:(NSNumber*)delay_ms;
+- (void)timerTimeout:(id)obj;
+@end
+
+@implementation EventHandler
+
+- (id)initWithPump:(client::MainMessageLoopExternalPumpMac*)pump {
+  if (self = [super init]) {
+    pump_ = pump;
+  }
+  return self;
+}
+
+- (void)scheduleWork:(NSNumber*)delay_ms {
+  pump_->HandleScheduleWork([delay_ms integerValue]);
+}
+
+- (void)timerTimeout:(id)obj {
+  pump_->HandleTimerTimeout();
+}
+
+@end
+
+namespace client {
+
+MainMessageLoopExternalPumpMac::MainMessageLoopExternalPumpMac()
+  : owner_thread_([[NSThread currentThread] retain]),
+    timer_(nil) {
+  event_handler_ = [[[EventHandler alloc] initWithPump:this] retain];
+}
+
+MainMessageLoopExternalPumpMac::~MainMessageLoopExternalPumpMac() {
+  KillTimer();
+  [owner_thread_ release];
+  [event_handler_ release];
+}
+
+void MainMessageLoopExternalPumpMac::Quit() {
+  [NSApp stop:nil];
+}
+
+int MainMessageLoopExternalPumpMac::Run() {
+  // Run the message loop.
+  [NSApp run];
+
+  KillTimer();
+
+  // We need to run the message pump until it is idle. However we don't have
+  // that information here so we run the message loop "for a while".
+  for (int i = 0; i < 10; ++i) {
+    // Let default runloop observers run.
+    CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, 1);
+
+    // Do some work.
+    CefDoMessageLoopWork();
+    
+    // Sleep to allow the CEF proc to do work.
+    [NSThread sleepForTimeInterval: 0.05];
+  }
+
+  return 0;
+}
+
+void MainMessageLoopExternalPumpMac::OnScheduleMessagePumpWork(int64 delay_ms) {
+  // This method may be called on any thread.
+  NSNumber* number = [NSNumber numberWithInt:static_cast<int>(delay_ms)];
+  [event_handler_ performSelector:@selector(scheduleWork:)
+                         onThread:owner_thread_
+                       withObject:number
+                    waitUntilDone:NO];
+}
+
+void MainMessageLoopExternalPumpMac::HandleScheduleWork(int64 delay_ms) {
+  OnScheduleWork(delay_ms);
+}
+
+void MainMessageLoopExternalPumpMac::HandleTimerTimeout() {
+  OnTimerTimeout();
+}
+
+void MainMessageLoopExternalPumpMac::SetTimer(int64 delay_ms) {
+  DCHECK_GT(delay_ms, 0);
+  DCHECK(!timer_);
+
+  const double delay_s = static_cast<double>(delay_ms) / 1000.0;
+  timer_ = [[NSTimer timerWithTimeInterval: delay_s
+                                    target: event_handler_
+                                  selector: @selector(timerTimeout:)
+                                  userInfo: nil
+                                   repeats: NO] retain];
+
+  // Add the timer to default and tracking runloop modes.
+  NSRunLoop* owner_runloop = [NSRunLoop currentRunLoop];
+  [owner_runloop addTimer: timer_ forMode: NSRunLoopCommonModes];
+  [owner_runloop addTimer: timer_ forMode: NSEventTrackingRunLoopMode];
+}
+
+void MainMessageLoopExternalPumpMac::KillTimer() {
+  if (timer_ != nil) {
+    [timer_ invalidate];
+    [timer_ release];
+    timer_ = nil;
+  }
+}
+
+// static
+scoped_ptr<MainMessageLoopExternalPump>
+MainMessageLoopExternalPump::Create() {
+  return make_scoped_ptr<MainMessageLoopExternalPump>(
+      new MainMessageLoopExternalPumpMac());
+}
+
+}  // namespace client

tests/cefclient/browser/main_message_loop_external_pump_win.cc

@@ -0,0 +1,149 @@
+// Copyright (c) 2016 The Chromium Embedded Framework 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 "cefclient/browser/main_message_loop_external_pump.h"
+
+#include <CommCtrl.h>
+
+#include "include/cef_app.h"
+#include "cefclient/browser/util_win.h"
+
+namespace client {
+
+namespace {
+
+// Message sent to get an additional time slice for pumping (processing) another
+// task (a series of such messages creates a continuous task pump).
+static const int kMsgHaveWork = WM_USER + 1;
+
+class MainMessageLoopExternalPumpWin : public MainMessageLoopExternalPump {
+ public:
+  MainMessageLoopExternalPumpWin();
+  ~MainMessageLoopExternalPumpWin();
+
+  // MainMessageLoopStd methods:
+  void Quit() OVERRIDE;
+  int Run() OVERRIDE;
+
+  // MainMessageLoopExternalPump methods:
+  void OnScheduleMessagePumpWork(int64 delay_ms) OVERRIDE;
+
+ protected:
+  // MainMessageLoopExternalPump methods:
+  void SetTimer(int64 delay_ms) OVERRIDE;
+  void KillTimer() OVERRIDE;
+  bool IsTimerPending() OVERRIDE { return timer_pending_; }
+
+ private:
+  static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam,
+                                  LPARAM lparam);
+
+  // True if a timer event is currently pending.
+  bool timer_pending_;
+
+  // HWND owned by the thread that CefDoMessageLoopWork should be invoked on.
+  HWND main_thread_target_;
+};
+
+MainMessageLoopExternalPumpWin::MainMessageLoopExternalPumpWin()
+  : timer_pending_(false),
+    main_thread_target_(NULL) {
+  HINSTANCE hInstance = GetModuleHandle(NULL);
+  const wchar_t* const kClassName = L"CEFMainTargetHWND";
+
+  WNDCLASSEX wcex = {};
+  wcex.cbSize = sizeof(WNDCLASSEX);
+  wcex.lpfnWndProc = WndProc;
+  wcex.hInstance = hInstance;
+  wcex.lpszClassName = kClassName;
+  RegisterClassEx(&wcex);
+
+  // Create the message handling window.
+  main_thread_target_ = CreateWindowW(kClassName, NULL, WS_OVERLAPPEDWINDOW,
+      0, 0, 0, 0, HWND_MESSAGE , NULL, hInstance, NULL);
+  DCHECK(main_thread_target_);
+  SetUserDataPtr(main_thread_target_, this);
+}
+
+MainMessageLoopExternalPumpWin::~MainMessageLoopExternalPumpWin() {
+  KillTimer();
+  if (main_thread_target_)
+    DestroyWindow(main_thread_target_);
+}
+
+void MainMessageLoopExternalPumpWin::Quit() {
+  PostMessage(NULL, WM_QUIT, 0, 0);
+}
+
+int MainMessageLoopExternalPumpWin::Run() {
+  // Run the message loop.
+  MSG msg;
+  while (GetMessage(&msg, NULL, 0, 0)) {
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+
+  KillTimer();
+
+  // We need to run the message pump until it is idle. However we don't have
+  // that information here so we run the message loop "for a while".
+  for (int i = 0; i < 10; ++i) {
+    // Do some work.
+    CefDoMessageLoopWork();
+    
+    // Sleep to allow the CEF proc to do work.
+    Sleep(50);
+  }
+  
+  return 0;
+}
+
+void MainMessageLoopExternalPumpWin::OnScheduleMessagePumpWork(int64 delay_ms) {
+  // This method may be called on any thread.
+  PostMessage(main_thread_target_, kMsgHaveWork, 0,
+              static_cast<LPARAM>(delay_ms));
+}
+
+void MainMessageLoopExternalPumpWin::SetTimer(int64 delay_ms) {
+  DCHECK(!timer_pending_);
+  DCHECK_GT(delay_ms, 0);
+  timer_pending_ = true;
+  ::SetTimer(main_thread_target_, 1, static_cast<UINT>(delay_ms), NULL);
+}
+
+void MainMessageLoopExternalPumpWin::KillTimer() {
+  if (timer_pending_) {
+    ::KillTimer(main_thread_target_, 1);
+    timer_pending_ = false;
+  }
+}
+
+// static
+LRESULT CALLBACK MainMessageLoopExternalPumpWin::WndProc(
+    HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
+  if (msg == WM_TIMER || msg == kMsgHaveWork) {
+    MainMessageLoopExternalPumpWin* message_loop =
+        GetUserDataPtr<MainMessageLoopExternalPumpWin*>(hwnd);
+    if (msg == kMsgHaveWork) {
+      // OnScheduleMessagePumpWork() request.
+      const int64 delay_ms = static_cast<int64>(lparam);
+      message_loop->OnScheduleWork(delay_ms);
+    } else {
+      // Timer timed out.
+      message_loop->OnTimerTimeout();
+    }
+  }
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+
+} // namespace
+
+// static
+scoped_ptr<MainMessageLoopExternalPump>
+MainMessageLoopExternalPump::Create() {
+  return make_scoped_ptr<MainMessageLoopExternalPump>(
+      new MainMessageLoopExternalPumpWin());
+}
+
+}  // namespace client

tests/cefclient/cefclient_gtk.cc

@@ -20,6 +20,7 @@
 #include "include/wrapper/cef_helpers.h"
 #include "cefclient/browser/client_app_browser.h"
 #include "cefclient/browser/main_context_impl.h"
+#include "cefclient/browser/main_message_loop_external_pump.h"
 #include "cefclient/browser/main_message_loop_std.h"
 #include "cefclient/browser/test_runner.h"
 #include "cefclient/common/client_app_other.h"
@@ -90,7 +91,11 @@ int RunMain(int argc, char* argv[]) {
   context->PopulateSettings(&settings);
 
   // Create the main message loop object.
-  scoped_ptr<MainMessageLoop> message_loop(new MainMessageLoopStd);
+  scoped_ptr<MainMessageLoop> message_loop;
+  if (settings.external_message_pump)
+    message_loop = MainMessageLoopExternalPump::Create();
+  else
+    message_loop.reset(new MainMessageLoopStd);
 
   // Initialize CEF.
   context->Initialize(main_args, settings, app, NULL);

tests/cefclient/cefclient_mac.mm

@@ -8,6 +8,7 @@
 #import "include/cef_application_mac.h"
 #include "cefclient/browser/client_app_browser.h"
 #include "cefclient/browser/main_context_impl.h"
+#include "cefclient/browser/main_message_loop_external_pump.h"
 #include "cefclient/browser/main_message_loop_std.h"
 #include "cefclient/browser/resource.h"
 #include "cefclient/browser/root_window.h"
@@ -216,7 +217,11 @@ int RunMain(int argc, char* argv[]) {
   context->PopulateSettings(&settings);
 
   // Create the main message loop object.
-  scoped_ptr<MainMessageLoop> message_loop(new MainMessageLoopStd);
+  scoped_ptr<MainMessageLoop> message_loop;
+  if (settings.external_message_pump)
+    message_loop = MainMessageLoopExternalPump::Create();
+  else
+    message_loop.reset(new MainMessageLoopStd);
 
   // Initialize CEF.
   context->Initialize(main_args, settings, app, NULL);

tests/cefclient/cefclient_win.cc

@@ -9,6 +9,7 @@
 #include "include/cef_sandbox_win.h"
 #include "cefclient/browser/client_app_browser.h"
 #include "cefclient/browser/main_context_impl.h"
+#include "cefclient/browser/main_message_loop_external_pump.h"
 #include "cefclient/browser/main_message_loop_multithreaded_win.h"
 #include "cefclient/browser/main_message_loop_std.h"
 #include "cefclient/browser/root_window_manager.h"
@@ -82,6 +83,8 @@ int RunMain(HINSTANCE hInstance, int nCmdShow) {
   scoped_ptr<MainMessageLoop> message_loop;
   if (settings.multi_threaded_message_loop)
     message_loop.reset(new MainMessageLoopMultithreadedWin);
+  else if (settings.external_message_pump)
+    message_loop = MainMessageLoopExternalPump::Create();
   else
     message_loop.reset(new MainMessageLoopStd);
 

tests/cefclient/common/client_switches.cc

@@ -18,6 +18,7 @@ namespace switches {
 //   content/public/common/content_switches.cc
 
 const char kMultiThreadedMessageLoop[] = "multi-threaded-message-loop";
+const char kExternalMessagePump[] = "external-message-pump";
 const char kCachePath[] = "cache-path";
 const char kUrl[] = "url";
 const char kOffScreenRenderingEnabled[] = "off-screen-rendering-enabled";

tests/cefclient/common/client_switches.h

@@ -12,6 +12,7 @@ namespace client {
 namespace switches {
 
 extern const char kMultiThreadedMessageLoop[];
+extern const char kExternalMessagePump[];
 extern const char kCachePath[];
 extern const char kUrl[];
 extern const char kOffScreenRenderingEnabled[];