Reland r212023 "Rename VideoDecoder::ReadCB to VideoDecoder::DecodeCB."

media/filters/video_frame_stream.cc

 // Copyright (c) 2013 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/video_frame_stream.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 36 matching lines @@
   statistics_cb_ = statistics_cb;
   init_cb_ = init_cb;
   stream_ = stream;
 
   state_ = STATE_INITIALIZING;
   // TODO(xhwang): VideoDecoderSelector only needs a config to select a decoder.
   decoder_selector_->SelectVideoDecoder(
       stream, base::Bind(&VideoFrameStream::OnDecoderSelected, weak_this_));
 }
 
-void VideoFrameStream::Read(const VideoDecoder::ReadCB& read_cb) {
+void VideoFrameStream::Read(const ReadCB& read_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR) << 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) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        read_cb, VideoDecoder::kDecodeError, scoped_refptr<VideoFrame>()));
+        read_cb, DECODE_ERROR, scoped_refptr<VideoFrame>()));
     return;
   }
 
   read_cb_ = read_cb;
 
   if (state_ == STATE_FLUSHING_DECODER) {
     FlushDecoder();
     return;
   }
 
@@ skipping 101 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(true, decoder_->HasAlpha());
   }
 
   // Stop() called during initialization.
   if (!stop_cb_.is_null()) {
     Stop(base::ResetAndReturn(&stop_cb_));
     return;
   }
 }
 
-void VideoFrameStream::SatisfyRead(VideoDecoder::Status status,
+void VideoFrameStream::SatisfyRead(Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   DCHECK(!read_cb_.is_null());
   base::ResetAndReturn(&read_cb_).Run(status, frame);
 }
 
 void VideoFrameStream::AbortRead() {
-  SatisfyRead(VideoDecoder::kOk, NULL);
+  SatisfyRead(ABORTED, NULL);
 }
 
 void VideoFrameStream::Decode(const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
   DCHECK(!read_cb_.is_null());
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
   DCHECK(buffer);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
   decoder_->Decode(buffer, base::Bind(&VideoFrameStream::OnFrameReady,
                                       weak_this_, buffer_size));
 }
 
 void VideoFrameStream::FlushDecoder() {
   Decode(DecoderBuffer::CreateEOSBuffer());
 }
 
 void VideoFrameStream::OnFrameReady(int buffer_size,
                                     const VideoDecoder::Status status,
                                     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
   DCHECK(!read_cb_.is_null());
 
-  if (status == VideoDecoder::kDecodeError ||
-      status == VideoDecoder::kDecryptError) {
+  if (status == VideoDecoder::kDecodeError) {
     DCHECK(!frame.get());
     state_ = STATE_ERROR;
-    SatisfyRead(status, NULL);
+    SatisfyRead(DECODE_ERROR, NULL);
     return;
   }
 
+  if (status == VideoDecoder::kDecryptError) {
+    DCHECK(!frame.get());
+    state_ = STATE_ERROR;
+    SatisfyRead(DECRYPT_ERROR, NULL);
+    return;
+  }
+
   // Any successful decode counts!
   if (buffer_size > 0) {
     PipelineStatistics statistics;
     statistics.video_bytes_decoded = buffer_size;
     statistics_cb_.Run(statistics);
   }
 
   // Drop decoding result if Reset()/Stop() was called during decoding.
   // The stopping/resetting process will be handled when the decoder is
   // stopped/reset.
@@ skipping 10 matching lines @@
   }
 
   if (status == VideoDecoder::kNotEnoughData) {
     if (state_ == STATE_NORMAL)
       ReadFromDemuxerStream();
     else if (state_ == STATE_FLUSHING_DECODER)
       FlushDecoder();
     return;
   }
 
-  SatisfyRead(status, frame);
+  SatisfyRead(OK, frame);
 }
 
 void VideoFrameStream::ReadFromDemuxerStream() {
   DCHECK_EQ(state_, STATE_NORMAL) << state_;
   DCHECK(!read_cb_.is_null());
   DCHECK(reset_cb_.is_null());
   DCHECK(stop_cb_.is_null());
 
   state_ = STATE_PENDING_DEMUXER_READ;
   stream_->Read(base::Bind(&VideoFrameStream::OnBufferReady, weak_this_));
@@ skipping 32 matching lines @@
     return;
   }
 
   if (!reset_cb_.is_null()) {
     AbortRead();
     Reset(base::ResetAndReturn(&reset_cb_));
     return;
   }
 
   if (status == DemuxerStream::kAborted) {
-    AbortRead();
+    SatisfyRead(DEMUXER_READ_ABORTED, NULL);
     return;
   }
 
   DCHECK(status == DemuxerStream::kOk) << status;
   Decode(buffer);
 }
 
 void VideoFrameStream::ReinitializeDecoder() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_FLUSHING_DECODER) << state_;
@@ skipping 22 matching lines @@
 
   if (!reset_cb_.is_null())
     base::ResetAndReturn(&reset_cb_).Run();
 
   // If !stop_cb_.is_null(), it will be handled in OnDecoderStopped().
 
   if (read_cb_.is_null())
     return;
 
   if (!stop_cb_.is_null()) {
-    base::ResetAndReturn(&read_cb_).Run(VideoDecoder::kOk, NULL);
+    base::ResetAndReturn(&read_cb_).Run(ABORTED, NULL);
     return;
   }
 
   if (state_ == STATE_ERROR) {
-    SatisfyRead(VideoDecoder::kDecodeError, NULL);
+    SatisfyRead(DECODE_ERROR, NULL);
     return;
   }
 
   ReadFromDemuxerStream();
 }
 
 void VideoFrameStream::ResetDecoder() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR) << state_;
@@ skipping 38 matching lines @@
   DCHECK(!stop_cb_.is_null());
 
   state_ = STATE_STOPPED;
   stream_ = NULL;
   decoder_.reset();
   decrypting_demuxer_stream_.reset();
   base::ResetAndReturn(&stop_cb_).Run();
 }
 
 }  // namespace media