Fix a bug in audio/video decoder that the stopped variable is not initialized...

media/filters/decoder_base.h

 // Copyright (c) 2009 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.
 
 // A base class that provides the plumbing for a decoder filters.
 
 #ifndef MEDIA_FILTERS_DECODER_BASE_H_
 #define MEDIA_FILTERS_DECODER_BASE_H_
 
 #include <deque>
@@ skipping 62 matching lines @@
     DCHECK(state_ == UNINITIALIZED || state_ == STOPPED);
     DCHECK(result_queue_.empty());
     DCHECK(read_queue_.empty());
   }
 
   // This method is called by the derived class from within the OnDecode method.
   // It places an output buffer in the result queue.  It must be called from
   // within the OnDecode method.
   void EnqueueResult(Output* output) {
     DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
-    if (!stopped_) {
+    if (!IsStopped()) {
       result_queue_.push_back(output);
     }
   }
 
   // Method that must be implemented by the derived class.  Called from within
   // the DecoderBase::Initialize() method before any reads are submitted to
   // the demuxer stream.  Returns true if successful, otherwise false indicates
   // a fatal error.  The derived class should NOT call the filter host's
   // InitializationComplete() method.  If this method returns true, then the
   // base class will call the host to complete initialization.  During this
@@ skipping 21 matching lines @@
 
   MediaFormat media_format_;
 
  private:
   // GCC doesn't let us access superclass member variables directly, so use
   // a helper to get around the situation.
   //
   // TODO(scherkus): another reason to add protected accessors to MediaFilter.
   FilterHost* host() const { return Decoder::host_; }
   MessageLoop* message_loop() const { return Decoder::message_loop_; }
+  bool IsStopped() { return state_ == STOPPED; }
 
   void StopTask() {
     DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
     // Delegate to the subclass first.
     OnStop();
 
     // Throw away all buffers in all queues.
     result_queue_.clear();
     STLDeleteElements(&read_queue_);
     state_ = STOPPED;
@@ skipping 29 matching lines @@
 
     // TODO(scherkus): subclass shouldn't mutate superclass media format.
     DCHECK(!media_format_.empty()) << "Subclass did not set media_format_";
     state_ = INITIALIZED;
     host()->InitializationComplete();
   }
 
   void ReadTask(ReadCallback* read_callback) {
     DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
     // TODO(scherkus): should reply with a null operation (empty buffer).
-    if (stopped_) {
+    if (IsStopped()) {
       delete read_callback;
       return;
     }
 
     // Enqueue the callback and attempt to fulfill it immediately.
     read_queue_.push_back(read_callback);
     FulfillPendingRead();
 
     // Issue reads as necessary.
     while (pending_reads_ < read_queue_.size()) {
       demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
       ++pending_reads_;
     }
   }
 
   void ReadCompleteTask(scoped_refptr<Buffer> buffer) {
     DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
     DCHECK_GT(pending_reads_, 0u);
     --pending_reads_;
-    if (stopped_) {
+    if (IsStopped()) {
       return;
     }
 
     // Once the |seeking_| flag is set we ignore every buffers here
     // until we receive a discontinuous buffer and we will turn off the
     // |seeking_| flag.
     if (buffer->IsDiscontinuous()) {
       // TODO(hclam): put a DCHECK here to assert |seeking_| being true.
       // I cannot do this now because seek operation is not fully
       // asynchronous. There may be pending seek requests even before the
@@ skipping 38 matching lines @@
     read_queue_.pop_front();
 
     // Execute the callback!
     read_callback->Run(output);
   }
 
   // Tracks the number of asynchronous reads issued to |demuxer_stream_|.
   // Using size_t since it is always compared against deque::size().
   size_t pending_reads_;
 
-  // If true, then Stop() has been called and no further processing of buffers
-  // should occur.
-  bool stopped_;
-
   // An internal state of the decoder that indicates that are waiting for seek
   // to complete. We expect to receive a discontinuous frame/packet from the
   // demuxer to signal that seeking is completed.
   bool seeking_;
 
   // Pointer to the demuxer stream that will feed us compressed buffers.
   scoped_refptr<DemuxerStream> demuxer_stream_;
 
   // Queue of decoded samples produced in the OnDecode() method of the decoder.
   // Any samples placed in this queue will be assigned to the OutputQueue
@@ skipping 20 matching lines @@
 
   // Used for debugging.
   PlatformThreadId thread_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_DECODER_BASE_H_