Factor out AudioOutputDelegate from AudioRendererHost.

media/audio/audio_output_controller.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 "media/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 AudioOutputController::AudioOutputController(
     AudioManager* audio_manager,
     EventHandler* handler,
     const AudioParameters& params,
     const std::string& output_device_id,
-    SyncReader* sync_reader)
+    std::unique_ptr<SyncReader> sync_reader)
     : audio_manager_(audio_manager),
       params_(params),
       handler_(handler),
       output_device_id_(output_device_id),
       stream_(NULL),
       diverting_to_stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
-      sync_reader_(sync_reader),
+      sync_reader_(std::move(sync_reader)),
       message_loop_(audio_manager->GetTaskRunner()),
       power_monitor_(
           params.sample_rate(),
           TimeDelta::FromMilliseconds(kPowerMeasurementTimeConstantMillis)),
       on_more_io_data_called_(0),
       ignore_errors_during_stop_close_(false) {
   DCHECK(audio_manager);
   DCHECK(handler_);
   DCHECK(sync_reader_);
   DCHECK(message_loop_.get());
 }
 
 AudioOutputController::~AudioOutputController() {
   CHECK_EQ(kClosed, state_);
   CHECK_EQ(nullptr, stream_);
   CHECK(duplication_targets_.empty());
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
     const std::string& output_device_id,
-    SyncReader* sync_reader) {
+    std::unique_ptr<SyncReader> sync_reader) {
   CHECK(audio_manager);
   CHECK_EQ(AudioManager::Get(), audio_manager);
   DCHECK(sync_reader);
 
   if (!params.IsValid())
     return NULL;
 
-  scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      audio_manager, event_handler, params, output_device_id, sync_reader));
+  scoped_refptr<AudioOutputController> controller(
+      new AudioOutputController(audio_manager, event_handler, params,
+                                output_device_id, std::move(sync_reader)));
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoCreate, controller, false));
   return controller;
 }
 
 void AudioOutputController::Play() {
   CHECK_EQ(AudioManager::Get(), audio_manager_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoPlay, this));
 }
@@ skipping 47 matching lines @@
     return;
 
   DoStopCloseAndClearStream();  // Calls RemoveOutputDeviceChangeListener().
   DCHECK_EQ(kEmpty, state_);
 
   stream_ = diverting_to_stream_ ?
       diverting_to_stream_ :
       audio_manager_->MakeAudioOutputStreamProxy(params_, output_device_id_);
   if (!stream_) {
     state_ = kError;
-    handler_->OnError();
+    handler_->OnControllerError();
     return;
   }
 
   if (!stream_->Open()) {
     DoStopCloseAndClearStream();
     state_ = kError;
-    handler_->OnError();
+    handler_->OnControllerError();
     return;
   }
 
   // Everything started okay, so re-register for state change callbacks if
   // stream_ was created via AudioManager.
   if (stream_ != diverting_to_stream_)
     audio_manager_->AddOutputDeviceChangeListener(this);
 
   // We have successfully opened the stream. Set the initial volume.
   stream_->SetVolume(volume_);
 
   // Finally set the state to kCreated.
   state_ = kCreated;
 
   // And then report we have been created if we haven't done so already.
   if (!is_for_device_change)
-    handler_->OnCreated();
+    handler_->OnControllerCreated();
 }
 
 void AudioOutputController::DoPlay() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.PlayTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoPlay");
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
@@ skipping 14 matching lines @@
   // it.
   //
   // Timer self-manages its lifetime and WedgeCheck() will only record the UMA
   // statistic if state is still kPlaying.  Additional Start() calls will
   // invalidate the previous timer.
   wedge_timer_.reset(new base::OneShotTimer());
   wedge_timer_->Start(
       FROM_HERE, TimeDelta::FromSeconds(5), this,
       &AudioOutputController::WedgeCheck);
 
-  handler_->OnPlaying();
+  handler_->OnControllerPlaying();
 }
 
 void AudioOutputController::StopStream() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ == kPlaying) {
     wedge_timer_.reset();
     stream_->Stop();
 
     // A stopped stream is silent, and power_montior_.Scan() is no longer being
@@ skipping 12 matching lines @@
   StopStream();
 
   if (state_ != kPaused)
     return;
 
   // Let the renderer know we've stopped.  Necessary to let PPAPI clients know
   // audio has been shutdown.  TODO(dalecurtis): This stinks.  PPAPI should have
   // a better way to know when it should exit PPB_Audio_Shared::Run().
   sync_reader_->UpdatePendingBytes(std::numeric_limits<uint32_t>::max(), 0);
 
-  handler_->OnPaused();
+  handler_->OnControllerPaused();
 }
 
 void AudioOutputController::DoClose() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioOutputController.CloseTime");
   TRACE_EVENT0("audio", "AudioOutputController::DoClose");
 
   if (state_ != kClosed) {
     DoStopCloseAndClearStream();
     sync_reader_->Close();
@@ skipping 40 matching lines @@
   // since it would break the diverted setup. Once diversion is
   // finished using StopDiverting() the output will switch to the new
   // device ID.
   if (stream_ != diverting_to_stream_)
     OnDeviceChange();
 }
 
 void AudioOutputController::DoReportError() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (state_ != kClosed)
-    handler_->OnError();
+    handler_->OnControllerError();
 }
 
 int AudioOutputController::OnMoreData(base::TimeDelta delay,
                                       base::TimeTicks delay_timestamp,
                                       int prior_frames_skipped,
                                       AudioBus* dest) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 
   // Indicate that we haven't wedged (at least not indefinitely, WedgeCheck()
   // may have already fired if OnMoreData() took an abnormal amount of time).
@@ skipping 202 matching lines @@
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we should be playing and we haven't, that's a wedge.
   if (state_ == kPlaying) {
     UMA_HISTOGRAM_BOOLEAN("Media.AudioOutputControllerPlaybackStartupSuccess",
                           base::AtomicRefCountIsOne(&on_more_io_data_called_));
   }
 }
 
 }  // namespace media