WIP fixing/extending acolwell's init-segment-received patch

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
+using TextTrackConfigMap = media::StreamParser::TextTrackConfigMap;
 
 namespace media {
 
 static TimeDelta EndTimestamp(const StreamParser::BufferQueue& queue) {
   return queue.back()->timestamp() + queue.back()->duration();
 }
 
 // List of time ranges for each SourceBuffer.
 typedef std::list<Ranges<TimeDelta> > RangesList;
 static Ranges<TimeDelta> ComputeIntersection(const RangesList& activeRanges,
@@ skipping 42 matching lines @@
     // Step 5.3: Let new intersection ranges equal the intersection between
     // the intersection ranges and the source ranges.
     // Step 5.4: Replace the ranges in intersection ranges with the new
     // intersection ranges.
     intersection_ranges = intersection_ranges.IntersectionWith(source_ranges);
   }
 
   return intersection_ranges;
 }
 
+InitSegment::InitSegment(const std::vector<AudioTrackInfo>& audio,
+                         const std::vector<VideoTrackInfo>& video,
+                         const std::vector<TextTrackInfo>& text) :
+    audio_tracks(audio),
+    video_tracks(video),
+    text_tracks(text) {
+}
+
+InitSegment::~InitSegment() {
+}
+
+InitSegment InitSegment::Create(
+    const AudioDecoderConfig& audio_config,
+    const VideoDecoderConfig& video_config,
+    const StreamParser::TextTrackConfigMap& text_configs) {
+  std::vector<AudioTrackInfo> audio_tracks;
+  std::vector<VideoTrackInfo> video_tracks;
+  std::vector<TextTrackInfo> text_tracks;
+
+  // BIG TODO: Reject/decode error on Invalid Configs??
+  // BIG TODO START HERE: Get Blink integration working...
+
+  if (audio_config.IsValidConfig())
+    audio_tracks.push_back(AudioTrackInfo(FrameProcessor::kAudioTrackId,
+                                          audio_config));
+
+  if (video_config.IsValidConfig())
+    video_tracks.push_back(VideoTrackInfo(FrameProcessor::kVideoTrackId,
+                                          video_config));
+
+  for (TextTrackConfigMap::const_iterator itr = text_configs.begin();
+       itr != text_configs.end(); ++itr) {
+    text_tracks.push_back(TextTrackInfo(itr->first, itr->second));
+  }
+
+  return InitSegment(audio_tracks, video_tracks, text_tracks);
+}
+
+bool InitSegment::HasTracks() const {
+  return !audio_tracks.empty() || !video_tracks.empty() || !text_tracks.empty();
+}
+
 // Contains state belonging to a source id.
 class SourceState {
  public:
+  typedef ChunkDemuxer::NewInitSegmentCB NewInitSegmentCB;
+
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   typedef base::Callback<void(
       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
 
   SourceState(
       scoped_ptr<StreamParser> stream_parser,
-      scoped_ptr<FrameProcessor> frame_processor, const LogCB& log_cb,
+      scoped_ptr<FrameProcessor> frame_processor,
+      const LogCB& log_cb,
+      const NewInitSegmentCB& new_init_segment_cb,
       const CreateDemuxerStreamCB& create_demuxer_stream_cb);
 
   ~SourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::NeedKeyCB& need_key_cb,
             const NewTextTrackCB& new_text_track_cb);
 
@@ skipping 46 matching lines @@
   void OnSetDuration(TimeDelta duration);
   void MarkEndOfStream();
   void UnmarkEndOfStream();
   void Shutdown();
   // Sets the memory limit on each stream. |memory_limit| is the
   // maximum number of bytes each stream is allowed to hold in its buffer.
   void SetMemoryLimitsForTesting(int memory_limit);
   bool IsSeekWaitingForData() const;
 
  private:
-  // Called by the |stream_parser_| when a new initialization segment is
-  // encountered.
+  // Called by the |stream_parse_| when a new initialization segment is
+  // encountered. This method implements the  "Initialization segment received"
+  // algorithm outlined in the MSE spec.
+  //
   // Returns true on a successful call. Returns false if an error occurred while
   // processing decoder configurations.
-  bool OnNewConfigs(bool allow_audio, bool allow_video,
-                    const AudioDecoderConfig& audio_config,
-                    const VideoDecoderConfig& video_config,
-                    const StreamParser::TextTrackConfigMap& text_configs);
+  bool OnInitSegment(bool allow_audio, bool allow_video,
+                     const AudioDecoderConfig& audio_config,
+                     const VideoDecoderConfig& video_config,
+                     const StreamParser::TextTrackConfigMap& text_configs);
+
+  // Implements step 3.1 - 3.3 of the "Initialization segment received"
+  // algorithm.
+  bool ValidateInitSegmentAndUpdateStreams(const InitSegment& init_segment);
+
+  // Implements step 5.1 of the "Initialization segment received" algorithm.
+  bool HasUnsupportedCodecs(bool allow_audio, bool allow_video,
+                            const InitSegment& init_segment) const;
+
+  // Implements step 5.3 of the "Initialization segment received" algorithm.
+  bool HandleNewAudioTracks(const std::vector<AudioTrackInfo>& audio_tracks);
+
+  // Implements step 5.4 of the "Initialization segment received" algorithm.
+  bool HandleNewVideoTracks(const std::vector<VideoTrackInfo>& video_tracks);
+
+  // Implements step 5.4 of the "Initialization segment received" algorithm.
+  bool HandleNewTextTracks(const std::vector<TextTrackInfo>& text_tracks);
 
   // Called by the |stream_parser_| at the beginning of a new media segment.
   void OnNewMediaSegment();
 
   // Called by the |stream_parser_| at the end of a media segment.
   void OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed.
   // It processes the new buffers using |frame_processor_|, which includes
   // appending the processed frames to associated demuxer streams for each
   // frame's track.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing the buffers.
   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map);
 
   void OnSourceInitDone(bool success,
                         const StreamParser::InitParameters& params);
 
+  NewInitSegmentCB new_init_segment_cb_;
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // During Append(), if OnNewBuffers() coded frame processing updates the
   // timestamp offset then |*timestamp_offset_during_append_| is also updated
   // so Append()'s caller can know the new offset. This pointer is only non-NULL
   // during the lifetime of an Append() call.
   TimeDelta* timestamp_offset_during_append_;
 
   // During Append(), coded frame processing triggered by OnNewBuffers()
   // requires these two attributes. These are only valid during the lifetime of
   // an Append() call.
   TimeDelta append_window_start_during_append_;
   TimeDelta append_window_end_during_append_;
 
   // Set to true if the next buffers appended within the append window
   // represent the start of a new media segment. This flag being set
   // triggers a call to |new_segment_cb_| when the new buffers are
   // appended. The flag is set on actual media segment boundaries and
   // when the "append window" filtering causes discontinuities in the
   // appended data.
   // TODO(wolenetz/acolwell): Investigate if we need this, or if coded frame
   // processing's discontinuity logic is enough. See http://crbug.com/351489.
   bool new_media_segment_;
 
   // Keeps track of whether a media segment is being parsed.
   bool parsing_media_segment_;
 
+  // Keeps track of the "first initialization segment flag" state mentioned in
+  // the MSE spec.
+  bool received_first_init_segment_;
+
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
   LogCB log_cb_;
   StreamParser::InitCB init_cb_;
 
   // Indicates that timestampOffset should be updated automatically during
   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
   // changes to MSE spec. See http://crbug.com/371499.
   bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          scoped_ptr<FrameProcessor> frame_processor,
                          const LogCB& log_cb,
+                         const NewInitSegmentCB& new_init_segment_cb,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb)
-    : create_demuxer_stream_cb_(create_demuxer_stream_cb),
+    : new_init_segment_cb_(new_init_segment_cb),
+      create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       new_media_segment_(false),
       parsing_media_segment_(false),
+      received_first_init_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
       log_cb_(log_cb),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 SourceState::~SourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        bool allow_audio,
                        bool allow_video,
                        const StreamParser::NeedKeyCB& need_key_cb,
                        const NewTextTrackCB& new_text_track_cb) {
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
   stream_parser_->Init(
       base::Bind(&SourceState::OnSourceInitDone, base::Unretained(this)),
-      base::Bind(&SourceState::OnNewConfigs,
+      base::Bind(&SourceState::OnInitSegment,
                  base::Unretained(this),
                  allow_audio,
                  allow_video),
       base::Bind(&SourceState::OnNewBuffers, base::Unretained(this)),
       new_text_track_cb_.is_null(),
       need_key_cb,
       base::Bind(&SourceState::OnNewMediaSegment, base::Unretained(this)),
       base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
       log_cb_);
 }
@@ skipping 220 matching lines @@
   // NOTE: We are intentionally not checking the text tracks
   // because text tracks are discontinuous and may not have data
   // for the seek position. This is ok and playback should not be
   // stalled because we don't have cues. If cues, with timestamps after
   // the seek time, eventually arrive they will be delivered properly
   // in response to ChunkDemuxerStream::Read() calls.
 
   return false;
 }
 
-bool SourceState::OnNewConfigs(
+bool SourceState::OnInitSegment(
     bool allow_audio, bool allow_video,
     const AudioDecoderConfig& audio_config,
     const VideoDecoderConfig& video_config,
     const StreamParser::TextTrackConfigMap& text_configs) {
-  DVLOG(1) << "OnNewConfigs(" << allow_audio << ", " << allow_video
-           << ", " << audio_config.IsValidConfig()
-           << ", " << video_config.IsValidConfig() << ")";
-
-  if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
-    DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
-    return false;
-  }
-
-  // Signal an error if we get configuration info for stream types that weren't
-  // specified in AddId() or more configs after a stream is initialized.
-  if (allow_audio != audio_config.IsValidConfig()) {
+  DVLOG(2) << "OnInitSegment() "
+           << ": allow_audio=" << allow_audio
+           << ", allow_video=" << allow_video
+           << ", audio_config is "
+           << (audio_config.IsValidConfig() ? "valid" : "invalid")
+           << ", video_config is "
+           << (video_config.IsValidConfig() ? "valid" : "invalid")
+           << ", text_configs.size()=" << text_configs.size();
+
+  // TODO(wolenetz/acolwell): Update StreamParser interface to emit InitSegments
+  // instead of individual configs.
+  InitSegment init_segment =
+      InitSegment::Create(audio_config, video_config, text_configs);
+
+  // Section 3.5.7 Initialization Segment Received
+  // 1. Update the duration attribute if it currently equals NaN:
+  //   If the initialization segment contains a duration:
+  //     1. Run the duration change algorithm with new duration set to the
+  //        duration in the initialization segment.
+  //   Otherwise:
+  //     1. Run the duration change algorithm with new duration set to positive
+  //        Infinity.
+  // TODO(wolenetz/acolwell): Refactor code so step 1 can actually be done here.
+
+  // 2. If the initialization segment has no audio, video, or text tracks, then
+  //    run the end of stream algorithm with the error parameter set to "decode"
+  //    and abort these steps.
+  if (!init_segment.HasTracks()) {
+    MEDIA_LOG(log_cb_) << "No audio, video or text tracks "
+                       << "in initialization segment";
+    return false;
+  }
+
+  // 3. If the first initialization segment flag is true, then run the following
+  //    steps:
+  if (received_first_init_segment_) {
+    // 3.1 Verify the following properties. If any of the checks fail then run
+    //     the end of stream algorithm with the error parameter set to "decode"
+    //     and abort these steps.
+    //     * The number of audio, video, and text tracks match what was in the
+    //       first initialization segment.
+    //     * The codecs for each track match what was specified in the first
+    //       initialization segment.
+    //     * If more than one track for a single type are present (ie 2 audio
+    //       tracks), then the Track IDs match the ones in the first
+    //       initialization segment.
+    // 3.2 Add the appropriate track descriptions from this initialization
+    //     segment to each of the track buffers.
+    // 3.3 Set the need random access point flag on all track buffers to true.
+    if (!ValidateInitSegmentAndUpdateStreams(init_segment))
+      return false;
+  }
+
+  // 4. Let active track flag equal false.
+  // Note: This step is handled in Blink.
+  // BIG TODO(wolenetz): confirm Blink does this...
+
+  // 5. If the first initialization segment flag is false, then run the
+  //    following steps:
+  // BIG TODO(wolenetz): confirm the spec steps match the comments here and the
+  // SourceState declaration comments.
+  if (!received_first_init_segment_) {
+    // 5.1 If the initialization segment contains tracks with codecs the user
+    //     agent does not support, then run the end of stream algorithm with the
+    //     error parameter set to "decode" and abort these steps.
+    if (HasUnsupportedCodecs(allow_audio, allow_video, init_segment))
+      return false;
+
+    // 5.2 For each audio track in the initialization segment, run the following
+    //     steps:
+    if (!init_segment.audio_tracks.empty() &&
+        !HandleNewAudioTracks(init_segment.audio_tracks)) {
+      return false;
+    }
+
+    // 5.3 For each video track in the initialization segment, run the
+    //     following steps:
+    if (!init_segment.video_tracks.empty() &&
+        !HandleNewVideoTracks(init_segment.video_tracks)) {
+      return false;
+    }
+
+    // 5.4 For each text track in the initialization segment, run the
+    //     following steps:
+    if (!init_segment.text_tracks.empty() &&
+        !HandleNewTextTracks(init_segment.text_tracks)) {
+      return false;
+    }
+
+    // 5.5 If active track flag equals true, then run the following steps:
+    // NOTE: Handled when |init_segment_state| is processed by Blink.
+    // BIG TODO(wolenetz): confirm Blink does this...
+
+    // 5.6 Set first initialization segment flag to true.
+    received_first_init_segment_ = true;
+  }
+
+  // Steps 6 & 7 are handled when |init_segment_state| is processed by Blink.
+  // BIG TODO(wolenetz): confirm Blink does this...
+
+  return true;
+}
+
+bool SourceState::ValidateInitSegmentAndUpdateStreams(
+    const InitSegment& init_segment) {
+  if (!init_segment.audio_tracks.empty()) {
+    const AudioDecoderConfig& audio_config =
+        init_segment.audio_tracks[0].config();
+    if (!audio_ || !audio_->UpdateAudioConfig(audio_config, log_cb_))
+      return false;
+    frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
+  }
+
+  if (!init_segment.video_tracks.empty() &&
+      (!video_ ||
+       !video_->UpdateVideoConfig(init_segment.video_tracks[0].config(),
+                                  log_cb_))) {
+    return false;
+  }
+
+  const size_t text_count = init_segment.text_tracks.size();
+  if (text_stream_map_.size() != text_count) {
+    MEDIA_LOG(log_cb_) << "The number of text track configs changed.";
+    return false;
+  }
+
+  if (text_count == 1) {
+    ChunkDemuxerStream* text_stream = text_stream_map_.begin()->second;
+    const StreamParser::TrackId old_id = text_stream_map_.begin()->first;
+    const TextTrackConfig& old_text_config = text_stream->text_track_config();
+    const StreamParser::TrackId new_id = init_segment.text_tracks[0].track_id();
+    const TextTrackConfig& new_text_config =
+        init_segment.text_tracks[0].config();
+
+    if (!new_text_config.Matches(old_text_config)) {
+      MEDIA_LOG(log_cb_) << "New text track config does not match old one.";
+      return false;
+    }
+
+    if (new_id != old_id) {
+      if (frame_processor_->UpdateTrack(old_id, new_id)) {
+        text_stream_map_.clear();
+        text_stream_map_[new_id] = text_stream;
+      } else {
+        MEDIA_LOG(log_cb_) << "Error remapping single text track number";
+        return false;
+      }
+    }
+  } else {
+    for (size_t i = 0; i < text_count; ++i) {
+      const TextTrackInfo& track_info = init_segment.text_tracks[i];
+      TextStreamMap::iterator stream_itr =
+          text_stream_map_.find(track_info.track_id());
+      if (stream_itr == text_stream_map_.end()) {
+        MEDIA_LOG(log_cb_) << "Unexpected text track configuration for track "
+                           << "ID " << track_info.track_id();
+        return false;
+      }
+
+      ChunkDemuxerStream* stream = stream_itr->second;
+      if (!track_info.config().Matches(stream->text_track_config())) {
+        MEDIA_LOG(log_cb_) << "New text track config for track ID "
+                           << track_info.track_id()
+                           << " does not match old one.";
+        return false;
+      }
+    }
+  }
+
+  frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
+
+  return true;
+}
+
+bool SourceState::HasUnsupportedCodecs(bool allow_audio, bool allow_video,
+                                       const InitSegment& init_segment) const {
+  bool has_audio = !init_segment.audio_tracks.empty();
+  bool has_video = !init_segment.video_tracks.empty();
+
+  if (allow_audio != has_audio) {
     MEDIA_LOG(log_cb_)
         << "Initialization segment"
-        << (audio_config.IsValidConfig() ? " has" : " does not have")
+        << (has_audio ? " has" : " does not have")
         << " an audio track, but the mimetype"
         << (allow_audio ? " specifies" : " does not specify")
         << " an audio codec.";
-    return false;
-  }
-
-  if (allow_video != video_config.IsValidConfig()) {
+    return true;
+  }
+
+  if (allow_video != has_video) {
     MEDIA_LOG(log_cb_)
         << "Initialization segment"
-        << (video_config.IsValidConfig() ? " has" : " does not have")
+        << (has_video ? " has" : " does not have")
         << " a video track, but the mimetype"
         << (allow_video ? " specifies" : " does not specify")
         << " a video codec.";
-    return false;
-  }
-
-  bool success = true;
-  if (audio_config.IsValidConfig()) {
-    if (!audio_) {
-      audio_ = create_demuxer_stream_cb_.Run(DemuxerStream::AUDIO);
-
-      if (!audio_) {
-        DVLOG(1) << "Failed to create an audio stream.";
-        return false;
-      }
-
-      if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
-        DVLOG(1) << "Failed to add audio track to frame processor.";
-        return false;
-      }
-    }
-
-    frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
-    success &= audio_->UpdateAudioConfig(audio_config, log_cb_);
-  }
-
-  if (video_config.IsValidConfig()) {
-    if (!video_) {
-      video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
-
-      if (!video_) {
-        DVLOG(1) << "Failed to create a video stream.";
-        return false;
-      }
-
-      if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
-        DVLOG(1) << "Failed to add video track to frame processor.";
-        return false;
-      }
-    }
-
-    success &= video_->UpdateVideoConfig(video_config, log_cb_);
-  }
-
-  typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
-  if (text_stream_map_.empty()) {
-    for (TextConfigItr itr = text_configs.begin();
-         itr != text_configs.end(); ++itr) {
-      ChunkDemuxerStream* const text_stream =
-          create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
-      if (!frame_processor_->AddTrack(itr->first, text_stream)) {
-        success &= false;
-        MEDIA_LOG(log_cb_) << "Failed to add text track ID " << itr->first
-                           << " to frame processor.";
-        break;
-      }
-      text_stream->UpdateTextConfig(itr->second, log_cb_);
-      text_stream_map_[itr->first] = text_stream;
-      new_text_track_cb_.Run(text_stream, itr->second);
-    }
-  } else {
-    const size_t text_count = text_stream_map_.size();
-    if (text_configs.size() != text_count) {
-      success &= false;
-      MEDIA_LOG(log_cb_) << "The number of text track configs changed.";
-    } else if (text_count == 1) {
-      TextConfigItr config_itr = text_configs.begin();
-      const TextTrackConfig& new_config = config_itr->second;
-      TextStreamMap::iterator stream_itr = text_stream_map_.begin();
-      ChunkDemuxerStream* text_stream = stream_itr->second;
-      TextTrackConfig old_config = text_stream->text_track_config();
-      if (!new_config.Matches(old_config)) {
-        success &= false;
-        MEDIA_LOG(log_cb_) << "New text track config does not match old one.";
-      } else {
-        StreamParser::TrackId old_id = stream_itr->first;
-        StreamParser::TrackId new_id = config_itr->first;
-        if (new_id != old_id) {
-          if (frame_processor_->UpdateTrack(old_id, new_id)) {
-            text_stream_map_.clear();
-            text_stream_map_[config_itr->first] = text_stream;
-          } else {
-            success &= false;
-            MEDIA_LOG(log_cb_) << "Error remapping single text track number";
-          }
-        }
-      }
-    } else {
-      for (TextConfigItr config_itr = text_configs.begin();
-           config_itr != text_configs.end(); ++config_itr) {
-        TextStreamMap::iterator stream_itr =
-            text_stream_map_.find(config_itr->first);
-        if (stream_itr == text_stream_map_.end()) {
-          success &= false;
-          MEDIA_LOG(log_cb_) << "Unexpected text track configuration "
-                                "for track ID "
-                             << config_itr->first;
-          break;
-        }
-
-        const TextTrackConfig& new_config = config_itr->second;
-        ChunkDemuxerStream* stream = stream_itr->second;
-        TextTrackConfig old_config = stream->text_track_config();
-        if (!new_config.Matches(old_config)) {
-          success &= false;
-          MEDIA_LOG(log_cb_) << "New text track config for track ID "
-                             << config_itr->first
-                             << " does not match old one.";
-          break;
-        }
-      }
-    }
-  }
-
-  frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
-
-  DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
-  return success;
+    return true;
+  }
+
+  return false;
+}
+
+bool SourceState::HandleNewAudioTracks(
+    const std::vector<AudioTrackInfo>& audio_tracks) {
+  DCHECK(!received_first_init_segment_);
+  DCHECK(!audio_tracks.empty());
+  DCHECK(!audio_);
+  audio_ = create_demuxer_stream_cb_.Run(DemuxerStream::AUDIO);
+  if (!audio_) {
+    DVLOG(1) << "Failed to create an audio stream.";
+    return false;
+  }
+
+  if (!frame_processor_->AddTrack(audio_tracks[0].track_id(), audio_)) {
+    MEDIA_LOG(log_cb_) << "Failed to add audio track ID "
+                       << audio_tracks[0].track_id()
+                       << " to frame processor.";
+    return false;
+  }
+
+  const AudioDecoderConfig& audio_config = audio_tracks[0].config();
+  frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
+  if (!audio_->UpdateAudioConfig(audio_config, log_cb_)) {
+    MEDIA_LOG(log_cb_) << "Failed to set config for new audio track ID "
+                       << audio_tracks[0].track_id();
+    return false;
+  }
+
+  return true;
+}
+
+bool SourceState::HandleNewVideoTracks(
+    const std::vector<VideoTrackInfo>& video_tracks) {
+  DCHECK(!received_first_init_segment_);
+  DCHECK(!video_tracks.empty());
+  DCHECK(!video_);
+  video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
+  if (!video_) {
+    DVLOG(1) << "Failed to create a video stream.";
+    return false;
+  }
+
+  if (!frame_processor_->AddTrack(video_tracks[0].track_id(), video_)) {
+    MEDIA_LOG(log_cb_) << "Failed to add video track ID "
+                       << video_tracks[0].track_id()
+                       << " to frame processor.";
+    return false;
+  }
+
+  if (!video_->UpdateVideoConfig(video_tracks[0].config(), log_cb_)) {
+    MEDIA_LOG(log_cb_) << "Failed to set config for new video track ID "
+                       << video_tracks[0].track_id();
+    return false;
+  }
+
+  return true;
+}
+
+bool SourceState::HandleNewTextTracks(
+    const std::vector<TextTrackInfo>& text_tracks) {
+  DCHECK(!received_first_init_segment_);
+  DCHECK(!text_tracks.empty());
+  DCHECK(text_stream_map_.empty());
+  for (size_t i = 0; i < text_tracks.size(); ++i) {
+    const TextTrackInfo& track_info = text_tracks[i];
+    ChunkDemuxerStream* const text_stream =
+        create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
+    if (!text_stream) {
+      DVLOG(1) << "Failed to create a text stream.";
+      return false;
+    }
+
+    if (!frame_processor_->AddTrack(track_info.track_id(), text_stream)) {
+      MEDIA_LOG(log_cb_) << "Failed to add text track ID "
+                         << track_info.track_id()
+                         << " to frame processor.";
+      return false;
+    }
+
+    text_stream->UpdateTextConfig(track_info.config(), log_cb_);
+    text_stream_map_[track_info.track_id()] = text_stream;
+    new_text_track_cb_.Run(text_stream, track_info.config());
+  }
+
+  return true;
 }
 
 void SourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   parsing_media_segment_ = true;
   new_media_segment_ = true;
 }
 
 void SourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
@@ skipping 461 matching lines @@
   SeekAllSources(seek_time);
 
   if (seek_cb_.is_null()) {
     cancel_next_seek_ = true;
     return;
   }
 
   base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 }
 
-ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
-                                         const std::string& type,
-                                         std::vector<std::string>& codecs) {
+ChunkDemuxer::Status ChunkDemuxer::AddId(
+    const std::string& id,
+    const std::string& type,
+    std::vector<std::string>& codecs,
+    const NewInitSegmentCB& new_init_segment_cb) {
   base::AutoLock auto_lock(lock_);
 
   if ((state_ != WAITING_FOR_INIT && state_ != INITIALIZING) || IsValidId(id))
     return kReachedIdLimit;
 
   bool has_audio = false;
   bool has_video = false;
   scoped_ptr<media::StreamParser> stream_parser(
       StreamParserFactory::Create(type, codecs, log_cb_,
                                   &has_audio, &has_video));
@@ skipping 11 matching lines @@
   if (has_video)
     source_id_video_ = id;
 
   scoped_ptr<FrameProcessor> frame_processor(
       new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
                          base::Unretained(this))));
 
   scoped_ptr<SourceState> source_state(
       new SourceState(stream_parser.Pass(),
                       frame_processor.Pass(), log_cb_,
+                      new_init_segment_cb,
                       base::Bind(&ChunkDemuxer::CreateDemuxerStream,
                                  base::Unretained(this))));
 
   SourceState::NewTextTrackCB new_text_track_cb;
 
   if (enable_text_) {
     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
                                    base::Unretained(this));
   }
 
@@ skipping 548 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media