media/formats/webm/webm_parser_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/formats/webm/cluster_builder.h"
   6 #include "media/formats/webm/webm_constants.h"
   7 #include "media/formats/webm/webm_parser.h"
   8 #include "testing/gmock/include/gmock/gmock.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using ::testing::InSequence;
  12 using ::testing::Return;
  13 using ::testing::ReturnNull;
  14 using ::testing::StrictMock;
  15 using ::testing::_;
  16
  17 namespace media {
  18
  19 enum { kBlockCount = 5 };
  20
  21 class MockWebMParserClient : public WebMParserClient {
  22  public:
  23   virtual ~MockWebMParserClient() {}
  24
  25   // WebMParserClient methods.
  26   MOCK_METHOD1(OnListStart, WebMParserClient*(int));
  27   MOCK_METHOD1(OnListEnd, bool(int));
  28   MOCK_METHOD2(OnUInt, bool(int, int64));
  29   MOCK_METHOD2(OnFloat, bool(int, double));
  30   MOCK_METHOD3(OnBinary, bool(int, const uint8*, int));
  31   MOCK_METHOD2(OnString, bool(int, const std::string&));
  32 };
  33
  34 class WebMParserTest : public testing::Test {
  35  protected:
  36   StrictMock<MockWebMParserClient> client_;
  37 };
  38
  39 static scoped_ptr<Cluster> CreateCluster(int block_count) {
  40   ClusterBuilder cb;
  41   cb.SetClusterTimecode(0);
  42
  43   for (int i = 0; i < block_count; i++) {
  44     uint8 data[] = { 0x00 };
  45     cb.AddSimpleBlock(0, i, 0, data, sizeof(data));
  46   }
  47
  48   return cb.Finish();
  49 }
  50
  51 static void CreateClusterExpectations(int block_count,
  52                                       bool is_complete_cluster,
  53                                       MockWebMParserClient* client) {
  54
  55   InSequence s;
  56   EXPECT_CALL(*client, OnListStart(kWebMIdCluster)).WillOnce(Return(client));
  57   EXPECT_CALL(*client, OnUInt(kWebMIdTimecode, 0))
  58       .WillOnce(Return(true));
  59
  60   for (int i = 0; i < block_count; i++) {
  61     EXPECT_CALL(*client, OnBinary(kWebMIdSimpleBlock, _, _))
  62         .WillOnce(Return(true));
  63   }
  64
  65   if (is_complete_cluster)
  66     EXPECT_CALL(*client, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
  67 }
  68
  69 TEST_F(WebMParserTest, EmptyCluster) {
  70   const uint8 kEmptyCluster[] = {
  71     0x1F, 0x43, 0xB6, 0x75, 0x80  // CLUSTER (size = 0)
  72   };
  73   int size = sizeof(kEmptyCluster);
  74
  75   InSequence s;
  76   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
  77   EXPECT_CALL(client_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
  78
  79   WebMListParser parser(kWebMIdCluster, &client_);
  80   EXPECT_EQ(size, parser.Parse(kEmptyCluster, size));
  81   EXPECT_TRUE(parser.IsParsingComplete());
  82 }
  83
  84 TEST_F(WebMParserTest, EmptyClusterInSegment) {
  85   const uint8 kBuffer[] = {
  86     0x18, 0x53, 0x80, 0x67, 0x85,  // SEGMENT (size = 5)
  87     0x1F, 0x43, 0xB6, 0x75, 0x80,  // CLUSTER (size = 0)
  88   };
  89   int size = sizeof(kBuffer);
  90
  91   InSequence s;
  92   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(Return(&client_));
  93   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
  94   EXPECT_CALL(client_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
  95   EXPECT_CALL(client_, OnListEnd(kWebMIdSegment)).WillOnce(Return(true));
  96
  97   WebMListParser parser(kWebMIdSegment, &client_);
  98   EXPECT_EQ(size, parser.Parse(kBuffer, size));
  99   EXPECT_TRUE(parser.IsParsingComplete());
 100 }
 101
 102 // Test the case where a non-list child element has a size
 103 // that is beyond the end of the parent.
 104 TEST_F(WebMParserTest, ChildNonListLargerThanParent) {
 105   const uint8 kBuffer[] = {
 106     0x1F, 0x43, 0xB6, 0x75, 0x81,  // CLUSTER (size = 1)
 107     0xE7, 0x81, 0x01,  // Timecode (size=1, value=1)
 108   };
 109
 110   InSequence s;
 111   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
 112
 113   WebMListParser parser(kWebMIdCluster, &client_);
 114   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 115   EXPECT_FALSE(parser.IsParsingComplete());
 116 }
 117
 118 // Test the case where a list child element has a size
 119 // that is beyond the end of the parent.
 120 TEST_F(WebMParserTest, ChildListLargerThanParent) {
 121   const uint8 kBuffer[] = {
 122     0x18, 0x53, 0x80, 0x67, 0x85,  // SEGMENT (size = 5)
 123     0x1F, 0x43, 0xB6, 0x75, 0x81, 0x11  // CLUSTER (size = 1)
 124   };
 125
 126   InSequence s;
 127   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(Return(&client_));
 128
 129   WebMListParser parser(kWebMIdSegment, &client_);
 130   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 131   EXPECT_FALSE(parser.IsParsingComplete());
 132 }
 133
 134 // Expecting to parse a Cluster, but get a Segment.
 135 TEST_F(WebMParserTest, ListIdDoesNotMatch) {
 136   const uint8 kBuffer[] = {
 137     0x18, 0x53, 0x80, 0x67, 0x80,  // SEGMENT (size = 0)
 138   };
 139
 140   WebMListParser parser(kWebMIdCluster, &client_);
 141   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 142   EXPECT_FALSE(parser.IsParsingComplete());
 143 }
 144
 145 TEST_F(WebMParserTest, InvalidElementInList) {
 146   const uint8 kBuffer[] = {
 147     0x18, 0x53, 0x80, 0x67, 0x82,  // SEGMENT (size = 2)
 148     0xAE, 0x80,  // TrackEntry (size = 0)
 149   };
 150
 151   InSequence s;
 152   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(Return(&client_));
 153
 154   WebMListParser parser(kWebMIdSegment, &client_);
 155   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 156   EXPECT_FALSE(parser.IsParsingComplete());
 157 }
 158
 159 // Test specific case of InvalidElementInList to verify EBMLHEADER within
 160 // known-sized cluster causes parse error.
 161 TEST_F(WebMParserTest, InvalidEBMLHeaderInCluster) {
 162   const uint8 kBuffer[] = {
 163     0x1F, 0x43, 0xB6, 0x75, 0x85,  // CLUSTER (size = 5)
 164     0x1A, 0x45, 0xDF, 0xA3, 0x80,    // EBMLHEADER (size = 0)
 165   };
 166
 167   InSequence s;
 168   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
 169
 170   WebMListParser parser(kWebMIdCluster, &client_);
 171   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 172   EXPECT_FALSE(parser.IsParsingComplete());
 173 }
 174
 175 // Verify that EBMLHEADER ends a preceding "unknown"-sized CLUSTER.
 176 TEST_F(WebMParserTest, UnknownSizeClusterFollowedByEBMLHeader) {
 177   const uint8 kBuffer[] = {
 178     0x1F, 0x43, 0xB6, 0x75, 0xFF,  // CLUSTER (size = unknown; really 0 due to:)
 179     0x1A, 0x45, 0xDF, 0xA3, 0x80,  // EBMLHEADER (size = 0)
 180   };
 181
 182   InSequence s;
 183   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
 184   EXPECT_CALL(client_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
 185
 186   WebMListParser parser(kWebMIdCluster, &client_);
 187
 188   // List parse should consume the CLUSTER but not the EBMLHEADER.
 189   EXPECT_EQ(5, parser.Parse(kBuffer, sizeof(kBuffer)));
 190   EXPECT_TRUE(parser.IsParsingComplete());
 191 }
 192
 193 TEST_F(WebMParserTest, VoidAndCRC32InList) {
 194   const uint8 kBuffer[] = {
 195     0x18, 0x53, 0x80, 0x67, 0x99,  // SEGMENT (size = 25)
 196     0xEC, 0x83, 0x00, 0x00, 0x00,  // Void (size = 3)
 197     0xBF, 0x83, 0x00, 0x00, 0x00,  // CRC32 (size = 3)
 198     0x1F, 0x43, 0xB6, 0x75, 0x8A,  // CLUSTER (size = 10)
 199     0xEC, 0x83, 0x00, 0x00, 0x00,  // Void (size = 3)
 200     0xBF, 0x83, 0x00, 0x00, 0x00,  // CRC32 (size = 3)
 201   };
 202   int size = sizeof(kBuffer);
 203
 204   InSequence s;
 205   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(Return(&client_));
 206   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(&client_));
 207   EXPECT_CALL(client_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
 208   EXPECT_CALL(client_, OnListEnd(kWebMIdSegment)).WillOnce(Return(true));
 209
 210   WebMListParser parser(kWebMIdSegment, &client_);
 211   EXPECT_EQ(size, parser.Parse(kBuffer, size));
 212   EXPECT_TRUE(parser.IsParsingComplete());
 213 }
 214
 215
 216 TEST_F(WebMParserTest, ParseListElementWithSingleCall) {
 217   scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
 218   CreateClusterExpectations(kBlockCount, true, &client_);
 219
 220   WebMListParser parser(kWebMIdCluster, &client_);
 221   EXPECT_EQ(cluster->size(), parser.Parse(cluster->data(), cluster->size()));
 222   EXPECT_TRUE(parser.IsParsingComplete());
 223 }
 224
 225 TEST_F(WebMParserTest, ParseListElementWithMultipleCalls) {
 226   scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
 227   CreateClusterExpectations(kBlockCount, true, &client_);
 228
 229   const uint8* data = cluster->data();
 230   int size = cluster->size();
 231   int default_parse_size = 3;
 232   WebMListParser parser(kWebMIdCluster, &client_);
 233   int parse_size = std::min(default_parse_size, size);
 234
 235   while (size > 0) {
 236     int result = parser.Parse(data, parse_size);
 237     ASSERT_GE(result, 0);
 238     ASSERT_LE(result, parse_size);
 239
 240     if (result == 0) {
 241       // The parser needs more data so increase the parse_size a little.
 242       EXPECT_FALSE(parser.IsParsingComplete());
 243       parse_size += default_parse_size;
 244       parse_size = std::min(parse_size, size);
 245       continue;
 246     }
 247
 248     parse_size = default_parse_size;
 249
 250     data += result;
 251     size -= result;
 252
 253     EXPECT_EQ((size == 0), parser.IsParsingComplete());
 254   }
 255   EXPECT_TRUE(parser.IsParsingComplete());
 256 }
 257
 258 TEST_F(WebMParserTest, Reset) {
 259   InSequence s;
 260   scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
 261
 262   // First expect all but the last block.
 263   CreateClusterExpectations(kBlockCount - 1, false, &client_);
 264
 265   // Now expect all blocks.
 266   CreateClusterExpectations(kBlockCount, true, &client_);
 267
 268   WebMListParser parser(kWebMIdCluster, &client_);
 269
 270   // Send slightly less than the full cluster so all but the last block is
 271   // parsed.
 272   int result = parser.Parse(cluster->data(), cluster->size() - 1);
 273   EXPECT_GT(result, 0);
 274   EXPECT_LT(result, cluster->size());
 275   EXPECT_FALSE(parser.IsParsingComplete());
 276
 277   parser.Reset();
 278
 279   // Now parse a whole cluster to verify that all the blocks will get parsed.
 280   EXPECT_EQ(cluster->size(), parser.Parse(cluster->data(), cluster->size()));
 281   EXPECT_TRUE(parser.IsParsingComplete());
 282 }
 283
 284 // Test the case where multiple clients are used for different lists.
 285 TEST_F(WebMParserTest, MultipleClients) {
 286   const uint8 kBuffer[] = {
 287     0x18, 0x53, 0x80, 0x67, 0x94,  // SEGMENT (size = 20)
 288     0x16, 0x54, 0xAE, 0x6B, 0x85,  //   TRACKS (size = 5)
 289     0xAE, 0x83,                    //     TRACKENTRY (size = 3)
 290     0xD7, 0x81, 0x01,              //       TRACKNUMBER (size = 1)
 291     0x1F, 0x43, 0xB6, 0x75, 0x85,  //   CLUSTER (size = 5)
 292     0xEC, 0x83, 0x00, 0x00, 0x00,  //     Void (size = 3)
 293   };
 294   int size = sizeof(kBuffer);
 295
 296   StrictMock<MockWebMParserClient> c1_;
 297   StrictMock<MockWebMParserClient> c2_;
 298   StrictMock<MockWebMParserClient> c3_;
 299
 300   InSequence s;
 301   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(Return(&c1_));
 302   EXPECT_CALL(c1_, OnListStart(kWebMIdTracks)).WillOnce(Return(&c2_));
 303   EXPECT_CALL(c2_, OnListStart(kWebMIdTrackEntry)).WillOnce(Return(&c3_));
 304   EXPECT_CALL(c3_, OnUInt(kWebMIdTrackNumber, 1)).WillOnce(Return(true));
 305   EXPECT_CALL(c2_, OnListEnd(kWebMIdTrackEntry)).WillOnce(Return(true));
 306   EXPECT_CALL(c1_, OnListEnd(kWebMIdTracks)).WillOnce(Return(true));
 307   EXPECT_CALL(c1_, OnListStart(kWebMIdCluster)).WillOnce(Return(&c2_));
 308   EXPECT_CALL(c1_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
 309   EXPECT_CALL(client_, OnListEnd(kWebMIdSegment)).WillOnce(Return(true));
 310
 311   WebMListParser parser(kWebMIdSegment, &client_);
 312   EXPECT_EQ(size, parser.Parse(kBuffer, size));
 313   EXPECT_TRUE(parser.IsParsingComplete());
 314 }
 315
 316 // Test the case where multiple clients are used for different lists.
 317 TEST_F(WebMParserTest, InvalidClient) {
 318   const uint8 kBuffer[] = {
 319     0x18, 0x53, 0x80, 0x67, 0x85,  // SEGMENT (size = 20)
 320     0x16, 0x54, 0xAE, 0x6B, 0x80,  //   TRACKS (size = 5)
 321   };
 322
 323   InSequence s;
 324   EXPECT_CALL(client_, OnListStart(kWebMIdSegment)).WillOnce(ReturnNull());
 325
 326   WebMListParser parser(kWebMIdSegment, &client_);
 327   EXPECT_EQ(-1, parser.Parse(kBuffer, sizeof(kBuffer)));
 328   EXPECT_FALSE(parser.IsParsingComplete());
 329 }
 330
 331 TEST_F(WebMParserTest, ReservedIds) {
 332   const uint8 k1ByteReservedId[] = { 0xFF, 0x81 };
 333   const uint8 k2ByteReservedId[] = { 0x7F, 0xFF, 0x81 };
 334   const uint8 k3ByteReservedId[] = { 0x3F, 0xFF, 0xFF, 0x81 };
 335   const uint8 k4ByteReservedId[] = { 0x1F, 0xFF, 0xFF, 0xFF, 0x81 };
 336   const uint8* kBuffers[] = {
 337     k1ByteReservedId,
 338     k2ByteReservedId,
 339     k3ByteReservedId,
 340     k4ByteReservedId
 341   };
 342
 343   for (size_t i = 0; i < arraysize(kBuffers); i++) {
 344     int id;
 345     int64 element_size;
 346     int buffer_size = 2 + i;
 347     EXPECT_EQ(buffer_size, WebMParseElementHeader(kBuffers[i], buffer_size,
 348                                                   &id, &element_size));
 349     EXPECT_EQ(id, kWebMReservedId);
 350     EXPECT_EQ(element_size, 1);
 351   }
 352 }
 353
 354 TEST_F(WebMParserTest, ReservedSizes) {
 355   const uint8 k1ByteReservedSize[] = { 0xA3, 0xFF };
 356   const uint8 k2ByteReservedSize[] = { 0xA3, 0x7F, 0xFF };
 357   const uint8 k3ByteReservedSize[] = { 0xA3, 0x3F, 0xFF, 0xFF };
 358   const uint8 k4ByteReservedSize[] = { 0xA3, 0x1F, 0xFF, 0xFF, 0xFF };
 359   const uint8 k5ByteReservedSize[] = { 0xA3, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF };
 360   const uint8 k6ByteReservedSize[] = { 0xA3, 0x07, 0xFF, 0xFF, 0xFF, 0xFF,
 361                                        0xFF };
 362   const uint8 k7ByteReservedSize[] = { 0xA3, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 363                                        0xFF };
 364   const uint8 k8ByteReservedSize[] = { 0xA3, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 365                                        0xFF, 0xFF };
 366   const uint8* kBuffers[] = {
 367     k1ByteReservedSize,
 368     k2ByteReservedSize,
 369     k3ByteReservedSize,
 370     k4ByteReservedSize,
 371     k5ByteReservedSize,
 372     k6ByteReservedSize,
 373     k7ByteReservedSize,
 374     k8ByteReservedSize
 375   };
 376
 377   for (size_t i = 0; i < arraysize(kBuffers); i++) {
 378     int id;
 379     int64 element_size;
 380     int buffer_size = 2 + i;
 381     EXPECT_EQ(buffer_size, WebMParseElementHeader(kBuffers[i], buffer_size,
 382                                                   &id, &element_size));
 383     EXPECT_EQ(id, 0xA3);
 384     EXPECT_EQ(element_size, kWebMUnknownSize);
 385   }
 386 }
 387
 388 TEST_F(WebMParserTest, ZeroPaddedStrings) {
 389   const uint8 kBuffer[] = {
 390     0x1A, 0x45, 0xDF, 0xA3, 0x91,  // EBMLHEADER (size = 17)
 391     0x42, 0x82, 0x80,  // DocType (size = 0)
 392     0x42, 0x82, 0x81, 0x00,  // DocType (size = 1) ""
 393     0x42, 0x82, 0x81, 'a',  // DocType (size = 1) "a"
 394     0x42, 0x82, 0x83, 'a', 0x00, 0x00  // DocType (size = 3) "a"
 395   };
 396   int size = sizeof(kBuffer);
 397
 398   InSequence s;
 399   EXPECT_CALL(client_, OnListStart(kWebMIdEBMLHeader))
 400       .WillOnce(Return(&client_));
 401   EXPECT_CALL(client_, OnString(kWebMIdDocType, "")).WillOnce(Return(true));
 402   EXPECT_CALL(client_, OnString(kWebMIdDocType, "")).WillOnce(Return(true));
 403   EXPECT_CALL(client_, OnString(kWebMIdDocType, "a")).WillOnce(Return(true));
 404   EXPECT_CALL(client_, OnString(kWebMIdDocType, "a")).WillOnce(Return(true));
 405   EXPECT_CALL(client_, OnListEnd(kWebMIdEBMLHeader)).WillOnce(Return(true));
 406
 407   WebMListParser parser(kWebMIdEBMLHeader, &client_);
 408   EXPECT_EQ(size, parser.Parse(kBuffer, size));
 409   EXPECT_TRUE(parser.IsParsingComplete());
 410 }
 411
 412 }  // namespace media