Stop the AudioDeviceThread when the IO loop goes away.

content/renderer/media/audio_device_thread.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_THREAD_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_THREAD_H_
 #pragma once
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/sync_socket.h"
+#include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "media/audio/audio_parameters.h"
 
 class MessageLoop;
 
 // Data transfer between browser and render process uses a combination
 // of sync sockets and shared memory. To read from the socket and render
 // data, we use a worker thread, a.k.a. the AudioDeviceThread, which reads
 // data from the browser via the socket and fills the shared memory from the
 // audio thread via the AudioDeviceThread::Callback interface/class.
@@ skipping 43 matching lines @@
 
   AudioDeviceThread();
   ~AudioDeviceThread();
 
   // Starts the audio thread. The thread must not already be running.
   void Start(AudioDeviceThread::Callback* callback,
              base::SyncSocket::Handle socket,
              const char* thread_name);
 
   // This tells the audio thread to stop and clean up the data.
-  // The method is asynchronous, so the thread might still be running after it
+  // The method can stop the thread synchronously or asynchronously.
+  // In the latter case, the thread will still be running after Stop()
   // returns, but the callback pointer is cleared so no further callbacks will
-  // be made (i.e. after Stop() returns, it is safe to delete the callback).
-  // The |loop_for_join| parameter is required in order to join the worker
-  // thread and close the thread handle later via a posted task.
-  // If set to NULL, the current message loop is used. Note that the thread
-  // that the message loop belongs to, must be allowed to join threads
-  // (see SetIOAllowed in base/thread_restrictions.h).
+  // be made (IOW after Stop() returns, it is safe to delete the callback).
+  // The |loop_for_join| parameter is required for asynchronous operation
+  // in order to join the worker thread and close the thread handle later via a
+  // posted task.
+  // If set to NULL, function will wait for the thread to exit before returning.
   void Stop(MessageLoop* loop_for_join);
 
+  // Returns true if the thread is stopped or stopping.
+  bool IsStopped() const;
+
  private:
   // Our own private SimpleThread override.  We implement this in a
   // private class so that we get the following benefits:
   // 1) AudioDeviceThread doesn't expose SimpleThread methods.
   //    I.e. the caller can't call Start()/Stop() - which would be bad.
   // 2) We override ThreadMain to add additional on-thread initialization
   //    while still synchronized with SimpleThread::Start() to provide
   //    reliable initialization.
   class Thread;
 
+  mutable base::Lock thread_lock_;

[scherkus (not reviewing), 2012/02/29 21:10:15]

nit: mutable = sadface

when would an ADT be const? how about dropping const+mutable, especially since
IsStopped() is only used for DCHECK purposes

[tommi (sloooow) - chröme, 2012/02/29 21:22:13]

why? I always figured it would be fair game for synchronization and cache?
OK with me.

[scherkus (not reviewing), 2012/02/29 21:40:53]

ah it was sadface for the reasons I mentioned (object isn't const and it's a
dcheck), i.e., the mutable doesn't really seem necessary here

   scoped_refptr<AudioDeviceThread::Thread> thread_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDeviceThread);
 };
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_THREAD_H_