Remove VideoDecoder::PrepareForShutdownHack() and friends.

content/renderer/media/capture_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 "content/renderer/media/capture_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/limits.h"
 #include "media/base/video_util.h"
 
 using media::CopyYPlane;
 using media::CopyUPlane;
 using media::CopyVPlane;
 
 CaptureVideoDecoder::CaptureVideoDecoder(
     base::MessageLoopProxy* message_loop_proxy,
     media::VideoCaptureSessionId video_stream_id,
     VideoCaptureImplManager* vc_manager,
     const media::VideoCaptureCapability& capability)
     : message_loop_proxy_(message_loop_proxy),
       vc_manager_(vc_manager),
       capability_(capability),
       natural_size_(capability.width, capability.height),
       state_(kUnInitialized),
       got_first_frame_(false),
-      shutting_down_(false),
       video_stream_id_(video_stream_id),
       capture_engine_(NULL) {
   DCHECK(vc_manager);
 }
 
 void CaptureVideoDecoder::Initialize(
     const scoped_refptr<media::DemuxerStream>& stream,
     const media::PipelineStatusCB& status_cb,
     const media::StatisticsCB& statistics_cb) {
   message_loop_proxy_->PostTask(
@@ skipping 14 matching lines @@
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::ResetOnDecoderThread, this, closure));
 }
 
 void CaptureVideoDecoder::Stop(const base::Closure& closure) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::StopOnDecoderThread, this, closure));
 }
 
-void CaptureVideoDecoder::PrepareForShutdownHack() {
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&CaptureVideoDecoder::PrepareForShutdownHackOnDecoderThread,
-                 this));
-}
-
 void CaptureVideoDecoder::OnStarted(media::VideoCapture* capture) {
   NOTIMPLEMENTED();
 }
 
 void CaptureVideoDecoder::OnStopped(media::VideoCapture* capture) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::OnStoppedOnDecoderThread,
                  this, capture));
 }
@@ skipping 51 matching lines @@
   status_cb.Run(media::PIPELINE_OK);
   state_ = kNormal;
   capture_engine_->StartCapture(this, capability_);
 }
 
 void CaptureVideoDecoder::ReadOnDecoderThread(const ReadCB& read_cb) {
   DCHECK_NE(state_, kUnInitialized);
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   CHECK(read_cb_.is_null());
   read_cb_ = read_cb;
-  if (state_ == kPaused || shutting_down_) {
+  if (state_ == kPaused || state_ == kStopped) {
     DeliverFrame(media::VideoFrame::CreateEmptyFrame());
   }
 }
 
 void CaptureVideoDecoder::ResetOnDecoderThread(const base::Closure& closure) {
   DVLOG(1) << "ResetOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   if (!read_cb_.is_null()) {
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateBlackFrame(natural_size_);
     DeliverFrame(video_frame);
   }
   closure.Run();
 }
 
 void CaptureVideoDecoder::StopOnDecoderThread(const base::Closure& closure) {
   DVLOG(1) << "StopOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   pending_stop_cb_ = closure;
   state_ = kStopped;
+
+  if (!read_cb_.is_null())
+    DeliverFrame(media::VideoFrame::CreateEmptyFrame());
+
   capture_engine_->StopCapture(this);
 }
 
-void CaptureVideoDecoder::PrepareForShutdownHackOnDecoderThread() {
-  DVLOG(1) << "PrepareForShutdownHackOnDecoderThread";
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  shutting_down_ = true;
-  if (!read_cb_.is_null()) {
-    DeliverFrame(media::VideoFrame::CreateEmptyFrame());
-  }
-}
-
 void CaptureVideoDecoder::OnStoppedOnDecoderThread(
     media::VideoCapture* capture) {
   DVLOG(1) << "OnStoppedOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   if (!pending_stop_cb_.is_null())
     base::ResetAndReturn(&pending_stop_cb_).Run();
   vc_manager_->RemoveDevice(video_stream_id_, this);
 }
 
 void CaptureVideoDecoder::OnPausedOnDecoderThread(
@@ skipping 72 matching lines @@
 
   DeliverFrame(video_frame);
   capture->FeedBuffer(buf);
 }
 
 void CaptureVideoDecoder::DeliverFrame(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   // Reset the callback before running to protect against reentrancy.
   base::ResetAndReturn(&read_cb_).Run(kOk, video_frame);
 }