Render inband text tracks in the media pipeline

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>
 
 #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_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/stream_parser_factory.h"
-#include "media/webm/webm_webvtt_parser.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 // Contains state belonging to a source id.
 class SourceState {
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   // Callback signature used to notify ChunkDemuxer of timestamps
   // that may cause the duration to be updated.
   typedef base::Callback<void(
       TimeDelta, ChunkDemuxerStream*)> IncreaseDurationCB;
 
   SourceState(scoped_ptr<StreamParser> stream_parser, const LogCB& log_cb,
               const CreateDemuxerStreamCB& create_demuxer_stream_cb,
               const IncreaseDurationCB& increase_duration_cb);
 
+  ~SourceState();
+
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
-            const StreamParser::NewTextBuffersCB& text_cb,
             const StreamParser::NeedKeyCB& need_key_cb,
-            const AddTextTrackCB& add_text_track_cb);
+            bool enable_text_tracks);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred.
   bool Append(const uint8* data, size_t length);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
 
   // Sets |timestamp_offset_| if possible.
   // Returns if the offset was set. Returns false if the offset could not be
   // updated at this time.
   bool SetTimestampOffset(TimeDelta timestamp_offset);
 
   TimeDelta timestamp_offset() const { return timestamp_offset_; }
 
   void set_append_window_start(TimeDelta start) {
     append_window_start_ = start;
   }
   void set_append_window_end(TimeDelta end) { append_window_end_ = end; }
 
+  void TextStartReturningData();
+  void TextAbortReads();
+  void TextSeek(TimeDelta);

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

nit: Specify parameter name here.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+  void TextCompletePendingReadIfPossible();
+
  private:
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occured while
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio, bool allow_video,
                     const AudioDecoderConfig& audio_config,
-                    const VideoDecoderConfig& video_config);
+                    const VideoDecoderConfig& video_config,
+                    const TextTrackConfigMap& text_track_config_map);
 
   // 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
   // applies |timestamp_offset_| to all buffers in |audio_buffers| and
   // |video_buffers| and then calls Append() on |audio_| and/or
   // |video_| with the modified buffers.
   // Returns true on a successful call. Returns false if an error occured while
   // processing the buffers.
   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers);
 
   // Called by the |stream_parser_| when new text buffers have been parsed. It
-  // applies |timestamp_offset_| to all buffers in |buffers| and then calls
-  // |new_buffers_cb| with the modified buffers.
+  // applies |timestamp_offset_| to all buffers in |buffers| and then appends
+  // the (modified) buffers to the demuxer stream associated with
+  // the track having |text_track_number|.
   // Returns true on a successful call. Returns false if an error occured while
   // processing the buffers.
-  bool OnTextBuffers(const StreamParser::NewTextBuffersCB& new_buffers_cb,
-                     TextTrack* text_track,
+  bool OnTextBuffers(int text_track_number,
                      const StreamParser::BufferQueue& buffers);
 
   // Helper function that adds |timestamp_offset_| to each buffer in |buffers|.
   void AdjustBufferTimestamps(const StreamParser::BufferQueue& buffers);
 
   // Filters out buffers that are outside of the append window
   // [|append_window_start_|, |append_window_end_|).
   // |needs_keyframe| is a pointer to the |xxx_need_keyframe_| flag
   // associated with the |buffers|. Its state is read an updated as
   // this method filters |buffers|.
@@ skipping 25 matching lines @@
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;
   bool audio_needs_keyframe_;
 
   ChunkDemuxerStream* video_;
   bool video_needs_keyframe_;
 
+  typedef std::map<int, ChunkDemuxerStream*> TextStreamMap;
+  TextStreamMap text_stream_map_;
+
   LogCB log_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 class ChunkDemuxerStream : public DemuxerStream {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
 
   explicit ChunkDemuxerStream(Type type);
@@ skipping 31 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 UpdateTextConfig(const TextTrackConfig& config, const LogCB& log_cb);
 
   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;
+  virtual TextTrackConfig text_track_config() OVERRIDE;
 
   void set_memory_limit_for_testing(int memory_limit) {
     stream_->set_memory_limit_for_testing(memory_limit);
   }
 
  private:
   enum State {
     UNINITIALIZED,
     RETURNING_DATA_FOR_READS,
     RETURNING_ABORT_FOR_READS,
     SHUTDOWN,
   };
 
   // Assigns |state_| to |state|
   void ChangeState_Locked(State state);
 
   void CompletePendingReadIfPossible_Locked();
 
   // Gets the value to pass to the next Read() callback. Returns true if
   // |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).
+  // Specifies the type of the stream.
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCB read_cb_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
@@ skipping 10 matching lines @@
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       audio_needs_keyframe_(true),
       video_(NULL),
       video_needs_keyframe_(true),
       log_cb_(log_cb) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(!increase_duration_cb_.is_null());
 }
 
+SourceState::~SourceState() {
+  STLDeleteValues(&text_stream_map_);

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

I believe you may need to call Shutdown() on each of the streams to cancel any
pending reads they might have.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+}
+
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        bool allow_audio,
                        bool allow_video,
-                       const StreamParser::NewTextBuffersCB& text_cb,
                        const StreamParser::NeedKeyCB& need_key_cb,
-                       const AddTextTrackCB& add_text_track_cb) {
+                       bool enable_text_tracks) {
   StreamParser::NewBuffersCB audio_cb;
 
   stream_parser_->Init(init_cb,
                        base::Bind(&SourceState::OnNewConfigs,
                                   base::Unretained(this),
                                   allow_audio,
                                   allow_video),
                        base::Bind(&SourceState::OnNewBuffers,
                                   base::Unretained(this)),
                        base::Bind(&SourceState::OnTextBuffers,
-                                  base::Unretained(this), text_cb),
+                                  base::Unretained(this)),
                        need_key_cb,
-                       add_text_track_cb,
+                       enable_text_tracks,
                        base::Bind(&SourceState::OnNewMediaSegment,
                                   base::Unretained(this)),
                        base::Bind(&SourceState::OnEndOfMediaSegment,
                                   base::Unretained(this)),
                        log_cb_);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
   if (!can_update_offset_)
     return false;
 
   timestamp_offset_ = timestamp_offset;
   return true;
 }
 
 bool SourceState::Append(const uint8* data, size_t length) {
   return stream_parser_->Parse(data, length);
 }
 
 void SourceState::Abort() {
   stream_parser_->Flush();
   audio_needs_keyframe_ = true;
   video_needs_keyframe_ = true;
   can_update_offset_ = true;
 }
 
+
+void SourceState::TextStartReturningData() {
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->StartReturningData();
+  }
+}
+
+void SourceState::TextAbortReads() {
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->AbortReads();
+  }
+}
+
+void SourceState::TextSeek(TimeDelta time) {
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->Seek(time);
+  }
+}
+
+void SourceState::TextCompletePendingReadIfPossible() {
+  for (TextStreamMap::iterator itr = text_stream_map_.begin();
+       itr != text_stream_map_.end(); ++itr) {
+    itr->second->CompletePendingReadIfPossible();
+  }
+}
+
 void SourceState::AdjustBufferTimestamps(
     const StreamParser::BufferQueue& buffers) {
   if (timestamp_offset_ == TimeDelta())
     return;
 
   for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
        itr != buffers.end(); ++itr) {
     (*itr)->SetDecodeTimestamp(
         (*itr)->GetDecodeTimestamp() + timestamp_offset_);
     (*itr)->set_timestamp((*itr)->timestamp() + timestamp_offset_);
   }
 }
 
 bool SourceState::OnNewConfigs(bool allow_audio, bool allow_video,
                                const AudioDecoderConfig& audio_config,
-                               const VideoDecoderConfig& video_config) {
+                               const VideoDecoderConfig& video_config,
+                               const TextTrackConfigMap& text_config) {

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

nit: s/test_config/text_configs/

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

   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
@@ skipping 38 matching lines @@
 
       if (!video_) {
         DVLOG(1) << "Failed to create a video stream.";
         return false;
       }
     }
 
     success &= video_->UpdateVideoConfig(video_config, log_cb_);
   }
 
+  if (text_stream_map_.empty()) {
+    for (TextTrackConfigMap::const_iterator itr = text_config.begin();
+         itr != text_config.end(); ++itr) {
+      ChunkDemuxerStream* const text_stream =
+          create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
+      text_stream->UpdateTextConfig(itr->second, log_cb_);
+      text_stream_map_[itr->first] = text_stream;
+    }
+    // TODO(matthewjheaney): must callback chunk demuxer, so it can notify
+    // its host to add text stream(s).
+  } else {
+    const TextStreamMap::size_type text_count = text_stream_map_.size();

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

nit: Please just use size_t here.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+    if (text_config.size() != text_count) {
+      success &= false;
+    } else if (text_count == 1) {
+      TextTrackConfigMap::const_iterator config_itr = text_config.begin();
+      const TextTrackConfig& new_config = config_itr->second;
+      TextStreamMap::iterator stream_itr = text_stream_map_.begin();
+      ChunkDemuxerStream* stream = stream_itr->second;
+      TextTrackConfig old_config = stream->text_track_config();
+      if (!new_config.Matches(old_config)) {
+        success &= false;
+      } else {
+        // TODO(matthewjheaney): replace old with new

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

I think this is just

text_stream_map_.clear().
text_stream_map_[config_itr->first] = text_stream;

Right?

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+      }
+    } else {
+      for (TextTrackConfigMap::const_iterator config_itr = text_config.begin();
+           config_itr != text_config.end(); ++config_itr) {
+        TextStreamMap::iterator stream_itr =
+            text_stream_map_.find(config_itr->first);
+        if (stream_itr == text_stream_map_.end()) {
+          success &= false;

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

nit: Break out of the loop here and then drop the else below & deindent.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+        } else {
+          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;
+          }
+        }
+      }
+
+      // TODO(matthewjheaney): if all configs match, then replace old with new

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

I don't think you need to do anything here. If they all match then everything
should be able to proceed as normal right?

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+    }
+  }
+
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   return success;
 }
 
 void SourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   can_update_offset_ = false;
   new_media_segment_ = true;
 }
 
@@ skipping 35 matching lines @@
       segment_timestamp = filtered_video.front()->GetDecodeTimestamp();
     }
 
     new_media_segment_ = false;
 
     if (audio_)
       audio_->OnNewMediaSegment(segment_timestamp);
 
     if (video_)
       video_->OnNewMediaSegment(segment_timestamp);
+
+    for (TextStreamMap::iterator itr = text_stream_map_.begin();
+         itr != text_stream_map_.end(); ++itr) {
+      itr->second->OnNewMediaSegment(segment_timestamp);
+    }
   }
 
   if (!filtered_audio.empty()) {
     if (!audio_ || !audio_->Append(filtered_audio))
       return false;
     increase_duration_cb_.Run(filtered_audio.back()->timestamp(), audio_);
   }
 
   if (!filtered_video.empty()) {
     if (!video_ || !video_->Append(filtered_video))
       return false;
     increase_duration_cb_.Run(filtered_video.back()->timestamp(), video_);
   }
 
   return true;
 }
 
 bool SourceState::OnTextBuffers(
-    const StreamParser::NewTextBuffersCB& new_buffers_cb,
-    TextTrack* text_track,
+    int text_track_number,
     const StreamParser::BufferQueue& buffers) {
-  if (new_buffers_cb.is_null())
+  DCHECK(!buffers.empty());
+
+  TextStreamMap::iterator itr = text_stream_map_.find(text_track_number);
+  if (itr == text_stream_map_.end())
     return false;
 
   AdjustBufferTimestamps(buffers);
 
-  return new_buffers_cb.Run(text_track, buffers);
+  return itr->second->Append(buffers);
 }
 
 void SourceState::FilterWithAppendWindow(
     const StreamParser::BufferQueue& buffers, bool* needs_keyframe,
     StreamParser::BufferQueue* filtered_buffers) {
   DCHECK(needs_keyframe);
   DCHECK(filtered_buffers);
 
   // This loop implements steps 1.9, 1.10, & 1.11 of the "Coded frame
   // processing loop" in the Media Source Extensions spec.
@@ skipping 170 matching lines @@
 
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
     stream_.reset(new SourceBufferStream(config, log_cb));
     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_);
+
+  if (!stream_) {

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

Since we don't update TextTrackConfigs, you should be able to just
DCHECK(!stream_) here instead.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

+    DCHECK_EQ(state_, UNINITIALIZED);
+    stream_.reset(new SourceBufferStream(config, log_cb));
+  }
+}
+
 void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->MarkEndOfStream();
 }
 
 void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
 }
 
@@ skipping 16 matching lines @@
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentAudioDecoderConfig();
 }
 
 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentVideoDecoderConfig();
 }
 
+TextTrackConfig ChunkDemuxerStream::text_track_config() {
+  CHECK_EQ(type_, TEXT);
+  base::AutoLock auto_lock(lock_);
+  return stream_->GetCurrentTextTrackConfig();
+}
+
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
            << "type " << type_
            << " - " << state_ << " -> " << state;
   state_ = state;
 }
 
 ChunkDemuxerStream::~ChunkDemuxerStream() {}
 
@@ skipping 39 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 AddTextTrackCB& add_text_track_cb,
+                           bool enable_text,
                            const LogCB& log_cb)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
-      add_text_track_cb_(add_text_track_cb),
+      enable_text_(enable_text),
       log_cb_(log_cb),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(DemuxerHost* host, const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
 
@@ skipping 49 matching lines @@
 }
 
 void ChunkDemuxer::OnAudioRendererDisabled() {
   base::AutoLock auto_lock(lock_);
   audio_->Shutdown();
   disabled_audio_ = audio_.Pass();
 }
 
 // Demuxer implementation.
 DemuxerStream* ChunkDemuxer::GetStream(DemuxerStream::Type type) {
+  DCHECK_NE(type, DemuxerStream::TEXT);
   base::AutoLock auto_lock(lock_);
   if (type == DemuxerStream::VIDEO)
     return video_.get();
 
   if (type == DemuxerStream::AUDIO)
     return audio_.get();
 
   return NULL;
 }
 
@@ skipping 69 matching lines @@
       new SourceState(stream_parser.Pass(), log_cb_,
                       base::Bind(&ChunkDemuxer::CreateDemuxerStream,
                                  base::Unretained(this)),
                       base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
                                  base::Unretained(this))));
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
       has_audio,
       has_video,
-      base::Bind(&ChunkDemuxer::OnTextBuffers, base::Unretained(this)),
       need_key_cb_,
-      add_text_track_cb_);
+      enable_text_);
 
   source_state_map_[id] = source_state.release();
   return kOk;
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
 
   delete source_state_map_[id];
   source_state_map_.erase(id);
 
   if (source_id_audio_ == id) {
     if (audio_)
       audio_->Shutdown();
     source_id_audio_.clear();
   }
 
   if (source_id_video_ == id) {
     if (video_)
       video_->Shutdown();
     source_id_video_.clear();
   }
+
+  // TODO(matthewjheaney): delete the text streams associated with this id

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

nit: No longer needed since the streams get deleted with the SourceState.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

Done.

 }
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
   DCHECK(IsValidId(id));
   DCHECK(id == source_id_audio_ || id == source_id_video_);
 
   if (id == source_id_audio_ && id != source_id_video_) {
     // Only include ranges that have been buffered in |audio_|
@@ skipping 386 matching lines @@
         return NULL;
       audio_.reset(new ChunkDemuxerStream(DemuxerStream::AUDIO));
       return audio_.get();
       break;
     case DemuxerStream::VIDEO:
       if (video_)
         return NULL;
       video_.reset(new ChunkDemuxerStream(DemuxerStream::VIDEO));
       return video_.get();
       break;
+    case DemuxerStream::TEXT: {
+      // TODO(matthewjheaney): we need to destroy this text stream
+      return new ChunkDemuxerStream(DemuxerStream::TEXT);
+      break;
+    }
     case DemuxerStream::UNKNOWN:
     case DemuxerStream::NUM_TYPES:
       NOTREACHED();
       return NULL;
   }
   NOTREACHED();
   return NULL;
 }
 
-bool ChunkDemuxer::OnTextBuffers(
-  TextTrack* text_track,
-  const StreamParser::BufferQueue& buffers) {
+#if 0

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

remove this block if it is no longer needed.

[Matthew Heaney (Chromium), 2013/10/23 05:09:01]

I restored the callback, so that the demuxer can notify the host.

+// TODO(matthewjheaney): must be called from source state
+void ChunkDemuxer::OnNewTextTrack(ChunkDemuxerStream* text_stream,
+                                  TextKind kind,
+                                  const std::string& name,
+                                  const std::string& language) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
-
-  // TODO(matthewjheaney): IncreaseDurationIfNecessary
-
-  for (StreamParser::BufferQueue::const_iterator itr = buffers.begin();
-       itr != buffers.end(); ++itr) {
-    const StreamParserBuffer* const buffer = itr->get();
-    const TimeDelta start = buffer->timestamp();
-    const TimeDelta end = start + buffer->duration();
-
-    std::string id, settings, content;
-
-    WebMWebVTTParser::Parse(buffer->data(),
-                            buffer->data_size(),
-                            &id, &settings, &content);
-
-    text_track->addWebVTTCue(start, end, id, content, settings);
-  }
-
-  return true;
+  DCHECK(text_stream_set_.find(text_stream) != text_stream_set_.end());
+  host_->AddTextStream(text_stream, kind, name, language);
 }
+#endif
 
 bool ChunkDemuxer::IsValidId(const std::string& source_id) const {
   lock_.AssertAcquired();
   return source_state_map_.count(source_id) > 0u;
 }
 
 void ChunkDemuxer::UpdateDuration(TimeDelta new_duration) {
   DCHECK(duration_ != new_duration);
   user_specified_duration_ = -1;
   duration_ = new_duration;
@@ skipping 28 matching lines @@
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 void ChunkDemuxer::StartReturningData() {
   if (audio_)
     audio_->StartReturningData();

[acolwell GONE FROM CHROMIUM, 2013/10/21 20:10:40]

Is there any reason the calls on audio_ and video_ can't be moved into
SourceState as well? Ditto for the similar methods below.

 
   if (video_)
     video_->StartReturningData();
+
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->TextStartReturningData();
+  }
 }
 
 void ChunkDemuxer::AbortPendingReads() {
   if (audio_)
     audio_->AbortReads();
 
   if (video_)
     video_->AbortReads();
+
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->TextAbortReads();
+  }
 }
 
 void ChunkDemuxer::SeekAllSources(TimeDelta seek_time) {
   if (audio_)
     audio_->Seek(seek_time);
 
   if (video_)
     video_->Seek(seek_time);
+
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->TextSeek(seek_time);
+  }
 }
 
 void ChunkDemuxer::CompletePendingReadsIfPossible() {
   if (audio_)
     audio_->CompletePendingReadIfPossible();
 
   if (video_)
     video_->CompletePendingReadIfPossible();
+
+  for (SourceStateMap::iterator itr = source_state_map_.begin();
+       itr != source_state_map_.end(); ++itr) {
+    itr->second->TextCompletePendingReadIfPossible();
+  }
 }
 
 }  // namespace media