Monitor the IO message loop in the AudioDevice classes.

content/renderer/media/audio_device.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.
 //
 // Low-latency audio rendering unit utilizing audio output stream provided
 // by browser process through IPC.
 //
 // Relationship of classes.
 //
 //  AudioOutputController                AudioDevice
@@ skipping 48 matching lines @@
 // - Pause() is asynchronous/non-blocking.
 // - The user must call Stop() before deleting the class instance.
 
 #ifndef CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_H_
 #pragma once
 
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/simple_thread.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_renderer_sink.h"
 
-namespace base {
-class WaitableEvent;
-}
+// A common base class for AudioDevice and AudioInputDevice that manages
+// the IO message loop pointer and monitors it for destruction.
+// When the loop goes away, we automatically stop any running streams.
+template <class T>
+class AudioDeviceIOLoopObserver
+    : public MessageLoop::DestructionObserver {
+ public:
+  AudioDeviceIOLoopObserver()
+      : io_loop_(
+          ChildProcess::current()->io_message_loop()->message_loop_proxy()) {
+    // Watch the IO loop and make sure that we stop the audio thread before we
+    // lose the IO thread.
+    ObserveIOLoopDestruction(true, NULL);
+  }
+
+  ~AudioDeviceIOLoopObserver() {
+    ObserveIOLoopDestruction(false, NULL);
+  }
+
+ protected:
+  // Accessor to the IO loop that's used by the derived class.
+  base::MessageLoopProxy* loop() { return io_loop_; }
+
+ private:
+  // MessageLoop::DestructionObserver implementation.
+  // Called on the IO thread when the thread is going away.
+  virtual void WillDestroyCurrentMessageLoop() OVERRIDE {
+    DCHECK(io_loop_->BelongsToCurrentThread());
+    // The IO thread is terminating.  We must stop the audio thread before the
+    // IO thread goes away.
+    static_cast<T*>(this)->ShutDownOnIOThread(NULL);
+  }
+
+  // Call from the IO thread to add or remove ourselves from the list of
+  // destruction observers for the IO message loop.
+  void ObserveIOLoopDestruction(bool enable, base::WaitableEvent* done) {
+    if (io_loop_->BelongsToCurrentThread()) {
+      MessageLoop* loop = MessageLoop::current();
+      enable ? loop->AddDestructionObserver(this) :

[enal1, 2012/01/31 17:23:54]

Why not regular if statement?

[tommi (sloooow) - chröme, 2012/02/01 14:50:49]

Done.

+               loop->RemoveDestructionObserver(this);
+    } else {
+      base::WaitableEvent event(false, false);
+      if (io_loop_->PostTask(FROM_HERE,

[enal1, 2012/01/31 17:23:54]

Are you sure we can post anything on IO loop if loop is being deleted?

[tommi (sloooow) - chröme, 2012/02/01 14:50:49]

It's OK if the loop is being deleted and PostTask fails or if the task is
discarded.
The danger is when the AudioDevice is going out of scope while still being
registered as an observer and the IO loop is still serving tasks.  We don't want
it to notify a bogus observer.

+              base::Bind(
+                  &AudioDeviceIOLoopObserver<T>::ObserveIOLoopDestruction,
+                  base::Unretained(this), enable, &event))) {
+        event.Wait();
+      } else {
+        // The IO thread has already terminated, so no need to wait.
+      }
+    }
+
+    if (done)
+      done->Signal();
+  }
+
+  // A pointer to the IO thread's message loop. That's here we do control the
+  // stream from.  It is possible during shutdown that the IO thread has gone
+  // away before the user of the AudioDevice instance has called Stop().
+  // So, we need to be prepared to stop and take down the audio thread if
+  // the IO thread ever goes away while we're still playing.
+  // So, when this pointer is NULL, the IO thread has gone away and all methods
+  // that post to it, must check for this first.

[enal1, 2012/01/31 17:23:54]

I don't see how this pointer can become NULL. It is private, and I don't see any
assignments to it.

[tommi (sloooow) - chröme, 2012/02/01 14:50:49]

It cannot become NULL - did you see any checks for NULL?
The assignment is in the constructor.

+  scoped_refptr<base::MessageLoopProxy> io_loop_;
+};
 
 class CONTENT_EXPORT AudioDevice
     : NON_EXPORTED_BASE(public media::AudioRendererSink),
       public AudioMessageFilter::Delegate,
-      public base::DelegateSimpleThread::Delegate {
+      public base::DelegateSimpleThread::Delegate,
+      public AudioDeviceIOLoopObserver<AudioDevice> {
  public:
   // Methods called on main render thread -------------------------------------
 
   // Minimal constructor where Initialize() must be called later.
   AudioDevice();
 
   AudioDevice(size_t buffer_size,
               int channels,
               double sample_rate,
               RenderCallback* callback);
@@ skipping 51 matching lines @@
   friend class base::RefCountedThreadSafe<AudioDevice>;
   virtual ~AudioDevice();
 
   // Methods called on IO thread ----------------------------------------------
   // The following methods are tasks posted on the IO thread that needs to
   // be executed on that thread. They interact with AudioMessageFilter and
   // sends IPC messages on that thread.
   void InitializeOnIOThread(const AudioParameters& params);
   void PlayOnIOThread();
   void PauseOnIOThread(bool flush);
+  // Allow AudioDeviceIOLoopObserver to call ShutDownOnIOThread.
+  friend class AudioDeviceIOLoopObserver<AudioDevice>;
   void ShutDownOnIOThread(base::WaitableEvent* signal);
   void SetVolumeOnIOThread(double volume);
 
   void Send(IPC::Message* message);
 
   // Method called on the audio thread ----------------------------------------
   // Calls the client's callback for rendering audio.
   // Returns actual number of filled frames that callback returned. This length
   // is passed to host at the end of the shared memory (i.e. buffer). In case of
   // continuous stream host just ignores it and assumes buffer is always filled
@@ skipping 54 matching lines @@
   // These variables must only be set on the IO thread while the audio_thread_
   // is not running.
   base::SharedMemoryHandle shared_memory_handle_;
   scoped_ptr<base::CancelableSyncSocket> audio_socket_;
   int memory_length_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDevice);
 };
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_H_