Makes MessagePumpGlib thread DCHECK work when pump is destroyed

base/message_loop/message_pump_glib.cc

 // 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.
 
 #include "base/message_loop/message_pump_glib.h"
 
 #include <fcntl.h>
 #include <math.h>
 
 #include <glib.h>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 namespace {
 
 // 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 TimeTicks& from) {
   if (from.is_null())
@@ skipping 86 matching lines @@
 }
 
 // I wish these could be const, but g_source_new wants non-const.
 GSourceFuncs WorkSourceFuncs = {
   WorkSourcePrepare,
   WorkSourceCheck,
   WorkSourceDispatch,
   NULL
 };
 
+// The following is used to make sure we only run the MessagePumpGlib on one
+// thread. X only has one message pump so we can only have one UI loop per
+// process.
+#ifndef NDEBUG
+
+// Tracks the pump the most recent pump that has been run.
+struct ThreadInfo {
+  // The pump.
+  MessagePumpGlib* pump;
+
+  // ID of the thread the pump was run on.
+  PlatformThreadId thread_id;
+};
+
+// Used for accesing |thread_info|.
+static LazyInstance<Lock>::Leaky thread_info_lock = LAZY_INSTANCE_INITIALIZER;
+
+// If non-NULL it means a MessagePumpGlib exists and has been Run. This is
+// destroyed when the MessagePump is destroyed.
+ThreadInfo* thread_info = NULL;
+
+void CheckThread(MessagePumpGlib* pump) {
+  AutoLock auto_lock(thread_info_lock.Get());
+  if (!thread_info) {
+    thread_info = new ThreadInfo;
+    thread_info->pump = pump;
+    thread_info->thread_id = PlatformThread::CurrentId();
+  }
+  DCHECK(thread_info->thread_id == PlatformThread::CurrentId()) <<
+      "Running MessagePumpGlib on two different threads; "
+      "this is unsupported by GLib!";
+}
+
+void PumpDestroyed(MessagePumpGlib* pump) {
+  AutoLock auto_lock(thread_info_lock.Get());
+  if (thread_info && thread_info->pump == pump) {

[sadrul, 2014/05/23 21:29:58]

Shouldn't thread_info->pump be always be == pump?

[sky, 2014/05/23 21:54:37]

I believe so, but I wanted to make sure if that isn't the case things don't go
bad.

[darin (slow to review), 2014/05/23 23:25:13]

You might consider a CHECK here.

Did you consider just going through MessageLoop::current() to find the current
thread's MessagePump?

[sky, 2014/05/27 15:57:27]

This is all to verify we don't start MessagePumpGlib twice. So, we shouldn't
really need a thread lookup.

+    delete thread_info;
+    thread_info = NULL;
+  }
+}
+
+#endif
+
 }  // namespace
 
 struct MessagePumpGlib::RunState {
   Delegate* delegate;
 
   // Used to flag that the current Run() invocation should return ASAP.
   bool should_quit;
 
   // Used to count how many Run() invocations are on the stack.
   int run_depth;
@@ skipping 23 matching lines @@
   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_);
 }
 
 MessagePumpGlib::~MessagePumpGlib() {
+#ifndef NDEBUG
+  PumpDestroyed(this);
+#endif
   g_source_destroy(work_source_);
   g_source_unref(work_source_);
   close(wakeup_pipe_read_);
   close(wakeup_pipe_write_);
 }
 
 // Return the timeout we want passed to poll.
 int MessagePumpGlib::HandlePrepare() {
   // We know we have work, but we haven't called HandleDispatch yet. Don't let
   // the pump block so that we can do some processing.
@@ skipping 52 matching lines @@
   }
 
   if (state_->should_quit)
     return;
 
   state_->delegate->DoDelayedWork(&delayed_work_time_);
 }
 
 void MessagePumpGlib::Run(Delegate* delegate) {
 #ifndef NDEBUG
-  // Make sure we only run this on one thread. X 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 MessagePumpGlib on two different threads; "
-      "this is unsupported by GLib!";
+  CheckThread(this);
 #endif
 
   RunState state;
   state.delegate = delegate;
   state.should_quit = false;
   state.run_depth = state_ ? state_->run_depth + 1 : 1;
   state.has_work = false;
 
   RunState* previous_state = state_;
   state_ = &state;
@@ skipping 60 matching lines @@
   delayed_work_time_ = delayed_work_time;
   ScheduleWork();
 }
 
 bool MessagePumpGlib::ShouldQuit() const {
   CHECK(state_);
   return state_->should_quit;
 }
 
 }  // namespace base