Use base::TimeTicks in OffScreenCanvas

Using a double timestamp is error prone and it's hard to tell which
units are being used.

Bug: 763980
Cq-Include-Trybots: luci.chromium.try:linux_layout_tests_slimming_paint_v2;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I2bb9e1fba0df15be9954cf055abed78016c39c9a
Reviewed-on: https://chromium-review.googlesource.com/1114180
Commit-Queue: Adithya Srinivasan <adithyas@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#570795}

third_party/blink/renderer/core/html/canvas/html_canvas_element.cc

@@ -415,7 +415,7 @@ void HTMLCanvasElement::FinalizeFrame() {
 
     if (LowLatencyEnabled() && !dirty_rect_.IsEmpty()) {
       // Push a frame
-      double start_time = WTF::CurrentTimeTicksInSeconds();
+      base::TimeTicks start_time = WTF::CurrentTimeTicks();
       scoped_refptr<StaticBitmapImage> image =
           canvas2d_bridge_->NewImageSnapshot(kPreferAcceleration);
       FloatRect src_rect(0, 0, Size().Width(), Size().Height());

third_party/blink/renderer/core/offscreencanvas/offscreen_canvas.cc

@@ -49,7 +49,7 @@ void OffscreenCanvas::Commit(scoped_refptr<StaticBitmapImage> bitmap_image,
   if (!HasPlaceholderCanvas())
     return;
 
-  double commit_start_time = WTF::CurrentTimeTicksInSeconds();
+  base::TimeTicks commit_start_time = WTF::CurrentTimeTicks();
   current_frame_damage_rect_.join(damage_rect);
   GetOrCreateFrameDispatcher()->DispatchFrameSync(
       std::move(bitmap_image), commit_start_time, current_frame_damage_rect_);
@@ -329,7 +329,7 @@ void OffscreenCanvas::PushFrame(scoped_refptr<StaticBitmapImage> image,
   current_frame_damage_rect_.join(damage_rect);
   if (current_frame_damage_rect_.isEmpty())
     return;
-  double commit_start_time = WTF::CurrentTimeTicksInSeconds();
+  base::TimeTicks commit_start_time = WTF::CurrentTimeTicks();
   GetOrCreateFrameDispatcher()->DispatchFrame(
       std::move(image), commit_start_time, current_frame_damage_rect_);
   current_frame_damage_rect_ = SkIRect::MakeEmpty();

third_party/blink/renderer/platform/graphics/canvas_resource_dispatcher.cc

@@ -128,7 +128,7 @@ void CanvasResourceDispatcher::PostImageToPlaceholder(
 
 void CanvasResourceDispatcher::DispatchFrameSync(
     scoped_refptr<StaticBitmapImage> image,
-    double commit_start_time,
+    base::TimeTicks commit_start_time,
     const SkIRect& damage_rect) {
   scoped_refptr<CanvasResource> canvas_resource = CanvasResourceBitmap::Create(
       std::move(image),
@@ -150,7 +150,7 @@ void CanvasResourceDispatcher::DispatchFrameSync(
 
 void CanvasResourceDispatcher::DispatchFrame(
     scoped_refptr<StaticBitmapImage> image,
-    double commit_start_time,
+    base::TimeTicks commit_start_time,
     const SkIRect& damage_rect) {
   scoped_refptr<CanvasResource> canvas_resource = CanvasResourceBitmap::Create(
       std::move(image),
@@ -170,7 +170,7 @@ void CanvasResourceDispatcher::DispatchFrame(
 
 bool CanvasResourceDispatcher::PrepareFrame(
     scoped_refptr<CanvasResource> canvas_resource,
-    double commit_start_time,
+    base::TimeTicks commit_start_time,
     const SkIRect& damage_rect,
     viz::CompositorFrame* frame) {
   DCHECK(canvas_resource->IsBitmap());
@@ -295,7 +295,7 @@ bool CanvasResourceDispatcher::PrepareFrame(
 
   frame->render_pass_list.push_back(std::move(pass));
 
-  double elapsed_time = WTF::CurrentTimeTicksInSeconds() - commit_start_time;
+  base::TimeDelta elapsed_time = WTF::CurrentTimeTicks() - commit_start_time;
 
   switch (commit_type) {
     case kCommitGPUCanvasGPUCompositing:
@@ -304,16 +304,16 @@ bool CanvasResourceDispatcher::PrepareFrame(
             CustomCountHistogram, commit_gpu_canvas_gpu_compositing_main_timer,
             ("Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositingMain", 0,
              10000000, 50));
-        commit_gpu_canvas_gpu_compositing_main_timer.Count(elapsed_time *
-                                                           1000000.0);
+        commit_gpu_canvas_gpu_compositing_main_timer.Count(
+            elapsed_time.InMicroseconds());
       } else {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram,
             commit_gpu_canvas_gpu_compositing_worker_timer,
             ("Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositingWorker", 0,
              10000000, 50));
-        commit_gpu_canvas_gpu_compositing_worker_timer.Count(elapsed_time *
-                                                             1000000.0);
+        commit_gpu_canvas_gpu_compositing_worker_timer.Count(
+            elapsed_time.InMicroseconds());
       }
       break;
     case kCommitGPUCanvasSoftwareCompositing:
@@ -323,8 +323,8 @@ bool CanvasResourceDispatcher::PrepareFrame(
             commit_gpu_canvas_software_compositing_main_timer,
             ("Blink.Canvas.OffscreenCommit.GPUCanvasSoftwareCompositingMain", 0,
              10000000, 50));
-        commit_gpu_canvas_software_compositing_main_timer.Count(elapsed_time *
-                                                                1000000.0);
+        commit_gpu_canvas_software_compositing_main_timer.Count(
+            elapsed_time.InMicroseconds());
       } else {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram,
@@ -332,8 +332,8 @@ bool CanvasResourceDispatcher::PrepareFrame(
             ("Blink.Canvas.OffscreenCommit."
              "GPUCanvasSoftwareCompositingWorker",
              0, 10000000, 50));
-        commit_gpu_canvas_software_compositing_worker_timer.Count(elapsed_time *
-                                                                  1000000.0);
+        commit_gpu_canvas_software_compositing_worker_timer.Count(
+            elapsed_time.InMicroseconds());
       }
       break;
     case kCommitSoftwareCanvasGPUCompositing:
@@ -343,8 +343,8 @@ bool CanvasResourceDispatcher::PrepareFrame(
             commit_software_canvas_gpu_compositing_main_timer,
             ("Blink.Canvas.OffscreenCommit.SoftwareCanvasGPUCompositingMain", 0,
              10000000, 50));
-        commit_software_canvas_gpu_compositing_main_timer.Count(elapsed_time *
-                                                                1000000.0);
+        commit_software_canvas_gpu_compositing_main_timer.Count(
+            elapsed_time.InMicroseconds());
       } else {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram,
@@ -352,8 +352,8 @@ bool CanvasResourceDispatcher::PrepareFrame(
             ("Blink.Canvas.OffscreenCommit."
              "SoftwareCanvasGPUCompositingWorker",
              0, 10000000, 50));
-        commit_software_canvas_gpu_compositing_worker_timer.Count(elapsed_time *
-                                                                  1000000.0);
+        commit_software_canvas_gpu_compositing_worker_timer.Count(
+            elapsed_time.InMicroseconds());
       }
       break;
     case kCommitSoftwareCanvasSoftwareCompositing:
@@ -365,7 +365,7 @@ bool CanvasResourceDispatcher::PrepareFrame(
              "SoftwareCanvasSoftwareCompositingMain",
              0, 10000000, 50));
         commit_software_canvas_software_compositing_main_timer.Count(
-            elapsed_time * 1000000.0);
+            elapsed_time.InMicroseconds());
       } else {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram,
@@ -374,7 +374,7 @@ bool CanvasResourceDispatcher::PrepareFrame(
              "SoftwareCanvasSoftwareCompositingWorker",
              0, 10000000, 50));
         commit_software_canvas_software_compositing_worker_timer.Count(
-            elapsed_time * 1000000.0);
+            elapsed_time.InMicroseconds());
       }
       break;
     case kOffscreenCanvasCommitTypeCount:

third_party/blink/renderer/platform/graphics/canvas_resource_dispatcher.h

@@ -48,11 +48,11 @@ class PLATFORM_EXPORT CanvasResourceDispatcher
   bool NeedsBeginFrame() const { return needs_begin_frame_; }
   bool IsAnimationSuspended() const { return suspend_animation_; }
   void DispatchFrame(scoped_refptr<StaticBitmapImage>,
-                     double commit_start_time,
+                     base::TimeTicks commit_start_time,
                      const SkIRect& damage_rect);
   void ReclaimResource(viz::ResourceId);
   void DispatchFrameSync(scoped_refptr<StaticBitmapImage>,
-                         double commit_start_time,
+                         base::TimeTicks commit_start_time,
                          const SkIRect& damage_rect);
 
   void Reshape(const IntSize&);
@@ -86,7 +86,7 @@ class PLATFORM_EXPORT CanvasResourceDispatcher
   friend class CanvasResourceDispatcherTest;
 
   bool PrepareFrame(scoped_refptr<CanvasResource>,
-                    double commit_start_time,
+                    base::TimeTicks commit_start_time,
                     const SkIRect& damage_rect,
                     viz::CompositorFrame* frame);
 

third_party/blink/renderer/platform/graphics/offscreen_canvas_frame_dispatcher_test.cc

@@ -60,8 +60,8 @@ class CanvasResourceDispatcherTest : public testing::Test {
 void CanvasResourceDispatcherTest::DispatchOneFrame() {
   sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(10, 10);
   dispatcher_->DispatchFrame(
-      StaticBitmapImage::Create(surface->makeImageSnapshot()), 0.0,
-      SkIRect::MakeEmpty());
+      StaticBitmapImage::Create(surface->makeImageSnapshot()),
+      base::TimeTicks(), SkIRect::MakeEmpty());
 }
 
 TEST_F(CanvasResourceDispatcherTest, PlaceholderRunsNormally) {