Convert video capture pipline to base::TimeTicks

content/browser/renderer_host/media/web_contents_video_capture_device.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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 85 matching lines @@
   result.set_width(std::max(kMinFrameWidth, MakeEven(result.width())));
   result.set_height(std::max(kMinFrameHeight, MakeEven(result.height())));
 
   return result;
 }
 
 // Wrapper function to invoke ThreadSafeCaptureOracle::CaptureFrameCallback, is
 // compatible with RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback.
 void InvokeCaptureFrameCallback(
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
-    base::Time timestamp,
+    base::TimeTicks timestamp,
     bool frame_captured) {
   capture_frame_cb.Run(timestamp, frame_captured);
 }
 
 // FrameSubscriber is a proxy to the ThreadSafeCaptureOracle that's compatible
 // with RenderWidgetHostViewFrameSubscriber. We create one per event type.
 class FrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FrameSubscriber(VideoCaptureOracle::Event event_type,
                   const scoped_refptr<ThreadSafeCaptureOracle>& oracle)
       : event_type_(event_type),
         oracle_proxy_(oracle) {}
 
   virtual bool ShouldCaptureFrame(
-      base::Time present_time,
+      base::TimeTicks present_time,
       scoped_refptr<media::VideoFrame>* storage,
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback*
           deliver_frame_cb) OVERRIDE;
 
  private:
   const VideoCaptureOracle::Event event_type_;
   scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_;
 };
 
 // ContentCaptureSubscription is the relationship between a RenderWidgetHost
 // whose content is updating, a subscriber that is deciding which of these
 // updates to capture (and where to deliver them to), and a callback that
 // knows how to do the capture and prepare the result for delivery.
 //
 // In practice, this means (a) installing a RenderWidgetHostFrameSubscriber in
 // the RenderWidgetHostView, to process updates that occur via accelerated
 // compositing, (b) installing itself as an observer of updates to the
 // RenderWidgetHost's backing store, to hook updates that occur via software
 // rendering, and (c) running a timer to possibly initiate non-event-driven
 // captures that the subscriber might request.
 //
 // All of this happens on the UI thread, although the
 // RenderWidgetHostViewFrameSubscriber we install may be dispatching updates
 // autonomously on some other thread.
 class ContentCaptureSubscription : public content::NotificationObserver {
  public:
-  typedef base::Callback<void(
-      const base::Time&,
-      const scoped_refptr<media::VideoFrame>&,
-      const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&)>
-          CaptureCallback;
+  typedef base::Callback<
+      void(const base::TimeTicks&,
+           const scoped_refptr<media::VideoFrame>&,
+           const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&)>
+      CaptureCallback;
 
   // Create a subscription. Whenever a manual capture is required, the
   // subscription will invoke |capture_callback| on the UI thread to do the
   // work.
   ContentCaptureSubscription(
       const RenderWidgetHost& source,
       const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
       const CaptureCallback& capture_callback);
   virtual ~ContentCaptureSubscription();
 
@@ skipping 48 matching lines @@
   // VideoCaptureMachine overrides.
   virtual bool Start(
       const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy) OVERRIDE;
   virtual void Stop() OVERRIDE;
 
   // Starts a copy from the backing store or the composited surface. Must be run
   // on the UI BrowserThread. |deliver_frame_cb| will be run when the operation
   // completes. The copy will occur to |target|.
   //
   // This may be used as a ContentCaptureSubscription::CaptureCallback.
-  void Capture(
-      const base::Time& start_time,
-      const scoped_refptr<media::VideoFrame>& target,
-      const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
-          deliver_frame_cb);
+  void Capture(const base::TimeTicks& start_time,
+               const scoped_refptr<media::VideoFrame>& target,
+               const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
+                   deliver_frame_cb);
 
   // content::WebContentsObserver implementation.
   virtual void DidShowFullscreenWidget(int routing_id) OVERRIDE {
     fullscreen_widget_id_ = routing_id;
     RenewFrameSubscription();
   }
 
   virtual void DidDestroyFullscreenWidget(int routing_id) OVERRIDE {
     DCHECK_EQ(fullscreen_widget_id_, routing_id);
     fullscreen_widget_id_ = MSG_ROUTING_NONE;
@@ skipping 18 matching lines @@
 
  private:
   // Starts observing the web contents, returning false if lookup fails.
   bool StartObservingWebContents();
 
   // Helper function to determine the view that we are currently tracking.
   RenderWidgetHost* GetTarget();
 
   // Response callback for RenderWidgetHost::CopyFromBackingStore().
   void DidCopyFromBackingStore(
-      const base::Time& start_time,
+      const base::TimeTicks& start_time,
       const scoped_refptr<media::VideoFrame>& target,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success,
       const SkBitmap& bitmap);
 
   // Response callback for RWHVP::CopyFromCompositingSurfaceToVideoFrame().
   void DidCopyFromCompositingSurfaceToVideoFrame(
-      const base::Time& start_time,
+      const base::TimeTicks& start_time,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success);
 
   // Remove the old subscription, and start a new one. This should be called
   // after any change to the WebContents that affects the RenderWidgetHost or
   // attached views.
   void RenewFrameSubscription();
 
   // Parameters saved in constructor.
@@ skipping 27 matching lines @@
  public:
   VideoFrameDeliveryLog();
 
   // Treat |frame_number| as having been delivered, and update the
   // frame rate statistics accordingly.
   void ChronicleFrameDelivery(int frame_number);
 
  private:
   // The following keep track of and log the effective frame rate whenever
   // verbose logging is turned on.
-  base::Time last_frame_rate_log_time_;
+  base::TimeTicks last_frame_rate_log_time_;
   int count_frames_rendered_;
   int last_frame_number_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliveryLog);
 };
 
 bool FrameSubscriber::ShouldCaptureFrame(
-    base::Time present_time,
+    base::TimeTicks present_time,
     scoped_refptr<media::VideoFrame>* storage,
     DeliverFrameCallback* deliver_frame_cb) {
   TRACE_EVENT1("mirroring", "FrameSubscriber::ShouldCaptureFrame",
                "instance", this);
 
   ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
   bool oracle_decision = oracle_proxy_->ObserveEventAndDecideCapture(
       event_type_, present_time, storage, &capture_frame_cb);
 
   *deliver_frame_cb = base::Bind(&InvokeCaptureFrameCallback, capture_frame_cb);
@@ skipping 66 matching lines @@
   if (!rwh || !rwh->GetView() || (rwh->is_accelerated_compositing_active() &&
                                   rwh->GetView()->IsSurfaceAvailableForCopy()))
     return;
 
   TRACE_EVENT1("mirroring", "ContentCaptureSubscription::Observe",
                "instance", this);
 
   base::Closure copy_done_callback;
   scoped_refptr<media::VideoFrame> frame;
   RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback deliver_frame_cb;
-  const base::Time start_time = base::Time::Now();
+  const base::TimeTicks start_time = base::TimeTicks::Now();
   if (paint_subscriber_.ShouldCaptureFrame(start_time,
                                            &frame,
                                            &deliver_frame_cb)) {
     // This message happens just before paint. If we post a task to do the copy,
     // it should run soon after the paint.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(capture_callback_, start_time, frame, deliver_frame_cb));
   }
 }
 
 void ContentCaptureSubscription::OnTimer() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT0("mirroring", "ContentCaptureSubscription::OnTimer");
 
   scoped_refptr<media::VideoFrame> frame;
   RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback deliver_frame_cb;
 
-  const base::Time start_time = base::Time::Now();
+  const base::TimeTicks start_time = base::TimeTicks::Now();
   if (timer_subscriber_.ShouldCaptureFrame(start_time,
                                            &frame,
                                            &deliver_frame_cb)) {
     capture_callback_.Run(start_time, frame, deliver_frame_cb);
   }
 }
 
 void RenderVideoFrame(const SkBitmap& input,
                       const scoped_refptr<media::VideoFrame>& output,
                       const base::Callback<void(bool)>& done_cb) {
@@ skipping 66 matching lines @@
 VideoFrameDeliveryLog::VideoFrameDeliveryLog()
     : last_frame_rate_log_time_(),
       count_frames_rendered_(0),
       last_frame_number_(0) {
 }
 
 void VideoFrameDeliveryLog::ChronicleFrameDelivery(int frame_number) {
   // Log frame rate, if verbose logging is turned on.
   static const base::TimeDelta kFrameRateLogInterval =
       base::TimeDelta::FromSeconds(10);
-  const base::Time now = base::Time::Now();
+  const base::TimeTicks now = base::TimeTicks::Now();
   if (last_frame_rate_log_time_.is_null()) {
     last_frame_rate_log_time_ = now;
     count_frames_rendered_ = 0;
     last_frame_number_ = frame_number;
   } else {
     ++count_frames_rendered_;
     const base::TimeDelta elapsed = now - last_frame_rate_log_time_;
     if (elapsed >= kFrameRateLogInterval) {
       const double measured_fps =
           count_frames_rendered_ / elapsed.InSecondsF();
@@ skipping 49 matching lines @@
   subscription_.reset();
   if (web_contents()) {
     web_contents()->DecrementCapturerCount();
     Observe(NULL);
   }
   render_thread_.Stop();
   started_ = false;
 }
 
 void WebContentsCaptureMachine::Capture(
-    const base::Time& start_time,
+    const base::TimeTicks& start_time,
     const scoped_refptr<media::VideoFrame>& target,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   RenderWidgetHost* rwh = GetTarget();
   RenderWidgetHostViewPort* view =
       rwh ? RenderWidgetHostViewPort::FromRWHV(rwh->GetView()) : NULL;
   if (!view || !rwh) {
-    deliver_frame_cb.Run(base::Time(), false);
+    deliver_frame_cb.Run(base::TimeTicks(), false);
     return;
   }
 
   gfx::Size video_size = target->coded_size();
   gfx::Size view_size = view->GetViewBounds().size();
   gfx::Size fitted_size;
   if (!view_size.IsEmpty()) {
     fitted_size = ComputeYV12LetterboxRegion(video_size, view_size).size();
   }
   if (view_size != last_view_size_) {
@@ skipping 78 matching lines @@
     if (process)
       rwh = RenderWidgetHost::FromID(process->GetID(), fullscreen_widget_id_);
   } else {
     rwh = web_contents()->GetRenderViewHost();
   }
 
   return rwh;
 }
 
 void WebContentsCaptureMachine::DidCopyFromBackingStore(
-    const base::Time& start_time,
+    const base::TimeTicks& start_time,
     const scoped_refptr<media::VideoFrame>& target,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb,
     bool success,
     const SkBitmap& bitmap) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  base::Time now = base::Time::Now();
+  base::TimeTicks now = base::TimeTicks::Now();
   if (success) {
     UMA_HISTOGRAM_TIMES("TabCapture.CopyTimeBitmap", now - start_time);
     TRACE_EVENT_ASYNC_STEP_INTO0("mirroring", "Capture", target.get(),
                                  "Render");
     render_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
         &RenderVideoFrame, bitmap, target,
         base::Bind(deliver_frame_cb, start_time)));
   } else {
     // Capture can fail due to transient issues, so just skip this frame.
     DVLOG(1) << "CopyFromBackingStore failed; skipping frame.";
     deliver_frame_cb.Run(start_time, false);
   }
 }
 
 void WebContentsCaptureMachine::DidCopyFromCompositingSurfaceToVideoFrame(
-    const base::Time& start_time,
+    const base::TimeTicks& start_time,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb,
     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  base::Time now = base::Time::Now();
+  base::TimeTicks now = base::TimeTicks::Now();
 
   if (success) {
     UMA_HISTOGRAM_TIMES("TabCapture.CopyTimeVideoFrame", now - start_time);
   } else {
     // Capture can fail due to transient issues, so just skip this frame.
     DVLOG(1) << "CopyFromCompositingSurface failed; skipping frame.";
   }
   deliver_frame_cb.Run(start_time, success);
 }
 
@@ skipping 41 matching lines @@
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   impl_->AllocateAndStart(params, client.Pass());
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   impl_->StopAndDeAllocate();
 }
 
 }  // namespace content