Report VideoDecoder status through ReadCB instead of through FilterHost.

media/filters/ffmpeg_video_decoder.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/ffmpeg_video_decoder.h"
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
@@ skipping 187 matching lines @@
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   // This can happen during shutdown after Stop() has been called.
   if (state_ == kUninitialized) {
     return;
   }
 
   // Return empty frames if decoding has finished.
   if (state_ == kDecodeFinished) {
-    read_cb.Run(VideoFrame::CreateEmptyFrame());
+    read_cb.Run(VideoFrame::CreateEmptyFrame(), kOk);
     return;
   }
 
   read_cb_ = read_cb;
   ReadFromDemuxerStream();
 }
 
 
 void FFmpegVideoDecoder::ReadFromDemuxerStream() {
   DCHECK_NE(state_, kUninitialized);
@@ skipping 55 matching lines @@
   // Transition to kFlushCodec on the first end of stream buffer.
   if (state_ == kNormal && buffer->IsEndOfStream()) {
     state_ = kFlushCodec;
   }
 
   scoped_refptr<Buffer> unencrypted_buffer = buffer;
   if (buffer->GetDecryptConfig() && buffer->GetDataSize()) {
     unencrypted_buffer = decryptor_.Decrypt(buffer);
     if (!unencrypted_buffer || !unencrypted_buffer->GetDataSize()) {
       state_ = kDecodeFinished;
-      DeliverFrame(VideoFrame::CreateEmptyFrame());
-      host()->SetError(PIPELINE_ERROR_DECRYPT);
+      base::ResetAndReturn(&read_cb_).Run(NULL, kDecryptError);
       return;
     }
   }
 
   scoped_refptr<VideoFrame> video_frame;
   if (!Decode(unencrypted_buffer, &video_frame)) {
     state_ = kDecodeFinished;
-    DeliverFrame(VideoFrame::CreateEmptyFrame());
-    host()->SetError(PIPELINE_ERROR_DECODE);
+    base::ResetAndReturn(&read_cb_).Run(NULL, kDecodeError);
     return;
   }
 
   // Any successful decode counts!
   if (buffer->GetDataSize()) {
     PipelineStatistics statistics;
     statistics.video_bytes_decoded = buffer->GetDataSize();
     statistics_cb_.Run(statistics);
   }
 
@@ skipping 104 matching lines @@
   CopyYPlane(av_frame_->data[0], av_frame_->linesize[0], y_rows, *video_frame);
   CopyUPlane(av_frame_->data[1], av_frame_->linesize[1], uv_rows, *video_frame);
   CopyVPlane(av_frame_->data[2], av_frame_->linesize[2], uv_rows, *video_frame);
 
   return true;
 }
 
 void FFmpegVideoDecoder::DeliverFrame(
     const scoped_refptr<VideoFrame>& video_frame) {
   // Reset the callback before running to protect against reentrancy.
-  ReadCB read_cb = read_cb_;
-  read_cb_.Reset();
-  read_cb.Run(video_frame);
+  base::ResetAndReturn(&read_cb_).Run(video_frame, kOk);
 }
 
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
     codec_context_ = NULL;
   }
   if (av_frame_) {
     av_free(av_frame_);
     av_frame_ = NULL;
   }
 }
 
 scoped_refptr<VideoFrame> FFmpegVideoDecoder::AllocateVideoFrame() {
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context_->pix_fmt);
   size_t width = codec_context_->width;
   size_t height = codec_context_->height;
 
   return VideoFrame::CreateFrame(format, width, height,
                                  kNoTimestamp(), kNoTimestamp());
 }
 
 }  // namespace media