Nice and easy fix for the media clock interpolating past the duration.

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2006-2009 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 <string>
 
 #include "base/waitable_event.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/filters.h"
@@ skipping 57 matching lines @@
     EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->data_source(), Seek(base::TimeDelta(), NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->data_source(), Stop());
   }
 
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
-  void InitializeDemuxer(MockDemuxerStreamVector* streams) {
+  void InitializeDemuxer(MockDemuxerStreamVector* streams,
+                         const base::TimeDelta& duration) {
     EXPECT_CALL(*mocks_->demuxer(),
                 Initialize(mocks_->data_source(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+        .WillOnce(DoAll(SetDuration(mocks_->data_source(), duration),
+                        Invoke(&RunFilterCallback)));
     EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
         .WillRepeatedly(Return(streams->size()));
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->demuxer(), Seek(base::TimeDelta(), NotNull()))
         .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->demuxer(), Stop());
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       scoped_refptr<DemuxerStream> stream = (*streams)[i];
@@ skipping 178 matching lines @@
   EXPECT_EQ(PIPELINE_ERROR_COULD_NOT_RENDER, pipeline_->GetError());
 }
 
 TEST_F(PipelineImplTest, AudioStream) {
   scoped_refptr<StrictMock<MockDemuxerStream> > stream =
       new StrictMock<MockDemuxerStream>("audio/x-foo");
   MockDemuxerStreamVector streams;
   streams.push_back(stream);
 
   InitializeDataSource();
-  InitializeDemuxer(&streams);
+  InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(stream);
   InitializeAudioRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_FALSE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, VideoStream) {
   scoped_refptr<StrictMock<MockDemuxerStream> > stream =
       new StrictMock<MockDemuxerStream>("video/x-foo");
   MockDemuxerStreamVector streams;
   streams.push_back(stream);
 
   InitializeDataSource();
-  InitializeDemuxer(&streams);
+  InitializeDemuxer(&streams, base::TimeDelta());
   InitializeVideoDecoder(stream);
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_FALSE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, AudioVideoStream) {
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream =
       new StrictMock<MockDemuxerStream>("audio/x-foo");
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream =
       new StrictMock<MockDemuxerStream>("video/x-foo");
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream);
   streams.push_back(video_stream);
 
   InitializeDataSource();
-  InitializeDemuxer(&streams);
+  InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream);
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream);
   InitializeVideoRenderer();
 
   InitializePipeline();
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(PIPELINE_OK, pipeline_->GetError());
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeAudio));
   EXPECT_TRUE(pipeline_->IsRendered(media::mime_type::kMajorTypeVideo));
 }
 
 TEST_F(PipelineImplTest, Seek) {
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream =
       new StrictMock<MockDemuxerStream>("audio/x-foo");
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream =
       new StrictMock<MockDemuxerStream>("video/x-foo");
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream);
   streams.push_back(video_stream);
 
   InitializeDataSource();
-  InitializeDemuxer(&streams);
+  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
   InitializeAudioDecoder(audio_stream);
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream);
   InitializeVideoRenderer();
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   EXPECT_CALL(*mocks_->data_source(), Seek(expected, NotNull()))
       .WillOnce(Invoke(&RunFilterCallback));
   EXPECT_CALL(*mocks_->demuxer(), Seek(expected, NotNull()))
@@ skipping 22 matching lines @@
   EXPECT_TRUE(expected == pipeline_->GetCurrentTime());
 }
 
 TEST_F(PipelineImplTest, SetVolume) {
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream =
       new StrictMock<MockDemuxerStream>("audio/x-foo");
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream);
 
   InitializeDataSource();
-  InitializeDemuxer(&streams);
+  InitializeDemuxer(&streams, base::TimeDelta());
   InitializeAudioDecoder(audio_stream);
   InitializeAudioRenderer();
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
   InitializePipeline();
   pipeline_->SetVolume(expected);
 }
 
 }  // namespace media