WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-surface.c

  *	Carl D. Worth
  */
 #include "cairoint.h"
 #include "cairo-array-private.h"
+#include "cairo-clip-inline.h"
-#include "cairo-surface-fallback-private.h"
+#include "cairo-clip-private.h"
-#include "cairo-clip-private.h"
+#include "cairo-damage-private.h"
+#include "cairo-device-private.h"
+#include "cairo-error-private.h"
-#include "cairo-device-private.h"
+#include "cairo-list-inline.h"
-#include "cairo-error-private.h"
+#include "cairo-image-surface-inline.h"
+#include "cairo-recording-surface-private.h"
-#include "cairo-recording-surface-private.h"
+#include "cairo-region-private.h"
-#include "cairo-region-private.h"
+#include "cairo-surface-inline.h"
 #include "cairo-tee-surface-private.h"
  * targets that cairo can render to.  The actual drawings are
  * performed using a cairo context.
+ *
  * A cairo surface is created by using backend-specific
  * constructors, typically of the form
  * cairo_backend_surface_create().
+ *
  * Most surface types allow accessing the surface without using Cairo
  * functions. If you do this, keep in mind that it is mandatory that you call
  * cairo_surface_flush() before reading from or writing to the surface and that
  * you must use cairo_surface_mark_dirty() after modifying it.
+ *
+ *
  * Note that for other surface types it might be necessary to acquire the
  * surface's device first. See cairo_device_acquire() for a discussion of
  * devices.
- */
+ **/
 #define DEFINE_NIL_SURFACE(status, name)			\
 const cairo_surface_t name = {					\
     NULL,				/* backend */		\
     NULL,				/* device */		\
     CAIRO_SURFACE_TYPE_IMAGE,		/* type */		\
     CAIRO_CONTENT_COLOR,		/* content */		\
     CAIRO_REFERENCE_COUNT_INVALID,	/* ref_count */		\
     status,				/* status */		\
+,					/* unique id */		\
+,					/* serial */		\
+    NULL,				/* damage */		\
-,					/* unique id */		\
+    FALSE,				/* _finishing */	\
     FALSE,				/* finished */		\
     TRUE,				/* is_clear */		\
     FALSE,				/* has_font_options */	\
     FALSE,				/* owns_device */	\
     { NULL, NULL },			/* snapshot */		\
     { CAIRO_ANTIALIAS_DEFAULT,		/* antialias */		\
       CAIRO_SUBPIXEL_ORDER_DEFAULT,	/* subpixel_order */	\
       CAIRO_LCD_FILTER_DEFAULT,		/* lcd_filter */	\
       CAIRO_HINT_STYLE_DEFAULT,		/* hint_style */	\
-      CAIRO_HINT_METRICS_DEFAULT	/* hint_metrics */	\
+      CAIRO_HINT_METRICS_DEFAULT,	/* hint_metrics */	\
+      CAIRO_ROUND_GLYPH_POS_DEFAULT	/* round_glyph_positions */	\
     }					/* font_options */	\
+}
 static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_STRIDE, _cairo_surface_nil_invalid_stride);
 static DEFINE_NIL_SURFACE(CAIRO_STATUS_INVALID_SIZE, _cairo_surface_nil_invalid_size);
 static DEFINE_NIL_SURFACE(CAIRO_STATUS_DEVICE_TYPE_MISMATCH, _cairo_surface_nil_device_type_mismatch);
 static DEFINE_NIL_SURFACE(CAIRO_STATUS_DEVICE_ERROR, _cairo_surface_nil_device_error);
+static DEFINE_NIL_SURFACE(CAIRO_INT_STATUS_UNSUPPORTED, _cairo_surface_nil_unsupported);
+static DEFINE_NIL_SURFACE(CAIRO_INT_STATUS_NOTHING_TO_DO, _cairo_surface_nil_nothing_to_do);
+static void _cairo_surface_finish_snapshots (cairo_surface_t *surface);
+static void _cairo_surface_finish (cairo_surface_t *surface);
 /**
  * _cairo_surface_set_error:
  * @surface: a surface
  * @status: a status value indicating an error
  * breakpoint in _cairo_error() to generate a stack trace for when the
  * user causes cairo to detect an error.
+ *
  * Return value: the error status.
  **/
-cairo_status_t
+cairo_int_status_t
 _cairo_surface_set_error (cairo_surface_t *surface,
-			  cairo_status_t status)
+			  cairo_int_status_t status)
+{
+    /* NOTHING_TO_DO is magic. We use it to break out of the inner-most
+     * surface function, but anything higher just sees "success".
+     */
     if (status == CAIRO_INT_STATUS_NOTHING_TO_DO)
-	status = CAIRO_STATUS_SUCCESS;
+	status = CAIRO_INT_STATUS_SUCCESS;
+    if (status == CAIRO_INT_STATUS_SUCCESS ||
-    if (status == CAIRO_STATUS_SUCCESS || status >= CAIRO_INT_STATUS_UNSUPPORTED)
+        status >= (int)CAIRO_INT_STATUS_LAST_STATUS)
-	return status;
+        return status;
     /* Don't overwrite an existing error. This preserves the first
      * error, which is the most significant. */
-    _cairo_status_set_error (&surface->status, status);
+    _cairo_status_set_error (&surface->status, (cairo_status_t)status);
      * special "wrapper" surfaces such as cairo_paginated_surface_t
      * can override surface->type with the type of the "child"
      * surface. */
     return surface->type;
+}
-slim_hidden_def (cairo_surface_get_type);
 /**
  * cairo_surface_get_content:
  * @surface: a #cairo_surface_t
 cairo_content_t
 cairo_surface_get_content (cairo_surface_t *surface)
+{
     return surface->content;
+}
-slim_hidden_def(cairo_surface_get_content);
 /**
  * cairo_surface_status:
  * @surface: a #cairo_surface_t
+ *
  * Return value: %CAIRO_STATUS_SUCCESS, %CAIRO_STATUS_NULL_POINTER,
  * %CAIRO_STATUS_NO_MEMORY, %CAIRO_STATUS_READ_ERROR,
  * %CAIRO_STATUS_INVALID_CONTENT, %CAIRO_STATUS_INVALID_FORMAT, or
  * %CAIRO_STATUS_INVALID_VISUAL.
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_surface_status (cairo_surface_t *surface)
+{
     return surface->status;
     cairo_surface_t *snapshot;
     cairo_list_foreach_entry (snapshot, cairo_surface_t,
 			      &surface->snapshots, snapshot)
-    {
 	/* XXX is_similar? */
 	if (snapshot->backend == backend)
 	    return snapshot;
+    }
     return NULL;
-}
-static cairo_bool_t
-_cairo_surface_is_writable (cairo_surface_t *surface)
-{
-    return ! surface->finished &&
-	   surface->snapshot_of == NULL &&
-	   ! _cairo_surface_has_snapshots (surface) &&
-	   ! _cairo_surface_has_mime_data (surface);
+}
-static void
+cairo_status_t
 _cairo_surface_begin_modification (cairo_surface_t *surface)
-{
-    assert (surface->status == CAIRO_STATUS_SUCCESS);
+{
-    assert (! surface->finished);
-    assert (surface->snapshot_of == NULL);
+    assert (surface->status == CAIRO_STATUS_SUCCESS);
     assert (! surface->finished);
     _cairo_surface_detach_snapshots (surface);
-    _cairo_surface_detach_mime_data (surface);
+    return _cairo_surface_flush (surface, 1);
     CAIRO_REFERENCE_COUNT_INIT (&surface->ref_count, 1);
     surface->status = CAIRO_STATUS_SUCCESS;
     surface->unique_id = _cairo_surface_allocate_unique_id ();
+    surface->finished = FALSE;
-    surface->finished = FALSE;
+    surface->_finishing = FALSE;
+    surface->is_clear = FALSE;
+    surface->serial = 0;
-    surface->is_clear = FALSE;
+    surface->damage = NULL;
     surface->owns_device = (device != NULL);
     cairo_surface_t *surface;
     if (unlikely (other->status))
+	return _cairo_surface_create_in_error (other->status);
-	return _cairo_surface_create_in_error (other->status);
+    surface = NULL;
+    if (other->backend->create_similar)
+	surface = other->backend->create_similar (other, content, width, height);
+    if (surface == NULL)
+	surface = cairo_surface_create_similar_image (other,
-    if (other->backend->create_similar == NULL)
-	return NULL;
+						      _cairo_format_from_content (content),
-    surface = other->backend->create_similar (other,
+						      width, height);
 					      content, width, height);
-    if (surface == NULL || surface->status)
+    if (unlikely (surface->status))
  * be examined with cairo_surface_get_type().
+ *
  * Initially the surface contents are all 0 (transparent if contents
  * have transparency, black otherwise.)
+ *
+ * Use cairo_surface_create_similar_image() if you need an image surface
+ * which can be painted quickly to the target surface.
+ *
  * Return value: a pointer to the newly allocated surface. The caller
  * owns the surface and should call cairo_surface_destroy() when done
  * with it.
+ *
  * This function always returns a valid pointer, but it will return a
  * pointer to a "nil" surface if @other is already in an error state
  * or any other error occurs.
+ *
+ * Since: 1.0
  **/
 cairo_surface_t *
 cairo_surface_create_similar (cairo_surface_t  *other,
 			      cairo_content_t	content,
 			      int		width,
 			      int		height)
+{
+    cairo_surface_t *surface;
     if (unlikely (other->status))
 	return _cairo_surface_create_in_error (other->status);
     if (unlikely (other->finished))
 	return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
+    if (unlikely (width < 0 || height < 0))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
     if (unlikely (! CAIRO_CONTENT_VALID (content)))
-	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_CONTENT));
+	return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_CONTENT);
-    return _cairo_surface_create_similar_solid (other,
+    surface = _cairo_surface_create_similar_solid (other,
+						   content, width, height,
+						   CAIRO_COLOR_TRANSPARENT);
+    assert (surface->is_clear);
+    return surface;
+}
+/**
+ * cairo_surface_create_similar_image:
+ * @other: an existing surface used to select the preference of the new surface
+ * @format: the format for the new surface
+ * @width: width of the new surface, (in device-space units)
+ * @height: height of the new surface (in device-space units)
+ *
+ * Create a new image surface that is as compatible as possible for uploading
+ * to and the use in conjunction with an existing surface. However, this surface
+ * can still be used like any normal image surface.
+ *
+ * Initially the surface contents are all 0 (transparent if contents
+ * have transparency, black otherwise.)
+ *
+ * Use cairo_surface_create_similar() if you don't need an image surface.
+ *
+ * Return value: a pointer to the newly allocated image surface. The caller
+ * owns the surface and should call cairo_surface_destroy() when done
+ * with it.
+ *
+ * This function always returns a valid pointer, but it will return a
+ * pointer to a "nil" surface if @other is already in an error state
+ * or any other error occurs.
+ *
+ * Since: 1.12
+ **/
+cairo_surface_t *
+cairo_surface_create_similar_image (cairo_surface_t  *other,
+				    cairo_format_t    format,
+				    int		width,
+				    int		height)
+{
+    cairo_surface_t *image;
+    if (unlikely (other->status))
+	return _cairo_surface_create_in_error (other->status);
+    if (unlikely (other->finished))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
+    if (unlikely (width < 0 || height < 0))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+    if (unlikely (! CAIRO_FORMAT_VALID (format)))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_FORMAT);
+    image = NULL;
+    if (other->backend->create_similar_image)
+	image = other->backend->create_similar_image (other,
+						      format, width, height);
+    if (image == NULL)
+	image = cairo_image_surface_create (format, width, height);
+    assert (image->is_clear);
+    return image;
+}
+slim_hidden_def (cairo_surface_create_similar_image);
+/**
+ * _cairo_surface_map_to_image:
+ * @surface: an existing surface used to extract the image from
+ * @extents: limit the extraction to an rectangular region
+ *
+ * Returns an image surface that is the most efficient mechanism for
+ * modifying the backing store of the target surface. The region
+ * retrieved is limited to @extents.
+ *
+ * Note, the use of the original surface as a target or source whilst
+ * it is mapped is undefined. The result of mapping the surface
+ * multiple times is undefined. Calling cairo_surface_destroy() or
+ * cairo_surface_finish() on the resulting image surface results in
+ * undefined behavior. Changing the device transform of the image
+ * surface or of @surface before the image surface is unmapped results
+ * in undefined behavior.
+ *
+ * Assumes that @surface is valid (CAIRO_STATUS_SUCCESS,
+ * non-finished).
+ *
+ * Return value: a pointer to the newly allocated image surface. The
+ * caller must use _cairo_surface_unmap_image() to destroy this image
+ * surface.
+ *
+ * This function always returns a valid pointer, but it will return a
+ * pointer to a "nil" surface if @other is already in an error state
+ * or any other error occurs.
+ *
+ * The returned image might have a %CAIRO_FORMAT_INVALID format.
+ **/
+cairo_image_surface_t *
+_cairo_surface_map_to_image (cairo_surface_t  *surface,
+			     const cairo_rectangle_int_t *extents)
+{
+    cairo_image_surface_t *image = NULL;
+    assert (extents != NULL);
+    /* TODO: require map_to_image != NULL */
+    if (surface->backend->map_to_image)
+	image = surface->backend->map_to_image (surface, extents);
+    if (image == NULL)
+	image = _cairo_image_surface_clone_subimage (surface, extents);
+    return image;
+}
+/**
+ * _cairo_surface_unmap_image:
+ * @surface: the surface passed to _cairo_surface_map_to_image().
+ * @image: the currently mapped image
+ *
+ * Unmaps the image surface as returned from
+ * _cairo_surface_map_to_image().
+ *
+ * The content of the image will be uploaded to the target surface.
+ * Afterwards, the image is destroyed.
+ *
+ * Using an image surface which wasn't returned by
+ * _cairo_surface_map_to_image() results in undefined behavior.
+ *
+ * An image surface in error status can be passed to
+ * _cairo_surface_unmap_image().
+ *
+ * Return value: the unmap status.
+ *
+ * Even if the unmap status is not successful, @image is destroyed.
+ **/
+cairo_int_status_t
+_cairo_surface_unmap_image (cairo_surface_t       *surface,
+			    cairo_image_surface_t *image)
+{
+    cairo_surface_pattern_t pattern;
+    cairo_rectangle_int_t extents;
+    cairo_clip_t *clip;
+    cairo_int_status_t status;
+    /* map_to_image can return error surfaces */
+    if (unlikely (image->base.status)) {
+	status = image->base.status;
+	goto destroy;
+    }
+    /* If the image is untouched just skip the update */
+    if (image->base.serial == 0) {
+	status = CAIRO_STATUS_SUCCESS;
+	goto destroy;
+    }
+    /* TODO: require unmap_image != NULL */
+    if (surface->backend->unmap_image &&
+	! _cairo_image_surface_is_clone (image))
+    {
+	status = surface->backend->unmap_image (surface, image);
+	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+	    return status;
+    }
+    _cairo_pattern_init_for_surface (&pattern, &image->base);
+    pattern.base.filter = CAIRO_FILTER_NEAREST;
+    /* We have to apply the translate from map_to_image's extents.x and .y */
+    cairo_matrix_init_translate (&pattern.base.matrix,
+				 image->base.device_transform.x0,
+				 image->base.device_transform.y0);
+    /* And we also have to clip the operation to the image's extents */
+    extents.x = image->base.device_transform_inverse.x0;
+    extents.y = image->base.device_transform_inverse.y0;
+    extents.width  = image->width;
+    extents.height = image->height;
+    clip = _cairo_clip_intersect_rectangle (NULL, &extents);
+    status = _cairo_surface_paint (surface,
-						content, width, height,
+				   CAIRO_OPERATOR_SOURCE,
+				   &pattern.base,
+				   clip);
+    _cairo_pattern_fini (&pattern.base);
+    _cairo_clip_destroy (clip);
+destroy:
+    cairo_surface_finish (&image->base);
+    cairo_surface_destroy (&image->base);
+    return status;
+}
+/**
+ * cairo_surface_map_to_image:
+ * @surface: an existing surface used to extract the image from
+ * @extents: limit the extraction to an rectangular region
+ *
+ * Returns an image surface that is the most efficient mechanism for
+ * modifying the backing store of the target surface. The region retrieved
+ * may be limited to the @extents or %NULL for the whole surface
+ *
+ * Note, the use of the original surface as a target or source whilst
+ * it is mapped is undefined. The result of mapping the surface
+ * multiple times is undefined. Calling cairo_surface_destroy() or
+ * cairo_surface_finish() on the resulting image surface results in
+ * undefined behavior. Changing the device transform of the image
+ * surface or of @surface before the image surface is unmapped results
+ * in undefined behavior.
+ *
+ * Return value: a pointer to the newly allocated image surface. The caller
+ * must use cairo_surface_unmap_image() to destroy this image surface.
+ *
+ * This function always returns a valid pointer, but it will return a
+ * pointer to a "nil" surface if @other is already in an error state
+ * or any other error occurs. If the returned pointer does not have an
+ * error status, it is guaranteed to be an image surface whose format
+ * is not %CAIRO_FORMAT_INVALID.
+ *
+ * Since: 1.12
+ **/
+cairo_surface_t *
+cairo_surface_map_to_image (cairo_surface_t  *surface,
+			    const cairo_rectangle_int_t *extents)
+{
+    cairo_rectangle_int_t rect;
+    cairo_image_surface_t *image;
+    cairo_status_t status;
+    if (unlikely (surface->status))
+	return _cairo_surface_create_in_error (surface->status);
+    if (unlikely (surface->finished))
+	return _cairo_surface_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
+    if (extents == NULL) {
+	if (unlikely (! surface->backend->get_extents (surface, &rect)))
+	    return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+	extents = ▭
+    } else {
+	cairo_rectangle_int_t surface_extents;
+	/* If this surface is bounded, we can't map parts
+	 * that are outside of it. */
+	if (likely (surface->backend->get_extents (surface, &surface_extents))) {
+	    if (unlikely (! _cairo_rectangle_contains_rectangle (&surface_extents, extents)))
+		return _cairo_surface_create_in_error (CAIRO_STATUS_INVALID_SIZE);
+	}
+    }
+    image = _cairo_surface_map_to_image (surface, extents);
+    status = image->base.status;
+    if (unlikely (status)) {
+	cairo_surface_destroy (&image->base);
+	return _cairo_surface_create_in_error (status);
+    }
+    if (image->format == CAIRO_FORMAT_INVALID) {
+	cairo_surface_destroy (&image->base);
+	image = _cairo_image_surface_clone_subimage (surface, extents);
+    }
+    return &image->base;
+}
+/**
+ * cairo_surface_unmap_image:
+ * @surface: the surface passed to cairo_surface_map_to_image().
+ * @image: the currently mapped image
+ *
+ * Unmaps the image surface as returned from #cairo_surface_map_to_image().
+ *
+ * The content of the image will be uploaded to the target surface.
+ * Afterwards, the image is destroyed.
+ *
+ * Using an image surface which wasn't returned by cairo_surface_map_to_image()
+ * results in undefined behavior.
+ *
+ * Since: 1.12
+ **/
+void
+cairo_surface_unmap_image (cairo_surface_t *surface,
+			   cairo_surface_t *image)
+{
+    cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
+    if (unlikely (surface->status)) {
+	status = surface->status;
+	goto error;
+    }
+    if (unlikely (surface->finished)) {
+	status = _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+	goto error;
+    }
+    if (unlikely (image->status)) {
+	status = image->status;
+	goto error;
+    }
+    if (unlikely (image->finished)) {
+	status = _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
+	goto error;
+    }
+    if (unlikely (! _cairo_surface_is_image (image))) {
+	status = _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
+	goto error;
+    }
+    status = _cairo_surface_unmap_image (surface,
+					 (cairo_image_surface_t *) image);
+    if (unlikely (status))
+	_cairo_surface_set_error (surface, status);
+    return;
+error:
+    _cairo_surface_set_error (surface, status);
-						CAIRO_COLOR_TRANSPARENT,
+    cairo_surface_finish (image);
-						TRUE);
+    cairo_surface_destroy (image);
+}
 cairo_surface_t *
 _cairo_surface_create_similar_solid (cairo_surface_t	 *other,
 				     cairo_content_t	  content,
-				     int		  width,
-				     int		  height,
+				     int		  width,
-				     const cairo_color_t *color,
+				     int		  height,
-				     cairo_bool_t allow_fallback)
+				     const cairo_color_t *color)
+{
     cairo_status_t status;
     cairo_surface_t *surface;
-    cairo_solid_pattern_t pattern;
-    surface = _cairo_surface_create_similar_scratch (other, content,
-						     width, height);
+    cairo_solid_pattern_t pattern;
     if (surface == NULL && allow_fallback)
-	surface = _cairo_image_surface_create_with_content (content,
+    surface = _cairo_surface_create_similar_scratch (other, content,
-							    width, height);
+						     width, height);
-    if (surface == NULL || surface->status)
+    if (unlikely (surface->status))
+    }
     return surface;
-}
-cairo_surface_t *
-_cairo_surface_create_solid_pattern_surface (cairo_surface_t	   *other,
-					     const cairo_solid_pattern_t *solid_pattern)
-{
-    if (other->backend->create_solid_pattern_surface != NULL) {
-	cairo_surface_t *surface;
-	surface = other->backend->create_solid_pattern_surface (other,
-								solid_pattern);
-	if (surface)
-	    return surface;
-    }
-    return _cairo_surface_create_similar_solid (other,
-						_cairo_color_get_content (&solid_pattern->color),
-, 1,
-						&solid_pattern->color,
-						FALSE);
-}
-cairo_int_status_t
-_cairo_surface_repaint_solid_pattern_surface (cairo_surface_t	    *other,
-					      cairo_surface_t       *solid_surface,
-					      const cairo_solid_pattern_t *solid_pattern)
-{
-    /* Solid pattern surface for these backends are special and not trivial
-     * to repaint.  Skip repainting.
-     *
-     * This does not work optimally with things like analysis surface that
-     * are proxies.  But returning UNSUPPORTED is *safe* as it only
-     * disables some caching.
-     */
-    if (other->backend->create_solid_pattern_surface != NULL &&
-	! other->backend->can_repaint_solid_pattern_surface (solid_surface,
-							     solid_pattern))
-    {
-	return CAIRO_INT_STATUS_UNSUPPORTED;
-    }
-    return _cairo_surface_paint (solid_surface,
-				 CAIRO_OPERATOR_SOURCE,
-				 &solid_pattern->base,
-				 NULL);
+}
 /**
  * cairo_surface_reference:
  * @surface: a #cairo_surface_t
+ *
  * The number of references to a #cairo_surface_t can be get using
  * cairo_surface_get_reference_count().
+ *
  * Return value: the referenced #cairo_surface_t.
+ *
+ * Since: 1.0
  **/
 cairo_surface_t *
 cairo_surface_reference (cairo_surface_t *surface)
+{
     if (surface == NULL ||
  * @surface: a #cairo_surface_t
+ *
  * Decreases the reference count on @surface by one. If the result is
  * zero, then @surface and all associated resources are freed.  See
  * cairo_surface_reference().
+ *
+ * Since: 1.0
  **/
 void
 cairo_surface_destroy (cairo_surface_t *surface)
+{
     if (surface == NULL ||
     if (! _cairo_reference_count_dec_and_test (&surface->ref_count))
 	return;
     assert (surface->snapshot_of == NULL);
+    if (! surface->finished) {
+	_cairo_surface_finish_snapshots (surface);
+	/* We may have been referenced by a snapshot prior to have
+	 * detaching it with the copy-on-write.
+	 */
-    if (! surface->finished)
+	if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count))
+	    return;
+	_cairo_surface_finish (surface);
-	cairo_surface_finish (surface);
+    }
-    /* paranoid check that nobody took a reference whilst finishing */
+    if (surface->damage)
-    assert (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count));
+	_cairo_damage_destroy (surface->damage);
+    _cairo_user_data_array_fini (&surface->user_data);
+    _cairo_user_data_array_fini (&surface->mime_data);
+    if (surface->owns_device)
+        cairo_device_destroy (surface->device);
     _cairo_user_data_array_fini (&surface->user_data);
-    _cairo_user_data_array_fini (&surface->mime_data);
+    assert (surface->snapshot_of == NULL);
     assert (! _cairo_surface_has_snapshots (surface));
-    if (surface->owns_device)
+    /* paranoid check that nobody took a reference whilst finishing */
 	return 0;
     return CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count);
+}
+static void
+_cairo_surface_finish_snapshots (cairo_surface_t *surface)
+{
+    cairo_status_t status;
+    /* update the snapshots *before* we declare the surface as finished */
+    surface->_finishing = TRUE;
+    status = _cairo_surface_flush (surface, 0);
+    (void) status;
+}
+static void
+_cairo_surface_finish (cairo_surface_t *surface)
+{
+    cairo_status_t status;
+    surface->finished = TRUE;
+    /* call finish even if in error mode */
+    if (surface->backend->finish) {
+	status = surface->backend->finish (surface);
+	if (unlikely (status))
+	    _cairo_surface_set_error (surface, status);
+    }
+    assert (surface->snapshot_of == NULL);
+    assert (!_cairo_surface_has_snapshots (surface));
+}
 /**
  * cairo_surface_finish:
  * @surface: the #cairo_surface_t to finish
+ *
  * When the last call to cairo_surface_destroy() decreases the
  * reference count to zero, cairo will call cairo_surface_finish() if
  * it hasn't been called already, before freeing the resources
  * associated with the surface.
+ *
+ * Since: 1.0
  **/
 void
 cairo_surface_finish (cairo_surface_t *surface)
+{
-    cairo_status_t status;
     if (surface == NULL)
 	return;
     if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
 	return;
     if (surface->finished)
 	return;
-    /* update the snapshots *before* we declare the surface as finished */
-    _cairo_surface_detach_snapshots (surface);
+    /* We have to be careful when decoupling potential reference cycles */
-    if (surface->snapshot_of != NULL)
+    cairo_surface_reference (surface);
-	_cairo_surface_detach_snapshot (surface);
-    cairo_surface_flush (surface);
-    surface->finished = TRUE;
-    /* call finish even if in error mode */
-    if (surface->backend->finish) {
+    _cairo_surface_finish_snapshots (surface);
-	status = surface->backend->finish (surface);
+    /* XXX need to block and wait for snapshot references */
-	if (unlikely (status))
+    _cairo_surface_finish (surface);
 	    status = _cairo_surface_set_error (surface, status);
  * Return user data previously attached to @surface using the specified
  * key.  If no user data has been attached with the given key this
  * function returns %NULL.
+ *
  * Return value: the user data previously attached or %NULL.
+ *
+ * Since: 1.0
  **/
 void *
 cairo_surface_get_user_data (cairo_surface_t		 *surface,
 			     const cairo_user_data_key_t *key)
+{
+    /* Prevent reads of the array during teardown */
-    return _cairo_user_data_array_get_data (&surface->user_data,
+    if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
-					    key);
+	return NULL;
+    return _cairo_user_data_array_get_data (&surface->user_data, key);
+}
 /**
  * cairo_surface_set_user_data:
  * call this function with the key that was used to set it and %NULL
  * for @data.
+ *
  * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY if a
  * slot could not be allocated for the user data.
+ *
+ * Since: 1.0
  **/
 cairo_status_t
 cairo_surface_set_user_data (cairo_surface_t		 *surface,
 			     const cairo_user_data_key_t *key,
 			     void			 *user_data,
 			     cairo_destroy_func_t	 destroy)
+{
     if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
 	return surface->status;
+    if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
+	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
     return _cairo_user_data_array_set_data (&surface->user_data,
 					    key, user_data, destroy);
+}
     cairo_user_data_slot_t *slots;
     int i, num_slots;
     *data = NULL;
+    *length = 0;
-    *length = 0;
+    /* Prevent reads of the array during teardown */
-    if (unlikely (surface->status))
+    if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
 	return;
     /* The number of mime-types attached to a surface is usually small,
      * typically zero. Therefore it is quicker to do a strcmp() against
      * each key than it is to intern the string (i.e. compute a hash,
      * search the hash table, and do a final strcmp).
      */
     num_slots = surface->mime_data.num_elements;
     slots = _cairo_array_index (&surface->mime_data, 0);
     for (i = 0; i < num_slots; i++) {
-	if (strcmp ((char *) slots[i].key, mime_type) == 0) {
+	if (slots[i].key != NULL && strcmp ((char *) slots[i].key, mime_type) == 0) {
 	    cairo_mime_data_t *mime_data = slots[i].user_data;
 /**
  * CAIRO_MIME_TYPE_JP2:
+ *
  * The Joint Photographic Experts Group (JPEG) 2000 image coding standard (ISO/IEC 15444-1).
+ *
- * @Since: 1.10
+ * Since: 1.10
- */
+ **/
 /**
  * CAIRO_MIME_TYPE_JPEG:
+ *
  * The Joint Photographic Experts Group (JPEG) image coding standard (ISO/IEC 10918-1).
  *
- * @Since: 1.10
+ * Since: 1.10
- */
+ **/
 /**
  * CAIRO_MIME_TYPE_PNG:
+ *
  * The Portable Network Graphics image file format (ISO/IEC 15948).
  *
- * @Since: 1.10
+ * Since: 1.10
- */
+ **/
 /**
  * CAIRO_MIME_TYPE_URI:
  *
+ * URI for an image file (unofficial MIME type).
+ *
+ * Since: 1.10
+ **/
+/**
+ * CAIRO_MIME_TYPE_UNIQUE_ID:
+ *
- * URI for an image file (unofficial MIME type).
+ * Unique identifier for a surface (cairo specific MIME type).
+ *
- * @Since: 1.10
+ * Since: 1.12
- */
+ **/
  * surfaces) to emit this data instead of making a snapshot of the
  * @surface.  This approach tends to be faster and requires less
  * memory and disk space.
+ *
  * The recognized MIME types are the following: %CAIRO_MIME_TYPE_JPEG,
- * %CAIRO_MIME_TYPE_PNG, %CAIRO_MIME_TYPE_JP2, %CAIRO_MIME_TYPE_URI.
+ * %CAIRO_MIME_TYPE_PNG, %CAIRO_MIME_TYPE_JP2, %CAIRO_MIME_TYPE_URI,
+ * %CAIRO_MIME_TYPE_UNIQUE_ID.
+ *
  * See corresponding backend surface docs for details about which MIME
  * types it can handle. Caution: the associated MIME data will be
  * discarded if you draw on the surface afterwards. Use this function
  * with care.
+ *
- * Since: 1.10
- *
  * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY if a
  * slot could not be allocated for the user data.
+ *
+ * Since: 1.10
  **/
 cairo_status_t
 cairo_surface_set_mime_data (cairo_surface_t		*surface,
                              const char			*mime_type,
                              const unsigned char	*data,
 			     void			*closure)
+{
     cairo_status_t status;
     cairo_mime_data_t *mime_data;
+    if (CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count))
+	return surface->status;
+    if (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count))
+	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
     if (unlikely (surface->status))
 	return surface->status;
-    if (surface->finished)
+    if (unlikely (surface->finished))
 	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
     status = _cairo_intern_string (&mime_type, -1);
     status = _cairo_user_data_array_set_data (&surface->mime_data,
 					      (cairo_user_data_key_t *) mime_type,
 					      mime_data,
 					      _cairo_mime_data_destroy);
     if (unlikely (status)) {
-	if (mime_data != NULL)
-	    free (mime_data);
+	free (mime_data);
 	return _cairo_surface_set_error (surface, status);
+    }
     return CAIRO_STATUS_SUCCESS;
+}
+slim_hidden_def (cairo_surface_set_mime_data);
+/**
+ * cairo_surface_supports_mime_type:
+ * @surface: a #cairo_surface_t
+ * @mime_type: the mime type
+ *
+ * Return whether @surface supports @mime_type.
+ *
+ * Return value: %TRUE if @surface supports
+ *               @mime_type, %FALSE otherwise
+ *
+ * Since: 1.12
+ **/
+cairo_bool_t
+cairo_surface_supports_mime_type (cairo_surface_t		*surface,
+				  const char			*mime_type)
+{
+    const char **types;
+    if (unlikely (surface->status))
+	return FALSE;
+    if (unlikely (surface->finished)) {
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	return FALSE;
+    }
+    if (surface->backend->get_supported_mime_types) {
+	types = surface->backend->get_supported_mime_types (surface);
+	if (types) {
+	    while (*types) {
+		if (strcmp (*types, mime_type) == 0)
+		    return TRUE;
+		types++;
+	    }
+	}
+    }
+    return FALSE;
+}
-slim_hidden_def (cairo_surface_set_mime_data);
+slim_hidden_def (cairo_surface_supports_mime_type);
 static void
  **/
 void
 _cairo_surface_set_font_options (cairo_surface_t       *surface,
 				 cairo_font_options_t  *options)
+{
-    cairo_status_t status;
     if (surface->status)
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
-	status = _cairo_surface_set_error (surface,
+    if (surface->finished) {
-		                           _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
 	return;
+    }
  * Retrieves the default font rendering options for the surface.
  * This allows display surfaces to report the correct subpixel order
  * for rendering on them, print surfaces to disable hinting of
  * metrics and so forth. The result can then be used with
  * cairo_scaled_font_create().
+ *
+ * Since: 1.0
  **/
 void
 cairo_surface_get_font_options (cairo_surface_t       *surface,
 				cairo_font_options_t  *options)
+{
     _cairo_font_options_init_copy (options, &surface->font_options);
+}
+slim_hidden_def (cairo_surface_get_font_options);
+cairo_status_t
+_cairo_surface_flush (cairo_surface_t *surface, unsigned flags)
+{
+    /* update the current snapshots *before* the user updates the surface */
+    _cairo_surface_detach_snapshots (surface);
+    if (surface->snapshot_of != NULL)
+	_cairo_surface_detach_snapshot (surface);
+    _cairo_surface_detach_mime_data (surface);
+    return __cairo_surface_flush (surface, flags);
 slim_hidden_def (cairo_surface_get_font_options);
 /**
  * cairo_surface_flush:
  * @surface: a #cairo_surface_t
+ *
  * Do any pending drawing for the surface and also restore any
  * temporary modifications cairo has made to the surface's
  * state. This function must be called before switching from
  * drawing on the surface with cairo to drawing on it directly
+ * with native APIs. If the surface doesn't support direct access,
+ * then this function does nothing.
  * with native APIs. If the surface doesn't support direct access,
- * then this function does nothing.
+ * Since: 1.0
  **/
 void
 cairo_surface_flush (cairo_surface_t *surface)
 	return;
     if (surface->finished)
-	return;
-    /* update the current snapshots *before* the user updates the surface */
-    _cairo_surface_detach_snapshots (surface);
+	return;
     if (surface->backend->flush) {
-	status = surface->backend->flush (surface);
+    status = _cairo_surface_flush (surface, 0);
-	if (unlikely (status))
-	    status = _cairo_surface_set_error (surface, status);
+    if (unlikely (status))
 	_cairo_surface_set_error (surface, status);
+}
 slim_hidden_def (cairo_surface_flush);
 /**
  * cairo_surface_mark_dirty:
  * @surface: a #cairo_surface_t
+ *
+ * Tells cairo that drawing has been done to surface using means other
+ * than cairo, and that cairo should reread any cached areas. Note
- * Tells cairo that drawing has been done to surface using means other
+ * that you must call cairo_surface_flush() before doing such drawing.
  * than cairo, and that cairo should reread any cached areas. Note
- * that you must call cairo_surface_flush() before doing such drawing.
+ * Since: 1.0
- */
+ **/
+void
+cairo_surface_mark_dirty (cairo_surface_t *surface)
+{
+    cairo_rectangle_int_t extents;
+    if (unlikely (surface->status))
+	return;
+    if (unlikely (surface->finished)) {
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	return;
-void
+    }
+    _cairo_surface_get_extents (surface, &extents);
-cairo_surface_mark_dirty (cairo_surface_t *surface)
+    cairo_surface_mark_dirty_rectangle (surface,
 					extents.x, extents.y,
-    cairo_surface_mark_dirty_rectangle (surface, 0, 0, -1, -1);
+					extents.width, extents.height);
+}
  * for other parts of the surface.
+ *
  * Any cached clip set on the surface will be reset by this function,
  * to make sure that future cairo calls have the clip set that they
  * expect.
+ *
+ * Since: 1.0
- */
+ **/
 void
 cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface,
 				    int              x,
 				    int              y,
 				    int              width,
 				    int              height)
+{
     cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
+    if (unlikely (surface->finished)) {
-	status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
 	return;
+    }
     /* The application *should* have called cairo_surface_flush() before
      * modifying the surface independently of cairo (and thus having to
+     * call mark_dirty()). */
+    assert (! _cairo_surface_has_snapshots (surface));
+    assert (! _cairo_surface_has_mime_data (surface));
+    surface->is_clear = FALSE;
+    surface->serial++;
+    if (surface->damage) {
+	cairo_box_t box;
+	box.p1.x = x;
+	box.p1.y = y;
-     * call mark_dirty()). */
+	box.p2.x = x + width;
-    assert (! _cairo_surface_has_snapshots (surface));
+	box.p2.y = y + height;
     assert (! _cairo_surface_has_mime_data (surface));
 	surface->damage = _cairo_damage_add_box (surface->damage, &box);
                                                          x + surface->device_transform.x0,
                                                          y + surface->device_transform.y0,
 							 width, height);
 	if (unlikely (status))
-	    status = _cairo_surface_set_error (surface, status);
+	    _cairo_surface_set_error (surface, status);
+    }
+}
 slim_hidden_def (cairo_surface_mark_dirty_rectangle);
 				 double		  sx,
 				 double		  sy)
+{
     cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
+    if (unlikely (surface->finished)) {
-	status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	return;
+    }
+    status = _cairo_surface_begin_modification (surface);
-	return;
+    if (unlikely (status)) {
 	_cairo_surface_set_error (surface, status);
 	return;
     _cairo_surface_begin_modification (surface);
  * sufficient to do this, since functions like
  * cairo_device_to_user() will expose the hidden offset.
+ *
  * Note that the offset affects drawing to the surface as well as
  * using the surface in a source pattern.
+ *
+ * Since: 1.0
  **/
 void
 cairo_surface_set_device_offset (cairo_surface_t *surface,
 				 double           x_offset,
 				 double           y_offset)
+{
     cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
+    if (unlikely (surface->finished)) {
-	status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	return;
+    }
+    status = _cairo_surface_begin_modification (surface);
-	return;
+    if (unlikely (status)) {
 	_cairo_surface_set_error (surface, status);
 	return;
 				       double		 x_pixels_per_inch,
 				       double		 y_pixels_per_inch)
+{
     cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
+    if (unlikely (surface->finished)) {
-	status = _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+	_cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
 	return;
+    }
     if (x_pixels_per_inch <= 0 || y_pixels_per_inch <= 0) {
 	/* XXX Could delay raising the error until we fallback, but throwing
 	 * the error here means that we can catch the real culprit.
 	 */
+	_cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_MATRIX);
+	return;
+    }
-	status = _cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_MATRIX);
+    status = _cairo_surface_begin_modification (surface);
-	return;
+    if (unlikely (status)) {
 	_cairo_surface_set_error (surface, status);
 	return;
 				     cairo_image_surface_t  **image_out,
 				     void                   **image_extra)
+{
     cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return surface->status;
     _cairo_debug_check_image_surface_is_defined (&(*image_out)->base);
     return CAIRO_STATUS_SUCCESS;
+}
+cairo_status_t
+_cairo_surface_default_acquire_source_image (void                    *_surface,
+					     cairo_image_surface_t  **image_out,
+					     void                   **image_extra)
+{
+    cairo_surface_t *surface = _surface;
+    cairo_rectangle_int_t extents;
+    if (unlikely (! surface->backend->get_extents (surface, &extents)))
+	return _cairo_error (CAIRO_STATUS_INVALID_SIZE);
+    *image_out = _cairo_surface_map_to_image (surface, &extents);
+    *image_extra = NULL;
+    return (*image_out)->base.status;
+}
 /**
  * _cairo_surface_release_source_image:
  * @surface: a #cairo_surface_t
     if (surface->backend->release_source_image)
 	surface->backend->release_source_image (surface, image, image_extra);
-}
-/**
- * _cairo_surface_acquire_dest_image:
- * @surface: a #cairo_surface_t
- * @interest_rect: area of @surface for which fallback drawing is being done.
- *    A value of %NULL indicates that the entire surface is desired.
- *    XXXX I'd like to get rid of being able to pass %NULL here (nothing seems to)
- * @image_out: location to store a pointer to an image surface that includes at least
- *    the intersection of @interest_rect with the visible area of @surface.
- *    This surface could be @surface itself, a surface held internal to @surface,
- *    or it could be a new surface with a copy of the relevant portion of @surface.
- *    If a new surface is created, it should have the same channels and depth
- *    as @surface so that copying to and from it is exact.
- * @image_rect: location to store area of the original surface occupied
- *    by the surface stored in @image.
- * @image_extra: location to store image specific backend data
- *
- * Retrieves a local image for a surface for implementing a fallback drawing
- * operation. After calling this function, the implementation of the fallback
- * drawing operation draws the primitive to the surface stored in @image_out
- * then calls _cairo_surface_release_dest_image(),
- * which, if a temporary surface was created, copies the bits back to the
- * main surface and frees the temporary surface.
- *
- * Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY.
- *  %CAIRO_INT_STATUS_UNSUPPORTED can be returned but this will mean that
- *  the backend can't draw with fallbacks. It's possible for the routine
- *  to store %NULL in @local_out and return %CAIRO_STATUS_SUCCESS;
- *  that indicates that no part of @interest_rect is visible, so no drawing
- *  is necessary. _cairo_surface_release_dest_image() should not be called in that
- *  case.
- **/
-cairo_status_t
-_cairo_surface_acquire_dest_image (cairo_surface_t         *surface,
-				   cairo_rectangle_int_t   *interest_rect,
-				   cairo_image_surface_t  **image_out,
-				   cairo_rectangle_int_t   *image_rect,
-				   void                   **image_extra)
-{
-    cairo_status_t status;
-    if (surface->status)
-	return surface->status;
-    assert (_cairo_surface_is_writable (surface));
-    if (surface->backend->acquire_dest_image == NULL)
-	return CAIRO_INT_STATUS_UNSUPPORTED;
-    status = surface->backend->acquire_dest_image (surface,
-						   interest_rect,
-						   image_out,
-						   image_rect,
-						   image_extra);
-    if (unlikely (status))
-	return _cairo_surface_set_error (surface, status);
-    _cairo_debug_check_image_surface_is_defined (&(*image_out)->base);
-    return CAIRO_STATUS_SUCCESS;
-}
-/**
- * _cairo_surface_release_dest_image:
- * @surface: a #cairo_surface_t
- * @interest_rect: same as passed to the matching _cairo_surface_acquire_dest_image()
- * @image: same as returned from the matching _cairo_surface_acquire_dest_image()
- * @image_rect: same as returned from the matching _cairo_surface_acquire_dest_image()
- * @image_extra: same as return from the matching _cairo_surface_acquire_dest_image()
- *
- * Finishes the operation started with _cairo_surface_acquire_dest_image(), by, if
- * necessary, copying the image from @image back to @surface and freeing any
  * resources that were allocated.
- **/
-void
-_cairo_surface_release_dest_image (cairo_surface_t         *surface,
+void
-				   cairo_rectangle_int_t   *interest_rect,
-				   cairo_image_surface_t   *image,
+_cairo_surface_default_release_source_image (void                   *surface,
-				   cairo_rectangle_int_t   *image_rect,
+					     cairo_image_surface_t  *image,
-				   void                    *image_extra)
-{
-    assert (_cairo_surface_is_writable (surface));
-    if (surface->backend->release_dest_image)
-	surface->backend->release_dest_image (surface, interest_rect,
-					      image, image_rect, image_extra);
-}
-static cairo_status_t
-_cairo_recording_surface_clone_similar (cairo_surface_t  *surface,
-					cairo_surface_t  *src,
-					int               src_x,
-					int               src_y,
-					int               width,
-					int               height,
-					int              *clone_offset_x,
-					int              *clone_offset_y,
-					cairo_surface_t **clone_out)
-{
-    cairo_recording_surface_t *recorder = (cairo_recording_surface_t *) src;
+					     void                   *image_extra)
-    cairo_surface_t *similar;
-    cairo_status_t status;
-    similar = _cairo_surface_has_snapshot (src, surface->backend);
-    if (similar != NULL) {
-	*clone_out = cairo_surface_reference (similar);
-	*clone_offset_x = 0;
-	*clone_offset_y = 0;
-	return CAIRO_STATUS_SUCCESS;
-    }
-    if (recorder->unbounded ||
-	width*height*8 < recorder->extents.width*recorder->extents.height)
-    {
-	similar = _cairo_surface_create_similar_solid (surface,
-						       src->content,
-						       width, height,
-                                                       CAIRO_COLOR_TRANSPARENT,
-                                                       FALSE);
-	if (similar == NULL)
-	    return CAIRO_INT_STATUS_UNSUPPORTED;
-	if (unlikely (similar->status))
-	    return similar->status;
-	cairo_surface_set_device_offset (similar, -src_x, -src_y);
-	status = _cairo_recording_surface_replay (src, similar);
-	if (unlikely (status)) {
-	    cairo_surface_destroy (similar);
-	    return status;
-	}
-    } else {
-	similar = _cairo_surface_create_similar_scratch (surface,
-							 src->content,
-							 recorder->extents.width,
-							 recorder->extents.height);
-	if (similar == NULL)
-	    return CAIRO_INT_STATUS_UNSUPPORTED;
-	if (unlikely (similar->status))
-	    return similar->status;
-	status = _cairo_recording_surface_replay (src, similar);
-	if (unlikely (status)) {
-	    cairo_surface_destroy (similar);
-	    return status;
-	}
-	_cairo_surface_attach_snapshot (src, similar, NULL);
-	src_x = src_y = 0;
-    }
-    *clone_out = similar;
-    *clone_offset_x = src_x;
-    *clone_offset_y = src_y;
-    return CAIRO_STATUS_SUCCESS;
-}
-/**
- * _cairo_surface_clone_similar:
- * @surface: a #cairo_surface_t
- * @src: the source image
- * @content: target content mask
- * @src_x: extent for the rectangle in src we actually care about
- * @src_y: extent for the rectangle in src we actually care about
- * @width: extent for the rectangle in src we actually care about
- * @height: extent for the rectangle in src we actually care about
- * @clone_out: location to store a surface compatible with @surface
- *   and with contents identical to @src. The caller must call
- *   cairo_surface_destroy() on the result.
- *
- * Creates a surface with contents identical to @src but that
- *   can be used efficiently with @surface. If @surface and @src are
- *   already compatible then it may return a new reference to @src.
- *
- * Return value: %CAIRO_STATUS_SUCCESS if a surface was created and stored
- *   in @clone_out. Otherwise %CAIRO_INT_STATUS_UNSUPPORTED or another
- *   error like %CAIRO_STATUS_NO_MEMORY.
- **/
-cairo_status_t
-_cairo_surface_clone_similar (cairo_surface_t  *surface,
-			      cairo_surface_t  *src,
-			      int               src_x,
-			      int               src_y,
-			      int               width,
-			      int               height,
-			      int              *clone_offset_x,
-			      int              *clone_offset_y,
-			      cairo_surface_t **clone_out)
-{
-    cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED;
-    cairo_image_surface_t *image;
-    void *image_extra;
-    if (unlikely (surface->status))
-	return surface->status;
-    if (unlikely (surface->finished))
-	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
-#if CAIRO_HAS_TEE_SURFACE
-    if (src->type == CAIRO_SURFACE_TYPE_TEE) {
-	cairo_surface_t *match;
-	match = _cairo_tee_surface_find_match (src,
-					       surface->backend,
-					       src->content);
-	if (match != NULL)
-	    src = match;
-    }
-#endif
-    if (surface->backend->clone_similar != NULL) {
-	status = surface->backend->clone_similar (surface, src,
-						  src_x, src_y,
-						  width, height,
-						  clone_offset_x,
-						  clone_offset_y,
-						  clone_out);
-	if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
-	    if (_cairo_surface_is_image (src))
-		return CAIRO_INT_STATUS_UNSUPPORTED;
-	    /* First check to see if we can replay to a similar surface */
-	    if (_cairo_surface_is_recording (src)) {
-		return _cairo_recording_surface_clone_similar (surface, src,
-							       src_x, src_y,
-							       width, height,
-							       clone_offset_x,
-							       clone_offset_y,
-							       clone_out);
-	    }
-	    /* If we failed, try again with an image surface */
-	    status = _cairo_surface_acquire_source_image (src, &image, &image_extra);
-	    if (status == CAIRO_STATUS_SUCCESS) {
-		status =
-		    surface->backend->clone_similar (surface, &image->base,
-						     src_x, src_y,
-						     width, height,
-						     clone_offset_x,
-						     clone_offset_y,
-						     clone_out);
-		_cairo_surface_release_source_image (src, image, image_extra);
-	    }
-	}
-    }
-    /* If we're still unsupported, hit our fallback path to get a clone */
-    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
-	status =
-	    _cairo_surface_fallback_clone_similar (surface, src,
-						   src_x, src_y,
-						   width, height,
-						   clone_offset_x,
-						   clone_offset_y,
-						   clone_out);
-    }
-    if (unlikely (status))
-	return status;
-    /* Update the clone's device_transform (which the underlying surface
-     * backend knows nothing about) */
-    if (*clone_out != src) {
-	(*clone_out)->device_transform = src->device_transform;
-	(*clone_out)->device_transform_inverse = src->device_transform_inverse;
-    }
-    return status;
-}
-/**
- * _cairo_surface_is_similar
- * @surface_a: a #cairo_surface_t
- * @surface_b: a #cairo_surface_t
- * @content: a #cairo_content_t
- *
- * Find out whether the given surfaces share the same backend,
- * and if so, whether they can be considered similar.
- *
- * The definition of "similar" depends on the backend. In
- * general, it means that the surface is equivalent to one
- * that would have been generated by a call to cairo_surface_create_similar().
- *
- * Return value: %TRUE if the surfaces are similar.
- **/
-cairo_bool_t
-_cairo_surface_is_similar (cairo_surface_t *surface_a,
-	                   cairo_surface_t *surface_b)
-{
-    if (surface_a->backend != surface_b->backend)
-	return FALSE;
-    if (surface_a->backend->is_similar != NULL)
-	return surface_a->backend->is_similar (surface_a, surface_b);
-    return TRUE;
-}
-cairo_status_t
-_cairo_surface_composite (cairo_operator_t	op,
-			  const cairo_pattern_t	*src,
-			  const cairo_pattern_t	*mask,
-			  cairo_surface_t	*dst,
-			  int			src_x,
-			  int			src_y,
-			  int			mask_x,
-			  int			mask_y,
-			  int			dst_x,
-			  int			dst_y,
-			  unsigned int		width,
-			  unsigned int		height,
-			  cairo_region_t	*clip_region)
-{
-    cairo_int_status_t status;
-    if (unlikely (dst->status))
-	return dst->status;
-    assert (_cairo_surface_is_writable (dst));
-    if (mask) {
-	/* These operators aren't interpreted the same way by the backends;
-	 * they are implemented in terms of other operators in cairo-gstate.c
-	 */
-	assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR);
-    }
-    if (dst->backend->composite) {
-	status = dst->backend->composite (op,
-					  src, mask, dst,
-                                          src_x, src_y,
-                                          mask_x, mask_y,
-                                          dst_x, dst_y,
-					  width, height,
-					  clip_region);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
-	    return _cairo_surface_set_error (dst, status);
-    }
-    return _cairo_surface_set_error (dst,
-	    _cairo_surface_fallback_composite (op,
-					      src, mask, dst,
-					      src_x, src_y,
-					      mask_x, mask_y,
-					      dst_x, dst_y,
-					      width, height,
-					      clip_region));
-}
-/**
- * _cairo_surface_fill_rectangle:
- * @surface: a #cairo_surface_t
- * @op: the operator to apply to the rectangle
- * @color: the source color
- * @x: X coordinate of rectangle, in backend coordinates
- * @y: Y coordinate of rectangle, in backend coordinates
- * @width: width of rectangle, in backend coordinates
- * @height: height of rectangle, in backend coordinates
- *
- * Applies an operator to a rectangle using a solid color as the source.
- * See _cairo_surface_fill_rectangles() for full details.
- *
- * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred
- **/
-cairo_status_t
-_cairo_surface_fill_rectangle (cairo_surface_t	   *surface,
-			       cairo_operator_t	    op,
-			       const cairo_color_t *color,
-			       int		    x,
-			       int		    y,
-			       int		    width,
-			       int		    height)
-{
-    cairo_rectangle_int_t rect;
-    if (surface->status)
-	return surface->status;
-    assert (_cairo_surface_is_writable (surface));
-    rect.x = x;
-    rect.y = y;
-    rect.width = width;
+{
+    cairo_status_t ignored;
     rect.height = height;
-    return _cairo_surface_fill_rectangles (surface, op, color, &rect, 1);
-}
-/**
- * _cairo_surface_fill_region:
- * @surface: a #cairo_surface_t
- * @op: the operator to apply to the region
- * @color: the source color
- * @region: the region to modify, in backend coordinates
- *
- * Applies an operator to a set of rectangles specified as a
- * #cairo_region_t using a solid color as the source.
- * See _cairo_surface_fill_rectangles() for full details.
- *
- * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred
- **/
-cairo_status_t
-_cairo_surface_fill_region (cairo_surface_t	   *surface,
-			    cairo_operator_t	    op,
-			    const cairo_color_t    *color,
-			    cairo_region_t         *region)
-{
-    int num_rects;
-    cairo_rectangle_int_t stack_rects[CAIRO_STACK_ARRAY_LENGTH (cairo_rectangle_int_t)];
-    cairo_rectangle_int_t *rects = stack_rects;
-    cairo_status_t status;
-    int i;
-    if (surface->status)
-	return surface->status;
-    assert (_cairo_surface_is_writable (surface));
+    ignored = _cairo_surface_unmap_image (surface, image);
-    num_rects = cairo_region_num_rectangles (region);
+    (void)ignored;
-    if (num_rects == 0)
+}
 	return CAIRO_STATUS_SUCCESS;
-    /* catch a common reduction of _cairo_clip_combine_with_surface() */
-    if (op == CAIRO_OPERATOR_IN &&
-	_cairo_color_equal (color, CAIRO_COLOR_WHITE))
-    {
-	return CAIRO_STATUS_SUCCESS;
-    }
+cairo_surface_t *
-    if (num_rects > ARRAY_LENGTH (stack_rects)) {
-	rects = _cairo_malloc_ab (num_rects,
-				  sizeof (cairo_rectangle_int_t));
+_cairo_surface_get_source (cairo_surface_t *surface,
-	if (rects == NULL) {
-	    return _cairo_surface_set_error (surface,
-					     _cairo_error (CAIRO_STATUS_NO_MEMORY));
-	}
-    }
-    for (i = 0; i < num_rects; i++)
-	cairo_region_get_rectangle (region, i, &rects[i]);
-    status =  _cairo_surface_fill_rectangles (surface,
-					      op, color, rects, num_rects);
-    if (rects != stack_rects)
-	free (rects);
-    return _cairo_surface_set_error (surface, status);
-}
-/**
- * _cairo_surface_fill_rectangles:
- * @surface: a #cairo_surface_t
- * @op: the operator to apply to the region
- * @color: the source color
- * @rects: the rectangles to modify, in backend coordinates
- * @num_rects: the number of rectangles in @rects
- *
- * Applies an operator to a set of rectangles using a solid color
- * as the source. Note that even if the operator is an unbounded operator
- * such as %CAIRO_OPERATOR_IN, only the given set of rectangles
+			   cairo_rectangle_int_t *extents)
- * is affected. This differs from _cairo_surface_composite_trapezoids()
+{
- * where the entire destination rectangle is cleared.
- *
- * Return value: %CAIRO_STATUS_SUCCESS or the error that occurred
+    assert (surface->backend->source);
- **/
-cairo_status_t
+    return surface->backend->source (surface, extents);
-_cairo_surface_fill_rectangles (cairo_surface_t		*surface,
-				cairo_operator_t         op,
-				const cairo_color_t	*color,
-				cairo_rectangle_int_t	*rects,
-				int			 num_rects)
-{
-    cairo_int_status_t status;
+}
-    if (surface->status)
-	return surface->status;
-    assert (_cairo_surface_is_writable (surface));
-    if (num_rects == 0)
-	return CAIRO_STATUS_SUCCESS;
-    if (surface->backend->fill_rectangles) {
-	status = surface->backend->fill_rectangles (surface,
-						    op, color,
-						    rects, num_rects);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
-	    return _cairo_surface_set_error (surface, status);
+cairo_surface_t *
 _cairo_surface_default_source (void *surface,
 			       cairo_rectangle_int_t *extents)
     return _cairo_surface_set_error (surface,
-	    _cairo_surface_fallback_fill_rectangles (surface,
+    if (extents)
 	return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
     return CAIRO_STATUS_SUCCESS;
+}
+static cairo_bool_t
+nothing_to_do (cairo_surface_t *surface,
+	       cairo_operator_t op,
+	       const cairo_pattern_t *source)
+{
+    if (_cairo_pattern_is_clear (source)) {
+	if (op == CAIRO_OPERATOR_OVER || op == CAIRO_OPERATOR_ADD)
+	    return TRUE;
+	if (op == CAIRO_OPERATOR_SOURCE)
+	    op = CAIRO_OPERATOR_CLEAR;
+    }
+    if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
+	return TRUE;
+    if (op == CAIRO_OPERATOR_ATOP && (surface->content & CAIRO_CONTENT_COLOR) ==0)
+	return TRUE;
+    return FALSE;
+}
 cairo_status_t
-_cairo_surface_paint (cairo_surface_t	*surface,
+_cairo_surface_paint (cairo_surface_t		*surface,
-		      cairo_operator_t	 op,
+		      cairo_operator_t		 op,
-		      const cairo_pattern_t *source,
+		      const cairo_pattern_t	*source,
-		      cairo_clip_t	    *clip)
+		      const cairo_clip_t	*clip)
+{
     cairo_int_status_t status;
     cairo_status_t status;
+    TRACE ((stderr, "%s\n", __FUNCTION__));
+    if (unlikely (surface->status))
+	return surface->status;
-    if (unlikely (surface->status))
+    if (unlikely (surface->finished))
-	return surface->status;
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+    if (_cairo_clip_is_all_clipped (clip))
-    if (clip && clip->all_clipped)
 	return CAIRO_STATUS_SUCCESS;
     if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
-	return CAIRO_STATUS_SUCCESS;
+    status = _pattern_has_error (source);
-    if (op == CAIRO_OPERATOR_OVER &&
+    if (unlikely (status))
-	_cairo_pattern_is_clear (source))
+	return status;
-    {
-	return CAIRO_STATUS_SUCCESS;
-    }
-    status = _pattern_has_error (source);
+    if (nothing_to_do (surface, op, source))
-    if (unlikely (status))
-	return status;
-    _cairo_surface_begin_modification (surface);
-    if (surface->backend->paint != NULL) {
-	status = surface->backend->paint (surface, op, source, clip);
+	return CAIRO_STATUS_SUCCESS;
+    status = _cairo_surface_begin_modification (surface);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+    if (unlikely (status))
-            goto FINISH;
+	return status;
     status = surface->backend->paint (surface, op, source, clip);
-    status = _cairo_surface_fallback_paint (surface, op, source, clip);
+    if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
 	surface->is_clear = op == CAIRO_OPERATOR_CLEAR && clip == NULL;
- FINISH:
+	surface->serial++;
-    surface->is_clear = op == CAIRO_OPERATOR_CLEAR && clip == NULL;
+    }
     return _cairo_surface_set_error (surface, status);
+}
 cairo_status_t
+_cairo_surface_mask (cairo_surface_t		*surface,
+		     cairo_operator_t		 op,
-cairo_status_t
+		     const cairo_pattern_t	*source,
-_cairo_surface_mask (cairo_surface_t		*surface,
-		     cairo_operator_t		 op,
-		     const cairo_pattern_t	*source,
 		     const cairo_pattern_t	*mask,
-		     cairo_clip_t		*clip)
+		     const cairo_clip_t		*clip)
+{
-    cairo_status_t status;
+    cairo_int_status_t status;
-    if (unlikely (surface->status))
+    TRACE ((stderr, "%s\n", __FUNCTION__));
-	return surface->status;
+    if (unlikely (surface->status))
-    if (clip && clip->all_clipped)
-	return CAIRO_STATUS_SUCCESS;
-    if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
-	return CAIRO_STATUS_SUCCESS;
 	return surface->status;
-    /* If the mask is blank, this is just an expensive no-op */
+    if (unlikely (surface->finished))
-    if (_cairo_pattern_is_clear (mask) &&
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
 	_cairo_operator_bounded_by_mask (op))
     if (_cairo_clip_is_all_clipped (clip))
 	return CAIRO_STATUS_SUCCESS;
-    }
-    if (op == CAIRO_OPERATOR_OVER &&
-	_cairo_pattern_is_clear (source))
-    {
+    /* If the mask is blank, this is just an expensive no-op */
-	return CAIRO_STATUS_SUCCESS;
-    }
+    if (_cairo_pattern_is_clear (mask) &&
+	_cairo_operator_bounded_by_mask (op))
+    {
+	return CAIRO_STATUS_SUCCESS;
-    status = _pattern_has_error (source);
+    }
     if (unlikely (status))
+    status = _pattern_has_error (source);
+    if (unlikely (status))
 	return status;
     status = _pattern_has_error (mask);
 			    const cairo_stroke_style_t    *stroke_style,
 			    const cairo_matrix_t	    *stroke_ctm,
 			    const cairo_matrix_t	    *stroke_ctm_inverse,
 			    double		     stroke_tolerance,
 			    cairo_antialias_t	     stroke_antialias,
-			    cairo_clip_t	    *clip)
+			    const cairo_clip_t	    *clip)
+{
-    cairo_status_t status;
+    cairo_int_status_t status;
     TRACE ((stderr, "%s\n", __FUNCTION__));
     if (unlikely (surface->status))
+	return surface->status;
+    if (unlikely (surface->finished))
-	return surface->status;
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
-    if (clip && clip->all_clipped)
+    if (_cairo_clip_is_all_clipped (clip))
 	return CAIRO_STATUS_SUCCESS;
     status = _pattern_has_error (stroke_source);
     if (unlikely (status))
 	return status;
+    status = _cairo_surface_begin_modification (surface);
     if (unlikely (status))
-    _cairo_surface_begin_modification (surface);
+	return status;
 				    clip);
     if (unlikely (status))
 	goto FINISH;
+  FINISH:
-  FINISH:
+    if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
+	surface->is_clear = FALSE;
+	surface->serial++;
     surface->is_clear = FALSE;
     return _cairo_surface_set_error (surface, status);
+}
 cairo_status_t
-_cairo_surface_stroke (cairo_surface_t		*surface,
+_cairo_surface_stroke (cairo_surface_t			*surface,
-		       cairo_operator_t		 op,
+		       cairo_operator_t			 op,
-		       const cairo_pattern_t	*source,
+		       const cairo_pattern_t		*source,
-		       cairo_path_fixed_t	*path,
+		       const cairo_path_fixed_t		*path,
 		       const cairo_stroke_style_t	*stroke_style,
 		       const cairo_matrix_t		*ctm,
 		       const cairo_matrix_t		*ctm_inverse,
-		       double			 tolerance,
+		       double				 tolerance,
-		       cairo_antialias_t	 antialias,
+		       cairo_antialias_t		 antialias,
+		       const cairo_clip_t		*clip)
 		       cairo_clip_t		*clip)
     cairo_int_status_t status;
+    TRACE ((stderr, "%s\n", __FUNCTION__));
-    cairo_status_t status;
+    if (unlikely (surface->status))
 	return surface->status;
-    if (unlikely (surface->status))
+    if (unlikely (surface->finished))
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
-	return surface->status;
-    if (clip && clip->all_clipped)
+    if (_cairo_clip_is_all_clipped (clip))
-	return CAIRO_STATUS_SUCCESS;
 	return CAIRO_STATUS_SUCCESS;
-    if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
-	return CAIRO_STATUS_SUCCESS;
     status = _pattern_has_error (source);
-    if (op == CAIRO_OPERATOR_OVER &&
+    if (unlikely (status))
-	_cairo_pattern_is_clear (source))
-    {
-	return CAIRO_STATUS_SUCCESS;
 	return status;
-    status = _pattern_has_error (source);
+    if (nothing_to_do (surface, op, source))
-    if (unlikely (status))
+	return CAIRO_STATUS_SUCCESS;
 	return status;
-    _cairo_surface_begin_modification (surface);
+    status = _cairo_surface_begin_modification (surface);
-    if (surface->backend->stroke != NULL) {
-	status = surface->backend->stroke (surface, op, source,
-					   path, stroke_style,
-					   ctm, ctm_inverse,
-					   tolerance, antialias,
-					   clip);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
-            goto FINISH;
     if (unlikely (status))
+	return status;
     status = surface->backend->stroke (surface, op, source,
-    status = _cairo_surface_fallback_stroke (surface, op, source,
+				       path, stroke_style,
-                                             path, stroke_style,
+				       ctm, ctm_inverse,
-                                             ctm, ctm_inverse,
+				       tolerance, antialias,
-                                             tolerance, antialias,
+				       clip);
-					     clip);
+    if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
+	surface->is_clear = FALSE;
- FINISH:
+	surface->serial++;
     surface->is_clear = FALSE;
     return _cairo_surface_set_error (surface, status);
+}
+cairo_status_t
-cairo_status_t
+_cairo_surface_fill (cairo_surface_t		*surface,
-_cairo_surface_fill (cairo_surface_t	*surface,
+		     cairo_operator_t		 op,
+		     const cairo_pattern_t	 *source,
+		     const cairo_path_fixed_t	*path,
-		     cairo_operator_t	 op,
+		     cairo_fill_rule_t		 fill_rule,
-		     const cairo_pattern_t *source,
+		     double			 tolerance,
-		     cairo_path_fixed_t	*path,
+		     cairo_antialias_t		 antialias,
+		     const cairo_clip_t		*clip)
-		     cairo_fill_rule_t	 fill_rule,
+{
-		     double		 tolerance,
-		     cairo_antialias_t	 antialias,
+    cairo_int_status_t status;
-		     cairo_clip_t	*clip)
-    cairo_status_t status;
+    TRACE ((stderr, "%s\n", __FUNCTION__));
     if (unlikely (surface->status))
 	return surface->status;
-    if (clip && clip->all_clipped)
-	return CAIRO_STATUS_SUCCESS;
     if (unlikely (surface->finished))
-    if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
 	return CAIRO_STATUS_SUCCESS;
     if (_cairo_clip_is_all_clipped (clip))
-    if (op == CAIRO_OPERATOR_OVER &&
-	_cairo_pattern_is_clear (source))
+	return CAIRO_STATUS_SUCCESS;
-    {
-	return CAIRO_STATUS_SUCCESS;
-    }
-    status = _pattern_has_error (source);
-    if (unlikely (status))
-	return status;
-    _cairo_surface_begin_modification (surface);
-    if (surface->backend->fill != NULL) {
-	status = surface->backend->fill (surface, op, source,
+    status = _pattern_has_error (source);
-					 path, fill_rule,
+    if (unlikely (status))
-					 tolerance, antialias,
-					 clip);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
-            goto FINISH;
-    }
-    status = _cairo_surface_fallback_fill (surface, op, source,
-                                           path, fill_rule,
-                                           tolerance, antialias,
-					   clip);
- FINISH:
-    surface->is_clear = FALSE;
-    return _cairo_surface_set_error (surface, status);
-}
-cairo_status_t
-_cairo_surface_composite_trapezoids (cairo_operator_t		op,
-				     const cairo_pattern_t	*pattern,
-				     cairo_surface_t		*dst,
-				     cairo_antialias_t		antialias,
-				     int			src_x,
-				     int			src_y,
-				     int			dst_x,
-				     int			dst_y,
-				     unsigned int		width,
-				     unsigned int		height,
-				     cairo_trapezoid_t		*traps,
-				     int			num_traps,
-				     cairo_region_t		*clip_region)
-{
-    cairo_int_status_t status;
-    if (dst->status)
-	return dst->status;
+	return status;
-    assert (_cairo_surface_is_writable (dst));
-    /* These operators aren't interpreted the same way by the backends;
-     * they are implemented in terms of other operators in cairo-gstate.c
-     */
-    assert (op != CAIRO_OPERATOR_SOURCE && op != CAIRO_OPERATOR_CLEAR);
-    if (dst->backend->composite_trapezoids) {
-	status = dst->backend->composite_trapezoids (op,
-						     pattern, dst,
-						     antialias,
-						     src_x, src_y,
-                                                     dst_x, dst_y,
-						     width, height,
-						     traps, num_traps,
-						     clip_region);
-	if (status != CAIRO_INT_STATUS_UNSUPPORTED)
-	    return _cairo_surface_set_error (dst, status);
-    }
-    return  _cairo_surface_set_error (dst,
-	    _cairo_surface_fallback_composite_trapezoids (op, pattern, dst,
-							  antialias,
-							  src_x, src_y,
-							  dst_x, dst_y,
-							  width, height,
-							  traps, num_traps,
-							  clip_region));
-}
-cairo_span_renderer_t *
-_cairo_surface_create_span_renderer (cairo_operator_t		 op,
-				     const cairo_pattern_t	*pattern,
-				     cairo_surface_t		*dst,
-				     cairo_antialias_t	         antialias,
-				     const cairo_composite_rectangles_t *rects,
-				     cairo_region_t		*clip_region)
-{
-    assert (dst->snapshot_of == NULL);
-    if (unlikely (dst->status))
-	return _cairo_span_renderer_create_in_error (dst->status);
-    if (unlikely (dst->finished))
-	return _cairo_span_renderer_create_in_error (CAIRO_STATUS_SURFACE_FINISHED);
-    if (dst->backend->create_span_renderer) {
-	return dst->backend->create_span_renderer (op,
-						   pattern, dst,
-						   antialias,
-						   rects,
-						   clip_region);
-    }
-    ASSERT_NOT_REACHED;
-    return _cairo_span_renderer_create_in_error (CAIRO_INT_STATUS_UNSUPPORTED);
-}
 cairo_bool_t
-_cairo_surface_check_span_renderer (cairo_operator_t		 op,
+    if (nothing_to_do (surface, op, source))
-				    const cairo_pattern_t	*pattern,
+	return CAIRO_STATUS_SUCCESS;
 				    cairo_surface_t		*dst,
+ *
  * There is a convenience function for this that takes a #cairo_t,
  * namely cairo_copy_page().
+ *
  * Since: 1.6
- */
+ **/
 void
 cairo_surface_copy_page (cairo_surface_t *surface)
+{
-    cairo_status_t status_ignored;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
     assert (surface->snapshot_of == NULL);
-    if (surface->finished) {
-	status_ignored = _cairo_surface_set_error (surface,
+    if (unlikely (surface->finished)) {
-		                                 CAIRO_STATUS_SURFACE_FINISHED);
+	_cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
 	return;
+    }
-    /* It's fine if some backends don't implement copy_page */
-    if (surface->backend->copy_page == NULL)
+    /* It's fine if some backends don't implement copy_page */
-	return;
+    if (surface->backend->copy_page == NULL)
 	return;
     status_ignored = _cairo_surface_set_error (surface,
-			                 surface->backend->copy_page (surface));
+    _cairo_surface_set_error (surface, surface->backend->copy_page (surface));
  * Since: 1.6
  **/
 void
 cairo_surface_show_page (cairo_surface_t *surface)
+{
-    cairo_status_t status_ignored;
+    cairo_status_t status;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return;
-    if (surface->finished) {
-	status_ignored = _cairo_surface_set_error (surface,
+    if (unlikely (surface->finished)) {
-		                                 CAIRO_STATUS_SURFACE_FINISHED);
+	_cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
 	return;
+    }
+    status = _cairo_surface_begin_modification (surface);
+    if (unlikely (status)) {
 	_cairo_surface_set_error (surface, status);
 	return;
     _cairo_surface_begin_modification (surface);
-    /* It's fine if some backends don't implement show_page */
-    if (surface->backend->show_page == NULL)
+    /* It's fine if some backends don't implement show_page */
-	return;
+    if (surface->backend->show_page == NULL)
 	return;
     status_ignored = _cairo_surface_set_error (surface,
  * current callers are within the surface layer where backend space is
  * desired.
+ *
  * This behavior would have to be changed is we ever exported a public
  * variant of this function.
- */
+ **/
 cairo_bool_t
 _cairo_surface_get_extents (cairo_surface_t         *surface,
 			    cairo_rectangle_int_t   *extents)
+{
     cairo_bool_t bounded;
+    if (unlikely (surface->status))
+	goto zero_extents;
+    if (unlikely (surface->finished)) {
+	_cairo_surface_set_error(surface, CAIRO_STATUS_SURFACE_FINISHED);
+	goto zero_extents;
+    }
     bounded = FALSE;
     if (surface->backend->get_extents != NULL)
 	bounded = surface->backend->get_extents (surface, extents);
     if (! bounded)
+	_cairo_unbounded_rectangle_init (extents);
+    return bounded;
+zero_extents:
-	_cairo_unbounded_rectangle_init (extents);
+    extents->x = extents->y = 0;
     extents->width = extents->height = 0;
-    return bounded;
+    return TRUE;
+}
  * Since: 1.8
  **/
 cairo_bool_t
 cairo_surface_has_show_text_glyphs (cairo_surface_t	    *surface)
+{
-    cairo_status_t status_ignored;
-    if (surface->status)
+    if (unlikely (surface->status))
 	return FALSE;
-    if (surface->finished) {
-	status_ignored = _cairo_surface_set_error (surface,
+    if (unlikely (surface->finished)) {
-						   CAIRO_STATUS_SURFACE_FINISHED);
+	_cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
 	return FALSE;
+    }
 				 int			     num_glyphs,
 				 const cairo_text_cluster_t *clusters,
 				 int			     num_clusters,
 				 cairo_text_cluster_flags_t  cluster_flags,
 				 cairo_scaled_font_t	    *scaled_font,
-				 cairo_clip_t		    *clip)
+				 const cairo_clip_t		*clip)
+{
-    cairo_status_t status;
+    cairo_int_status_t status;
     cairo_scaled_font_t *dev_scaled_font = scaled_font;
     TRACE ((stderr, "%s\n", __FUNCTION__));
     if (unlikely (surface->status))
+	return surface->status;
+    if (unlikely (surface->finished))
-	return surface->status;
+	return _cairo_surface_set_error (surface, _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
     if (num_glyphs == 0 && utf8_len == 0)
-	return CAIRO_STATUS_SUCCESS;
-    if (clip && clip->all_clipped)
 	return CAIRO_STATUS_SUCCESS;
-    if (op == CAIRO_OPERATOR_CLEAR && surface->is_clear)
+    if (_cairo_clip_is_all_clipped (clip))
 	return CAIRO_STATUS_SUCCESS;
+    status = _pattern_has_error (source);
+    if (unlikely (status))
+	return status;
+    if (nothing_to_do (surface, op, source))
-    status = _pattern_has_error (source);
+	return CAIRO_STATUS_SUCCESS;
     if (unlikely (status))
-	return status;
+    status = _cairo_surface_begin_modification (surface);
     if (unlikely (status))
 							 clip);
+	}
 	if (status == CAIRO_INT_STATUS_UNSUPPORTED &&
 	    surface->backend->show_glyphs)
+	{
-	    int remaining_glyphs = num_glyphs;
 	    status = surface->backend->show_glyphs (surface, op,
 						    source,
 						    glyphs, num_glyphs,
 						    dev_scaled_font,
-						    clip,
+						    clip);
-						    &remaining_glyphs);
-	    glyphs += num_glyphs - remaining_glyphs;
-	    num_glyphs = remaining_glyphs;
-	    if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0)
-		status = CAIRO_STATUS_SUCCESS;
+	}
     } else {
 	/* A mere show_glyphs call.  Try show_glyphs backend method first */
 	if (surface->backend->show_glyphs != NULL) {
-	    int remaining_glyphs = num_glyphs;
 	    status = surface->backend->show_glyphs (surface, op,
 						    source,
 						    glyphs, num_glyphs,
 						    dev_scaled_font,
-						    clip,
+						    clip);
-						    &remaining_glyphs);
-	    glyphs += num_glyphs - remaining_glyphs;
-	    num_glyphs = remaining_glyphs;
-	    if (status == CAIRO_INT_STATUS_UNSUPPORTED && remaining_glyphs == 0)
-		status = CAIRO_STATUS_SUCCESS;
 	} else if (surface->backend->show_text_glyphs != NULL) {
 	    /* Intentionally only try show_text_glyphs method for show_glyphs
 	     * calls if backend does not have show_glyphs.  If backend has
 	     * both methods implemented, we don't fallback from show_glyphs to
 	     * show_text_glyphs, and hence the backend can assume in its
 							 dev_scaled_font,
 							 clip);
+	}
+    }
-    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
-	status = _cairo_surface_fallback_show_glyphs (surface, op,
-						      source,
-						      glyphs, num_glyphs,
-						      dev_scaled_font,
-						      clip);
-    }
     if (dev_scaled_font != scaled_font)
+	cairo_scaled_font_destroy (dev_scaled_font);
 	cairo_scaled_font_destroy (dev_scaled_font);
-    surface->is_clear = FALSE;
+    if (status != CAIRO_INT_STATUS_NOTHING_TO_DO) {
 	surface->is_clear = FALSE;
-    return _cairo_surface_set_error (surface, status);
-}
-/* XXX: Previously, we had a function named _cairo_surface_show_glyphs
- * with not-so-useful semantics. We've now got a
- * _cairo_surface_show_text_glyphs with the proper semantics, and its
- * fallback still uses this old function (which still needs to be
- * cleaned up in terms of both semantics and naming). */
-cairo_status_t
-_cairo_surface_old_show_glyphs (cairo_scaled_font_t	*scaled_font,
-				cairo_operator_t	 op,
-				const cairo_pattern_t	*pattern,
-				cairo_surface_t		*dst,
-				int			 source_x,
-				int			 source_y,
-				int			 dest_x,
-				int			 dest_y,
-				unsigned int		 width,
-				unsigned int		 height,
-				cairo_glyph_t		*glyphs,
-				int			 num_glyphs,
-				cairo_region_t		*clip_region)
-{
-    cairo_status_t status;
-    if (dst->status)
-	return dst->status;
-    assert (_cairo_surface_is_writable (dst));
-    if (dst->backend->old_show_glyphs) {
-	status = dst->backend->old_show_glyphs (scaled_font,
-						op, pattern, dst,
-						source_x, source_y,
-                                                dest_x, dest_y,
-						width, height,
-						glyphs, num_glyphs,
-						clip_region);
-    } else
-	status = CAIRO_INT_STATUS_UNSUPPORTED;
-    return _cairo_surface_set_error (dst, status);
-}
-static cairo_status_t
-_cairo_surface_composite_fixup_unbounded_internal (cairo_surface_t         *dst,
-						   cairo_rectangle_int_t   *src_rectangle,
-						   cairo_rectangle_int_t   *mask_rectangle,
-						   int			    dst_x,
-						   int			    dst_y,
-						   unsigned int		    width,
-						   unsigned int		    height,
-						   cairo_region_t	    *clip_region)
-{
-    cairo_rectangle_int_t dst_rectangle;
-    cairo_region_t clear_region;
-    cairo_status_t status;
-    /* The area that was drawn is the area in the destination rectangle but
-     * not within the source or the mask.
-     */
-    dst_rectangle.x = dst_x;
-    dst_rectangle.y = dst_y;
-    dst_rectangle.width = width;
-    dst_rectangle.height = height;
-    _cairo_region_init_rectangle (&clear_region, &dst_rectangle);
-    if (clip_region != NULL) {
-	status = cairo_region_intersect (&clear_region, clip_region);
-	if (unlikely (status))
-	    goto CLEANUP_REGIONS;
-    }
-    if (src_rectangle != NULL) {
-        if (! _cairo_rectangle_intersect (&dst_rectangle, src_rectangle))
-	    goto EMPTY;
-    }
-    if (mask_rectangle != NULL) {
-        if (! _cairo_rectangle_intersect (&dst_rectangle, mask_rectangle))
-	    goto EMPTY;
-    }
-    /* Now compute the area that is in dst but not drawn */
-    status = cairo_region_subtract_rectangle (&clear_region, &dst_rectangle);
-    if (unlikely (status) || cairo_region_is_empty (&clear_region))
-        goto CLEANUP_REGIONS;
-  EMPTY:
-    status = _cairo_surface_fill_region (dst, CAIRO_OPERATOR_CLEAR,
-                                         CAIRO_COLOR_TRANSPARENT,
-                                         &clear_region);
-  CLEANUP_REGIONS:
+	surface->serial++;
-    _cairo_region_fini (&clear_region);
-    return _cairo_surface_set_error (dst, status);
-}
-/**
- * _cairo_surface_composite_fixup_unbounded:
- * @dst: the destination surface
- * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface())
- * @src_width: width of source surface
- * @src_height: height of source surface
- * @mask_attr: mask surface attributes or %NULL if no mask
- * @mask_width: width of mask surface
- * @mask_height: height of mask surface
- * @src_x: @src_x from _cairo_surface_composite()
- * @src_y: @src_y from _cairo_surface_composite()
- * @mask_x: @mask_x from _cairo_surface_composite()
- * @mask_y: @mask_y from _cairo_surface_composite()
- * @dst_x: @dst_x from _cairo_surface_composite()
- * @dst_y: @dst_y from _cairo_surface_composite()
- * @width: @width from _cairo_surface_composite()
- * @height: @height_x from _cairo_surface_composite()
- *
- * Eeek! Too many parameters! This is a helper function to take care of fixing
- * up for bugs in libpixman and RENDER where, when asked to composite an
- * untransformed surface with an unbounded operator (like CLEAR or SOURCE)
- * only the region inside both the source and the mask is affected.
- * This function clears the region that should have been drawn but was wasn't.
- **/
-cairo_status_t
-_cairo_surface_composite_fixup_unbounded (cairo_surface_t            *dst,
-					  cairo_surface_attributes_t *src_attr,
-					  int                         src_width,
-					  int                         src_height,
-					  cairo_surface_attributes_t *mask_attr,
-					  int                         mask_width,
-					  int                         mask_height,
-					  int			      src_x,
-					  int			      src_y,
-					  int			      mask_x,
-					  int			      mask_y,
-					  int			      dst_x,
-					  int			      dst_y,
-					  unsigned int		      width,
-					  unsigned int		      height,
-					  cairo_region_t	     *clip_region)
-{
-    cairo_rectangle_int_t src_tmp, mask_tmp;
-    cairo_rectangle_int_t *src_rectangle = NULL;
-    cairo_rectangle_int_t *mask_rectangle = NULL;
-    if (unlikely (dst->status))
-	return dst->status;
-    assert (_cairo_surface_is_writable (dst));
-    /* The RENDER/libpixman operators are clipped to the bounds of the untransformed,
-     * non-repeating sources and masks. Other sources and masks can be ignored.
-     */
-    if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) &&
-	src_attr->extend == CAIRO_EXTEND_NONE)
-    {
-	src_tmp.x = (dst_x - (src_x + src_attr->x_offset));
-	src_tmp.y = (dst_y - (src_y + src_attr->y_offset));
-	src_tmp.width = src_width;
-	src_tmp.height = src_height;
-	src_rectangle = &src_tmp;
-    }
-    if (mask_attr &&
-	_cairo_matrix_is_integer_translation (&mask_attr->matrix, NULL, NULL) &&
-	mask_attr->extend == CAIRO_EXTEND_NONE)
-    {
-	mask_tmp.x = (dst_x - (mask_x + mask_attr->x_offset));
-	mask_tmp.y = (dst_y - (mask_y + mask_attr->y_offset));
-	mask_tmp.width = mask_width;
-	mask_tmp.height = mask_height;
-	mask_rectangle = &mask_tmp;
-    }
-    return _cairo_surface_composite_fixup_unbounded_internal (dst, src_rectangle, mask_rectangle,
-							      dst_x, dst_y, width, height,
-							      clip_region);
-}
-/**
- * _cairo_surface_composite_shape_fixup_unbounded:
- * @dst: the destination surface
- * @src_attr: source surface attributes (from _cairo_pattern_acquire_surface())
- * @src_width: width of source surface
- * @src_height: height of source surface
- * @mask_width: width of mask surface
- * @mask_height: height of mask surface
- * @src_x: @src_x from _cairo_surface_composite()
- * @src_y: @src_y from _cairo_surface_composite()
- * @mask_x: @mask_x from _cairo_surface_composite()
- * @mask_y: @mask_y from _cairo_surface_composite()
- * @dst_x: @dst_x from _cairo_surface_composite()
- * @dst_y: @dst_y from _cairo_surface_composite()
- * @width: @width from _cairo_surface_composite()
- * @height: @height_x from _cairo_surface_composite()
- *
- * Like _cairo_surface_composite_fixup_unbounded(), but instead of
- * handling the case where we have a source pattern and a mask
- * pattern, handle the case where we are compositing a source pattern
- * using a mask we create ourselves, as in
- * _cairo_surface_composite_glyphs() or _cairo_surface_composite_trapezoids()
- **/
-cairo_status_t
-_cairo_surface_composite_shape_fixup_unbounded (cairo_surface_t            *dst,
-						cairo_surface_attributes_t *src_attr,
-						int                         src_width,
-						int                         src_height,
-						int                         mask_width,
-						int                         mask_height,
-						int			    src_x,
-						int			    src_y,
-						int			    mask_x,
-						int			    mask_y,
-						int			    dst_x,
-						int			    dst_y,
-						unsigned int		    width,
-						unsigned int		    height,
-						cairo_region_t	    *clip_region)
-{
-    cairo_rectangle_int_t src_tmp, *src= NULL;
-    cairo_rectangle_int_t mask;
-    if (dst->status)
-	return dst->status;
-    assert (_cairo_surface_is_writable (dst));
-    /* The RENDER/libpixman operators are clipped to the bounds of the untransformed,
-     * non-repeating sources and masks. Other sources and masks can be ignored.
-     */
-    if (_cairo_matrix_is_integer_translation (&src_attr->matrix, NULL, NULL) &&
-	src_attr->extend == CAIRO_EXTEND_NONE)
-    {
-	src_tmp.x = (dst_x - (src_x + src_attr->x_offset));
-	src_tmp.y = (dst_y - (src_y + src_attr->y_offset));
-	src_tmp.width  = src_width;
-	src_tmp.height = src_height;
-	src = &src_tmp;
-    }
-    mask.x = dst_x - mask_x;
-    mask.y = dst_y - mask_y;
-    mask.width  = mask_width;
-    mask.height = mask_height;
     return _cairo_surface_composite_fixup_unbounded_internal (dst, src, &mask,
 							      dst_x, dst_y, width, height,
-							      clip_region);
+    return _cairo_surface_set_error (surface, status);
+}
 /**
- * _cairo_surface_set_resolution
+ * _cairo_surface_set_resolution:
  * @surface: the surface
  * @x_res: x resolution, in dpi
  * @y_res: y resolution, in dpi
  *
  * Set the actual surface resolution of @surface to the given x and y DPI.
  * Mainly used for correctly computing the scale factor when fallback
  * rendering needs to take place in the paginated surface.
- */
+ **/
 void
     surface->x_resolution = x_res;
     surface->y_resolution = y_res;
-}
-/* Generic methods for determining operation extents. */
-static void
-_rectangle_intersect_clip (cairo_rectangle_int_t *extents, cairo_clip_t *clip)
-{
-    const cairo_rectangle_int_t *clip_extents;
-    cairo_bool_t is_empty;
-    clip_extents = NULL;
-    if (clip != NULL)
-	clip_extents = _cairo_clip_get_extents (clip);
-    if (clip_extents != NULL)
-	is_empty = _cairo_rectangle_intersect (extents, clip_extents);
-}
-static void
-_cairo_surface_operation_extents (cairo_surface_t *surface,
-				  cairo_operator_t op,
-				  const cairo_pattern_t *source,
-				  cairo_clip_t *clip,
-				  cairo_rectangle_int_t *extents)
-{
-    cairo_bool_t is_empty;
-    is_empty = _cairo_surface_get_extents (surface, extents);
-    if (_cairo_operator_bounded_by_source (op)) {
-	cairo_rectangle_int_t source_extents;
-	_cairo_pattern_get_extents (source, &source_extents);
-	is_empty = _cairo_rectangle_intersect (extents, &source_extents);
-    }
-    _rectangle_intersect_clip (extents, clip);
-}
-cairo_status_t
-_cairo_surface_paint_extents (cairo_surface_t *surface,
-			      cairo_operator_t		op,
-			      const cairo_pattern_t	*source,
-			      cairo_clip_t		*clip,
-			      cairo_rectangle_int_t	*extents)
-{
-    _cairo_surface_operation_extents (surface, op, source, clip, extents);
-    return CAIRO_STATUS_SUCCESS;
-}
-cairo_status_t
-_cairo_surface_mask_extents (cairo_surface_t *surface,
-			     cairo_operator_t		 op,
-			     const cairo_pattern_t	*source,
-			     const cairo_pattern_t	*mask,
-			     cairo_clip_t		*clip,
-			     cairo_rectangle_int_t	*extents)
-{
-    cairo_bool_t is_empty;
-    _cairo_surface_operation_extents (surface, op, source, clip, extents);
-    if (_cairo_operator_bounded_by_mask (op)) {
-	cairo_rectangle_int_t mask_extents;
-	_cairo_pattern_get_extents (mask, &mask_extents);
-	is_empty = _cairo_rectangle_intersect (extents, &mask_extents);
-    }
-    return CAIRO_STATUS_SUCCESS;
-}
-cairo_status_t
-_cairo_surface_stroke_extents (cairo_surface_t *surface,
-			       cairo_operator_t op,
-			       const cairo_pattern_t *source,
-			       cairo_path_fixed_t	*path,
-			       const cairo_stroke_style_t *style,
-			       const cairo_matrix_t *ctm,
-			       const cairo_matrix_t *ctm_inverse,
-			       double tolerance,
-			       cairo_antialias_t	 antialias,
-			       cairo_clip_t *clip,
-			       cairo_rectangle_int_t *extents)
-{
-    cairo_status_t status;
-    cairo_bool_t is_empty;
-    _cairo_surface_operation_extents (surface, op, source, clip, extents);
-    if (_cairo_operator_bounded_by_mask (op)) {
-	cairo_rectangle_int_t mask_extents;
-	status = _cairo_path_fixed_stroke_extents (path, style,
-						   ctm, ctm_inverse,
-						   tolerance,
-						   &mask_extents);
-	if (unlikely (status))
-	    return status;
-	is_empty = _cairo_rectangle_intersect (extents, &mask_extents);
-    }
-    return CAIRO_STATUS_SUCCESS;
-}
-cairo_status_t
-_cairo_surface_fill_extents (cairo_surface_t		*surface,
-			     cairo_operator_t		 op,
-			     const cairo_pattern_t	*source,
-			     cairo_path_fixed_t		*path,
-			     cairo_fill_rule_t		 fill_rule,
-			     double			 tolerance,
-			     cairo_antialias_t		 antialias,
-			     cairo_clip_t		*clip,
-			     cairo_rectangle_int_t	*extents)
-{
-    cairo_bool_t is_empty;
-    _cairo_surface_operation_extents (surface, op, source, clip, extents);
-    if (_cairo_operator_bounded_by_mask (op)) {
-	cairo_rectangle_int_t mask_extents;
-	_cairo_path_fixed_fill_extents (path, fill_rule, tolerance,
-					&mask_extents);
-	is_empty = _cairo_rectangle_intersect (extents, &mask_extents);
-    }
-    return CAIRO_STATUS_SUCCESS;
-}
-cairo_status_t
-_cairo_surface_glyphs_extents (cairo_surface_t *surface,
-			       cairo_operator_t	   op,
-			       const cairo_pattern_t *source,
-			       cairo_glyph_t	  *glyphs,
-			       int		   num_glyphs,
-			       cairo_scaled_font_t  *scaled_font,
-			       cairo_clip_t         *clip,
-			       cairo_rectangle_int_t *extents)
-{
-    cairo_status_t	     status;
-    cairo_bool_t             is_empty;
-    _cairo_surface_operation_extents (surface, op, source, clip, extents);
-    if (_cairo_operator_bounded_by_mask (op)) {
-	cairo_rectangle_int_t glyph_extents;
-	status = _cairo_scaled_font_glyph_device_extents (scaled_font,
-							  glyphs,
-							  num_glyphs,
-							  &glyph_extents,
-							  NULL);
-	if (unlikely (status))
-	    return status;
-	is_empty = _cairo_rectangle_intersect (extents, &glyph_extents);
-    }
-    return CAIRO_STATUS_SUCCESS;
+}
 cairo_surface_t *
+_cairo_surface_create_in_error (cairo_status_t status)
 _cairo_surface_create_in_error (cairo_status_t status)
     assert (status < CAIRO_STATUS_LAST_STATUS);
     switch (status) {
     case CAIRO_STATUS_NO_MEMORY:
 	return (cairo_surface_t *) &_cairo_surface_nil;
     case CAIRO_STATUS_NEGATIVE_COUNT:
     case CAIRO_STATUS_INVALID_CLUSTERS:
     case CAIRO_STATUS_INVALID_SLANT:
     case CAIRO_STATUS_INVALID_WEIGHT:
     case CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED:
+    case CAIRO_STATUS_INVALID_MESH_CONSTRUCTION:
+    case CAIRO_STATUS_DEVICE_FINISHED:
+    default:
+	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+	return (cairo_surface_t *) &_cairo_surface_nil;
+    }
+}
+cairo_surface_t *
+_cairo_int_surface_create_in_error (cairo_int_status_t status)
+{
+    if (status < CAIRO_INT_STATUS_LAST_STATUS)
+	return _cairo_surface_create_in_error (status);
+    switch ((int)status) {
+    case CAIRO_INT_STATUS_UNSUPPORTED:
+	return (cairo_surface_t *) &_cairo_surface_nil_unsupported;
+    case CAIRO_INT_STATUS_NOTHING_TO_DO:
+	return (cairo_surface_t *) &_cairo_surface_nil_nothing_to_do;
     default:
 	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
 	return (cairo_surface_t *) &_cairo_surface_nil;
+    }
+}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-surface.c – Rev 1892 → 3959