Fix media timeline so that thumb never exceeds buffered data

media/base/clock_unittest.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/test/mock_time_provider.h"
 #include "media/base/clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace base {
 
 // Provide a stream output operator so we can use EXPECT_EQ(...) with TimeDelta.
 //
 // TODO(scherkus): move this into the testing package.
 static std::ostream& operator<<(std::ostream& stream, const TimeDelta& time) {
   return (stream << time.ToInternalValue());
 }
 
 }  // namespace
 
 namespace media {
 
-TEST(ClockTest, Created) {
-  StrictMock<base::MockTimeProvider> mock_time;
+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_;
+};
+
+TEST_F(ClockTest, Created) {
   const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  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)));
-  const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, 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)));
-  const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetPlaybackRate(2.0f);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, 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)));
-  const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(2);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  clock.SetPlaybackRate(0.5f);
-  EXPECT_EQ(kZero, clock.Play());
-  EXPECT_EQ(kExpected, clock.Elapsed());
-}
-
-TEST(ClockTest, Play_ZeroSpeed) {
+  EXPECT_EQ(kExpected, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, Play_NormalSpeed) {
+  const base::TimeDelta kZero;
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(2);
+
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(kTimeToAdvance, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, Play_DoubleSpeed) {
+  const base::TimeDelta kZero;
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(5);
+
+  clock_.SetPlaybackRate(2.0f);
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(2 * kTimeToAdvance, clock_.Elapsed());
+}
+
+TEST_F(ClockTest, Play_HalfSpeed) {
+  const base::TimeDelta kZero;
+  const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(4);
+
+  clock_.SetPlaybackRate(0.5f);
+  EXPECT_EQ(kZero, clock_.Play());
+  AdvanceSystemTime(kTimeToAdvance);
+  EXPECT_EQ(kTimeToAdvance / 2, clock_.Elapsed());
+}
+
+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)));
-  const base::TimeDelta kZero;
-  const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(10);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  clock.SetPlaybackRate(0.0f);
-  clock.SetPlaybackRate(1.0f);
-  EXPECT_EQ(kExpected, clock.Elapsed());
-}
-
-TEST(ClockTest, Play_MultiSpeed) {
+  // seconds at normal speed.
+  const base::TimeDelta kZero;
+  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);
+
+  EXPECT_EQ(kExpected, clock_.Elapsed());
+}
+
+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)));
-  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());
-}
-
-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)));
-  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());
-}
-
-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;
+  // seconds at double speed.
+  const base::TimeDelta kZero;
+  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_F(ClockTest, Pause) {
+  const base::TimeDelta kZero;
+  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_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());
-}
-
-TEST(ClockTest, SetTime_Playing) {
+  clock_.SetTime(kFirstTime, clock_.Duration());
+  EXPECT_EQ(kFirstTime, clock_.Elapsed());
+  clock_.SetTime(kSecondTime, clock_.Duration());
+  EXPECT_EQ(kSecondTime, clock_.Elapsed());
+}
+
+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)));
-  const base::TimeDelta kZero;
-  const base::TimeDelta kExepected = base::TimeDelta::FromSeconds(16);
-
-  Clock clock(&base::MockTimeProvider::StaticNow);
-  EXPECT_EQ(kZero, clock.Play());
-  clock.SetTime(base::TimeDelta::FromSeconds(12));
-  EXPECT_EQ(kExepected, clock.Elapsed());
+  // 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 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());
+
+  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