Remove VideoDecoder::PrepareForShutdownHack() and friends.

content/renderer/media/rtc_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/rtc_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 using media::VideoDecoder;
 
 RTCVideoDecoder::RTCVideoDecoder(base::TaskRunner* video_decoder_thread,
                                  base::TaskRunner* main_thread,
                                  webrtc::VideoTrackInterface* video_track)
     : video_decoder_thread_(video_decoder_thread),
       main_thread_(main_thread),
       visible_size_(640, 480),
       state_(kUnInitialized),
       got_first_frame_(false),
-      shutting_down_(false),
       video_track_(video_track) {
 }
 
 void RTCVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& status_cb,
                                  const StatisticsCB& statistics_cb) {
   main_thread_->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoDecoder::RegisterToVideoTrack, this));
   if (!video_decoder_thread_->RunsTasksOnCurrentThread()) {
@@ skipping 13 matching lines @@
 void RTCVideoDecoder::Read(const ReadCB& read_cb) {
   if (!video_decoder_thread_->RunsTasksOnCurrentThread()) {
     video_decoder_thread_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::Read, this, read_cb));
     return;
   }
 
   base::AutoLock auto_lock(lock_);
   CHECK(read_cb_.is_null());
+
+  if (state_ == kStopped) {
+    read_cb.Run(kOk, NULL);
+    return;
+  }
+
   read_cb_ = read_cb;
-
-  if (shutting_down_) {
-    video_decoder_thread_->PostTask(FROM_HERE,
-        base::Bind(&RTCVideoDecoder::CancelPendingRead, this));
-  }
 }
 
 void RTCVideoDecoder::Reset(const base::Closure& closure) {
   if (!video_decoder_thread_->RunsTasksOnCurrentThread()) {
     video_decoder_thread_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::Reset, this, closure));
     return;
   }
 
   CancelPendingRead();
   closure.Run();
 }
 
 void RTCVideoDecoder::Stop(const base::Closure& closure) {
   main_thread_->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoDecoder::DeregisterFromVideoTrack, this));
   if (!video_decoder_thread_->RunsTasksOnCurrentThread()) {
     video_decoder_thread_->PostTask(
         FROM_HERE, base::Bind(&RTCVideoDecoder::Stop, this, closure));
     return;
   }
 
   state_ = kStopped;
+  CancelPendingRead();
   closure.Run();
 }
 
-void RTCVideoDecoder::PrepareForShutdownHack() {
-  if (!video_decoder_thread_->RunsTasksOnCurrentThread()) {
-    video_decoder_thread_->PostTask(
-        FROM_HERE, base::Bind(&RTCVideoDecoder::PrepareForShutdownHack,
-                              this));
-    return;
-  }
-  shutting_down_ = true;
-  CancelPendingRead();
-}
-
 void RTCVideoDecoder::SetSize(int width, int height) {
   visible_size_.SetSize(width, height);
 }
 
 // TODO(wjia): this function can be split into two parts so that the |lock_|
 // can be removed.
 // First creates media::VideoFrame, then post a task onto |message_loop_|
 // to deliver that frame.
 void RTCVideoDecoder::RenderFrame(const cricket::VideoFrame* frame) {
   // Called from libjingle thread.
@@ skipping 69 matching lines @@
   DCHECK(main_thread_->RunsTasksOnCurrentThread());
   if (video_track_) {
     video_track_->RemoveRenderer(this);
     video_track_ = NULL;
   }
 }
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DCHECK_NE(kNormal, state_);
 }