Rename media::Clock to media::TimeDeltaInterpolator and update API.

media/base/time_delta_interpolator.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 "media/base/clock.h"
+#include "media/base/time_delta_interpolator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/time/tick_clock.h"
 #include "media/base/buffers.h"
 
 namespace media {
 
-Clock::Clock(base::TickClock* clock)
-    : clock_(clock),
-      playing_(false),
+TimeDeltaInterpolator::TimeDeltaInterpolator(base::TickClock* tick_clock)
+    : tick_clock_(tick_clock),
+      interpolating_(false),
       underflow_(false),
       playback_rate_(1.0f),
       max_time_(kNoTimestamp()) {
-  DCHECK(clock_);
+  DCHECK(tick_clock_);
 }
 
-Clock::~Clock() {}
+TimeDeltaInterpolator::~TimeDeltaInterpolator() {}
 
-bool Clock::IsPlaying() const {
-  return playing_;
-}
-
-base::TimeDelta Clock::Play() {
-  DCHECK(!playing_);
+base::TimeDelta TimeDeltaInterpolator::StartInterpolating() {
+  DCHECK(!interpolating_);
   UpdateReferencePoints();
-  playing_ = true;
+  interpolating_ = true;
   return media_time_;
 }
 
-base::TimeDelta Clock::Pause() {
-  DCHECK(playing_);
+base::TimeDelta TimeDeltaInterpolator::StopInterpolating() {
+  DCHECK(interpolating_);
   UpdateReferencePoints();
-  playing_ = false;
+  interpolating_ = false;
   return media_time_;
 }
 
-void Clock::SetPlaybackRate(float playback_rate) {
+void TimeDeltaInterpolator::SetPlaybackRate(float playback_rate) {
   UpdateReferencePoints();
   playback_rate_ = playback_rate;
 }
 
-void Clock::SetTime(base::TimeDelta current_time, base::TimeDelta max_time) {
+void TimeDeltaInterpolator::SetTime(base::TimeDelta current_time,
+                                    base::TimeDelta max_time) {
   DCHECK(current_time <= max_time);
   DCHECK(current_time != kNoTimestamp());
 
   UpdateReferencePoints(current_time);
   max_time_ = ClampToValidTimeRange(max_time);
   underflow_ = false;
 }
 
-base::TimeDelta Clock::Elapsed() {
+base::TimeDelta TimeDeltaInterpolator::GetInterpolatedTime() {
   // The clock is not advancing, so return the last recorded time.
-  if (!playing_ || underflow_)
+  if (!interpolating_ || underflow_)

[acolwell GONE FROM CHROMIUM, 2014/07/09 00:42:46]

hmm.. seems like we should merge these into a single state variable. Once we
underflow, we aren't technically interpolating anymore since we clamp to the
upper bound.

[scherkus (not reviewing), 2014/07/09 01:54:32]

I noticed the same thing but wanted to keep this CL mostly cosmetic ... but I
decided to change it anyway. Unit tests should help provide coverage.

     return media_time_;
 
   base::TimeDelta elapsed = EstimatedElapsedTime();
   if (max_time_ != kNoTimestamp() && elapsed > max_time_) {
     UpdateReferencePoints(max_time_);
     underflow_ = true;
     elapsed = max_time_;
   }
 
   return elapsed;
 }
 
-void Clock::SetMaxTime(base::TimeDelta max_time) {
+void TimeDeltaInterpolator::SetMaxTime(base::TimeDelta max_time) {
   DCHECK(max_time != kNoTimestamp());
 
   UpdateReferencePoints();
   max_time_ = ClampToValidTimeRange(max_time);
 
   underflow_ = media_time_ > max_time_;
   if (underflow_)
     media_time_ = max_time_;
 }
 
-base::TimeDelta Clock::ElapsedViaProvidedTime(
+base::TimeDelta TimeDeltaInterpolator::ElapsedViaProvidedTime(
     const base::TimeTicks& time) const {
   // TODO(scherkus): floating point badness scaling time by playback rate.
   int64 now_us = (time - reference_).InMicroseconds();
   now_us = static_cast<int64>(now_us * playback_rate_);
   return media_time_ + base::TimeDelta::FromMicroseconds(now_us);
 }
 
-base::TimeDelta Clock::ClampToValidTimeRange(base::TimeDelta time) const {
+base::TimeDelta TimeDeltaInterpolator::ClampToValidTimeRange(
+    base::TimeDelta time) const {
   return std::max(base::TimeDelta(), time);
 }
 
-void Clock::UpdateReferencePoints() {
-  UpdateReferencePoints(Elapsed());
+void TimeDeltaInterpolator::UpdateReferencePoints() {
+  UpdateReferencePoints(GetInterpolatedTime());
 }
 
-void Clock::UpdateReferencePoints(base::TimeDelta current_time) {
+void TimeDeltaInterpolator::UpdateReferencePoints(
+    base::TimeDelta current_time) {
   media_time_ = ClampToValidTimeRange(current_time);
-  reference_ = clock_->NowTicks();
+  reference_ = tick_clock_->NowTicks();
 }
 
-base::TimeDelta Clock::EstimatedElapsedTime() {
-  return ClampToValidTimeRange(ElapsedViaProvidedTime(clock_->NowTicks()));
+base::TimeDelta TimeDeltaInterpolator::EstimatedElapsedTime() {
+  return ClampToValidTimeRange(ElapsedViaProvidedTime(tick_clock_->NowTicks()));
 }
 
 }  // namespace media