Adding performance tracking for canvas API calls

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.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 "modules/canvas2d/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/canvas2d/CanvasStyle.h"
 #include "modules/canvas2d/Path2D.h"
+#include "platform/Histogram.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 
 namespace blink {
@@ skipping 951 matching lines @@
     return false;
 }
 
 void BaseRenderingContext2D::drawImage(ExecutionContext* executionContext, CanvasImageSource* imageSource,
     double sx, double sy, double sw, double sh,
     double dx, double dy, double dw, double dh, ExceptionState& exceptionState)
 {
     if (!drawingCanvas())
         return;
 
+    Optional<ScopedUsHistogramTimer> timer;
+    if (imageBuffer() && imageBuffer()->isAccelerated()) {
+        if (imageSource->isVideoElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterVideoGPU, ("Blink.Canvas.DrawImage.VideoGPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterVideoGPU);
+        } else if (imageSource->isCanvasElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCanvasGPU, ("Blink.Canvas.DrawImage.CanvasGPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterCanvasGPU);
+        } else if (imageSource->isSVGSource()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterSVGGPU, ("Blink.Canvas.DrawImage.SVGGPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterSVGGPU);
+        } else if (imageSource->isImageBitmap()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterImageBitmapGPU, ("Blink.Canvas.DrawImage.ImageBitmapGPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterImageBitmapGPU);
+        } else {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterOthersGPU, ("Blink.Canvas.DrawImage.OthersGPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterOthersGPU);
+        }
+    } else if (imageBuffer() && imageBuffer()->isRecording()) {
+        if (imageSource->isVideoElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterVideoDisplayList, ("Blink.Canvas.DrawImage.VideoDisplayList", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterVideoDisplayList);
+        } else if (imageSource->isCanvasElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCanvasDisplayList, ("Blink.Canvas.DrawImage.CanvasDisplayList", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterCanvasDisplayList);
+        } else if (imageSource->isSVGSource()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterSVGDisplayList, ("Blink.Canvas.DrawImage.SVGDisplayList", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterSVGDisplayList);
+        } else if (imageSource->isImageBitmap()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterImageBitmapDisplayList, ("Blink.Canvas.DrawImage.ImageBitmapDisplayList", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterImageBitmapDisplayList);
+        } else {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterOthersDisplayList, ("Blink.Canvas.DrawImage.OthersDisplayList", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterOthersDisplayList);
+        }
+    } else {
+        if (imageSource->isVideoElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterVideoCPU, ("Blink.Canvas.DrawImage.VideoCPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterVideoCPU);
+        } else if (imageSource->isCanvasElement()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCanvasCPU, ("Blink.Canvas.DrawImage.CanvasCPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterCanvasCPU);
+        } else if (imageSource->isSVGSource()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterSVGCPU, ("Blink.Canvas.DrawImage.SVGCPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterSVGCPU);
+        } else if (imageSource->isImageBitmap()) {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterImageBitmapCPU, ("Blink.Canvas.DrawImage.ImageBitmapCPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterImageBitmapCPU);
+        } else {
+            DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterOthersCPU, ("Blink.Canvas.DrawImage.OthersCPU", 0, 10000000, 50));
+            timer.emplace(scopedUsCounterOthersCPU);
+        }
+    }
+
     RefPtr<Image> image;
     FloatSize defaultObjectSize(width(), height());
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
         AccelerationHint hint = imageBuffer()->isAccelerated() ? PreferAcceleration : PreferNoAcceleration;
         image = imageSource->getSourceImageForCanvas(&sourceImageStatus, hint, SnapshotReasonDrawImage, defaultObjectSize);
         if (sourceImageStatus == UndecodableSourceImageStatus)
             exceptionState.throwDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");
         if (!image || !image->width() || !image->height())
             return;
@@ skipping 182 matching lines @@
         size.setHeight(1);
 
     ImageData* result = ImageData::create(size);
     if (!result)
         exceptionState.throwRangeError("Out of memory at ImageData creation");
     return result;
 }
 
 ImageData* BaseRenderingContext2D::getImageData(double sx, double sy, double sw, double sh, ExceptionState& exceptionState) const
 {
+    Optional<ScopedUsHistogramTimer> timer;
+    if (imageBuffer() && imageBuffer()->isAccelerated()) {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterGPU, ("Blink.Canvas.GetImageData.GPU", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterGPU);
+    } else if (imageBuffer() && imageBuffer()->isRecording()) {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterDisplayList, ("Blink.Canvas.GetImageData.DisplayList", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterDisplayList);
+    } else {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCPU, ("Blink.Canvas.GetImageData.CPU", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterCPU);
+    }
+
     if (!originClean())
         exceptionState.throwSecurityError("The canvas has been tainted by cross-origin data.");
     else if (!sw || !sh)
         exceptionState.throwDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));
 
     if (exceptionState.hadException())
         return nullptr;
 
     if (sw < 0) {
         sx += sw;
@@ skipping 33 matching lines @@
         DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength()));
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data, double dx, double dy, ExceptionState& exceptionState)
 {
     putImageData(data, dx, dy, 0, 0, data->width(), data->height(), exceptionState);
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data, double dx, double dy, double dirtyX, double dirtyY, double dirtyWidth, double dirtyHeight, ExceptionState& exceptionState)
 {
+    Optional<ScopedUsHistogramTimer> timer;
+    if (imageBuffer() && imageBuffer()->isAccelerated()) {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterGPU, ("Blink.Canvas.PutImageData.GPU", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterGPU);
+    } else if (imageBuffer() && imageBuffer()->isRecording()) {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterDisplayList, ("Blink.Canvas.PutImageData.DisplayList", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterDisplayList);
+    } else {
+        DEFINE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCPU, ("Blink.Canvas.PutImageData.CPU", 0, 10000000, 50));
+        timer.emplace(scopedUsCounterCPU);
+    }
+
     if (data->data()->bufferBase()->isNeutered()) {
         exceptionState.throwDOMException(InvalidStateError, "The source data has been neutered.");
         return;
     }
     ImageBuffer* buffer = imageBuffer();
     if (!buffer)
         return;
 
     if (dirtyWidth < 0) {
         dirtyX += dirtyWidth;
@@ skipping 130 matching lines @@
 
     imageBuffer()->willOverwriteCanvas();
 }
 
 DEFINE_TRACE(BaseRenderingContext2D)
 {
     visitor->trace(m_stateStack);
 }
 
 } // namespace blink