Add timer to OffscreenCanvas's commit API

third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp

 // Copyright 2016 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 "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
@@ skipping 134 matching lines @@
   resource.read_lock_fences_enabled = false;
   resource.is_software = false;
 
   // Hold ref to |image|, to keep it alive until the browser ReturnResources.
   // It guarantees that the resource is not re-used or deleted.
   m_cachedImages.add(m_nextResourceId, std::move(image));
 }
 
 void OffscreenCanvasFrameDispatcherImpl::dispatchFrame(
     RefPtr<StaticBitmapImage> image,
+    double commitStartTime,
     bool isWebGLSoftwareRendering /* This flag is true when WebGL's commit is
     called on SwiftShader. */) {
   if (!image)
     return;
   if (!verifyImageSize(image->imageForCurrentFrame()))
     return;
   cc::CompositorFrame frame;
   // TODO(crbug.com/652931): update the device_scale_factor
   frame.metadata.device_scale_factor = 1.0f;
   frame.delegated_frame_data.reset(new cc::DelegatedFrameData);
@@ skipping 10 matching lines @@
   cc::TransferableResource resource;
   resource.id = m_nextResourceId;
   resource.format = cc::ResourceFormat::RGBA_8888;
   // TODO(crbug.com/645590): filter should respect the image-rendering CSS
   // property of associated canvas element.
   resource.filter = GL_LINEAR;
   resource.size = gfx::Size(m_width, m_height);
   // TODO(crbug.com/646022): making this overlay-able.
   resource.is_overlay_candidate = false;
 
+  OffscreenCanvasCommitType commitType;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       EnumerationHistogram, commitTypeHistogram,
       new EnumerationHistogram("OffscreenCanvas.CommitType",
                                OffscreenCanvasCommitTypeCount));
   if (image->isTextureBacked()) {
     if (Platform::current()->isGPUCompositingEnabled() &&
         !isWebGLSoftwareRendering) {
       // Case 1: both canvas and compositor are gpu accelerated.
-      commitTypeHistogram.count(CommitGPUCanvasGPUCompositing);
+      commitType = CommitGPUCanvasGPUCompositing;
       setTransferableResourceToStaticBitmapImage(resource, image);
     } else {
       // Case 2: canvas is accelerated but --disable-gpu-compositing is
       // specified, or WebGL's commit is called with SwiftShader. The latter
       // case is indicated by
       // WebGraphicsContext3DProvider::isSoftwareRendering.
-      commitTypeHistogram.count(CommitGPUCanvasSoftwareCompositing);
+      commitType = CommitGPUCanvasSoftwareCompositing;
       setTransferableResourceToSharedBitmap(resource, image);
     }
   } else {
     if (Platform::current()->isGPUCompositingEnabled() &&
         !isWebGLSoftwareRendering) {
       // Case 3: canvas is not gpu-accelerated, but compositor is
-      commitTypeHistogram.count(CommitSoftwareCanvasGPUCompositing);
+      commitType = CommitSoftwareCanvasGPUCompositing;
       setTransferableResourceToSharedGPUContext(resource, image);
     } else {
       // Case 4: both canvas and compositor are not gpu accelerated.
-      commitTypeHistogram.count(CommitSoftwareCanvasSoftwareCompositing);
+      commitType = CommitSoftwareCanvasSoftwareCompositing;
       setTransferableResourceToSharedBitmap(resource, image);
     }
   }
+  commitTypeHistogram.count(commitType);
 
   m_nextResourceId++;
   frame.delegated_frame_data->resource_list.push_back(std::move(resource));
 
   cc::TextureDrawQuad* quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   gfx::Size rectSize(m_width, m_height);
 
   const bool needsBlending = true;
   // TOOD(crbug.com/645993): this should be inherited from WebGL context's
   // creation settings.
   const bool premultipliedAlpha = true;
   const gfx::PointF uvTopLeft(0.f, 0.f);
   const gfx::PointF uvBottomRight(1.f, 1.f);
   float vertexOpacity[4] = {1.f, 1.f, 1.f, 1.f};
   const bool yflipped = false;
   // TODO(crbug.com/645994): this should be true when using style
   // "image-rendering: pixelated".
   const bool nearestNeighbor = false;
   quad->SetAll(sqs, bounds, bounds, bounds, needsBlending, resource.id,
                gfx::Size(), premultipliedAlpha, uvTopLeft, uvBottomRight,
                SK_ColorTRANSPARENT, vertexOpacity, yflipped, nearestNeighbor,
                false);
 
   frame.delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
+  double elapsedTime = WTF::monotonicallyIncreasingTime() - commitStartTime;
+  if (commitType == CommitGPUCanvasGPUCompositing) {

[Justin Novosad, 2016/10/12 21:11:12]

Nit: Should use switch/case IMHO

[xidachen, 2016/10/13 01:39:24]

Done.

+    DEFINE_STATIC_LOCAL(CustomCountHistogram,
+                        commitGPUCanvasGPUCompositingTimer,
+                        ("Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositing",
+                         0, 10000000, 50));

[Justin Novosad, 2016/10/12 21:11:12]

I think we should double the number of categories to track calls made on the
main thread separately from those made in workers.  Ther might not be much
difference between the two today, but there could be when we address
crbug.com/655278

[xidachen, 2016/10/13 01:39:24]

Done.

+    commitGPUCanvasGPUCompositingTimer.count(elapsedTime * 1000000.0);
+  } else if (commitType == CommitGPUCanvasSoftwareCompositing) {
+    DEFINE_STATIC_LOCAL(
+        CustomCountHistogram, commitGPUCanvasSoftwareCompositingTimer,
+        ("Blink.Canvas.OffscreenCommit.GPUCanvasSoftwareCompositing", 0,
+         10000000, 50));
+    commitGPUCanvasSoftwareCompositingTimer.count(elapsedTime * 1000000.0);
+  } else if (commitType == CommitSoftwareCanvasGPUCompositing) {
+    DEFINE_STATIC_LOCAL(
+        CustomCountHistogram, commitSoftwareCanvasGPUCompositingTimer,
+        ("Blink.Canvas.OffscreenCommit.SoftwareCanvasGPUCompositing", 0,
+         10000000, 50));
+    commitSoftwareCanvasGPUCompositingTimer.count(elapsedTime * 1000000.0);
+  } else {
+    DEFINE_STATIC_LOCAL(
+        CustomCountHistogram, commitSoftwareCanvasSoftwareCompositingTimer,
+        ("Blink.Canvas.OffscreenCommit.SoftwareCanvasSoftwareCompositing", 0,
+         10000000, 50));
+    commitSoftwareCanvasSoftwareCompositingTimer.count(elapsedTime * 1000000.0);
+  }
+
   m_sink->SubmitCompositorFrame(std::move(frame), base::Closure());
 }
 
 void OffscreenCanvasFrameDispatcherImpl::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   for (const auto& resource : resources) {
     m_cachedImages.remove(resource.id);
     m_sharedBitmaps.remove(resource.id);
     m_cachedTextureIds.remove(resource.id);
   }
 }
 
 bool OffscreenCanvasFrameDispatcherImpl::verifyImageSize(
     const sk_sp<SkImage>& image) {
   if (image && image->width() == m_width && image->height() == m_height)
     return true;
   return false;
 }
 
 }  // namespace blink