Make CanvasRenderingContext2D use SkCanvas directly

Source/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 92 matching lines @@
     , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)
 {
     if (document.settings() && document.settings()->antialiasedClips2dCanvasEnabled())
         m_clipAntialiasing = AntiAliased;
     m_stateStack.append(adoptPtrWillBeNoop(new State()));
 }
 
 void CanvasRenderingContext2D::unwindStateStack()
 {
     if (size_t stackSize = m_stateStack.size()) {
-        if (GraphicsContext* context = canvas()->existingDrawingContext()) {
+        if (SkCanvas* skCanvas = canvas()->existingDrawingCanvas()) {
             while (--stackSize)
-                context->restore();
+                skCanvas->restore();
         }
     }
 }
 
 CanvasRenderingContext2D::~CanvasRenderingContext2D()
 {
 }
 
 void CanvasRenderingContext2D::validateStateStack()
 {
 #if ENABLE(ASSERT)
-    GraphicsContext* context = canvas()->existingDrawingContext();
-    if (context && !context->contextDisabled() && !m_isContextLost)
-        ASSERT(context->saveCount() == m_stateStack.size());
+    SkCanvas* skCanvas = canvas()->existingDrawingCanvas();
+    if (skCanvas && !m_isContextLost) {
+        ASSERT(static_cast<size_t>(skCanvas->getSaveCount() - 1) == m_stateStack.size());
+    }
 #endif
 }
 
 bool CanvasRenderingContext2D::isAccelerated() const
 {
     if (!canvas()->hasImageBuffer())
         return false;
-    GraphicsContext* context = drawingContext();
-    return context && context->isAccelerated();
+    return canvas()->buffer()->isAccelerated();
 }
 
 bool CanvasRenderingContext2D::isContextLost() const
 {
     return m_isContextLost;
 }
 
 void CanvasRenderingContext2D::loseContext()
 {
     if (m_isContextLost)
@@ skipping 89 matching lines @@
     validateStateStack();
     unwindStateStack();
     m_stateStack.resize(1);
     m_stateStack.first() = adoptPtrWillBeNoop(new State());
     m_path.clear();
     validateStateStack();
 }
 
 void CanvasRenderingContext2D::restoreCanvasMatrixClipStack()
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     WillBeHeapVector<OwnPtrWillBeMember<State>>::iterator currState;
     for (currState = m_stateStack.begin(); currState < m_stateStack.end(); currState++) {
-        // We are only restoring state stored in the SkCanvas, and not
-        // state stored in the graphics context, so we call save() only on the canvas.
-        // The initial save accounts for the save installed by HTMLCanvasElement::m_contextStateSaver
-        c->canvas()->save();
+        // The initial save accounts for the save installed by canvasElementElement::m_contextStateSaver
+        c->save();
         c->setMatrix(SkMatrix::I());
         currState->get()->m_clipList.playback(c);
-        c->setCTM(currState->get()->m_transform);
+        c->setMatrix(affineTransformToSkMatrix(currState->get()->m_transform));
     }
 }
 
 // Important: Several of these properties are also stored in GraphicsContext's
 // StrokeData. The default values that StrokeData uses may not the same values
 // that the canvas 2d spec specifies. Make sure to sync the initial state of the
 // GraphicsContext in HTMLCanvasElement::createImageBuffer()!
 CanvasRenderingContext2D::State::State()
     : m_unrealizedSaveCount(0)
     , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))
@@ skipping 111 matching lines @@
     m_font.update(fontSelector);
 }
 
 void CanvasRenderingContext2D::State::trace(Visitor* visitor)
 {
     visitor->trace(m_strokeStyle);
     visitor->trace(m_fillStyle);
     CSSFontSelectorClient::trace(visitor);
 }
 
-void CanvasRenderingContext2D::realizeSaves(GraphicsContext* context)
+void CanvasRenderingContext2D::realizeSaves(SkCanvas* canvas)
 {
     validateStateStack();
     if (state().m_unrealizedSaveCount) {
         ASSERT(m_stateStack.size() >= 1);
         // Reduce the current state's unrealized count by one now,
         // to reflect the fact we are saving one state.
         m_stateStack.last()->m_unrealizedSaveCount--;
         m_stateStack.append(adoptPtrWillBeNoop(new State(state(), 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.last()->m_unrealizedSaveCount = 0;
-        if (!context)
-            context = drawingContext();
-        if (context)
-            context->save();
+        if (!canvas)
+            canvas = drawingCanvas();
+        if (canvas)
+            canvas->save();
         validateStateStack();
     }
 }
 
 void CanvasRenderingContext2D::restore()
 {
     validateStateStack();
     if (state().m_unrealizedSaveCount) {
         // We never realized the save, so just record that it was unnecessary.
         --m_stateStack.last()->m_unrealizedSaveCount;
         return;
     }
     ASSERT(m_stateStack.size() >= 1);
     if (m_stateStack.size() <= 1)
         return;
     m_path.transform(state().m_transform);
     m_stateStack.removeLast();
     m_path.transform(state().m_transform.inverse());
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (c)
         c->restore();
+
+    // Temporary code while crbug.com/453113 is a WIP: GraphicsContext state stack
+    // is no longer exercised so state stored still stored in GC must be re-installed
+    // after a restore.
+    GraphicsContext* gc = drawingContext();
+    if (gc) {
+        state().m_fillStyle->applyFillColor(gc);
+        state().m_strokeStyle->applyStrokeColor(gc);
+        gc->setStrokeThickness(state().m_lineWidth);
+        gc->setLineCap(state().m_lineCap);
+        gc->setLineJoin(state().m_lineJoin);
+        gc->setMiterLimit(state().m_miterLimit);
+        applyLineDash();
+        gc->setAlphaAsFloat(state().m_globalAlpha);
+        gc->setCompositeOperation(state().m_globalComposite);
+        gc->setImageInterpolationQuality(state().m_imageSmoothingEnabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
+        applyShadow();
+    }
+
     validateStateStack();
 }
 
 static inline void convertCanvasStyleToUnionType(CanvasStyle* style, StringOrCanvasGradientOrCanvasPattern& returnValue)
 {
     if (CanvasGradient* gradient = style->canvasGradient()) {
         returnValue.setCanvasGradient(gradient);
         return;
     }
     if (CanvasPattern* pattern = style->canvasPattern()) {
@@ skipping 33 matching lines @@
         RefPtrWillBeRawPtr<CanvasPattern> canvasPattern = style.getAsCanvasPattern();
 
         if (canvas()->originClean() && !canvasPattern->originClean())
             canvas()->setOriginTainted();
 
         canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
     ASSERT(canvasStyle);
 
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_strokeStyle = canvasStyle.release();
     if (!c)
         return;
-    state().m_strokeStyle->applyStrokeColor(c);
+    state().m_strokeStyle->applyStrokeColor(drawingContext());
     modifiableState().m_unparsedStrokeColor = colorString;
 }
 
 void CanvasRenderingContext2D::fillStyle(StringOrCanvasGradientOrCanvasPattern& returnValue) const
 {
     convertCanvasStyleToUnionType(state().m_fillStyle.get(), returnValue);
 }
 
 void CanvasRenderingContext2D::setFillStyle(const StringOrCanvasGradientOrCanvasPattern& style)
 {
     ASSERT(!style.isNull());
-
+    validateStateStack();
     String colorString;
     RefPtrWillBeRawPtr<CanvasStyle> canvasStyle;
     if (style.isString()) {
         colorString = style.getAsString();
         if (colorString == state().m_unparsedFillColor)
             return;
         RGBA32 parsedColor = 0;
         if (!parseColorOrCurrentColor(parsedColor, colorString, canvas()))
             return;
         if (state().m_fillStyle->isEquivalentRGBA(parsedColor)) {
             realizeSaves(nullptr);
             modifiableState().m_unparsedFillColor = colorString;
             return;
         }
         canvasStyle = CanvasStyle::createFromRGBA(parsedColor);
     } else if (style.isCanvasGradient()) {
         canvasStyle = CanvasStyle::createFromGradient(style.getAsCanvasGradient());
     } else if (style.isCanvasPattern()) {
         RefPtrWillBeRawPtr<CanvasPattern> canvasPattern = style.getAsCanvasPattern();
 
         if (canvas()->originClean() && !canvasPattern->originClean())
             canvas()->setOriginTainted();
 
         canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
     ASSERT(canvasStyle);
 
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_fillStyle = canvasStyle.release();
     if (!c)
         return;
-    state().m_fillStyle->applyFillColor(c);
+    state().m_fillStyle->applyFillColor(drawingContext());
     modifiableState().m_unparsedFillColor = colorString;
 }
 
 float CanvasRenderingContext2D::lineWidth() const
 {
     return state().m_lineWidth;
 }
 
 void CanvasRenderingContext2D::setLineWidth(float width)
 {
     if (!std::isfinite(width) || width <= 0)
         return;
     if (state().m_lineWidth == width)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_lineWidth = width;
     if (!c)
         return;
-    c->setStrokeThickness(width);
+    drawingContext()->setStrokeThickness(width);
 }
 
 String CanvasRenderingContext2D::lineCap() const
 {
     return lineCapName(state().m_lineCap);
 }
 
 void CanvasRenderingContext2D::setLineCap(const String& s)
 {
     LineCap cap;
     if (!parseLineCap(s, cap))
         return;
     if (state().m_lineCap == cap)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_lineCap = cap;
     if (!c)
         return;
-    c->setLineCap(cap);
+    drawingContext()->setLineCap(cap);
 }
 
 String CanvasRenderingContext2D::lineJoin() const
 {
     return lineJoinName(state().m_lineJoin);
 }
 
 void CanvasRenderingContext2D::setLineJoin(const String& s)
 {
     LineJoin join;
     if (!parseLineJoin(s, join))
         return;
     if (state().m_lineJoin == join)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_lineJoin = join;
     if (!c)
         return;
-    c->setLineJoin(join);
+    drawingContext()->setLineJoin(join);
 }
 
 float CanvasRenderingContext2D::miterLimit() const
 {
     return state().m_miterLimit;
 }
 
 void CanvasRenderingContext2D::setMiterLimit(float limit)
 {
     if (!std::isfinite(limit) || limit <= 0)
         return;
     if (state().m_miterLimit == limit)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_miterLimit = limit;
     if (!c)
         return;
-    c->setMiterLimit(limit);
+    drawingContext()->setMiterLimit(limit);
 }
 
 float CanvasRenderingContext2D::shadowOffsetX() const
 {
     return state().m_shadowOffset.width();
 }
 
 void CanvasRenderingContext2D::setShadowOffsetX(float x)
 {
     if (!std::isfinite(x))
@@ skipping 113 matching lines @@
 {
     return state().m_globalAlpha;
 }
 
 void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
 {
     if (!(alpha >= 0 && alpha <= 1))
         return;
     if (state().m_globalAlpha == alpha)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_globalAlpha = alpha;
     if (!c)
         return;
-    c->setAlphaAsFloat(alpha);
+    drawingContext()->setAlphaAsFloat(alpha);
 }
 
 String CanvasRenderingContext2D::globalCompositeOperation() const
 {
     return compositeOperatorName(compositeOperatorFromSkia(state().m_globalComposite), blendModeFromSkia(state().m_globalComposite));
 }
 
 void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
 {
     CompositeOperator op = CompositeSourceOver;
     WebBlendMode blendMode = WebBlendModeNormal;
     if (!parseCompositeAndBlendOperator(operation, op, blendMode))
         return;
     SkXfermode::Mode xfermode = WebCoreCompositeToSkiaComposite(op, blendMode);
     if (state().m_globalComposite == xfermode)
         return;
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_globalComposite = xfermode;
     if (!c)
         return;
-    c->setCompositeOperation(xfermode);
+    drawingContext()->setCompositeOperation(xfermode);
 }
 
 void CanvasRenderingContext2D::setCurrentTransform(PassRefPtrWillBeRawPtr<SVGMatrixTearOff> passMatrixTearOff)
 {
     RefPtrWillBeRawPtr<SVGMatrixTearOff> matrixTearOff = passMatrixTearOff;
     const AffineTransform& transform = matrixTearOff->value();
     setTransform(transform.a(), transform.b(), transform.c(), transform.d(), transform.e(), transform.f());
 }
 
 void CanvasRenderingContext2D::scale(float sx, float sy)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     if (!std::isfinite(sx) || !std::isfinite(sy))
         return;
 
     AffineTransform newTransform = state().m_transform;
     newTransform.scaleNonUniform(sx, sy);
     if (state().m_transform == newTransform)
         return;
 
     realizeSaves(c);
 
     if (!newTransform.isInvertible()) {
         modifiableState().m_invertibleCTM = false;
         return;
     }
 
     modifiableState().m_transform = newTransform;
     c->scale(sx, sy);
     m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 }
 
 void CanvasRenderingContext2D::rotate(float angleInRadians)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     if (!std::isfinite(angleInRadians))
         return;
 
     AffineTransform newTransform = state().m_transform;
     newTransform.rotateRadians(angleInRadians);
     if (state().m_transform == newTransform)
         return;
 
     realizeSaves(c);
 
     if (!newTransform.isInvertible()) {
         modifiableState().m_invertibleCTM = false;
         return;
     }
 
     modifiableState().m_transform = newTransform;
-    c->rotate(angleInRadians);
+    c->rotate(angleInRadians * (180.0f / piFloat));
     m_path.transform(AffineTransform().rotateRadians(-angleInRadians));
 }
 
 void CanvasRenderingContext2D::translate(float tx, float ty)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     if (!std::isfinite(tx) || !std::isfinite(ty))
         return;
 
     AffineTransform newTransform = state().m_transform;
     newTransform.translate(tx, ty);
     if (state().m_transform == newTransform)
         return;
 
     realizeSaves(c);
 
     if (!newTransform.isInvertible()) {
         modifiableState().m_invertibleCTM = false;
         return;
     }
 
     modifiableState().m_transform = newTransform;
     c->translate(tx, ty);
     m_path.transform(AffineTransform().translate(-tx, -ty));
 }
 
 void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         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().m_transform * transform;
     if (state().m_transform == newTransform)
         return;
 
     realizeSaves(c);
 
     modifiableState().m_transform = newTransform;
     if (!newTransform.isInvertible()) {
         modifiableState().m_invertibleCTM = false;
         return;
     }
 
-    c->concatCTM(transform);
+    c->concat(affineTransformToSkMatrix(transform));
     m_path.transform(transform.inverse());
 }
 
 void CanvasRenderingContext2D::resetTransform()
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     AffineTransform ctm = state().m_transform;
     bool invertibleCTM = state().m_invertibleCTM;
     // 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;
 
     realizeSaves(c);
     // resetTransform() resolves the non-invertible CTM state.
     modifiableState().m_transform.makeIdentity();
     modifiableState().m_invertibleCTM = true;
-    c->setCTM(canvas()->baseTransform());
+    c->setMatrix(affineTransformToSkMatrix(canvas()->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 CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* 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 24 matching lines @@
 }
 
 static bool isFullCanvasCompositeMode(SkXfermode::Mode op)
 {
     // See 4.8.11.1.3 Compositing
     // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
     // implement the specification's behavior.
     return op == SkXfermode::kSrcIn_Mode || op == SkXfermode::kSrcOut_Mode || op == SkXfermode::kDstIn_Mode || op == SkXfermode::kDstATop_Mode;
 }
 
-static WindRule parseWinding(const String& windingRuleString)
+static SkPath::FillType parseWinding(const String& windingRuleString)
 {
     if (windingRuleString == "nonzero")
-        return RULE_NONZERO;
+        return SkPath::kWinding_FillType;
     if (windingRuleString == "evenodd")
-        return RULE_EVENODD;
+        return SkPath::kEvenOdd_FillType;
 
     ASSERT_NOT_REACHED();
-    return RULE_EVENODD;
+    return SkPath::kEvenOdd_FillType;
 }
 
 void CanvasRenderingContext2D::fillInternal(const Path& path, const String& windingRuleString)
 {
     if (path.isEmpty()) {
         return;
     }
     GraphicsContext* c = drawingContext();
     if (!c) {
         return;
     }
     if (!state().m_invertibleCTM) {
         return;
     }
     FloatRect clipBounds;
     if (!c->getTransformedClipBounds(&clipBounds)) {
         return;
     }
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize()) {
         return;
     }
 
     WindRule windRule = c->fillRule();
-    c->setFillRule(parseWinding(windingRuleString));
+    c->setFillRule(SkFillTypeToWindRule(parseWinding(windingRuleString)));
 
     if (isFullCanvasCompositeMode(state().m_globalComposite)) {
         fullCanvasCompositedDraw(bind(&GraphicsContext::fillPath, c, path));
         didDraw(clipBounds);
     } else if (state().m_globalComposite == SkXfermode::kSrc_Mode) {
         clearCanvas();
         c->clearShadow();
         c->fillPath(path);
         applyShadow(DrawShadowAndForeground);
         didDraw(clipBounds);
@@ skipping 65 matching lines @@
     strokeInternal(m_path);
 }
 
 void CanvasRenderingContext2D::stroke(Path2D* domPath)
 {
     strokeInternal(domPath->path());
 }
 
 void CanvasRenderingContext2D::clipInternal(const Path& path, const String& windingRuleString)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c) {
         return;
     }
     if (!state().m_invertibleCTM) {
         return;
     }
 
     realizeSaves(c);
 
-    WindRule windRule = parseWinding(windingRuleString);
+    SkPath skPath = path.skPath();
+    skPath.setFillType(parseWinding(windingRuleString));
     ImageBuffer* buffer = canvas()->buffer();
     if (buffer && buffer->needsClipTracking()) {
-        modifiableState().m_clipList.clipPath(path, windRule, m_clipAntialiasing, state().m_transform);
+        modifiableState().m_clipList.clipPath(skPath, m_clipAntialiasing, affineTransformToSkMatrix(state().m_transform));
     }
-    c->clipPath(path, windRule, m_clipAntialiasing);
+
+    c->clipPath(skPath, SkRegion::kIntersect_Op, m_clipAntialiasing == AntiAliased);
+    if (!skPath.isRect(0))
+        drawingContext()->setHasComplexClip();
     modifiableState().m_hasClip = true;
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
 void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString)
 {
     clipInternal(domPath->path(), windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString)
 {
     return isPointInPathInternal(m_path, x, y, windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y, const String& windingRuleString)
 {
     return isPointInPathInternal(domPath->path(), x, y, windingRuleString);
 }
 
 bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, const float x, const float y, const String& windingRuleString)
 {
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return false;
     if (!state().m_invertibleCTM)
         return false;
 
     FloatPoint point(x, y);
     if (!std::isfinite(point.x()) || !std::isfinite(point.y()))
         return false;
     AffineTransform ctm = state().m_transform;
     FloatPoint transformedPoint = ctm.inverse().mapPoint(point);
 
-    return path.contains(transformedPoint, parseWinding(windingRuleString));
+    return path.contains(transformedPoint, SkFillTypeToWindRule(parseWinding(windingRuleString)));
 }
 
 bool CanvasRenderingContext2D::isPointInStroke(const float x, const float y)
 {
     return isPointInStrokeInternal(m_path, x, y);
 }
 
 bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const float x, const float y)
 {
     return isPointInStrokeInternal(domPath->path(), x, y);
@@ skipping 66 matching lines @@
     if (!context)
         return;
     if (!state().m_invertibleCTM)
         return;
     FloatRect rect(x, y, width, height);
 
     FloatRect dirtyRect;
     if (!computeDirtyRect(rect, &dirtyRect))
         return;
 
-    bool saved = false;
-    if (shouldDrawShadows()) {
-        context->save();
-        saved = true;
-        context->clearShadow();
-    }
-    if (state().m_globalAlpha != 1) {
-        if (!saved) {
-            context->save();
-            saved = true;
-        }
-        context->setAlphaAsFloat(1);
-    }
-    if (state().m_globalComposite != SkXfermode::kSrcOver_Mode) {
-        if (!saved) {
-            context->save();
-            saved = true;
-        }
-        context->setCompositeOperation(SkXfermode::kSrcOver_Mode);
-    }
+    context->clearShadow();
+    context->setAlphaAsFloat(1);
+    context->setCompositeOperation(SkXfermode::kSrcOver_Mode);
+
     context->clearRect(rect);
     if (m_hitRegionManager)
         m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
-    if (saved)
-        context->restore();
+
+    applyShadow(DrawShadowAndForeground);
+    context->setAlphaAsFloat(state().m_globalAlpha);
+    context->setCompositeOperation(state().m_globalComposite);
 
     validateStateStack();
     didDraw(dirtyRect);
 }
 
 // FIXME(crbug.com/425531): Funtional.h cannot handle override function signature.
 static void fillRectOnContext(GraphicsContext* context, const FloatRect& rect)
 {
     context->fillRect(rect);
 }
@@ skipping 166 matching lines @@
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     drawImageInternal(imageSourceInternal, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
 }
 
-static void drawVideo(GraphicsContext* c, CanvasImageSource* imageSource, FloatRect srcRect, FloatRect dstRect)
+static void drawVideo(SkCanvas* c, GraphicsContext* gc, CanvasImageSource* imageSource, FloatRect srcRect, FloatRect dstRect)
 {
     HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
-    GraphicsContextStateSaver stateSaver(*c);
-    c->clip(dstRect);
+    c->save();
+    c->clipRect(WebCoreFloatRectToSKRect(dstRect));
     c->translate(dstRect.x(), dstRect.y());
     c->scale(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height());
     c->translate(-srcRect.x(), -srcRect.y());
-    video->paintCurrentFrameInContext(c, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())));
-    stateSaver.restore();
+    video->paintCurrentFrameInContext(gc, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())));
+    c->restore();
 }
 
-static void drawImageOnContext(GraphicsContext* c, CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect)
+static void drawImageOnContext(SkCanvas* c, GraphicsContext* gc, CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect)
 {
     if (!imageSource->isVideoElement()) {
-        c->drawImage(image, dstRect, srcRect, c->compositeOperation());
+        gc->drawImage(image, dstRect, srcRect, gc->compositeOperation());
     } else {
-        drawVideo(c, static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
+        drawVideo(c, gc, static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
     }
 }
 
 void CanvasRenderingContext2D::drawImageInternal(CanvasImageSource* imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     RefPtr<Image> image;
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
@@ skipping 36 matching lines @@
 
     // FIXME: crbug.com/447218
     // We make the destination canvas fall out of display list mode by calling
     // willAccessPixels. This is to prevent run-away memory consumption caused by SkSurface
     // copyOnWrite when the source canvas is animated and consumed at a rate higher than the
     // presentation frame rate of the destination canvas.
     if (imageSource->isCanvasElement())
         canvas()->buffer()->willAccessPixels();
 
     if (rectContainsTransformedRect(dstRect, clipBounds)) {
-        drawImageOnContext(c, imageSource, image.get(), srcRect, dstRect);
+        drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedDraw(bind(&drawImageOnContext, c, imageSource, image.get(), srcRect, dstRect));
+        fullCanvasCompositedDraw(bind(&drawImageOnContext, drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect));
         didDraw(clipBounds);
     } else if (state().m_globalComposite == SkXfermode::kSrc_Mode) {
         clearCanvas();
-        drawImageOnContext(c, imageSource, image.get(), srcRect, dstRect);
+        drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(dstRect, clipBounds, &dirtyRect)) {
-            drawImageOnContext(c, imageSource, image.get(), srcRect, dstRect);
+            drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
             didDraw(dirtyRect);
         }
     }
+
     validateStateStack();
 
     if (sourceImageStatus == ExternalSourceImageStatus && isAccelerated() && canvas()->buffer())
         canvas()->buffer()->flush();
 
     if (canvas()->originClean() && wouldTaintOrigin(imageSource))
         canvas()->setOriginTainted();
 }
 
 void CanvasRenderingContext2D::clearCanvas()
 {
     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
-    c->save();
-    c->setCTM(canvas()->baseTransform());
-    c->clearRect(canvasRect);
-    c->restore();
+    c->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const FloatRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(transformedRect);
     return state().m_transform.mapQuad(quad).containsQuad(transformedQuad);
 }
 
 void CanvasRenderingContext2D::fullCanvasCompositedDraw(PassOwnPtr<Closure> draw)
@@ skipping 106 matching lines @@
 }
 
 void CanvasRenderingContext2D::didDraw(const FloatRect& dirtyRect)
 {
     if (dirtyRect.isEmpty())
         return;
 
     canvas()->didDraw(dirtyRect);
 }
 
+SkCanvas* CanvasRenderingContext2D::drawingCanvas() const
+{
+    if (isContextLost())
+        return nullptr;
+    return canvas()->drawingCanvas();
+}
+
 GraphicsContext* CanvasRenderingContext2D::drawingContext() const
 {
     if (isContextLost())
         return nullptr;
     return canvas()->drawingContext();
 }
 
 PassRefPtrWillBeRawPtr<ImageData> CanvasRenderingContext2D::createImageData(PassRefPtrWillBeRawPtr<ImageData> imageData) const
 {
     return ImageData::create(imageData->size());
@@ skipping 531 matching lines @@
 bool CanvasRenderingContext2D::imageSmoothingEnabled() const
 {
     return state().m_imageSmoothingEnabled;
 }
 
 void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)
 {
     if (enabled == state().m_imageSmoothingEnabled)
         return;
 
-    GraphicsContext* c = drawingContext();
+    SkCanvas* c = drawingCanvas();
     realizeSaves(c);
     modifiableState().m_imageSmoothingEnabled = enabled;
     if (c)
-        c->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
+        drawingContext()->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
 }
 
 void CanvasRenderingContext2D::getContextAttributes(Canvas2DContextAttributes& attrs) const
 {
     attrs.setAlpha(m_hasAlpha);
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)
 {
     drawFocusIfNeededInternal(m_path, element);
@@ skipping 41 matching lines @@
     const int focusRingOutline = 0;
 
     // We need to add focusRingWidth to dirtyRect.
     StrokeData strokeData;
     strokeData.setThickness(focusRingWidth);
 
     FloatRect dirtyRect;
     if (!computeDirtyRect(path.strokeBoundingRect(strokeData), &dirtyRect))
         return;
 
-    c->save();
     c->setAlphaAsFloat(1.0);
     c->clearShadow();
     c->setCompositeOperation(SkXfermode::kSrcOver_Mode);
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
-    c->restore();
+    applyShadow(DrawShadowAndForeground);
+    c->setAlphaAsFloat(state().m_globalAlpha);
+    c->setCompositeOperation(state().m_globalComposite);
+
     validateStateStack();
     didDraw(dirtyRect);
 }
 
 void CanvasRenderingContext2D::addHitRegion(const HitRegionOptions& options, ExceptionState& exceptionState)
 {
     if (options.id().isEmpty() && !options.control()) {
         exceptionState.throwDOMException(NotSupportedError, "Both id and control are null.");
         return;
     }
@@ skipping 53 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink