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

Source/platform/graphics/GraphicsContext.h

 /*
  * Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 91 matching lines @@
 #endif
 
     float strokeThickness() const { return immutableState()->strokeData().thickness(); }
     void setStrokeThickness(float thickness) { mutableState()->setStrokeThickness(thickness); }
 
     StrokeStyle strokeStyle() const { return immutableState()->strokeData().style(); }
     void setStrokeStyle(StrokeStyle style) { mutableState()->setStrokeStyle(style); }
 
     Color strokeColor() const { return immutableState()->strokeColor(); }
     void setStrokeColor(const Color& color) { mutableState()->setStrokeColor(color); }
-    SkColor effectiveStrokeColor() const { return immutableState()->effectiveStrokeColor(); }
 
     Pattern* strokePattern() const { return immutableState()->strokePattern(); }
     void setStrokePattern(PassRefPtr<Pattern>, float alpha = 1);
 
     Gradient* strokeGradient() const { return immutableState()->strokeGradient(); }
     void setStrokeGradient(PassRefPtr<Gradient>, float alpha = 1);
 
     void setLineCap(LineCap cap) { mutableState()->setLineCap(cap); }
     void setLineDash(const DashArray& dashes, float dashOffset) { mutableState()->setLineDash(dashes, dashOffset); }
     void setLineJoin(LineJoin join) { mutableState()->setLineJoin(join); }
     void setMiterLimit(float limit) { mutableState()->setMiterLimit(limit); }
 
     void setFillRule(WindRule fillRule) { mutableState()->setFillRule(fillRule); }
 
     Color fillColor() const { return immutableState()->fillColor(); }
     void setFillColor(const Color& color) { mutableState()->setFillColor(color); }
 
     void setFillPattern(PassRefPtr<Pattern>, float alpha = 1);
 
     void setFillGradient(PassRefPtr<Gradient>, float alpha = 1);
 
     SkDrawLooper* drawLooper() const { return immutableState()->drawLooper(); }
 
     SkMatrix getTotalMatrix() const;
 
     void setShouldAntialias(bool antialias) { mutableState()->setShouldAntialias(antialias); }
     bool shouldAntialias() const { return immutableState()->shouldAntialias(); }
 
-    // Disable the anti-aliasing optimization for scales/multiple-of-90-degrees
-    // rotations of thin ("hairline") images.
-    // Note: This will only be reliable when the device pixel scale/ratio is
-    // fixed (e.g. when drawing to context backed by an ImageBuffer).
-    void disableAntialiasingOptimizationForHairlineImages() { ASSERT(!isRecording()); m_antialiasHairlineImages = true; }
-    bool shouldAntialiasHairlineImages() const { return m_antialiasHairlineImages; }
-
-    void setShouldClampToSourceRect(bool clampToSourceRect) { mutableState()->setShouldClampToSourceRect(clampToSourceRect); }
-    bool shouldClampToSourceRect() const { return immutableState()->shouldClampToSourceRect(); }
-
     void setTextDrawingMode(TextDrawingModeFlags mode) { mutableState()->setTextDrawingMode(mode); }
     TextDrawingModeFlags textDrawingMode() const { return immutableState()->textDrawingMode(); }
 
-    void setAlphaAsFloat(float alpha) { mutableState()->setAlphaAsFloat(alpha);}
-    int getNormalizedAlpha() const
-    {
-        int alpha = immutableState()->alpha();
-        return alpha > 255 ? 255 : alpha;
-    }
-
     void setImageInterpolationQuality(InterpolationQuality quality) { mutableState()->setInterpolationQuality(quality); }
     InterpolationQuality imageInterpolationQuality() const { return immutableState()->interpolationQuality(); }
 
-    // Do not use these methods: they are deprecated/scheduled for removal.
-    void setCompositeOperation(SkXfermode::Mode);
-    SkXfermode::Mode compositeOperation() const;
-
     // Specify the device scale factor which may change the way document markers
     // and fonts are rendered.
     void setDeviceScaleFactor(float factor) { m_deviceScaleFactor = factor; }
     float deviceScaleFactor() const { return m_deviceScaleFactor; }
 
     // Returns if the context is a printing context instead of a display
     // context. Bitmap shouldn't be resampled when printing to keep the best
     // possible quality.
     bool printing() const { return m_printing; }
     void setPrinting(bool printing) { m_printing = printing; }
@@ skipping 41 matching lines @@
         SkXfermode::Mode = SkXfermode::kSrcOver_Mode, const IntSize& repeatSpacing = IntSize());
     void drawTiledImage(Image*, const IntRect& destRect, const IntRect& srcRect,
         const FloatSize& tileScaleFactor, Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,
         SkXfermode::Mode = SkXfermode::kSrcOver_Mode);
 
     void drawImageBuffer(ImageBuffer*, const FloatRect& destRect, const FloatRect* srcRect = 0, SkXfermode::Mode = SkXfermode::kSrcOver_Mode);
 
     // These methods write to the canvas.
     // Also drawLine(const IntPoint& point1, const IntPoint& point2) and fillRoundedRect
     void writePixels(const SkImageInfo&, const void* pixels, size_t rowBytes, int x, int y);
-    void drawBitmapRect(const SkBitmap&, const SkRect*, const SkRect&, const SkPaint* = 0);
     void drawOval(const SkRect&, const SkPaint&);
     void drawPath(const SkPath&, const SkPaint&);
     void drawRect(const SkRect&, const SkPaint&);
 
     void clip(const IntRect& rect) { clipRect(rect); }
     void clip(const FloatRect& rect) { clipRect(rect); }
     void clipRoundedRect(const FloatRoundedRect&, SkRegion::Op = SkRegion::kIntersect_Op);
     void clipOut(const IntRect& rect) { clipRect(rect, NotAntiAliased, SkRegion::kDifference_Op); }
     void clipOut(const FloatRect& rect) { clipRect(rect, NotAntiAliased, SkRegion::kDifference_Op); }
     void clipOut(const Path&);
@@ skipping 23 matching lines @@
 
     // Instead of being dispatched to the active canvas, draw commands following beginRecording()
     // are stored in a display list that can be replayed at a later time. Pass in the bounding
     // rectangle for the content in the list.
     void beginRecording(const FloatRect&, uint32_t = 0);
     PassRefPtr<const SkPicture> endRecording();
 
     void setShadow(const FloatSize& offset, float blur, const Color&,
         DrawLooperBuilder::ShadowTransformMode = DrawLooperBuilder::ShadowRespectsTransforms,
         DrawLooperBuilder::ShadowAlphaMode = DrawLooperBuilder::ShadowRespectsAlpha, ShadowMode = DrawShadowAndForeground);
-    void clearShadow() { clearDrawLooper(); clearDropShadowImageFilter(); }
-    void setDropShadowImageFilter(PassRefPtr<SkImageFilter>);
 
     // It is assumed that this draw looper is used only for shadows
     // (i.e. a draw looper is set if and only if there is a shadow).
     // The builder passed into this method will be destroyed.
     void setDrawLooper(PassOwnPtr<DrawLooperBuilder>);
-    void setDrawLooper(PassRefPtr<SkDrawLooper> looper) { mutableState()->setDrawLooper(looper); }
     void clearDrawLooper();
 
     void drawFocusRing(const Vector<IntRect>&, int width, int offset, const Color&);
     void drawFocusRing(const Path&, int width, int offset, const Color&);
 
     enum Edge {
         NoEdge = 0,
         TopEdge = 1 << 1,
         RightEdge = 1 << 2,
         BottomEdge = 1 << 3,
         LeftEdge = 1 << 4
     };
     typedef unsigned Edges;
     void drawInnerShadow(const FloatRoundedRect&, const Color& shadowColor, const IntSize shadowOffset, int shadowBlur, int shadowSpread, Edges clippedEdges = NoEdge);
 
+    const SkPaint& fillPaint() const { return immutableState()->fillPaint(); }
+
     // ---------- Transformation methods -----------------
     // Note that the getCTM method returns only the current transform from Blink's perspective,
     // which is not the final transform used to place content on screen. It cannot be relied upon
     // for testing where a point will appear on screen or how large it will be.
     AffineTransform getCTM() const;
     void concatCTM(const AffineTransform&);
     void setCTM(const AffineTransform&);
     void setMatrix(const SkMatrix&);
 
     void scale(float x, float y);
     void rotate(float angleInRadians);
     void translate(float x, float y);
     // ---------- End transformation methods -----------------
 
+    SkFilterQuality computeFilterQuality(Image*, const FloatRect& dest, const FloatRect& src) const;
+    bool shouldAntialiasImages() { return shouldAntialias() && !getTotalMatrix().rectStaysRect();}

[Stephen White, 2015/05/29 17:26:37]

Aside: not new to this code, but this feels like an optimization that should be
in Skia (or CC), rather than Blink. But perhaps I'm misunderstanding its
purpose.

+
     // URL drawing
     void setURLForRect(const KURL&, const IntRect&);
     void setURLFragmentForRect(const String& name, const IntRect&);
     void addURLTargetAtPoint(const String& name, const IntPoint&);
 
     static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);
 
-    // This method can potentially push saves onto the canvas. It returns the initial save count,
-    // and should be balanced with a call to context->canvas()->restoreToCount(initialSaveCount).
-    WARN_UNUSED_RETURN int preparePaintForDrawRectToRect(
-        SkPaint*,
-        const SkRect& srcRect,
-        const SkRect& destRect,
-        SkXfermode::Mode,
-        bool isBitmapWithAlpha,
-        bool isLazyDecoded = false,
-        bool isDataComplete = true) const;
-
     static int focusRingOutsetExtent(int offset, int width)
     {
         return focusRingOutset(offset) + (focusRingWidth(width) + 1) / 2;
     }
 
     // public decl needed for OwnPtr wrapper.
     class RecordingState;
 
 #if ENABLE(ASSERT)
     void setInDrawingRecorder(bool);
@@ skipping 27 matching lines @@
     static SkPMColor antiColors1(int);
     static SkPMColor antiColors2(int);
     static void draw1xMarker(SkBitmap*, int);
     static void draw2xMarker(SkBitmap*, int);
 #endif
 
     void saveLayer(const SkRect* bounds, const SkPaint*);
     void restoreLayer();
 
     // Helpers for drawing a focus ring (drawFocusRing)
-    float prepareFocusRingPaint(SkPaint&, const Color&, int width) const;
     void drawFocusRingPath(const SkPath&, const Color&, int width);
     void drawFocusRingRect(const SkRect&, const Color&, int width);
 
     // SkCanvas wrappers.
     void clipRRect(const SkRRect&, AntiAliasingMode = NotAntiAliased, SkRegion::Op = SkRegion::kIntersect_Op);
     void concat(const SkMatrix&);
     void drawRRect(const SkRRect&, const SkPaint&);
 
-    void clearDropShadowImageFilter();
-    SkImageFilter* dropShadowImageFilter() const { return immutableState()->dropShadowImageFilter(); }
-
     // Apply deferred paint state saves
     void realizePaintSave()
     {
         if (contextDisabled())
             return;
 
         if (m_paintState->saveCount()) {
             m_paintState->decrementSaveCount();
             ++m_paintStateIndex;
             if (m_paintStateStack.size() == m_paintStateIndex) {
@@ skipping 39 matching lines @@
     bool m_disableDestructionChecks;
     bool m_inDrawingRecorder;
 #endif
 
     const DisabledMode m_disabledState;
 
     float m_deviceScaleFactor;
 
     unsigned m_accelerated : 1;
     unsigned m_printing : 1;
-    unsigned m_antialiasHairlineImages : 1;
 };
 
 } // namespace blink
 
 #endif // GraphicsContext_h