Mutual exclusion between gconf and the glib main loop.

base/message_pump_glib.cc

 // Copyright (c) 2008 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_pump_glib.h"
 
+#include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
+#include "base/scoped_ptr.h"
 
 namespace {
 
 // We send a byte across a pipe to wakeup the event loop.
 const char kWorkScheduled = '\0';
 
 // 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(base::Time from) {
   if (from.is_null())
@@ skipping 60 matching lines @@
   WorkSourceCheck,
   WorkSourceDispatch,
   NULL
 };
 
 }  // namespace
 
 
 namespace base {
 
+// static
+Lock MessagePumpForUI::glib_main_loop_lock_;
+
 MessagePumpForUI::MessagePumpForUI()
     : state_(NULL),
       context_(g_main_context_default()) {
   // Create our wakeup pipe, which is used to flag when work was scheduled.
   int fds[2];
   CHECK(pipe(fds) == 0);
   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_);
   // 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_);
 }
 
 MessagePumpForUI::~MessagePumpForUI() {
   g_source_destroy(work_source_);
   g_source_unref(work_source_);
   close(wakeup_pipe_read_);
   close(wakeup_pipe_write_);
 }
 
+// Runs a glib main loop iteration. Grabs glib_main_loop_lock_ while
+// calling glib functions, but releases it while polling.
+static void GMainIterate(GMainContext* context) {
+  AutoLock locked(MessagePumpForUI::glib_main_loop_lock_);
+  int fds_array_size = 50;
+  scoped_array<GPollFD> fds(new GPollFD[fds_array_size]);
+
+  // We use the lower-level component functions and do the poll
+  // ourselves so that we can release glib_main_loop_lock_ while
+  // polling, otherwise waiters might starve.
+
+  // I'll assume no other thread will g_main_context_acquire the
+  // context away from this thread. We cannot g_main_context_wait as
+  // we can't get to the condition and mutex in the context (which is
+  // externally opaque).
+
+  gint max_priority, timeout;
+  g_main_context_prepare(context, &max_priority);
+  int number_of_fds = g_main_context_query(context, max_priority, &timeout,
+                                           fds.get(), fds_array_size);
+  // We could reallocate instead, then we'd want to cache the array size...
+  CHECK(number_of_fds <= fds_array_size);
+  GPollFunc poll_func = g_main_context_get_poll_func(context);
+
+  {
+    // Release the lock while polling
+    AutoUnlock locked(MessagePumpForUI::glib_main_loop_lock_);
+
+    if ((*poll_func) (fds.get(), number_of_fds, timeout) < 0) {
+      if (errno != EINTR)
+        LOG(ERROR) << "g_main_loop poll error: " << strerror(errno);
+      // Just carry on.
+    }
+  }
+
+  g_main_context_check(context, max_priority, fds.get(), number_of_fds);
+  g_main_context_dispatch(context);
+}
+
 void MessagePumpForUI::Run(Delegate* delegate) {
 #ifndef NDEBUG
   // Make sure we only run this on one thread.  GTK only has one message pump
   // so we can only have one UI loop per process.
   static PlatformThreadId thread_id = PlatformThread::CurrentId();
   DCHECK(thread_id == PlatformThread::CurrentId()) <<
       "Running MessagePumpForUI on two different threads; "
       "this is unsupported by GLib!";
 #endif
 
   RunState state;
   state.delegate = delegate;
   state.should_quit = false;
   state.run_depth = state_ ? state_->run_depth + 1 : 1;
   // 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, so RunAllPending() works correctly.
   state.more_work_is_plausible = true;
 
   RunState* previous_state = state_;
   state_ = &state;
 
   // 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.  TODO(deanm): Is this what we want?
   while (!state_->should_quit)
-    g_main_context_iteration(context_, true);
+    GMainIterate(context_);
 
   state_ = previous_state;
 }
 
 // Return the timeout we want passed to poll.
 int MessagePumpForUI::HandlePrepare() {
   // If it's likely that we have more work, don't let the pump
   // block so that we can do some processing.
   if (state_->more_work_is_plausible)
     return 0;
@@ skipping 68 matching lines @@
 }
 
 void MessagePumpForUI::ScheduleDelayedWork(const Time& delayed_work_time) {
   // We need to wake up the loop in case the poll timeout needs to be
   // adjusted.  This will cause us to try to do work, but that's ok.
   delayed_work_time_ = delayed_work_time;
   ScheduleWork();
 }
 
 }  // namespace base