CL for perf tryjob on linux

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 14 matching lines @@
 #include "media/base/video_renderer.h"
 #include "media/base/wall_clock_time_source.h"
 
 namespace media {
 
 // See |video_underflow_threshold_|.
 static const int kDefaultVideoUnderflowThresholdMs = 3000;
 
 static const int kAudioRestartUnderflowThresholdMs = 2000;
 
+static const int kTimeUpdateIntervalMs = 50;
+
 class RendererImpl::RendererClientInternal : public RendererClient {
  public:
   RendererClientInternal(DemuxerStream::Type type, RendererImpl* renderer)
       : type_(type), renderer_(renderer) {
     DCHECK((type_ == DemuxerStream::AUDIO) || (type_ == DemuxerStream::VIDEO));
   }
 
   void OnError(PipelineStatus error) override { renderer_->OnError(error); }
   void OnEnded() override { renderer_->OnRendererEnded(type_); }
   void OnStatisticsUpdate(const PipelineStatistics& stats) override {
     renderer_->OnStatisticsUpdate(stats);
   }
   void OnBufferingStateChange(BufferingState state) override {
     renderer_->OnBufferingStateChange(type_, state);
   }
   void OnWaitingForDecryptionKey() override {
     renderer_->OnWaitingForDecryptionKey();
   }
   void OnVideoNaturalSizeChange(const gfx::Size& size) override {
     DCHECK(type_ == DemuxerStream::VIDEO);
     renderer_->OnVideoNaturalSizeChange(size);
   }
   void OnVideoOpacityChange(bool opaque) override {
     DCHECK(type_ == DemuxerStream::VIDEO);
     renderer_->OnVideoOpacityChange(opaque);
   }
+  void OnTimeUpdate(base::TimeDelta curr_time,
+                    base::TimeDelta max_time,
+                    base::TimeTicks capture_time) override {
+    NOTREACHED();
+  }
 
  private:
   DemuxerStream::Type type_;
   RendererImpl* renderer_;
 };
 
 RendererImpl::RendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     std::unique_ptr<AudioRenderer> audio_renderer,
     std::unique_ptr<VideoRenderer> video_renderer)
@@ skipping 165 matching lines @@
     DCHECK(time_source_);
     if (restarting_audio_)
       return;
     restarting_audio_ = true;
     // Stop ticking (transition into paused state) in audio renderer before
     // calling Flush, since after Flush we are going to restart playback by
     // calling audio renderer StartPlaying which would fail in playing state.
     if (time_ticking_) {
       time_ticking_ = false;
       time_source_->StopTicking();
+      CancelPeriodicMediaTimeUpdates();
     }
     audio_renderer_->Flush(
         base::Bind(&RendererImpl::RestartAudioRenderer, weak_this_, time));
   }
 }
 
 void RendererImpl::RestartVideoRenderer(base::TimeDelta time) {
   DVLOG(3) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(video_renderer_);
@@ skipping 37 matching lines @@
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
 
 base::TimeDelta RendererImpl::GetMediaTime() {
   // No BelongsToCurrentThread() checking because this can be called from other
   // threads.
-  return time_source_->CurrentMediaTime();
+  return time_source_->CurrentMediaTime(nullptr);
 }
 
 bool RendererImpl::HasAudio() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return audio_renderer_ != NULL;
 }
 
 bool RendererImpl::HasVideo() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return video_renderer_ != NULL;
@@ skipping 422 matching lines @@
       break;
 
     case STATE_ERROR:
       // An error state may occur at any time.
       break;
   }
 
   if (time_ticking_) {
     time_ticking_ = false;
     time_source_->StopTicking();
+    CancelPeriodicMediaTimeUpdates();
   }
   if (playback_rate_ > 0 && video_renderer_)
     video_renderer_->OnTimeStateChanged(false);
 }
 
 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();
+  SchedulePeriodicMediaTimeUpdates();
+
   if (playback_rate_ > 0 && video_renderer_)
     video_renderer_->OnTimeStateChanged(true);
 }
 
 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)
@@ skipping 71 matching lines @@
 void RendererImpl::OnVideoNaturalSizeChange(const gfx::Size& size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
+void RendererImpl::UpdateMediaTime() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(time_ticking_);
+
+  base::TimeTicks capture_time;
+  base::TimeDelta curr_time = time_source_->CurrentMediaTime(&capture_time);
+  // Allow some slop to account for delays in scheduling time update tasks.
+  base::TimeDelta max_time =
+      curr_time + base::TimeDelta::FromMilliseconds(2 * kTimeUpdateIntervalMs);
+  client_->OnTimeUpdate(curr_time, max_time, capture_time);
+}
+
+void RendererImpl::SchedulePeriodicMediaTimeUpdates() {
+  DVLOG(2) << __func__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  base::TimeTicks capture_time;
+  base::TimeDelta curr_time = time_source_->CurrentMediaTime(&capture_time);
+  client_->OnTimeUpdate(curr_time, curr_time, capture_time);
+
+  time_update_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kTimeUpdateIntervalMs),
+      base::Bind(&RendererImpl::UpdateMediaTime, weak_this_));
+}
+
+void RendererImpl::CancelPeriodicMediaTimeUpdates() {
+  DVLOG(2) << __func__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  time_update_timer_.Stop();
+
+  base::TimeTicks capture_time;
+  base::TimeDelta curr_time = time_source_->CurrentMediaTime(&capture_time);
+  client_->OnTimeUpdate(curr_time, curr_time, capture_time);
+}
+
 }  // namespace media