Report VideoDecoder status through ReadCB instead of through FilterHost.

media/filters/video_renderer_base.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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
@@ skipping 341 matching lines @@
   if (state_ == kFlushing) {
     AttemptFlush_Locked();
     return;
   }
 
   if (state_ == kError || state_ == kStopped) {
     DoStopOrError_Locked();
   }
 }
 
-void VideoRendererBase::FrameReady(scoped_refptr<VideoFrame> frame) {
+void VideoRendererBase::FrameReady(VideoDecoder::DecoderStatus status,
+                                   scoped_refptr<VideoFrame> frame) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
+  if (status == VideoDecoder::kDecodeError) {
+    DCHECK(!frame);
+    host()->SetError(PIPELINE_ERROR_DECODE);
+    return;
+  }
+
+  if (status == VideoDecoder::kDecryptError) {
+    DCHECK(!frame);
+    host()->SetError(PIPELINE_ERROR_DECRYPT);
+    return;
+  }
+
+  DCHECK_EQ(status, VideoDecoder::kOk);
+
   // Already-queued Decoder ReadCB's can fire after various state transitions
   // have happened; in that case just drop those frames immediately.
   if (state_ == kStopped || state_ == kError || state_ == kFlushed ||
       state_ == kFlushingDecoder)
     return;
 
   if (state_ == kFlushing) {
     AttemptFlush_Locked();
     return;
   }
@@ skipping 74 matching lines @@
 
 void VideoRendererBase::AttemptRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
 
   if (pending_read_ ||
       NumFrames_Locked() == limits::kMaxVideoFrames ||
       (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream()) ||
       state_ == kFlushingDecoder ||
       state_ == kFlushing) {
-     return;
-   }
+    return;
+  }
 
   pending_read_ = true;
   decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, this));
 }
 
 void VideoRendererBase::OnDecoderFlushDone() {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kFlushingDecoder, state_);
   DCHECK(!pending_read_);
 
@@ skipping 45 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media