Stop the AudioDeviceThread when the IO loop goes away.

content/renderer/media/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 "content/renderer/media/audio_device_thread.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
-#include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/audio/audio_util.h"
 
 using base::PlatformThread;
 
 // 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
 // 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);
 
   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
+  // synchronously for the thread to terminate.
   void Stop(MessageLoop* loop_for_join);
 
  private:
   friend class base::RefCountedThreadSafe<AudioDeviceThread::Thread>;
   virtual ~Thread();
 
   // Overrides from PlatformThread::Delegate.
   virtual void ThreadMain() OVERRIDE;
 
   // Runs the loop that reads from the socket.
@@ skipping 14 matching lines @@
 AudioDeviceThread::AudioDeviceThread() {
 }
 
 AudioDeviceThread::~AudioDeviceThread() {
   DCHECK(!thread_);
 }
 
 void AudioDeviceThread::Start(AudioDeviceThread::Callback* callback,
                               base::SyncSocket::Handle socket,
                               const char* thread_name) {
+  base::AutoLock auto_lock(thread_lock_);
   CHECK(thread_ == NULL);
   thread_ = new AudioDeviceThread::Thread(callback, socket, thread_name);
   thread_->Start();
 }
 
 void AudioDeviceThread::Stop(MessageLoop* loop_for_join) {
+  base::AutoLock auto_lock(thread_lock_);
   if (thread_) {
-    if (!loop_for_join) {
-      loop_for_join = MessageLoop::current();
-      CHECK(loop_for_join);
-    }
     thread_->Stop(loop_for_join);
     thread_ = NULL;
   }
 }
 
+bool AudioDeviceThread::IsStopped() {
+  base::AutoLock auto_lock(thread_lock_);
+  return thread_ == NULL;
+}
+
 // AudioDeviceThread::Thread implementation
 AudioDeviceThread::Thread::Thread(AudioDeviceThread::Callback* callback,
                                   base::SyncSocket::Handle socket,
                                   const char* thread_name)
     : thread_(base::kNullThreadHandle),
       callback_(callback),
       socket_(socket),
       thread_name_(thread_name) {
 }
 
@@ skipping 16 matching lines @@
 
   base::PlatformThreadHandle thread = base::kNullThreadHandle;
 
   {  // NOLINT
     base::AutoLock auto_lock(callback_lock_);
     callback_ = NULL;
     std::swap(thread, thread_);
   }
 
   if (thread != base::kNullThreadHandle) {
-    loop_for_join->PostTask(FROM_HERE,
-        base::Bind(&base::PlatformThread::Join, thread));
+    if (loop_for_join) {
+      loop_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.
   // The callback is the only point where the thread calls out to 'unknown' code
   // that might touch singletons and the lifetime of the callback is controlled
   // by another thread on which singleton access is OK as well.
@@ skipping 54 matching lines @@
   MapSharedMemory();
   DCHECK(shared_memory_.memory() != NULL);
 
   audio_data_.reserve(audio_parameters_.channels);
   for (int i = 0; i < audio_parameters_.channels; ++i) {
     float* channel_data = new float[audio_parameters_.samples_per_packet];
     audio_data_.push_back(channel_data);
   }
 }