MSE: Populate WebM missing duration with DefaultDuration, derived, or default

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 "base/bind.h"
 #include "base/logging.h"
 #include "media/base/decrypt_config.h"
 #include "media/formats/webm/cluster_builder.h"
@@ skipping 18 matching lines @@
 struct BlockInfo {
   int track_num;
   int timestamp;
   int duration;
   bool use_simple_block;
 };
 
 static const BlockInfo kDefaultBlockInfo[] = {
   { kAudioTrackNum, 0, 23, true },
   { kAudioTrackNum, 23, 23, true },
-  { kVideoTrackNum, 33, 34, true },
+  { kVideoTrackNum, 33, 34, true },  // Assumes not using DefaultDuration
   { kAudioTrackNum, 46, 23, true },
   { kVideoTrackNum, 67, 33, false },
   { kAudioTrackNum, 69, 23, false },
   { kVideoTrackNum, 100, 33, false },
 };
 
 static const uint8 kEncryptedFrame[] = {
   0x01,  // Block is encrypted
   0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08  // IV
 };
@@ skipping 64 matching lines @@
       LOG(ERROR) << "Unexpected track number " << block_info[i].track_num;
       return false;
     }
 
     if (*offset >= buffers->size())
       return false;
 
     scoped_refptr<StreamParserBuffer> buffer = (*buffers)[(*offset)++];
 
     EXPECT_EQ(block_info[i].timestamp, buffer->timestamp().InMilliseconds());
-
-    if (!block_info[i].use_simple_block)
-      EXPECT_NE(kNoTimestamp(), buffer->duration());
-
-    if (buffer->duration() != kNoTimestamp())
-      EXPECT_EQ(block_info[i].duration, buffer->duration().InMilliseconds());
-
+    EXPECT_EQ(block_info[i].duration, buffer->duration().InMilliseconds());
     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) {
   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->audio_buffers(),
-                       parser->video_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,
@@ skipping 37 matching lines @@
        itr != src.end(); ++itr) {
     dest->push_back(*itr);
   }
 }
 
 class WebMClusterParserTest : public testing::Test {
  public:
   WebMClusterParserTest()
       : parser_(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
+                                      kNoTimestamp(),
                                       kVideoTrackNum,
+                                      kNoTimestamp(),
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
                                       LogCB())) {}
 
  protected:
   scoped_ptr<WebMClusterParser> parser_;
 };
 
@@ skipping 45 matching lines @@
     ASSERT_GE(result, 0);
     ASSERT_LE(result, parse_size);
 
     if (result == 0) {
       // The parser needs more data so increase the parse_size a little.
       parse_size += default_parse_size;
       parse_size = std::min(parse_size, size);
       continue;
     }
 
-    AppendToEnd(parser_->audio_buffers(), &audio_buffers);
-    AppendToEnd(parser_->video_buffers(), &video_buffers);
+    AppendToEnd(parser_->GetAudioBuffers(), &audio_buffers);
+    AppendToEnd(parser_->GetVideoBuffers(), &video_buffers);
 
     parse_size = default_parse_size;
 
     data += result;
     size -= result;
   }
   ASSERT_TRUE(VerifyBuffers(audio_buffers, video_buffers,
                             no_text_buffers, kDefaultBlockInfo,
                             block_count));
 }
@@ skipping 44 matching lines @@
   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(),
                                       WebMTracksParser::TextTracks(),
                                       ignored_tracks,
                                       std::string(),
                                       std::string(),
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 33, true },
+    { kVideoTrackNum, 33, 34, true },
     { kTextTrackNum,  33, 99, true },
     { kAudioTrackNum, 46, 23, true },
-    { kVideoTrackNum, 67, 33, true },
+    { kVideoTrackNum, 67, 34, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   const BlockInfo kOutputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 33, true },
+    { kVideoTrackNum, 33, 34, true },
     { kAudioTrackNum, 46, 23, true },
-    { kVideoTrackNum, 67, 33, true },
+    { kVideoTrackNum, 67, 34, true },
   };
   int output_block_count = arraysize(kOutputBlockInfo);
 
   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_, kOutputBlockInfo, output_block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseTextTracks) {
   typedef WebMTracksParser::TextTracks TextTracks;
   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(),
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 33, true },
+    { kVideoTrackNum, 33, 34, true },
     { kTextTrackNum,  33, 42, false },
     { kAudioTrackNum, 46, 23, true },
     { kTextTrackNum, 55, 44, false },
-    { kVideoTrackNum, 67, 33, true },
+    { kVideoTrackNum, 67, 34, 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_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kInputBlockInfo, input_block_count));
 }
 
 TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   typedef WebMTracksParser::TextTracks TextTracks;
   WebMTracksParser::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(),
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
@@ skipping 15 matching lines @@
   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(),
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kAudioTrackNum, 0,  23, true },
     { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 33, true },
+    { kVideoTrackNum, 33, 34, true },
     { kSubtitleTextTrackNum,  33, 42, false },
     { kAudioTrackNum, 46, 23, true },
     { kCaptionTextTrackNum, 55, 44, false },
-    { kVideoTrackNum, 67, 33, true },
+    { kVideoTrackNum, 67, 34, true },
     { kSubtitleTextTrackNum,  67, 33, false },
   };
   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);
 
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser_->GetTextBuffers();
   for (WebMClusterParser::TextBufferQueueMap::const_iterator itr =
            text_map.begin();
        itr != text_map.end();
        ++itr) {
     const WebMTracksParser::TextTracks::const_iterator find_result =
         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(),
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
-  ASSERT_EQ(1UL, parser_->video_buffers().size());
-  scoped_refptr<StreamParserBuffer> buffer = parser_->video_buffers()[0];
+  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(),
                                       WebMTracksParser::TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidZeroSizedCluster) {
   const uint8 kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x80,  // CLUSTER (size = 0)
   };
 
   EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidUnknownButActuallyZeroSizedCluster) {
   const uint8 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)));
 }
 
 }  // namespace media