Update the WebMediaSourceClientImpl & ChunkDemuxer to received explicit end of stream cancellation.

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 <algorithm>
 #include <deque>
 #include <limits>
 
@@ skipping 142 matching lines @@
   // Signal to the stream that buffers handed in through subsequent calls to
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
   // Called when midstream config updates occur.
   // Returns true if the new config is accepted.
   // Returns false if the new config should trigger an error.
   bool UpdateAudioConfig(const AudioDecoderConfig& config, const LogCB& log_cb);
   bool UpdateVideoConfig(const VideoDecoderConfig& config, const LogCB& log_cb);
 
-  void EndOfStream();
-  void CancelEndOfStream();
+  void MarkEndOfStream();
+  void UnmarkEndOfStream();
 
   // DemuxerStream methods.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
   virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
   virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
 
   void set_memory_limit_for_testing(int memory_limit) {
     stream_->set_memory_limit_for_testing(memory_limit);
@@ skipping 350 matching lines @@
 
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
     stream_.reset(new SourceBufferStream(config, log_cb));
     return true;
   }
 
   return stream_->UpdateVideoConfig(config);
 }
 
-void ChunkDemuxerStream::EndOfStream() {
+void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
-  stream_->EndOfStream();
+  stream_->MarkEndOfStream();
 }
 
-void ChunkDemuxerStream::CancelEndOfStream() {
+void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
-  stream_->CancelEndOfStream();
+  stream_->UnmarkEndOfStream();
 }
 
 // DemuxerStream methods.
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, UNINITIALIZED);
   DCHECK(read_cb_.is_null());
 
   read_cb_ = BindToCurrentLoop(read_cb);
   CompletePendingReadIfPossible_Locked();
@@ skipping 322 matching lines @@
                               const uint8* data,
                               size_t length) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
 
   Ranges<TimeDelta> ranges;
 
   {
     base::AutoLock auto_lock(lock_);
+    DCHECK_NE(state_, ENDED);
 
     // Capture if any of the SourceBuffers are waiting for data before we start
     // parsing.
     bool old_waiting_for_data = IsSeekWaitingForData_Locked();
 
-    if (state_ == ENDED) {
-      ChangeState_Locked(INITIALIZED);
-
-      if (audio_)
-        audio_->CancelEndOfStream();
-
-      if (video_)
-        video_->CancelEndOfStream();
-    }
-
     if (length == 0u)
       return;
 
     DCHECK(data);
 
     switch (state_) {
       case INITIALIZING:
         DCHECK(IsValidId(id));
         if (!source_state_map_[id]->Append(data, length)) {
           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
@@ skipping 105 matching lines @@
 }
 
 bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
   CHECK(IsValidId(id));
 
   return source_state_map_[id]->SetTimestampOffset(offset);
 }
 
-void ChunkDemuxer::EndOfStream(PipelineStatus status) {
-  DVLOG(1) << "EndOfStream(" << status << ")";
+void ChunkDemuxer::MarkEndOfStream(PipelineStatus status) {
+  DVLOG(1) << "MarkEndOfStream(" << status << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, WAITING_FOR_INIT);
   DCHECK_NE(state_, ENDED);
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
   if (state_ == INITIALIZING) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
   if (audio_)
-    audio_->EndOfStream();
+    audio_->MarkEndOfStream();
 
   if (video_)
-    video_->EndOfStream();
+    video_->MarkEndOfStream();
 
   CompletePendingReadsIfPossible();
 
   // Give a chance to resume the pending seek process.
   if (status != PIPELINE_OK) {
     ReportError_Locked(status);
     return;
   }
 
   ChangeState_Locked(ENDED);
   DecreaseDurationIfNecessary();
 
   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
       !seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   }
 }
 
+void ChunkDemuxer::UnmarkEndOfStream() {
+  DVLOG(1) << "UnmarkEndOfStream()";
+  base::AutoLock auto_lock(lock_);
+  DCHECK_EQ(state_, ENDED);
+
+  ChangeState_Locked(INITIALIZED);
+
+  if (audio_)
+    audio_->UnmarkEndOfStream();
+
+  if (video_)
+    video_->UnmarkEndOfStream();
+}
+
 void ChunkDemuxer::Shutdown() {
   DVLOG(1) << "Shutdown()";
   base::AutoLock auto_lock(lock_);
 
   if (state_ == SHUTDOWN)
     return;
 
   if (audio_)
     audio_->Shutdown();
 
@@ skipping 238 matching lines @@
 
 void ChunkDemuxer::CompletePendingReadsIfPossible() {
   if (audio_)
     audio_->CompletePendingReadIfPossible();
 
   if (video_)
     video_->CompletePendingReadIfPossible();
 }
 
 }  // namespace media