Fix flow control in media::DecoderBase

media/filters/decoder_base.h

 // Copyright (c) 2010 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 190 matching lines @@
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
 
     // TODO(scherkus): should reply with a null operation (empty buffer).
     if (IsStopped()) {
       delete read_callback;
       return;
     }
 
     // Enqueue the callback and attempt to fulfill it immediately.
     read_queue_.push_back(read_callback);
-    FulfillPendingRead();
+    if (FulfillPendingRead())
+      return;
 
-    // Issue reads as necessary.
-    while (pending_reads_ < read_queue_.size()) {
-      demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
-      ++pending_reads_;
-    }
+    // Since we can't fulfill a read request now then submit a read
+    // request to the demuxer stream.
+    demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
+    ++pending_reads_;
   }
 
   void ReadCompleteTask(scoped_refptr<Buffer> buffer) {
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
     DCHECK_GT(pending_reads_, 0u);
     --pending_reads_;
     if (IsStopped()) {
       return;
     }
 
     // TODO(scherkus): remove this when we're less paranoid about our seeking
     // invariants.
     if (buffer->IsDiscontinuous()) {
       DCHECK(expecting_discontinuous_);
       expecting_discontinuous_ = false;
     }
 
     // Decode the frame right away.
     DoDecode(buffer, NewRunnableMethod(this, &DecoderBase::OnDecodeComplete));
   }
 
   void OnDecodeComplete() {
     // Attempt to fulfill a pending read callback and schedule additional reads
     // if necessary.
-    FulfillPendingRead();
+    bool fulfilled = FulfillPendingRead();
 
     // Issue reads as necessary.
     //
     // Note that it's possible for us to decode but not produce a frame, in
     // which case |pending_reads_| will remain less than |read_queue_| so we
     // need to schedule an additional read.
-    // TODO(hclam): Enable this line again to make sure we don't break the
-    // flow control. (BUG=32947)
-    // DCHECK_LE(pending_reads_, read_queue_.size());
-    while (pending_reads_ < read_queue_.size()) {
+    DCHECK_LE(pending_reads_, read_queue_.size());
+    if (!fulfilled) {
+      DCHECK_LT(pending_reads_, read_queue_.size());
       demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
       ++pending_reads_;
     }
   }
 
   // Attempts to fulfill a single pending read by dequeuing a buffer and read
   // callback pair and executing the callback.
-  void FulfillPendingRead() {
+  //
+  // Return true if one read request is fulfilled.
+  bool FulfillPendingRead() {
     DCHECK_EQ(MessageLoop::current(), this->message_loop());
     if (read_queue_.empty() || result_queue_.empty()) {
-      return;
+      return false;
     }
 
     // Dequeue a frame and read callback pair.
     scoped_refptr<Output> output = result_queue_.front();
     scoped_ptr<ReadCallback> read_callback(read_queue_.front());
     result_queue_.pop_front();
     read_queue_.pop_front();
 
     // Execute the callback!
     read_callback->Run(output);
+    return true;
   }
 
   // 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_;
 
   // A flag used for debugging that we expect our next read to be discontinuous.
   bool expecting_discontinuous_;
 
   // Pointer to the demuxer stream that will feed us compressed buffers.
@@ skipping 24 matching lines @@
     kStopped,
   };
   State state_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_DECODER_BASE_H_