Remove calls to MessageLoop::current() in media.

media/audio/audio_device_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 "media/audio/audio_device_thread.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
-#include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/audio_bus.h"
 
 using base::PlatformThread;
 
 namespace media {
 
 // The actual worker thread implementation.  It's very bare bones and much
 // simpler than SimpleThread (no synchronization in Start, etc) and supports
-// joining the thread handle asynchronously via a provided message loop even
+// joining the thread handle asynchronously via a provided task runner even
 // after the Thread object itself has been deleted.
 class AudioDeviceThread::Thread
     : public PlatformThread::Delegate,
       public base::RefCountedThreadSafe<AudioDeviceThread::Thread> {
  public:
   Thread(AudioDeviceThread::Callback* callback,
          base::SyncSocket::Handle socket,
          const char* thread_name,
          bool synchronized_buffers);
 
   void Start();
 
-  // Stops the thread.  If |loop_for_join| is non-NULL, the function posts
-  // a task to join (close) the thread handle later instead of waiting for
-  // the thread.  If loop_for_join is NULL, then the function waits
+  // Stops the thread.  If |task_runner_for_join| is non-NULL, the function
+  // posts a task to join (close) the thread handle later instead of waiting for
+  // the thread.  If |task_runner_for_join| is NULL, then the function waits
   // synchronously for the thread to terminate.
-  void Stop(base::MessageLoop* loop_for_join);
+  void Stop(scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_join);

[chcunningham, 2016/06/21 01:34:36]

This file just underwent some significant cleanup that got merged before you.
See
https://chromium.googlesource.com/chromium/src/+/47f99faeb277c3fbd9eb709f803c...

[fdoray, 2016/06/29 15:44:31]

Done.

 
  private:
   friend class base::RefCountedThreadSafe<AudioDeviceThread::Thread>;
   ~Thread() override;
 
   // Overrides from PlatformThread::Delegate.
   void ThreadMain() override;
 
   // Runs the loop that reads from the socket.
   void Run();
@@ skipping 20 matching lines @@
                               base::SyncSocket::Handle socket,
                               const char* thread_name,
                               bool synchronized_buffers) {
   base::AutoLock auto_lock(thread_lock_);
   CHECK(!thread_.get());
   thread_ = new AudioDeviceThread::Thread(
       callback, socket, thread_name, synchronized_buffers);
   thread_->Start();
 }
 
-void AudioDeviceThread::Stop(base::MessageLoop* loop_for_join) {
+void AudioDeviceThread::Stop(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_join) {
   base::AutoLock auto_lock(thread_lock_);
   if (thread_.get()) {
-    thread_->Stop(loop_for_join);
+    thread_->Stop(std::move(task_runner_for_join));
     thread_ = NULL;
   }
 }
 
 bool AudioDeviceThread::IsStopped() {
   base::AutoLock auto_lock(thread_lock_);
   return !thread_.get();
 }
 
 // AudioDeviceThread::Thread implementation
@@ skipping 16 matching lines @@
   base::AutoLock auto_lock(callback_lock_);
   DCHECK(thread_.is_null());
   // This reference will be released when the thread exists.
   AddRef();
 
   PlatformThread::CreateWithPriority(0, this, &thread_,
                                      base::ThreadPriority::REALTIME_AUDIO);
   CHECK(!thread_.is_null());
 }
 
-void AudioDeviceThread::Thread::Stop(base::MessageLoop* loop_for_join) {
+void AudioDeviceThread::Thread::Stop(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_join) {
   socket_.Shutdown();
 
   base::PlatformThreadHandle thread = base::PlatformThreadHandle();
 
   {  // NOLINT
     base::AutoLock auto_lock(callback_lock_);
     callback_ = NULL;
     std::swap(thread, thread_);
   }
 
   if (!thread.is_null()) {
-    if (loop_for_join) {
-      loop_for_join->PostTask(FROM_HERE,
-          base::Bind(&base::PlatformThread::Join, thread));
+    if (task_runner_for_join) {
+      task_runner_for_join->PostTask(
+          FROM_HERE, base::Bind(&base::PlatformThread::Join, thread));
     } else {
       base::PlatformThread::Join(thread);
     }
   }
 }
 
 void AudioDeviceThread::Thread::ThreadMain() {
   PlatformThread::SetName(thread_name_);
 
   // Singleton access is safe from this thread as long as callback is non-NULL.
@@ skipping 87 matching lines @@
   // Normally this function is called before the thread checker is used
   // elsewhere, but it's not guaranteed. DCHECK to ensure it was not used on
   // another thread before we get here.
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Thread checker was attached on the wrong thread";
   MapSharedMemory();
   CHECK(shared_memory_.memory());
 }
 
 }  // namespace media.