Remove duration from media::Clock.

media/base/pipeline.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/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 138 matching lines @@
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::VolumeChangedTask, base::Unretained(this), volume));
   }
 }
 
 TimeDelta Pipeline::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
-  return clock_->Elapsed();
+  return std::min(clock_->Elapsed(), duration_);
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() const {
   base::AutoLock auto_lock(lock_);
   return buffered_time_ranges_;
 }
 
 TimeDelta Pipeline::GetMediaDuration() const {
   base::AutoLock auto_lock(lock_);
-  return clock_->Duration();
+  return duration_;
 }
 
 bool Pipeline::DidLoadingProgress() {
   base::AutoLock auto_lock(lock_);
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
 
 PipelineStatistics Pipeline::GetStatistics() const {
@@ skipping 137 matching lines @@
 }
 
 void Pipeline::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
-  clock_->SetDuration(duration);
+  duration_ = duration;
   if (!duration_change_cb_.is_null())
     duration_change_cb_.Run();
 }
 
 void Pipeline::OnStateTransition(PipelineStatus status) {
   // Force post to process state transitions after current execution frame.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StateTransitionTask, base::Unretained(this), status));
 }
 
@@ skipping 362 matching lines @@
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!audio_ended_);
   audio_ended_ = true;
 
   // Start clock since there is no more audio to trigger clock updates.
   {
     base::AutoLock auto_lock(lock_);
-    clock_->SetMaxTime(clock_->Duration());
+    clock_->SetMaxTime(duration_);
     StartClockIfWaitingForTimeUpdate_Locked();
   }
 
   RunEndedCallbackIfNeeded();
 }
 
 void Pipeline::DoVideoRendererEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != kPlaying)
@@ skipping 25 matching lines @@
 
   if (video_renderer_ && !video_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_ended_)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     PauseClockAndStopRendering_Locked();
-    clock_->SetTime(clock_->Duration(), clock_->Duration());
+    clock_->SetTime(duration_, duration_);
   }
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
 void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
                                  const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
@@ skipping 109 matching lines @@
 
   if (audio_renderer_) {
     // We use audio stream to update the clock. So if there is such a
     // stream, we pause the clock until we receive a valid timestamp.
     base::AutoLock auto_lock(lock_);
     clock_state_ = CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE;
     audio_renderer_->StartRendering();
   } else {
     base::AutoLock auto_lock(lock_);
     clock_state_ = CLOCK_PLAYING;
-    clock_->SetMaxTime(clock_->Duration());
+    clock_->SetMaxTime(duration_);
     clock_->Play();
   }
 }
 
 void Pipeline::PauseClockAndStopRendering_Locked() {
   lock_.AssertAcquired();
   switch (clock_state_) {
     case CLOCK_PAUSED:
       return;
 
@@ skipping 14 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (clock_state_ != CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE)
     return;
 
   clock_state_ = CLOCK_PLAYING;
   clock_->Play();
 }
 
 }  // namespace media