Moved the fake input stream's processing onto the audio worker thread.

media/audio/fake_audio_provider.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2015 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 "media/audio/fake_audio_input_stream.h"
+#include "media/audio/fake_audio_provider.h"
 
 #include "base/bind.h"
-#include "base/command_line.h"
+#include "base/cancelable_callback.h"
 #include "base/files/file.h"
+#include "base/files/file_path.h"
 #include "base/lazy_instance.h"
-#include "media/audio/audio_manager_base.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/thread_checker.h"
+#include "base/time/time.h"
+#include "media/audio/audio_parameters.h"
+#include "media/audio/sounds/wav_audio_handler.h"
 #include "media/base/audio_bus.h"
-#include "media/base/media_switches.h"
-
-using base::TimeTicks;
-using base::TimeDelta;
+#include "media/base/audio_converter.h"
 
 namespace media {
 
 namespace {
 
 // These values are based on experiments for local-to-local
 // PeerConnection to demonstrate audio/video synchronization.
 const int kBeepDurationMilliseconds = 20;
 const int kBeepFrequency = 400;
 
@@ skipping 68 matching lines @@
   scoped_ptr<media::WavAudioHandler> wav_audio_handler(
       new media::WavAudioHandler(wav_data));
   return wav_audio_handler.Pass();
 }
 
 static base::LazyInstance<BeepContext> g_beep_context =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-AudioInputStream* FakeAudioInputStream::MakeFakeStream(
-    AudioManagerBase* manager,
-    const AudioParameters& params) {
-  return new FakeAudioInputStream(manager, params);
+class FakeAudioProvider::Worker
+    : public base::RefCountedThreadSafe<FakeAudioProvider::Worker>,
+      public AudioConverter::InputCallback {
+ public:
+  Worker(const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+         const AudioParameters& params);
+
+  void Open(const base::FilePath& optional_path_to_wav_file);
+  void Start(InputCB input_cb);
+  void Stop();
+  bool IsStopped();
+
+ private:
+  friend class base::RefCountedThreadSafe<Worker>;
+  ~Worker() override;
+
+  void DoCallback();
+  void DoOpen(const base::FilePath& optional_path_to_wav_file);
+  void DoStart();
+  void DoCancel();
+
+  void LoadWavFileIntoWorker(const base::FilePath& wav_filename);
+
+  // Returns true if the device is playing from a file; false if we're beeping.
+  bool PlayingFromFile();
+
+  void PlayFile();
+  void PlayBeep();
+
+  base::Lock input_cb_lock_;  // Held while mutating or running |input_cb_|.
+  InputCB input_cb_;
+  base::CancelableClosure input_task_cb_;
+  scoped_ptr<uint8[]> buffer_;
+  int buffer_size_;
+  AudioParameters params_;
+  const scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner_;
+  base::TimeTicks last_callback_time_;
+  base::TimeDelta callback_interval_;
+  base::TimeDelta interval_from_last_beep_;
+  int beep_duration_in_buffers_;
+  int beep_generated_in_buffers_;
+  int beep_period_in_frames_;
+  scoped_ptr<media::AudioBus> audio_bus_;
+  scoped_ptr<uint8[]> wav_file_data_;
+  scoped_ptr<media::WavAudioHandler> wav_audio_handler_;
+  scoped_ptr<media::AudioConverter> file_audio_converter_;
+  int wav_file_read_pos_;
+
+  base::ThreadChecker thread_checker_;
+
+  // If running in file mode, this provides audio data from wav_audio_handler_.
+  double ProvideInput(AudioBus* audio_bus,
+                      base::TimeDelta buffer_delay) override;
+};
+
+FakeAudioProvider::FakeAudioProvider(
+      const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+      const AudioParameters& params)
+    : worker_(new Worker(worker_task_runner, params)) {
 }
 
-FakeAudioInputStream::FakeAudioInputStream(AudioManagerBase* manager,
-                                           const AudioParameters& params)
-    : audio_manager_(manager),
-      callback_(NULL),
-      buffer_size_((params.channels() * params.bits_per_sample() *
+FakeAudioProvider::~FakeAudioProvider() {
+  DCHECK(worker_->IsStopped());
+}
+
+void FakeAudioProvider::OpenInBeepMode() {
+  worker_->Open(base::FilePath());
+}
+
+void FakeAudioProvider::OpenInFileMode(const base::FilePath& path_to_wav_file) {
+  worker_->Open(path_to_wav_file);
+}
+
+void FakeAudioProvider::Start(const InputCB& input_cb) {
+  DCHECK(worker_->IsStopped());
+  worker_->Start(input_cb);
+}
+
+void FakeAudioProvider::Stop() {
+  worker_->Stop();
+}
+
+FakeAudioProvider::Worker::Worker(
+    const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
+    const AudioParameters& params)
+    : buffer_size_((params.channels() * params.bits_per_sample() *
                     params.frames_per_buffer()) /
                    8),
       params_(params),
-      task_runner_(manager->GetTaskRunner()),
+      worker_task_runner_(worker_task_runner),
       callback_interval_(base::TimeDelta::FromMilliseconds(
           (params.frames_per_buffer() * 1000) / params.sample_rate())),
       beep_duration_in_buffers_(kBeepDurationMilliseconds *
                                 params.sample_rate() /
                                 params.frames_per_buffer() /
                                 1000),
       beep_generated_in_buffers_(0),
       beep_period_in_frames_(params.sample_rate() / kBeepFrequency),
       audio_bus_(AudioBus::Create(params)),
-      wav_file_read_pos_(0),
-      weak_factory_(this) {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
+      wav_file_read_pos_(0) {
+  // Ensure Start, Stop and Open is called on the same thread (where we're
+  // created doesn't matter though).
+  thread_checker_.DetachFromThread();
 }
 
-FakeAudioInputStream::~FakeAudioInputStream() {}
+FakeAudioProvider::Worker::~Worker() {
+  DCHECK(input_cb_.is_null());
+}
 
-bool FakeAudioInputStream::Open() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
+void FakeAudioProvider::Worker::Open(
+    const base::FilePath& optional_path_to_wav_file) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  worker_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Worker::DoOpen, this, optional_path_to_wav_file));
+}
+
+void FakeAudioProvider::Worker::DoOpen(
+    const base::FilePath& optional_path_to_wav_file) {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
   buffer_.reset(new uint8[buffer_size_]);
   memset(buffer_.get(), 0, buffer_size_);
   audio_bus_->Zero();
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseFileForFakeAudioCapture)) {
-    OpenInFileMode(base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-        switches::kUseFileForFakeAudioCapture));
-  }
-
-  return true;
+  if (!optional_path_to_wav_file.empty())
+    LoadWavFileIntoWorker(optional_path_to_wav_file);
 }
 
-void FakeAudioInputStream::Start(AudioInputCallback* callback)  {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  DCHECK(!callback_);
-  callback_ = callback;
-  last_callback_time_ = TimeTicks::Now();
-
-  task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&FakeAudioInputStream::DoCallback, weak_factory_.GetWeakPtr()),
-      callback_interval_);
-}
-
-void FakeAudioInputStream::DoCallback() {
-  DCHECK(callback_);
-
-  const TimeTicks now = TimeTicks::Now();
-  base::TimeDelta next_callback_time =
-      last_callback_time_ + callback_interval_ * 2 - now;
-
-  // If we are falling behind, try to catch up as much as we can in the next
-  // callback.
-  if (next_callback_time < base::TimeDelta())
-    next_callback_time = base::TimeDelta();
-
-  if (PlayingFromFile()) {
-    PlayFile();
-  } else {
-    PlayBeep();
-  }
-
-  last_callback_time_ = now;
-
-  task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&FakeAudioInputStream::DoCallback, weak_factory_.GetWeakPtr()),
-      next_callback_time);
-}
-
-void FakeAudioInputStream::OpenInFileMode(const base::FilePath& wav_filename) {
-  CHECK(!wav_filename.empty())
-      << "You must pass the file to use as argument to --"
-      << switches::kUseFileForFakeAudioCapture << ".";
+void FakeAudioProvider::Worker::LoadWavFileIntoWorker(
+    const base::FilePath& wav_filename) {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
 
   // Read the file, and put its data in a scoped_ptr so it gets deleted later.
   size_t file_length = 0;
   wav_file_data_ = ReadWavFile(wav_filename, &file_length);
   wav_audio_handler_ = CreateWavAudioHandler(
       wav_filename, wav_file_data_.get(), file_length, params_);
 
   // Hook us up so we pull in data from the file into the converter. We need to
   // modify the wav file's audio parameters since we'll be reading small slices
   // of it at a time and not the whole thing (like 10 ms at a time).
   AudioParameters file_audio_slice(
       wav_audio_handler_->params().format(),
       wav_audio_handler_->params().channel_layout(),
       wav_audio_handler_->params().sample_rate(),
       wav_audio_handler_->params().bits_per_sample(),
       params_.frames_per_buffer());
 
   file_audio_converter_.reset(
       new AudioConverter(file_audio_slice, params_, false));
   file_audio_converter_->AddInput(this);
 }
 
-bool FakeAudioInputStream::PlayingFromFile() {
+void FakeAudioProvider::Worker::Start(InputCB callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  {
+    base::AutoLock scoped_lock(input_cb_lock_);
+    DCHECK(input_cb_.is_null());
+    input_cb_ = callback;
+  }
+  worker_task_runner_->PostTask(FROM_HERE, base::Bind(&Worker::DoStart, this));
+}
+
+void FakeAudioProvider::Worker::DoStart()  {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
+  DCHECK(buffer_.get() != nullptr) << "Must be opened first.";
+
+  last_callback_time_ = base::TimeTicks::Now();
+
+  input_task_cb_.Reset(base::Bind(&Worker::DoCallback, this));
+  input_task_cb_.callback().Run();
+}
+
+void FakeAudioProvider::Worker::DoCallback() {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
+
+  const base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeDelta delay = last_callback_time_ + callback_interval_ * 2 - now;
+
+  // If we are falling behind, try to catch up as much as we can in the next
+  // callback.
+  if (delay < base::TimeDelta())
+    delay = base::TimeDelta();
+
+  if (PlayingFromFile()) {
+    PlayFile();
+  } else {
+    PlayBeep();
+  }
+
+  last_callback_time_ = now;
+  worker_task_runner_->PostDelayedTask(FROM_HERE, input_task_cb_.callback(),
+                                       delay);
+}
+
+bool FakeAudioProvider::Worker::PlayingFromFile() {
   return wav_audio_handler_.get() != nullptr;
 }
 
-void FakeAudioInputStream::PlayFile() {
+void FakeAudioProvider::Worker::PlayFile() {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
+
   // Stop playing if we've played out the whole file.
   if (wav_audio_handler_->AtEnd(wav_file_read_pos_))
     return;
 
   file_audio_converter_->Convert(audio_bus_.get());
-  callback_->OnData(this, audio_bus_.get(), buffer_size_, 1.0);
+  {
+    base::AutoLock scoped_lock(input_cb_lock_);
+    if (input_cb_.is_null())
+      return;
+    input_cb_.Run(audio_bus_.get(), buffer_size_);
+  }
 }
 
-void FakeAudioInputStream::PlayBeep() {
+void FakeAudioProvider::Worker::PlayBeep() {
+  DCHECK(worker_task_runner_->BelongsToCurrentThread());
+
   // Accumulate the time from the last beep.
-  interval_from_last_beep_ += TimeTicks::Now() - last_callback_time_;
+  interval_from_last_beep_ += base::TimeTicks::Now() - last_callback_time_;
 
   memset(buffer_.get(), 0, buffer_size_);
   bool should_beep = false;
   {
     BeepContext* beep_context = g_beep_context.Pointer();
     if (beep_context->automatic_beep()) {
       base::TimeDelta delta = interval_from_last_beep_ -
-          TimeDelta::FromMilliseconds(kAutomaticBeepIntervalInMs);
+          base::TimeDelta::FromMilliseconds(kAutomaticBeepIntervalInMs);
       if (delta > base::TimeDelta()) {
         should_beep = true;
         interval_from_last_beep_ = delta;
       }
     } else {
       should_beep = beep_context->beep_once();
       beep_context->SetBeepOnce(false);
     }
   }
 
@@ skipping 16 matching lines @@
       position += high_bytes * 2;
     }
 
     ++beep_generated_in_buffers_;
     if (beep_generated_in_buffers_ >= beep_duration_in_buffers_)
       beep_generated_in_buffers_ = 0;
   }
 
   audio_bus_->FromInterleaved(
       buffer_.get(), audio_bus_->frames(), params_.bits_per_sample() / 8);
-  callback_->OnData(this, audio_bus_.get(), buffer_size_, 1.0);
+  {
+    base::AutoLock scoped_lock(input_cb_lock_);
+    if (input_cb_.is_null())
+      return;
+    input_cb_.Run(audio_bus_.get(), buffer_size_);
+  }
 }
 
-void FakeAudioInputStream::Stop() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  weak_factory_.InvalidateWeakPtrs();
-  callback_ = NULL;
+void FakeAudioProvider::Worker::Stop() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  {
+    base::AutoLock scoped_lock(input_cb_lock_);
+    if (input_cb_.is_null())
+      return;
+    input_cb_.Reset();
+  }
+  worker_task_runner_->PostTask(FROM_HERE, base::Bind(&Worker::DoCancel, this));
 }
 
-void FakeAudioInputStream::Close() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  audio_manager_->ReleaseInputStream(this);
+bool FakeAudioProvider::Worker::IsStopped() {
+  base::AutoLock scoped_lock(input_cb_lock_);
+  return input_cb_.is_null();
 }
 
-double FakeAudioInputStream::GetMaxVolume() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  return 1.0;
+void FakeAudioProvider::Worker::DoCancel() {
+  input_task_cb_.Cancel();
 }
 
-void FakeAudioInputStream::SetVolume(double volume) {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-}
-
-double FakeAudioInputStream::GetVolume() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  return 1.0;
-}
-
-bool FakeAudioInputStream::IsMuted() {
-  DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread());
-  return false;
-}
-
-bool FakeAudioInputStream::SetAutomaticGainControl(bool enabled) {
-  return false;
-}
-
-bool FakeAudioInputStream::GetAutomaticGainControl() {
-  return false;
-}
-
-// static
-void FakeAudioInputStream::BeepOnce() {
-  BeepContext* beep_context = g_beep_context.Pointer();
-  beep_context->SetBeepOnce(true);
-}
-
-double FakeAudioInputStream::ProvideInput(AudioBus* audio_bus_into_converter,
-                                          base::TimeDelta buffer_delay) {
+double FakeAudioProvider::Worker::ProvideInput(
+    AudioBus* audio_bus_into_converter,
+    base::TimeDelta buffer_delay) {
   // Unfilled frames will be zeroed by CopyTo.
   size_t bytes_written;
   wav_audio_handler_->CopyTo(audio_bus_into_converter, wav_file_read_pos_,
                              &bytes_written);
   wav_file_read_pos_ += bytes_written;
   return 1.0;
 };
 
+void FakeAudioProvider::BeepOnce() {
+  BeepContext* beep_context = g_beep_context.Pointer();
+  beep_context->SetBeepOnce(true);
+}
+
 }  // namespace media