Remove VideoDecoder::PrepareForShutdownHack() and friends.

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 38 matching lines @@
     const scoped_refptr<Factories>& factories)
     : message_loop_factory_cb_(message_loop_factory_cb),
       gvd_loop_proxy_(NULL),
       vda_loop_proxy_(vda_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),
       error_occured_(false) {
   DCHECK(!message_loop_factory_cb_.is_null());
   DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   if (!gvd_loop_proxy_->BelongsToCurrentThread() ||
       state_ == kDrainingDecoder) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, this, closure));
     return;
   }
 
   // Throw away any already-decoded, not-yet-delivered frames.
   ready_video_frames_.clear();
 
   if (!vda_.get()) {
     closure.Run();
     return;
   }
 
   DCHECK(pending_reset_cb_.is_null());
   DCHECK(!closure.is_null());
 
   // VideoRendererBase::Flush() can't complete while it has a pending read to
   // us, so we fulfill such a read here.
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 
-  if (shutting_down_) {
-    // Immediately fire the callback instead of waiting for the reset to
-    // complete (which will happen after PipelineImpl::Stop() completes).
-    gvd_loop_proxy_->PostTask(FROM_HERE, closure);
-  } else {
-    pending_reset_cb_ = closure;
-  }
-
+  pending_reset_cb_ = closure;
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Reset, weak_vda_));
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Stop, this, closure));
     return;
   }
@@ skipping 195 matching lines @@
     *natural_size = it->natural_size;
     return;
   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
 }
 
 bool GpuVideoDecoder::HasAlpha() const {
   return true;
 }
 
-void GpuVideoDecoder::PrepareForShutdownHack() {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::PrepareForShutdownHack, this));
-    return;
-  }
-  shutting_down_ = true;
-}
-
 void GpuVideoDecoder::NotifyInitializeDone() {
   NOTREACHED() << "GpuVideoDecodeAcceleratorHost::Initialize is synchronous!";
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size,
                                             uint32 texture_target) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::ProvidePictureBuffers, this, count, size,
@@ skipping 231 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media