Refactor WebMClusterParserTest parser creation for readability

media/formats/webm/webm_cluster_parser_unittest.cc

 // Copyright 2014 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 <cstdlib>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decrypt_config.h"
 #include "media/formats/webm/cluster_builder.h"
 #include "media/formats/webm/opus_packet_builder.h"
 #include "media/formats/webm/webm_cluster_parser.h"
 #include "media/formats/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::_;
 
 namespace media {
 
 typedef WebMTracksParser::TextTracks TextTracks;
 
+namespace {
+
 enum {
   kTimecodeScale = 1000000,  // Timecode scale for millisecond timestamps.
   kAudioTrackNum = 1,
   kVideoTrackNum = 2,
   kTextTrackNum = 3,
   kTestAudioFrameDefaultDurationInMs = 13,
   kTestVideoFrameDefaultDurationInMs = 17
 };
 
 // Test duration defaults must differ from parser estimation defaults to know
@@ skipping 18 matching lines @@
   // parser verification.
   double duration;
 
   bool use_simple_block;
 
   // Default data will be used if no data given.
   const uint8_t* data;
   int data_length;
 };
 
-static const BlockInfo kDefaultBlockInfo[] = {
+const BlockInfo kDefaultBlockInfo[] = {
     {kAudioTrackNum, 0, 23, true, NULL, 0},
     {kAudioTrackNum, 23, 23, true, NULL, 0},
     // Assumes not using DefaultDuration
     {kVideoTrackNum, 33, 34, true, NULL, 0},
     {kAudioTrackNum, 46, 23, true, NULL, 0},
     {kVideoTrackNum, 67, 33, false, NULL, 0},
     {kAudioTrackNum, 69, 23, false, NULL, 0},
     {kVideoTrackNum, 100, 33, false, NULL, 0},
 };
 
-static const uint8_t kEncryptedFrame[] = {
-  0x01,  // Block is encrypted
-  0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08  // IV
-};
+const uint8_t kEncryptedFrame[] = {
+    // Block is encrypted
+    0x01,
 
-static scoped_ptr<Cluster> CreateCluster(int timecode,
-                                         const BlockInfo* block_info,
-                                         int block_count) {
+    // IV
+    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
+
+// Helper that hard-codes some non-varying constructor parameters.
+WebMClusterParser* CreateParserHelper(
+    base::TimeDelta audio_default_duration,
+    base::TimeDelta video_default_duration,
+    const WebMTracksParser::TextTracks& text_tracks,
+    const std::set<int64>& ignored_tracks,
+    const std::string& audio_encryption_key_id,
+    const std::string& video_encryption_key_id,
+    const AudioCodec audio_codec) {
+  return new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, audio_default_duration, kVideoTrackNum,
+      video_default_duration, text_tracks, ignored_tracks,
+      audio_encryption_key_id, video_encryption_key_id, audio_codec,
+      new MediaLog());
+}
+
+// Create a default version of the parser for test.
+WebMClusterParser* CreateDefaultParser() {
+  return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
+                            std::set<int64>(), std::string(), std::string(),
+                            kUnknownAudioCodec);
+}
+
+// Create a parser for test with custom audio and video default durations, and
+// optionally custom text tracks.
+WebMClusterParser* CreateParserWithDefaultDurationsAndOptionalTextTracks(
+    base::TimeDelta audio_default_duration,
+    base::TimeDelta video_default_duration,
+    const WebMTracksParser::TextTracks& text_tracks = TextTracks()) {
+  return CreateParserHelper(audio_default_duration, video_default_duration,
+                            text_tracks, std::set<int64>(), std::string(),
+                            std::string(), kUnknownAudioCodec);
+}
+
+// Create a parser for test with custom ignored tracks.
+WebMClusterParser* CreateParserWithIgnoredTracks(
+    std::set<int64>& ignored_tracks) {
+  return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
+                            ignored_tracks, std::string(), std::string(),
+                            kUnknownAudioCodec);
+}
+
+// Create a parser for test with custom encryption key ids and audio codec.
+WebMClusterParser* CreateParserWithKeyIdsAndAudioCodec(
+    const std::string& audio_encryption_key_id,
+    const std::string& video_encryption_key_id,
+    const AudioCodec audio_codec) {
+  return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
+                            std::set<int64>(), audio_encryption_key_id,
+                            video_encryption_key_id, audio_codec);
+}
+
+scoped_ptr<Cluster> CreateCluster(int timecode,
+                                  const BlockInfo* block_info,
+                                  int block_count) {
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
 
   uint8_t kDefaultBlockData[] = { 0x00 };
 
   for (int i = 0; i < block_count; i++) {
     const uint8_t* data;
     int data_length;
     if (block_info[i].data != NULL) {
       data = block_info[i].data;
@@ skipping 19 matching lines @@
 
     cb.AddBlockGroup(block_info[i].track_num, block_info[i].timestamp,
                      block_info[i].duration, 0, data, data_length);
   }
 
   return cb.Finish();
 }
 
 // Creates a Cluster with one encrypted Block. |bytes_to_write| is number of
 // bytes of the encrypted frame to write.
-static scoped_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
+scoped_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
   CHECK_GT(bytes_to_write, 0);
   CHECK_LE(bytes_to_write, static_cast<int>(sizeof(kEncryptedFrame)));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   cb.AddSimpleBlock(kVideoTrackNum, 0, 0, kEncryptedFrame, bytes_to_write);
   return cb.Finish();
 }
 
-static bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
-                          const WebMClusterParser::BufferQueue& video_buffers,
-                          const WebMClusterParser::BufferQueue& text_buffers,
-                          const BlockInfo* block_info,
-                          int block_count) {
+bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
+                   const WebMClusterParser::BufferQueue& video_buffers,
+                   const WebMClusterParser::BufferQueue& text_buffers,
+                   const BlockInfo* block_info,
+                   int block_count) {
   int buffer_count = audio_buffers.size() + video_buffers.size() +
       text_buffers.size();
   if (block_count != buffer_count) {
     DVLOG(1) << __FUNCTION__ << " : block_count (" << block_count
              << ") mismatches buffer_count (" << buffer_count << ")";
     return false;
   }
 
   size_t audio_offset = 0;
   size_t video_offset = 0;
@@ skipping 32 matching lines @@
     EXPECT_EQ(block_info[i].timestamp, buffer->timestamp().InMilliseconds());
     EXPECT_EQ(std::abs(block_info[i].duration),
               buffer->duration().InMillisecondsF());
     EXPECT_EQ(expected_type, buffer->type());
     EXPECT_EQ(block_info[i].track_num, buffer->track_id());
   }
 
   return true;
 }
 
-static bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
-                          const BlockInfo* block_info,
-                          int block_count) {
+bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
+                   const BlockInfo* block_info,
+                   int block_count) {
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser->GetTextBuffers();
   const WebMClusterParser::BufferQueue* text_buffers;
   const WebMClusterParser::BufferQueue no_text_buffers;
   if (!text_map.empty())
     text_buffers = &(text_map.rbegin()->second);
   else
     text_buffers = &no_text_buffers;
 
   return VerifyBuffers(parser->GetAudioBuffers(),
                        parser->GetVideoBuffers(),
                        *text_buffers,
                        block_info,
                        block_count);
 }
 
-static bool VerifyTextBuffers(
-    const scoped_ptr<WebMClusterParser>& parser,
-    const BlockInfo* block_info_ptr,
-    int block_count,
-    int text_track_num,
-    const WebMClusterParser::BufferQueue& text_buffers) {
+bool VerifyTextBuffers(const scoped_ptr<WebMClusterParser>& parser,
+                       const BlockInfo* block_info_ptr,
+                       int block_count,
+                       int text_track_num,
+                       const WebMClusterParser::BufferQueue& text_buffers) {
   const BlockInfo* const block_info_end = block_info_ptr + block_count;
 
   typedef WebMClusterParser::BufferQueue::const_iterator TextBufferIter;
   TextBufferIter buffer_iter = text_buffers.begin();
   const TextBufferIter buffer_end = text_buffers.end();
 
   while (block_info_ptr != block_info_end) {
     const BlockInfo& block_info = *block_info_ptr++;
 
     if (block_info.track_num != text_track_num)
       continue;
 
     EXPECT_FALSE(block_info.use_simple_block);
     EXPECT_FALSE(buffer_iter == buffer_end);
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
     EXPECT_EQ(block_info.timestamp, buffer->timestamp().InMilliseconds());
     EXPECT_EQ(std::abs(block_info.duration),
               buffer->duration().InMillisecondsF());
     EXPECT_EQ(DemuxerStream::TEXT, buffer->type());
     EXPECT_EQ(text_track_num, buffer->track_id());
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
-static void VerifyEncryptedBuffer(
-    scoped_refptr<StreamParserBuffer> buffer) {
+void VerifyEncryptedBuffer(scoped_refptr<StreamParserBuffer> buffer) {
   EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
             buffer->decrypt_config()->iv().length());
 }
 
-static void AppendToEnd(const WebMClusterParser::BufferQueue& src,
-                        WebMClusterParser::BufferQueue* dest) {
+void AppendToEnd(const WebMClusterParser::BufferQueue& src,
+                 WebMClusterParser::BufferQueue* dest) {
   for (WebMClusterParser::BufferQueue::const_iterator itr = src.begin();
        itr != src.end(); ++itr) {
     dest->push_back(*itr);
   }
 }
 
+}  // namespace
+
 class WebMClusterParserTest : public testing::Test {
  public:
-  WebMClusterParserTest()
-      : parser_(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      TextTracks(),
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      new MediaLog())) {}
+  WebMClusterParserTest() : parser_(CreateDefaultParser()) {}
 
  protected:
   void ResetParserToHaveDefaultDurations() {
     base::TimeDelta default_audio_duration = base::TimeDelta::FromMilliseconds(
         kTestAudioFrameDefaultDurationInMs);
     base::TimeDelta default_video_duration = base::TimeDelta::FromMilliseconds(
         kTestVideoFrameDefaultDurationInMs);
     ASSERT_GE(default_audio_duration, base::TimeDelta());
     ASSERT_GE(default_video_duration, base::TimeDelta());
     ASSERT_NE(kNoTimestamp(), default_audio_duration);
     ASSERT_NE(kNoTimestamp(), default_video_duration);
 
-    parser_.reset(new WebMClusterParser(
-        kTimecodeScale, kAudioTrackNum, default_audio_duration, kVideoTrackNum,
-        default_video_duration, TextTracks(), std::set<int64>(), std::string(),
-        std::string(), kUnknownAudioCodec, new MediaLog()));
+    parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+        default_audio_duration, default_video_duration));
   }
 
   scoped_ptr<WebMClusterParser> parser_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMClusterParserTest);
 };
 
 TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
   // If a buffer is missing duration and is being held back, then all other
   // tracks' buffers that have same or higher (decode) timestamp should be held
   // back too to keep the timestamps emitted for a cluster monotonically
   // non-decreasing and in same order as parsed.
   InSequence s;
 
   // Reset the parser to have 3 tracks: text, video (no default frame duration),
   // and audio (with a default frame duration).
   TextTracks text_tracks;
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
   base::TimeDelta default_audio_duration =
       base::TimeDelta::FromMilliseconds(kTestAudioFrameDefaultDurationInMs);
   ASSERT_GE(default_audio_duration, base::TimeDelta());
   ASSERT_NE(kNoTimestamp(), default_audio_duration);
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, default_audio_duration, kVideoTrackNum,
-      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+      default_audio_duration, kNoTimestamp(), text_tracks));
 
   const BlockInfo kBlockInfo[] = {
       {kVideoTrackNum, 0, 33, true, NULL, 0},
       {kAudioTrackNum, 0, 23, false, NULL, 0},
       {kTextTrackNum, 10, 42, false, NULL, 0},
       {kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kVideoTrackNum, 33, 33, true, NULL, 0},
       {kAudioTrackNum, 36, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kVideoTrackNum, 66, 33, true, NULL, 0},
       {kAudioTrackNum, 70, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
@@ skipping 162 matching lines @@
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
   std::set<int64> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), ignored_tracks, std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithIgnoredTracks(ignored_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kTextTrackNum, 33, 99, true, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
@@ skipping 15 matching lines @@
   ASSERT_TRUE(VerifyBuffers(parser_, kOutputBlockInfo, output_block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseTextTracks) {
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+      kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kTextTrackNum, 33, 42, false, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kTextTrackNum, 55, 44, false, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kInputBlockInfo, input_block_count));
 }
 
 TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+      kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
 TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
   TextTracks text_tracks;
 
   const int kSubtitleTextTrackNum = kTextTrackNum;
   const int kCaptionTextTrackNum = kTextTrackNum + 1;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kSubtitleTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kCaptionTextTrackNum),
                                     TextTrackConfig(kTextCaptions, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+      kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kSubtitleTextTrackNum, 33, 42, false, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kCaptionTextTrackNum, 55, 44, false, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
       {kSubtitleTextTrackNum, 67, 33, false, NULL, 0},
@@ skipping 16 matching lines @@
         text_tracks.find(itr->first);
     ASSERT_TRUE(find_result != text_tracks.end());
     ASSERT_TRUE(VerifyTextBuffers(parser_, kInputBlockInfo, input_block_count,
                                   itr->first, itr->second));
   }
 }
 
 TEST_F(WebMClusterParserTest, ParseEncryptedBlock) {
   scoped_ptr<Cluster> cluster(CreateEncryptedCluster(sizeof(kEncryptedFrame)));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      "video_key_id", kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
+      std::string(), "video_key_id", kUnknownAudioCodec));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_EQ(1UL, parser_->GetVideoBuffers().size());
   scoped_refptr<StreamParserBuffer> buffer = parser_->GetVideoBuffers()[0];
   VerifyEncryptedBuffer(buffer);
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   scoped_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      "video_key_id", kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
+      std::string(), "video_key_id", kUnknownAudioCodec));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidZeroSizedCluster) {
   const uint8_t kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x80,  // CLUSTER (size = 0)
   };
 
   EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidUnknownButActuallyZeroSizedCluster) {
   const uint8_t kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0xFF,  // CLUSTER (size = "unknown")
     0x1F, 0x43, 0xB6, 0x75, 0x85,  // CLUSTER (size = 5)
   };
 
   EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidTextBlockGroupWithoutDuration) {
   // Text track frames must have explicitly specified BlockGroup BlockDurations.
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
-      std::string(), kUnknownAudioCodec, new MediaLog()));
+  parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
+      kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kBlockInfo[] = {
     { kTextTrackNum,  33, -42, false },
   };
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
@@ skipping 227 matching lines @@
 
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ReadOpusDurationsSimpleBlockAtEndOfCluster) {
   // Reset parser to expect Opus codec audio.
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      std::string(), kCodecOpus, new MediaLog()));
+  parser_.reset(CreateParserWithKeyIdsAndAudioCodec(std::string(),
+                                                    std::string(), kCodecOpus));
 
   int loop_count = 0;
   for (const auto* packet_ptr : BuildAllOpusPackets()) {
     const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
                                      0,
                                      packet_ptr->duration_ms(),
                                      true,  // Make it a SimpleBlock.
                                      packet_ptr->data(),
                                      packet_ptr->size()}};
 
     int block_count = arraysize(kBlockInfo);
     scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
     int result = parser_->Parse(cluster->data(), cluster->size());
     EXPECT_EQ(cluster->size(), result);
     ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
     loop_count++;
   }
 
   // Test should minimally cover all the combinations of config and frame count.
   ASSERT_GE(loop_count, kNumPossibleOpusConfigs * kMaxOpusPacketFrameCount);
 }
 
 TEST_F(WebMClusterParserTest, PreferOpusDurationsOverBlockDurations) {
   // Reset parser to expect Opus codec audio.
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      std::string(), kCodecOpus, new MediaLog()));
+  parser_.reset(CreateParserWithKeyIdsAndAudioCodec(std::string(),
+                                                    std::string(), kCodecOpus));
 
   int loop_count = 0;
   for (const auto* packet_ptr : BuildAllOpusPackets()) {
     // Setting BlockDuration != Opus duration to see which one the parser uses.
     int block_duration_ms = packet_ptr->duration_ms() + 10;
 
     BlockInfo block_infos[] = {{kAudioTrackNum,
                                 0,
                                 block_duration_ms,
                                 false,  // Not a SimpleBlock.
@@ skipping 18 matching lines @@
 }
 
 // Tests that BlockDuration is used to set duration on buffer rather than
 // encoded duration in Opus packet (or hard coded duration estimates). Encoded
 // Opus duration is usually preferred but cannot be known when encrypted.
 TEST_F(WebMClusterParserTest, DontReadEncodedDurationWhenEncrypted) {
   // Non-empty dummy value signals encryption is active for audio.
   std::string audio_encryption_id("audio_key_id");
 
   // Reset parser to expect Opus codec audio and use audio encryption key id.
-  parser_.reset(new WebMClusterParser(
-      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
-      kNoTimestamp(), TextTracks(), std::set<int64>(), audio_encryption_id,
-      std::string(), kCodecOpus, new MediaLog()));
+  parser_.reset(CreateParserWithKeyIdsAndAudioCodec(audio_encryption_id,
+                                                    std::string(), kCodecOpus));
 
   // Single Block with BlockDuration and encrypted data.
   const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
                                    0,
                                    kTestAudioFrameDefaultDurationInMs,
                                    false,            // Not a SimpleBlock
                                    kEncryptedFrame,  // Encrypted frame data
                                    arraysize(kEncryptedFrame)}};
 
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   // Will verify that duration of buffer matches that of BlockDuration.
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 }  // namespace media