Remove pending demuxer read state, prefer flag, it's not stable.

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 379 matching lines @@
   // |pending_buffers_|.
   DecodeInternal(DecoderBuffer::CreateEOSBuffer());
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecodeDone(int buffer_size,
                                              bool end_of_stream,
                                              DecodeStatus status) {
   FUNCTION_DVLOG(2) << ": " << status;
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
-         state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
+         state_ == STATE_ERROR)
       << state_;
   DCHECK_GT(pending_decode_requests_, 0);
 
   --pending_decode_requests_;
 
   TRACE_EVENT_ASYNC_END0("media", GetTraceString<StreamType>(), this);
 
   if (end_of_stream) {
     DCHECK(!pending_decode_requests_);
     decoding_eos_ = false;
@@ skipping 63 matching lines @@
       return;
   }
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecodeOutputReady(
     const scoped_refptr<Output>& output) {
   FUNCTION_DVLOG(2) << ": " << output->timestamp().InMilliseconds() << " ms";
   DCHECK(output.get());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
-         state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
+         state_ == STATE_ERROR)
       << state_;
 
   if (state_ == STATE_ERROR) {
     DCHECK(read_cb_.is_null());
     return;
   }
 
   // Drop decoding result if Reset() was called during decoding.
   // The resetting process will be handled when the decoder is reset.
   if (!reset_cb_.is_null())
@@ skipping 37 matching lines @@
 
   if (!fallback_buffers_.empty()) {
     scoped_refptr<DecoderBuffer> buffer = fallback_buffers_.front();
     fallback_buffers_.pop_front();
 
     // Decode the buffer without re-appending it to |pending_buffers_|.
     DecodeInternal(buffer);
     return;
   }
 
-  // Set a flag in addition to the state, because the state can be overwritten
-  // when encountering an error. See crbug.com/597605.
-  DCHECK(!pending_demuxer_read_);
+  // We may get here when a read is already pending, ignore this.
+  if (pending_demuxer_read_)
+    return;
+
   pending_demuxer_read_ = true;
-
-  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.get() ? buffer->AsHumanReadableString()
                                      : "NULL");
 
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(pending_demuxer_read_);
   if (decoded_frames_since_fallback_) {
-    DCHECK(state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR)
-        << state_;
+    DCHECK(pending_demuxer_read_ || state_ == STATE_ERROR) << state_;
   } else {
-    DCHECK(state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR ||
-           state_ == STATE_REINITIALIZING_DECODER || state_ == STATE_NORMAL)
+    DCHECK(state_ == STATE_ERROR || state_ == STATE_REINITIALIZING_DECODER ||
+           state_ == STATE_NORMAL)
         << state_;
   }
   DCHECK_EQ(buffer.get() != NULL, status == DemuxerStream::kOk) << status;
-
-  // Unset the flag. STATE_PENDING_DEMUXER_READ might have been overwritten.
-  // See crbug.com/597605.
   pending_demuxer_read_ = false;
 
   // If parallel decode requests are supported, multiple read requests might
   // have been sent to the demuxer. The buffers might arrive while the decoder
   // is reinitializing after falling back on first decode error.
   if (state_ == STATE_REINITIALIZING_DECODER &&
       !decoded_frames_since_fallback_) {
     switch (status) {
       case DemuxerStream::kOk:
         // Save valid buffers to be consumed by the new decoder.
@@ skipping 205 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media