Rename paint data structures

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 "core/css/cssom/CSSURLImageValue.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 "core/offscreencanvas/OffscreenCanvas.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/RuntimeEnabledFeatures.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/paint/PaintCanvas.h"
+#include "platform/graphics/paint/PaintFlags.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 
 namespace blink {
 
 BaseRenderingContext2D::BaseRenderingContext2D()
     : m_clipAntialiasing(NotAntiAliased) {
   m_stateStack.push_back(CanvasRenderingContext2DState::create());
 }
 
 BaseRenderingContext2D::~BaseRenderingContext2D() {}
@@ skipping 12 matching lines @@
     m_stateStack.back()->restore();
     m_stateStack.push_back(CanvasRenderingContext2DState::create(
         state(), CanvasRenderingContext2DState::DontCopyClipList));
     // Set the new state's unrealized count to 0, because it has no outstanding
     // saves.
     // We need to do this explicitly because the copy constructor and operator=
     // used by the Vector operations copy the unrealized count from the previous
     // state (in turn necessary to support correct resizing and unwinding of the
     // stack).
     m_stateStack.back()->resetUnrealizedSaveCount();
-    SkCanvas* canvas = drawingCanvas();
+    PaintCanvas* canvas = drawingCanvas();
     if (canvas)
       canvas->save();
     validateStateStack();
   }
 }
 
 void BaseRenderingContext2D::save() {
   m_stateStack.back()->save();
 }
 
 void BaseRenderingContext2D::restore() {
   validateStateStack();
   if (state().hasUnrealizedSaves()) {
     // We never realized the save, so just record that it was unnecessary.
     m_stateStack.back()->restore();
     return;
   }
   ASSERT(m_stateStack.size() >= 1);
   if (m_stateStack.size() <= 1)
     return;
   m_path.transform(state().transform());
   m_stateStack.pop_back();
   m_stateStack.back()->clearResolvedFilter();
   m_path.transform(state().transform().inverse());
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (c)
     c->restore();
 
   validateStateStack();
 }
 
-void BaseRenderingContext2D::restoreMatrixClipStack(SkCanvas* c) const {
+void BaseRenderingContext2D::restoreMatrixClipStack(PaintCanvas* c) const {
   if (!c)
     return;
   HeapVector<Member<CanvasRenderingContext2DState>>::const_iterator currState;
   DCHECK(m_stateStack.begin() < m_stateStack.end());
   for (currState = m_stateStack.begin(); currState < m_stateStack.end();
        currState++) {
     c->setMatrix(SkMatrix::I());
     if (currState->get()) {
       currState->get()->playbackClips(c);
       c->setMatrix(affineTransformToSkMatrix(currState->get()->transform()));
     }
     c->save();
   }
   c->restore();
   validateStateStack();
 }
 
 void BaseRenderingContext2D::unwindStateStack() {
   if (size_t stackSize = m_stateStack.size()) {
-    if (SkCanvas* skCanvas = existingDrawingCanvas()) {
+    if (PaintCanvas* skCanvas = existingDrawingCanvas()) {
       while (--stackSize)
         skCanvas->restore();
     }
   }
 }
 
 void BaseRenderingContext2D::reset() {
   validateStateStack();
   unwindStateStack();
   m_stateStack.resize(1);
   m_stateStack.front() = CanvasRenderingContext2DState::create();
   m_path.clear();
-  if (SkCanvas* c = existingDrawingCanvas()) {
+  if (PaintCanvas* c = existingDrawingCanvas()) {
     // The canvas should always have an initial/unbalanced save frame, which
     // we use to reset the top level matrix and clip here.
     DCHECK_EQ(c->getSaveCount(), 2);
     c->restore();
     c->save();
     DCHECK(c->getTotalMatrix().isIdentity());
 #if DCHECK_IS_ON()
     SkIRect clipBounds;
     DCHECK(c->getDeviceClipBounds(&clipBounds));
     DCHECK(clipBounds == c->imageInfo().bounds());
@@ skipping 281 matching lines @@
 }
 
 void BaseRenderingContext2D::setCurrentTransform(
     SVGMatrixTearOff* matrixTearOff) {
   const AffineTransform& transform = matrixTearOff->value();
   setTransform(transform.a(), transform.b(), transform.c(), transform.d(),
                transform.e(), transform.f());
 }
 
 void BaseRenderingContext2D::scale(double sx, double sy) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(sx) || !std::isfinite(sy))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.scaleNonUniform(sx, sy);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
 
   c->scale(sx, sy);
   m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 }
 
 void BaseRenderingContext2D::rotate(double angleInRadians) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(angleInRadians))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.rotateRadians(angleInRadians);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
   c->rotate(angleInRadians * (180.0 / piFloat));
   m_path.transform(AffineTransform().rotateRadians(-angleInRadians));
 }
 
 void BaseRenderingContext2D::translate(double tx, double ty) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
   if (!state().isTransformInvertible())
     return;
 
   if (!std::isfinite(tx) || !std::isfinite(ty))
     return;
 
   AffineTransform newTransform = state().transform();
   newTransform.translate(tx, ty);
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
   c->translate(tx, ty);
   m_path.transform(AffineTransform().translate(-tx, -ty));
 }
 
 void BaseRenderingContext2D::transform(double m11,
                                        double m12,
                                        double m21,
                                        double m22,
                                        double dx,
                                        double dy) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) ||
       !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
     return;
 
   AffineTransform transform(m11, m12, m21, m22, dx, dy);
   AffineTransform newTransform = state().transform() * transform;
   if (state().transform() == newTransform)
     return;
 
   modifiableState().setTransform(newTransform);
   if (!state().isTransformInvertible())
     return;
 
   c->concat(affineTransformToSkMatrix(transform));
   m_path.transform(transform.inverse());
 }
 
 void BaseRenderingContext2D::resetTransform() {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   AffineTransform ctm = state().transform();
   bool invertibleCTM = state().isTransformInvertible();
   // It is possible that CTM is identity while CTM is not invertible.
   // When CTM becomes non-invertible, realizeSaves() can make CTM identity.
   if (ctm.isIdentity() && invertibleCTM)
     return;
 
   // resetTransform() resolves the non-invertible CTM state.
   modifiableState().resetTransform();
   c->setMatrix(affineTransformToSkMatrix(baseTransform()));
 
   if (invertibleCTM)
     m_path.transform(ctm);
   // When else, do nothing because all transform methods didn't update m_path
   // when CTM became non-invertible.
   // It means that resetTransform() restores m_path just before CTM became
   // non-invertible.
 }
 
 void BaseRenderingContext2D::setTransform(double m11,
                                           double m12,
                                           double m21,
                                           double m22,
                                           double dx,
                                           double dy) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
 
   if (!std::isfinite(m11) || !std::isfinite(m21) || !std::isfinite(dx) ||
       !std::isfinite(m12) || !std::isfinite(m22) || !std::isfinite(dy))
     return;
 
   resetTransform();
   transform(m11, m12, m21, m22, dx, dy);
 }
@@ skipping 57 matching lines @@
   SkPath skPath = path.getSkPath();
   FloatRect bounds = path.boundingRect();
   skPath.setFillType(fillType);
 
   if (paintType == CanvasRenderingContext2DState::StrokePaintType)
     inflateStrokeRect(bounds);
 
   if (!drawingCanvas())
     return;
 
-  if (draw([&skPath](SkCanvas* c, const SkPaint* paint)  // draw lambda
+  if (draw([&skPath](PaintCanvas* c, const PaintFlags* paint)  // draw lambda
            { c->drawPath(skPath, *paint); },
            [](const SkIRect& rect)  // overdraw test lambda
            { return false; },
            bounds, paintType)) {
     if (isPathExpensive(path)) {
       ImageBuffer* buffer = imageBuffer();
       if (buffer)
         buffer->setHasExpensiveOp();
     }
   }
@@ skipping 39 matching lines @@
                                       double width,
                                       double height) {
   trackDrawCall(FillRect, nullptr, width, height);
   if (!validateRectForCanvas(x, y, width, height))
     return;
 
   if (!drawingCanvas())
     return;
 
   SkRect rect = SkRect::MakeXYWH(x, y, width, height);
-  draw([&rect](SkCanvas* c, const SkPaint* paint)  // draw lambda
+  draw([&rect](PaintCanvas* c, const PaintFlags* paint)  // draw lambda
        { c->drawRect(rect, *paint); },
        [&rect, this](const SkIRect& clipBounds)  // overdraw test lambda
        { return rectContainsTransformedRect(rect, clipBounds); },
        rect, CanvasRenderingContext2DState::FillPaintType);
 }
 
 static void strokeRectOnCanvas(const FloatRect& rect,
-                               SkCanvas* canvas,
-                               const SkPaint* paint) {
+                               PaintCanvas* canvas,
+                               const PaintFlags* paint) {
   ASSERT(paint->getStyle() == SkPaint::kStroke_Style);
   if ((rect.width() > 0) != (rect.height() > 0)) {
     // When stroking, we must skip the zero-dimension segments
     SkPath path;
     path.moveTo(rect.x(), rect.y());
     path.lineTo(rect.maxX(), rect.maxY());
     path.close();
     canvas->drawPath(path, *paint);
     return;
   }
   canvas->drawRect(rect, *paint);
 }
 
 void BaseRenderingContext2D::strokeRect(double x,
                                         double y,
                                         double width,
                                         double height) {
   trackDrawCall(StrokeRect, nullptr, width, height);
   if (!validateRectForCanvas(x, y, width, height))
     return;
 
   if (!drawingCanvas())
     return;
 
   SkRect rect = SkRect::MakeXYWH(x, y, width, height);
   FloatRect bounds = rect;
   inflateStrokeRect(bounds);
-  draw([&rect](SkCanvas* c, const SkPaint* paint)  // draw lambda
+  draw([&rect](PaintCanvas* c, const PaintFlags* paint)  // draw lambda
        { strokeRectOnCanvas(rect, c, paint); },
        [](const SkIRect& clipBounds)  // overdraw test lambda
        { return false; },
        bounds, CanvasRenderingContext2DState::StrokePaintType);
 }
 
 void BaseRenderingContext2D::clipInternal(const Path& path,
                                           const String& windingRuleString) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c) {
     return;
   }
   if (!state().isTransformInvertible()) {
     return;
   }
 
   SkPath skPath = path.getSkPath();
   skPath.setFillType(parseWinding(windingRuleString));
   modifiableState().clipPath(skPath, m_clipAntialiasing);
@@ skipping 24 matching lines @@
                                            const double y,
                                            const String& windingRuleString) {
   return isPointInPathInternal(domPath->path(), x, y, windingRuleString);
 }
 
 bool BaseRenderingContext2D::isPointInPathInternal(
     const Path& path,
     const double x,
     const double y,
     const String& windingRuleString) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return false;
   if (!state().isTransformInvertible())
     return false;
 
   FloatPoint point(x, y);
   if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
     return false;
   AffineTransform ctm = state().transform();
   FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
   return path.contains(transformedPoint,
                        SkFillTypeToWindRule(parseWinding(windingRuleString)));
 }
 
 bool BaseRenderingContext2D::isPointInStroke(const double x, const double y) {
   return isPointInStrokeInternal(m_path, x, y);
 }
 
 bool BaseRenderingContext2D::isPointInStroke(Path2D* domPath,
                                              const double x,
                                              const double y) {
   return isPointInStrokeInternal(domPath->path(), x, y);
 }
 
 bool BaseRenderingContext2D::isPointInStrokeInternal(const Path& path,
                                                      const double x,
                                                      const double y) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return false;
   if (!state().isTransformInvertible())
     return false;
 
   FloatPoint point(x, y);
   if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
     return false;
   AffineTransform ctm = state().transform();
   FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
@@ skipping 12 matching lines @@
 
 void BaseRenderingContext2D::clearRect(double x,
                                        double y,
                                        double width,
                                        double height) {
   m_usageCounters.numClearRectCalls++;
 
   if (!validateRectForCanvas(x, y, width, height))
     return;
 
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c)
     return;
   if (!state().isTransformInvertible())
     return;
 
   SkIRect clipBounds;
   if (!c->getDeviceClipBounds(&clipBounds))
     return;
 
-  SkPaint clearPaint;
+  PaintFlags clearPaint;
   clearPaint.setBlendMode(SkBlendMode::kClear);
-  clearPaint.setStyle(SkPaint::kFill_Style);
+  clearPaint.setStyle(PaintFlags::kFill_Style);
   FloatRect rect(x, y, width, height);
 
   if (rectContainsTransformedRect(rect, clipBounds)) {
     checkOverdraw(rect, &clearPaint, CanvasRenderingContext2DState::NoImage,
                   ClipFill);
     if (drawingCanvas())
       drawingCanvas()->drawRect(rect, clearPaint);
     didDraw(clipBounds);
   } else {
     SkIRect dirtyRect;
@@ skipping 128 matching lines @@
   if (!imageSourceInternal)
     return;
   drawImage(executionContext, imageSourceInternal, sx, sy, sw, sh, dx, dy, dw,
             dh, exceptionState);
 }
 
 bool BaseRenderingContext2D::shouldDrawImageAntialiased(
     const FloatRect& destRect) const {
   if (!state().shouldAntialias())
     return false;
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   ASSERT(c);
 
   const SkMatrix& ctm = c->getTotalMatrix();
   // Don't disable anti-aliasing if we're rotated or skewed.
   if (!ctm.rectStaysRect())
     return true;
   // Check if the dimensions of the destination are "small" (less than one
   // device pixel). To prevent sudden drop-outs. Since we know that
   // kRectStaysRect_Mask is set, the matrix either has scale and no skew or
   // vice versa. We can query the kAffine_Mask flag to determine which case
@@ skipping 15 matching lines @@
 static bool isDrawScalingDown(const FloatRect& srcRect,
                               const FloatRect& dstRect,
                               float xScaleSquared,
                               float yScaleSquared) {
   return dstRect.width() * dstRect.width() * xScaleSquared <
              srcRect.width() * srcRect.width() &&
          dstRect.height() * dstRect.height() * yScaleSquared <
              srcRect.height() * srcRect.height();
 }
 
-void BaseRenderingContext2D::drawImageInternal(SkCanvas* c,
+void BaseRenderingContext2D::drawImageInternal(PaintCanvas* c,
                                                CanvasImageSource* imageSource,
                                                Image* image,
                                                const FloatRect& srcRect,
                                                const FloatRect& dstRect,
-                                               const SkPaint* paint) {
+                                               const PaintFlags* paint) {
   if (imageSource->isSVGSource()) {
     trackDrawCall(DrawVectorImage, nullptr, dstRect.width(), dstRect.height());
   } else {
     trackDrawCall(DrawBitmapImage, nullptr, dstRect.width(), dstRect.height());
   }
 
   int initialSaveCount = c->getSaveCount();
-  SkPaint imagePaint = *paint;
+  PaintFlags imagePaint = *paint;
 
   if (paint->getImageFilter()) {
     SkMatrix ctm = c->getTotalMatrix();
     SkMatrix invCtm;
     if (!ctm.invert(&invCtm)) {
       // There is an earlier check for invertibility, but the arithmetic
       // in AffineTransform is not exactly identical, so it is possible
       // for SkMatrix to find the transform to be non-invertible at this stage.
       // crbug.com/504687
       return;
     }
     c->save();
     c->concat(invCtm);
     SkRect bounds = dstRect;
     ctm.mapRect(&bounds);
-    SkPaint layerPaint;
+    PaintFlags layerPaint;
     layerPaint.setBlendMode(paint->getBlendMode());
     layerPaint.setImageFilter(paint->refImageFilter());
 
     c->saveLayer(&bounds, &layerPaint);
     c->concat(ctm);
     imagePaint.setBlendMode(SkBlendMode::kSrcOver);
     imagePaint.setImageFilter(nullptr);
   }
 
   if (!imageSmoothingEnabled() &&
@@ skipping 225 matching lines @@
       DEFINE_THREAD_SAFE_STATIC_LOCAL(
           CustomCountHistogram, scopedUsCounterOthersCPU,
           new CustomCountHistogram("Blink.Canvas.DrawImage.Others.CPU", 0,
                                    10000000, 50));
       timer.emplace(scopedUsCounterOthersCPU);
     }
   }
 
   draw(
       [this, &imageSource, &image, &srcRect, dstRect](
-          SkCanvas* c, const SkPaint* paint)  // draw lambda
+          PaintCanvas* c, const PaintFlags* paint)  // draw lambda
       {
         drawImageInternal(c, imageSource, image.get(), srcRect, dstRect, paint);
       },
       [this, &dstRect](const SkIRect& clipBounds)  // overdraw test lambda
       { return rectContainsTransformedRect(dstRect, clipBounds); },
       dstRect, CanvasRenderingContext2DState::ImagePaintType,
       imageSource->isOpaque() ? CanvasRenderingContext2DState::OpaqueImage
                               : CanvasRenderingContext2DState::NonOpaqueImage);
 
   validateStateStack();
@@ skipping 16 matching lines @@
   }
 
   if (originClean() && wouldTaintOrigin(imageSource, executionContext))
     setOriginTainted();
 }
 
 void BaseRenderingContext2D::clearCanvas() {
   FloatRect canvasRect(0, 0, width(), height());
   checkOverdraw(canvasRect, 0, CanvasRenderingContext2DState::NoImage,
                 ClipFill);
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (c)
     c->clear(hasAlpha() ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool BaseRenderingContext2D::rectContainsTransformedRect(
     const FloatRect& rect,
     const SkIRect& transformedRect) const {
   FloatQuad quad(rect);
   FloatQuad transformedQuad(FloatRect(transformedRect.x(), transformedRect.y(),
                                       transformedRect.width(),
@@ skipping 355 matching lines @@
 
 void BaseRenderingContext2D::setImageSmoothingQuality(const String& quality) {
   if (quality == state().imageSmoothingQuality())
     return;
 
   modifiableState().setImageSmoothingQuality(quality);
 }
 
 void BaseRenderingContext2D::checkOverdraw(
     const SkRect& rect,
-    const SkPaint* paint,
+    const PaintFlags* paint,
     CanvasRenderingContext2DState::ImageType imageType,
     DrawType drawType) {
-  SkCanvas* c = drawingCanvas();
+  PaintCanvas* c = drawingCanvas();
   if (!c || !imageBuffer()->isRecording())
     return;
 
   SkRect deviceRect;
   if (drawType == UntransformedUnclippedFill) {
     deviceRect = rect;
   } else {
     ASSERT(drawType == ClipFill);
     if (state().hasComplexClip())
       return;
@@ skipping 18 matching lines @@
     SkBlendMode mode = paint->getBlendMode();
     isSourceOver = mode == SkBlendMode::kSrcOver;
     if (!isSourceOver && mode != SkBlendMode::kSrc &&
         mode != SkBlendMode::kClear)
       return;  // The code below only knows how to handle Src, SrcOver, and
                // Clear
 
     alpha = paint->getAlpha();
 
     if (isSourceOver && imageType == CanvasRenderingContext2DState::NoImage) {
-      SkShader* shader = paint->getShader();
+      PaintShader* shader = paint->getShader();
       if (shader) {
         if (shader->isOpaque() && alpha == 0xFF)
           imageBuffer()->willOverwriteCanvas();
         return;
       }
     }
   }
 
   if (isSourceOver) {
     // With source over, we need to certify that alpha == 0xFF for all pixels
@@ skipping 241 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink