Move overdraw tracking code from GraphicsContext to CanvasRenderingContext2D

Source/core/html/canvas/CanvasRenderingContext2D.h

 /*
  * Copyright (C) 2006, 2007, 2009, 2010, 2011, 2012 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 145 matching lines @@
     void scrollPathIntoView();
     void scrollPathIntoView(Path2D*);
 
     void clearRect(float x, float y, float width, float height);
     void fillRect(float x, float y, float width, float height);
     void strokeRect(float x, float y, float width, float height);
 
     void drawImage(const CanvasImageSourceUnion&, float x, float y, ExceptionState&);
     void drawImage(const CanvasImageSourceUnion&, float x, float y, float width, float height, ExceptionState&);
     void drawImage(const CanvasImageSourceUnion&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionState&);
+    void drawImage(CanvasImageSource*, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionState&);

[dshwang, 2015/02/11 08:37:52]

why does it become public? I guess it's for unittests, but existing public
drawImage methods might have enough coverage.

[Justin Novosad, 2015/02/11 18:59:54]

Yes it is for testing purposes. The problem is that I can't wrap a
FakeCanvasImageSource into a CanvasImageSourceUnion without exposing
FakeCanvasImageSource in places where it should not be. So I needed an entry
point that takes a CanvasImageSoure*.  It's either this or I make the test class
a friend of CRC2D. I am actually not sure which is preferable.

 
     PassRefPtrWillBeRawPtr<CanvasGradient> createLinearGradient(float x0, float y0, float x1, float y1);
     PassRefPtrWillBeRawPtr<CanvasGradient> createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState&);
     PassRefPtrWillBeRawPtr<CanvasPattern> createPattern(const CanvasImageSourceUnion&, const String& repetitionType, ExceptionState&);
 
     PassRefPtrWillBeRawPtr<ImageData> createImageData(PassRefPtrWillBeRawPtr<ImageData>) const;
     PassRefPtrWillBeRawPtr<ImageData> createImageData(float width, float height, ExceptionState&) const;
     PassRefPtrWillBeRawPtr<ImageData> getImageData(float sx, float sy, float sw, float sh, ExceptionState&) const;
     void putImageData(ImageData*, float dx, float dy);
     void putImageData(ImageData*, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
@@ skipping 92 matching lines @@
         // Text state.
         TextAlign m_textAlign;
         TextBaseline m_textBaseline;
         Direction m_direction;
 
         String m_unparsedFont;
         Font m_font;
         bool m_realizedFont;
 
         bool m_hasClip;
+        bool m_hasComplexClip;
 
         ClipList m_clipList;
     };
 
     CanvasRenderingContext2D(HTMLCanvasElement*, const CanvasContextCreationAttributes& attrs, Document&);
 
     State& modifiableState() { ASSERT(!state().m_unrealizedSaveCount); return *m_stateStack.last(); }
     const State& state() const { return *m_stateStack.last(); }
 
     void applyLineDash() const;
@@ skipping 11 matching lines @@
 
     GraphicsContext* drawingContext() const; // Deprecated: use drawingCanvas
     SkCanvas* drawingCanvas() const;
 
     void unwindStateStack();
     void realizeSaves(SkCanvas*);
 
     void applyStrokePattern();
     void applyFillPattern();
 
-    void drawImageInternal(CanvasImageSource*, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionState&);
-
     void fillInternal(const Path&, const String& windingRuleString);
     void strokeInternal(const Path&);
     void clipInternal(const Path&, const String& windingRuleString);
 
     bool isPointInPathInternal(const Path&, const float x, const float y, const String& windingRuleString);
     bool isPointInStrokeInternal(const Path&, const float x, const float y);
 
     void scrollPathIntoViewInternal(const Path&);
 
     void drawTextInternal(const String& text, float x, float y, bool fill, float maxWidth = 0, bool useMaxWidth = false);
 
     const Font& accessFont();
     int getFontBaseline(const FontMetrics&) const;
 
     void clearCanvas();
     bool rectContainsTransformedRect(const FloatRect&, const FloatRect&) const;
 
     void inflateStrokeRect(FloatRect&) const;
 
     void fullCanvasCompositedDraw(PassOwnPtr<Closure> draw);
 
     void drawFocusIfNeededInternal(const Path&, Element*);
     bool focusRingCallIsValid(const Path&, Element*);
     void drawFocusRing(const Path&);
 
     bool hasClip() { return state().m_hasClip; }
 
     void validateStateStack();
 
+    enum DrawType {
+        ClipFill, // Fill that is already known to cover the current clip
+        UntransformedUnclippedFill
+    };
+
+    enum ImageType {
+        NoImage,
+        OpaqueImage,
+        NonOpaqueImage
+    };
+
+    void checkOverdraw(const SkRect&, const SkPaint*, ImageType, DrawType);
+
     virtual bool is2d() const override { return true; }
     virtual bool isAccelerated() const override;
     virtual bool hasAlpha() const override { return m_hasAlpha; }
     virtual void setIsHidden(bool) override;
 
     virtual bool isTransformInvertible() const override { return state().m_invertibleCTM; }
 
     virtual WebLayer* platformLayer() const override;
     TextDirection toTextDirection(Direction, RenderStyle** computedStyle = nullptr) const;
 
@@ skipping 10 matching lines @@
     Timer<CanvasRenderingContext2D> m_dispatchContextLostEventTimer;
     Timer<CanvasRenderingContext2D> m_dispatchContextRestoredEventTimer;
     Timer<CanvasRenderingContext2D> m_tryRestoreContextEventTimer;
 };
 
 DEFINE_TYPE_CASTS(CanvasRenderingContext2D, CanvasRenderingContext, context, context->is2d(), context.is2d());
 
 } // namespace blink
 
 #endif // CanvasRenderingContext2D_h