Move pending seek cancellation logic from ChunkDemuxerStream to ChunkDemuxer.

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 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/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 772 matching lines @@
                       scoped_ptr<uint8[]> init_data, int init_data_size) {
     NeedKeyMock(type, init_data.get(), init_data_size);
   }
 
   scoped_ptr<TextTrack> OnTextTrack(TextKind kind,
                                     const std::string& label,
                                     const std::string& language) {
     return scoped_ptr<TextTrack>();
   }
 
+  void Seek(base::TimeDelta seek_time) {
+    demuxer_->StartWaitingForSeek();
+    demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
+    message_loop_.RunUntilIdle();
+  }
+
   base::MessageLoop message_loop_;
   MockDemuxerHost host_;
 
   scoped_ptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
@@ skipping 74 matching lines @@
 // arrives.
 TEST_F(ChunkDemuxerTest, TestAppendDataAfterSeek) {
   ASSERT_TRUE(InitDemuxer(true, true));
   scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster());
   AppendData(first_cluster->data(), first_cluster->size());
 
   InSequence s;
 
   EXPECT_CALL(*this, Checkpoint(1));
 
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(46),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(46));
 
   EXPECT_CALL(*this, Checkpoint(2));
 
   scoped_ptr<Cluster> cluster(kDefaultSecondCluster());
 
   Checkpoint(1);
 
   AppendData(cluster->data(), cluster->size());
 
   message_loop_.RunUntilIdle();
@@ skipping 29 matching lines @@
   AppendData(cluster_a->data(), first_append_size);
 
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectRead(DemuxerStream::VIDEO, 0);
   ExpectRead(DemuxerStream::AUDIO, kAudioBlockDuration);
   // Note: We skip trying to read a video buffer here because computing
   // the duration for this block relies on successfully parsing the last block
   // in the cluster the cluster.
   ExpectRead(DemuxerStream::AUDIO, 2 * kAudioBlockDuration);
 
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(5),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(5));
 
   // Append the rest of the cluster.
   AppendData(cluster_a->data() + first_append_size, second_append_size);
 
   // Append the new cluster and verify that only the blocks
   // in the new cluster are returned.
   scoped_ptr<Cluster> cluster_b(GenerateCluster(5000, 6));
   AppendData(cluster_b->data(), cluster_b->size());
   GenerateExpectedReads(5000, 6);
 }
@@ skipping 310 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringCanceledSeek) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   AppendCluster(0, 10);
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(138)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   // Start the first seek.
-  demuxer_->StartWaitingForSeek();
-
-  // Simulate the pipeline finally calling Seek().
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(20),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(20));
 
   // Simulate another seek being requested before the first
   // seek has finished prerolling.
   demuxer_->CancelPendingSeek();
 
   // Finish second seek.
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(30),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(30));
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
   // Make sure audio can reach end of stream.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kOk);
 
   // Make sure video can reach end of stream.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
@@ skipping 299 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, TestSeekCanceled) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   // Append cluster at the beginning of the stream.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
   AppendData(start_cluster->data(), start_cluster->size());
 
   // Seek to an unbuffered region.
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(50),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(50));
 
   // Attempt to read in unbuffered area; should not fulfill the read.
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_AbortExpected, &video_read_done));
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Now cancel the pending seek, which should flush the reads with empty
   // buffers.
   demuxer_->CancelPendingSeek();
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(0),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(0));
   GenerateExpectedReads(0, 4);
 }
 
 TEST_F(ChunkDemuxerTest, TestSeekCanceledWhileWaitingForSeek) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   // Append cluster at the beginning of the stream.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
   AppendData(start_cluster->data(), start_cluster->size());
 
   // Start waiting for a seek.
   demuxer_->StartWaitingForSeek();
 
   // Now cancel the upcoming seek to an unbuffered region.
   demuxer_->CancelPendingSeek();
   demuxer_->Seek(base::TimeDelta::FromSeconds(50),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   // Read requests should be fulfilled with empty buffers.
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone_AbortExpected, &video_read_done));
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // A seek back to the buffered region should succeed.
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(0),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(0));
   GenerateExpectedReads(0, 4);
 }
 
 // Test that Seek() successfully seeks to all source IDs.
 TEST_F(ChunkDemuxerTest, TestSeekAudioAndVideoSources) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   scoped_ptr<Cluster> cluster_a1(
@@ skipping 11 matching lines @@
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Seek to 3 (an unbuffered region).
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(3),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(3));
 
   audio_read_done = false;
   video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromSeconds(3),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromSeconds(3),
                        &video_read_done));
   // Read()s should not return until after data is appended at the Seek point.
@@ skipping 264 matching lines @@
   CheckExpectedRanges("{ [0,100) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   // Create a cluster where the video timecode begins 25ms after the audio.
   scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 25, 8));
   AppendData(start_cluster->data(), start_cluster->size());
 
-  demuxer_->Seek(base::TimeDelta::FromSeconds(0),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(0));
   GenerateExpectedReads(0, 25, 8);
 
   // Seek to 5 seconds.
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromSeconds(5),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromSeconds(5));
 
   // Generate a cluster to fulfill this seek, where audio timecode begins 25ms
   // after the video.
   scoped_ptr<Cluster> middle_cluster(GenerateCluster(5025, 5000, 8));
   AppendData(middle_cluster->data(), middle_cluster->size());
   GenerateExpectedReads(5025, 5000, 8);
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodesSeparateSources) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Generate two streams where the video stream starts 5ms after the audio
   // stream and append them.
   scoped_ptr<Cluster> cluster_v(
       GenerateSingleStreamCluster(30, 4 * kVideoBlockDuration + 30,
                                   kVideoTrackNum, kVideoBlockDuration));
   scoped_ptr<Cluster> cluster_a(
       GenerateSingleStreamCluster(25, 4 * kAudioBlockDuration + 25,
                                   kAudioTrackNum, kAudioBlockDuration));
   AppendData(audio_id, cluster_a->data(), cluster_a->size());
   AppendData(video_id, cluster_v->data(), cluster_v->size());
 
   // Both streams should be able to fulfill a seek to 25.
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(25),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(25));
   GenerateAudioStreamExpectedReads(25, 4);
   GenerateVideoStreamExpectedReads(30, 4);
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodesOutOfRange) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Generate two streams where the video stream starts 10s after the audio
   // stream and append them.
   scoped_ptr<Cluster> cluster_v(
       GenerateSingleStreamCluster(10000, 4 * kVideoBlockDuration + 10000,
                                   kVideoTrackNum, kVideoBlockDuration));
   scoped_ptr<Cluster> cluster_a(
       GenerateSingleStreamCluster(0, 4 * kAudioBlockDuration + 0,
                                   kAudioTrackNum, kAudioBlockDuration));
   AppendData(audio_id, cluster_a->data(), cluster_a->size());
   AppendData(video_id, cluster_v->data(), cluster_v->size());
 
   // Should not be able to fulfill a seek to 0.
+  demuxer_->StartWaitingForSeek();
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(0),
                  NewExpectedStatusCB(PIPELINE_ERROR_ABORT));
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectEndOfStream(DemuxerStream::VIDEO);
 }
 
 TEST_F(ChunkDemuxerTest, TestClusterWithNoBuffers) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   // Generate and append an empty cluster beginning at 0.
@@ skipping 69 matching lines @@
   // Verify that we can read audio & video to the end w/o problems.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastAudioTimestamp, last_timestamp);
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastVideoTimestamp, last_timestamp);
 
   // Seek back to 0 and verify that we can read to the end again..
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(0),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(0));
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastAudioTimestamp, last_timestamp);
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
   EXPECT_EQ(DemuxerStream::kOk, status);
   EXPECT_EQ(kLastVideoTimestamp, last_timestamp);
 }
 
@@ skipping 139 matching lines @@
 
   // Fetch initial video config and verify it matches what we expect.
   const VideoDecoderConfig& video_config_1 = video->video_decoder_config();
   ASSERT_TRUE(video_config_1.IsValidConfig());
   EXPECT_EQ(video_config_1.natural_size().width(), 320);
   EXPECT_EQ(video_config_1.natural_size().height(), 240);
 
   ExpectRead(DemuxerStream::VIDEO, 0);
 
   // Seek to a location with a different config.
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(527),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(527));
 
   // Verify that the config change is signalled.
   ExpectConfigChanged(DemuxerStream::VIDEO);
 
   // Fetch the new decoder config and verify it is what we expect.
   const VideoDecoderConfig& video_config_2 = video->video_decoder_config();
   ASSERT_TRUE(video_config_2.IsValidConfig());
   EXPECT_EQ(video_config_2.natural_size().width(), 640);
   EXPECT_EQ(video_config_2.natural_size().height(), 360);
 
   // Verify that Read() will return a buffer now.
   ExpectRead(DemuxerStream::VIDEO, 527);
 
   // Seek back to the beginning and verify we get another config change.
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(0),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(0));
   ExpectConfigChanged(DemuxerStream::VIDEO);
   ASSERT_TRUE(video_config_1.Matches(video->video_decoder_config()));
   ExpectRead(DemuxerStream::VIDEO, 0);
 
   // Seek to a location that requires a config change and then
   // seek to a new location that has the same configuration as
   // the start of the file without a Read() in the middle.
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(527),
-                 NewExpectedStatusCB(PIPELINE_OK));
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(801),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(527));
+  Seek(base::TimeDelta::FromMilliseconds(801));
 
   // Verify that no config change is signalled.
   ExpectRead(DemuxerStream::VIDEO, 801);
   ASSERT_TRUE(video_config_1.Matches(video->video_decoder_config()));
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(30)));
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   AppendData(cluster->data(), cluster->size());
 
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(30000),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(30000));
 
   GenerateExpectedReads(30000, 2);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampNegativeOffset) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       kSourceId, base::TimeDelta::FromSeconds(-1)));
   scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2);
@@ skipping 27 matching lines @@
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       audio_id, base::TimeDelta::FromMilliseconds(-2500)));
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       video_id, base::TimeDelta::FromMilliseconds(-2500)));
   AppendData(audio_id, cluster_a1->data(), cluster_a1->size());
   AppendData(video_id, cluster_v1->data(), cluster_v1->size());
   GenerateAudioStreamExpectedReads(0, 4);
   GenerateVideoStreamExpectedReads(0, 4);
 
-  demuxer_->StartWaitingForSeek();
-  demuxer_->Seek(base::TimeDelta::FromMilliseconds(27300),
-                 NewExpectedStatusCB(PIPELINE_OK));
+  Seek(base::TimeDelta::FromMilliseconds(27300));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       audio_id, base::TimeDelta::FromMilliseconds(27300)));
   ASSERT_TRUE(demuxer_->SetTimestampOffset(
       video_id, base::TimeDelta::FromMilliseconds(27300)));
   AppendData(audio_id, cluster_a2->data(), cluster_a2->size());
   AppendData(video_id, cluster_v2->data(), cluster_v2->size());
   GenerateVideoStreamExpectedReads(27300, 4);
   GenerateAudioStreamExpectedReads(27300, 4);
 }
@@ skipping 179 matching lines @@
   // Verify that the reads don't complete.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->EndOfStream(PIPELINE_OK);
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
+TEST_F(ChunkDemuxerTest, TestCanceledSeekDuringInitialPreroll) {
+  ASSERT_TRUE(InitDemuxer(true, true));
+
+  // Cancel preroll.
+  demuxer_->CancelPendingSeek();
+
+  // Initiate the seek to the new location.
+  int seek_time_in_ms = 200;
+  Seek(base::TimeDelta::FromMilliseconds(seek_time_in_ms));
+
+  // Append data to satisfy the seek.
+  AppendCluster(seek_time_in_ms, 10);
+}
+
 }  // namespace media