Add status parameter to DemuxerStream::ReadCB

media/filters/chunk_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/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 193 matching lines @@
 
   // Adds the callback to |read_cbs_| so it can be called later when we
   // have data.
   void DeferRead_Locked(const ReadCB& read_cb);
 
   // Creates closures that bind ReadCBs in |read_cbs_| to data in
   // |buffers_| and pops the callbacks & buffers from the respecive queues.
   void CreateReadDoneClosures_Locked(ClosureQueue* closures);
 
   // Gets the value to pass to the next Read() callback. Returns true if
-  // |buffer| should be passed to the callback. False indicates that |buffer|
-  // was not set and more data is needed.
-  bool GetNextBuffer_Locked(scoped_refptr<StreamParserBuffer>* buffer);
+  // |status| and |buffer| should be passed to the callback. False indicates
+  // that |status| and |buffer| were not set and more data is needed.
+  bool GetNextBuffer_Locked(DemuxerStream::Status* status,
+                            scoped_refptr<StreamParserBuffer>* buffer);
 
   // Specifies the type of the stream (must be AUDIO or VIDEO for now).
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
   bool end_of_stream_;
@@ skipping 19 matching lines @@
   DVLOG(1) << "StartWaitingForSeek()";
   ReadCBQueue read_cbs;
   {
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(WAITING_FOR_SEEK);
     end_of_stream_ = false;
     std::swap(read_cbs_, read_cbs);
   }
 
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
-    it->Run(NULL);
+    it->Run(kAborted, NULL);
 }
 
 void ChunkDemuxerStream::Seek(TimeDelta time) {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(read_cbs_.empty());
 
   stream_->Seek(time);
 
   if (state_ == WAITING_FOR_SEEK)
@@ skipping 111 matching lines @@
   ReadCBQueue read_cbs;
   {
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(SHUTDOWN);
     std::swap(read_cbs_, read_cbs);
   }
 
   // Pass end of stream buffers to all callbacks to signal that no more data
   // will be sent.
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
-    it->Run(StreamParserBuffer::CreateEOSBuffer());
+    it->Run(DemuxerStream::kOk, StreamParserBuffer::CreateEOSBuffer());
 }
 
 // Helper function that makes sure |read_cb| runs on |message_loop|.
 static void RunOnMessageLoop(const DemuxerStream::ReadCB& read_cb,
                              MessageLoop* message_loop,
+                             DemuxerStream::Status status,
                              const scoped_refptr<DecoderBuffer>& buffer) {
   if (MessageLoop::current() != message_loop) {
     message_loop->PostTask(FROM_HERE, base::Bind(
-        &RunOnMessageLoop, read_cb, message_loop, buffer));
+        &RunOnMessageLoop, read_cb, message_loop, status, buffer));
     return;
   }
 
-  read_cb.Run(buffer);
+  read_cb.Run(status, buffer);
 }
 
 // DemuxerStream methods.
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
+  DemuxerStream::Status status = kOk;
   scoped_refptr<StreamParserBuffer> buffer;
   {
     base::AutoLock auto_lock(lock_);
-    if (!read_cbs_.empty() || !GetNextBuffer_Locked(&buffer)) {
+    if (!read_cbs_.empty() || !GetNextBuffer_Locked(&status, &buffer)) {
       DeferRead_Locked(read_cb);
       return;
     }
   }
 
-  read_cb.Run(buffer);
+  read_cb.Run(status, buffer);
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
 
 void ChunkDemuxerStream::EnableBitstreamConverter() {}
 
 const AudioDecoderConfig& ChunkDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentAudioDecoderConfig();
@@ skipping 19 matching lines @@
   read_cbs_.push_back(base::Bind(&RunOnMessageLoop, read_cb,
                                  MessageLoop::current()));
 }
 
 void ChunkDemuxerStream::CreateReadDoneClosures_Locked(ClosureQueue* closures) {
   lock_.AssertAcquired();
 
   if (state_ != RETURNING_DATA_FOR_READS)
     return;
 
+  DemuxerStream::Status status;
   scoped_refptr<StreamParserBuffer> buffer;
   while (!read_cbs_.empty()) {
-    if (!GetNextBuffer_Locked(&buffer))
+    if (!GetNextBuffer_Locked(&status, &buffer))
       return;
-    closures->push_back(base::Bind(read_cbs_.front(), buffer));
+    closures->push_back(base::Bind(read_cbs_.front(),
+                                   status, buffer));
     read_cbs_.pop_front();
   }
 }
 
 bool ChunkDemuxerStream::GetNextBuffer_Locked(
+    DemuxerStream::Status* status,
     scoped_refptr<StreamParserBuffer>* buffer) {
   lock_.AssertAcquired();
 
   switch (state_) {
     case RETURNING_DATA_FOR_READS:
-      if (stream_->GetNextBuffer(buffer))
+      if (stream_->GetNextBuffer(buffer)) {
+        *status = DemuxerStream::kOk;
         return true;
+      }
 
       if (end_of_stream_) {
+        *status = DemuxerStream::kOk;
         *buffer = StreamParserBuffer::CreateEOSBuffer();
         return true;
       }
       return false;
     case WAITING_FOR_SEEK:
       // Null buffers should be returned in this state since we are waiting
       // for a seek. Any buffers in the SourceBuffer should NOT be returned
       // because they are associated with the seek.
       DCHECK(read_cbs_.empty());
+      *status = DemuxerStream::kAborted;
       *buffer = NULL;
       return true;
     case SHUTDOWN:
       DCHECK(read_cbs_.empty());
+      *status = DemuxerStream::kOk;
       *buffer = StreamParserBuffer::CreateEOSBuffer();
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
@@ skipping 541 matching lines @@
     video_->SetStartTime(start_time_);
     video_->Seek(start_time_);
   }
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media