Changeset 237344 in webkit


Ignore:
Timestamp:
Oct 22, 2018 5:46:14 PM (5 years ago)
Author:
commit-queue@webkit.org
Message:

CSS Paint API should give a 2d rendering context
https://bugs.webkit.org/show_bug.cgi?id=190762

Patch by Justin Michaud <Justin Michaud> on 2018-10-22
Reviewed by Dean Jackson.

Source/WebCore:

Add a new type of canvas and 2d rendering context to support the CSS Painting API.
Make many of the methods from HTMLCanvasElement virtual functions on CanvasBase, and
remove many of the downcasts in CanvasRenderingContext2DBase as a result.

  • CMakeLists.txt:
  • DerivedSources.make:
  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • bindings/js/JSPaintRenderingContext2DCustom.cpp: Copied from Source/WebCore/css/CSSPaintCallback.h.

(WebCore::root):
(WebCore::JSPaintRenderingContext2DOwner::isReachableFromOpaqueRoots):
(WebCore::JSPaintRenderingContext2D::visitAdditionalChildren):

  • bindings/js/WebCoreBuiltinNames.h:
  • css/CSSPaintCallback.h:
  • css/CSSPaintCallback.idl:
  • html/CanvasBase.cpp:

(WebCore::CanvasBase::~CanvasBase):

  • html/CanvasBase.h:

(WebCore::CanvasBase::isCustomPaintCanvas const):

  • html/CustomPaintCanvas.cpp: Added.

(WebCore::CustomPaintCanvas::create):
(WebCore::CustomPaintCanvas::CustomPaintCanvas):
(WebCore::CustomPaintCanvas::~CustomPaintCanvas):
(WebCore::CustomPaintCanvas::width const):
(WebCore::CustomPaintCanvas::setWidth):
(WebCore::CustomPaintCanvas::height const):
(WebCore::CustomPaintCanvas::setHeight):
(WebCore::CustomPaintCanvas::size const):
(WebCore::CustomPaintCanvas::setSize):
(WebCore::CustomPaintCanvas::getContext):
(WebCore::CustomPaintCanvas::copiedImage const):
(WebCore::CustomPaintCanvas::drawingContext const):
(WebCore::CustomPaintCanvas::existingDrawingContext const):
(WebCore::CustomPaintCanvas::makeRenderingResultsAvailable):

  • html/CustomPaintCanvas.h: Copied from Source/WebCore/html/OffscreenCanvas.h.
  • html/HTMLCanvasElement.h:
  • html/OffscreenCanvas.h:
  • html/canvas/CanvasRenderingContext.cpp:

(WebCore::CanvasRenderingContext::wouldTaintOrigin):

  • html/canvas/CanvasRenderingContext.h:

(WebCore::CanvasRenderingContext::isPaint const):

  • html/canvas/CanvasRenderingContext2DBase.cpp:

(WebCore::DisplayListDrawingContext::DisplayListDrawingContext):
(WebCore::CanvasRenderingContext2DBase::unwindStateStack):
(WebCore::CanvasRenderingContext2DBase::isAccelerated const):
(WebCore::CanvasRenderingContext2DBase::setStrokeStyle):
(WebCore::CanvasRenderingContext2DBase::setFillStyle):
(WebCore::CanvasRenderingContext2DBase::resetTransform):
(WebCore::CanvasRenderingContext2DBase::clearCanvas):
(WebCore::CanvasRenderingContext2DBase::transformAreaToDevice const):
(WebCore::CanvasRenderingContext2DBase::rectContainsCanvas const):
(WebCore::CanvasRenderingContext2DBase::calculateCompositingBufferRect):
(WebCore::CanvasRenderingContext2DBase::compositeBuffer):
(WebCore::CanvasRenderingContext2DBase::createPattern):
(WebCore::CanvasRenderingContext2DBase::didDrawEntireCanvas):
(WebCore::CanvasRenderingContext2DBase::didDraw):
(WebCore::CanvasRenderingContext2DBase::paintRenderingResultsToCanvas):
(WebCore::CanvasRenderingContext2DBase::drawingContext const):

  • html/canvas/CanvasRenderingContext2DBase.h:
  • html/canvas/PaintRenderingContext2D.cpp: Copied from Source/WebCore/css/CSSPaintCallback.h.

(WebCore::PaintRenderingContext2D::create):
(WebCore::PaintRenderingContext2D::PaintRenderingContext2D):

  • html/canvas/PaintRenderingContext2D.h: Copied from Source/WebCore/css/CSSPaintCallback.h.
  • html/canvas/PaintRenderingContext2D.idl: Copied from Source/WebCore/css/CSSPaintCallback.idl.
  • html/canvas/WebMetalRenderPassAttachmentDescriptor.h:
  • platform/graphics/CustomPaintImage.cpp:

(WebCore::CustomPaintImage::doCustomPaint):

LayoutTests:

  • fast/css-custom-paint/basic.html:
Location:
trunk
Files:
1 added
21 edited
5 copied

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r237342 r237344  
     12018-10-22  Justin Michaud  <justin_michaud@apple.com>
     2
     3        CSS Paint API should give a 2d rendering context
     4        https://bugs.webkit.org/show_bug.cgi?id=190762
     5
     6        Reviewed by Dean Jackson.
     7
     8        * fast/css-custom-paint/basic.html:
     9
    1102018-10-22  Ryan Haddad  <ryanhaddad@apple.com>
    211
  • trunk/LayoutTests/fast/css-custom-paint/basic.html

    r237276 r237344  
    99  #paint {
    1010    background-image: paint(my-paint);
    11     width: 50px;
    12     height: 50px;
     11    width: 150px;
     12    height: 150px;
    1313  }
    1414</style>
     
    7171  CSS.paintWorkletGlobalScope.registerPaint('my-paint', class {
    7272    paint(ctx, geom, properties) {
    73       ctx.clearColor(0,1.0,0,1.0);
    74       ctx.clear(ctx.COLOR_BUFFER_BIT);
     73      for (var i = 0; i < 6; i++){
     74        for (var j = 0; j < 6; j++){
     75          ctx.fillStyle = 'rgb(' + Math.floor(255 - 42.5 * i) + ',' +
     76                           Math.floor(255 - 42.5 * j) + ',0)';
     77          ctx.fillRect(j * 25, i * 25, 25, 25);
     78        }
     79      }
    7580      paint_called_test.done();
    7681    }
  • trunk/Source/WebCore/CMakeLists.txt

    r237306 r237344  
    807807    html/canvas/ImageSmoothingQuality.idl
    808808    html/canvas/OffscreenCanvasRenderingContext2D.idl
     809    html/canvas/PaintRenderingContext2D.idl
    809810    html/canvas/Path2D.idl
    810811    html/canvas/WebMetalBuffer.idl
  • trunk/Source/WebCore/ChangeLog

    r237340 r237344  
     12018-10-22  Justin Michaud  <justin_michaud@apple.com>
     2
     3        CSS Paint API should give a 2d rendering context
     4        https://bugs.webkit.org/show_bug.cgi?id=190762
     5
     6        Reviewed by Dean Jackson.
     7
     8        Add a new type of canvas and 2d rendering context to support the CSS Painting API.
     9        Make many of the methods from HTMLCanvasElement virtual functions on CanvasBase, and
     10        remove many of the downcasts in CanvasRenderingContext2DBase as a result.
     11
     12        * CMakeLists.txt:
     13        * DerivedSources.make:
     14        * Sources.txt:
     15        * WebCore.xcodeproj/project.pbxproj:
     16        * bindings/js/JSPaintRenderingContext2DCustom.cpp: Copied from Source/WebCore/css/CSSPaintCallback.h.
     17        (WebCore::root):
     18        (WebCore::JSPaintRenderingContext2DOwner::isReachableFromOpaqueRoots):
     19        (WebCore::JSPaintRenderingContext2D::visitAdditionalChildren):
     20        * bindings/js/WebCoreBuiltinNames.h:
     21        * css/CSSPaintCallback.h:
     22        * css/CSSPaintCallback.idl:
     23        * html/CanvasBase.cpp:
     24        (WebCore::CanvasBase::~CanvasBase):
     25        * html/CanvasBase.h:
     26        (WebCore::CanvasBase::isCustomPaintCanvas const):
     27        * html/CustomPaintCanvas.cpp: Added.
     28        (WebCore::CustomPaintCanvas::create):
     29        (WebCore::CustomPaintCanvas::CustomPaintCanvas):
     30        (WebCore::CustomPaintCanvas::~CustomPaintCanvas):
     31        (WebCore::CustomPaintCanvas::width const):
     32        (WebCore::CustomPaintCanvas::setWidth):
     33        (WebCore::CustomPaintCanvas::height const):
     34        (WebCore::CustomPaintCanvas::setHeight):
     35        (WebCore::CustomPaintCanvas::size const):
     36        (WebCore::CustomPaintCanvas::setSize):
     37        (WebCore::CustomPaintCanvas::getContext):
     38        (WebCore::CustomPaintCanvas::copiedImage const):
     39        (WebCore::CustomPaintCanvas::drawingContext const):
     40        (WebCore::CustomPaintCanvas::existingDrawingContext const):
     41        (WebCore::CustomPaintCanvas::makeRenderingResultsAvailable):
     42        * html/CustomPaintCanvas.h: Copied from Source/WebCore/html/OffscreenCanvas.h.
     43        * html/HTMLCanvasElement.h:
     44        * html/OffscreenCanvas.h:
     45        * html/canvas/CanvasRenderingContext.cpp:
     46        (WebCore::CanvasRenderingContext::wouldTaintOrigin):
     47        * html/canvas/CanvasRenderingContext.h:
     48        (WebCore::CanvasRenderingContext::isPaint const):
     49        * html/canvas/CanvasRenderingContext2DBase.cpp:
     50        (WebCore::DisplayListDrawingContext::DisplayListDrawingContext):
     51        (WebCore::CanvasRenderingContext2DBase::unwindStateStack):
     52        (WebCore::CanvasRenderingContext2DBase::isAccelerated const):
     53        (WebCore::CanvasRenderingContext2DBase::setStrokeStyle):
     54        (WebCore::CanvasRenderingContext2DBase::setFillStyle):
     55        (WebCore::CanvasRenderingContext2DBase::resetTransform):
     56        (WebCore::CanvasRenderingContext2DBase::clearCanvas):
     57        (WebCore::CanvasRenderingContext2DBase::transformAreaToDevice const):
     58        (WebCore::CanvasRenderingContext2DBase::rectContainsCanvas const):
     59        (WebCore::CanvasRenderingContext2DBase::calculateCompositingBufferRect):
     60        (WebCore::CanvasRenderingContext2DBase::compositeBuffer):
     61        (WebCore::CanvasRenderingContext2DBase::createPattern):
     62        (WebCore::CanvasRenderingContext2DBase::didDrawEntireCanvas):
     63        (WebCore::CanvasRenderingContext2DBase::didDraw):
     64        (WebCore::CanvasRenderingContext2DBase::paintRenderingResultsToCanvas):
     65        (WebCore::CanvasRenderingContext2DBase::drawingContext const):
     66        * html/canvas/CanvasRenderingContext2DBase.h:
     67        * html/canvas/PaintRenderingContext2D.cpp: Copied from Source/WebCore/css/CSSPaintCallback.h.
     68        (WebCore::PaintRenderingContext2D::create):
     69        (WebCore::PaintRenderingContext2D::PaintRenderingContext2D):
     70        * html/canvas/PaintRenderingContext2D.h: Copied from Source/WebCore/css/CSSPaintCallback.h.
     71        * html/canvas/PaintRenderingContext2D.idl: Copied from Source/WebCore/css/CSSPaintCallback.idl.
     72        * html/canvas/WebMetalRenderPassAttachmentDescriptor.h:
     73        * platform/graphics/CustomPaintImage.cpp:
     74        (WebCore::CustomPaintImage::doCustomPaint):
     75
    1762018-10-22  Keith Rollin  <krollin@apple.com>
    277
  • trunk/Source/WebCore/DerivedSources.make

    r237306 r237344  
    730730    $(WebCore)/html/canvas/OESVertexArrayObject.idl \
    731731    $(WebCore)/html/canvas/OffscreenCanvasRenderingContext2D.idl \
     732        $(WebCore)/html/canvas/PaintRenderingContext2D.idl \
    732733    $(WebCore)/html/canvas/Path2D.idl \
    733734    $(WebCore)/html/canvas/WebGL2RenderingContext.idl \
  • trunk/Source/WebCore/Sources.txt

    r237306 r237344  
    446446bindings/js/JSNodeListCustom.cpp
    447447bindings/js/JSOffscreenCanvasRenderingContext2DCustom.cpp
     448bindings/js/JSPaintRenderingContext2DCustom.cpp
    448449bindings/js/JSPaymentMethodChangeEventCustom.cpp
    449450bindings/js/JSPaymentResponseCustom.cpp
     
    971972html/CheckboxInputType.cpp
    972973html/ColorInputType.cpp
     974html/CustomPaintCanvas.cpp
    973975html/DOMFormData.cpp
    974976html/DOMTokenList.cpp
     
    11291131html/canvas/ImageBitmapRenderingContext.cpp
    11301132html/canvas/OffscreenCanvasRenderingContext2D.cpp
     1133html/canvas/PaintRenderingContext2D.cpp
    11311134html/canvas/Path2D.cpp
    11321135html/canvas/PlaceholderRenderingContext.cpp
     
    28462849JSOffscreenCanvas.cpp
    28472850JSOffscreenCanvasRenderingContext2D.cpp
     2851JSPaintRenderingContext2D.cpp
    28482852JSOscillatorNode.cpp
    28492853JSOverconstrainedError.cpp
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r237340 r237344  
    13461346                4AD01009127E642A0015035F /* HTMLOutputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 4AD01006127E642A0015035F /* HTMLOutputElement.h */; };
    13471347                4AD0173D127E82860015035F /* JSHTMLOutputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 4AD0173B127E82860015035F /* JSHTMLOutputElement.h */; };
     1348                4B1E13E721790D660042CF98 /* CustomPaintCanvas.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B1E13E621790D660042CF98 /* CustomPaintCanvas.h */; };
     1349                4B1E13EB217937B30042CF98 /* PaintRenderingContext2D.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B1E13EA217937B30042CF98 /* PaintRenderingContext2D.h */; };
    13481350                4B2708C70AF19EE40065127F /* Pasteboard.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B2708C50AF19EE40065127F /* Pasteboard.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13491351                4B3043CD0AE0373B00A82647 /* Editor.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B3043CB0AE0373B00A82647 /* Editor.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    78847886                4AD0173B127E82860015035F /* JSHTMLOutputElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSHTMLOutputElement.h; sourceTree = "<group>"; };
    78857887                4B1706642162B42F00E578BB /* CSSRegisteredCustomProperty.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CSSRegisteredCustomProperty.cpp; sourceTree = "<group>"; };
     7888                4B1E13E621790D660042CF98 /* CustomPaintCanvas.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CustomPaintCanvas.h; sourceTree = "<group>"; };
     7889                4B1E13E921790D7E0042CF98 /* CustomPaintCanvas.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CustomPaintCanvas.cpp; sourceTree = "<group>"; };
     7890                4B1E13EA217937B30042CF98 /* PaintRenderingContext2D.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PaintRenderingContext2D.h; sourceTree = "<group>"; };
     7891                4B1E13EC217938380042CF98 /* PaintRenderingContext2D.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = PaintRenderingContext2D.cpp; sourceTree = "<group>"; };
     7892                4B1E13ED21793DC10042CF98 /* PaintRenderingContext2D.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = PaintRenderingContext2D.idl; sourceTree = "<group>"; };
     7893                4B1E13EE217941320042CF98 /* JSPaintRenderingContext2DCustom.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JSPaintRenderingContext2DCustom.cpp; sourceTree = "<group>"; };
    78867894                4B2708C50AF19EE40065127F /* Pasteboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Pasteboard.h; sourceTree = "<group>"; };
    78877895                4B2709810AF2E5E00065127F /* PasteboardMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = PasteboardMac.mm; sourceTree = "<group>"; };
     
    1763717645                                3140C51E1FDF151A00D2A873 /* OffscreenCanvasRenderingContext2D.h */,
    1763817646                                3140C51B1FDF13D200D2A873 /* OffscreenCanvasRenderingContext2D.idl */,
     17647                                4B1E13EC217938380042CF98 /* PaintRenderingContext2D.cpp */,
     17648                                4B1E13EA217937B30042CF98 /* PaintRenderingContext2D.h */,
     17649                                4B1E13ED21793DC10042CF98 /* PaintRenderingContext2D.idl */,
    1763917650                                7C193BA71F5E0EAF0088F3E6 /* Path2D.cpp */,
    1764017651                                7C193BAB1F5E0EB10088F3E6 /* Path2D.h */,
     
    2021220223                                AD20B18C18E9D216005A8083 /* JSNodeListCustom.h */,
    2021320224                                3140C52B1FE06B4900D2A873 /* JSOffscreenCanvasRenderingContext2DCustom.cpp */,
     20225                                4B1E13EE217941320042CF98 /* JSPaintRenderingContext2DCustom.cpp */,
    2021420226                                CB38FD551CD21D5B00592A3F /* JSPerformanceEntryCustom.cpp */,
    2021520227                                833CF70F20DB3F5F00141BCC /* JSPerformanceObserverCustom.cpp */,
     
    2077820790                                BC29935C17A1DD5800BCE880 /* ColorInputType.cpp */,
    2077920791                                F55B3D801251F12D003EF269 /* ColorInputType.h */,
     20792                                4B1E13E921790D7E0042CF98 /* CustomPaintCanvas.cpp */,
     20793                                4B1E13E621790D660042CF98 /* CustomPaintCanvas.h */,
    2078020794                                E517670220B88C1400D41167 /* DataListSuggestionInformation.h */,
    2078120795                                F55B3D811251F12D003EF269 /* DateInputType.cpp */,
     
    2810428118                                9BD4E91B1C462CFC005065BC /* CustomElementRegistry.h in Headers */,
    2810528119                                62CD325A1157E57C0063B0A7 /* CustomEvent.h in Headers */,
     28120                                4B1E13E721790D660042CF98 /* CustomPaintCanvas.h in Headers */,
    2810628121                                4B7AE4932177B56F00C59959 /* CustomPaintImage.h in Headers */,
    2810728122                                A8CB413E0E8633FD0032C4F0 /* DashArray.h in Headers */,
     
    3012930144                                0885067F11DA045B00182B98 /* PaintInfo.h in Headers */,
    3013030145                                0885068011DA045B00182B98 /* PaintPhase.h in Headers */,
     30146                                4B1E13EB217937B30042CF98 /* PaintRenderingContext2D.h in Headers */,
    3013130147                                A80E6CFB0A1989CA007FB8C5 /* Pair.h in Headers */,
    3013230148                                FD3160A312B026F700C1A359 /* Panner.h in Headers */,
  • trunk/Source/WebCore/bindings/js/JSPaintRenderingContext2DCustom.cpp

    r237342 r237344  
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "JSPaintRenderingContext2D.h"
    2728
    2829#if ENABLE(CSS_PAINTING_API)
    2930
    30 #include "ActiveDOMCallback.h"
    31 #include "CallbackResult.h"
    32 #include <wtf/RefCounted.h>
     31namespace WebCore {
     32using namespace JSC;
    3333
    34 namespace WebCore {
    35 class WebGLRenderingContext;
     34inline void* root(CustomPaintCanvas* canvas)
     35{
     36    return canvas;
     37}
    3638
    37 class CSSPaintCallback : public RefCounted<CSSPaintCallback>, public ActiveDOMCallback {
    38 public:
    39     using ActiveDOMCallback::ActiveDOMCallback;
     39bool JSPaintRenderingContext2DOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor, const char** reason)
     40{
     41    if (UNLIKELY(reason))
     42        *reason = "Canvas is opaque root";
    4043
    41     virtual CallbackResult<void> handleEvent(WebGLRenderingContext&) = 0;
     44    JSPaintRenderingContext2D* jsPaintRenderingContext = jsCast<JSPaintRenderingContext2D*>(handle.slot()->asCell());
     45    void* root = WebCore::root(&jsPaintRenderingContext->wrapped().canvas());
     46    return visitor.containsOpaqueRoot(root);
     47}
    4248
    43     virtual ~CSSPaintCallback()
    44     {
    45     }
    46 };
     49void JSPaintRenderingContext2D::visitAdditionalChildren(SlotVisitor& visitor)
     50{
     51    visitor.addOpaqueRoot(root(&wrapped().canvas()));
     52}
    4753
    4854} // namespace WebCore
    4955#endif
     56
  • trunk/Source/WebCore/bindings/js/WebCoreBuiltinNames.h

    r237306 r237344  
    114114    macro(OffscreenCanvas) \
    115115    macro(OffscreenCanvasRenderingContext2D) \
     116    macro(PaintRenderingContext2D) \
    116117    macro(PaymentAddress) \
    117118    macro(PaymentMethodChangeEvent) \
  • trunk/Source/WebCore/css/CSSPaintCallback.h

    r237276 r237344  
    3333
    3434namespace WebCore {
    35 class WebGLRenderingContext;
     35class PaintRenderingContext2D;
    3636
    3737class CSSPaintCallback : public RefCounted<CSSPaintCallback>, public ActiveDOMCallback {
     
    3939    using ActiveDOMCallback::ActiveDOMCallback;
    4040
    41     virtual CallbackResult<void> handleEvent(WebGLRenderingContext&) = 0;
     41    virtual CallbackResult<void> handleEvent(PaintRenderingContext2D&) = 0;
    4242
    4343    virtual ~CSSPaintCallback()
  • trunk/Source/WebCore/css/CSSPaintCallback.idl

    r237276 r237344  
    2727    EnabledAtRuntime=CSSPaintingAPI,
    2828    Conditional=CSS_PAINTING_API,
    29 ] callback CSSPaintCallback = void (WebGLRenderingContext context);
     29] callback CSSPaintCallback = void (PaintRenderingContext2D context);
  • trunk/Source/WebCore/html/CanvasBase.cpp

    r226439 r237344  
    4242CanvasBase::~CanvasBase()
    4343{
     44    ASSERT(!m_context); // Should have been set to null by base class.
    4445    notifyObserversCanvasDestroyed();
    4546}
  • trunk/Source/WebCore/html/CanvasBase.h

    r226439 r237344  
    3131namespace WebCore {
    3232
     33class AffineTransform;
    3334class CanvasBase;
    3435class CanvasRenderingContext;
    3536class Element;
     37class GraphicsContext;
     38class Image;
     39class ImageBuffer;
    3640class IntSize;
    3741class FloatRect;
     
    5963    virtual bool isHTMLCanvasElement() const { return false; }
    6064    virtual bool isOffscreenCanvas() const { return false; }
     65    virtual bool isCustomPaintCanvas() const { return false; }
    6166
    6267    virtual unsigned width() const = 0;
     
    8287    HashSet<Element*> cssCanvasClients() const;
    8388
     89    virtual GraphicsContext* drawingContext() const = 0;
     90    virtual GraphicsContext* existingDrawingContext() const = 0;
     91
     92    virtual void makeRenderingResultsAvailable() = 0;
     93    virtual void didDraw(const FloatRect&) = 0;
     94
     95    virtual AffineTransform baseTransform() const = 0;
     96    virtual Image* copiedImage() const = 0;
     97
    8498protected:
    8599    CanvasBase(ScriptExecutionContext*);
  • trunk/Source/WebCore/html/CustomPaintCanvas.h

    r237342 r237344  
    11/*
    2  * Copyright (C) 2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2626#pragma once
    2727
     28#if ENABLE(CSS_PAINTING_API)
     29
     30#include "AffineTransform.h"
    2831#include "CanvasBase.h"
    2932#include "EventTarget.h"
    3033#include "ExceptionOr.h"
     34#include "ImageBuffer.h"
    3135#include "IntSize.h"
    3236#include "JSDOMPromiseDeferred.h"
     
    3943
    4044class ImageBitmap;
    41 class WebGLRenderingContext;
     45class PaintRenderingContext2D;
    4246
    43 #if ENABLE(WEBGL)
    44 using OffscreenRenderingContext = RefPtr<WebGLRenderingContext>;
    45 #endif
    46 
    47 class OffscreenCanvas final : public RefCounted<OffscreenCanvas>, public CanvasBase, public EventTargetWithInlineData {
     47class CustomPaintCanvas final : public RefCounted<CustomPaintCanvas>, public CanvasBase {
    4848    WTF_MAKE_FAST_ALLOCATED;
    4949public:
    5050
    51     struct ImageEncodeOptions {
    52         String type = "image/png";
    53         double quality = 1.0;
    54     };
    55 
    56     enum class RenderingContextType {
    57         _2d,
    58         Webgl
    59     };
    60 
    61     static Ref<OffscreenCanvas> create(ScriptExecutionContext&, unsigned width, unsigned height);
    62     virtual ~OffscreenCanvas();
     51    static Ref<CustomPaintCanvas> create(ScriptExecutionContext&, unsigned width, unsigned height);
     52    virtual ~CustomPaintCanvas();
     53    bool isCustomPaintCanvas() const final { return true; }
    6354
    6455    unsigned width() const final;
     
    7061    void setSize(const IntSize&) final;
    7162
    72 #if ENABLE(WEBGL)
    73     ExceptionOr<OffscreenRenderingContext> getContext(JSC::ExecState&, RenderingContextType, Vector<JSC::Strong<JSC::Unknown>>&& arguments);
    74 #endif
    75     RefPtr<ImageBitmap> transferToImageBitmap();
    76     // void convertToBlob(ImageEncodeOptions options);
     63    ExceptionOr<RefPtr<PaintRenderingContext2D>> getContext();
     64
     65    GraphicsContext* drawingContext() const final;
     66    GraphicsContext* existingDrawingContext() const final;
     67
     68    void makeRenderingResultsAvailable() final;
     69    void didDraw(const FloatRect&) final { }
     70
     71    AffineTransform baseTransform() const final { ASSERT(m_destinationGraphicsContext && m_copiedBuffer); return m_copiedBuffer->baseTransform(); }
     72    Image* copiedImage() const final;
    7773
    7874    using RefCounted::ref;
     
    8076
    8177private:
    82 
    83     OffscreenCanvas(ScriptExecutionContext&, unsigned width, unsigned height);
    84 
    85     bool isOffscreenCanvas() const final { return true; }
    86 
    87     ScriptExecutionContext* scriptExecutionContext() const final { return CanvasBase::scriptExecutionContext(); }
    88 
    89     EventTargetInterface eventTargetInterface() const final { return OffscreenCanvasEventTargetInterfaceType; }
    90     void refEventTarget() final { ref(); }
    91     void derefEventTarget() final { deref(); }
     78    CustomPaintCanvas(ScriptExecutionContext&, unsigned width, unsigned height);
    9279
    9380    void refCanvasBase() final { ref(); }
    9481    void derefCanvasBase() final { deref(); }
    9582
    96     IntSize m_size;
     83    mutable GraphicsContext* m_destinationGraphicsContext = nullptr;
     84    mutable IntSize m_size;
     85    mutable std::unique_ptr<ImageBuffer> m_copiedBuffer;
     86    mutable RefPtr<Image> m_copiedImage;
    9787};
    9888
    9989}
    100 
    101 SPECIALIZE_TYPE_TRAITS_CANVAS(WebCore::OffscreenCanvas, isOffscreenCanvas())
     90SPECIALIZE_TYPE_TRAITS_CANVAS(WebCore::CustomPaintCanvas, isCustomPaintCanvas())
     91#endif
  • trunk/Source/WebCore/html/HTMLCanvasElement.h

    r237306 r237344  
    119119
    120120    // Used for rendering
    121     void didDraw(const FloatRect&);
     121    void didDraw(const FloatRect&) final;
    122122
    123123    void paint(GraphicsContext&, const LayoutRect&);
    124124
    125     GraphicsContext* drawingContext() const;
    126     GraphicsContext* existingDrawingContext() const;
     125    GraphicsContext* drawingContext() const final;
     126    GraphicsContext* existingDrawingContext() const final;
    127127
    128128#if ENABLE(MEDIA_STREAM)
     
    132132
    133133    ImageBuffer* buffer() const;
    134     Image* copiedImage() const;
     134    Image* copiedImage() const final;
    135135    void clearCopiedImage();
    136136    RefPtr<ImageData> getImageData();
     
    140140    SecurityOrigin* securityOrigin() const final;
    141141
    142     AffineTransform baseTransform() const;
    143 
    144     void makeRenderingResultsAvailable();
     142    AffineTransform baseTransform() const final;
     143
     144    void makeRenderingResultsAvailable() final;
    145145    bool hasCreatedImageBuffer() const { return m_hasCreatedImageBuffer; }
    146146
  • trunk/Source/WebCore/html/OffscreenCanvas.cpp

    r225713 r237344  
    2727#include "OffscreenCanvas.h"
    2828
     29#include "CanvasRenderingContext.h"
    2930#include "ImageBitmap.h"
    3031#include "WebGLRenderingContext.h"
     
    4344}
    4445
    45 OffscreenCanvas::~OffscreenCanvas() = default;
     46OffscreenCanvas::~OffscreenCanvas()
     47{
     48    m_context = nullptr;
     49}
    4650
    4751unsigned OffscreenCanvas::width() const
  • trunk/Source/WebCore/html/OffscreenCanvas.h

    r226439 r237344  
    2626#pragma once
    2727
     28#include "AffineTransform.h"
    2829#include "CanvasBase.h"
    2930#include "EventTarget.h"
     
    7677    // void convertToBlob(ImageEncodeOptions options);
    7778
     79    GraphicsContext* drawingContext() const final { return nullptr; }
     80    GraphicsContext* existingDrawingContext() const final { return nullptr; }
     81
     82    void makeRenderingResultsAvailable() final { }
     83    void didDraw(const FloatRect&) final { }
     84
     85    AffineTransform baseTransform() const final { return { }; }
     86    Image* copiedImage() const final { return nullptr; }
     87
    7888    using RefCounted::ref;
    7989    using RefCounted::deref;
  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext.cpp

    r234055 r237344  
    6262}
    6363
    64 bool CanvasRenderingContext::wouldTaintOrigin(const HTMLCanvasElement* sourceCanvas)
     64bool CanvasRenderingContext::wouldTaintOrigin(const CanvasBase* sourceCanvas)
    6565{
    6666    if (m_canvas.originClean() && sourceCanvas && !sourceCanvas->originClean())
  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext.h

    r237306 r237344  
    6767    virtual bool isPlaceholder() const { return false; }
    6868    virtual bool isOffscreen2d() const { return false; }
     69    virtual bool isPaint() const { return false; }
    6970
    7071    virtual void paintRenderingResultsToCanvas() {}
     
    7778    explicit CanvasRenderingContext(CanvasBase&);
    7879    bool wouldTaintOrigin(const CanvasPattern*);
    79     bool wouldTaintOrigin(const HTMLCanvasElement*);
     80    bool wouldTaintOrigin(const CanvasBase*);
    8081    bool wouldTaintOrigin(const HTMLImageElement*);
    8182    bool wouldTaintOrigin(const HTMLVideoElement*);
  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp

    r237198 r237344  
    8989   
    9090    DisplayListDrawingContext(GraphicsContext& context, const FloatRect& clip)
     91        : DisplayListDrawingContext(context.state(), clip)
     92    {
     93    }
     94
     95    DisplayListDrawingContext(const GraphicsContextState& state, const FloatRect& clip)
    9196        : context([&](GraphicsContext& displayListContext) {
    92             return std::make_unique<DisplayList::Recorder>(displayListContext, displayList, context.state(), clip, AffineTransform());
     97            return std::make_unique<DisplayList::Recorder>(displayListContext, displayList, state, clip, AffineTransform());
    9398        })
    9499    {
     
    147152    // GraphicsContext dtor.
    148153    if (size_t stackSize = m_stateStack.size()) {
    149         auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    150         if (GraphicsContext* context = canvas.existingDrawingContext()) {
     154        if (auto* context = canvasBase().existingDrawingContext()) {
    151155            while (--stackSize)
    152156                context->restore();
     
    168172{
    169173#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
    170     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    171     if (!canvas.hasCreatedImageBuffer())
    172         return false;
    173     auto* context = drawingContext();
     174    auto* context = canvasBase().existingDrawingContext();
    174175    return context && context->isAcceleratedContext();
    175176#else
     
    402403        return;
    403404
    404     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    405 
    406     if (style.isCurrentColor()) {
     405    if (style.isCurrentColor() && is<HTMLCanvasElement>(canvasBase())) {
     406        auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
     407
    407408        if (style.hasOverrideAlpha()) {
    408409            // FIXME: Should not use RGBA32 here.
     
    431432        return;
    432433
    433     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    434 
    435     if (style.isCurrentColor()) {
     434    if (style.isCurrentColor() && is<HTMLCanvasElement>(canvasBase())) {
     435        auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
     436
    436437        if (style.hasOverrideAlpha()) {
    437438            // FIXME: Should not use RGBA32 here.
     
    929930    realizeSaves();
    930931
    931     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    932     c->setCTM(canvas.baseTransform());
     932    c->setCTM(canvasBase().baseTransform());
    933933    modifiableState().transform = AffineTransform();
    934934
     
    17281728
    17291729    c->save();
    1730     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    1731     c->setCTM(canvas.baseTransform());
    1732     c->clearRect(FloatRect(0, 0, canvas.width(), canvas.height()));
     1730    c->setCTM(canvasBase().baseTransform());
     1731    c->clearRect(FloatRect(0, 0, canvasBase().width(), canvasBase().height()));
    17331732    c->restore();
    17341733}
     
    17371736{
    17381737    Path transformed(path);
    1739     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    17401738    transformed.transform(state().transform);
    1741     transformed.transform(canvas.baseTransform());
     1739    transformed.transform(canvasBase().baseTransform());
    17421740    return transformed;
    17431741}
     
    17531751{
    17541752    FloatQuad quad(rect);
    1755     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    1756     FloatQuad canvasQuad(FloatRect(0, 0, canvas.width(), canvas.height()));
     1753    FloatQuad canvasQuad(FloatRect(0, 0, canvasBase().width(), canvasBase().height()));
    17571754    return state().transform.mapQuad(quad).containsQuad(canvasQuad);
    17581755}
     
    17601757template<class T> IntRect CanvasRenderingContext2DBase::calculateCompositingBufferRect(const T& area, IntSize* croppedOffset)
    17611758{
    1762     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    1763 
    1764     IntRect canvasRect(0, 0, canvas.width(), canvas.height());
    1765     canvasRect = canvas.baseTransform().mapRect(canvasRect);
     1759    IntRect canvasRect(0, 0, canvasBase().width(), canvasBase().height());
     1760    canvasRect = canvasBase().baseTransform().mapRect(canvasRect);
    17661761    Path path = transformAreaToDevice(area);
    17671762    IntRect bufferRect = enclosingIntRect(path.fastBoundingRect());
     
    17801775void CanvasRenderingContext2DBase::compositeBuffer(ImageBuffer& buffer, const IntRect& bufferRect, CompositeOperator op)
    17811776{
    1782     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    1783     IntRect canvasRect(0, 0, canvas.width(), canvas.height());
    1784     canvasRect = canvas.baseTransform().mapRect(canvasRect);
     1777    IntRect canvasRect(0, 0, canvasBase().width(), canvasBase().height());
     1778    canvasRect = canvasBase().baseTransform().mapRect(canvasRect);
    17851779
    17861780    auto* c = drawingContext();
     
    19471941}
    19481942
    1949 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2DBase::createPattern(HTMLCanvasElement& canvas, bool repeatX, bool repeatY)
    1950 {
    1951     if (!canvas.width() || !canvas.height() || !canvas.buffer())
     1943ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2DBase::createPattern(CanvasBase& canvas, bool repeatX, bool repeatY)
     1944{
     1945    if (!canvas.width() || !canvas.height())
    19521946        return Exception { InvalidStateError };
    1953 
    1954     return RefPtr<CanvasPattern> { CanvasPattern::create(*canvas.copiedImage(), repeatX, repeatY, canvas.originClean()) };
     1947    auto* copiedImage = canvas.copiedImage();
     1948
     1949    if (!copiedImage)
     1950        return Exception { InvalidStateError };
     1951
     1952    return RefPtr<CanvasPattern> { CanvasPattern::create(*copiedImage, repeatX, repeatY, canvas.originClean()) };
    19551953}
    19561954   
     
    19891987void CanvasRenderingContext2DBase::didDrawEntireCanvas()
    19901988{
    1991     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    1992     didDraw(FloatRect(FloatPoint::zero(), canvas.size()), CanvasDidDrawApplyClip);
     1989    didDraw(FloatRect(FloatPoint::zero(), canvasBase().size()), CanvasDidDrawApplyClip);
    19931990}
    19941991
     
    20352032    }
    20362033
    2037     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    2038     canvas.didDraw(dirtyRect);
     2034    canvasBase().didDraw(dirtyRect);
    20392035}
    20402036
     
    20762072            return;
    20772073
    2078         auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    2079 
    2080         FloatRect clip(FloatPoint::zero(), canvas.size());
    2081         DisplayList::Replayer replayer(*canvas.drawingContext(), m_recordingContext->displayList);
     2074        FloatRect clip(FloatPoint::zero(), canvasBase().size());
     2075        DisplayList::Replayer replayer(*canvasBase().drawingContext(), m_recordingContext->displayList);
    20822076
    20832077        if (UNLIKELY(m_tracksDisplayListReplay)) {
     
    20932087GraphicsContext* CanvasRenderingContext2DBase::drawingContext() const
    20942088{
    2095     auto& canvas = downcast<HTMLCanvasElement>(canvasBase());
    20962089    if (UNLIKELY(m_usesDisplayListDrawing)) {
    20972090        if (!m_recordingContext)
    2098             m_recordingContext = std::make_unique<DisplayListDrawingContext>(*canvas.drawingContext(), FloatRect(FloatPoint::zero(), canvas.size()));
     2091            m_recordingContext = std::make_unique<DisplayListDrawingContext>(GraphicsContextState(), FloatRect(FloatPoint::zero(), canvasBase().size()));
    20992092        return &m_recordingContext->context;
    21002093    }
    21012094
    2102     return canvas.drawingContext();
     2095    return canvasBase().drawingContext();
    21032096}
    21042097
  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.h

    r237198 r237344  
    317317
    318318    ExceptionOr<RefPtr<CanvasPattern>> createPattern(HTMLImageElement&, bool repeatX, bool repeatY);
    319     ExceptionOr<RefPtr<CanvasPattern>> createPattern(HTMLCanvasElement&, bool repeatX, bool repeatY);
     319    ExceptionOr<RefPtr<CanvasPattern>> createPattern(CanvasBase&, bool repeatX, bool repeatY);
    320320#if ENABLE(VIDEO)
    321321    ExceptionOr<RefPtr<CanvasPattern>> createPattern(HTMLVideoElement&, bool repeatX, bool repeatY);
  • trunk/Source/WebCore/html/canvas/PaintRenderingContext2D.cpp

    r237342 r237344  
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "PaintRenderingContext2D.h"
    2728
    2829#if ENABLE(CSS_PAINTING_API)
    2930
    30 #include "ActiveDOMCallback.h"
    31 #include "CallbackResult.h"
    32 #include <wtf/RefCounted.h>
     31namespace WebCore {
    3332
    34 namespace WebCore {
    35 class WebGLRenderingContext;
     33std::unique_ptr<PaintRenderingContext2D> PaintRenderingContext2D::create(CanvasBase& canvas)
     34{
     35    return std::unique_ptr<PaintRenderingContext2D>(new PaintRenderingContext2D(canvas));
     36}
    3637
    37 class CSSPaintCallback : public RefCounted<CSSPaintCallback>, public ActiveDOMCallback {
    38 public:
    39     using ActiveDOMCallback::ActiveDOMCallback;
     38PaintRenderingContext2D::PaintRenderingContext2D(CanvasBase& canvas)
     39    : CanvasRenderingContext2DBase(canvas, false, false)
     40{
     41}
    4042
    41     virtual CallbackResult<void> handleEvent(WebGLRenderingContext&) = 0;
    42 
    43     virtual ~CSSPaintCallback()
    44     {
    45     }
    46 };
     43PaintRenderingContext2D::~PaintRenderingContext2D() = default;
    4744
    4845} // namespace WebCore
  • trunk/Source/WebCore/html/canvas/PaintRenderingContext2D.h

    r237342 r237344  
    2626#pragma once
    2727
     28#include "CanvasRenderingContext2DBase.h"
     29
    2830#if ENABLE(CSS_PAINTING_API)
    2931
    30 #include "ActiveDOMCallback.h"
    31 #include "CallbackResult.h"
    32 #include <wtf/RefCounted.h>
     32#include "CustomPaintCanvas.h"
    3333
    3434namespace WebCore {
    35 class WebGLRenderingContext;
    3635
    37 class CSSPaintCallback : public RefCounted<CSSPaintCallback>, public ActiveDOMCallback {
     36class PaintRenderingContext2D final : public CanvasRenderingContext2DBase {
    3837public:
    39     using ActiveDOMCallback::ActiveDOMCallback;
     38    static std::unique_ptr<PaintRenderingContext2D> create(CanvasBase&);
    4039
    41     virtual CallbackResult<void> handleEvent(WebGLRenderingContext&) = 0;
     40    virtual ~PaintRenderingContext2D();
    4241
    43     virtual ~CSSPaintCallback()
    44     {
    45     }
     42    bool isPaint() const override { return true; }
     43    CustomPaintCanvas& canvas() const { return downcast<CustomPaintCanvas>(canvasBase()); }
     44
     45private:
     46    PaintRenderingContext2D(CanvasBase&);
    4647};
    4748
    4849} // namespace WebCore
     50SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::PaintRenderingContext2D, isPaint())
    4951#endif
  • trunk/Source/WebCore/html/canvas/PaintRenderingContext2D.idl

    r237342 r237344  
    11/*
    2 * Copyright (C) 2018 Apple Inc.  All rights reserved.
     2* Copyright (C) 2018 Apple Inc. All rights reserved.
    33*
    44* Redistribution and use in source and binary forms, with or without
     
    2525
    2626[
     27    CustomIsReachable,
    2728    EnabledAtRuntime=CSSPaintingAPI,
    2829    Conditional=CSS_PAINTING_API,
    29 ] callback CSSPaintCallback = void (WebGLRenderingContext context);
     30    JSGenerateToJSObject,
     31    JSCustomMarkFunction,
     32] interface PaintRenderingContext2D {
     33};
     34
     35PaintRenderingContext2D implements CanvasState;
     36PaintRenderingContext2D implements CanvasTransform;
     37PaintRenderingContext2D implements CanvasCompositing;
     38PaintRenderingContext2D implements CanvasImageSmoothing;
     39PaintRenderingContext2D implements CanvasFillStrokeStyles;
     40PaintRenderingContext2D implements CanvasShadowStyles;
     41PaintRenderingContext2D implements CanvasRect;
     42PaintRenderingContext2D implements CanvasDrawPath;
     43PaintRenderingContext2D implements CanvasDrawImage;
     44PaintRenderingContext2D implements CanvasPathDrawingStyles;
     45PaintRenderingContext2D implements CanvasPath;
  • trunk/Source/WebCore/html/canvas/WebMetalRenderPassAttachmentDescriptor.h

    r236954 r237344  
    2828#if ENABLE(WEBMETAL)
    2929
    30 #include <wtf/Ref.h>
    3130#include <wtf/RefCounted.h>
     31#include <wtf/RefPtr.h>
    3232
    3333namespace WebCore {
  • trunk/Source/WebCore/platform/graphics/CustomPaintImage.cpp

    r237276 r237344  
    2929#if ENABLE(CSS_PAINTING_API)
    3030
     31#include "CustomPaintCanvas.h"
    3132#include "GraphicsContext.h"
    3233#include "ImageBitmap.h"
    3334#include "ImageBuffer.h"
    3435#include "JSCSSPaintCallback.h"
    35 #include "OffscreenCanvas.h"
    36 #include "WebGLRenderingContext.h"
     36#include "PaintRenderingContext2D.h"
    3737
    3838namespace WebCore {
     
    5252    if (!scriptExecutionContext)
    5353        return ImageDrawResult::DidNothing;
    54     auto* execState = scriptExecutionContext->execState();
    55     if (!execState)
    56         return ImageDrawResult::DidNothing;
    5754
    58     auto canvas = OffscreenCanvas::create(*scriptExecutionContext, destSize.width(), destSize.height());
    59     ExceptionOr<OffscreenRenderingContext> contextOrException = canvas->getContext(*execState, OffscreenCanvas::RenderingContextType::Webgl, { });
     55    auto canvas = CustomPaintCanvas::create(*scriptExecutionContext, destSize.width(), destSize.height());
     56    ExceptionOr<RefPtr<PaintRenderingContext2D>> contextOrException = canvas->getContext();
    6057
    6158    if (contextOrException.hasException())
     
    6360    auto context = contextOrException.releaseReturnValue();
    6461
    65     context->clearColor(0, 0, 0, 1.0);
    66     context->clear(GL_COLOR_BUFFER_BIT);
    67 
    6862    auto result = m_paintCallback->handleEvent(*context);
    6963    if (result.type() != CallbackResultType::Success)
    7064        return ImageDrawResult::DidNothing;
    7165
    72     auto bitmap = canvas->transferToImageBitmap();
    73     if (!bitmap)
     66    UNUSED_PARAM(destContext);
     67    auto image = canvas->copiedImage();
     68    if (!image)
    7469        return ImageDrawResult::DidNothing;
    7570
    76     destContext.drawImage(*bitmap->buffer()->copyImage(), FloatPoint());
     71    destContext.drawImage(*image, FloatPoint());
    7772
    7873    return ImageDrawResult::DidDraw;
Note: See TracChangeset for help on using the changeset viewer.