Switch GetWallClockTime to using vectors for input and output.

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 126 matching lines @@
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& init_cb,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const StatisticsCB& statistics_cb,
     const BufferingStateCB& buffering_state_cb,
     const base::Closure& ended_cb,
     const PipelineStatusCB& error_cb,
-    const WallClockTimeCB& wall_clock_time_cb,
+    const TimeSource::WallClockTimeCB& wall_clock_time_cb,
     const base::Closure& waiting_for_decryption_key_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!wall_clock_time_cb.is_null());
@@ skipping 183 matching lines @@
             FROM_HERE, base::Bind(buffering_state_cb_, BUFFERING_HAVE_NOTHING));
       } else {
         wait_time = std::min(kIdleTimeDelta, latest_possible_paint_time_ - now);
       }
 
       UpdateStatsAndWait_Locked(wait_time);
       continue;
     }
 
     base::TimeTicks target_paint_time =
-        wall_clock_time_cb_.Run(ready_frames_.front()->timestamp());
+        ConvertMediaTimestamp(ready_frames_.front()->timestamp());
 
     // If media time has stopped, don't attempt to paint any more frames.
     if (target_paint_time.is_null()) {
       UpdateStatsAndWait_Locked(kIdleTimeDelta);
       continue;
     }
 
     // Deadline is defined as the duration between this frame and the next
     // frame, using the delta between this frame and the previous frame as the
     // assumption for frame duration.
@@ skipping 53 matching lines @@
   }
 }
 
 void VideoRendererImpl::PaintNextReadyFrame_Locked() {
   DCHECK(!use_new_video_renderering_path_);
   lock_.AssertAcquired();
 
   scoped_refptr<VideoFrame> next_frame = ready_frames_.front();
   ready_frames_.pop_front();
 
-  last_media_time_ = wall_clock_time_cb_.Run(next_frame->timestamp());
+  last_media_time_ = ConvertMediaTimestamp(next_frame->timestamp());
 
   paint_cb_.Run(next_frame);
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::DropNextReadyFrame_Locked() {
   DCHECK(!use_new_video_renderering_path_);
   TRACE_EVENT0("media", "VideoRendererImpl:frameDropped");
 
   lock_.AssertAcquired();
 
-  last_media_time_ =
-      wall_clock_time_cb_.Run(ready_frames_.front()->timestamp());
+  last_media_time_ = ConvertMediaTimestamp(ready_frames_.front()->timestamp());
 
   ready_frames_.pop_front();
   frames_dropped_++;
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
@@ skipping 284 matching lines @@
   if (!effective_frames ||
       (algorithm_->frames_queued() == 1u &&
        algorithm_->average_frame_duration() == base::TimeDelta())) {
     rendered_end_of_stream_ = true;
     task_runner_->PostTask(FROM_HERE, ended_cb_);
   }
 
   return effective_frames;
 }
 
+base::TimeTicks VideoRendererImpl::ConvertMediaTimestamp(
+    base::TimeDelta media_time) {
+  std::vector<base::TimeDelta> media_times(1, media_time);
+  std::vector<base::TimeTicks> wall_clock_times;
+  if (!wall_clock_time_cb_.Run(media_times, &wall_clock_times))
+    return base::TimeTicks();
+  return wall_clock_times[0];
+}
+
 }  // namespace media