Support encrypted audio stream in demuxer.

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 "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/webm/cluster_builder.h"
 #include "media/webm/webm_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
+using ::testing::Exactly;
 using ::testing::InSequence;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 using ::testing::_;
 
 namespace media {
 
 static const uint8 kTracksHeader[] = {
   0x16, 0x54, 0xAE, 0x6B,  // Tracks ID
   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // tracks(size = 0)
 };
 
 static const int kTracksHeaderSize = sizeof(kTracksHeader);
 static const int kTracksSizeOffset = 4;
 
+// The size of TrackEntry element in test file "webm_vorbis_track_entry" starts
+// at index 1 and spans 8 bytes.
+static const int kAudioTrackSizeOffset = 1;
+static const int kAudioTrackSizeWidth = 8;
+static const int kAudioTrackEntryHeaderSize = kAudioTrackSizeOffset +
+                                              kAudioTrackSizeWidth;
+
 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at
 // index 1 and spans 8 bytes.
 static const int kVideoTrackSizeOffset = 1;
 static const int kVideoTrackSizeWidth = 8;
 static const int kVideoTrackEntryHeaderSize = kVideoTrackSizeOffset +
                                               kVideoTrackSizeWidth;
 
 static const int kVideoTrackNum = 1;
 static const int kAudioTrackNum = 2;
 
@@ skipping 110 matching lines @@
     ChunkDemuxer::NeedKeyCB need_key_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
     demuxer_ = new ChunkDemuxer(open_cb, need_key_cb);
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(bool has_audio, bool has_video,
-                         bool video_content_encoded,
+                         bool is_audio_encrypted, bool is_video_encrypted,
                          scoped_array<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;
 
     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->GetDataSize();
+      if (is_audio_encrypted) {
+        audio_content_encodings = ReadTestDataFile("webm_content_encodings");
+        tracks_element_size += audio_content_encodings->GetDataSize();
+      }
     }
 
     if (has_video) {
       video_track_entry = ReadTestDataFile("webm_vp8_track_entry");
       tracks_element_size += video_track_entry->GetDataSize();
-      if (video_content_encoded) {
+      if (is_video_encrypted) {
         video_content_encodings = ReadTestDataFile("webm_content_encodings");
         tracks_element_size += video_content_encodings->GetDataSize();
       }
     }
 
     *size = ebml_header->GetDataSize() + info->GetDataSize() +
         kTracksHeaderSize + tracks_element_size;
 
     buffer->reset(new uint8[*size]);
 
     uint8* buf = buffer->get();
     memcpy(buf, ebml_header->GetData(), ebml_header->GetDataSize());
     buf += ebml_header->GetDataSize();
 
     memcpy(buf, info->GetData(), info->GetDataSize());
     buf += info->GetDataSize();
 
     memcpy(buf, kTracksHeader, kTracksHeaderSize);
     WriteInt64(buf + kTracksSizeOffset, tracks_element_size);
     buf += kTracksHeaderSize;
 
+    // TODO(xhwang): Simplify this! Probably have test data files that contain

[acolwell GONE FROM CHROMIUM, 2012/10/11 01:11:24]

+1

+    // ContentEncodings directly instead of trying to create one at run-time.
     if (has_audio) {
       memcpy(buf, audio_track_entry->GetData(),
              audio_track_entry->GetDataSize());
+      if (is_audio_encrypted) {
+        memcpy(buf + audio_track_entry->GetDataSize(),
+               audio_content_encodings->GetData(),
+               audio_content_encodings->GetDataSize());
+        WriteInt64(buf + kAudioTrackSizeOffset,
+                   audio_track_entry->GetDataSize() +
+                   audio_content_encodings->GetDataSize() -
+                   kAudioTrackEntryHeaderSize);
+        buf += audio_content_encodings->GetDataSize();
+      }
       buf += audio_track_entry->GetDataSize();
     }
 
     if (has_video) {
       memcpy(buf, video_track_entry->GetData(),
              video_track_entry->GetDataSize());
-      if (video_content_encoded) {
+      if (is_video_encrypted) {
         memcpy(buf + video_track_entry->GetDataSize(),
                video_content_encodings->GetData(),
                video_content_encodings->GetDataSize());
         WriteInt64(buf + kVideoTrackSizeOffset,
                    video_track_entry->GetDataSize() +
                    video_content_encodings->GetDataSize() -
                    kVideoTrackEntryHeaderSize);
         buf += video_content_encodings->GetDataSize();
       }
       buf += video_track_entry->GetDataSize();
@@ skipping 52 matching lines @@
     while (start < end) {
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
     }
     return true;
   }
 
-  bool AppendInitSegment(bool has_audio, bool has_video,
-                         bool video_content_encoded) {
-    return AppendInitSegment(kSourceId, has_audio, has_video,
-                             video_content_encoded);
+  bool AppendInitSegment(bool has_audio, bool has_video) {
+    return AppendInitSegmentWithSourceId(kSourceId, has_audio, has_video);
   }
 
-  bool AppendInitSegment(const std::string& source_id,
-                         bool has_audio, bool has_video,
-                         bool video_content_encoded) {
+  bool AppendInitSegmentWithSourceId(const std::string& source_id,
+                                     bool has_audio, bool has_video) {
+    return AppendInitSegmentWithEncryptedInfo(
+        source_id, has_audio, has_video, false, false);
+  }
+
+  bool AppendInitSegmentWithEncryptedInfo(const std::string& source_id,
+                                          bool has_audio, bool has_video,
+                                          bool is_audio_encrypted,
+                                          bool is_video_encrypted) {
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
-    CreateInitSegment(has_audio, has_video, video_content_encoded,
+    CreateInitSegment(has_audio, has_video,
+                      is_audio_encrypted, is_video_encrypted,
                       &info_tracks, &info_tracks_size);
     return AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   bool AppendGarbage() {
     // Fill up an array with gibberish.
     int garbage_cluster_size = 10;
     scoped_array<uint8> garbage_cluster(new uint8[garbage_cluster_size]);
     for (int i = 0; i < garbage_cluster_size; ++i)
       garbage_cluster[i] = i;
@@ skipping 16 matching lines @@
       EXPECT_CALL(host_, SetDuration(expected_duration));
     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,
-                   bool video_content_encoded) {
+  bool InitDemuxer(bool has_audio, bool has_video) {
+    return InitDemuxerWithEncryptionInfo(has_audio, has_video, false, false);
+  }
+
+  bool InitDemuxerWithEncryptionInfo(
+      bool has_audio, bool has_video,
+      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));
 
     if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
-    return AppendInitSegment(has_audio, has_video, video_content_encoded);
+    return AppendInitSegmentWithEncryptedInfo(
+        kSourceId, has_audio, has_video,
+        is_audio_encrypted, is_video_encrypted);
   }
 
   bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
                                        const std::string& video_id) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
     if (AddId(audio_id, true, false) != ChunkDemuxer::kOk)
       return false;
     if (AddId(video_id, false, true) != ChunkDemuxer::kOk)
       return false;
 
-    bool success = AppendInitSegment(audio_id, true, false, false);
-    success &= AppendInitSegment(video_id, false, true, false);
+    bool success = AppendInitSegmentWithSourceId(audio_id, true, false);
+    success &= AppendInitSegmentWithSourceId(video_id, false, true);
     return success;
   }
 
   // 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
@@ skipping 320 matching lines @@
   MessageLoop message_loop_;
   MockDemuxerHost host_;
 
   scoped_refptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
-  // Test no streams, audio-only, video-only, and audio & video scenarios,
-  // with video encrypted or not.
-  for (int i = 0; i < 8; i++) {
+  // Test no streams, audio-only, video-only, and audio & video scenarios.
+  // Audio and video streams can be encrypted or not encrypted.
+  for (int i = 0; i < 16; i++) {
     bool has_audio = (i & 0x1) != 0;
     bool has_video = (i & 0x2) != 0;
-    bool is_video_encrypted = (i & 0x4) != 0;
+    bool is_audio_encrypted = (i & 0x4) != 0;
+    bool is_video_encrypted = (i & 0x8) != 0;
 
     // No test on invalid combination.
-    if (!has_video && is_video_encrypted)
+    if ((!has_audio && is_audio_encrypted) ||
+        (!has_video && is_video_encrypted)) {
       continue;
+    }
 
     CreateNewDemuxer();
-    if (has_video && is_video_encrypted)
-      EXPECT_CALL(*this, NeedKeyMock(NotNull(), 16));
 
-    ASSERT_TRUE(InitDemuxer(has_audio, has_video, is_video_encrypted));
+    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(NotNull(), 16))
+          .Times(Exactly(need_key_count));
+    }
+
+    ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
+        has_audio, has_video, is_audio_encrypted, is_video_encrypted));
 
     scoped_refptr<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(16, 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(is_audio_encrypted,
+                audio_stream->audio_decoder_config().is_encrypted());
     } else {
       EXPECT_FALSE(audio_stream);
     }
 
     scoped_refptr<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());
@@ skipping 10 matching lines @@
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
 
   EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk);
 
-  EXPECT_TRUE(AppendInitSegment("audio", true, false, false));
+  EXPECT_TRUE(AppendInitSegmentWithSourceId("audio", true, false));
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, TestAppendDataAfterSeek) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   InSequence s;
 
   EXPECT_CALL(*this, Checkpoint(1));
 
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(46),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   EXPECT_CALL(*this, Checkpoint(2));
 
   scoped_ptr<Cluster> cluster(kDefaultSecondCluster());
 
   Checkpoint(1);
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   Checkpoint(2);
 }
 
 // Test that parsing errors are handled for clusters appended after init.
 TEST_F(ChunkDemuxerTest, TestErrorWhileParsingClusterAfterInit) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendGarbage());
 }
 
 // Test the case where a Seek() is requested while the parser
 // is in the middle of cluster. This is to verify that the parser
 // does not reset itself on a seek.
 TEST_F(ChunkDemuxerTest, TestSeekWhileParsingCluster) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   InSequence s;
 
   scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 6));
 
@@ skipping 24 matching lines @@
   // in the new cluster are returned.
   scoped_ptr<Cluster> cluster_b(GenerateCluster(5000, 6));
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
   GenerateExpectedReads(5000, 6, audio, video);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, TestAppendDataBeforeInit) {
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
-  CreateInitSegment(true, true, false, &info_tracks, &info_tracks_size);
+  CreateInitSegment(true, true, false, false, &info_tracks, &info_tracks_size);
 
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, info_tracks.get(),
                                     info_tracks_size));
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
 TEST_F(ChunkDemuxerTest, TestRead) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   audio->Read(base::Bind(&OnReadDone,
                          base::TimeDelta::FromMilliseconds(0),
                          &audio_read_done));
   video->Read(base::Bind(&OnReadDone,
                          base::TimeDelta::FromMilliseconds(0),
                          &video_read_done));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, TestOutOfOrderClusters) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_ptr<Cluster> cluster_a(GenerateCluster(10, 4));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Cluster B starts before cluster_a and has data
   // that overlaps.
   scoped_ptr<Cluster> cluster_b(GenerateCluster(5, 4));
 
   // Make sure that AppendData() does not fail.
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   // Verify that AppendData() can still accept more data.
   scoped_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
   ASSERT_TRUE(demuxer_->AppendData(kSourceId, cluster_c->data(),
                                    cluster_c->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   ClusterBuilder cb;
 
   // Test the case where block timecodes are not monotonically
   // increasing but stay above the cluster timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   AddSimpleBlock(&cb, kAudioTrackNum, 7);
   AddSimpleBlock(&cb, kVideoTrackNum, 15);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   scoped_ptr<Cluster> cluster_b(GenerateCluster(20, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(),
                                     cluster_b->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   ClusterBuilder cb;
 
   // Test timecodes going backwards and including values less than the cluster
   // timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 3);
   AddSimpleBlock(&cb, kVideoTrackNum, 3);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
   scoped_ptr<Cluster> cluster_b(GenerateCluster(6, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(),
                                     cluster_b->size()));
 }
 
 
 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   ClusterBuilder cb;
 
   // Test monotonic increasing timestamps on a per stream
   // basis.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
@@ skipping 36 matching lines @@
 
   CheckExpectedRanges("{ }");
   demuxer_->EndOfStream(PIPELINE_OK);
   ShutdownDemuxer();
   CheckExpectedRanges("{ }");
   demuxer_->RemoveId(kSourceId);
   demuxer_ = NULL;
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithNoMediaAppend) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   CheckExpectedRanges("{ }");
   demuxer_->EndOfStream(PIPELINE_OK);
   CheckExpectedRanges("{ }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
   CheckExpectedRanges(kDefaultFirstClusterRange);
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   demuxer_->EndOfStream(PIPELINE_ERROR_DECODE);
   CheckExpectedRanges(kDefaultFirstClusterRange);
 }
 
 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
   CheckExpectedRanges(kDefaultFirstClusterRange);
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK));
   demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
@@ skipping 43 matching lines @@
   scoped_refptr<Demuxer> demuxer_;
   bool audio_read_done_;
   bool video_read_done_;
 
   DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
 };
 
 // Make sure that all pending reads that we don't have media data for get an
 // "end of stream" buffer when EndOfStream() is called.
 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithPendingReads) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done_1 = false;
@@ skipping 21 matching lines @@
       base::TimeDelta::FromMilliseconds(kVideoBlockDuration)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(true);
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 }
 
 // Make sure that all Read() calls after we get an EndOfStream()
 // call return an "end of stream" buffer.
 TEST_F(ChunkDemuxerTest, TestReadsAfterEndOfStream) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done_1 = false;
@@ skipping 25 matching lines @@
   // Request a few more reads and make sure we immediately get
   // end of stream buffers.
   end_of_stream_helper_2.RequestReads();
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 
   end_of_stream_helper_3.RequestReads();
   end_of_stream_helper_3.CheckIfReadDonesWereCalled(true);
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringCanceledSeek) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   ASSERT_TRUE(AppendCluster(0, 10));
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(138)));
   EXPECT_TRUE(demuxer_->EndOfStream(PIPELINE_OK));
 
   // Start the first seek.
@@ skipping 36 matching lines @@
 // Make sure AppendData() will accept elements that span multiple calls.
 TEST_F(ChunkDemuxerTest, TestAppendingInPieces) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
-  CreateInitSegment(true, true, false, &info_tracks, &info_tracks_size);
+  CreateInitSegment(true, true, 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_array<uint8> buffer(new uint8[buffer_size]);
   uint8* dst = buffer.get();
   memcpy(dst, info_tracks.get(), info_tracks_size);
   dst += info_tracks_size;
 
@@ skipping 83 matching lines @@
     {100, 12},
     {kSkip, kSkip},
   };
 
   ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps,
                             base::TimeDelta::FromMilliseconds(2767)));
 }
 
 // Verify that we output buffers before the entire cluster has been parsed.
 TEST_F(ChunkDemuxerTest, TestIncrementalClusterParsing) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   ASSERT_TRUE(AppendEmptyCluster(0));
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 6));
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
@@ skipping 66 matching lines @@
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN));
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vorbis";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
             ChunkDemuxer::kOk);
 
-  ASSERT_TRUE(AppendInitSegment(true, true, false));
+  ASSERT_TRUE(AppendInitSegment(true, true));
 }
 
 TEST_F(ChunkDemuxerTest, TestAVHeadersWithVideoOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp(),
                                DEMUXER_ERROR_COULD_NOT_OPEN));
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
 
-  ASSERT_TRUE(AppendInitSegment(true, true, false));
+  ASSERT_TRUE(AppendInitSegment(true, true));
 }
 
 TEST_F(ChunkDemuxerTest, TestMultipleHeaders) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Append another identical initialization segment.
-  ASSERT_TRUE(AppendInitSegment(true, true, false));
+  ASSERT_TRUE(AppendInitSegment(true, true));
 
   scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   GenerateExpectedReads(0, 9, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestAddSeparateSourcesForAudioAndVideo) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
@@ skipping 23 matching lines @@
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   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);
 
-  ASSERT_TRUE(AppendInitSegment(audio_id, true, false, false));
+  ASSERT_TRUE(AppendInitSegmentWithSourceId(audio_id, true, 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, TestRemoveId) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
@@ skipping 22 matching lines @@
                          &audio_read_done));
   EXPECT_TRUE(audio_read_done);
 
   // Read() from video should still return normal buffers.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateSingleStreamExpectedReads(0, 4, video, kVideoBlockDuration);
 }
 
 TEST_F(ChunkDemuxerTest, TestSeekCanceled) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Append cluster at the beginning of the stream.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
   ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size()));
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
   demuxer_->StartWaitingForSeek();
   demuxer_->Seek(base::TimeDelta::FromSeconds(0),
                  NewExpectedStatusCB(PIPELINE_OK));
   GenerateExpectedReads(0, 4, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestSeekCanceledWhileWaitingForSeek) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Append cluster at the beginning of the stream.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
   ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size()));
 
@@ skipping 86 matching lines @@
   EXPECT_TRUE(video_read_done);
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk);
-  ASSERT_TRUE(AppendInitSegment(true, false, false));
+  ASSERT_TRUE(AppendInitSegment(true, false));
 
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 92,
                                 kAudioTrackNum, kAudioBlockDuration));
   ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size()));
 
   CheckExpectedRanges("{ [0,92) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 219,
                                 kAudioTrackNum, kAudioBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size()));
 
   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));
 
   ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk);
-  ASSERT_TRUE(AppendInitSegment(false, true, false));
+  ASSERT_TRUE(AppendInitSegment(false, true));
 
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 132,
                                 kVideoTrackNum, kVideoBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size()));
 
   CheckExpectedRanges("{ [0,132) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(200, 299,
                                 kVideoTrackNum, kVideoBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size()));
 
   CheckExpectedRanges("{ [0,132) [200,299) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   // Audio: 0 -> 23
   // Video: 0 -> 33
   // Buffered Range: 0 -> 23
   // Audio block duration is smaller than video block duration,
   // so the buffered ranges should correspond to the audio blocks.
   scoped_ptr<Cluster> cluster_a0(
       GenerateSingleStreamCluster(0, kAudioBlockDuration, kAudioTrackNum,
                                   kAudioBlockDuration));
 
@@ skipping 73 matching lines @@
   scoped_ptr<Cluster> cluster_v5(
       GenerateSingleStreamCluster(1230, 1240, kVideoTrackNum, 10));
   ASSERT_TRUE(AppendData(cluster_v5->data(), cluster_v5->size()));
   CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
 }
 
 // Once EndOfStream() is called, GetBufferedRanges should not cut off any
 // over-hanging tails at the end of the ranges as this is likely due to block
 // duration differences.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_EndOfStream) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster_a(
       GenerateSingleStreamCluster(0, 90, kAudioTrackNum, 90));
   scoped_ptr<Cluster> cluster_v(
       GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 100));
 
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
   ASSERT_TRUE(AppendData(cluster_v->data(), cluster_v->size()));
 
   CheckExpectedRanges("{ [0,90) }");
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(100)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   CheckExpectedRanges("{ [0,100) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Create a cluster where the video timecode begins 25ms after the audio.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 25, 8));
   ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size()));
 
@@ skipping 63 matching lines @@
   ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
 
   // Should not be able to fulfill a seek to 0.
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(0),
                  NewExpectedStatusCB(PIPELINE_ERROR_ABORT));
   ExpectRead(audio, 0);
   ExpectEndOfStream(video);
 }
 
 TEST_F(ChunkDemuxerTest, TestClusterWithNoBuffers) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   // Generate and append an empty cluster beginning at 0.
   ASSERT_TRUE(AppendEmptyCluster(0));
 
   // Sanity check that data can be appended after this cluster correctly.
   scoped_ptr<Cluster> media_data(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(media_data->data(), media_data->size()));
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
@@ skipping 75 matching lines @@
 
   CheckExpectedRanges("audio", "{ }");
   CheckExpectedRanges("video", "{ }");
 }
 
 // Test that Seek() completes successfully when the first cluster
 // arrives.
 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringSeek) {
   InSequence s;
 
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   demuxer_->StartWaitingForSeek();
 
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp)));
@@ skipping 155 matching lines @@
                  NewExpectedStatusCB(PIPELINE_OK));
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(801),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   // Verify that no config change is signalled.
   ExpectRead(stream, 801);
   ASSERT_TRUE(video_config_1.Matches(stream->video_decoder_config()));
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(30)));
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   demuxer_->StartWaitingForSeek();
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(30000),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateExpectedReads(30000, 2, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampNegativeOffset) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(-1)));
   scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2);
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
@@ skipping 45 matching lines @@
       audio_id, base::TimeDelta::FromMilliseconds(27300)));
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       video_id, base::TimeDelta::FromMilliseconds(27300)));
   ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
   GenerateSingleStreamExpectedReads(27300, 4, video, kVideoBlockDuration);
   GenerateSingleStreamExpectedReads(27300, 4, audio, kAudioBlockDuration);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampOffsetMidParse) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13));
 
   // Setting a timestamp should fail because we're in the middle of a cluster.
   ASSERT_FALSE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(25)));
 
   demuxer_->Abort(kSourceId);
   // After Abort(), setting a timestamp should succeed since we're no longer
   // in the middle of a cluster
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(25)));
 }
 
 TEST_F(ChunkDemuxerTest, TestDurationChange) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
   static const int kStreamDuration = kDefaultDuration().InMilliseconds();
 
   // Add data leading up to the currently set duration.
   scoped_ptr<Cluster> first_cluster = GenerateCluster(
       kStreamDuration - kAudioBlockDuration,
       kStreamDuration - kVideoBlockDuration, 2);
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
   CheckExpectedRanges(kSourceId, "{ [201191,201224) }");
 
@@ skipping 13 matching lines @@
       kStreamDuration + kVideoBlockDuration, 2);
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kNewStreamDuration)));
   ASSERT_TRUE(AppendData(third_cluster->data(), third_cluster->size()));
 
   // See that the range has increased appropriately.
   CheckExpectedRanges(kSourceId, "{ [201191,201270) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDurationChangeTimestampOffset) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, kDefaultDuration()));
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 4);
 
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kAudioBlockDuration * 2)));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamTruncateDuration) {
-  ASSERT_TRUE(InitDemuxer(true, true, false));
+  ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp)));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 }  // namespace media