Move splice frame setting to ChunkDemuxer(). Disable for now.

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 684 matching lines @@
   return true;
 }
 
 void SourceState::OnSourceInitDone(bool success,
                                    TimeDelta duration,
                                    bool auto_update_timestamp_offset) {
   auto_update_timestamp_offset_ = auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(success, duration);
 }
 
-ChunkDemuxerStream::ChunkDemuxerStream(Type type)
+ChunkDemuxerStream::ChunkDemuxerStream(Type type, bool splice_frames_enabled)
     : type_(type),
-      state_(UNINITIALIZED) {
-}
+      state_(UNINITIALIZED),
+      splice_frames_enabled_(splice_frames_enabled) {}
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
   DCHECK(read_cb_.is_null());
   ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
 void ChunkDemuxerStream::AbortReads() {
   DVLOG(1) << "ChunkDemuxerStream::AbortReads()";
@@ skipping 110 matching lines @@
   stream_->OnNewMediaSegment(start_timestamp);
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
                                            const LogCB& log_cb) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
-    stream_.reset(new SourceBufferStream(config, log_cb));
+    stream_.reset(
+        new SourceBufferStream(config, log_cb, splice_frames_enabled_));
     return true;
   }
 
   return stream_->UpdateAudioConfig(config);
 }
 
 bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
                                            const LogCB& log_cb) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
 
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
-    stream_.reset(new SourceBufferStream(config, log_cb));
+    stream_.reset(
+        new SourceBufferStream(config, log_cb, splice_frames_enabled_));
     return true;
   }
 
   return stream_->UpdateVideoConfig(config);
 }
 
 void ChunkDemuxerStream::UpdateTextConfig(const TextTrackConfig& config,
                                           const LogCB& log_cb) {
   DCHECK_EQ(type_, TEXT);
   base::AutoLock auto_lock(lock_);
   DCHECK(!stream_);
   DCHECK_EQ(state_, UNINITIALIZED);
-  stream_.reset(new SourceBufferStream(config, log_cb));
+  stream_.reset(new SourceBufferStream(config, log_cb, splice_frames_enabled_));
 }
 
 void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->MarkEndOfStream();
 }
 
 void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
@@ skipping 85 matching lines @@
       status = DemuxerStream::kOk;
       buffer = StreamParserBuffer::CreateEOSBuffer();
       break;
   }
 
   base::ResetAndReturn(&read_cb_).Run(status, buffer);
 }
 
 ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
                            const NeedKeyCB& need_key_cb,
-                           const LogCB& log_cb)
+                           const LogCB& log_cb,
+                           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) {
+      user_specified_duration_(-1),
+      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 511 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));
+      audio_.reset(
+          new ChunkDemuxerStream(DemuxerStream::AUDIO, splice_frames_enabled_));
       return audio_.get();
       break;
     case DemuxerStream::VIDEO:
       if (video_)
         return NULL;
-      video_.reset(new ChunkDemuxerStream(DemuxerStream::VIDEO));
+      video_.reset(
+          new ChunkDemuxerStream(DemuxerStream::VIDEO, splice_frames_enabled_));
       return video_.get();
       break;
     case DemuxerStream::TEXT: {
-      return new ChunkDemuxerStream(DemuxerStream::TEXT);
+      return new ChunkDemuxerStream(DemuxerStream::TEXT,
+                                    splice_frames_enabled_);
       break;
     }
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       return NULL;
   }
   NOTREACHED();
   return NULL;
 }
@@ skipping 98 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media