Media Source dispatches inband text tracks

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 12 matching lines @@
 
 // Contains state belonging to a source id.
 class SourceState {
  public:
   explicit SourceState(scoped_ptr<StreamParser> stream_parser);
 
   void Init(const StreamParser::InitCB& init_cb,
             const StreamParser::NewConfigCB& config_cb,
             const StreamParser::NewBuffersCB& audio_cb,
             const StreamParser::NewBuffersCB& video_cb,
+            const StreamParser::NewBuffersCB& text_cb,
             const StreamParser::NeedKeyCB& need_key_cb,
+            const AddTextTrackCB& add_text_track_cb,
             const StreamParser::NewMediaSegmentCB& new_segment_cb,
             const LogCB& log_cb);
 
   // 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();
@@ skipping 41 matching lines @@
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser)
     : can_update_offset_(true),
       stream_parser_(stream_parser.release()) {
 }
 
 void SourceState::Init(const StreamParser::InitCB& init_cb,
                        const StreamParser::NewConfigCB& config_cb,
                        const StreamParser::NewBuffersCB& audio_cb,
                        const StreamParser::NewBuffersCB& video_cb,
+                       const StreamParser::NewBuffersCB& text_cb,
                        const StreamParser::NeedKeyCB& need_key_cb,
+                       const AddTextTrackCB& add_text_track_cb,
                        const StreamParser::NewMediaSegmentCB& new_segment_cb,
                        const LogCB& log_cb) {
   stream_parser_->Init(init_cb, config_cb,
                        base::Bind(&SourceState::OnBuffers,
                                   base::Unretained(this), audio_cb),
                        base::Bind(&SourceState::OnBuffers,
                                   base::Unretained(this), video_cb),
+                       base::Bind(&SourceState::OnBuffers,
+                                  base::Unretained(this), text_cb),
                        need_key_cb,
+                       add_text_track_cb,
                        base::Bind(&SourceState::OnNewMediaSegment,
                                   base::Unretained(this), new_segment_cb),
                        base::Bind(&SourceState::OnEndOfMediaSegment,
                                   base::Unretained(this)),
                        log_cb);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
   if (!can_update_offset_)
     return false;
@@ skipping 424 matching lines @@
       *buffer = StreamParserBuffer::CreateEOSBuffer();
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
                            const NeedKeyCB& need_key_cb,
+                           const AddTextTrackCB& add_text_track_cb,
                            const LogCB& log_cb)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
+      add_text_track_cb_(add_text_track_cb),
       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 133 matching lines @@
     audio_cb = base::Bind(&ChunkDemuxer::OnAudioBuffers,
                           base::Unretained(this));
   }
 
   if (has_video) {
     source_id_video_ = id;
     video_cb = base::Bind(&ChunkDemuxer::OnVideoBuffers,
                           base::Unretained(this));
   }
 
+  StreamParser::NewBuffersCB text_cb;
+  text_cb = base::Bind(&ChunkDemuxer::OnTextBuffers,

[acolwell GONE FROM CHROMIUM, 2013/05/10 18:41:39]

nit: Please inline like the other Bind calls below.

[Matthew Heaney (Chromium), 2013/05/11 07:29:13]

Done.

+                       base::Unretained(this));
+
   scoped_ptr<SourceState> source_state(new SourceState(stream_parser.Pass()));
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&ChunkDemuxer::OnNewConfigs, base::Unretained(this),
                  has_audio, has_video),
       audio_cb,
       video_cb,
+      text_cb,
       base::Bind(&ChunkDemuxer::OnNeedKey, base::Unretained(this)),
+      add_text_track_cb_,
       base::Bind(&ChunkDemuxer::OnNewMediaSegment, base::Unretained(this), id),
       log_cb_);
 
   source_state_map_[id] = source_state.release();
   return kOk;
 }
 
 void ChunkDemuxer::RemoveId(const std::string& id) {
   base::AutoLock auto_lock(lock_);
   CHECK(IsValidId(id));
@@ skipping 455 matching lines @@
     return false;
 
   CHECK(IsValidId(source_id_video_));
   if (!video_->Append(buffers))
     return false;
 
   IncreaseDurationIfNecessary(buffers, video_.get());
   return true;
 }
 
+bool ChunkDemuxer::OnTextBuffers(const StreamParser::BufferQueue& buffers) {
+  lock_.AssertAcquired();
+  DCHECK_NE(state_, SHUTDOWN);
+
+  // TODO(matthewjheaney):
+  // The text buffers are pushed up the stack directly by the stream parser,
+  // so it doesn't appear that there's anything we need to do here.

[acolwell GONE FROM CHROMIUM, 2013/05/10 18:41:39]

Text tracks need to be able to update the duration like the audio and video
tracks do. See the IncreaseDurationIfNecessary() calls above. I'm fine with
adding a TODO for this and addressing it in a second CL since it might lead to a
yak shave.

You should change the signature of this method to bool(TextTrack*, const
StreamParser::BufferQueue& buffers) and move the
WebMStreamParser::OnTextBuffers() and WebMStreamParser::OnTextBuffer() logic
here. These don't need to be seperate methods since the code is so simple. This
also implies that you'll need to make a method SourceState::OnTextBuffers that
is almost identical to SourceState::OnBuffers, but also forwards the new
TextTrack parameter.

[Matthew Heaney (Chromium), 2013/05/11 07:29:13]

Done.

+
+  return true;
+}
+
 // TODO(acolwell): Remove bool from StreamParser::NeedKeyCB so that
 // this method can be removed and need_key_cb_ can be passed directly
 // to the parser.
 bool ChunkDemuxer::OnNeedKey(const std::string& type,
                              scoped_ptr<uint8[]> init_data,
                              int init_data_size) {
   lock_.AssertAcquired();
   need_key_cb_.Run(type, init_data.Pass(), init_data_size);
   return true;
 }
@@ skipping 51 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media