Implements AudioMessageFilter as member in RenderThread

content/renderer/media/audio_device.h

 // Copyright (c) 2011 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_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_H_
 #pragma once
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/threading/simple_thread.h"
 #include "content/renderer/media/audio_message_filter.h"
 
 struct AudioParameters;
 
-// Each instance of AudioDevice corresponds to one host stream.
-// This class is not thread-safe, so its methods must be called from
-// the same thread.
+// TODO(henrika): add comments here...
 class AudioDevice : public AudioMessageFilter::Delegate,
                     public base::DelegateSimpleThread::Delegate,
                     public base::RefCountedThreadSafe<AudioDevice> {
  public:
   class RenderCallback {
    public:
     virtual void Render(const std::vector<float*>& audio_data,
                         size_t number_of_frames,
                         size_t audio_delay_milliseconds) = 0;
    protected:
     virtual ~RenderCallback() {}
   };
 
-  // |buffer_size| is the number of sample-frames.
+  // Methods called on creating thread ----------------------------------------
   AudioDevice(size_t buffer_size,
               int channels,
               double sample_rate,
-              RenderCallback* callback);
+              RenderCallback* callback,
+              AudioMessageFilter* filter);

[Chris Rogers, 2011/06/14 22:57:10]

Can't the AudioDevice simply call AudioMessageFilterCreator::SharedFilter()
itself instead of having this passed as a constructor argument?

[henrika_dont_use, 2011/06/15 15:16:39]

Good point. Will make such a change and upload for review. Guess Andrew wants to
comment as well.

On 2011/06/14 22:57:10, Chris Rogers wrote:

   virtual ~AudioDevice();
 
   // Starts audio playback. Returns |true| on success.
   bool Start();
 
   // Stops audio playback. Returns |true| on success.
   bool Stop();
 
   // Sets the playback volume, with range [0.0, 1.0] inclusive.
   // Returns |true| on success.
   bool SetVolume(double volume);
 
   // Gets the playback volume, with range [0.0, 1.0] inclusive.
   // Returns |true| on success.
   bool GetVolume(double* volume);
 
   double sample_rate() const { return sample_rate_; }
   size_t buffer_size() const { return buffer_size_; }
 
- private:
-  // I/O thread backends to above functions.
-  void InitializeOnIOThread(const AudioParameters& params);
-  void StartOnIOThread();
-  void ShutDownOnIOThread();
-  void SetVolumeOnIOThread(double volume);
-
-  // AudioMessageFilter::Delegate implementation.
+  // Methods called on IO thread ----------------------------------------------
+  // AudioMessageFilter::Delegate methods, called by AudioMessageFilter.
   virtual void OnRequestPacket(AudioBuffersState buffers_state);
   virtual void OnStateChanged(AudioStreamState state);
   virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length);
   virtual void OnLowLatencyCreated(base::SharedMemoryHandle handle,
                                    base::SyncSocket::Handle socket_handle,
                                    uint32 length);
   virtual void OnVolume(double volume);
 
+ private:
+  // 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 InitializeTask(const AudioParameters& params);
+  void StartTask();
+  void ShutDownTask();
+  void SetVolumeTask(double volume);
+
+  // Method called on the audio thread ----------------------------------------
+  // Calls the client's callback for rendering audio.
+  void FireRenderCallback();
+
   // DelegateSimpleThread::Delegate implementation.
   virtual void Run();
 
   // Format
   size_t buffer_size_;  // in sample-frames
   int channels_;
   int bits_per_sample_;
   double sample_rate_;
 
-  // Calls the client's callback for rendering audio.
-  void FireRenderCallback();
   RenderCallback* callback_;
 
   // The client callback renders audio into here.
   std::vector<float*> audio_data_;
 
   // The client stores the last reported audio delay in this member.
   // The delay shall reflect the amount of audio which still resides in
   // the output buffer, i.e., the expected audio output delay.
   int audio_delay_milliseconds_;
 
   // The current volume scaling [0.0, 1.0] of the audio stream.
   double volume_;
 
   // Callbacks for rendering audio occur on this thread.
   scoped_ptr<base::DelegateSimpleThread> audio_thread_;
 
   // IPC message stuff.
   base::SharedMemory* shared_memory() { return shared_memory_.get(); }
   base::SyncSocket* socket() { return socket_.get(); }
   void* shared_memory_data() { return shared_memory()->memory(); }
 
-  // MessageFilter used to send/receive IPC. THIS MUST ONLY BE ACCESSED ON THE
-  // I/O thread except to send messages and get the message loop.
-  static scoped_refptr<AudioMessageFilter> filter_;
+  // MessageFilter used to send/receive IPC. Only accessed on the IO thread.
+  scoped_refptr<AudioMessageFilter> filter_;
 
-  // Our ID on the message filter. THIS MUST ONLY BE ACCESSED ON THE I/O THREAD
-  // or else you could race with the initialize function which sets it.
+  // Message loop for the IO thread.
+  MessageLoop* io_loop_;
+
+  // Our ID on the message filter. Only modified on the IO thread.
   int32 stream_id_;
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   scoped_ptr<base::SyncSocket> socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDevice);
 };
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_DEVICE_H_