GpuVideoDecoder not to use DemuxerStream after it's stopped.

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/cpu.h"
 #include "base/message_loop.h"
@@ skipping 89 matching lines @@
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (vda_.get())
     DestroyVDA();
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
+  demuxer_stream_ = NULL;
   BindToCurrentLoop(closure).Run();
 }
 
 void GpuVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
       "Media.GpuVideoDecoderInitializeStatus",
       BindToCurrentLoop(orig_status_cb));
@@ skipping 422 matching lines @@
   for (std::map<int32, BufferPair>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     it->second.shm_buffer->shm->Close();
   }
   bitstream_buffers_in_decoder_.clear();
 
   DestroyTextures();
 }
 
+void GpuVideoDecoder::ReadFromDemuxerStream() {
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(demuxer_read_in_progress_);
+
+  // This can happen during the tear-down process. GpuVideoDecoder::Stop()
+  // returns the |pending_read_cb_| immediately without waiting for the demuxer
+  // read to be returned. Therefore, this function could be called even after
+  // the decoder has been stopped.
+  if (!demuxer_stream_) {
+    demuxer_read_in_progress_ = false;
+    return;
+  }
+
+  demuxer_stream_->Read(base::Bind(
+      &GpuVideoDecoder::RequestBufferDecode, this));
+}
+
 void GpuVideoDecoder::EnsureDemuxOrDecode() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (demuxer_read_in_progress_)
     return;
   demuxer_read_in_progress_ = true;
   gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &DemuxerStream::Read, demuxer_stream_.get(),
-      base::Bind(&GpuVideoDecoder::RequestBufferDecode, this)));
+      &GpuVideoDecoder::ReadFromDemuxerStream, this));

[Ami GONE FROM CHROMIUM, 2013/04/04 03:43:22]

Do you see a reason not to simply run the Read() here, instead of posting it?

[xhwang, 2013/04/04 04:15:23]

I think there are two reasons why we always post:
1) DemuxerStream can return the ReadCB synchronously (See
http://crbug.com/168270). 
2) RequestBufferDecode() calls EnsureDemuxOrDecode() directly. If we don't post,
we'd reentry the DS. 

Now (1) is already fixed. (2) seems can be solved by posting
ReadFromDemuxerStream instead of calling it directly. I'll try it out tomorrow
and update this CL.

[xhwang, 2013/04/04 17:05:33]

Done.

 }
 
 void GpuVideoDecoder::NotifyFlushDone() {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::NotifyFlushDone, this));
     return;
   }
   DCHECK_EQ(state_, kDrainingDecoder);
   state_ = kDecoderDrained;
@@ skipping 34 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media