Report VideoDecoder status through ReadCB instead of through FilterHost.

media/filters/gpu_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/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 35 matching lines @@
     MessageLoop* vda_loop,
     const scoped_refptr<Factories>& factories)
     : gvd_loop_proxy_(message_loop->message_loop_proxy()),
       vda_loop_proxy_(vda_loop->message_loop_proxy()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
-      shutting_down_(false) {
+      shutting_down_(false),
+      pending_error_count_(0) {
   DCHECK(gvd_loop_proxy_ && factories_);
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DCHECK(!vda_);  // Stop should have been already called.
   DCHECK(pending_read_cb_.is_null());
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     available_shm_segments_[i]->shm->Close();
     delete available_shm_segments_[i];
   }
@@ skipping 118 matching lines @@
   status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::Read(const ReadCB& read_cb) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Read, this, read_cb));
     return;
   }
 
+  CHECK_GE(pending_error_count_, 0);

[Ami GONE FROM CHROMIUM, 2012/04/27 16:49:14]

unnecessary, IMO

[xhwang, 2012/04/27 23:22:30]

Done.

+  if (pending_error_count_ > 0) {
+    read_cb.Run(NULL, kDecodeError);
+    pending_error_count_--;

[scherkus (not reviewing), 2012/04/27 18:27:56]

fischman: is there a case where we'd report an error on one read, but have
subsequent reads successfully complete?

in other words, should we replace pending_error_count_ with a flag that puts
GpuVD into lame duck mode and always reports read errors?

[Ami GONE FROM CHROMIUM, 2012/04/27 18:31:16]

No; pending_error_count_ only goes positive when NotifyError is called, past
which vda_ is NULL.
I like it!

[xhwang, 2012/04/27 23:22:30]

Done.

[xhwang, 2012/04/27 23:22:30]

Done.

+    return;
+  }
+
   if (!vda_) {
-    read_cb.Run(VideoFrame::CreateEmptyFrame());
+    read_cb.Run(VideoFrame::CreateEmptyFrame(), kOk);
     return;
   }
 
   DCHECK(pending_reset_cb_.is_null());
   DCHECK(pending_read_cb_.is_null());
   pending_read_cb_ = read_cb;
 
   if (!ready_video_frames_.empty()) {
     EnqueueFrameAndTriggerFrameDelivery(NULL);
     return;
@@ skipping 19 matching lines @@
         &GpuVideoDecoder::RequestBufferDecode, this, buffer));
     return;
   }
   demuxer_read_in_progress_ = false;
 
   if (!buffer) {
     if (pending_read_cb_.is_null())
       return;
 
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        pending_read_cb_, scoped_refptr<VideoFrame>()));
+        pending_read_cb_, scoped_refptr<VideoFrame>(), kOk));
     pending_read_cb_.Reset();
     return;
   }
 
   if (!vda_) {
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
     return;
   }
 
   if (buffer->IsEndOfStream()) {
@@ skipping 161 matching lines @@
 
   if (frame)
     ready_video_frames_.push_back(frame);
   else
     DCHECK(!ready_video_frames_.empty());
 
   if (pending_read_cb_.is_null())
     return;
 
   gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      pending_read_cb_, ready_video_frames_.front()));
+      pending_read_cb_, ready_video_frames_.front(), kOk));
   pending_read_cb_.Reset();
   ready_video_frames_.pop_front();
 }
 
 void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::ReusePictureBuffer, this, picture_buffer_id));
     return;
   }
@@ skipping 100 matching lines @@
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::NotifyError, this, error));
     return;
   }
   if (!vda_)
     return;
   vda_ = NULL;
   DLOG(ERROR) << "VDA Error: " << error;
-  if (host())
-    host()->SetError(PIPELINE_ERROR_DECODE);
+
+  if (!pending_read_cb_.is_null()) {
+    base::ResetAndReturn(&pending_read_cb_).Run(NULL, kDecodeError);
+    return;
+  }
+
+  CHECK_GE(pending_error_count_, 0);

[Ami GONE FROM CHROMIUM, 2012/04/27 16:49:14]

unnecessary.

[xhwang, 2012/04/27 23:22:30]

Done.

+  pending_error_count_++;
 }
 
 }  // namespace media