Land Henrik's patch: http://codereview.chromium.org/6721027/

BUG=none
TEST=none
TBR=crogers@google.com
Review URL: http://codereview.chromium.org/6745026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@79473 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 145 insertions, 41 deletions

diff --git a/content/renderer/audio_device.cc b/content/renderer/audio_device.cc
index 0038467..1f38f29 100644
--- a/content/renderer/audio_device.cc
+++ b/content/renderer/audio_device.cc
@@ -1,12 +1,14 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 #include "content/renderer/audio_device.h"
 
+#include "base/message_loop.h"
 #include "base/singleton.h"
 #include "chrome/renderer/render_thread.h"
 #include "content/common/audio_messages.h"
+#include "content/common/child_process.h"
 #include "content/common/view_messages.h"
 #include "media/audio/audio_util.h"
 
@@ -41,7 +43,7 @@ class AudioMessageFilterCreator {
   scoped_refptr<AudioMessageFilter> filter_;
 };
 
-}
+}  // namespace
 
 AudioDevice::AudioDevice(size_t buffer_size,
                          int channels,
@@ -49,17 +51,24 @@ AudioDevice::AudioDevice(size_t buffer_size,
                          RenderCallback* callback)
     : buffer_size_(buffer_size),
       channels_(channels),
+      bits_per_sample_(16),
       sample_rate_(sample_rate),
       callback_(callback),
+      audio_delay_milliseconds_(0),
+      volume_(1.0),
       stream_id_(0) {
   audio_data_.reserve(channels);
   for (int i = 0; i < channels; ++i) {
     float* channel_data = new float[buffer_size];
     audio_data_.push_back(channel_data);
   }
+  // Lazily create the message filter and share across AudioDevice instances.
+  filter_ = AudioMessageFilterCreator::SharedFilter();
 }
 
 AudioDevice::~AudioDevice() {
+  // Make sure we have been shut down.
+  DCHECK_EQ(0, stream_id_);
   Stop();
   for (int i = 0; i < channels_; ++i)
     delete [] audio_data_[i];
@@ -71,44 +80,91 @@ bool AudioDevice::Start() {
   if (stream_id_)
     return false;
 
-  // Lazily create the message filter and share across AudioDevice instances.
-  filter_ = AudioMessageFilterCreator::SharedFilter();
-
-  stream_id_ = filter_->AddDelegate(this);
-
   AudioParameters params;
   params.format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
   params.channels = channels_;
   params.sample_rate = static_cast<int>(sample_rate_);
-  params.bits_per_sample = 16;
+  params.bits_per_sample = bits_per_sample_;
   params.samples_per_packet = buffer_size_;
 
-  filter_->Send(new AudioHostMsg_CreateStream(0, stream_id_, params, true));
+  // Ensure that the initialization task is posted on the I/O thread by
+  // accessing the I/O message loop directly. This approach avoids a race
+  // condition which could exist if the message loop of the filter was
+  // used instead.
+  DCHECK(ChildProcess::current()) << "Must be in the renderer";
+  MessageLoop* message_loop = ChildProcess::current()->io_message_loop();
+  if (!message_loop)
+    return false;
+
+  message_loop->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioDevice::InitializeOnIOThread, params));
 
   return true;
 }
 
 bool AudioDevice::Stop() {
-  if (stream_id_) {
-    OnDestroy();
-    return true;
+  if (!stream_id_)
+    return false;
+
+  filter_->message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioDevice::ShutDownOnIOThread));
+
+  if (audio_thread_.get()) {
+    socket_->Close();
+    audio_thread_->Join();
   }
-  return false;
+
+  return true;
+}
+
+bool AudioDevice::SetVolume(double volume) {
+  if (!stream_id_)
+    return false;
+
+  if (volume < 0 || volume > 1.0)
+    return false;
+
+  filter_->message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &AudioDevice::SetVolumeOnIOThread, volume));
+
+  volume_ = volume;
+
+  return true;
 }
 
-void AudioDevice::OnDestroy() {
-  // Make sure we don't call destroy more than once.
-  DCHECK_NE(0, stream_id_);
+bool AudioDevice::GetVolume(double* volume) {
+  if (!stream_id_)
+    return false;
+
+  // Return a locally cached version of the current scaling factor.
+  *volume = volume_;
+
+  return true;
+}
+
+void AudioDevice::InitializeOnIOThread(const AudioParameters& params) {
+  stream_id_ = filter_->AddDelegate(this);
+  filter_->Send(new AudioHostMsg_CreateStream(0, stream_id_, params, true));
+}
+
+void AudioDevice::StartOnIOThread() {
+  if (stream_id_)
+    filter_->Send(new AudioHostMsg_PlayStream(0, stream_id_));
+}
+
+void AudioDevice::ShutDownOnIOThread() {
+  // Make sure we don't call shutdown more than once.
   if (!stream_id_)
     return;
 
-  filter_->RemoveDelegate(stream_id_);
   filter_->Send(new AudioHostMsg_CloseStream(0, stream_id_));
+  filter_->RemoveDelegate(stream_id_);
   stream_id_ = 0;
-  if (audio_thread_.get()) {
-    socket_->Close();
-    audio_thread_->Join();
-  }
+}
+
+void AudioDevice::SetVolumeOnIOThread(double volume) {
+  if (stream_id_)
+    filter_->Send(new AudioHostMsg_SetVolume(0, stream_id_, volume));
 }
 
 void AudioDevice::OnRequestPacket(AudioBuffersState buffers_state) {
@@ -117,7 +173,9 @@ void AudioDevice::OnRequestPacket(AudioBuffersState buffers_state) {
 }
 
 void AudioDevice::OnStateChanged(AudioStreamState state) {
-  // Not needed in this simple implementation.
+  if (state == kAudioStreamError) {
+    DLOG(WARNING) << "AudioDevice::OnStateChanged(kError)";
+  }
   NOTIMPLEMENTED();
 }
 
@@ -131,7 +189,6 @@ void AudioDevice::OnLowLatencyCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
-
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
@@ -140,7 +197,6 @@ void AudioDevice::OnLowLatencyCreated(
   DCHECK_GE(socket_handle, 0);
 #endif
   DCHECK(length);
-  DCHECK(!audio_thread_.get());
 
   // TODO(crogers) : check that length is big enough for buffer_size_
 
@@ -156,28 +212,39 @@ void AudioDevice::OnLowLatencyCreated(
       new base::DelegateSimpleThread(this, "renderer_audio_thread"));
   audio_thread_->Start();
 
-  filter_->Send(new AudioHostMsg_PlayStream(0, stream_id_));
+  if (filter_) {
+    filter_->message_loop()->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &AudioDevice::StartOnIOThread));
+  }
 }
 
 void AudioDevice::OnVolume(double volume) {
-  // Not needed in this simple implementation.
   NOTIMPLEMENTED();
 }
 
 // Our audio thread runs here.
 void AudioDevice::Run() {
   int pending_data;
+  const int samples_per_ms = static_cast<int>(sample_rate_) / 1000;
+  const int bytes_per_ms = channels_ * (bits_per_sample_ / 8) * samples_per_ms;
+
   while (sizeof(pending_data) == socket_->Receive(&pending_data,
                                                   sizeof(pending_data)) &&
                                                   pending_data >= 0) {
+    {
+      // Convert the number of pending bytes in the render buffer
+      // into milliseconds.
+      audio_delay_milliseconds_ = pending_data / bytes_per_ms;
+    }
+
     FireRenderCallback();
   }
 }
 
 void AudioDevice::FireRenderCallback() {
   if (callback_) {
-    // Ask client to render audio.
-    callback_->Render(audio_data_, buffer_size_);
+    // Update the audio-delay measurement then ask client to render audio.
+    callback_->Render(audio_data_, buffer_size_, audio_delay_milliseconds_);
 
     // Interleave, scale, and clip to int16.
     int16* output_buffer16 = static_cast<int16*>(shared_memory_data());
diff --git a/content/renderer/audio_device.h b/content/renderer/audio_device.h
index d76492b..41b5031 100644
--- a/content/renderer/audio_device.h
+++ b/content/renderer/audio_device.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -14,16 +14,20 @@
 #include "base/threading/simple_thread.h"
 #include "content/renderer/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.
 class AudioDevice : public AudioMessageFilter::Delegate,
-                    public base::DelegateSimpleThread::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) = 0;
+                        size_t number_of_frames,
+                        size_t audio_delay_milliseconds) = 0;
    protected:
     virtual ~RenderCallback() {}
   };
@@ -35,11 +39,30 @@ class AudioDevice : public AudioMessageFilter::Delegate,
               RenderCallback* callback);
   virtual ~AudioDevice();
 
-  // Returns |true| on success.
+  // 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.
   virtual void OnRequestPacket(AudioBuffersState buffers_state);
   virtual void OnStateChanged(AudioStreamState state);
@@ -48,7 +71,6 @@ class AudioDevice : public AudioMessageFilter::Delegate,
                                    base::SyncSocket::Handle socket_handle,
                                    uint32 length);
   virtual void OnVolume(double volume);
-  virtual void OnDestroy();
 
   // DelegateSimpleThread::Delegate implementation.
   virtual void Run();
@@ -56,6 +78,7 @@ class AudioDevice : public AudioMessageFilter::Delegate,
   // 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.
@@ -65,6 +88,14 @@ class AudioDevice : public AudioMessageFilter::Delegate,
   // 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_;
 
@@ -73,8 +104,14 @@ class AudioDevice : public AudioMessageFilter::Delegate,
   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_;
+
+  // 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.
   int32 stream_id_;
+
   scoped_ptr<base::SharedMemory> shared_memory_;
   scoped_ptr<base::SyncSocket> socket_;
 
diff --git a/content/renderer/renderer_webaudiodevice_impl.cc b/content/renderer/renderer_webaudiodevice_impl.cc
index 5c008c5..b12b2c1 100644
--- a/content/renderer/renderer_webaudiodevice_impl.cc
+++ b/content/renderer/renderer_webaudiodevice_impl.cc
@@ -10,8 +10,7 @@ using WebKit::WebVector;
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(size_t buffer_size,
     int channels, double sample_rate, WebAudioDevice::RenderCallback* callback)
     : client_callback_(callback) {
-  audio_device_.reset(
-      new AudioDevice(buffer_size, channels, sample_rate, this));
+  audio_device_ = new AudioDevice(buffer_size, channels, sample_rate, this);
 }
 
 RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
@@ -26,13 +25,13 @@ void RendererWebAudioDeviceImpl::stop() {
   audio_device_->Stop();
 }
 
-double RendererWebAudioDeviceImpl::sampleRate()
-{
+double RendererWebAudioDeviceImpl::sampleRate() {
   return 44100.0;
 }
 
 void RendererWebAudioDeviceImpl::Render(const std::vector<float*>& audio_data,
-                                size_t number_of_frames) {
+                                size_t number_of_frames,
+                                size_t audio_delay_milliseconds) {
   // Make the client callback to get rendered audio.
   DCHECK(client_callback_);
   if (client_callback_) {
diff --git a/content/renderer/renderer_webaudiodevice_impl.h b/content/renderer/renderer_webaudiodevice_impl.h
index dd5c61f..afafa23 100644
--- a/content/renderer/renderer_webaudiodevice_impl.h
+++ b/content/renderer/renderer_webaudiodevice_impl.h
@@ -7,7 +7,7 @@
 
 #include <vector>
 
-#include "base/scoped_ptr.h"
+#include "base/ref_counted.h"
 #include "content/renderer/audio_device.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAudioDevice.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVector.h"
@@ -28,10 +28,11 @@ class RendererWebAudioDeviceImpl : public WebKit::WebAudioDevice,
 
   // AudioDevice::RenderCallback implementation.
   virtual void Render(const std::vector<float*>& audio_data,
-                      size_t number_of_frames);
+                      size_t number_of_frames,
+                      size_t audio_delay_milliseconds);
 
  private:
-  scoped_ptr<AudioDevice> audio_device_;
+  scoped_refptr<AudioDevice> audio_device_;
 
   // Weak reference to the callback into WebKit code.
   WebKit::WebAudioDevice::RenderCallback* client_callback_;