Move Liveness from DemuxerStreamProvider to DemuxerStream.

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 <limits>
 #include <list>
 
@@ skipping 755 matching lines @@
 
   return true;
 }
 
 void SourceState::OnSourceInitDone(bool success,
                                    const StreamParser::InitParameters& params) {
   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(success, params);
 }
 
-ChunkDemuxerStream::ChunkDemuxerStream(Type type, bool splice_frames_enabled)
+ChunkDemuxerStream::ChunkDemuxerStream(Type type,
+                                       Liveness liveness,
+                                       bool splice_frames_enabled)
     : type_(type),
+      liveness_(liveness),
       state_(UNINITIALIZED),
       splice_frames_enabled_(splice_frames_enabled),
       partial_append_window_trimming_enabled_(false) {
 }
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   ChangeState_Locked(RETURNING_DATA_FOR_READS);
@@ skipping 177 matching lines @@
 // 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();
 }
 
-DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
+DemuxerStream::Type ChunkDemuxerStream::type() const { return type_; }
+
+DemuxerStream::Liveness ChunkDemuxerStream::liveness() const {
+  return liveness_;
+}
 
 AudioDecoderConfig ChunkDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentAudioDecoderConfig();
 }
 
 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
@@ skipping 75 matching lines @@
                            bool splice_frames_enabled)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
       enable_text_(false),
       log_cb_(log_cb),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
-      liveness_(LIVENESS_UNKNOWN),
+      liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
     const PipelineStatusCB& cb,
     bool enable_text_tracks) {
   DVLOG(1) << "Init()";
@@ skipping 63 matching lines @@
   if (type == DemuxerStream::AUDIO)
     return audio_.get();
 
   return NULL;
 }
 
 TimeDelta ChunkDemuxer::GetStartTime() const {
   return TimeDelta();
 }
 
-Demuxer::Liveness ChunkDemuxer::GetLiveness() const {
-  return liveness_;
-}
-
 void ChunkDemuxer::StartWaitingForSeek(TimeDelta seek_time) {
   DVLOG(1) << "StartWaitingForSeek()";
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN ||
          state_ == PARSE_ERROR) << state_;
   DCHECK(seek_cb_.is_null());
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
@@ skipping 460 matching lines @@
         params.timeline_offset != timeline_offset_) {
       MEDIA_LOG(log_cb_)
           << "Timeline offset is not the same across all SourceBuffers.";
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
       return;
     }
 
     timeline_offset_ = params.timeline_offset;
   }
 
-  if (params.liveness != LIVENESS_UNKNOWN) {
-    if (liveness_ != LIVENESS_UNKNOWN && params.liveness != liveness_) {
+  if (params.liveness != DemuxerStream::LIVENESS_UNKNOWN) {
+    if (liveness_ != DemuxerStream::LIVENESS_UNKNOWN &&
+        params.liveness != liveness_) {
       MEDIA_LOG(log_cb_)
           << "Liveness is not the same across all SourceBuffers.";
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
       return;
     }
 
     liveness_ = params.liveness;
   }
 
   // Wait until all streams have initialized.
@@ skipping 12 matching lines @@
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 ChunkDemuxerStream*
 ChunkDemuxer::CreateDemuxerStream(DemuxerStream::Type type) {
   switch (type) {
     case DemuxerStream::AUDIO:
       if (audio_)
         return NULL;
-      audio_.reset(
-          new ChunkDemuxerStream(DemuxerStream::AUDIO, splice_frames_enabled_));
+      audio_.reset(new ChunkDemuxerStream(DemuxerStream::AUDIO, liveness_,
+                                          splice_frames_enabled_));
       return audio_.get();
       break;
     case DemuxerStream::VIDEO:
       if (video_)
         return NULL;
-      video_.reset(
-          new ChunkDemuxerStream(DemuxerStream::VIDEO, splice_frames_enabled_));
+      video_.reset(new ChunkDemuxerStream(DemuxerStream::VIDEO, liveness_,
+                                          splice_frames_enabled_));
       return video_.get();
       break;
     case DemuxerStream::TEXT: {
-      return new ChunkDemuxerStream(DemuxerStream::TEXT,
+      return new ChunkDemuxerStream(DemuxerStream::TEXT, liveness_,
                                     splice_frames_enabled_);
       break;
     }
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       return NULL;
   }
   NOTREACHED();
   return NULL;
@@ skipping 105 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media