Fix hangs & crashes in teardown-during-Seek.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "media/base/data_buffer.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_h264_bitstream_converter.h"
 
 namespace media {
@@ skipping 109 matching lines @@
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   DCHECK(read_queue_.empty()) << "Read requests should be empty";
   buffer_queue_.clear();
 }
 
 void FFmpegDemuxerStream::Stop() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   buffer_queue_.clear();
+  for (ReadQueue::iterator it = read_queue_.begin();
+       it != read_queue_.end(); ++it) {
+    it->Run(new DataBuffer(0));
+  }
   read_queue_.clear();
   stopped_ = true;
 }
 
 base::TimeDelta FFmpegDemuxerStream::duration() {
   return duration_;
 }
 
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   return type_;
@@ skipping 130 matching lines @@
   // TODO(hclam): close the codecs in the corresponding decoders.
   if (!format_context_)
     return;
 
   DestroyAVFormatContext(format_context_);
   format_context_ = NULL;
 }
 
 void FFmpegDemuxer::PostDemuxTask() {
   message_loop_->PostTask(FROM_HERE,
-      base::Bind(&FFmpegDemuxer::DemuxTask, this));
+                          base::Bind(&FFmpegDemuxer::DemuxTask, this));
 }
 
 void FFmpegDemuxer::Stop(const base::Closure& callback) {
   // Post a task to notify the streams to stop as well.
   message_loop_->PostTask(FROM_HERE,
-      base::Bind(&FFmpegDemuxer::StopTask, this, callback));
+                          base::Bind(&FFmpegDemuxer::StopTask, this, callback));
 
   // Then wakes up the thread from reading.
   SignalReadCompleted(DataSource::kReadError);
 }
 
 void FFmpegDemuxer::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   message_loop_->PostTask(FROM_HERE,
-      base::Bind(&FFmpegDemuxer::SeekTask, this, time, cb));
+                          base::Bind(&FFmpegDemuxer::SeekTask, this, time, cb));
 }
 
 void FFmpegDemuxer::SetPlaybackRate(float playback_rate) {
   DCHECK(data_source_.get());
   data_source_->SetPlaybackRate(playback_rate);
 }
 
 void FFmpegDemuxer::SetPreload(Preload preload) {
   DCHECK(data_source_.get());
   data_source_->SetPreload(preload);
 }
 
 void FFmpegDemuxer::OnAudioRendererDisabled() {
-  message_loop_->PostTask(FROM_HERE,
-      base::Bind(&FFmpegDemuxer::DisableAudioStreamTask, this));
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &FFmpegDemuxer::DisableAudioStreamTask, this));
 }
 
 void FFmpegDemuxer::set_host(FilterHost* filter_host) {
   Demuxer::set_host(filter_host);
   if (data_source_)
     data_source_->set_host(filter_host);
   if (max_duration_.InMicroseconds() >= 0)
     host()->SetDuration(max_duration_);
   if (read_position_ > 0)
     host()->SetCurrentReadPosition(read_position_);
@@ skipping 134 matching lines @@
   base::TimeDelta max_duration;
   const bool kDemuxerIsWebm = !strcmp("webm", format_context_->iformat->name);
   bool no_supported_streams = true;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
     AVMediaType codec_type = codec_context->codec_type;
     if (codec_type == AVMEDIA_TYPE_AUDIO || codec_type == AVMEDIA_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       // WebM is currently strictly VP8 and Vorbis.
       if (kDemuxerIsWebm && (stream->codec->codec_id != CODEC_ID_VP8 &&
-        stream->codec->codec_id != CODEC_ID_VORBIS)) {
+                             stream->codec->codec_id != CODEC_ID_VORBIS)) {
         packet_streams_.push_back(NULL);
         continue;
       }
 
       scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
           new FFmpegDemuxerStream(this, stream));
       if (!streams_[demuxer_stream->type()]) {
         no_supported_streams = false;
         streams_[demuxer_stream->type()] = demuxer_stream;
         max_duration = std::max(max_duration, demuxer_stream->duration());
 
         if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
           const base::TimeDelta first_dts = ConvertFromTimeBase(
-            stream->time_base, stream->first_dts);
+              stream->time_base, stream->first_dts);
           if (start_time_ == kNoTimestamp || first_dts < start_time_)
             start_time_ = first_dts;
         }
       }
       packet_streams_.push_back(demuxer_stream);
     } else {
       packet_streams_.push_back(NULL);
     }
   }
   if (no_supported_streams) {
@@ skipping 214 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media