Add m-esr52 at 52.6.0

1 files changed, 1190 insertions, 0 deletions

diff --git a/gfx/cairo/quartz-state.patch b/gfx/cairo/quartz-state.patch
new file mode 100644
index 000000000..d4c04f706
--- /dev/null
+++ b/gfx/cairo/quartz-state.patch
@@ -0,0 +1,1190 @@
+diff --git a/gfx/cairo/cairo/src/cairo-quartz-private.h b/gfx/cairo/cairo/src/cairo-quartz-private.h
+--- a/gfx/cairo/cairo/src/cairo-quartz-private.h
++++ b/gfx/cairo/cairo/src/cairo-quartz-private.h
+@@ -50,30 +50,16 @@ typedef struct cairo_quartz_surface {
+     CGContextRef cgContext;
+     CGAffineTransform cgContextBaseCTM;
+ 
+     void *imageData;
+     cairo_surface_t *imageSurfaceEquiv;
+ 
+     cairo_surface_clipper_t clipper;
+     cairo_rectangle_int_t extents;
+-
+-    /* These are stored while drawing operations are in place, set up
+-     * by quartz_setup_source() and quartz_finish_source()
+-     */
+-    CGAffineTransform sourceTransform;
+-
+-    CGImageRef sourceImage;
+-    cairo_surface_t *sourceImageSurface;
+-    CGRect sourceImageRect;
+-
+-    CGShadingRef sourceShading;
+-    CGPatternRef sourcePattern;
+-
+-    CGInterpolationQuality oldInterpolationQuality;
+ } cairo_quartz_surface_t;
+ 
+ typedef struct cairo_quartz_image_surface {
+     cairo_surface_t base;
+ 
+     cairo_rectangle_int_t extents;
+ 
+     CGImageRef image;
+diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+--- a/gfx/cairo/cairo/src/cairo-quartz-surface.c
++++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+@@ -1333,36 +1333,59 @@ _cairo_quartz_cairo_repeating_surface_pa
+     return CAIRO_STATUS_SUCCESS;
+ }
+ 
+ typedef enum {
+     DO_SOLID,
+     DO_SHADING,
+     DO_PATTERN,
+     DO_IMAGE,
++    DO_TILED_IMAGE,
+     DO_UNSUPPORTED,
+-    DO_NOTHING,
+-    DO_TILED_IMAGE
++    DO_NOTHING
+ } cairo_quartz_action_t;
+ 
+-static cairo_quartz_action_t
++/* State used during a drawing operation. */
++typedef struct {
++    CGContextRef context;
++    cairo_quartz_action_t action;
++
++    // Used with DO_SHADING, DO_IMAGE and DO_TILED_IMAGE
++    CGAffineTransform transform;
++
++    // Used with DO_IMAGE and DO_TILED_IMAGE
++    CGImageRef image;
++    cairo_surface_t *imageSurface;
++    CGRect imageRect;
++
++    // Used with DO_SHADING
++    CGShadingRef shading;
++
++    // Used with DO_PATTERN
++    CGPatternRef pattern;
++} cairo_quartz_drawing_state_t;
++
++static void
+ _cairo_quartz_setup_fallback_source (cairo_quartz_surface_t *surface,
+-				     const cairo_pattern_t *source)
++				     const cairo_pattern_t *source,
++				     cairo_quartz_drawing_state_t *state)
+ {
+-    CGRect clipBox = CGContextGetClipBoundingBox (surface->cgContext);
++    CGRect clipBox = CGContextGetClipBoundingBox (state->context);
+     double x0, y0, w, h;
+ 
+     cairo_surface_t *fallback;
+     CGImageRef img;
+ 
+     cairo_status_t status;
+ 
+     if (clipBox.size.width == 0.0f ||
+-	clipBox.size.height == 0.0f)
+-	return DO_NOTHING;
++	clipBox.size.height == 0.0f) {
++	state->action = DO_NOTHING;
++	return;
++    }
+ 
+     x0 = floor(clipBox.origin.x);
+     y0 = floor(clipBox.origin.y);
+     w = ceil(clipBox.origin.x + clipBox.size.width) - x0;
+     h = ceil(clipBox.origin.y + clipBox.size.height) - y0;
+ 
+     /* Create a temporary the size of the clip surface, and position
+      * it so that the device origin coincides with the original surface */
+@@ -1396,73 +1419,79 @@ _cairo_quartz_setup_fallback_source (cai
+ 				  &fallback->device_transform_inverse);
+ 	status = _cairo_surface_paint (fallback,
+ 				       CAIRO_OPERATOR_SOURCE,
+ 				       &pattern.base, NULL);
+     }
+ #endif
+ 
+     status = _cairo_surface_to_cgimage (&surface->base, fallback, &img);
+-    if (status)
+-	return DO_UNSUPPORTED;
+-    if (img == NULL)
+-	return DO_NOTHING;
+-
+-    surface->sourceImageRect = CGRectMake (0.0, 0.0, w, h);
+-    surface->sourceImage = img;
+-    surface->sourceImageSurface = fallback;
+-    surface->sourceTransform = CGAffineTransformMakeTranslation (x0, y0);
+-
+-    return DO_IMAGE;
++    if (status) {
++        state->action = DO_UNSUPPORTED;
++	return;
++    }
++    if (img == NULL) {
++        state->action = DO_NOTHING;
++	return;
++    }
++
++    state->imageRect = CGRectMake (0.0, 0.0, w, h);
++    state->image = img;
++    state->imageSurface = fallback;
++    state->transform = CGAffineTransformMakeTranslation (x0, y0);
++    state->action = DO_IMAGE;
+ }
+ 
+ /*
+ Quartz does not support repeating radients. We handle repeating gradients
+ by manually extending the gradient and repeating color stops. We need to
+ minimize the number of repetitions since Quartz seems to sample our color
+ function across the entire range, even if part of that range is not needed
+ for the visible area of the gradient, and it samples with some fixed resolution,
+ so if the gradient range is too large it samples with very low resolution and
+ the gradient is very coarse. CreateRepeatingLinearGradientFunction and
+ CreateRepeatingRadialGradientFunction compute the number of repetitions needed
+ based on the extents of the object (the clip region cannot be used here since
+ we don't want the rasterization of the entire gradient to depend on the
+ clip region).
+ */
+-static cairo_quartz_action_t
++static void
+ _cairo_quartz_setup_linear_source (cairo_quartz_surface_t *surface,
+ 				   const cairo_linear_pattern_t *lpat,
+-				   cairo_rectangle_int_t *extents)
++				   cairo_rectangle_int_t *extents,
++				   cairo_quartz_drawing_state_t *state)
+ {
+     const cairo_pattern_t *abspat = &lpat->base.base;
+     cairo_matrix_t mat;
+     CGPoint start, end;
+     CGFunctionRef gradFunc;
+     CGColorSpaceRef rgb;
+     bool extend = abspat->extend == CAIRO_EXTEND_PAD;
+ 
+     if (lpat->base.n_stops == 0) {
+-	CGContextSetRGBStrokeColor (surface->cgContext, 0., 0., 0., 0.);
+-	CGContextSetRGBFillColor (surface->cgContext, 0., 0., 0., 0.);
+-	return DO_SOLID;
++	CGContextSetRGBStrokeColor (state->context, 0., 0., 0., 0.);
++	CGContextSetRGBFillColor (state->context, 0., 0., 0., 0.);
++	state->action = DO_SOLID;
++	return;
+     }
+ 
+     if (lpat->p1.x == lpat->p2.x &&
+         lpat->p1.y == lpat->p2.y) {
+ 	/* Quartz handles cases where the vector has no length very
+ 	 * differently from pixman.
+ 	 * Whatever the correct behaviour is, let's at least have only pixman's
+ 	 * implementation to worry about.
+ 	 */
+-	return _cairo_quartz_setup_fallback_source (surface, abspat);
++	_cairo_quartz_setup_fallback_source (surface, abspat, state);
++	return;
+     }
+ 
+     mat = abspat->matrix;
+     cairo_matrix_invert (&mat);
+-    _cairo_quartz_cairo_matrix_to_quartz (&mat, &surface->sourceTransform);
++    _cairo_quartz_cairo_matrix_to_quartz (&mat, &state->transform);
+ 
+     rgb = CGColorSpaceCreateDeviceRGB();
+ 
+     start = CGPointMake (_cairo_fixed_to_double (lpat->p1.x),
+ 			 _cairo_fixed_to_double (lpat->p1.y));
+     end = CGPointMake (_cairo_fixed_to_double (lpat->p2.x),
+ 		       _cairo_fixed_to_double (lpat->p2.y));
+ 
+@@ -1472,31 +1501,32 @@ _cairo_quartz_setup_linear_source (cairo
+ 	gradFunc = CreateGradientFunction (&lpat->base);
+     } else {
+ 	gradFunc = CreateRepeatingLinearGradientFunction (surface,
+ 						          &lpat->base,
+ 						          &start, &end,
+ 						          extents);
+     }
+ 
+-    surface->sourceShading = CGShadingCreateAxial (rgb,
+-						   start, end,
+-						   gradFunc,
+-						   extend, extend);
++    state->shading = CGShadingCreateAxial (rgb,
++					   start, end,
++					   gradFunc,
++					   extend, extend);
+ 
+     CGColorSpaceRelease(rgb);
+     CGFunctionRelease(gradFunc);
+ 
+-    return DO_SHADING;
++    state->action = DO_SHADING;
+ }
+ 
+-static cairo_quartz_action_t
++static void
+ _cairo_quartz_setup_radial_source (cairo_quartz_surface_t *surface,
+ 				   const cairo_radial_pattern_t *rpat,
+-				   cairo_rectangle_int_t *extents)
++				   cairo_rectangle_int_t *extents,
++				   cairo_quartz_drawing_state_t *state)
+ {
+     const cairo_pattern_t *abspat = &rpat->base.base;
+     cairo_matrix_t mat;
+     CGPoint start, end;
+     CGFunctionRef gradFunc;
+     CGColorSpaceRef rgb;
+     bool extend = abspat->extend == CAIRO_EXTEND_PAD;
+     double c1x = _cairo_fixed_to_double (rpat->c1.x);
+@@ -1505,35 +1535,37 @@ _cairo_quartz_setup_radial_source (cairo
+     double c2y = _cairo_fixed_to_double (rpat->c2.y);
+     double r1 = _cairo_fixed_to_double (rpat->r1);
+     double r2 = _cairo_fixed_to_double (rpat->r2);
+     double dx = c1x - c2x;
+     double dy = c1y - c2y;
+     double centerDistance = sqrt (dx*dx + dy*dy);
+ 
+     if (rpat->base.n_stops == 0) {
+-	CGContextSetRGBStrokeColor (surface->cgContext, 0., 0., 0., 0.);
+-	CGContextSetRGBFillColor (surface->cgContext, 0., 0., 0., 0.);
+-	return DO_SOLID;
++	CGContextSetRGBStrokeColor (state->context, 0., 0., 0., 0.);
++	CGContextSetRGBFillColor (state->context, 0., 0., 0., 0.);
++	state->action = DO_SOLID;
++	return;
+     }
+ 
+     if (r2 <= centerDistance + r1 + 1e-6 && /* circle 2 doesn't contain circle 1 */
+         r1 <= centerDistance + r2 + 1e-6) { /* circle 1 doesn't contain circle 2 */
+ 	/* Quartz handles cases where neither circle contains the other very
+ 	 * differently from pixman.
+ 	 * Whatever the correct behaviour is, let's at least have only pixman's
+ 	 * implementation to worry about.
+ 	 * Note that this also catches the cases where r1 == r2.
+ 	 */
+-	return _cairo_quartz_setup_fallback_source (surface, abspat);
++	_cairo_quartz_setup_fallback_source (surface, abspat, state);
++	return;
+     }
+ 
+     mat = abspat->matrix;
+     cairo_matrix_invert (&mat);
+-    _cairo_quartz_cairo_matrix_to_quartz (&mat, &surface->sourceTransform);
++    _cairo_quartz_cairo_matrix_to_quartz (&mat, &state->transform);
+ 
+     rgb = CGColorSpaceCreateDeviceRGB();
+ 
+     start = CGPointMake (c1x, c1y);
+     end = CGPointMake (c2x, c2y);
+ 
+     if (abspat->extend == CAIRO_EXTEND_NONE ||
+         abspat->extend == CAIRO_EXTEND_PAD)
+@@ -1542,111 +1574,146 @@ _cairo_quartz_setup_radial_source (cairo
+     } else {
+ 	gradFunc = CreateRepeatingRadialGradientFunction (surface,
+ 						          &rpat->base,
+ 						          &start, &r1,
+ 						          &end, &r2,
+ 						          extents);
+     }
+ 
+-    surface->sourceShading = CGShadingCreateRadial (rgb,
+-						    start,
+-						    r1,
+-						    end,
+-						    r2,
+-						    gradFunc,
+-						    extend, extend);
++    state->shading = CGShadingCreateRadial (rgb,
++					    start,
++					    r1,
++					    end,
++					    r2,
++					    gradFunc,
++					    extend, extend);
+ 
+     CGColorSpaceRelease(rgb);
+     CGFunctionRelease(gradFunc);
+ 
+-    return DO_SHADING;
++    state->action = DO_SHADING;
+ }
+ 
+-static cairo_quartz_action_t
+-_cairo_quartz_setup_source (cairo_quartz_surface_t *surface,
+-			    const cairo_pattern_t *source,
+-			    cairo_rectangle_int_t *extents)
++/**
++ * Sets up internal state to be used to draw the source mask, stored in
++ * cairo_quartz_state_t. Guarantees to call CGContextSaveGState on
++ * surface->cgContext.
++ */
++static cairo_quartz_drawing_state_t
++_cairo_quartz_setup_state (cairo_quartz_surface_t *surface,
++			   const cairo_pattern_t *source,
++			   cairo_operator_t op,
++			   cairo_rectangle_int_t *extents)
+ {
+-    assert (!(surface->sourceImage || surface->sourceShading || surface->sourcePattern));
+-
+-    surface->oldInterpolationQuality = CGContextGetInterpolationQuality (surface->cgContext);
+-    CGContextSetInterpolationQuality (surface->cgContext, _cairo_quartz_filter_to_quartz (source->filter));
++    CGContextRef context = surface->cgContext;
++    cairo_quartz_drawing_state_t state;
++    cairo_status_t status;
++
++    state.context = context;
++    state.image = NULL;
++    state.imageSurface = NULL;
++    state.shading = NULL;
++    state.pattern = NULL;
++
++    // Save before we change the pattern, colorspace, etc. so that
++    // we can restore and make sure that quartz releases our
++    // pattern (which may be stack allocated)
++    CGContextSaveGState(context);
++
++    CGContextSetInterpolationQuality (context, _cairo_quartz_filter_to_quartz (source->filter));
++
++    status = _cairo_quartz_surface_set_cairo_operator (surface, op);
++    if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) {
++        state.action = DO_NOTHING;
++        return state;
++    }
++    if (status) {
++        state.action = DO_UNSUPPORTED;
++        return state;
++    }
+ 
+     if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
+ 	cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) source;
+ 
+-	CGContextSetRGBStrokeColor (surface->cgContext,
++	CGContextSetRGBStrokeColor (context,
+ 				    solid->color.red,
+ 				    solid->color.green,
+ 				    solid->color.blue,
+ 				    solid->color.alpha);
+-	CGContextSetRGBFillColor (surface->cgContext,
++	CGContextSetRGBFillColor (context,
+ 				  solid->color.red,
+ 				  solid->color.green,
+ 				  solid->color.blue,
+ 				  solid->color.alpha);
+ 
+-	return DO_SOLID;
++        state.action = DO_SOLID;
++        return state;
+     }
+ 
+     if (source->type == CAIRO_PATTERN_TYPE_LINEAR) {
+ 	const cairo_linear_pattern_t *lpat = (const cairo_linear_pattern_t *)source;
+-	return _cairo_quartz_setup_linear_source (surface, lpat, extents);
++	_cairo_quartz_setup_linear_source (surface, lpat, extents, &state);
++	return state;
+     }
+ 
+     if (source->type == CAIRO_PATTERN_TYPE_RADIAL) {
+ 	const cairo_radial_pattern_t *rpat = (const cairo_radial_pattern_t *)source;
+-	return _cairo_quartz_setup_radial_source (surface, rpat, extents);
++	_cairo_quartz_setup_radial_source (surface, rpat, extents, &state);
++	return state;
+     }
+ 
+     if (source->type == CAIRO_PATTERN_TYPE_SURFACE &&
+ 	(source->extend == CAIRO_EXTEND_NONE || (CGContextDrawTiledImagePtr && source->extend == CAIRO_EXTEND_REPEAT)))
+     {
+ 	const cairo_surface_pattern_t *spat = (const cairo_surface_pattern_t *) source;
+ 	cairo_surface_t *pat_surf = spat->surface;
+ 	CGImageRef img;
+ 	cairo_matrix_t m = spat->base.matrix;
+ 	cairo_rectangle_int_t extents;
+-	cairo_status_t status;
+ 	CGAffineTransform xform;
+ 	CGRect srcRect;
+ 	cairo_fixed_t fw, fh;
+ 	cairo_bool_t is_bounded;
+ 
+ 	status = _cairo_surface_to_cgimage ((cairo_surface_t *) surface, pat_surf, &img);
+-	if (status)
+-	    return DO_UNSUPPORTED;
+-	if (img == NULL)
+-	    return DO_NOTHING;
++        if (status) {
++            state.action = DO_UNSUPPORTED;
++	    return state;
++        }
++        if (img == NULL) {
++            state.action = DO_NOTHING;
++	    return state;
++        }
+ 
+ 	CGContextSetRGBFillColor (surface->cgContext, 0, 0, 0, 1);
+ 
+-	surface->sourceImage = img;
++	state.image = img;
+ 
+ 	cairo_matrix_invert(&m);
+-	_cairo_quartz_cairo_matrix_to_quartz (&m, &surface->sourceTransform);
++	_cairo_quartz_cairo_matrix_to_quartz (&m, &state.transform);
+ 
+ 	is_bounded = _cairo_surface_get_extents (pat_surf, &extents);
+ 	assert (is_bounded);
+ 
+ 	if (source->extend == CAIRO_EXTEND_NONE) {
+-	    surface->sourceImageRect = CGRectMake (0, 0, extents.width, extents.height);
+-	    return DO_IMAGE;
++	    state.imageRect = CGRectMake (0, 0, extents.width, extents.height);
++	    state.action = DO_IMAGE;
++	    return state;
+ 	}
+ 
+ 	/* Quartz seems to tile images at pixel-aligned regions only -- this
+ 	 * leads to seams if the image doesn't end up scaling to fill the
+ 	 * space exactly.  The CGPattern tiling approach doesn't have this
+ 	 * problem.  Check if we're going to fill up the space (within some
+ 	 * epsilon), and if not, fall back to the CGPattern type.
+ 	 */
+ 
+-	xform = CGAffineTransformConcat (CGContextGetCTM (surface->cgContext),
+-					 surface->sourceTransform);
++	xform = CGAffineTransformConcat (CGContextGetCTM (context),
++					 state.transform);
+ 
+ 	srcRect = CGRectMake (0, 0, extents.width, extents.height);
+ 	srcRect = CGRectApplyAffineTransform (srcRect, xform);
+ 
+ 	fw = _cairo_fixed_from_double (srcRect.size.width);
+ 	fh = _cairo_fixed_from_double (srcRect.size.height);
+ 
+ 	if ((fw & CAIRO_FIXED_FRAC_MASK) <= CAIRO_FIXED_EPSILON &&
+@@ -1657,111 +1724,109 @@ _cairo_quartz_setup_source (cairo_quartz
+ 
+ 	    srcRect.size.width = round(srcRect.size.width);
+ 	    srcRect.size.height = round(srcRect.size.height);
+ 
+ 	    xform = CGAffineTransformInvert (xform);
+ 
+ 	    srcRect = CGRectApplyAffineTransform (srcRect, xform);
+ 
+-	    surface->sourceImageRect = srcRect;
+-
+-	    return DO_TILED_IMAGE;
++	    state.imageRect = srcRect;
++            state.action = DO_TILED_IMAGE;
++            return state;
+ 	}
+ 
+ 	/* Fall through to generic SURFACE case */
+     }
+ 
+     if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
+ 	CGFloat patternAlpha = 1.0f;
+ 	CGColorSpaceRef patternSpace;
+ 	CGPatternRef pattern;
+ 	cairo_int_status_t status;
+ 
+ 	status = _cairo_quartz_cairo_repeating_surface_pattern_to_quartz (surface, source, &pattern);
+-	if (status == CAIRO_INT_STATUS_NOTHING_TO_DO)
+-	    return DO_NOTHING;
+-	if (status)
+-	    return DO_UNSUPPORTED;
+-
+-	// Save before we change the pattern, colorspace, etc. so that
+-	// we can restore and make sure that quartz releases our
+-	// pattern (which may be stack allocated)
+-	CGContextSaveGState(surface->cgContext);
+-
+-	patternSpace = CGColorSpaceCreatePattern(NULL);
+-	CGContextSetFillColorSpace (surface->cgContext, patternSpace);
+-	CGContextSetFillPattern (surface->cgContext, pattern, &patternAlpha);
+-	CGContextSetStrokeColorSpace (surface->cgContext, patternSpace);
+-	CGContextSetStrokePattern (surface->cgContext, pattern, &patternAlpha);
++	if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) {
++	    state.action = DO_NOTHING;
++	    return state;
++	}
++	if (status) {
++	    state.action = DO_UNSUPPORTED;
++	    return state;
++	}
++
++	patternSpace = CGColorSpaceCreatePattern (NULL);
++	CGContextSetFillColorSpace (context, patternSpace);
++	CGContextSetFillPattern (context, pattern, &patternAlpha);
++	CGContextSetStrokeColorSpace (context, patternSpace); 
++	CGContextSetStrokePattern (context, pattern, &patternAlpha);
+ 	CGColorSpaceRelease (patternSpace);
+ 
+ 	/* Quartz likes to munge the pattern phase (as yet unexplained
+ 	 * why); force it to 0,0 as we've already baked in the correct
+ 	 * pattern translation into the pattern matrix
+ 	 */
+-	CGContextSetPatternPhase (surface->cgContext, CGSizeMake(0,0));
+-
+-	surface->sourcePattern = pattern;
+-
+-	return DO_PATTERN;
++	CGContextSetPatternPhase (context, CGSizeMake(0,0));
++
++	state.pattern = pattern;
++        state.action = DO_PATTERN;
++        return state;
+     }
+ 
+-    return DO_UNSUPPORTED;
++    state.action = DO_UNSUPPORTED;
++    return state;
+ }
+ 
++/**
++ * 1) Tears down internal state used to draw the source
++ * 2) Does CGContextRestoreGState(state->context)
++ */
+ static void
+-_cairo_quartz_teardown_source (cairo_quartz_surface_t *surface,
+-			       const cairo_pattern_t *source)
++_cairo_quartz_teardown_state (cairo_quartz_drawing_state_t *state)
+ {
+-    CGContextSetInterpolationQuality (surface->cgContext, surface->oldInterpolationQuality);
+-
+-    if (surface->sourceImage) {
+-	CGImageRelease(surface->sourceImage);
+-	surface->sourceImage = NULL;
+-
+-	cairo_surface_destroy(surface->sourceImageSurface);
+-	surface->sourceImageSurface = NULL;
++    if (state->image) {
++	CGImageRelease(state->image);
+     }
+ 
+-    if (surface->sourceShading) {
+-	CGShadingRelease(surface->sourceShading);
+-	surface->sourceShading = NULL;
++    if (state->imageSurface) {
++	cairo_surface_destroy(state->imageSurface);
+     }
+ 
+-    if (surface->sourcePattern) {
+-	CGPatternRelease(surface->sourcePattern);
+-	// To tear down the pattern and colorspace
+-	CGContextRestoreGState(surface->cgContext);
+-
+-	surface->sourcePattern = NULL;
++    if (state->shading) {
++	CGShadingRelease(state->shading);
+     }
++
++    if (state->pattern) {
++	CGPatternRelease(state->pattern);
++    }
++
++    CGContextRestoreGState(state->context);
+ }
+ 
+ 
+ static void
+-_cairo_quartz_draw_image (cairo_quartz_surface_t *surface, cairo_operator_t op,  cairo_quartz_action_t action)
++_cairo_quartz_draw_image (cairo_quartz_drawing_state_t *state, cairo_operator_t op)
+ {
+-    assert (surface && surface->sourceImage && (action == DO_IMAGE || action == DO_TILED_IMAGE));
+-
+-    CGContextConcatCTM (surface->cgContext, surface->sourceTransform);
+-    CGContextTranslateCTM (surface->cgContext, 0, surface->sourceImageRect.size.height);
+-    CGContextScaleCTM (surface->cgContext, 1, -1);
+-
+-    if (action == DO_IMAGE) {
+-	CGContextDrawImage (surface->cgContext, surface->sourceImageRect, surface->sourceImage);
+-	if (!_cairo_operator_bounded_by_source(op)) {
+-	    CGContextBeginPath (surface->cgContext);
+-	    CGContextAddRect (surface->cgContext, surface->sourceImageRect);
+-	    CGContextAddRect (surface->cgContext, CGContextGetClipBoundingBox (surface->cgContext));
+-	    CGContextSetRGBFillColor (surface->cgContext, 0, 0, 0, 0);
+-	    CGContextEOFillPath (surface->cgContext);
++    assert (state && state->image && (state->action == DO_IMAGE || state->action == DO_TILED_IMAGE));
++
++    CGContextConcatCTM (state->context, state->transform);
++    CGContextTranslateCTM (state->context, 0, state->imageRect.size.height);
++    CGContextScaleCTM (state->context, 1, -1);
++
++    if (state->action == DO_IMAGE) {
++	CGContextDrawImage (state->context, state->imageRect, state->image);
++	if (!_cairo_operator_bounded_by_source (op)) {
++	    CGContextBeginPath (state->context);
++	    CGContextAddRect (state->context, state->imageRect);
++	    CGContextAddRect (state->context, CGContextGetClipBoundingBox (state->context));
++	    CGContextSetRGBFillColor (state->context, 0, 0, 0, 0);
++	    CGContextEOFillPath (state->context);
+ 	}
+     } else
+-	CGContextDrawTiledImagePtr (surface->cgContext, surface->sourceImageRect, surface->sourceImage);
++	CGContextDrawTiledImagePtr (state->context, state->imageRect, state->image);
+ }
+ 
+ 
+ /*
+  * get source/dest image implementation
+  */
+ 
+ /* Read the image from the surface's front buffer */
+@@ -2098,52 +2163,44 @@ _cairo_quartz_surface_get_extents (void 
+ static cairo_int_status_t
+ _cairo_quartz_surface_paint (void *abstract_surface,
+ 			     cairo_operator_t op,
+ 			     const cairo_pattern_t *source,
+ 			     cairo_clip_t *clip)
+ {
+     cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface;
+     cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
+-    cairo_quartz_action_t action;
++    cairo_quartz_drawing_state_t state;
+ 
+     ND((stderr, "%p _cairo_quartz_surface_paint op %d source->type %d\n", surface, op, source->type));
+ 
+     if (IS_EMPTY(surface))
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     rv = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+     if (unlikely (rv))
+ 	return rv;
+ 
+-    rv = _cairo_quartz_surface_set_cairo_operator (surface, op);
+-    if (unlikely (rv))
+-	return rv == CAIRO_INT_STATUS_NOTHING_TO_DO ? CAIRO_STATUS_SUCCESS : rv;
+-
+-    action = _cairo_quartz_setup_source (surface, source, NULL);
+-
+-    if (action == DO_SOLID || action == DO_PATTERN) {
+-	CGContextFillRect (surface->cgContext, CGRectMake(surface->extents.x,
+-							  surface->extents.y,
+-							  surface->extents.width,
+-							  surface->extents.height));
+-    } else if (action == DO_SHADING) {
+-	CGContextSaveGState (surface->cgContext);
+-	CGContextConcatCTM (surface->cgContext, surface->sourceTransform);
+-	CGContextDrawShading (surface->cgContext, surface->sourceShading);
+-	CGContextRestoreGState (surface->cgContext);
+-    } else if (action == DO_IMAGE || action == DO_TILED_IMAGE) {
+-	CGContextSaveGState (surface->cgContext);
+-	_cairo_quartz_draw_image (surface, op, action);
+-	CGContextRestoreGState (surface->cgContext);
+-    } else if (action != DO_NOTHING) {
++    state = _cairo_quartz_setup_state (surface, source, op, NULL);
++
++    if (state.action == DO_SOLID || state.action == DO_PATTERN) {
++	CGContextFillRect (state.context, CGRectMake(surface->extents.x,
++						     surface->extents.y,
++						     surface->extents.width,
++						     surface->extents.height));
++    } else if (state.action == DO_SHADING) {
++	CGContextConcatCTM (state.context, state.transform);
++	CGContextDrawShading (state.context, state.shading);
++    } else if (state.action == DO_IMAGE || state.action == DO_TILED_IMAGE) {
++	_cairo_quartz_draw_image (&state, op);
++    } else if (state.action != DO_NOTHING) {
+ 	rv = CAIRO_INT_STATUS_UNSUPPORTED;
+     }
+ 
+-    _cairo_quartz_teardown_source (surface, source);
++    _cairo_quartz_teardown_state (&state);
+ 
+     ND((stderr, "-- paint\n"));
+     return rv;
+ }
+ 
+ static cairo_bool_t
+ _cairo_quartz_source_needs_extents (const cairo_pattern_t *source)
+ {
+@@ -2170,91 +2227,83 @@ _cairo_quartz_surface_fill (void *abstra
+ 			     cairo_path_fixed_t *path,
+ 			     cairo_fill_rule_t fill_rule,
+ 			     double tolerance,
+ 			     cairo_antialias_t antialias,
+ 			     cairo_clip_t *clip)
+ {
+     cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface;
+     cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
+-    cairo_quartz_action_t action;
++    cairo_quartz_drawing_state_t state;
+     quartz_stroke_t stroke;
+     CGPathRef path_for_unbounded = NULL;
+ 
+     ND((stderr, "%p _cairo_quartz_surface_fill op %d source->type %d\n", surface, op, source->type));
+ 
+     if (IS_EMPTY(surface))
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     rv = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+     if (unlikely (rv))
+ 	return rv;
+ 
+-    rv = _cairo_quartz_surface_set_cairo_operator (surface, op);
+-    if (unlikely (rv))
+-	return rv == CAIRO_INT_STATUS_NOTHING_TO_DO ? CAIRO_STATUS_SUCCESS : rv;
+-
+-    CGContextSaveGState (surface->cgContext);
+-
+-    CGContextSetShouldAntialias (surface->cgContext, (antialias != CAIRO_ANTIALIAS_NONE));
+-
+     if (_cairo_quartz_source_needs_extents (source))
+     {
+         /* We don't need precise extents since these are only used to
+            compute the number of gradient reptitions needed to cover the
+            object. */
+         cairo_rectangle_int_t path_extents;
+         _cairo_path_fixed_approximate_fill_extents (path, &path_extents);
+-        action = _cairo_quartz_setup_source (surface, source, &path_extents);
++        state = _cairo_quartz_setup_state (surface, source, op, &path_extents);
+     } else {
+-        action = _cairo_quartz_setup_source (surface, source, NULL);
++        state = _cairo_quartz_setup_state (surface, source, op, NULL);
+     }
+ 
+-    CGContextBeginPath (surface->cgContext);
+-
+-    stroke.cgContext = surface->cgContext;
++    CGContextSetShouldAntialias (state.context, (antialias != CAIRO_ANTIALIAS_NONE));
++
++    CGContextBeginPath (state.context);
++
++    stroke.cgContext = state.context;
+     stroke.ctm_inverse = NULL;
+     rv = _cairo_quartz_cairo_path_to_quartz_context (path, &stroke);
+     if (rv)
+         goto BAIL;
+ 
+     if (!_cairo_operator_bounded_by_mask(op) && CGContextCopyPathPtr)
+-	path_for_unbounded = CGContextCopyPathPtr (surface->cgContext);
+-
+-    if (action == DO_SOLID || action == DO_PATTERN) {
++	path_for_unbounded = CGContextCopyPathPtr (state.context);
++
++    if (state.action == DO_SOLID || state.action == DO_PATTERN) {
+ 	if (fill_rule == CAIRO_FILL_RULE_WINDING)
+-	    CGContextFillPath (surface->cgContext);
++	    CGContextFillPath (state.context);
+ 	else
+-	    CGContextEOFillPath (surface->cgContext);
+-    } else if (action == DO_SHADING) {
++	    CGContextEOFillPath (state.context);
++    } else if (state.action == DO_SHADING) {
+ 
+ 	// we have to clip and then paint the shading; we can't fill
+ 	// with the shading
+ 	if (fill_rule == CAIRO_FILL_RULE_WINDING)
+-	    CGContextClip (surface->cgContext);
++	    CGContextClip (state.context);
+ 	else
+-	    CGContextEOClip (surface->cgContext);
+-
+-	CGContextConcatCTM (surface->cgContext, surface->sourceTransform);
+-	CGContextDrawShading (surface->cgContext, surface->sourceShading);
+-    } else if (action == DO_IMAGE || action == DO_TILED_IMAGE) {
++            CGContextEOClip (state.context);
++
++	CGContextConcatCTM (state.context, state.transform);
++	CGContextDrawShading (state.context, state.shading);
++    } else if (state.action == DO_IMAGE || state.action == DO_TILED_IMAGE) {
+ 	if (fill_rule == CAIRO_FILL_RULE_WINDING)
+-	    CGContextClip (surface->cgContext);
++	    CGContextClip (state.context);
+ 	else
+-	    CGContextEOClip (surface->cgContext);
+-
+-	_cairo_quartz_draw_image (surface, op, action);
+-    } else if (action != DO_NOTHING) {
++	    CGContextEOClip (state.context);
++
++	_cairo_quartz_draw_image (&state, op);
++    } else if (state.action != DO_NOTHING) {
+ 	rv = CAIRO_INT_STATUS_UNSUPPORTED;
+     }
+ 
+   BAIL:
+-    _cairo_quartz_teardown_source (surface, source);
+-
+-    CGContextRestoreGState (surface->cgContext);
++    _cairo_quartz_teardown_state (&state);
+ 
+     if (path_for_unbounded) {
+ 	unbounded_op_data_t ub;
+ 	ub.op = UNBOUNDED_STROKE_FILL;
+ 	ub.u.stroke_fill.cgPath = path_for_unbounded;
+ 	ub.u.stroke_fill.fill_rule = fill_rule;
+ 
+ 	_cairo_quartz_fixup_unbounded_operation (surface, &ub, antialias);
+@@ -2274,44 +2323,49 @@ _cairo_quartz_surface_stroke (void *abst
+ 			      cairo_matrix_t *ctm,
+ 			      cairo_matrix_t *ctm_inverse,
+ 			      double tolerance,
+ 			      cairo_antialias_t antialias,
+ 			      cairo_clip_t *clip)
+ {
+     cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface;
+     cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
+-    cairo_quartz_action_t action;
++    cairo_quartz_drawing_state_t state;
+     quartz_stroke_t stroke;
+     CGAffineTransform origCTM, strokeTransform;
+     CGPathRef path_for_unbounded = NULL;
+ 
+     ND((stderr, "%p _cairo_quartz_surface_stroke op %d source->type %d\n", surface, op, source->type));
+ 
+     if (IS_EMPTY(surface))
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     rv = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+     if (unlikely (rv))
+ 	return rv;
+ 
+-    rv = _cairo_quartz_surface_set_cairo_operator (surface, op);
+-    if (unlikely (rv))
+-	return rv == CAIRO_INT_STATUS_NOTHING_TO_DO ? CAIRO_STATUS_SUCCESS : rv;
++    if (_cairo_quartz_source_needs_extents (source))
++    {
++        cairo_rectangle_int_t path_extents;
++        _cairo_path_fixed_approximate_stroke_extents (path, style, ctm, &path_extents);
++        state = _cairo_quartz_setup_state (surface, source, op, &path_extents);
++    } else {
++        state = _cairo_quartz_setup_state (surface, source, op, NULL);
++    }
+ 
+     // Turning antialiasing off used to cause misrendering with
+     // single-pixel lines (e.g. 20,10.5 -> 21,10.5 end up being rendered as 2 pixels).
+     // That's been since fixed in at least 10.5, and in the latest 10.4 dot releases.
+-    CGContextSetShouldAntialias (surface->cgContext, (antialias != CAIRO_ANTIALIAS_NONE));
+-    CGContextSetLineWidth (surface->cgContext, style->line_width);
+-    CGContextSetLineCap (surface->cgContext, _cairo_quartz_cairo_line_cap_to_quartz (style->line_cap));
+-    CGContextSetLineJoin (surface->cgContext, _cairo_quartz_cairo_line_join_to_quartz (style->line_join));
+-    CGContextSetMiterLimit (surface->cgContext, style->miter_limit);
+-
+-    origCTM = CGContextGetCTM (surface->cgContext);
++    CGContextSetShouldAntialias (state.context, (antialias != CAIRO_ANTIALIAS_NONE));
++    CGContextSetLineWidth (state.context, style->line_width);
++    CGContextSetLineCap (state.context, _cairo_quartz_cairo_line_cap_to_quartz (style->line_cap));
++    CGContextSetLineJoin (state.context, _cairo_quartz_cairo_line_join_to_quartz (style->line_join));
++    CGContextSetMiterLimit (state.context, style->miter_limit);
++
++    origCTM = CGContextGetCTM (state.context);
+ 
+     if (style->dash && style->num_dashes) {
+ #define STATIC_DASH 32
+ 	CGFloat sdash[STATIC_DASH];
+ 	CGFloat *fdash = sdash;
+ 	double offset = style->dash_offset;
+ 	unsigned int max_dashes = style->num_dashes;
+ 	unsigned int k;
+@@ -2330,90 +2384,75 @@ _cairo_quartz_surface_stroke (void *abst
+ 	    if (max_dashes > STATIC_DASH)
+ 		fdash = _cairo_malloc_ab (max_dashes, sizeof (CGFloat));
+ 	    if (fdash == NULL)
+ 		return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ 
+ 	    for (k = 0; k < max_dashes; k++)
+ 		fdash[k] = (CGFloat) style->dash[k % style->num_dashes];
+ 	}
+-	CGContextSetLineDash (surface->cgContext, offset, fdash, max_dashes);
++	CGContextSetLineDash (state.context, offset, fdash, max_dashes);
+ 	if (fdash != sdash)
+ 	    free (fdash);
+     } else
+-	CGContextSetLineDash (surface->cgContext, 0, NULL, 0);
+-
+-    CGContextSaveGState (surface->cgContext);
+-
+-
+-    if (_cairo_quartz_source_needs_extents (source))
+-    {
+-        cairo_rectangle_int_t path_extents;
+-        _cairo_path_fixed_approximate_stroke_extents (path, style, ctm, &path_extents);
+-        action = _cairo_quartz_setup_source (surface, source, &path_extents);
+-    } else {
+-        action = _cairo_quartz_setup_source (surface, source, NULL);
+-    }
++	CGContextSetLineDash (state.context, 0, NULL, 0);
+ 
+     _cairo_quartz_cairo_matrix_to_quartz (ctm, &strokeTransform);
+-    CGContextConcatCTM (surface->cgContext, strokeTransform);
+-
+-    CGContextBeginPath (surface->cgContext);
+-
+-    stroke.cgContext = surface->cgContext;
++    CGContextConcatCTM (state.context, strokeTransform);
++
++    CGContextBeginPath (state.context);
++
++    stroke.cgContext = state.context;
+     stroke.ctm_inverse = ctm_inverse;
+     rv = _cairo_quartz_cairo_path_to_quartz_context (path, &stroke);
+     if (rv)
+ 	goto BAIL;
+ 
+     if (!_cairo_operator_bounded_by_mask (op) && CGContextCopyPathPtr)
+-	path_for_unbounded = CGContextCopyPathPtr (surface->cgContext);
+-
+-    if (action == DO_SOLID || action == DO_PATTERN) {
+-	CGContextStrokePath (surface->cgContext);
+-    } else if (action == DO_IMAGE || action == DO_TILED_IMAGE) {
+-	CGContextReplacePathWithStrokedPath (surface->cgContext);
+-	CGContextClip (surface->cgContext);
+-
+-	CGContextSetCTM (surface->cgContext, origCTM);
+-	_cairo_quartz_draw_image (surface, op, action);
+-    } else if (action == DO_SHADING) {
+-	CGContextReplacePathWithStrokedPath (surface->cgContext);
+-	CGContextClip (surface->cgContext);
+-
+-	CGContextSetCTM (surface->cgContext, origCTM);
+-
+-	CGContextConcatCTM (surface->cgContext, surface->sourceTransform);
+-	CGContextDrawShading (surface->cgContext, surface->sourceShading);
+-    } else if (action != DO_NOTHING) {
++	path_for_unbounded = CGContextCopyPathPtr (state.context);
++
++    if (state.action == DO_SOLID || state.action == DO_PATTERN) {
++	CGContextStrokePath (state.context);
++    } else if (state.action == DO_IMAGE || state.action == DO_TILED_IMAGE) {
++	CGContextReplacePathWithStrokedPath (state.context);
++	CGContextClip (state.context);
++
++	CGContextSetCTM (state.context, origCTM);
++	_cairo_quartz_draw_image (&state, op);
++    } else if (state.action == DO_SHADING) {
++	CGContextReplacePathWithStrokedPath (state.context);
++	CGContextClip (state.context);
++
++	CGContextSetCTM (state.context, origCTM);
++
++	CGContextConcatCTM (state.context, state.transform);
++	CGContextDrawShading (state.context, state.shading);
++    } else if (state.action != DO_NOTHING) {
+ 	rv = CAIRO_INT_STATUS_UNSUPPORTED;
++	goto BAIL;
+     }
+ 
++    if (path_for_unbounded) {
++	CGContextSetCTM (state.context, origCTM);
++	CGContextConcatCTM (state.context, strokeTransform);
++
++	CGContextBeginPath (state.context);
++	CGContextAddPath (state.context, path_for_unbounded);
++	CGPathRelease (path_for_unbounded);
++
++	CGContextReplacePathWithStrokedPath (state.context);
++
++	CGContextAddRect (state.context, CGContextGetClipBoundingBox (state.context));
++
++	CGContextSetRGBFillColor (state.context, 0., 0., 0., 0.);
++	CGContextEOFillPath (state.context);
++    }
++
+   BAIL:
+-    _cairo_quartz_teardown_source (surface, source);
+-
+-    CGContextRestoreGState (surface->cgContext);
+-
+-    if (path_for_unbounded) {
+-	CGContextSaveGState (surface->cgContext);
+-	CGContextConcatCTM (surface->cgContext, strokeTransform);
+-
+-	CGContextBeginPath (surface->cgContext);
+-	CGContextAddPath (surface->cgContext, path_for_unbounded);
+-	CGPathRelease (path_for_unbounded);
+-
+-	CGContextReplacePathWithStrokedPath (surface->cgContext);
+-
+-	CGContextAddRect (surface->cgContext, CGContextGetClipBoundingBox (surface->cgContext));
+-
+-	CGContextSetRGBFillColor (surface->cgContext, 0., 0., 0., 0.);
+-	CGContextEOFillPath (surface->cgContext);
+-
+-	CGContextRestoreGState (surface->cgContext);
+-    }
++    _cairo_quartz_teardown_state (&state);
+ 
+     ND((stderr, "-- stroke\n"));
+     return rv;
+ }
+ 
+ #if CAIRO_HAS_QUARTZ_FONT
+ static cairo_int_status_t
+ _cairo_quartz_surface_show_glyphs (void *abstract_surface,
+@@ -2429,17 +2468,17 @@ _cairo_quartz_surface_show_glyphs (void 
+ #define STATIC_BUF_SIZE 64
+     CGGlyph glyphs_static[STATIC_BUF_SIZE];
+     CGSize cg_advances_static[STATIC_BUF_SIZE];
+     CGGlyph *cg_glyphs = &glyphs_static[0];
+     CGSize *cg_advances = &cg_advances_static[0];
+ 
+     cairo_quartz_surface_t *surface = (cairo_quartz_surface_t *) abstract_surface;
+     cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
+-    cairo_quartz_action_t action;
++    cairo_quartz_drawing_state_t state;
+     float xprev, yprev;
+     int i;
+     CGFontRef cgfref = NULL;
+ 
+     cairo_bool_t isClipping = FALSE;
+     cairo_bool_t didForceFontSmoothing = FALSE;
+ 
+     if (IS_EMPTY(surface))
+@@ -2450,65 +2489,59 @@ _cairo_quartz_surface_show_glyphs (void 
+ 
+     if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ)
+ 	return CAIRO_INT_STATUS_UNSUPPORTED;
+ 
+     rv = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+     if (unlikely (rv))
+ 	return rv;
+ 
+-    rv = _cairo_quartz_surface_set_cairo_operator (surface, op);
+-    if (unlikely (rv))
+-	return rv == CAIRO_INT_STATUS_NOTHING_TO_DO ? CAIRO_STATUS_SUCCESS : rv;
+-
+-    CGContextSaveGState (surface->cgContext);
+-
+     if (_cairo_quartz_source_needs_extents (source))
+     {
+         cairo_rectangle_int_t glyph_extents;
+         _cairo_scaled_font_glyph_device_extents (scaled_font, glyphs, num_glyphs,
+                                                  &glyph_extents, NULL);
+-        action = _cairo_quartz_setup_source (surface, source, &glyph_extents);
++        state = _cairo_quartz_setup_state (surface, source, op, &glyph_extents);
+     } else {
+-        action = _cairo_quartz_setup_source (surface, source, NULL);
++        state = _cairo_quartz_setup_state (surface, source, op, NULL);
+     }
+ 
+-    if (action == DO_SOLID || action == DO_PATTERN) {
+-	CGContextSetTextDrawingMode (surface->cgContext, kCGTextFill);
+-    } else if (action == DO_IMAGE || action == DO_TILED_IMAGE || action == DO_SHADING) {
+-	CGContextSetTextDrawingMode (surface->cgContext, kCGTextClip);
++    if (state.action == DO_SOLID || state.action == DO_PATTERN) {
++	CGContextSetTextDrawingMode (state.context, kCGTextFill);
++    } else if (state.action == DO_IMAGE || state.action == DO_TILED_IMAGE || state.action == DO_SHADING) {
++	CGContextSetTextDrawingMode (state.context, kCGTextClip);
+ 	isClipping = TRUE;
+     } else {
+-	if (action != DO_NOTHING)
++	if (state.action != DO_NOTHING)
+ 	    rv = CAIRO_INT_STATUS_UNSUPPORTED;
+ 	goto BAIL;
+     }
+ 
+     /* this doesn't addref */
+     cgfref = _cairo_quartz_scaled_font_get_cg_font_ref (scaled_font);
+-    CGContextSetFont (surface->cgContext, cgfref);
+-    CGContextSetFontSize (surface->cgContext, 1.0);
++    CGContextSetFont (state.context, cgfref);
++    CGContextSetFontSize (state.context, 1.0);
+ 
+     switch (scaled_font->options.antialias) {
+ 	case CAIRO_ANTIALIAS_SUBPIXEL:
+-	    CGContextSetShouldAntialias (surface->cgContext, TRUE);
+-	    CGContextSetShouldSmoothFonts (surface->cgContext, TRUE);
++	    CGContextSetShouldAntialias (state.context, TRUE);
++	    CGContextSetShouldSmoothFonts (state.context, TRUE);
+ 	    if (CGContextSetAllowsFontSmoothingPtr &&
+-		!CGContextGetAllowsFontSmoothingPtr (surface->cgContext))
++		!CGContextGetAllowsFontSmoothingPtr (state.context))
+ 	    {
+ 		didForceFontSmoothing = TRUE;
+-		CGContextSetAllowsFontSmoothingPtr (surface->cgContext, TRUE);
++		CGContextSetAllowsFontSmoothingPtr (state.context, TRUE);
+ 	    }
+ 	    break;
+ 	case CAIRO_ANTIALIAS_NONE:
+-	    CGContextSetShouldAntialias (surface->cgContext, FALSE);
++	    CGContextSetShouldAntialias (state.context, FALSE);
+ 	    break;
+ 	case CAIRO_ANTIALIAS_GRAY:
+-	    CGContextSetShouldAntialias (surface->cgContext, TRUE);
+-	    CGContextSetShouldSmoothFonts (surface->cgContext, FALSE);
++	    CGContextSetShouldAntialias (state.context, TRUE);
++	    CGContextSetShouldSmoothFonts (state.context, FALSE);
+ 	    break;
+ 	case CAIRO_ANTIALIAS_DEFAULT:
+ 	    /* Don't do anything */
+ 	    break;
+     }
+ 
+     if (num_glyphs > STATIC_BUF_SIZE) {
+ 	cg_glyphs = (CGGlyph*) _cairo_malloc_ab (num_glyphs, sizeof(CGGlyph));
+@@ -2532,17 +2565,17 @@ _cairo_quartz_surface_show_glyphs (void 
+     textTransform = CGAffineTransformScale (textTransform, 1.0, -1.0);
+     textTransform = CGAffineTransformConcat (CGAffineTransformMake(scaled_font->ctm.xx,
+ 								   -scaled_font->ctm.yx,
+ 								   -scaled_font->ctm.xy,
+ 								   scaled_font->ctm.yy,
+ 								   0., 0.),
+ 					     textTransform);
+ 
+-    CGContextSetTextMatrix (surface->cgContext, textTransform);
++    CGContextSetTextMatrix (state.context, textTransform);
+ 
+     /* Convert our glyph positions to glyph advances.  We need n-1 advances,
+      * since the advance at index 0 is applied after glyph 0. */
+     xprev = glyphs[0].x;
+     yprev = glyphs[0].y;
+ 
+     cg_glyphs[0] = glyphs[0].index;
+ 
+@@ -2569,40 +2602,38 @@ _cairo_quartz_surface_show_glyphs (void 
+ 
+ #if 0
+     for (i = 0; i < num_glyphs; i++) {
+ 	ND((stderr, "[%d: %d %f,%f]\n", i, cg_glyphs[i], cg_advances[i].width, cg_advances[i].height));
+     }
+ #endif
+ 
+     /* Translate to the first glyph's position before drawing */
+-    ctm = CGContextGetCTM (surface->cgContext);
+-    CGContextTranslateCTM (surface->cgContext, glyphs[0].x, glyphs[0].y);
+-
+-    CGContextShowGlyphsWithAdvances (surface->cgContext,
++    ctm = CGContextGetCTM (state.context);
++    CGContextTranslateCTM (state.context, glyphs[0].x, glyphs[0].y);
++
++    CGContextShowGlyphsWithAdvances (state.context,
+ 				     cg_glyphs,
+ 				     cg_advances,
+ 				     num_glyphs);
+ 
+-    CGContextSetCTM (surface->cgContext, ctm);
+-
+-    if (action == DO_IMAGE || action == DO_TILED_IMAGE) {
+-	_cairo_quartz_draw_image (surface, op, action);
+-    } else if (action == DO_SHADING) {
+-	CGContextConcatCTM (surface->cgContext, surface->sourceTransform);
+-	CGContextDrawShading (surface->cgContext, surface->sourceShading);
++    CGContextSetCTM (state.context, ctm);
++
++    if (state.action == DO_IMAGE || state.action == DO_TILED_IMAGE) {
++	_cairo_quartz_draw_image (&state, op);
++    } else if (state.action == DO_SHADING) {
++	CGContextConcatCTM (state.context, state.transform);
++	CGContextDrawShading (state.context, state.shading);
+     }
+ 
+ BAIL:
+-    _cairo_quartz_teardown_source (surface, source);
+-
+     if (didForceFontSmoothing)
+-	CGContextSetAllowsFontSmoothingPtr (surface->cgContext, FALSE);
+-
+-    CGContextRestoreGState (surface->cgContext);
++        CGContextSetAllowsFontSmoothingPtr (state.context, FALSE);
++
++    _cairo_quartz_teardown_state (&state);
+ 
+     if (rv == CAIRO_STATUS_SUCCESS &&
+ 	cgfref &&
+ 	!_cairo_operator_bounded_by_mask (op))
+     {
+ 	unbounded_op_data_t ub;
+ 	ub.op = UNBOUNDED_SHOW_GLYPHS;
+