src/tests/shared/browser/main_message_loop_external_pump_linux.cc - cef - Git at Google

 // 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 "tests/shared/browser/main_message_loop_external_pump.h"

 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>

 #include <glib.h>

 #include "include/base/cef_logging.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 !DCHECK_IS_ON()

 #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  // !DCHECK_IS_ON()
 #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 scoped_ptr<MainMessageLoopExternalPump>(
       new MainMessageLoopExternalPumpLinux());
 }

 }  // namespace client
	// 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 "tests/shared/browser/main_message_loop_external_pump.h"

	#include <errno.h>
	#include <fcntl.h>
	#include <math.h>

	#include <glib.h>

	#include "include/base/cef_logging.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 !DCHECK_IS_ON()

	#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 // !DCHECK_IS_ON()
	#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 scoped_ptr<MainMessageLoopExternalPump>(
	new MainMessageLoopExternalPumpLinux());
	}

	} // namespace client