Remove call to MessageLoop::QuitWhenIdle() in auto_thread.cc.

remoting/base/auto_thread.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 "remoting/base/auto_thread.h"
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/lazy_instance.h"
+#include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "remoting/base/auto_thread_task_runner.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
@@ skipping 73 matching lines @@
 #endif
 
 AutoThread::AutoThread(const char* name)
   : startup_data_(NULL),
 #if defined(OS_WIN)
     com_init_type_(COM_INIT_NONE),
 #endif
     thread_(),
     name_(name),
     was_quit_properly_(false) {
+  thread_checker_.DetachFromThread();
 }
 
 AutoThread::AutoThread(const char* name, AutoThreadTaskRunner* joiner)
   : startup_data_(NULL),
 #if defined(OS_WIN)
     com_init_type_(COM_INIT_NONE),
 #endif
     thread_(),
     name_(name),
     was_quit_properly_(false),
     joiner_(joiner) {
+  thread_checker_.DetachFromThread();
 }
 
 AutoThread::~AutoThread() {
   DCHECK(!startup_data_);
 
   // Wait for the thread to exit.
   if (!thread_.is_null()) {
     base::PlatformThread::Join(thread_);
   }
 }
@@ skipping 29 matching lines @@
   return startup_data.task_runner;
 }
 
 #if defined(OS_WIN)
 void AutoThread::SetComInitType(ComInitType com_init_type) {
   DCHECK_EQ(com_init_type_, COM_INIT_NONE);
   com_init_type_ = com_init_type;
 }
 #endif
 
-void AutoThread::QuitThread(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  if (!task_runner->BelongsToCurrentThread()) {
-    task_runner->PostTask(FROM_HERE, base::Bind(&AutoThread::QuitThread,
-                                                base::Unretained(this),
-                                                task_runner));
-    return;
-  }
+void AutoThread::QuitThread(const base::Closure& quit_when_idle_closure) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  base::MessageLoop::current()->QuitWhenIdle();
+  quit_when_idle_closure.Run();
   was_quit_properly_ = true;
 
   if (joiner_.get()) {
     joiner_->PostTask(
         FROM_HERE,
         base::Bind(&AutoThread::JoinAndDeleteThread, base::Unretained(this)));
   }
 }
 
 void AutoThread::JoinAndDeleteThread() {
   delete this;
 }
 
 void AutoThread::ThreadMain() {
-  // The message loop for this thread.
+  // Bind |thread_checker_| to the current thread.
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   base::MessageLoop message_loop(startup_data_->loop_type);
+  base::RunLoop run_loop;
 
   // Complete the initialization of our AutoThread object.
   base::PlatformThread::SetName(name_);
   ANNOTATE_THREAD_NAME(name_.c_str());  // Tell the name to race detector.
 
   // Return an AutoThreadTaskRunner that will cleanly quit this thread when
   // no more references to it remain.
-  startup_data_->task_runner =
-      new AutoThreadTaskRunner(message_loop.task_runner(),
-          base::Bind(&AutoThread::QuitThread,
-                     base::Unretained(this),
-                     message_loop.task_runner()));
+  startup_data_->task_runner = new AutoThreadTaskRunner(
+      message_loop.task_runner(),
+      base::Bind(&AutoThread::QuitThread, base::Unretained(this),
+                 run_loop.QuitWhenIdleClosure()));
 
   startup_data_->event.Signal();
   // startup_data_ can't be touched anymore since the starting thread is now
   // unlocked.
 
 #if defined(OS_WIN)
   // Initialize COM on the thread, if requested.
   std::unique_ptr<base::win::ScopedCOMInitializer> com_initializer(
       CreateComInitializer(com_init_type_));
 #endif
 
-  base::RunLoop().Run();
+  run_loop.Run();
 
   // Assert that MessageLoop::QuitWhenIdle was called by AutoThread::QuitThread.
   DCHECK(was_quit_properly_);
 }
 
 }  // namespace base