MSE: Add StreamParser buffer remuxing utility and tests

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 78 matching lines @@
                           const WebMClusterParser::BufferQueue& video_buffers,
                           const WebMClusterParser::BufferQueue& text_buffers,
                           const BlockInfo* block_info,
                           int block_count) {
   size_t audio_offset = 0;
   size_t video_offset = 0;
   size_t text_offset = 0;
   for (int i = 0; i < block_count; i++) {
     const WebMClusterParser::BufferQueue* buffers = NULL;
     size_t* offset;
+    StreamParserBuffer::Type expected_type = StreamParserBuffer::kAudio;

[xhwang, 2014/01/29 08:04:50]

kAudio/UNKNOWN here, then set expected_type to kAudio after line 103?

[wolenetz, 2014/02/05 02:49:53]

Done.

 
     if (block_info[i].track_num == kAudioTrackNum) {
       buffers = &audio_buffers;
       offset = &audio_offset;
     } else if (block_info[i].track_num == kVideoTrackNum) {
       buffers = &video_buffers;
       offset = &video_offset;
+      expected_type = StreamParserBuffer::kVideo;
     } else if (block_info[i].track_num == kTextTrackNum) {
       buffers = &text_buffers;
       offset = &text_offset;
+      expected_type = StreamParserBuffer::kText;
     } else {
       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(buffer->timestamp().InMilliseconds(), block_info[i].timestamp);
 
     if (!block_info[i].use_simple_block)
       EXPECT_NE(buffer->duration(), kNoTimestamp());
 
     if (buffer->duration() != kNoTimestamp())
       EXPECT_EQ(buffer->duration().InMilliseconds(), block_info[i].duration);
+
+    EXPECT_EQ(buffer->type(), expected_type);
+    if (expected_type == StreamParserBuffer::kText)
+      EXPECT_EQ(buffer->text_track_number(), kTextTrackNum);
   }
 
   return true;
 }
 
 static bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
                           const BlockInfo* block_info,
                           int block_count) {
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser->GetTextBuffers();
@@ skipping 28 matching lines @@
 
     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(buffer->timestamp().InMilliseconds(), block_info.timestamp);
     EXPECT_EQ(buffer->duration().InMilliseconds(), block_info.duration);
+    EXPECT_EQ(buffer->type(), StreamParserBuffer::kText);
+    EXPECT_EQ(buffer->text_track_number(), text_track_num);

[xhwang, 2014/01/29 08:04:50]

FYI, we use EXPECT_EQ(expected, variable) style, not EXPECT_EQ(variable,
expected);

[wolenetz, 2014/02/05 02:49:53]

Done, also conformed a bunch of other places in this file to this.

   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
 static void VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
   EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
@@ skipping 345 matching lines @@
 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(parser_->Parse(kBuffer, sizeof(kBuffer)), -1);
 }
 
 }  // namespace media