Cancel pending seek in ChunkDemuxer when a new seek occurs

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 "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
@@ skipping 68 matching lines @@
 
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
                        DemuxerStream::Status status,
                        const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kOk);
   EXPECT_EQ(expected_time, buffer->GetTimestamp());
   *called = true;
 }
 
+static void OnReadDone_AbortExpected(
+    bool* called, DemuxerStream::Status status,
+    const scoped_refptr<DecoderBuffer>& buffer) {
+  EXPECT_EQ(status, DemuxerStream::kAborted);
+  EXPECT_EQ(NULL, buffer.get());
+  *called = true;
+}
+
 static void OnReadDone_EOSExpected(bool* called,
                                    DemuxerStream::Status status,
                                    const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(status, DemuxerStream::kOk);
   EXPECT_TRUE(buffer->IsEndOfStream());
   *called = true;
 }
 
 class MockChunkDemuxerClient : public ChunkDemuxerClient {
  public:
@@ skipping 1383 matching lines @@
   audio->Read(base::Bind(&OnReadDone_EOSExpected,
                          &audio_read_done));
   EXPECT_TRUE(audio_read_done);
 
   // Read() from video should still return normal buffers.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateSingleStreamExpectedReads(0, 4, video, kVideoBlockDuration);
 }
 
+TEST_F(ChunkDemuxerTest, TestSeekCanceled) {
+  ASSERT_TRUE(InitDemuxer(true, true, false));
+
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  // Append cluster at the beginning of the stream.
+  scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
+  ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size()));
+
+  // Seek to an unbuffered region.
+  demuxer_->StartWaitingForSeek();
+  demuxer_->Seek(base::TimeDelta::FromSeconds(50),
+                 NewExpectedStatusCB(PIPELINE_OK));
+
+  // Attempt to read in unbuffered area; should not fulfill the read.
+  bool audio_read_done = false;
+  bool video_read_done = false;
+  audio->Read(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
+  video->Read(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));
+  GenerateExpectedReads(0, 4, audio, video);
+}
+
+TEST_F(ChunkDemuxerTest, TestSeekCanceledWhileWaitingForSeek) {
+  ASSERT_TRUE(InitDemuxer(true, true, false));
+
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  // Append cluster at the beginning of the stream.
+  scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4));
+  ASSERT_TRUE(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;
+  audio->Read(base::Bind(&OnReadDone_AbortExpected, &audio_read_done));
+  video->Read(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));
+  GenerateExpectedReads(0, 4, audio, video);
+}
+
 // 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(
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
 
   scoped_ptr<Cluster> cluster_v1(
@@ skipping 748 matching lines @@
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp)));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 }  // namespace media