Fix ChunkDemuxer seeks that occur during a partially parsed cluster.

media/webm/webm_parser_unittest.cc

 // Copyright (c) 2011 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 "media/webm/cluster_builder.h"
 #include "media/webm/webm_constants.h"
 #include "media/webm/webm_parser.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 42 matching lines @@
 
   for (int i = 0; i < block_count; i++)
     AddSimpleBlock(&cb, block_info[i].track_num, block_info[i].timestamp);
 
   return cb.Finish();
 }
 
 static void CreateClusterExpectations(int timecode,
                                       const SimpleBlockInfo* block_info,
                                       int block_count,
+                                      bool is_complete_cluster,
                                       MockWebMParserClient* client) {
 
   InSequence s;
   EXPECT_CALL(*client, OnListStart(kWebMIdCluster)).WillOnce(Return(true));
-  EXPECT_CALL(*client, OnUInt(kWebMIdTimecode, 0)).WillOnce(Return(true));
+  EXPECT_CALL(*client, OnUInt(kWebMIdTimecode, timecode))
+      .WillOnce(Return(true));
 
   for (int i = 0; i < block_count; i++) {
     EXPECT_CALL(*client, OnSimpleBlock(block_info[i].track_num,
                                        block_info[i].timestamp,
                                        _, _, _))
         .WillOnce(Return(true));
   }
 
-  EXPECT_CALL(*client, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
+  if (is_complete_cluster)
+    EXPECT_CALL(*client, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
 }
 
 TEST_F(WebMParserTest, EmptyCluster) {
   const uint8 kEmptyCluster[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x80  // CLUSTER (size = 0)
   };
   int size = sizeof(kEmptyCluster);
 
   InSequence s;
   EXPECT_CALL(client_, OnListStart(kWebMIdCluster)).WillOnce(Return(true));
@@ skipping 117 matching lines @@
   const SimpleBlockInfo kBlockInfo[] = {
     { 0, 1 },
     { 1, 2 },
     { 0, 3 },
     { 0, 4 },
     { 1, 4 },
   };
   int block_count = arraysize(kBlockInfo);
 
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
-  CreateClusterExpectations(0, kBlockInfo, block_count, &client_);
+  CreateClusterExpectations(0, kBlockInfo, block_count, true, &client_);
 
   WebMListParser parser(kWebMIdCluster);
   int result = parser.Parse(cluster->data(), cluster->size(), &client_);
   EXPECT_EQ(cluster->size(), result);
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
 TEST_F(WebMParserTest, ParseListElementWithMultipleCalls) {
   const SimpleBlockInfo kBlockInfo[] = {
     { 0, 1 },
     { 1, 2 },
     { 0, 3 },
     { 0, 4 },
     { 1, 4 },
   };
   int block_count = arraysize(kBlockInfo);
 
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
-  CreateClusterExpectations(0, kBlockInfo, block_count, &client_);
+  CreateClusterExpectations(0, kBlockInfo, block_count, true, &client_);
 
   const uint8* data = cluster->data();
   int size = cluster->size();
   int default_parse_size = 3;
   WebMListParser parser(kWebMIdCluster);
   int parse_size = std::min(default_parse_size, size);
 
   while (size > 0) {
     int result = parser.Parse(data, parse_size, &client_);
     EXPECT_GE(result, 0);
@@ skipping 10 matching lines @@
     parse_size = default_parse_size;
 
     data += result;
     size -= result;
 
     EXPECT_EQ((size == 0), parser.IsParsingComplete());
   }
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
+TEST_F(WebMParserTest, TestReset) {
+  InSequence s;
+
+  const SimpleBlockInfo kBlockInfo[] = {
+    { 0, 1 },
+    { 1, 2 },
+    { 0, 3 },
+    { 0, 4 },
+    { 1, 4 },
+  };
+  int block_count = arraysize(kBlockInfo);
+
+  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+
+  // First expect all but the last block.
+  CreateClusterExpectations(0, kBlockInfo, block_count - 1, false, &client_);
+
+  // Now expect all blocks.
+  CreateClusterExpectations(0, kBlockInfo, block_count, true, &client_);
+
+  WebMListParser parser(kWebMIdCluster);
+
+  // Send slightly less than the full cluster so all but the last block is
+  // parsed.
+  int result = parser.Parse(cluster->data(), cluster->size() - 1, &client_);
+  EXPECT_GT(result, 0);
+  EXPECT_LT(result, cluster->size());
+  EXPECT_FALSE(parser.IsParsingComplete());
+
+  parser.Reset();
+
+  // Now parse a whole cluster to verify that all the blocks will get parsed.
+  result = parser.Parse(cluster->data(), cluster->size(), &client_);
+  EXPECT_EQ(result, cluster->size());
+  EXPECT_TRUE(parser.IsParsingComplete());
+}
+
 }  // namespace media