Removing the dependency on GraphicsContext for drawing images in 2D canvas

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 43 matching lines @@
 #include "core/html/canvas/CanvasRenderingContext2DState.h"
 #include "core/html/canvas/CanvasStyle.h"
 #include "core/html/canvas/HitRegion.h"
 #include "core/html/canvas/Path2D.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutTheme.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
-#include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
+#include "platform/graphics/StrokeData.h"
+#include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiTextRun.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
 #include "wtf/ArrayBufferContents.h"
 #include "wtf/CheckedArithmetic.h"
 #include "wtf/MathExtras.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 static const int defaultFontSize = 10;
 static const char defaultFontFamily[] = "sans-serif";
@@ skipping 45 matching lines @@
     , m_contextLostMode(NotLostContext)
     , m_contextRestorable(true)
     , m_tryRestoreContextAttemptCount(0)
     , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)
     , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)
     , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)
 {
     if (document.settings() && document.settings()->antialiasedClips2dCanvasEnabled())
         m_clipAntialiasing = AntiAliased;
     m_stateStack.append(adoptPtrWillBeNoop(new CanvasRenderingContext2DState()));
+    setShouldAntialias(true);
 }
 
 void CanvasRenderingContext2D::unwindStateStack()
 {
     if (size_t stackSize = m_stateStack.size()) {
         if (SkCanvas* skCanvas = canvas()->existingDrawingCanvas()) {
             while (--stackSize)
                 skCanvas->restore();
         }
     }
 }
 
 CanvasRenderingContext2D::~CanvasRenderingContext2D()
 {
 }
 
 void CanvasRenderingContext2D::validateStateStack()
 {
 #if ENABLE(ASSERT)
     SkCanvas* skCanvas = canvas()->existingDrawingCanvas();
     if (skCanvas && m_contextLostMode == NotLostContext) {
-        ASSERT(static_cast<size_t>(skCanvas->getSaveCount() - 1) == m_stateStack.size());
+        ASSERT(static_cast<size_t>(skCanvas->getSaveCount()) == m_stateStack.size());
     }
 #endif
 }
 
 CanvasRenderingContext2DState& CanvasRenderingContext2D::modifiableState()
 {
-    ASSERT(!state().hasUnrealizedSaves());
+    realizeSaves();
     return *m_stateStack.last();
 }
 
 bool CanvasRenderingContext2D::isAccelerated() const
 {
     if (!canvas()->hasImageBuffer())
         return false;
     return canvas()->buffer()->isAccelerated();
 }
 
@@ skipping 103 matching lines @@
     }
 }
 
 void CanvasRenderingContext2D::reset()
 {
     validateStateStack();
     unwindStateStack();
     m_stateStack.resize(1);
     m_stateStack.first() = adoptPtrWillBeNoop(new CanvasRenderingContext2DState());
     m_path.clear();
+    SkCanvas* c = canvas()->existingDrawingCanvas();
+    if (c) {
+        c->resetMatrix();
+        c->clipRect(SkRect::MakeWH(canvas()->width(), canvas()->height()), SkRegion::kReplace_Op);
+    }
     validateStateStack();
 }
 
 void CanvasRenderingContext2D::restoreCanvasMatrixClipStack()
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     WillBeHeapVector<OwnPtrWillBeMember<CanvasRenderingContext2DState>>::iterator currState;
+    ASSERT(m_stateStack.begin() < m_stateStack.end());
     for (currState = m_stateStack.begin(); currState < m_stateStack.end(); currState++) {
-        // The initial save accounts for the save installed by canvasElementElement::m_contextStateSaver
-        c->save();
         c->setMatrix(SkMatrix::I());
         currState->get()->playbackClips(c);
         c->setMatrix(affineTransformToSkMatrix(currState->get()->transform()));
+        c->save();
     }
+    c->restore();
 }
 
-void CanvasRenderingContext2D::realizeSaves(SkCanvas* canvas)
+void CanvasRenderingContext2D::realizeSaves()
 {
     validateStateStack();
     if (state().hasUnrealizedSaves()) {
         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()->restore();
         m_stateStack.append(adoptPtrWillBeNoop(new CanvasRenderingContext2DState(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.last()->resetUnrealizedSaveCount();
-        if (!canvas)
-            canvas = drawingCanvas();
+        SkCanvas* canvas = drawingCanvas();
         if (canvas)
             canvas->save();
         validateStateStack();
     }
 }
 
 void CanvasRenderingContext2D::save()
 {
     m_stateStack.last()->save();
 }
 
 void CanvasRenderingContext2D::restore()
 {
     validateStateStack();
     if (state().hasUnrealizedSaves()) {
         // We never realized the save, so just record that it was unnecessary.
         m_stateStack.last()->restore();
         return;
     }
     ASSERT(m_stateStack.size() >= 1);
     if (m_stateStack.size() <= 1)
         return;
     m_path.transform(state().transform());
     m_stateStack.removeLast();
     m_path.transform(state().transform().inverse());
     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) {
-        gc->setAlphaAsFloat(state().globalAlpha());
-        gc->setCompositeOperation(state().globalComposite());
-        gc->setImageInterpolationQuality(state().imageSmoothingEnabled() ? CanvasDefaultInterpolationQuality : InterpolationNone);
-    }
-
     validateStateStack();
 }
 
 static inline void convertCanvasStyleToUnionType(CanvasStyle* style, StringOrCanvasGradientOrCanvasPattern& returnValue)
 {
     if (CanvasGradient* gradient = style->canvasGradient()) {
         returnValue.setCanvasGradient(gradient);
         return;
     }
     if (CanvasPattern* pattern = style->canvasPattern()) {
@@ skipping 15 matching lines @@
     String colorString;
     RefPtrWillBeRawPtr<CanvasStyle> canvasStyle = nullptr;
     if (style.isString()) {
         colorString = style.getAsString();
         if (colorString == state().unparsedStrokeColor())
             return;
         RGBA32 parsedColor = 0;
         if (!parseColorOrCurrentColor(parsedColor, colorString, canvas()))
             return;
         if (state().strokeStyle()->isEquivalentRGBA(parsedColor)) {
-            realizeSaves(nullptr);
             modifiableState().setUnparsedStrokeColor(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);
 
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setStrokeStyle(canvasStyle.release());
-    if (!c)
-        return;
     modifiableState().setUnparsedStrokeColor(colorString);
 }
 
 void CanvasRenderingContext2D::fillStyle(StringOrCanvasGradientOrCanvasPattern& returnValue) const
 {
     convertCanvasStyleToUnionType(state().fillStyle(), returnValue);
 }
 
 void CanvasRenderingContext2D::setFillStyle(const StringOrCanvasGradientOrCanvasPattern& style)
 {
     ASSERT(!style.isNull());
     validateStateStack();
     String colorString;
     RefPtrWillBeRawPtr<CanvasStyle> canvasStyle = nullptr;
     if (style.isString()) {
         colorString = style.getAsString();
         if (colorString == state().unparsedFillColor())
             return;
         RGBA32 parsedColor = 0;
         if (!parseColorOrCurrentColor(parsedColor, colorString, canvas()))
             return;
         if (state().fillStyle()->isEquivalentRGBA(parsedColor)) {
-            realizeSaves(nullptr);
             modifiableState().setUnparsedFillColor(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);
-    SkCanvas* c = drawingCanvas();
-    if (!c)
-        return;
-    realizeSaves(c);
-
     modifiableState().setFillStyle(canvasStyle.release());
     modifiableState().setUnparsedFillColor(colorString);
 }
 
 float CanvasRenderingContext2D::lineWidth() const
 {
     return state().lineWidth();
 }
 
 void CanvasRenderingContext2D::setLineWidth(float width)
 {
     if (!std::isfinite(width) || width <= 0)
         return;
     if (state().lineWidth() == width)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setLineWidth(width);
-    if (!c)
-        return;
 }
 
 String CanvasRenderingContext2D::lineCap() const
 {
     return lineCapName(state().lineCap());
 }
 
 void CanvasRenderingContext2D::setLineCap(const String& s)
 {
     LineCap cap;
     if (!parseLineCap(s, cap))
         return;
     if (state().lineCap() == cap)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setLineCap(cap);
-    if (!c)
-        return;
 }
 
 String CanvasRenderingContext2D::lineJoin() const
 {
     return lineJoinName(state().lineJoin());
 }
 
 void CanvasRenderingContext2D::setLineJoin(const String& s)
 {
     LineJoin join;
     if (!parseLineJoin(s, join))
         return;
     if (state().lineJoin() == join)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setLineJoin(join);
-    if (!c)
-        return;
 }
 
 float CanvasRenderingContext2D::miterLimit() const
 {
     return state().miterLimit();
 }
 
 void CanvasRenderingContext2D::setMiterLimit(float limit)
 {
     if (!std::isfinite(limit) || limit <= 0)
         return;
     if (state().miterLimit() == limit)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setMiterLimit(limit);
-    if (!c)
-        return;
 }
 
 float CanvasRenderingContext2D::shadowOffsetX() const
 {
     return state().shadowOffset().width();
 }
 
 void CanvasRenderingContext2D::setShadowOffsetX(float x)
 {
     if (!std::isfinite(x))
         return;
     if (state().shadowOffset().width() == x)
         return;
-    realizeSaves(nullptr);
     modifiableState().setShadowOffsetX(x);
 }
 
 float CanvasRenderingContext2D::shadowOffsetY() const
 {
     return state().shadowOffset().height();
 }
 
 void CanvasRenderingContext2D::setShadowOffsetY(float y)
 {
     if (!std::isfinite(y))
         return;
     if (state().shadowOffset().height() == y)
         return;
-    realizeSaves(nullptr);
     modifiableState().setShadowOffsetY(y);
 }
 
 float CanvasRenderingContext2D::shadowBlur() const
 {
     return state().shadowBlur();
 }
 
 void CanvasRenderingContext2D::setShadowBlur(float blur)
 {
     if (!std::isfinite(blur) || blur < 0)
         return;
     if (state().shadowBlur() == blur)
         return;
-    realizeSaves(nullptr);
     modifiableState().setShadowBlur(blur);
 }
 
 String CanvasRenderingContext2D::shadowColor() const
 {
     return Color(state().shadowColor()).serialized();
 }
 
 void CanvasRenderingContext2D::setShadowColor(const String& color)
 {
     RGBA32 rgba;
     if (!parseColorOrCurrentColor(rgba, color, canvas()))
         return;
     if (state().shadowColor() == rgba)
         return;
-    realizeSaves(nullptr);
     modifiableState().setShadowColor(rgba);
 }
 
 const Vector<float>& CanvasRenderingContext2D::getLineDash() const
 {
     return state().lineDash();
 }
 
 static bool lineDashSequenceIsValid(const Vector<float>& dash)
 {
     for (size_t i = 0; i < dash.size(); i++) {
         if (!std::isfinite(dash[i]) || dash[i] < 0)
             return false;
     }
     return true;
 }
 
 void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)
 {
     if (!lineDashSequenceIsValid(dash))
         return;
-
-    realizeSaves(nullptr);
     modifiableState().setLineDash(dash);
 }
 
 float CanvasRenderingContext2D::lineDashOffset() const
 {
     return state().lineDashOffset();
 }
 
 void CanvasRenderingContext2D::setLineDashOffset(float offset)
 {
     if (!std::isfinite(offset) || state().lineDashOffset() == offset)
         return;
-
-    realizeSaves(nullptr);
     modifiableState().setLineDashOffset(offset);
 }
 
 float CanvasRenderingContext2D::globalAlpha() const
 {
     return state().globalAlpha();
 }
 
 void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
 {
     if (!(alpha >= 0 && alpha <= 1))
         return;
     if (state().globalAlpha() == alpha)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setGlobalAlpha(alpha);
-    if (!c)
-        return;
-    drawingContext()->setAlphaAsFloat(alpha);
+}
+
+bool CanvasRenderingContext2D::shouldAntialias() const
+{
+    return state().shouldAntialias();
+}
+
+void CanvasRenderingContext2D::setShouldAntialias(bool doAA)
+{
+    modifiableState().setShouldAntialias(doAA);
 }
 
 String CanvasRenderingContext2D::globalCompositeOperation() const
 {
     return compositeOperatorName(compositeOperatorFromSkia(state().globalComposite()), blendModeFromSkia(state().globalComposite()));
 }
 
 void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
 {
     CompositeOperator op = CompositeSourceOver;
     WebBlendMode blendMode = WebBlendModeNormal;
     // TODO(dshwang): Support nonstandard "darker" until M43. crbug.com/425628
     String operationName = operation;
     if (operation == "darker") {
         operationName = "darken";
         if (canvas())
             UseCounter::countDeprecation(canvas()->document(), UseCounter::CanvasRenderingContext2DCompositeOperationDarker);
     }
     if (!parseCompositeAndBlendOperator(operationName, op, blendMode))
         return;
     SkXfermode::Mode xfermode = WebCoreCompositeToSkiaComposite(op, blendMode);
     if (state().globalComposite() == xfermode)
         return;
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setGlobalComposite(xfermode);
-    if (!c)
-        return;
-    drawingContext()->setCompositeOperation(xfermode);
 }
 
 PassRefPtrWillBeRawPtr<SVGMatrixTearOff> CanvasRenderingContext2D::currentTransform() const
 {
     return SVGMatrixTearOff::create(state().transform());
 }
 
 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)
 {
     SkCanvas* 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;
 
-    realizeSaves(c);
-
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
 
     c->scale(sx, sy);
     m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 }
 
 void CanvasRenderingContext2D::rotate(float angleInRadians)
 {
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(angleInRadians))
         return;
 
     AffineTransform newTransform = state().transform();
     newTransform.rotateRadians(angleInRadians);
     if (state().transform() == newTransform)
         return;
 
-    realizeSaves(c);
-
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
     c->rotate(angleInRadians * (180.0f / piFloat));
     m_path.transform(AffineTransform().rotateRadians(-angleInRadians));
 }
 
 void CanvasRenderingContext2D::translate(float tx, float ty)
 {
     SkCanvas* 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;
 
-    realizeSaves(c);
-
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
     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)
 {
     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;
 
     AffineTransform transform(m11, m12, m21, m22, dx, dy);
     AffineTransform newTransform = state().transform() * transform;
     if (state().transform() == newTransform)
         return;
 
-    realizeSaves(c);
-
     modifiableState().setTransform(newTransform);
     if (!state().isTransformInvertible())
         return;
 
     c->concat(affineTransformToSkMatrix(transform));
     m_path.transform(transform.inverse());
 }
 
 void CanvasRenderingContext2D::resetTransform()
 {
     SkCanvas* 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;
 
-    realizeSaves(c);
     // resetTransform() resolves the non-invertible CTM state.
     modifiableState().resetTransform();
     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.
 }
 
@@ skipping 76 matching lines @@
 bool CanvasRenderingContext2D::draw(const DrawFunc& drawFunc, const ContainsFunc& drawCoversClipBounds, const SkRect& bounds, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
 {
     if (!state().isTransformInvertible())
         return false;
 
     SkIRect clipBounds;
     if (!drawingCanvas() || !drawingCanvas()->getClipDeviceBounds(&clipBounds))
         return false;
 
     // If gradient size is zero, then paint nothing.
-    CanvasGradient* gradient = state().style(paintType)->canvasGradient();
-    if (gradient && gradient->gradient()->isZeroSize())
-        return false;
+    CanvasStyle* style = state().style(paintType);
+    if (style) {
+        CanvasGradient* gradient = style->canvasGradient();
+        if (gradient && gradient->gradient()->isZeroSize())
+            return false;
+    }
 
     if (isFullCanvasCompositeMode(state().globalComposite())) {
         fullCanvasCompositedDraw(drawFunc, paintType, imageType);
         didDraw(clipBounds);
     } else if (state().globalComposite() == SkXfermode::kSrc_Mode) {
         clearCanvas(); // takes care of checkOvewrdraw()
         const SkPaint* paint = state().getPaint(paintType, DrawForegroundOnly, imageType);
         drawFunc(paint);
         didDraw(clipBounds);
     } else {
         SkIRect dirtyRect;
         if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
             const SkPaint* paint = state().getPaint(paintType, DrawShadowAndForeground, imageType);
-            if (paintType == CanvasRenderingContext2DState::FillPaintType && drawCoversClipBounds(clipBounds))
+            if (paintType != CanvasRenderingContext2DState::StrokePaintType && drawCoversClipBounds(clipBounds))
                 checkOverdraw(bounds, paint, imageType, ClipFill);
             drawFunc(paint);
             didDraw(dirtyRect);
         }
     }
     return true;
 }
 
 static bool isPathExpensive(const Path& path)
 {
@@ skipping 128 matching lines @@
 void CanvasRenderingContext2D::clipInternal(const Path& path, const String& windingRuleString)
 {
     SkCanvas* c = drawingCanvas();
     if (!c) {
         return;
     }
     if (!state().isTransformInvertible()) {
         return;
     }
 
-    realizeSaves(c);
-
     SkPath skPath = path.skPath();
     skPath.setFillType(parseWinding(windingRuleString));
     modifiableState().clipPath(skPath, m_clipAntialiasing);
     c->clipPath(skPath, SkRegion::kIntersect_Op, m_clipAntialiasing == AntiAliased);
     if (ExpensiveCanvasHeuristicParameters::ComplexClipsAreExpensive && !skPath.isRect(0) && canvas()->hasImageBuffer()) {
         canvas()->buffer()->setHasExpensiveOp();
     }
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
@@ skipping 136 matching lines @@
             c->drawRect(rect, clearPaint);
             didDraw(dirtyRect);
         }
     }
 
     if (m_hitRegionManager) {
         m_hitRegionManager->removeHitRegionsInRect(rect, state().transform());
     }
 }
 
-void CanvasRenderingContext2D::applyShadow(ShadowMode shadowMode)
-{
-    GraphicsContext* c = drawingContext();
-    if (!c)
-        return;
-
-    if (state().shouldDrawShadows()) {
-        c->setShadow(state().shadowOffset(), state().shadowBlur(), state().shadowColor(),
-            DrawLooperBuilder::ShadowIgnoresTransforms, DrawLooperBuilder::ShadowRespectsAlpha, shadowMode);
-    } else {
-        c->clearShadow();
-    }
-}
-
 static inline FloatRect normalizeRect(const FloatRect& rect)
 {
     return FloatRect(std::min(rect.x(), rect.maxX()),
         std::min(rect.y(), rect.maxY()),
         std::max(rect.width(), -rect.width()),
         std::max(rect.height(), -rect.height()));
 }
 
 static inline void clipRectsToImageRect(const FloatRect& imageRect, FloatRect* srcRect, FloatRect* dstRect)
 {
@@ skipping 45 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);
     drawImage(imageSourceInternal, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
 }
 
-void CanvasRenderingContext2D::drawVideo(CanvasImageSource* imageSource, const FloatRect& srcRect, const FloatRect& dstRect)
+bool CanvasRenderingContext2D::shouldDrawImageAntialiased(const FloatRect& destRect) const
 {
-    HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
-    ASSERT(video);
+    if (!shouldAntialias())
+        return false;
     SkCanvas* c = drawingCanvas();
-    if (!c)
-        return;
-    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(drawingContext(), IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())));
-    // In case the paint propagated a queued context loss signal
-    if (drawingCanvas())
-        drawingCanvas()->restore();
+    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
+    // it is.
+    // FIXME: This queries the CTM while drawing, which is generally
+    // discouraged. Always drawing with AA can negatively impact performance
+    // though - that's why it's not always on.
+    SkScalar widthExpansion, heightExpansion;
+    if (ctm.getType() & SkMatrix::kAffine_Mask)
+        widthExpansion = ctm[SkMatrix::kMSkewY], heightExpansion = ctm[SkMatrix::kMSkewX];
+    else
+        widthExpansion = ctm[SkMatrix::kMScaleX], heightExpansion = ctm[SkMatrix::kMScaleY];
+    return destRect.width() * fabs(widthExpansion) < 1 || destRect.height() * fabs(heightExpansion) < 1;
 }
 
-void CanvasRenderingContext2D::drawImageOnContext(CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const SkPaint* paint)
+void CanvasRenderingContext2D::drawImageInternal(CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const SkPaint* paint)
 {
-    SkXfermode::Mode mode;
-    if (!SkXfermode::AsMode(paint->getXfermode(), &mode))
-        mode = SkXfermode::kSrcOver_Mode;
+    SkCanvas* c = drawingCanvas();
+    ASSERT(c);
 
-    RefPtr<SkImageFilter> imageFilter(paint->getImageFilter());
-    drawingContext()->setDropShadowImageFilter(imageFilter.release());
-    RefPtr<SkDrawLooper> drawLooper(paint->getLooper());
-    drawingContext()->setDrawLooper(drawLooper.release());
+    int initialSaveCount = c->getSaveCount();
+    SkPaint imagePaint = *paint;
+
+    if (paint->getImageFilter()) {
+        SkMatrix ctm = c->getTotalMatrix();
+        SkMatrix invCtm;
+        if (!ctm.invert(&invCtm)) {
+            ASSERT_NOT_REACHED(); // There is an earlier check for invertibility
+        }
+        c->save();
+        c->concat(invCtm);
+        SkRect bounds = dstRect;
+        ctm.mapRect(&bounds);
+        SkRect filteredBounds;
+        paint->getImageFilter()->computeFastBounds(bounds, &filteredBounds);
+        SkPaint layerPaint;
+        layerPaint.setXfermode(paint->getXfermode());
+        layerPaint.setImageFilter(paint->getImageFilter());
+        c->saveLayer(&filteredBounds, &layerPaint);
+        c->concat(ctm);
+        imagePaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+        imagePaint.setImageFilter(nullptr);
+    }
 
     if (!imageSource->isVideoElement()) {
-        drawingContext()->drawImage(image, dstRect, srcRect, mode);
+        // TODO: Find a way to pass SkCanvas::kBleed_DrawBitmapRectFlag
+        imagePaint.setAntiAlias(shouldDrawImageAntialiased(dstRect));
+        image->draw(c, imagePaint, dstRect, srcRect, DoNotRespectImageOrientation, Image::DoNotClampImageToSourceRect);
     } else {
-        SkXfermode::Mode oldMode = drawingContext()->compositeOperation();
-        drawingContext()->setCompositeOperation(mode);
-        drawVideo(imageSource, srcRect, dstRect);
-        // Must re-check drawingContext() in case drawVideo propagated a pending context loss signal
-        if (drawingContext())
-            drawingContext()->setCompositeOperation(oldMode);
+        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());
+        HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
+        video->paintCurrentFrame(c, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())), &imagePaint);
     }
+
+    c->restoreToCount(initialSaveCount);
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     if (!drawingCanvas())
         return;
 
     RefPtr<Image> image;
@@ skipping 32 matching lines @@
     // 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();
 
     draw(
         [this, &imageSource, &image, &srcRect, dstRect](const SkPaint* paint) // draw lambda
         {
-            if (drawingCanvas())
-                drawImageOnContext(imageSource, image.get(), srcRect, dstRect, paint);
+            drawImageInternal(imageSource, image.get(), srcRect, dstRect, paint);
         },
         [this, &dstRect](const SkIRect& clipBounds) // overdraw test lambda
         {
             return rectContainsTransformedRect(dstRect, clipBounds);
         },
         dstRect,
-        CanvasRenderingContext2DState::FillPaintType,
+        CanvasRenderingContext2DState::ImagePaintType,
         imageSource->isOpaque() ? CanvasRenderingContext2DState::OpaqueImage : CanvasRenderingContext2DState::NonOpaqueImage);
 
     validateStateStack();
 
     bool isExpensive = false;
 
     if (ExpensiveCanvasHeuristicParameters::SVGImageSourcesAreExpensive && image && image->isSVGImage())
         isExpensive = true;
 
     if (imageSource->elementSize().width() * imageSource->elementSize().height() > canvas()->width() * canvas()->height() * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio)
@@ skipping 125 matching lines @@
     canvas()->didDraw(SkRect::Make(dirtyRect));
 }
 
 SkCanvas* CanvasRenderingContext2D::drawingCanvas() const
 {
     if (isContextLost())
         return nullptr;
     return canvas()->drawingCanvas();
 }
 
-GraphicsContext* CanvasRenderingContext2D::drawingContext() const
-{
-    if (isContextLost())
-        return nullptr;
-    return canvas()->drawingContext();
-}
-
 ImageData* CanvasRenderingContext2D::createImageData(ImageData* imageData) const
 {
     return ImageData::create(imageData->size());
 }
 
 ImageData* CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionState& exceptionState) const
 {
     if (!sw || !sh) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));
         return nullptr;
@@ skipping 157 matching lines @@
 
     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
 
     // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
     // the "inherit" and "initial" values must be ignored.
     if (fontValue == "inherit" || fontValue == "initial")
         return;
 
     // The parse succeeded.
     String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves.
-    realizeSaves(nullptr);
     modifiableState().setUnparsedFont(newFontSafeCopy);
 
     // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
     // relative to the canvas.
     RefPtr<ComputedStyle> newStyle = ComputedStyle::create();
     canvas()->document().updateLayoutTreeIfNeeded();
     if (const ComputedStyle* computedStyle = canvas()->ensureComputedStyle()) {
         FontDescription elementFontDescription(computedStyle->fontDescription());
         // Reset the computed size to avoid inheriting the zoom factor from the <canvas> element.
         elementFontDescription.setComputedSize(elementFontDescription.specifiedSize());
@@ skipping 22 matching lines @@
     return textAlignName(state().textAlign());
 }
 
 void CanvasRenderingContext2D::setTextAlign(const String& s)
 {
     TextAlign align;
     if (!parseTextAlign(s, align))
         return;
     if (state().textAlign() == align)
         return;
-    realizeSaves(nullptr);
     modifiableState().setTextAlign(align);
 }
 
 String CanvasRenderingContext2D::textBaseline() const
 {
     return textBaselineName(state().textBaseline());
 }
 
 void CanvasRenderingContext2D::setTextBaseline(const String& s)
 {
     TextBaseline baseline;
     if (!parseTextBaseline(s, baseline))
         return;
     if (state().textBaseline() == baseline)
         return;
-    realizeSaves(nullptr);
     modifiableState().setTextBaseline(baseline);
 }
 
 static inline TextDirection toTextDirection(CanvasRenderingContext2DState::Direction direction, HTMLCanvasElement* canvas, const ComputedStyle** computedStyle = 0)
 {
     const ComputedStyle* style = (computedStyle || direction == CanvasRenderingContext2DState::DirectionInherit) ? canvas->ensureComputedStyle() : nullptr;
     if (computedStyle)
         *computedStyle = style;
     switch (direction) {
     case CanvasRenderingContext2DState::DirectionInherit:
@@ skipping 22 matching lines @@
     else if (directionString == rtl)
         direction = CanvasRenderingContext2DState::DirectionRTL;
     else if (directionString == ltr)
         direction = CanvasRenderingContext2DState::DirectionLTR;
     else
         return;
 
     if (state().direction() == direction)
         return;
 
-    realizeSaves(nullptr);
     modifiableState().setDirection(direction);
 }
 
 void CanvasRenderingContext2D::fillText(const String& text, float x, float y)
 {
     drawTextInternal(text, x, y, CanvasRenderingContext2DState::FillPaintType);
 }
 
 void CanvasRenderingContext2D::fillText(const String& text, float x, float y, float maxWidth)
 {
@@ skipping 153 matching lines @@
     if (state().lineJoin() == MiterJoin)
         delta *= state().miterLimit();
     else if (state().lineCap() == SquareCap)
         delta *= root2;
 
     rect.inflate(delta);
 }
 
 const Font& CanvasRenderingContext2D::accessFont()
 {
-    // This needs style to be up to date, but can't assert so because drawTextInternal
-    // can invalidate style before this is called (e.g. drawingContext invalidates style).
     if (!state().hasRealizedFont())
         setFont(state().unparsedFont());
     return state().font();
 }
 
 int CanvasRenderingContext2D::getFontBaseline(const FontMetrics& fontMetrics) const
 {
     switch (state().textBaseline()) {
     case TopTextBaseline:
         return fontMetrics.ascent();
@@ skipping 33 matching lines @@
 bool CanvasRenderingContext2D::imageSmoothingEnabled() const
 {
     return state().imageSmoothingEnabled();
 }
 
 void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)
 {
     if (enabled == state().imageSmoothingEnabled())
         return;
 
-    SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
     modifiableState().setImageSmoothingEnabled(enabled);
-    if (c)
-        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 29 matching lines @@
     if (path.isEmpty())
         return false;
     if (!element->isDescendantOf(canvas()))
         return false;
 
     return true;
 }
 
 void CanvasRenderingContext2D::drawFocusRing(const Path& path)
 {
-    GraphicsContext* c = drawingContext();
-    if (!c)
+    if (!drawingCanvas())
         return;
 
-    // These should match the style defined in html.css.
-    Color focusRingColor = LayoutTheme::theme().focusRingColor();
+    SkColor color = LayoutTheme::theme().focusRingColor().rgb();
     const int focusRingWidth = 5;
-    const int focusRingOutline = 0;
+
+    drawPlatformFocusRing(path.skPath(), drawingCanvas(), color, focusRingWidth);
 
     // We need to add focusRingWidth to dirtyRect.
     StrokeData strokeData;
     strokeData.setThickness(focusRingWidth);
 
     SkIRect dirtyRect;
     if (!computeDirtyRect(path.strokeBoundingRect(strokeData), &dirtyRect))
         return;
 
-    c->setAlphaAsFloat(1.0);
-    c->clearShadow();
-    c->setCompositeOperation(SkXfermode::kSrcOver_Mode);
-    c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
-    c->setAlphaAsFloat(state().globalAlpha());
-    c->setCompositeOperation(state().globalComposite());
-
-    validateStateStack();
     didDraw(dirtyRect);
 }
 
 void CanvasRenderingContext2D::updateFocusRingElementAccessibility(const Path& path, Element* element)
 {
     AXObjectCache* axObjectCache = element->document().existingAXObjectCache();
     LayoutBoxModelObject* lbmo = canvas()->layoutBoxModelObject();
     LayoutObject* renderer = canvas()->layoutObject();
     if (!axObjectCache || !lbmo || !renderer)
         return;
@@ skipping 138 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink