Fix dropped demuxer buffers for fallback decoder

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 318 matching lines @@
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Decode(
     const scoped_refptr<DecoderBuffer>& buffer) {
   FUNCTION_DVLOG(2);
 
   // We don't know if the decoder will error out on first decode yet. Save the
   // buffer to feed it to the fallback decoder later if needed.
   if (!decoded_frames_since_fallback_)
     pending_buffers_.push_back(buffer);
 
-  DecodeInternal(buffer);
+  // It's possible for a buffer to arrive from the demuxer right after the
+  // fallback decoder successfully completed its initialization. At this point
+  // |pending_buffers_| has already been copied to |fallback_buffers_| and we
+  // need to append it ourselves.
+  if (!fallback_buffers_.empty()) {
+    fallback_buffers_.push_back(buffer);
+
+    scoped_refptr<DecoderBuffer> temp = fallback_buffers_.front();
+    fallback_buffers_.pop_front();
+    DecodeInternal(temp);
+  } else {
+    DecodeInternal(buffer);
+  }
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::DecodeInternal(
     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(buffer.get());
@@ skipping 181 matching lines @@
 
 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_;
   } else {
     DCHECK(state_ == STATE_PENDING_DEMUXER_READ || state_ == STATE_ERROR ||
-           STATE_REINITIALIZING_DECODER)
+           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
@@ skipping 17 matching lines @@
         break;
       case DemuxerStream::kAborted:
         // |this| will read from the demuxer stream again in OnDecoderSelected()
         // and receive a kAborted then.
         pending_buffers_.clear();
         break;
     }
     return;
   }
 
-  // Decoding has been stopped (e.g due to an error).
-  if (state_ != STATE_PENDING_DEMUXER_READ) {
-    DCHECK(state_ == STATE_ERROR);
+  // Decoding has been stopped.
+  if (state_ == STATE_ERROR) {
     DCHECK(read_cb_.is_null());
 
     if (!reset_cb_.is_null()) {
       // If we are using DecryptingDemuxerStream, we already called DDS::Reset()
       // which will continue the resetting process in its callback.
       if (!decrypting_demuxer_stream_)
         Reset(base::ResetAndReturn(&reset_cb_));
     }
     return;
   }
@@ skipping 172 matching lines @@
   }
 
   // The resetting process will be continued in OnDecoderReinitialized().
   ReinitializeDecoder();
 }
 
 template class DecoderStream<DemuxerStream::VIDEO>;
 template class DecoderStream<DemuxerStream::AUDIO>;
 
 }  // namespace media