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

Source/platform/graphics/Image.h

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 15 matching lines @@
 
 #ifndef Image_h
 #define Image_h
 
 #include "platform/PlatformExport.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/graphics/GraphicsTypes.h"
 #include "platform/graphics/ImageAnimationPolicy.h"
 #include "platform/graphics/ImageOrientation.h"
-#include "third_party/skia/include/core/SkXfermode.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/RetainPtr.h"
 #include "wtf/text/WTFString.h"
 
 class SkBitmap;
 class SkImage;
 
 namespace blink {
 
 class FloatPoint;
 class FloatRect;
 class FloatSize;
 class GraphicsContext;
 class Length;
 class SharedBuffer;
+class Image;
 
 // This class gets notified when an image creates or destroys decoded frames and when it advances animation frames.
 class ImageObserver;
 
+class ImageFilterQualityHelper {
+public:
+    virtual SkFilterQuality computeFilterQuality(Image*, const FloatRect& dest, const FloatRect& src) const = 0;
+    virtual bool shouldClampToSourceRect() const = 0;
+    virtual bool shouldDrawAntiAliased(const FloatRect&destRect) const = 0;
+    virtual ~ImageFilterQualityHelper() { }
+};
+
 class PLATFORM_EXPORT Image : public RefCounted<Image> {
     friend class GeneratedImage;
     friend class CrossfadeGeneratedImage;
     friend class GradientGeneratedImage;
     friend class GraphicsContext;
 
 public:
     virtual ~Image();
 
     static PassRefPtr<Image> loadPlatformResource(const char* name);
     static bool supportsType(const String&);
 
     virtual bool isSVGImage() const { return false; }
     virtual bool isBitmapImage() const { return false; }
+    virtual bool isLazyDecodedBitmap() { return false; }
+    virtual bool isImmutableBitmap() { return false; }
     virtual bool currentFrameKnownToBeOpaque() = 0;
 
     virtual PassRefPtr<SkImage> skImage();
 
     // Derived classes should override this if they can assure that the current
     // image frame contains only resources from its own security origin.
     virtual bool currentFrameHasSingleSecurityOrigin() const { return false; }
 
     static Image* nullImage();
     bool isNull() const { return size().isEmpty(); }
@@ skipping 40 matching lines @@
     // Typically the ImageResource that owns us.
     ImageObserver* imageObserver() const { return m_imageObserver; }
     void setImageObserver(ImageObserver* observer) { m_imageObserver = observer; }
 
     enum TileRule { StretchTile, RoundTile, SpaceTile, RepeatTile };
 
     virtual bool bitmapForCurrentFrame(SkBitmap*) WARN_UNUSED_RETURN;
 
     virtual PassRefPtr<Image> imageForDefaultFrame();
 
     virtual void drawPattern(GraphicsContext*, const FloatRect&,

[Stephen White, 2015/05/27 15:46:02]

Perhaps at some point we could circle back and change the other GraphicsContext
references here to take an SkCanvas. Maybe it's just my OCD, but it feels weird
having a mix of the two in Image's public API.

[Justin Novosad, 2015/05/27 20:08:16]

Yeah, it is not required to enact the separation, but it would feel cleaner, I
agree. created crbug.com/492794

         const FloatSize&, const FloatPoint& phase, SkXfermode::Mode,
         const FloatRect&, const IntSize& repeatSpacing = IntSize());
 
 #if ENABLE(ASSERT)
     virtual bool notSolidColor() { return true; }
 #endif
 
+    virtual void draw(SkCanvas*, const SkPaint&, const FloatRect& dstRect, const FloatRect& srcRect, RespectImageOrientationEnum, const ImageFilterQualityHelper*) = 0;

[Stephen White, 2015/05/27 15:46:02]

To be honest, I'm not a fan of this callback object. I'd really prefer if we
could pass in some dumb state (SkPaint plus additional struct or params?). Maybe
I'm being optimistic, but it seems strange that we can't infer the desired
behaviour from passed-in state combined with specialization in the draw()
virtual on each Image subclass.

+
 protected:
     Image(ImageObserver* = 0);
 
     static void fillWithSolidColor(GraphicsContext*, const FloatRect& dstRect, const Color&, SkXfermode::Mode);
     static FloatRect adjustForNegativeSize(const FloatRect&); // A helper method for translating negative width and height values.
 
-    virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, SkXfermode::Mode, RespectImageOrientationEnum) = 0;
     void drawTiled(GraphicsContext*, const FloatRect& dstRect, const FloatPoint& srcPoint, const FloatSize& tileSize,
         SkXfermode::Mode, const IntSize& repeatSpacing);
     void drawTiled(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, const FloatSize& tileScaleFactor, TileRule hRule, TileRule vRule, SkXfermode::Mode);
 
     // Supporting tiled drawing
     virtual bool mayFillWithSolidColor() { return false; }
     virtual Color solidColor() const { return Color(); }
 
 private:
     RefPtr<SharedBuffer> m_encodedImageData;
     ImageObserver* m_imageObserver;
 };
 
 #define DEFINE_IMAGE_TYPE_CASTS(typeName) \
     DEFINE_TYPE_CASTS(typeName, Image, image, image->is##typeName(), image.is##typeName())
 
 } // namespace blink
 
 #endif