Revert of Fix seeking when the start time is non-zero.

media/base/pipeline_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 89 matching lines @@
                                     base::Unretained(this)));
     scoped_ptr<TextRenderer> text_renderer(text_renderer_);
     filter_collection_->SetTextRenderer(text_renderer.Pass());
 
     // InitializeDemuxer() adds overriding expectations for expected non-NULL
     // streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_))
         .WillRepeatedly(Return(null_pointer));
 
+    EXPECT_CALL(*demuxer_, GetStartTime())
+        .WillRepeatedly(Return(base::TimeDelta()));
+
     EXPECT_CALL(*demuxer_, GetTimelineOffset())
         .WillRepeatedly(Return(base::Time()));
 
     EXPECT_CALL(*demuxer_, GetLiveness())
         .WillRepeatedly(Return(Demuxer::LIVENESS_UNKNOWN));
   }
 
   virtual ~PipelineTest() {
     if (!pipeline_ || !pipeline_->IsRunning())
       return;
@@ skipping 44 matching lines @@
     return stream.Pass();
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*video_renderer_, Initialize(stream, _, _, _, _, _, _, _, _))
         .WillOnce(RunCallback<2>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
 
     // Startup sequence.
-    EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
+    EXPECT_CALL(*video_renderer_, Preroll(demuxer_->GetStartTime(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Play(_))
         .WillOnce(RunClosure<0>());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&audio_time_cb_),
                         RunCallback<1>(PIPELINE_OK)));
@@ skipping 544 matching lines @@
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunUntilIdle();
 }
 
+TEST_F(PipelineTest, StartTimeIsZero) {
+  CreateVideoStream();
+  MockDemuxerStreamVector streams;
+  streams.push_back(video_stream());
+
+  const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
+  InitializeDemuxer(&streams, kDuration);
+  InitializeVideoRenderer(video_stream());
+
+  InitializePipeline(PIPELINE_OK);
+  EXPECT_FALSE(metadata_.has_audio);
+  EXPECT_TRUE(metadata_.has_video);
+
+  EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
+}
+
+TEST_F(PipelineTest, StartTimeIsNonZero) {
+  const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
+
+  EXPECT_CALL(*demuxer_, GetStartTime())
+      .WillRepeatedly(Return(kStartTime));
+
+  CreateVideoStream();
+  MockDemuxerStreamVector streams;
+  streams.push_back(video_stream());
+
+  InitializeDemuxer(&streams, kDuration);
+  InitializeVideoRenderer(video_stream());
+
+  InitializePipeline(PIPELINE_OK);
+  EXPECT_FALSE(metadata_.has_audio);
+  EXPECT_TRUE(metadata_.has_video);
+
+  EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
+}
+
 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
                        int time_in_ms,
                        int max_time_in_ms) {
   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
               base::TimeDelta::FromMilliseconds(max_time_in_ms));
 }
 
 TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
@@ skipping 359 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media