Rename VideoRenderer::OnTimeStateChanged to OnTime{Progressing,Stopped}

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 273 matching lines @@
     return;
 
   time_source_->SetPlaybackRate(playback_rate);
 
   const double old_rate = playback_rate_;
   playback_rate_ = playback_rate;
   if (!time_ticking_ || !video_renderer_)
     return;
 
   if (old_rate == 0 && playback_rate > 0)
-    video_renderer_->OnTimeStateChanged(true);
+    video_renderer_->OnTimeProgressing();
   else if (old_rate > 0 && playback_rate == 0)
-    video_renderer_->OnTimeStateChanged(false);
+    video_renderer_->OnTimeStopped();
 }
 
 void RendererImpl::SetVolume(float volume) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
 
@@ skipping 281 matching lines @@
                               " resuming playback.";
       restarting_video_ = false;
       if (state_ == STATE_PLAYING &&
           !deferred_video_underflow_cb_.IsCancelled()) {
         // If deferred_video_underflow_cb_ wasn't triggered, then audio should
         // still be playing, we only need to unpause the video stream.
         DVLOG(4) << "deferred_video_underflow_cb_.Cancel()";
         deferred_video_underflow_cb_.Cancel();
         video_buffering_state_ = new_buffering_state;
         if (playback_rate_ > 0)
-          video_renderer_->OnTimeStateChanged(true);
+          video_renderer_->OnTimeProgressing();
         return true;
       }
     }
     // We don't handle the BUFFERING_HAVE_NOTHING case explicitly here, since
     // the existing logic for deferring video underflow reporting in
     // OnBufferingStateChange is exactly what we need. So fall through to the
     // regular video underflow handling path in OnBufferingStateChange.
   }
 
   if (type == DemuxerStream::AUDIO && restarting_audio_) {
@@ skipping 136 matching lines @@
     case STATE_ERROR:
       // An error state may occur at any time.
       break;
   }
 
   if (time_ticking_) {
     time_ticking_ = false;
     time_source_->StopTicking();
   }
   if (playback_rate_ > 0 && video_renderer_)
-    video_renderer_->OnTimeStateChanged(false);
+    video_renderer_->OnTimeStopped();
 }
 
 void RendererImpl::StartPlayback() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_PLAYING);
   DCHECK(!time_ticking_);
   DCHECK(!WaitingForEnoughData());
 
   time_ticking_ = true;
   time_source_->StartTicking();
   if (playback_rate_ > 0 && video_renderer_)
-    video_renderer_->OnTimeStateChanged(true);
+    video_renderer_->OnTimeProgressing();
 }
 
 void RendererImpl::OnRendererEnded(DemuxerStream::Type type) {
   DVLOG(1) << __func__ << (type == DemuxerStream::AUDIO ? " audio" : " video");
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK((type == DemuxerStream::AUDIO) || (type == DemuxerStream::VIDEO));
 
   if (state_ != STATE_PLAYING)
     return;
 
   if (type == DemuxerStream::AUDIO) {
     DCHECK(!audio_ended_);
     audio_ended_ = true;
   } else {
     DCHECK(!video_ended_);
     video_ended_ = true;
     DCHECK(video_renderer_);
-    video_renderer_->OnTimeStateChanged(false);
+    video_renderer_->OnTimeStopped();
   }
 
   RunEndedCallbackIfNeeded();
 }
 
 bool RendererImpl::PlaybackHasEnded() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_ && !audio_ended_)
     return false;
@@ skipping 52 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media