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* CreateParser() {

[xhwang, 2015/07/21 04:28:31]

Looking at the call sites below, it's a bit hard to track which version of
CreateParser() is called without looking at these definitions and comments.
Maybe we should follow the style guide more rigorously to favor more explicit
function names to function overloads. For example, this one can be
CreateDefaultParser.

[wolenetz, 2015/07/21 18:15:56]

Done (and good point!) I hadn't read that particular overload style guidance
recently.

+  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* CreateParser(
+    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* CreateParser(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* CreateParser(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_(CreateParser()) {}
 
  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(CreateParser(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(
+      CreateParser(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(CreateParser(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(CreateParser(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(CreateParser(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(CreateParser(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(
+      CreateParser(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(
+      CreateParser(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(CreateParser(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(CreateParser(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(CreateParser(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(CreateParser(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