Fold DecoderStream::Stop() into the dtor.

media/filters/decoder_stream.cc

 // Copyright 2014 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/decoder_stream.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
@@ skipping 38 matching lines @@
       decoder_selector_(
           new DecoderSelector<StreamType>(task_runner,
                                           decoders.Pass(),
                                           set_decryptor_ready_cb)),
       active_splice_(false),
       pending_decode_requests_(0),
       weak_factory_(this) {}
 
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::~DecoderStream() {
-  DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_STOPPED) << state_;
+  FUNCTION_DVLOG(2);
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  // TODO(xhwang): Fold DecoderSelector::Abort() into the dtor.
+  if (state_ == STATE_INITIALIZING)
+    decoder_selector_->Abort();
+
+  if (!init_cb_.is_null()) {
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(base::ResetAndReturn(&init_cb_), false));
+  }
+  if (!read_cb_.is_null()) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(
+        base::ResetAndReturn(&read_cb_), ABORTED, scoped_refptr<Output>()));
+  }
+  if (!reset_cb_.is_null())
+    task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&reset_cb_));
+
+  if (decrypting_demuxer_stream_)
+    decrypting_demuxer_stream_->Stop();
+
+  stream_ = NULL;
+  decoder_.reset();
+  decrypting_demuxer_stream_.reset();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Initialize(DemuxerStream* stream,
                                            bool low_delay,
                                            const StatisticsCB& statistics_cb,
                                            const InitCB& init_cb) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED) << state_;
@@ skipping 12 matching lines @@
       base::Bind(&DecoderStream<StreamType>::OnDecoderSelected,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(const ReadCB& read_cb) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING &&
-         state_ != STATE_STOPPED) << state_;
+  DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING)
+      << state_;
   // No two reads in the flight at any time.
   DCHECK(read_cb_.is_null());
   // No read during resetting or stopping process.
   DCHECK(reset_cb_.is_null());
-  DCHECK(stop_cb_.is_null());
 
   if (state_ == STATE_ERROR) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(read_cb, DECODE_ERROR, scoped_refptr<Output>()));
     return;
   }
 
   if (state_ == STATE_END_OF_STREAM && ready_outputs_.empty()) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(read_cb, OK, StreamTraits::CreateEOSOutput()));
     return;
   }
 
   if (!ready_outputs_.empty()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(read_cb, OK, ready_outputs_.front()));
     ready_outputs_.pop_front();
   } else {
     read_cb_ = read_cb;
   }
 
   if (state_ == STATE_NORMAL && CanDecodeMore())
     ReadFromDemuxerStream();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Reset(const base::Closure& closure) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
+  DCHECK(state_ != STATE_UNINITIALIZED)<< state_;
   DCHECK(reset_cb_.is_null());
-  DCHECK(stop_cb_.is_null());
 
   reset_cb_ = closure;
 
   if (!read_cb_.is_null()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         base::ResetAndReturn(&read_cb_), ABORTED, scoped_refptr<Output>()));
   }
 
   ready_outputs_.clear();
 
@@ skipping 12 matching lines @@
   if (decrypting_demuxer_stream_) {
     decrypting_demuxer_stream_->Reset(base::Bind(
         &DecoderStream<StreamType>::ResetDecoder, weak_factory_.GetWeakPtr()));
     return;
   }
 
   ResetDecoder();
 }
 
 template <DemuxerStream::Type StreamType>
-void DecoderStream<StreamType>::Stop(const base::Closure& closure) {
-  FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK_NE(state_, STATE_STOPPED) << state_;
-  DCHECK(stop_cb_.is_null());
-
-  // TODO(xhwang): This is the only asynchronousness in DecoderStream::Stop().
-  // Fix this so that we can merge the stopping code into the dtor.
-  if (state_ == STATE_INITIALIZING) {
-    stop_cb_ = closure;
-    decoder_selector_->Abort();
-    return;
-  }
-
-  DCHECK(init_cb_.is_null());
-
-  // All pending callbacks will be dropped.
-  weak_factory_.InvalidateWeakPtrs();
-
-  // Post callbacks to prevent reentrance into this object.
-  if (!read_cb_.is_null()) {
-    task_runner_->PostTask(FROM_HERE, base::Bind(
-        base::ResetAndReturn(&read_cb_), ABORTED, scoped_refptr<Output>()));
-  }
-  if (!reset_cb_.is_null())
-    task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&reset_cb_));
-
-  if (decrypting_demuxer_stream_)
-    decrypting_demuxer_stream_->Stop();
-
-  stream_ = NULL;
-  decoder_.reset();
-  decrypting_demuxer_stream_.reset();
-
-  state_ = STATE_STOPPED;
-  task_runner_->PostTask(FROM_HERE, closure);
-}
-
-template <DemuxerStream::Type StreamType>
 bool DecoderStream<StreamType>::CanReadWithoutStalling() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return !ready_outputs_.empty() || decoder_->CanReadWithoutStalling();
 }
 
 template <>
 bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return true;
 }
@@ skipping 32 matching lines @@
   DCHECK(reset_cb_.is_null());
 
   decoder_selector_.reset();
   if (decrypting_demuxer_stream)
     stream_ = decrypting_demuxer_stream.get();
 
   if (!selected_decoder) {
     state_ = STATE_UNINITIALIZED;
     StreamTraits::FinishInitialization(
         base::ResetAndReturn(&init_cb_), selected_decoder.get(), stream_);
-  } else {
-    state_ = STATE_NORMAL;
-    decoder_ = selected_decoder.Pass();
-    decrypting_demuxer_stream_ = decrypting_demuxer_stream.Pass();
-    StreamTraits::FinishInitialization(
-        base::ResetAndReturn(&init_cb_), decoder_.get(), stream_);
+    return;
   }
 
-  // Stop() called during initialization.
-  if (!stop_cb_.is_null()) {
-    Stop(base::ResetAndReturn(&stop_cb_));
-    return;
-  }
+  state_ = STATE_NORMAL;
+  decoder_ = selected_decoder.Pass();
+  decrypting_demuxer_stream_ = decrypting_demuxer_stream.Pass();
+  StreamTraits::FinishInitialization(
+      base::ResetAndReturn(&init_cb_), decoder_.get(), stream_);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::SatisfyRead(
     Status status,
     const scoped_refptr<Output>& output) {
   DCHECK(!read_cb_.is_null());
   base::ResetAndReturn(&read_cb_).Run(status, output);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Decode(
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(2);
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
   DCHECK_LT(pending_decode_requests_, GetMaxDecodeRequests());
   DCHECK(reset_cb_.is_null());
-  DCHECK(stop_cb_.is_null());
   DCHECK(buffer);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
 
   TRACE_EVENT_ASYNC_BEGIN0("media", GetTraceString<StreamType>(), this);
   ++pending_decode_requests_;
   decoder_->Decode(buffer,
                    base::Bind(&DecoderStream<StreamType>::OnDecodeDone,
                               weak_factory_.GetWeakPtr(),
                               buffer_size,
                               buffer->end_of_stream()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::FlushDecoder() {
   Decode(DecoderBuffer::CreateEOSBuffer());
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecodeDone(int buffer_size,
                                              bool end_of_stream,
                                              typename Decoder::Status status) {
   FUNCTION_DVLOG(2) << status;
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
       << state_;
-  DCHECK(stop_cb_.is_null());
   DCHECK_GT(pending_decode_requests_, 0);
 
   --pending_decode_requests_;
 
   TRACE_EVENT_ASYNC_END0("media", GetTraceString<StreamType>(), this);
 
   if (state_ == STATE_ERROR) {
     DCHECK(read_cb_.is_null());
     return;
   }
@@ skipping 74 matching lines @@
   ready_outputs_.pop_front();
   SatisfyRead(OK, output);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReadFromDemuxerStream() {
   FUNCTION_DVLOG(2);
   DCHECK_EQ(state_, STATE_NORMAL) << state_;
   DCHECK(CanDecodeMore());
   DCHECK(reset_cb_.is_null());
-  DCHECK(stop_cb_.is_null());
 
   state_ = STATE_PENDING_DEMUXER_READ;
   stream_->Read(base::Bind(&DecoderStream<StreamType>::OnBufferReady,
                            weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnBufferReady(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(2) << ": " << status << ", "
                     << (buffer ? buffer->AsHumanReadableString() : "NULL");
 
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR ||
-         state_ == STATE_STOPPED)
+  DCHECK(state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
       << state_;
   DCHECK_EQ(buffer.get() != NULL, status == DemuxerStream::kOk) << status;
-  DCHECK(stop_cb_.is_null());
 
   // Decoding has been stopped (e.g due to an error).
   if (state_ != STATE_PENDING_DEMUXER_READ) {
-    DCHECK(state_ == STATE_ERROR || state_ == STATE_STOPPED);
+    DCHECK(state_ == STATE_ERROR);
     DCHECK(read_cb_.is_null());
     return;
   }
 
   state_ = STATE_NORMAL;
 
   if (status == DemuxerStream::kConfigChanged) {
     FUNCTION_DVLOG(2) << ": " << "ConfigChanged";
     DCHECK(stream_->SupportsConfigChanges());
 
@@ skipping 60 matching lines @@
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DecoderStream<StreamType>::OnDecodeOutputReady,
                  weak_factory_.GetWeakPtr()));
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReinitialized(PipelineStatus status) {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER) << state_;
-  DCHECK(stop_cb_.is_null());
 
   // ReinitializeDecoder() can be called in two cases:
   // 1, Flushing decoder finished (see OnDecodeOutputReady()).
   // 2, Reset() was called during flushing decoder (see OnDecoderReset()).
   // Also, Reset() can be called during pending ReinitializeDecoder().
   // This function needs to handle them all!
 
   state_ = (status == PIPELINE_OK) ? STATE_NORMAL : STATE_ERROR;
 
   if (!reset_cb_.is_null()) {
@@ skipping 27 matching lines @@
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReset() {
   FUNCTION_DVLOG(2);
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR || state_ == STATE_END_OF_STREAM) << state_;
   // If Reset() was called during pending read, read callback should be fired
   // before the reset callback is fired.
   DCHECK(read_cb_.is_null());
   DCHECK(!reset_cb_.is_null());
-  DCHECK(stop_cb_.is_null());
 
   if (state_ != STATE_FLUSHING_DECODER) {
     state_ = STATE_NORMAL;
     active_splice_ = false;
     base::ResetAndReturn(&reset_cb_).Run();
     return;
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media