Fix media timeline so that thumb never exceeds buffered data

media/base/clock_unittest.cc

Index: media/base/clock_unittest.cc
diff --git a/media/base/clock_unittest.cc b/media/base/clock_unittest.cc
index dcf39ae6c1494441c3062878116bf03e4d28bda8..733f409b5b8a6c1f7379b2ecabad9c1ea9179cfc 100644
--- a/media/base/clock_unittest.cc
+++ b/media/base/clock_unittest.cc
@@ -24,167 +24,233 @@ static std::ostream& operator<<(std::ostream& stream, const TimeDelta& time) {
 
 namespace media {
 
-TEST(ClockTest, Created) {
-  StrictMock<base::MockTimeProvider> mock_time;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0);
+static const int kDurationInSeconds = 120;
+
+class ClockTest : public ::testing::Test {
+ public:
+  ClockTest()
+      : clock_(&base::MockTimeProvider::StaticNow) {
+    SetDuration();
+    EXPECT_CALL(mock_time_, Now())
+        .WillRepeatedly(Return(base::Time::UnixEpoch()));
+  }
+
+ protected:
+  void SetDuration() {
+    const base::TimeDelta kDuration =
+        base::TimeDelta::FromSeconds(kDurationInSeconds);
+    clock_.SetDuration(kDuration);
+    EXPECT_EQ(kDuration, clock_.Duration());
+  }
+
+  void AdvanceSystemTime(base::TimeDelta delta) {
+    time_elapsed_ += delta;
+    EXPECT_CALL(mock_time_, Now())
+        .WillRepeatedly(Return(base::Time::UnixEpoch() + time_elapsed_));
+  }
+
+  Clock clock_;
+  StrictMock<base::MockTimeProvider> mock_time_;
+  base::TimeDelta time_elapsed_;
+};
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kExpected, clock.Elapsed());
+TEST_F(ClockTest, Created) {
+  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0);
+  EXPECT_EQ(kExpected, clock_.Elapsed());
 }
 
-TEST(ClockTest, Play_NormalSpeed) {
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(6)));
+TEST_F(ClockTest, Play_NormalSpeed) {
   const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2);
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(2);
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, clock.Elapsed());
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(kTimeToAdvance, clock_.Elapsed());
 }
 
-TEST(ClockTest, Play_DoubleSpeed) {
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(9)));
+TEST_F(ClockTest, Play_DoubleSpeed) {
   const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10);
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(5);
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetPlaybackRate(2.0f);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, clock.Elapsed());
+  clock_.SetPlaybackRate(2.0f);
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(2 * kTimeToAdvance, clock_.Elapsed());
 }
 
-TEST(ClockTest, Play_HalfSpeed) {
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(8)));
+TEST_F(ClockTest, Play_HalfSpeed) {
   const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2);
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(4);
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetPlaybackRate(0.5f);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, clock.Elapsed());
+  clock_.SetPlaybackRate(0.5f);
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(kTimeToAdvance / 2, clock_.Elapsed());
 }
 
-TEST(ClockTest, Play_ZeroSpeed) {
+TEST_F(ClockTest, Play_ZeroSpeed) {
   // We'll play for 2 seconds at normal speed, 4 seconds at zero speed, and 8
-  // seconds at normal speed:
-  //   (1.0 x 2) + (0.0 x 4) + (1.0 x 8) = 10
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(6)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(10)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(18)));
+  // seconds at normal speed.
   const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10);
+  const base::TimeDelta kPlayDuration1 = base::TimeDelta::FromSeconds(2);
+  const base::TimeDelta kPlayDuration2 = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kPlayDuration3 = base::TimeDelta::FromSeconds(8);
+  const base::TimeDelta kExpected = kPlayDuration1 + kPlayDuration3;
+
+  EXPECT_EQ(kZero, clock_.Play());
+
+  AdvanceSystemTime(kPlayDuration1);
+  clock_.SetPlaybackRate(0.0f);
+  AdvanceSystemTime(kPlayDuration2);
+  clock_.SetPlaybackRate(1.0f);
+  AdvanceSystemTime(kPlayDuration3);
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  clock.SetPlaybackRate(0.0f);
-  clock.SetPlaybackRate(1.0f);
-  EXPECT_EQ(kExpected, clock.Elapsed());
+  EXPECT_EQ(kExpected, clock_.Elapsed());
 }
 
-TEST(ClockTest, Play_MultiSpeed) {
+TEST_F(ClockTest, Play_MultiSpeed) {
   // We'll play for 2 seconds at half speed, 4 seconds at normal speed, and 8
-  // seconds at double speed:
-  //   (0.5 x 2) + (1.0 x 4) + (2.0 x 8) = 21
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(6)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(10)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(18)));
+  // seconds at double speed.
   const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(21);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetPlaybackRate(0.5f);
-  EXPECT_EQ(kZero, clock.Play());
-  clock.SetPlaybackRate(1.0f);
-  clock.SetPlaybackRate(2.0f);
-  EXPECT_EQ(kExpected, clock.Elapsed());
+  const base::TimeDelta kPlayDuration1 = base::TimeDelta::FromSeconds(2);
+  const base::TimeDelta kPlayDuration2 = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kPlayDuration3 = base::TimeDelta::FromSeconds(8);
+  const base::TimeDelta kExpected =
+      kPlayDuration1 / 2 + kPlayDuration2 + 2 * kPlayDuration3;
+
+  clock_.SetPlaybackRate(0.5f);
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kPlayDuration1);
+
+  clock_.SetPlaybackRate(1.0f);
+  AdvanceSystemTime(kPlayDuration2);
+
+  clock_.SetPlaybackRate(2.0f);
+  AdvanceSystemTime(kPlayDuration3);
+  EXPECT_EQ(kExpected, clock_.Elapsed());
 }
 
-TEST(ClockTest, Pause) {
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(8)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(12)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(16)));
+TEST_F(ClockTest, Pause) {
   const base::TimeDelta kZero;
-  const base::TimeDelta kFirstPause = base::TimeDelta::FromSeconds(4);
-  const base::TimeDelta kSecondPause = base::TimeDelta::FromSeconds(8);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kFirstPause, clock.Pause());
-  EXPECT_EQ(kFirstPause, clock.Elapsed());
-  EXPECT_EQ(kFirstPause, clock.Play());
-  EXPECT_EQ(kSecondPause, clock.Pause());
-  EXPECT_EQ(kSecondPause, clock.Elapsed());
+  const base::TimeDelta kPlayDuration = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kPauseDuration = base::TimeDelta::FromSeconds(20);
+  const base::TimeDelta kExpectedFirstPause = kPlayDuration;
+  const base::TimeDelta kExpectedSecondPause = 2 * kPlayDuration;
+
+  // Play for 4 seconds.
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kPlayDuration);
+
+  // Pause for 20 seconds.
+  EXPECT_EQ(kExpectedFirstPause, clock_.Pause());
+  EXPECT_EQ(kExpectedFirstPause, clock_.Elapsed());
+  AdvanceSystemTime(kPauseDuration);
+  EXPECT_EQ(kExpectedFirstPause, clock_.Elapsed());
+
+  // Play again for 4 more seconds.
+  EXPECT_EQ(kExpectedFirstPause, clock_.Play());
+  AdvanceSystemTime(kPlayDuration);
+  EXPECT_EQ(kExpectedSecondPause, clock_.Pause());
+  EXPECT_EQ(kExpectedSecondPause, clock_.Elapsed());
 }
 
-TEST(ClockTest, SetTime_Paused) {
-  // We'll remain paused while we set the time.  The time should be simply
-  // updated without accessing the time provider.
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
+TEST_F(ClockTest, SetTime_Paused) {
   const base::TimeDelta kFirstTime = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kSecondTime = base::TimeDelta::FromSeconds(16);
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetTime(kFirstTime);
-  EXPECT_EQ(kFirstTime, clock.Elapsed());
-  clock.SetTime(kSecondTime);
-  EXPECT_EQ(kSecondTime, clock.Elapsed());
+  clock_.SetTime(kFirstTime, clock_.Duration());
+  EXPECT_EQ(kFirstTime, clock_.Elapsed());
+  clock_.SetTime(kSecondTime, clock_.Duration());
+  EXPECT_EQ(kSecondTime, clock_.Elapsed());
 }
 
-TEST(ClockTest, SetTime_Playing) {
+TEST_F(ClockTest, SetTime_Playing) {
   // We'll play for 4 seconds, then set the time to 12, then play for 4 more
-  // seconds.  We'll expect a media time of 16.
-  InSequence s;
-  StrictMock<base::MockTimeProvider> mock_time;
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(4)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(8)));
-  EXPECT_CALL(mock_time, Now())
-      .WillOnce(Return(base::Time::FromDoubleT(12)));
+  // seconds.
+  const base::TimeDelta kZero;
+  const base::TimeDelta kPlayDuration = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kUpdatedTime = base::TimeDelta::FromSeconds(12);
+  const base::TimeDelta kExpected = kUpdatedTime + kPlayDuration;
+
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kPlayDuration);
+
+  clock_.SetTime(base::TimeDelta::FromSeconds(12), clock_.Duration());

[acolwell GONE FROM CHROMIUM, 2012/01/24 18:13:59]

kUpdatedTime?

[vrk (LEFT CHROMIUM), 2012/01/25 00:09:32]

Done.

+  AdvanceSystemTime(kPlayDuration);
+  EXPECT_EQ(kExpected, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, CapAtMediaDuration_Paused) {
+  const base::TimeDelta kDuration =
+      base::TimeDelta::FromSeconds(kDurationInSeconds);
+  const base::TimeDelta kTimeOverDuration =
+      base::TimeDelta::FromSeconds(kDurationInSeconds + 4);
+
+  // Elapsed time should always be capped at the duration of the media.
+  clock_.SetTime(kTimeOverDuration, kTimeOverDuration);
+  EXPECT_EQ(kDuration, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, CapAtMediaDuration_Playing) {
+  const base::TimeDelta kZero;
+  const base::TimeDelta kDuration =
+      base::TimeDelta::FromSeconds(kDurationInSeconds);
+  const base::TimeDelta kTimeOverDuration =
+      base::TimeDelta::FromSeconds(kDurationInSeconds + 4);
+
+  // Play for twice as long as the duration of the media.
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(2 * kDuration);
+  EXPECT_EQ(kDuration, clock_.Elapsed());
+
+  // Manually set the time past the duration.
+  clock_.SetTime(kTimeOverDuration, kTimeOverDuration);
+  EXPECT_EQ(kDuration, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, SetMaxTime) {
   const base::TimeDelta kZero;
-  const base::TimeDelta kExepected = base::TimeDelta::FromSeconds(16);
+  const base::TimeDelta kTimeInterval = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kMaxTime = base::TimeDelta::FromSeconds(6);
+
+  EXPECT_EQ(kZero, clock_.Play());
+  clock_.SetMaxTime(kMaxTime);
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kTimeInterval, clock_.Elapsed());
+
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime, clock_.Elapsed());
+
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, SetMaxTime_MultipleTimes) {
+  const base::TimeDelta kZero;
+  const base::TimeDelta kTimeInterval = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kMaxTime1 = base::TimeDelta::FromSeconds(6);
+  const base::TimeDelta kMaxTime2 = base::TimeDelta::FromSeconds(12);
+
+  EXPECT_EQ(kZero, clock_.Play());
+  clock_.SetMaxTime(clock_.Duration());

[acolwell GONE FROM CHROMIUM, 2012/01/24 18:13:59]

Why Duration() here instead of kMaxTime1?

[vrk (LEFT CHROMIUM), 2012/01/25 00:09:32]

I wanted to test what happens if the MaxTime gets set to something large, then
gets set to something smaller. (This happens in the code when the pipeline is
done initializing and there's no audio, so max time is set to duration as the
clock runs wild and free... until the first SetMax gets called!)

I could make this a separate test if you want!

[acolwell GONE FROM CHROMIUM, 2012/01/25 05:20:30]

Ok that is what I thought might be the case. Just wanted to check.
 
No. This is fine.

+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kTimeInterval, clock_.Elapsed());
+
+  clock_.SetMaxTime(kMaxTime1);
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime1, clock_.Elapsed());
+
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime1, clock_.Elapsed());
+
+  clock_.SetMaxTime(kMaxTime2);
+  EXPECT_EQ(kMaxTime1, clock_.Elapsed());
+
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime1 + kTimeInterval, clock_.Elapsed());
 
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  clock.SetTime(base::TimeDelta::FromSeconds(12));
-  EXPECT_EQ(kExepected, clock.Elapsed());
+  AdvanceSystemTime(kTimeInterval);
+  EXPECT_EQ(kMaxTime2, clock_.Elapsed());
 }

[acolwell GONE FROM CHROMIUM, 2012/01/24 18:13:59]

\o/ these tests are so much clearer!!!

[vrk (LEFT CHROMIUM), 2012/01/25 00:09:32]

Yay!! :)

 
 }  // namespace media