Remove duration from media::Clock.

media/base/clock_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/compiler_specific.h"
 #include "base/logging.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/clock.h"
 #include "media/base/clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 12 matching lines @@
 }
 
 }  // namespace
 
 namespace media {
 
 static const int kDurationInSeconds = 120;
 
 class ClockTest : public ::testing::Test {
  public:
-  ClockTest() : clock_(&test_tick_clock_) {
-    SetDuration();
-  }
+  ClockTest()
+      : clock_(&test_tick_clock_),
+        duration_(base::TimeDelta::FromSeconds(kDurationInSeconds)) {}
 
  protected:
-  void SetDuration() {
-    const base::TimeDelta kDuration =
-        base::TimeDelta::FromSeconds(kDurationInSeconds);
-    clock_.SetDuration(kDuration);
-    EXPECT_EQ(kDuration, clock_.Duration());
-  }
-
   void AdvanceSystemTime(base::TimeDelta delta) {
     test_tick_clock_.Advance(delta);
   }
 
   base::SimpleTestTickClock test_tick_clock_;
   Clock clock_;
   base::TimeDelta time_elapsed_;
+  base::TimeDelta duration_;

[xhwang, 2014/07/08 19:53:10]

Now the Clock has no concept of duration. Rename to max_time_? Also, make it a
static const?

[scherkus (not reviewing), 2014/07/08 21:20:04]

Actually I just removed it instead and created const TimeDeltas in the tests
that need it

 };
 
 TEST_F(ClockTest, Created) {
   const base::TimeDelta kExpected = base::TimeDelta::FromSeconds(0);
   EXPECT_EQ(kExpected, clock_.Elapsed());
 }
 
 TEST_F(ClockTest, Play_NormalSpeed) {
   const base::TimeDelta kZero;
   const base::TimeDelta kTimeToAdvance = base::TimeDelta::FromSeconds(2);
@@ skipping 86 matching lines @@
   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_.SetTime(kFirstTime, clock_.Duration());
+  clock_.SetTime(kFirstTime, duration_);
   EXPECT_EQ(kFirstTime, clock_.Elapsed());
-  clock_.SetTime(kSecondTime, clock_.Duration());
+  clock_.SetTime(kSecondTime, 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.
   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(kUpdatedTime, clock_.Duration());
+  clock_.SetTime(kUpdatedTime, duration_);
   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());
+  clock_.SetMaxTime(duration_);
   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());
 }
 
 }  // namespace media