Fold DecoderStream::Stop() into the dtor.

media/filters/audio_renderer_impl.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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 30 matching lines @@
 }  // namespace
 
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     AudioHardwareConfig* hardware_config)
     : task_runner_(task_runner),
       sink_(sink),
-      audio_buffer_stream_(task_runner,
-                           decoders.Pass(),
-                           set_decryptor_ready_cb),
+      audio_buffer_stream_(new AudioBufferStream(task_runner,
+                                                 decoders.Pass(),
+                                                 set_decryptor_ready_cb)),
       hardware_config_(hardware_config),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       weak_factory_(this) {
-  audio_buffer_stream_.set_splice_observer(base::Bind(
+  audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
-  audio_buffer_stream_.set_config_change_observer(base::Bind(
+  audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererImpl::StartRendering() {
@@ skipping 72 matching lines @@
   DoFlush_Locked();
 }
 
 void AudioRendererImpl::DoFlush_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   DCHECK(!pending_read_);
   DCHECK_EQ(state_, kFlushed);
 
-  audio_buffer_stream_.Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
-                                        weak_factory_.GetWeakPtr()));
+  audio_buffer_stream_->Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
+                                         weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
     if (state_ == kStopped)
       return;
 
     DCHECK_EQ(state_, kFlushed);
@@ skipping 38 matching lines @@
     algorithm_.reset();
     time_cb_.Reset();
     flush_cb_.Reset();
   }
 
   if (sink_) {
     sink_->Stop();
     sink_ = NULL;
   }
 
-  audio_buffer_stream_.Stop(callback);
+  audio_buffer_stream_.reset();

[scherkus (not reviewing), 2014/07/16 17:49:48]

will we be getting rid of Audio/VideoRenderer::Stop() as well?

if so, will audio_buffer_stream_ go back to being a regular member instead of
head-allocated?

[xhwang, 2014/07/16 23:45:49]

Yes, that's the plan. I'd like to do the transition in small steps and this is
some small overhead I have to pay.

+  task_runner_->PostTask(FROM_HERE, callback);
 }
 
 void AudioRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
@@ skipping 60 matching lines @@
         ChannelLayoutToChannelCount(
             stream->audio_decoder_config().channel_layout()),
         hw_params.input_channels(),
         hw_params.sample_rate(),
         hw_params.bits_per_sample(),
         hardware_config_->GetHighLatencyBufferSize());
   }
 
   audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
 
-  audio_buffer_stream_.Initialize(
+  audio_buffer_stream_->Initialize(
       stream,
       false,
       statistics_cb,
       base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 169 matching lines @@
 }
 
 void AudioRendererImpl::AttemptRead_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (!CanRead_Locked())
     return;
 
   pending_read_ = true;
-  audio_buffer_stream_.Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
-                                       weak_factory_.GetWeakPtr()));
+  audio_buffer_stream_->Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
+                                        weak_factory_.GetWeakPtr()));
 }
 
 bool AudioRendererImpl::CanRead_Locked() {
   lock_.AssertAcquired();
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
     case kFlushed:
@@ skipping 198 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media