Move ImageBuffer:clip() into GraphicsContextCG
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsContext.h
index 3cc0278..c83f408 100644 (file)
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 #include "ColorSpace.h"
 #include "DashArray.h"
 #include "FloatRect.h"
-#include "Font.h"
+#include "FontCascade.h"
 #include "Gradient.h"
+#include "GraphicsTypes.h"
 #include "Image.h"
 #include "ImageOrientation.h"
 #include "Path.h"
 #include "Pattern.h"
 #include <wtf/Noncopyable.h>
-#include <wtf/PassOwnPtr.h>
 
 #if USE(CG)
 typedef struct CGContext PlatformGraphicsContext;
@@ -65,7 +65,7 @@ namespace WebCore {
 
 #if USE(WINGDI)
     class SharedBitmap;
-    class SimpleFontData;
+    class Font;
     class GlyphBuffer;
 #endif
 
@@ -74,7 +74,6 @@ namespace WebCore {
     const int cMisspellingLinePatternGapWidth = 1;
 
     class AffineTransform;
-    class DrawingBuffer;
     class FloatRoundedRect;
     class Gradient;
     class GraphicsContextPlatformPrivate;
@@ -85,9 +84,6 @@ namespace WebCore {
     class GraphicsContext3D;
     class TextRun;
     class TransformationMatrix;
-#if PLATFORM(IOS)
-    struct BidiStatus;
-#endif
 
     enum TextDrawingMode {
         TextModeFill = 1 << 0,
@@ -117,24 +113,9 @@ namespace WebCore {
 
     struct GraphicsContextState {
         GraphicsContextState()
-            : strokeThickness(0)
-            , shadowBlur(0)
-            , textDrawingMode(TextModeFill)
-            , strokeColor(Color::black)
-            , fillColor(Color::black)
-            , strokeStyle(SolidStroke)
-            , fillRule(RULE_NONZERO)
-            , strokeColorSpace(ColorSpaceDeviceRGB)
-            , fillColorSpace(ColorSpaceDeviceRGB)
-            , shadowColorSpace(ColorSpaceDeviceRGB)
-            , compositeOperator(CompositeSourceOver)
-            , blendMode(BlendModeNormal)
-#if PLATFORM(IOS)
-            , emojiDrawingEnabled(true)
-            , shouldUseContextColors(true)
-#endif
-            , shouldAntialias(true)
+            : shouldAntialias(true)
             , shouldSmoothFonts(true)
+            , antialiasedFontDilationEnabled(true)
             , shouldSubpixelQuantizeFonts(true)
             , paintingDisabled(false)
             , shadowsIgnoreTransforms(false)
@@ -155,31 +136,29 @@ namespace WebCore {
 
         FloatSize shadowOffset;
 
-        float strokeThickness;
-        float shadowBlur;
+        float strokeThickness { 0 };
+        float shadowBlur { 0 };
 
-        TextDrawingModeFlags textDrawingMode;
+        TextDrawingModeFlags textDrawingMode { TextModeFill };
 
-        Color strokeColor;
-        Color fillColor;
+        Color strokeColor { Color::black };
+        Color fillColor { Color::black };
         Color shadowColor;
 
-        StrokeStyle strokeStyle;
-        WindRule fillRule;
+        StrokeStyle strokeStyle { SolidStroke };
+        WindRule fillRule { RULE_NONZERO };
 
-        ColorSpace strokeColorSpace;
-        ColorSpace fillColorSpace;
-        ColorSpace shadowColorSpace;
+        ColorSpace strokeColorSpace { ColorSpaceDeviceRGB };
+        ColorSpace fillColorSpace { ColorSpaceDeviceRGB };
+        ColorSpace shadowColorSpace { ColorSpaceDeviceRGB };
 
-        CompositeOperator compositeOperator;
-        BlendMode blendMode;
+        float alpha { 1 };
+        CompositeOperator compositeOperator { CompositeSourceOver };
+        BlendMode blendMode { BlendModeNormal };
 
-#if PLATFORM(IOS)
-        bool emojiDrawingEnabled : 1;
-        bool shouldUseContextColors : 1;
-#endif
         bool shouldAntialias : 1;
         bool shouldSmoothFonts : 1;
+        bool antialiasedFontDilationEnabled : 1;
         bool shouldSubpixelQuantizeFonts : 1;
         bool paintingDisabled : 1;
         bool shadowsIgnoreTransforms : 1;
@@ -189,175 +168,184 @@ namespace WebCore {
         bool drawLuminanceMask : 1;
     };
 
-#if PLATFORM(IOS)
-    void setStrokeAndFillColor(PlatformGraphicsContext*, CGColorRef);
-#endif
+    struct ImagePaintingOptions {
+        ImagePaintingOptions(CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), bool useLowQualityScale = false)
+            : m_compositeOperator(compositeOperator)
+            , m_blendMode(blendMode)
+            , m_orientationDescription(orientationDescription)
+            , m_useLowQualityScale(useLowQualityScale)
+        {
+        }
+
+        ImagePaintingOptions(ImageOrientationDescription orientationDescription, bool useLowQualityScale = false, CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal)
+            : m_compositeOperator(compositeOperator)
+            , m_blendMode(blendMode)
+            , m_orientationDescription(orientationDescription)
+            , m_useLowQualityScale(useLowQualityScale)
+        {
+        }
+
+        ImagePaintingOptions(bool useLowQualityScale, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal)
+            : m_compositeOperator(compositeOperator)
+            , m_blendMode(blendMode)
+            , m_orientationDescription(orientationDescription)
+            , m_useLowQualityScale(useLowQualityScale)
+        {
+        }
+
+        CompositeOperator m_compositeOperator;
+        BlendMode m_blendMode;
+        ImageOrientationDescription m_orientationDescription;
+        bool m_useLowQualityScale;
+    };
 
     class GraphicsContext {
         WTF_MAKE_NONCOPYABLE(GraphicsContext); WTF_MAKE_FAST_ALLOCATED;
     public:
-#if !PLATFORM(IOS)
-        GraphicsContext(PlatformGraphicsContext*);
-#else
-        GraphicsContext(PlatformGraphicsContext*, bool shouldUseContextColors = true);
-#endif
-        ~GraphicsContext();
+        WEBCORE_EXPORT GraphicsContext(PlatformGraphicsContext*);
+        WEBCORE_EXPORT ~GraphicsContext();
 
-        PlatformGraphicsContext* platformContext() const;
+        WEBCORE_EXPORT PlatformGraphicsContext* platformContext() const;
 
-        float strokeThickness() const;
         void setStrokeThickness(float);
-        StrokeStyle strokeStyle() const;
+        float strokeThickness() const { return m_state.strokeThickness; }
+
         void setStrokeStyle(StrokeStyle);
-        Color strokeColor() const;
-        ColorSpace strokeColorSpace() const;
-        void setStrokeColor(const Color&, ColorSpace);
+        StrokeStyle strokeStyle() const { return m_state.strokeStyle; }
+
+        WEBCORE_EXPORT void setStrokeColor(const Color&, ColorSpace);
+        Color strokeColor() const { return m_state.strokeColor; }
+        ColorSpace strokeColorSpace() const { return m_state.strokeColorSpace; }
 
-        void setStrokePattern(PassRefPtr<Pattern>);
-        Pattern* strokePattern() const;
+        void setStrokePattern(Ref<Pattern>&&);
+        Pattern* strokePattern() const { return m_state.strokePattern.get(); }
 
-        void setStrokeGradient(PassRefPtr<Gradient>);
-        Gradient* strokeGradient() const;
+        void setStrokeGradient(Ref<Gradient>&&);
+        Gradient* strokeGradient() const { return m_state.strokeGradient.get(); }
 
-        WindRule fillRule() const;
-        void setFillRule(WindRule);
-        Color fillColor() const;
-        ColorSpace fillColorSpace() const;
-        void setFillColor(const Color&, ColorSpace);
+        void setFillRule(WindRule fillRule) { m_state.fillRule = fillRule; }
+        WindRule fillRule() const { return m_state.fillRule; }
+    
+        WEBCORE_EXPORT void setFillColor(const Color&, ColorSpace);
+        Color fillColor() const { return m_state.fillColor; }
+        ColorSpace fillColorSpace() const { return m_state.fillColorSpace; }
 
-        void setFillPattern(PassRefPtr<Pattern>);
-        Pattern* fillPattern() const;
+        void setFillPattern(Ref<Pattern>&&);
+        Pattern* fillPattern() const { return m_state.fillPattern.get(); }
 
-        void setFillGradient(PassRefPtr<Gradient>);
-        Gradient* fillGradient() const;
+        WEBCORE_EXPORT void setFillGradient(Ref<Gradient>&&);
+        Gradient* fillGradient() const { return m_state.fillGradient.get(); }
 
-        void setShadowsIgnoreTransforms(bool);
-        bool shadowsIgnoreTransforms() const;
+        void setShadowsIgnoreTransforms(bool shadowsIgnoreTransforms) { m_state.shadowsIgnoreTransforms = shadowsIgnoreTransforms; }
+        bool shadowsIgnoreTransforms() const { return m_state.shadowsIgnoreTransforms; }
 
-        void setShouldAntialias(bool);
-        bool shouldAntialias() const;
+        WEBCORE_EXPORT void setShouldAntialias(bool);
+        bool shouldAntialias() const { return m_state.shouldAntialias; }
 
-        void setShouldSmoothFonts(bool);
-        bool shouldSmoothFonts() const;
+        WEBCORE_EXPORT void setAntialiasedFontDilationEnabled(bool);
+        bool antialiasedFontDilationEnabled() const { return m_state.antialiasedFontDilationEnabled; }
+
+        WEBCORE_EXPORT void setShouldSmoothFonts(bool);
+        bool shouldSmoothFonts() const { return m_state.shouldSmoothFonts; }
 
         // Normally CG enables subpixel-quantization because it improves the performance of aligning glyphs.
         // In some cases we have to disable to to ensure a high-quality output of the glyphs.
-        void setShouldSubpixelQuantizeFonts(bool);
-        bool shouldSubpixelQuantizeFonts() const;
+        void setShouldSubpixelQuantizeFonts(bool shouldSubpixelQuantizeFonts) { m_state.shouldSubpixelQuantizeFonts = shouldSubpixelQuantizeFonts; }
+        bool shouldSubpixelQuantizeFonts() const { return m_state.shouldSubpixelQuantizeFonts; }
 
-        const GraphicsContextState& state() const;
+        const GraphicsContextState& state() const { return m_state; }
 
 #if USE(CG)
         void applyStrokePattern();
         void applyFillPattern();
         void drawPath(const Path&);
 
-        void drawNativeImage(PassNativeImagePtr, const FloatSize& selfSize, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, float scale = 1, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, ImageOrientation = DefaultImageOrientation);
+        WEBCORE_EXPORT void drawNativeImage(PassNativeImagePtr, const FloatSize& selfSize, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, ImageOrientation = DefaultImageOrientation);
+
+        void clipToNativeImage(PassNativeImagePtr, const FloatRect& destRect, const FloatSize& bufferSize);
 
         // Allow font smoothing (LCD antialiasing). Not part of the graphics state.
         void setAllowsFontSmoothing(bool);
         
-        void setIsCALayerContext(bool);
+        WEBCORE_EXPORT void setIsCALayerContext(bool);
         bool isCALayerContext() const;
 
-        void setIsAcceleratedContext(bool);
+        WEBCORE_EXPORT void setIsAcceleratedContext(bool);
 #endif
         bool isAcceleratedContext() const;
+        RenderingMode renderingMode() const { return isAcceleratedContext() ? Accelerated : Unaccelerated; }
 
-        void save();
-        void restore();
+        WEBCORE_EXPORT void save();
+        WEBCORE_EXPORT void restore();
 
         // These draw methods will do both stroking and filling.
         // FIXME: ...except drawRect(), which fills properly but always strokes
         // using a 1-pixel stroke inset from the rect borders (of the correct
         // stroke color).
-        void drawRect(const FloatRect&);
+        void drawRect(const FloatRect&, float borderThickness = 1);
         void drawLine(const FloatPoint&, const FloatPoint&);
 
 #if PLATFORM(IOS)
         void drawJoinedLines(CGPoint points[], unsigned count, bool antialias, CGLineCap = kCGLineCapButt);
 #endif
 
-        void drawEllipse(const IntRect&);
-#if PLATFORM(IOS)
         void drawEllipse(const FloatRect&);
         void drawRaisedEllipse(const FloatRect&, const Color& ellipseColor, ColorSpace ellipseColorSpace, const Color& shadowColor, ColorSpace shadowColorSpace);
-#endif
         void drawConvexPolygon(size_t numPoints, const FloatPoint*, bool shouldAntialias = false);
 
-        void fillPath(const Path&);
+        WEBCORE_EXPORT void fillPath(const Path&);
         void strokePath(const Path&);
 
         void fillEllipse(const FloatRect&);
         void strokeEllipse(const FloatRect&);
 
-        void fillRect(const FloatRect&);
-        void fillRect(const FloatRect&, const Color&, ColorSpace);
+        WEBCORE_EXPORT void fillRect(const FloatRect&);
+        WEBCORE_EXPORT void fillRect(const FloatRect&, const Color&, ColorSpace);
         void fillRect(const FloatRect&, Gradient&);
         void fillRect(const FloatRect&, const Color&, ColorSpace, CompositeOperator, BlendMode = BlendModeNormal);
         void fillRoundedRect(const FloatRoundedRect&, const Color&, ColorSpace, BlendMode = BlendModeNormal);
         void fillRectWithRoundedHole(const FloatRect&, const FloatRoundedRect& roundedHoleRect, const Color&, ColorSpace);
 
-        void clearRect(const FloatRect&);
+        WEBCORE_EXPORT void clearRect(const FloatRect&);
 
-        void strokeRect(const FloatRect&, float lineWidth);
+        WEBCORE_EXPORT void strokeRect(const FloatRect&, float lineWidth);
 
-        void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver, ImageOrientationDescription = ImageOrientationDescription());
-        void drawImage(Image*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, ImageOrientationDescription = ImageOrientationDescription(), bool useLowQualityScale = false);
-        void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, ImageOrientationDescription = ImageOrientationDescription());
-        void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect);
-        void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, ImageOrientationDescription = ImageOrientationDescription(), bool useLowQualityScale = false);
-        void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientationDescription = ImageOrientationDescription(), bool useLowQualityScale = false);
-        
-        void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize,
-            CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false, BlendMode = BlendModeNormal);
-        void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect,
-                            const FloatSize& tileScaleFactor, Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,
-                            CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
-
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal);
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, bool useLowQualityScale = false);
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal);
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, bool useLowQualityScale = false);
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const FloatRect& destRect);
-        void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, bool useLowQualityScale = false);
-
-        void setImageInterpolationQuality(InterpolationQuality);
+        WEBCORE_EXPORT void drawImage(Image&, ColorSpace, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
+        WEBCORE_EXPORT void drawImage(Image&, ColorSpace, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
+        void drawImage(Image&, ColorSpace, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
+
+        void drawTiledImage(Image&, ColorSpace, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& = ImagePaintingOptions());
+        void drawTiledImage(Image&, ColorSpace, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor,
+            Image::TileRule, Image::TileRule, const ImagePaintingOptions& = ImagePaintingOptions());
+
+        WEBCORE_EXPORT void drawImageBuffer(ImageBuffer&, ColorSpace, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
+        void drawImageBuffer(ImageBuffer&, ColorSpace, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
+        void drawImageBuffer(ImageBuffer&, ColorSpace, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
+
+        void drawPattern(Image&, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, ColorSpace, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
+
+        WEBCORE_EXPORT void setImageInterpolationQuality(InterpolationQuality);
         InterpolationQuality imageInterpolationQuality() const;
 
-        void clip(const IntRect&);
-        void clip(const FloatRect&);
+        WEBCORE_EXPORT void clip(const IntRect&);
+        WEBCORE_EXPORT void clip(const FloatRect&);
         void clipRoundedRect(const FloatRoundedRect&);
 
         void clipOut(const FloatRect&);
         void clipOutRoundedRect(const FloatRoundedRect&);
         void clipPath(const Path&, WindRule);
         void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias = true);
-        void clipToImageBuffer(ImageBuffer*, const FloatRect&);
+        void clipToImageBuffer(ImageBuffer&, const FloatRect&);
         
         IntRect clipBounds() const;
 
-        TextDrawingModeFlags textDrawingMode() const;
         void setTextDrawingMode(TextDrawingModeFlags);
+        TextDrawingModeFlags textDrawingMode() const { return m_state.textDrawingMode; }
 
-#if PLATFORM(IOS)
-        bool emojiDrawingEnabled();
-        void setEmojiDrawingEnabled(bool);
-#endif
-        
-#if !PLATFORM(IOS)
-        void drawText(const Font&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
-#else
-        float drawText(const Font&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
-#endif
-        void drawGlyphs(const Font&, const SimpleFontData&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
-        void drawEmphasisMarks(const Font&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
-#if !PLATFORM(IOS)
-        void drawBidiText(const Font&, const TextRun&, const FloatPoint&, Font::CustomFontNotReadyAction = Font::DoNotPaintIfFontNotReady);
-#else
-        float drawBidiText(const Font&, const TextRun&, const FloatPoint&, Font::CustomFontNotReadyAction = Font::DoNotPaintIfFontNotReady, BidiStatus* = 0, int length = -1);
-#endif
-        void drawHighlightForText(const Font&, const TextRun&, const FloatPoint&, int h, const Color& backgroundColor, ColorSpace, int from = 0, int to = -1);
+        float drawText(const FontCascade&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
+        void drawGlyphs(const FontCascade&, const Font&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
+        void drawEmphasisMarks(const FontCascade&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
+        void drawBidiText(const FontCascade&, const TextRun&, const FloatPoint&, FontCascade::CustomFontNotReadyAction = FontCascade::DoNotPaintIfFontNotReady);
 
         enum RoundingMode {
             RoundAllSides,
@@ -366,7 +354,7 @@ namespace WebCore {
         FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);
 
         FloatRect computeLineBoundsForText(const FloatPoint&, float width, bool printing);
-        void drawLineForText(const FloatPoint&, float width, bool printing, bool doubleLines = false);
+        WEBCORE_EXPORT void drawLineForText(const FloatPoint&, float width, bool printing, bool doubleLines = false);
         void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines = false);
         enum DocumentMarkerLineStyle {
 #if PLATFORM(IOS)
@@ -380,32 +368,37 @@ namespace WebCore {
         static void updateDocumentMarkerResources();
         void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle);
 
-        bool paintingDisabled() const;
-        void setPaintingDisabled(bool);
+        void setPaintingDisabled(bool paintingDisabled) { m_state.paintingDisabled = paintingDisabled; }
+        bool paintingDisabled() const { return m_state.paintingDisabled; }
 
-        bool updatingControlTints() const;
         void setUpdatingControlTints(bool);
+        bool updatingControlTints() const { return m_updatingControlTints; }
 
-        void beginTransparencyLayer(float opacity);
-        void endTransparencyLayer();
-        bool isInTransparencyLayer() const;
+        WEBCORE_EXPORT void beginTransparencyLayer(float opacity);
+        WEBCORE_EXPORT void endTransparencyLayer();
+        bool isInTransparencyLayer() const { return (m_transparencyCount > 0) && supportsTransparencyLayers(); }
 
-        bool hasShadow() const;
-        void setShadow(const FloatSize&, float blur, const Color&, ColorSpace);
+        WEBCORE_EXPORT void setShadow(const FloatSize&, float blur, const Color&, ColorSpace);
         // Legacy shadow blur radius is used for canvas, and -webkit-box-shadow.
         // It has different treatment of radii > 8px.
         void setLegacyShadow(const FloatSize&, float blur, const Color&, ColorSpace);
 
+        WEBCORE_EXPORT void clearShadow();
         bool getShadow(FloatSize&, float&, Color&, ColorSpace&) const;
-        void clearShadow();
 
-        bool hasBlurredShadow() const;
+        bool hasVisibleShadow() const { return m_state.shadowColor.isValid() && m_state.shadowColor.alpha(); }
+        bool hasShadow() const { return hasVisibleShadow() && (m_state.shadowBlur || m_state.shadowOffset.width() || m_state.shadowOffset.height()); }
+        bool hasBlurredShadow() const { return hasVisibleShadow() && m_state.shadowBlur; }
+
 #if USE(CAIRO)
         bool mustUseShadowBlur() const;
 #endif
 
         void drawFocusRing(const Vector<IntRect>&, int width, int offset, const Color&);
         void drawFocusRing(const Path&, int width, int offset, const Color&);
+#if PLATFORM(MAC)
+        void drawFocusRing(const Vector<IntRect>&, int width, int offset, double timeOffset, bool& needsRedraw);
+#endif
 
         void setLineCap(LineCap);
         void setLineDash(const DashArray&, float dashOffset);
@@ -413,15 +406,16 @@ namespace WebCore {
         void setMiterLimit(float);
 
         void setAlpha(float);
+        float alpha() const { return m_state.alpha; }
 
-        void setCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
-        CompositeOperator compositeOperation() const;
-        BlendMode blendModeOperation() const;
+        WEBCORE_EXPORT void setCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
+        CompositeOperator compositeOperation() const { return m_state.compositeOperator; }
+        BlendMode blendModeOperation() const { return m_state.blendMode; }
 
-        void setDrawLuminanceMask(bool);
-        bool drawLuminanceMask() const;
+        void setDrawLuminanceMask(bool drawLuminanceMask) { m_state.drawLuminanceMask = drawLuminanceMask; }
+        bool drawLuminanceMask() const { return m_state.drawLuminanceMask; }
 
-        void clip(const Path&, WindRule = RULE_EVENODD);
+        WEBCORE_EXPORT void clip(const Path&, WindRule = RULE_EVENODD);
 
         // This clip function is used only by <canvas> code. It allows
         // implementations to handle clipping on the canvas differently since
@@ -429,10 +423,10 @@ namespace WebCore {
         void canvasClip(const Path&, WindRule = RULE_EVENODD);
         void clipOut(const Path&);
 
-        void scale(const FloatSize&);
+        WEBCORE_EXPORT void scale(const FloatSize&);
         void rotate(float angleInRadians);
         void translate(const FloatSize& size) { translate(size.width(), size.height()); }
-        void translate(float x, float y);
+        WEBCORE_EXPORT void translate(float x, float y);
 
         void setURLForRect(const URL&, const IntRect&);
 
@@ -442,7 +436,7 @@ namespace WebCore {
         enum IncludeDeviceScale { DefinitelyIncludeDeviceScale, PossiblyIncludeDeviceScale };
         AffineTransform getCTM(IncludeDeviceScale includeScale = PossiblyIncludeDeviceScale) const;
 
-#if ENABLE(3D_RENDERING) && USE(TEXTURE_MAPPER)
+#if ENABLE(3D_TRANSFORMS) && USE(TEXTURE_MAPPER)
         // This is needed when using accelerated-compositing in software mode, like in TextureMapper.
         void concat3DTransform(const TransformationMatrix&);
         void set3DTransform(const TransformationMatrix&);
@@ -450,17 +444,18 @@ namespace WebCore {
 #endif
         // Create an image buffer compatible with this context, with suitable resolution
         // for drawing into the buffer and then into this context.
-        std::unique_ptr<ImageBuffer> createCompatibleBuffer(const IntSize&, bool hasAlpha = true) const;
-        bool isCompatibleWithBuffer(ImageBuffer*) const;
+        std::unique_ptr<ImageBuffer> createCompatibleBuffer(const FloatSize&, bool hasAlpha = true) const;
+        bool isCompatibleWithBuffer(ImageBuffer&) const;
 
         // This function applies the device scale factor to the context, making the context capable of
         // acting as a base-level context for a HiDPI environment.
-        void applyDeviceScaleFactor(float);
+        WEBCORE_EXPORT void applyDeviceScaleFactor(float);
         void platformApplyDeviceScaleFactor(float);
 
 #if OS(WINDOWS)
         HDC getWindowsContext(const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in rect is used to create a bitmap for compositing inside transparency layers.
         void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in HDC should be the one handed back by getWindowsContext.
+        HDC hdc() const;
 #if PLATFORM(WIN)
 #if USE(WINGDI)
         void setBitmap(PassRefPtr<SharedBitmap>);
@@ -468,7 +463,7 @@ namespace WebCore {
         AffineTransform& affineTransform();
         void resetAffineTransform();
         void fillRect(const FloatRect&, const Gradient*);
-        void drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point);
+        void drawText(const Font&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
         void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);
         void drawFocusRect(const IntRect& rect);
         void paintTextField(const IntRect& rect, unsigned state);
@@ -510,7 +505,7 @@ namespace WebCore {
             DIBPixelData m_pixelData;
         };
 
-        PassOwnPtr<WindowsBitmap> createWindowsBitmap(const IntSize&);
+        std::unique_ptr<WindowsBitmap> createWindowsBitmap(const IntSize&);
         // The bitmap should be non-premultiplied.
         void drawWindowsBitmap(WindowsBitmap*, const IntPoint&);
 #endif
@@ -523,16 +518,10 @@ namespace WebCore {
         GraphicsContext(cairo_t*);
 #endif
 
-#if PLATFORM(GTK)
-        void setGdkExposeEvent(GdkEventExpose*);
-        GdkWindow* gdkWindow() const;
-        GdkEventExpose* gdkExposeEvent() const;
-#endif
-
         static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);
 
     private:
-        void platformInit(PlatformGraphicsContext*, bool shouldUseContextColors = false);
+        void platformInit(PlatformGraphicsContext*);
         void platformDestroy();
 
 #if PLATFORM(WIN) && !USE(WINGDI)
@@ -556,6 +545,7 @@ namespace WebCore {
         void setPlatformShadow(const FloatSize&, float blur, const Color&, ColorSpace);
         void clearPlatformShadow();
 
+        void setPlatformAlpha(float);
         void setPlatformCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
 
         void beginPlatformTransparencyLayer(float opacity);
@@ -570,10 +560,12 @@ namespace WebCore {
 
         void platformFillRoundedRect(const FloatRoundedRect&, const Color&, ColorSpace);
 
+        FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatPoint&, float width, bool printing, bool& shouldAntialias, Color&);
+
         GraphicsContextPlatformPrivate* m_data;
 
         GraphicsContextState m_state;
-        Vector<GraphicsContextState> m_stack;
+        Vector<GraphicsContextState, 1> m_stack;
         bool m_updatingControlTints;
         unsigned m_transparencyCount;
     };