Add kSeekToStartFudgeRoom to SourceBufferStream

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 "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"
 #include "media/base/test_data_util.h"
@@ skipping 54 matching lines @@
     buffer[i] = tmp & 0xff;
     tmp >>= 8;
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
   return arg && !arg->IsEndOfStream() &&
       arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
 }
 
+MATCHER(IsEndOfStream, "") {
+  return arg && arg->IsEndOfStream();
+}
+
 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_EOSExpected(bool* called,
@@ skipping 493 matching lines @@
       ss << "[" << r.start(i).InMilliseconds() << ","
          << r.end(i).InMilliseconds() << ") ";
     }
     ss << "}";
     EXPECT_EQ(ss.str(), expected);
   }
 
   MOCK_METHOD2(ReadDone, void(DemuxerStream::Status status,
                               const scoped_refptr<DecoderBuffer>&));
 
+  void ExpectStall(DemuxerStream* stream) {

[acolwell GONE FROM CHROMIUM, 2012/08/04 00:04:51]

s/ExpectStall/ExpectEndOfStream/ ? since that looks like what is happening here.

[vrk (LEFT CHROMIUM), 2012/08/06 20:43:42]

Done.

+    EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
+    stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
+                            base::Unretained(this)));
+  }
+
   void ExpectRead(DemuxerStream* stream, int64 timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
                                 HasTimestamp(timestamp_in_ms)));
     stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
                             base::Unretained(this)));
   }
 
   void ExpectConfigChanged(DemuxerStream* stream) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kConfigChanged, _));
     stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
@@ skipping 1160 matching lines @@
   ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
   ASSERT_TRUE(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));
   GenerateSingleStreamExpectedReads(25, 4, audio, kAudioBlockDuration);
   GenerateSingleStreamExpectedReads(30, 4, video, kVideoBlockDuration);
 }
 
+TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodesOutOfRange) {
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
+
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  // 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));
+  ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
+
+  // Should not be able to fulfill a seek to 0.
+  demuxer_->Seek(base::TimeDelta::FromMilliseconds(0),
+                 NewExpectedStatusCB(PIPELINE_ERROR_ABORT));
+  ExpectRead(audio, 0);
+  ExpectStall(video);
+}
+
 TEST_F(ChunkDemuxerTest, TestClusterWithNoBuffers) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   // Generate and append an empty cluster beginning at 0.
   ASSERT_TRUE(AppendEmptyCluster(0));
 
   // Sanity check that data can be appended after this cluster correctly.
   scoped_ptr<Cluster> media_data(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(media_data->data(), media_data->size()));
   scoped_refptr<DemuxerStream> audio =
@@ skipping 317 matching lines @@
   scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2);
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateExpectedReads(0, 2, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampOffsetSeparateStreams) {

[vrk (LEFT CHROMIUM), 2012/08/03 23:52:03]

Had to fix this test because it was unintentionally relying on the old behavior!

   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
-  scoped_ptr<Cluster> cluster_a(
+  scoped_ptr<Cluster> cluster_a1(
       GenerateSingleStreamCluster(
           2500, 2500 + kAudioBlockDuration * 4, kAudioTrackNum,
           kAudioBlockDuration));
 
-  scoped_ptr<Cluster> cluster_v(
+  scoped_ptr<Cluster> cluster_v1(
+      GenerateSingleStreamCluster(
+          2500, 2500 + kVideoBlockDuration * 4, kVideoTrackNum,
+          kVideoBlockDuration));
+
+  scoped_ptr<Cluster> cluster_a2(
+      GenerateSingleStreamCluster(
+          0, kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
+
+  scoped_ptr<Cluster> cluster_v2(
       GenerateSingleStreamCluster(
           0, kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, -2.5));
-  ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, -2.5));
+  ASSERT_TRUE(AppendData(audio_id, cluster_a1->data(), cluster_a1->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v1->data(), cluster_v1->size()));
   GenerateSingleStreamExpectedReads(0, 4, audio, kAudioBlockDuration);
+  GenerateSingleStreamExpectedReads(0, 4, video, kVideoBlockDuration);
 
+  demuxer_->StartWaitingForSeek();
+  demuxer_->Seek(base::TimeDelta::FromMilliseconds(27300),
+                 NewExpectedStatusCB(PIPELINE_OK));
+
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, 27.3));
   ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, 27.3));
-  ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
+  ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
   GenerateSingleStreamExpectedReads(27300, 4, video, kVideoBlockDuration);
+  GenerateSingleStreamExpectedReads(27300, 4, audio, kAudioBlockDuration);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampOffsetMidParse) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13));
 
   // Setting a timestamp should fail because we're in the middle of a cluster.
@@ skipping 52 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