Render inband text tracks in the media pipeline

media/filters/chunk_demuxer_unittest.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 141 matching lines @@
 
   ChunkDemuxerTest() {
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::NeedKeyCB need_key_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
-    AddTextTrackCB add_text_track_cb =
-        base::Bind(&ChunkDemuxerTest::OnTextTrack, base::Unretained(this));
-    demuxer_.reset(new ChunkDemuxer(open_cb, need_key_cb,
-                                    add_text_track_cb, LogCB()));
+    demuxer_.reset(new ChunkDemuxer(open_cb, need_key_cb, LogCB()));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
-  void CreateInitSegment(bool has_audio, bool has_video,
+  void CreateInitSegment(bool has_audio, bool has_video, bool has_text,
                          bool is_audio_encrypted, bool is_video_encrypted,
                          scoped_ptr<uint8[]>* buffer,
                          int* size) {
     scoped_refptr<DecoderBuffer> ebml_header;
     scoped_refptr<DecoderBuffer> info;
     scoped_refptr<DecoderBuffer> audio_track_entry;
     scoped_refptr<DecoderBuffer> video_track_entry;
     scoped_refptr<DecoderBuffer> audio_content_encodings;
     scoped_refptr<DecoderBuffer> video_content_encodings;
+    scoped_refptr<DecoderBuffer> text_track_entry;
 
     ebml_header = ReadTestDataFile("webm_ebml_element");
 
     info = ReadTestDataFile("webm_info_element");
 
     int tracks_element_size = 0;
 
     if (has_audio) {
       audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry");
       tracks_element_size += audio_track_entry->data_size();
       if (is_audio_encrypted) {
         audio_content_encodings = ReadTestDataFile("webm_content_encodings");
         tracks_element_size += audio_content_encodings->data_size();
       }
     }
 
     if (has_video) {
       video_track_entry = ReadTestDataFile("webm_vp8_track_entry");
       tracks_element_size += video_track_entry->data_size();
       if (is_video_encrypted) {
         video_content_encodings = ReadTestDataFile("webm_content_encodings");
         tracks_element_size += video_content_encodings->data_size();
       }
     }
 
+    if (has_text) {
+      // TODO(matthewjheaney): create an abstraction to do
+      // this (http://crbug/321454).
+      // We need it to also handle the creation of multiple text tracks.
+      //
+      // This is the track entry for a text track,
+      // TrackEntry [AE], size=26
+      //   TrackNum [D7], size=1, val=3
+      //   TrackType [83], size=1, val=0x11
+      //   CodecId [86], size=18, val="D_WEBVTT/SUBTITLES"
+      const char str[] = "\xAE\x9A\xD7\x81\x03\x83\x81\x11\x86\x92"
+                         "D_WEBVTT/SUBTITLES";
+      const int len = strlen(str);
+      DCHECK_EQ(len, 28);
+      const uint8* const buf = reinterpret_cast<const uint8*>(str);
+      text_track_entry = DecoderBuffer::CopyFrom(buf, len);
+      tracks_element_size += text_track_entry->data_size();
+    }
+
     *size = ebml_header->data_size() + info->data_size() +
         kTracksHeaderSize + tracks_element_size;
 
     buffer->reset(new uint8[*size]);
 
     uint8* buf = buffer->get();
     memcpy(buf, ebml_header->data(), ebml_header->data_size());
     buf += ebml_header->data_size();
 
     memcpy(buf, info->data(), info->data_size());
@@ skipping 29 matching lines @@
                video_content_encodings->data(),
                video_content_encodings->data_size());
         WriteInt64(buf + kVideoTrackSizeOffset,
                    video_track_entry->data_size() +
                    video_content_encodings->data_size() -
                    kVideoTrackEntryHeaderSize);
         buf += video_content_encodings->data_size();
       }
       buf += video_track_entry->data_size();
     }
+
+    if (has_text) {
+      memcpy(buf, text_track_entry->data(),
+             text_track_entry->data_size());
+      buf += text_track_entry->data_size();
+    }
   }
 
   ChunkDemuxer::Status AddId() {
     return AddId(kSourceId, true, true);
   }
 
   ChunkDemuxer::Status AddId(const std::string& source_id,
                              bool has_audio, bool has_video) {
     std::vector<std::string> codecs;
     std::string type;
@@ skipping 92 matching lines @@
     const uint8* end = data + length;
     while (start < end) {
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       AppendData(start, append_size);
       start += append_size;
     }
   }
 
   void AppendInitSegment(bool has_audio, bool has_video) {
-    AppendInitSegmentWithSourceId(kSourceId, has_audio, has_video);
+    AppendInitSegmentWithSourceId(kSourceId, has_audio, has_video, false);
+  }
+
+  void AppendInitSegmentText(bool has_audio, bool has_video) {
+    AppendInitSegmentWithSourceId(kSourceId, has_audio, has_video, true);
   }
 
   void AppendInitSegmentWithSourceId(const std::string& source_id,
-                                     bool has_audio, bool has_video) {
+                                     bool has_audio, bool has_video,
+                                     bool has_text) {
     AppendInitSegmentWithEncryptedInfo(
-        source_id, has_audio, has_video, false, false);
+        source_id, has_audio, has_video, has_text, false, false);
   }
 
   void AppendInitSegmentWithEncryptedInfo(const std::string& source_id,
                                           bool has_audio, bool has_video,
+                                          bool has_text,
                                           bool is_audio_encrypted,
                                           bool is_video_encrypted) {
     scoped_ptr<uint8[]> info_tracks;
     int info_tracks_size = 0;
-    CreateInitSegment(has_audio, has_video,
+    CreateInitSegment(has_audio, has_video, has_text,
                       is_audio_encrypted, is_video_encrypted,
                       &info_tracks, &info_tracks_size);
     AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   void AppendGarbage() {
     // Fill up an array with gibberish.
     int garbage_cluster_size = 10;
     scoped_ptr<uint8[]> garbage_cluster(new uint8[garbage_cluster_size]);
     for (int i = 0; i < garbage_cluster_size; ++i)
@@ skipping 17 matching lines @@
     return CreateInitDoneCB(expected_status);
   }
 
   PipelineStatusCB CreateInitDoneCB(PipelineStatus expected_status) {
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
                       expected_status);
   }
 
   bool InitDemuxer(bool has_audio, bool has_video) {
-    return InitDemuxerWithEncryptionInfo(has_audio, has_video, false, false);
+    return InitDemuxerWithEncryptionInfo(has_audio, has_video, false,
+                                         false, false);
+  }
+
+  bool InitDemuxerText(bool has_audio, bool has_video) {
+    return InitDemuxerWithEncryptionInfo(has_audio, has_video, true,
+                                         false, false);
   }
 
   bool InitDemuxerWithEncryptionInfo(
-      bool has_audio, bool has_video,
+      bool has_audio, bool has_video, bool has_text,
       bool is_audio_encrypted, bool is_video_encrypted) {
     PipelineStatus expected_status =
         (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN;
 
     base::TimeDelta expected_duration = kNoTimestamp();
     if (expected_status == PIPELINE_OK)
       expected_duration = kDefaultDuration();
 
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
-        &host_, CreateInitDoneCB(expected_duration, expected_status));
+        &host_, CreateInitDoneCB(expected_duration, expected_status), true);
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     AppendInitSegmentWithEncryptedInfo(
-        kSourceId, has_audio, has_video,
+        kSourceId, has_audio, has_video, has_text,
         is_audio_encrypted, is_video_encrypted);
     return true;
   }
 
-  bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
-                                       const std::string& video_id) {
+  bool InitDemuxerAudioAndVideoSourcesText(const std::string& audio_id,
+                                           const std::string& video_id,
+                                           bool has_text) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
-        &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+        &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
     if (AddId(audio_id, true, false) != ChunkDemuxer::kOk)
       return false;
     if (AddId(video_id, false, true) != ChunkDemuxer::kOk)
       return false;
 
-    AppendInitSegmentWithSourceId(audio_id, true, false);
-    AppendInitSegmentWithSourceId(video_id, false, true);
+    AppendInitSegmentWithSourceId(audio_id, true, false, has_text);
+    AppendInitSegmentWithSourceId(video_id, false, true, has_text);
     return true;
   }
 
+  bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
+                                       const std::string& video_id) {
+    return InitDemuxerAudioAndVideoSourcesText(audio_id, video_id, false);
+  }
+
   // Initializes the demuxer with data from 2 files with different
   // decoder configurations. This is used to test the decoder config change
   // logic.
   //
   // bear-320x240.webm VideoDecoderConfig returns 320x240 for its natural_size()
   // bear-640x360.webm VideoDecoderConfig returns 640x360 for its natural_size()
   // The resulting video stream returns data from each file for the following
   // time ranges.
   // bear-320x240.webm : [0-501)       [801-2737)
   // bear-640x360.webm :       [527-793)
   //
   // bear-320x240.webm AudioDecoderConfig returns 3863 for its extra_data_size()
   // bear-640x360.webm AudioDecoderConfig returns 3935 for its extra_data_size()
   // The resulting audio stream returns data from each file for the following
   // time ranges.
   // bear-320x240.webm : [0-524)       [779-2737)
   // bear-640x360.webm :       [527-759)
   bool InitDemuxerWithConfigChangeData() {
     scoped_refptr<DecoderBuffer> bear1 = ReadTestDataFile("bear-320x240.webm");
     scoped_refptr<DecoderBuffer> bear2 = ReadTestDataFile("bear-640x360.webm");
 
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
-                                 PIPELINE_OK));
+                                 PIPELINE_OK), true);
 
     if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
     AppendData(bear1->data(), bear1->data_size());
     CheckExpectedRanges(kSourceId, "{ [0,2737) }");
 
     // Append initialization segment for bear2.
     // Note: Offsets here and below are derived from
@@ skipping 305 matching lines @@
                      const base::TimeDelta& duration) {
     return ParseWebMFile(filename, timestamps, duration, true, true);
   }
 
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration,
                      bool has_audio, bool has_video) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
-        &host_, CreateInitDoneCB(duration, PIPELINE_OK));
+        &host_, CreateInitDoneCB(duration, PIPELINE_OK), true);
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
 
     // Verify that the timestamps on the first few packets match what we
     // expect.
@@ skipping 30 matching lines @@
   // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
   // std::string instead of scoped_ptr<uint8[]> (http://crbug.com/130689).
   MOCK_METHOD3(NeedKeyMock, void(const std::string& type,
                                  const uint8* init_data, int init_data_size));
   void DemuxerNeedKey(const std::string& type,
                       const std::vector<uint8>& init_data) {
     const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
     NeedKeyMock(type, init_data_ptr, init_data.size());
   }
 
-  scoped_ptr<TextTrack> OnTextTrack(TextKind kind,
-                                    const std::string& label,
-                                    const std::string& language) {
-    return scoped_ptr<TextTrack>();
-  }
-
   void Seek(base::TimeDelta seek_time) {
     demuxer_->StartWaitingForSeek(seek_time);
     demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunUntilIdle();
   }
 
   void MarkEndOfStream(PipelineStatus status) {
     demuxer_->MarkEndOfStream(status);
     message_loop_.RunUntilIdle();
   }
@@ skipping 26 matching lines @@
 
     if (is_audio_encrypted || is_video_encrypted) {
       int need_key_count = (is_audio_encrypted ? 1 : 0) +
                            (is_video_encrypted ? 1 : 0);
       EXPECT_CALL(*this, NeedKeyMock(kWebMEncryptInitDataType, NotNull(),
                                      DecryptConfig::kDecryptionKeySize))
           .Times(Exactly(need_key_count));
     }
 
     ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
-        has_audio, has_video, is_audio_encrypted, is_video_encrypted));
+        has_audio, has_video, false, is_audio_encrypted, is_video_encrypted));
 
     DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
     if (has_audio) {
+      ASSERT_TRUE(audio_stream);
+
+      const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
+      EXPECT_EQ(kCodecVorbis, config.codec());
+      EXPECT_EQ(32, config.bits_per_channel());
+      EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout());
+      EXPECT_EQ(44100, config.samples_per_second());
+      EXPECT_TRUE(config.extra_data());
+      EXPECT_GT(config.extra_data_size(), 0u);
+      EXPECT_EQ(kSampleFormatPlanarF32, config.sample_format());
+      EXPECT_EQ(is_audio_encrypted,
+                audio_stream->audio_decoder_config().is_encrypted());
+    } else {
+      EXPECT_FALSE(audio_stream);
+    }
+
+    DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+    if (has_video) {
+      EXPECT_TRUE(video_stream);
+      EXPECT_EQ(is_video_encrypted,
+                video_stream->video_decoder_config().is_encrypted());
+    } else {
+      EXPECT_FALSE(video_stream);
+    }
+
+    ShutdownDemuxer();
+    demuxer_.reset();
+  }
+}
+
+TEST_F(ChunkDemuxerTest, InitText) {
+  // Test with 1 video stream and 1 text streams, and 0 or 1 audio streams.
+  // No encryption cases handled here.
+  bool has_video = true;
+  bool is_audio_encrypted = false;
+  bool is_video_encrypted = false;
+  for (int i = 0; i < 2; i++) {
+    bool has_audio = (i & 0x1) != 0;
+
+    CreateNewDemuxer();
+
+    DemuxerStream* text_stream = NULL;
+    TextTrackConfig text_config;
+    EXPECT_CALL(host_, AddTextStream(_,_))
+        .WillOnce(DoAll(SaveArg<0>(&text_stream),
+                        SaveArg<1>(&text_config)));
+
+    ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
+        has_audio, has_video, true, is_audio_encrypted, is_video_encrypted));
+    ASSERT_TRUE(text_stream);
+    EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
+    EXPECT_EQ(kTextSubtitles, text_config.kind());
+
+    DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+    if (has_audio) {
       ASSERT_TRUE(audio_stream);
 
       const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
       EXPECT_EQ(kCodecVorbis, config.codec());
       EXPECT_EQ(32, config.bits_per_channel());
       EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout());
       EXPECT_EQ(44100, config.samples_per_second());
       EXPECT_TRUE(config.extra_data());
       EXPECT_GT(config.extra_data_size(), 0u);
       EXPECT_EQ(kSampleFormatPlanarF32, config.sample_format());
@@ skipping 16 matching lines @@
     demuxer_.reset();
   }
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, ShutdownBeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
-          kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
+          kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
-  AppendInitSegmentWithSourceId("audio", true, false);
+  AppendInitSegmentWithSourceId("audio", true, false, false);
+}
+
+TEST_F(ChunkDemuxerTest, ShutdownBeforeAllInitSegmentsAppendedText) {
+  EXPECT_CALL(*this, DemuxerOpened());
+  demuxer_->Initialize(
+      &host_, CreateInitDoneCB(
+          kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
+
+  EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
+  EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
+
+  EXPECT_CALL(host_, AddTextStream(_,_))
+      .Times(Exactly(1));
+
+  AppendInitSegmentWithSourceId("video", false, true, true);
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, AppendDataAfterSeek) {
   ASSERT_TRUE(InitDemuxer(true, true));
   AppendCluster(kDefaultFirstCluster());
 
   InSequence s;
 
@@ skipping 54 matching lines @@
   // Append the new cluster and verify that only the blocks
   // in the new cluster are returned.
   AppendCluster(GenerateCluster(5000, 6));
   GenerateExpectedReads(5000, 6);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, AppendDataBeforeInit) {
   scoped_ptr<uint8[]> info_tracks;
   int info_tracks_size = 0;
-  CreateInitSegment(true, true, false, false, &info_tracks, &info_tracks_size);
+  CreateInitSegment(true, true, false,
+                    false, false, &info_tracks, &info_tracks_size);
 
   demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size);
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
 TEST_F(ChunkDemuxerTest, Read) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   AppendCluster(kDefaultFirstCluster());
 
@@ skipping 85 matching lines @@
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendCluster(cb.Finish());
 }
 
 // Test the case where a cluster is passed to AppendCluster() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, ClusterBeforeInitSegment) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   AppendCluster(GenerateCluster(0, 1));
 }
 
 // Test cases where we get an MarkEndOfStream() call during initialization.
 TEST_F(ChunkDemuxerTest, EOSDuringInit) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
   MarkEndOfStream(PIPELINE_OK);
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamWithNoAppend) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("{ }");
   MarkEndOfStream(PIPELINE_OK);
   ShutdownDemuxer();
   CheckExpectedRanges("{ }");
   demuxer_->RemoveId(kSourceId);
   demuxer_.reset();
 }
@@ skipping 178 matching lines @@
 
   // Make sure video can reach end of stream.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kOk);
 }
 
 // Make sure AppendData() will accept elements that span multiple calls.
 TEST_F(ChunkDemuxerTest, AppendingInPieces) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   scoped_ptr<uint8[]> info_tracks;
   int info_tracks_size = 0;
-  CreateInitSegment(true, true, false, false, &info_tracks, &info_tracks_size);
+  CreateInitSegment(true, true, false,
+                    false, false, &info_tracks, &info_tracks_size);
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
 
   size_t buffer_size = info_tracks_size + cluster_a->size() + cluster_b->size();
   scoped_ptr<uint8[]> buffer(new uint8[buffer_size]);
   uint8* dst = buffer.get();
   memcpy(dst, info_tracks.get(), info_tracks_size);
   dst += info_tracks_size;
 
@@ skipping 141 matching lines @@
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, ParseErrorDuringInit) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
-          kNoTimestamp(), DEMUXER_ERROR_COULD_NOT_OPEN));
+          kNoTimestamp(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   uint8 tmp = 0;
   demuxer_->AppendData(kSourceId, &tmp, 1);
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithAudioOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
-                               DEMUXER_ERROR_COULD_NOT_OPEN));
+                               DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vorbis";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
             ChunkDemuxer::kOk);
 
   AppendInitSegment(true, true);
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithVideoOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
-                               DEMUXER_ERROR_COULD_NOT_OPEN));
+                               DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
 
   AppendInitSegment(true, true);
 }
 
 TEST_F(ChunkDemuxerTest, MultipleHeaders) {
@@ skipping 16 matching lines @@
 
   // Append audio and video data into separate source ids.
   AppendCluster(audio_id,
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
   GenerateAudioStreamExpectedReads(0, 4);
   AppendCluster(video_id,
       GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
   GenerateVideoStreamExpectedReads(0, 4);
 }
 
+TEST_F(ChunkDemuxerTest, AddSeparateSourcesForAudioAndVideoText) {
+  // TODO(matthewjheaney): Here and elsewhere, we need more tests
+  // for inband text tracks (http://crbug/321455).
+
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+
+  EXPECT_CALL(host_, AddTextStream(_,_))
+    .Times(Exactly(2));
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSourcesText(audio_id, video_id, true));
+
+  // Append audio and video data into separate source ids.
+  AppendCluster(audio_id,
+      GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
+  GenerateAudioStreamExpectedReads(0, 4);
+  AppendCluster(video_id,
+      GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
+  GenerateVideoStreamExpectedReads(0, 4);
+}
+
 TEST_F(ChunkDemuxerTest, AddIdFailures) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   std::string audio_id = "audio1";
   std::string video_id = "video1";
 
   ASSERT_EQ(AddId(audio_id, true, false), ChunkDemuxer::kOk);
 
   // Adding an id with audio/video should fail because we already added audio.
   ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit);
 
-  AppendInitSegmentWithSourceId(audio_id, true, false);
+  AppendInitSegmentWithSourceId(audio_id, true, false, false);
 
   // Adding an id after append should fail.
   ASSERT_EQ(AddId(video_id, false, true), ChunkDemuxer::kReachedIdLimit);
 }
 
 // Test that Read() calls after a RemoveId() return "end of stream" buffers.
 TEST_F(ChunkDemuxerTest, RemoveId) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
@@ skipping 208 matching lines @@
 
   EXPECT_TRUE(seek_cb_was_called);
 
   ShutdownDemuxer();
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk);
   AppendInitSegment(true, false);
 
   // Test a simple cluster.
   AppendCluster(
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
 
   CheckExpectedRanges("{ [0,92) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   AppendCluster(GenerateSingleStreamCluster(
       150, 219, kAudioTrackNum, kAudioBlockDuration));
 
   CheckExpectedRanges("{ [0,92) [150,219) }");
 }
 
 // Test ranges in a video-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
-      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk);
   AppendInitSegment(false, true);
 
   // Test a simple cluster.
   AppendCluster(
       GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
 
   CheckExpectedRanges("{ [0,132) }");
 
@@ skipping 221 matching lines @@
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastAudioTimestamp, last_timestamp);
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastVideoTimestamp, last_timestamp);
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRangesBeforeInitSegment) {
   EXPECT_CALL(*this, DemuxerOpened());
-  demuxer_->Initialize(&host_, CreateInitDoneCB(PIPELINE_OK));
+  demuxer_->Initialize(&host_, CreateInitDoneCB(PIPELINE_OK), true);
   ASSERT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   ASSERT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("audio", "{ }");
   CheckExpectedRanges("video", "{ }");
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringSeek) {
@@ skipping 303 matching lines @@
   AppendCluster(kDefaultSecondCluster());
   MarkEndOfStream(PIPELINE_OK);
 }
 
 // Test receiving a Shutdown() call before we get an Initialize()
 // call. This can happen if video element gets destroyed before
 // the pipeline has a chance to initialize the demuxer.
 TEST_F(ChunkDemuxerTest, ShutdownBeforeInitialize) {
   demuxer_->Shutdown();
   demuxer_->Initialize(
-      &host_, CreateInitDoneCB(DEMUXER_ERROR_COULD_NOT_OPEN));
+      &host_, CreateInitDoneCB(DEMUXER_ERROR_COULD_NOT_OPEN), true);
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(ChunkDemuxerTest, ReadAfterAudioDisabled) {
   ASSERT_TRUE(InitDemuxer(true, true));
   AppendCluster(kDefaultFirstCluster());
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(stream);
 
@@ skipping 128 matching lines @@
   // NOTE: The current GC algorithm tries to preserve the GOP at the
   //  current position as well as the last appended GOP. This is
   //  why there are 2 ranges in the expectations.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 700, 5);
   CheckExpectedRanges(kSourceId, "{ [500,592) [792,815) }");
 }
 
 TEST_F(ChunkDemuxerTest, RemoveBeforeInitSegment) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
-        &host_, CreateInitDoneCB(kNoTimestamp(), PIPELINE_OK));
+        &host_, CreateInitDoneCB(kNoTimestamp(), PIPELINE_OK), true);
 
     EXPECT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, true, true));
 
     demuxer_->Remove(kSourceId, base::TimeDelta::FromMilliseconds(0),
                      base::TimeDelta::FromMilliseconds(1));
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow) {
   ASSERT_TRUE(InitDemuxer(false, true));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
@@ skipping 27 matching lines @@
 
 TEST_F(ChunkDemuxerTest, StartWaitingForSeekAfterParseError) {
   ASSERT_TRUE(InitDemuxer(true, true));
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendGarbage();
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(50);
   demuxer_->StartWaitingForSeek(seek_time);
 }
 
 }  // namespace media