Add status parameter to DemuxerStream::ReadCB

media/filters/ffmpeg_demuxer.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 "media/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 107 matching lines @@
   buffer_queue_.clear();
   last_packet_timestamp_ = kNoTimestamp();
 }
 
 void FFmpegDemuxerStream::Stop() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   buffer_queue_.clear();
   for (ReadQueue::iterator it = read_queue_.begin();
        it != read_queue_.end(); ++it) {
-    it->Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
+    it->Run(DemuxerStream::kOk,

[Ami GONE FROM CHROMIUM, 2012/06/26 00:33:21]

I'm surprised that nothing in this file Run()'s a CB with a status *other* than
kOk.
In particular, I expected there to be mention of kConfigChanged here and/or in
chunk_demuxer.cc.

[acolwell GONE FROM CHROMIUM, 2012/07/12 01:19:38]

FFmpeg can always return a buffer or end of stream which is why it returns kOk
all the time. Config changes won't happen in this demuxer.
I've uploaded 2 CLs to show how config changes can be supported.

ChunkDemuxer & SourceBufferStream changes to track config changes and generate
kConfigChange status
https://chromiumcodereview.appspot.com/10696182/

FFmpegVideoDecoder changes to react to kConfigChange
https://chromiumcodereview.appspot.com/10704175

+            scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
   }
   read_queue_.clear();
   stopped_ = true;
 }
 
 base::TimeDelta FFmpegDemuxerStream::duration() {
   return duration_;
 }
 
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   return type_;
 }
 
 void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
   DCHECK(!read_cb.is_null());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
   // The demuxer_ may have been destroyed in the pipleine thread.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
-    read_cb.Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
+    read_cb.Run(DemuxerStream::kOk,
+                scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
     return;
   }
 
   // Buffers are only queued when there are no pending reads.
   DCHECK(buffer_queue_.empty() || read_queue_.empty());
 
   if (buffer_queue_.empty()) {
     demuxer_->message_loop()->PostTask(FROM_HERE, base::Bind(
         &FFmpegDemuxerStream::ReadTask, this, read_cb));
     return;
   }
 
   // Send the oldest buffer back.
   scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
   buffer_queue_.pop_front();
-  read_cb.Run(buffer);
+  read_cb.Run(DemuxerStream::kOk, buffer);
 }
 
 void FFmpegDemuxerStream::ReadTask(const ReadCB& read_cb) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
-    read_cb.Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
+    read_cb.Run(DemuxerStream::kOk,
+                scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
     return;
   }
 
   // Enqueue the callback and attempt to satisfy it immediately.
   read_queue_.push_back(read_cb);
   FulfillPendingRead();
 
   // Check if there are still pending reads, demux some more.
   if (!read_queue_.empty()) {
     demuxer_->PostDemuxTask();
   }
 }
 
 void FFmpegDemuxerStream::FulfillPendingRead() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   lock_.AssertAcquired();
   if (buffer_queue_.empty() || read_queue_.empty()) {
     return;
   }
 
   // Dequeue a buffer and pending read pair.
   scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
   ReadCB read_cb(read_queue_.front());
   buffer_queue_.pop_front();
   read_queue_.pop_front();
 
   // Execute the callback.
-  read_cb.Run(buffer);
+  read_cb.Run(DemuxerStream::kOk, buffer);
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
   // Called by hardware decoder to require different bitstream converter.
   // Currently we assume that converter is determined by codec_id;
   DCHECK(stream_);
 
   if (stream_->codec->codec_id == CODEC_ID_H264) {
     // Use Chromium bitstream converter in case of H.264
     bitstream_converter_.reset(
@@ skipping 518 matching lines @@
   } else if (audio) {
     buffered = audio->GetBufferedRanges();
   } else if (video) {
     buffered = video->GetBufferedRanges();
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 }  // namespace media