Moving SwitchOutputDevice out of OutputDevice interface, eliminating OutputDevice

content/renderer/media/track_audio_renderer.cc

 // 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.
 
 #include "content/renderer/media/track_audio_renderer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
@@ skipping 119 matching lines @@
       output_device_id_(device_id),
       security_origin_(security_origin),
       volume_(0.0),
       sink_started_(false) {
   DCHECK(MediaStreamAudioTrack::From(audio_track_));
   DVLOG(1) << "TrackAudioRenderer::TrackAudioRenderer()";
 }
 
 TrackAudioRenderer::~TrackAudioRenderer() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(!sink_.get());
+  DCHECK(!sink_);
   DVLOG(1) << "TrackAudioRenderer::~TrackAudioRenderer()";
 }
 
 void TrackAudioRenderer::Start() {
   DVLOG(1) << "TrackAudioRenderer::Start()";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(playing_, false);
 
   // We get audio data from |audio_track_|...
   MediaStreamAudioSink::AddToAudioTrack(this, audio_track_);
   // ...and |sink_| will get audio data from us.
-  DCHECK(!sink_.get());
+  DCHECK(!sink_);
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
       AudioDeviceFactory::kSourceNonRtcAudioTrack, playout_render_frame_id_,
       session_id_, output_device_id_, security_origin_);
 
   base::AutoLock auto_lock(thread_lock_);
   prior_elapsed_render_time_ = base::TimeDelta();
   num_samples_rendered_ = 0;
 }
 
 void TrackAudioRenderer::Stop() {
   DVLOG(1) << "TrackAudioRenderer::Stop()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   Pause();
 
   // Stop the output audio stream, i.e, stop asking for data to render.
   // It is safer to call Stop() on the |sink_| to clean up the resources even
   // when the |sink_| is never started.
-  if (sink_.get()) {
+  if (sink_) {
     sink_->Stop();
     sink_ = NULL;
   }
 
   if (!sink_started_ && IsLocalRenderer()) {
     UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates",
                               kSinkNeverStarted, kSinkStatesMax);
   }
   sink_started_ = false;
 
   // Ensure that the capturer stops feeding us with captured audio.
   MediaStreamAudioSink::RemoveFromAudioTrack(this, audio_track_);
 }
 
 void TrackAudioRenderer::Play() {
   DVLOG(1) << "TrackAudioRenderer::Play()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (!sink_.get())
+  if (!sink_)
     return;
 
   playing_ = true;
 
   MaybeStartSink();
 }
 
 void TrackAudioRenderer::Pause() {
   DVLOG(1) << "TrackAudioRenderer::Pause()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (!sink_.get())
+  if (!sink_)
     return;
 
   playing_ = false;
 
   base::AutoLock auto_lock(thread_lock_);
   HaltAudioFlowWhileLockHeld();
 }
 
 void TrackAudioRenderer::SetVolume(float volume) {
   DVLOG(1) << "TrackAudioRenderer::SetVolume(" << volume << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Cache the volume.  Whenever |sink_| is re-created, call SetVolume() with
   // this cached volume.
   volume_ = volume;
-  if (sink_.get())
+  if (sink_)
     sink_->SetVolume(volume);
 }
 
-media::OutputDevice* TrackAudioRenderer::GetOutputDevice() {
+media::OutputDeviceInfo TrackAudioRenderer::GetOutputDeviceInfo() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  return this;
+  return sink_ ? sink_->GetOutputDeviceInfo() : media::OutputDeviceInfo();
 }
 
 base::TimeDelta TrackAudioRenderer::GetCurrentRenderTime() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(thread_lock_);
   if (source_params_.IsValid()) {
     return ComputeTotalElapsedRenderTime(prior_elapsed_render_time_,
                                          num_samples_rendered_,
                                          source_params_.sample_rate());
   }
   return prior_elapsed_render_time_;
 }
 
 bool TrackAudioRenderer::IsLocalRenderer() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return MediaStreamAudioTrack::From(audio_track_)->is_local_track();
 }
 
 void TrackAudioRenderer::SwitchOutputDevice(
     const std::string& device_id,
     const url::Origin& security_origin,
-    const media::SwitchOutputDeviceCB& callback) {
+    const media::OutputDeviceStatusCB& callback) {
   DVLOG(1) << "TrackAudioRenderer::SwitchOutputDevice()";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   {
     base::AutoLock auto_lock(thread_lock_);
     HaltAudioFlowWhileLockHeld();
   }
 
   scoped_refptr<media::AudioRendererSink> new_sink =
       AudioDeviceFactory::NewAudioRendererSink(
           AudioDeviceFactory::kSourceNonRtcAudioTrack, playout_render_frame_id_,
           session_id_, device_id, security_origin);
+
   media::OutputDeviceStatus new_sink_status =
-      new_sink->GetOutputDevice()->GetDeviceStatus();
+      new_sink->GetOutputDeviceInfo().device_status();
   if (new_sink_status != media::OUTPUT_DEVICE_STATUS_OK) {
     callback.Run(new_sink_status);
     return;
   }
 
   output_device_id_ = device_id;
   security_origin_ = security_origin;
   bool was_sink_started = sink_started_;
 
-  if (sink_.get())
+  if (sink_)
     sink_->Stop();
 
   sink_started_ = false;
   sink_ = new_sink;
   if (was_sink_started)
     MaybeStartSink();
 
   callback.Run(media::OUTPUT_DEVICE_STATUS_OK);
 }
 
-media::AudioParameters TrackAudioRenderer::GetOutputParameters() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  if (!sink_ || !source_params_.IsValid())
-    return media::AudioParameters();
-
-  // Output parameters consist of the same channel layout and sample rate as the
-  // source, but having the buffer duration preferred by the hardware.
-  const media::AudioParameters& preferred_params =
-      sink_->GetOutputDevice()->GetOutputParameters();
-  return media::AudioParameters(
-      preferred_params.format(), source_params_.channel_layout(),
-      source_params_.sample_rate(), source_params_.bits_per_sample(),
-      preferred_params.frames_per_buffer() * source_params_.sample_rate() /
-          preferred_params.sample_rate());
-}
-
-media::OutputDeviceStatus TrackAudioRenderer::GetDeviceStatus() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  if (!sink_.get())
-    return media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL;
-
-  return sink_->GetOutputDevice()->GetDeviceStatus();
-}
-
 void TrackAudioRenderer::MaybeStartSink() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "TrackAudioRenderer::MaybeStartSink()";
 
-  if (!sink_.get() || !source_params_.IsValid() || !playing_)
+  if (!sink_ || !source_params_.IsValid() || !playing_)
     return;
 
   // Re-create the AudioShifter to drop old audio data and reset to a starting
   // state.  MaybeStartSink() is always called in a situation where either the
   // source or sink has changed somehow and so all of AudioShifter's internal
   // time-sync state is invalid.
   CreateAudioShifter();
 
-  if (sink_started_ ||
-      sink_->GetOutputDevice()->GetDeviceStatus() !=
-          media::OUTPUT_DEVICE_STATUS_OK) {
+  if (sink_started_)
     return;
-  }
 
+  const media::OutputDeviceInfo& device_info = sink_->GetOutputDeviceInfo();
+  if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK)
+    return;
+
+  // Output parameters consist of the same channel layout and sample rate as the
+  // source, but having the buffer duration preferred by the hardware.
+  const media::AudioParameters& hardware_params = device_info.output_params();
+  media::AudioParameters sink_params(
+      hardware_params.format(), source_params_.channel_layout(),
+      source_params_.sample_rate(), source_params_.bits_per_sample(),
+      hardware_params.frames_per_buffer() * source_params_.sample_rate() /
+          hardware_params.sample_rate());
   DVLOG(1) << ("TrackAudioRenderer::MaybeStartSink() -- Starting sink.  "
                "source_params_={")
            << source_params_.AsHumanReadableString() << "}, sink parameters={"
-           << GetOutputParameters().AsHumanReadableString() << '}';
-  sink_->Initialize(GetOutputParameters(), this);
+           << sink_params.AsHumanReadableString() << '}';
+  sink_->Initialize(sink_params, this);
   sink_->Start();
   sink_->SetVolume(volume_);
   sink_->Play();  // Not all the sinks play on start.
   sink_started_ = true;
   if (IsLocalRenderer()) {
     UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates", kSinkStarted,
                               kSinkStatesMax);
   }
 }
 
 void TrackAudioRenderer::ReconfigureSink(const media::AudioParameters& params) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "TrackAudioRenderer::ReconfigureSink()";
 
   if (source_params_.Equals(params))
     return;
   source_params_ = params;
 
-  if (!sink_.get())
+  if (!sink_)
     return;  // TrackAudioRenderer has not yet been started.
 
   // Stop |sink_| and re-create a new one to be initialized with different audio
   // parameters.  Then, invoke MaybeStartSink() to restart everything again.
   sink_->Stop();
   sink_started_ = false;
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
       AudioDeviceFactory::kSourceNonRtcAudioTrack, playout_render_frame_id_,
       session_id_, output_device_id_, security_origin_);
   MaybeStartSink();
@@ skipping 29 matching lines @@
   if (source_params_.IsValid()) {
     prior_elapsed_render_time_ =
         ComputeTotalElapsedRenderTime(prior_elapsed_render_time_,
                                       num_samples_rendered_,
                                       source_params_.sample_rate());
     num_samples_rendered_ = 0;
   }
 }
 
 }  // namespace content