Fix hangs & crashes in teardown-during-Seek.

media/filters/video_renderer_base.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/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 20 matching lines @@
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_reads_(0),
       pending_paint_(false),
       pending_paint_with_last_available_(false),
       playback_rate_(0) {
 }
 
 VideoRendererBase::~VideoRendererBase() {
   base::AutoLock auto_lock(lock_);
-  DCHECK(state_ == kUninitialized || state_ == kStopped);
+  DCHECK(state_ == kUninitialized || state_ == kStopped) << state_;
 }
 
 void VideoRendererBase::Play(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
 void VideoRendererBase::Pause(const base::Closure& callback) {
@@ skipping 36 matching lines @@
 
   // Signal the subclass we're stopping.
   OnStop(callback);
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
-void VideoRendererBase::Seek(base::TimeDelta time, const FilterStatusCB&  cb) {
+void VideoRendererBase::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   bool run_callback = false;
 
   {
     base::AutoLock auto_lock(lock_);
     // There is a race condition between filters to receive SeekTask().
     // It turns out we could receive buffer from decoder before seek()
     // is called on us. so we do the following:
     // kFlushed => ( Receive first buffer or Seek() ) => kSeeking and
     // kSeeking => ( Receive enough buffers) => kPrerolled. )
     DCHECK(state_ == kPrerolled || state_ == kFlushed || state_ == kSeeking);
     DCHECK(!cb.is_null());
     DCHECK(seek_cb_.is_null());
 
     if (state_ == kPrerolled) {
       // Already get enough buffers from decoder.
       run_callback = true;
-
     } else {
       // Otherwise we are either kFlushed or kSeeking, but without enough
       // buffers we should save the callback function and call it later.
       state_ = kSeeking;
       seek_cb_ = cb;
     }
 
     seek_timestamp_ = time;
     ScheduleRead_Locked();
   }
@@ skipping 464 matching lines @@
 void VideoRendererBase::DoStopOrErrorFlush_Locked() {
   DCHECK(!pending_paint_);
   DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
   FlushBuffers_Locked();
   last_available_frame_ = NULL;
   DCHECK_EQ(pending_reads_, 0);
 }
 
 }  // namespace media