Fold {Audio|Video}Decoder::Stop() into the dtor.

media/filters/fake_video_decoder.cc

 // Copyright 2013 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/fake_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/test_helpers.h"
 
 namespace media {
 
 FakeVideoDecoder::FakeVideoDecoder(int decoding_delay,
                                    int max_parallel_decoding_requests)
     : decoding_delay_(decoding_delay),
       max_parallel_decoding_requests_(max_parallel_decoding_requests),
       state_(STATE_UNINITIALIZED),
       hold_decode_(false),
       total_bytes_decoded_(0),
       weak_factory_(this) {
   DCHECK_GE(decoding_delay, 0);
 }
 
 FakeVideoDecoder::~FakeVideoDecoder() {
-  DCHECK_EQ(state_, STATE_UNINITIALIZED);
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (state_ == STATE_UNINITIALIZED)
+    return;
+
+  if (!init_cb_.IsNull())
+    SatisfyInit();
+  if (!held_decode_callbacks_.empty())
+    SatisfyDecode();
+  if (!reset_cb_.IsNull())
+    SatisfyReset();
+
+  decoded_frames_.clear();
 }
 
 void FakeVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                   bool low_delay,
                                   const PipelineStatusCB& status_cb,
                                   const OutputCB& output_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(config.IsValidConfig());
   DCHECK(held_decode_callbacks_.empty())
       << "No reinitialization during pending decode.";
@@ skipping 18 matching lines @@
 void FakeVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                               const DecodeCB& decode_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(reset_cb_.IsNull());
   DCHECK_LE(decoded_frames_.size(),
             decoding_delay_ + held_decode_callbacks_.size());
   DCHECK_LT(static_cast<int>(held_decode_callbacks_.size()),
             max_parallel_decoding_requests_);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
-  DecodeCB wrapped_decode_cb =
-      BindToCurrentLoop(base::Bind(&FakeVideoDecoder::OnFrameDecoded,
-                                   weak_factory_.GetWeakPtr(),
-                                   buffer_size, decode_cb));
+  DecodeCB wrapped_decode_cb = base::Bind(&FakeVideoDecoder::OnFrameDecoded,
+                                          weak_factory_.GetWeakPtr(),
+                                          buffer_size,
+                                          BindToCurrentLoop(decode_cb));
 
   if (state_ == STATE_ERROR) {
     wrapped_decode_cb.Run(kDecodeError);
     return;
   }
 
   if (buffer->end_of_stream()) {
     state_ = STATE_END_OF_STREAM;
   } else {
     DCHECK(VerifyFakeVideoBufferForTest(buffer, current_config_));
@@ skipping 12 matching lines @@
   reset_cb_.SetCallback(BindToCurrentLoop(closure));
   decoded_frames_.clear();
 
   // Defer the reset if a decode is pending.
   if (!held_decode_callbacks_.empty())
     return;
 
   DoReset();
 }
 
-void FakeVideoDecoder::Stop() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!init_cb_.IsNull())
-    SatisfyInit();
-  if (!held_decode_callbacks_.empty())
-    SatisfyDecode();
-  if (!reset_cb_.IsNull())
-    SatisfyReset();
-
-  decoded_frames_.clear();
-  state_ = STATE_UNINITIALIZED;
-}
-
 void FakeVideoDecoder::HoldNextInit() {
   DCHECK(thread_checker_.CalledOnValidThread());
   init_cb_.HoldCallback();
 }
 
 void FakeVideoDecoder::HoldDecode() {
   DCHECK(thread_checker_.CalledOnValidThread());
   hold_decode_ = true;
 }
 
@@ skipping 109 matching lines @@
 
 void FakeVideoDecoder::DoReset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(held_decode_callbacks_.empty());
   DCHECK(!reset_cb_.IsNull());
 
   reset_cb_.RunOrHold();
 }
 
 }  // namespace media