Add m-esr52 at 52.6.0

1 files changed, 519 insertions, 0 deletions

diff --git a/gfx/cairo/disable-subpixel-antialiasing.patch b/gfx/cairo/disable-subpixel-antialiasing.patch
new file mode 100644
index 000000000..7a0eb3a06
--- /dev/null
+++ b/gfx/cairo/disable-subpixel-antialiasing.patch
@@ -0,0 +1,519 @@
+# HG changeset patch
+# User Robert O'Callahan <robert@ocallahan.org>
+# Date 1294019288 -46800
+# Node ID 8857392e37aea7475ed6d8ee4b45023e1233bcec
+# Parent  c53f60831c43cca397dfed8adf8d350aeec7d3ca
+Bug 363861. Part 2: Introduce cairo_surface_get/set_subpixel_antialiasing. r=jrmuizel,sr=vlad,a=blocking
+
+diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+--- a/gfx/cairo/cairo/src/cairo-quartz-surface.c
++++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+@@ -2473,16 +2473,17 @@ _cairo_quartz_surface_show_glyphs (void 
+     cairo_int_status_t rv = CAIRO_STATUS_SUCCESS;
+     cairo_quartz_drawing_state_t state;
+     float xprev, yprev;
+     int i;
+     CGFontRef cgfref = NULL;
+ 
+     cairo_bool_t isClipping = FALSE;
+     cairo_bool_t didForceFontSmoothing = FALSE;
++    cairo_antialias_t effective_antialiasing;
+ 
+     if (IS_EMPTY(surface))
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     if (num_glyphs <= 0)
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     if (cairo_scaled_font_get_type (scaled_font) != CAIRO_FONT_TYPE_QUARTZ)
+@@ -2514,16 +2515,22 @@ _cairo_quartz_surface_show_glyphs (void 
+ 	goto BAIL;
+     }
+ 
+     /* this doesn't addref */
+     cgfref = _cairo_quartz_scaled_font_get_cg_font_ref (scaled_font);
+     CGContextSetFont (state.context, cgfref);
+     CGContextSetFontSize (state.context, 1.0);
+ 
++    effective_antialiasing = scaled_font->options.antialias;
++    if (effective_antialiasing == CAIRO_ANTIALIAS_SUBPIXEL &&
++        !surface->base.permit_subpixel_antialiasing) {
++        effective_antialiasing = CAIRO_ANTIALIAS_GRAY;
++    }
++
+     switch (scaled_font->options.antialias) {
+ 	case CAIRO_ANTIALIAS_SUBPIXEL:
+ 	    CGContextSetShouldAntialias (state.context, TRUE);
+ 	    CGContextSetShouldSmoothFonts (state.context, TRUE);
+ 	    if (CGContextSetAllowsFontSmoothingPtr &&
+ 		!CGContextGetAllowsFontSmoothingPtr (state.context))
+ 	    {
+ 		didForceFontSmoothing = TRUE;
+diff --git a/gfx/cairo/cairo/src/cairo-surface-private.h b/gfx/cairo/cairo/src/cairo-surface-private.h
+--- a/gfx/cairo/cairo/src/cairo-surface-private.h
++++ b/gfx/cairo/cairo/src/cairo-surface-private.h
+@@ -58,16 +58,17 @@ struct _cairo_surface {
+ 
+     cairo_reference_count_t ref_count;
+     cairo_status_t status;
+     unsigned int unique_id;
+ 
+     unsigned finished : 1;
+     unsigned is_clear : 1;
+     unsigned has_font_options : 1;
++    unsigned permit_subpixel_antialiasing : 1;
+ 
+     cairo_user_data_array_t user_data;
+     cairo_user_data_array_t mime_data;
+ 
+     cairo_matrix_t device_transform;
+     cairo_matrix_t device_transform_inverse;
+ 
+     /* The actual resolution of the device, in dots per inch. */
+diff --git a/gfx/cairo/cairo/src/cairo-surface.c b/gfx/cairo/cairo/src/cairo-surface.c
+--- a/gfx/cairo/cairo/src/cairo-surface.c
++++ b/gfx/cairo/cairo/src/cairo-surface.c
+@@ -49,17 +49,18 @@ const cairo_surface_t name = {					\
+     NULL,				/* backend */		\
+     CAIRO_SURFACE_TYPE_IMAGE,		/* type */		\
+     CAIRO_CONTENT_COLOR,		/* content */		\
+     CAIRO_REFERENCE_COUNT_INVALID,	/* ref_count */		\
+     status,				/* status */		\
+     0,					/* unique id */		\
+     FALSE,				/* finished */		\
+     TRUE,				/* is_clear */		\
+-    FALSE,				/* has_font_options */	\
++    FALSE,                             /* has_font_options */	\
++    FALSE,                             /* permit_subpixel_antialiasing */ \
+     { 0, 0, 0, NULL, },			/* user_data */		\
+     { 0, 0, 0, NULL, },			/* mime_data */         \
+     { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 },   /* device_transform */	\
+     { 1.0, 0.0,	0.0, 1.0, 0.0, 0.0 },	/* device_transform_inverse */	\
+     0.0,				/* x_resolution */	\
+     0.0,				/* y_resolution */	\
+     0.0,				/* x_fallback_resolution */	\
+     0.0,				/* y_fallback_resolution */	\
+@@ -342,46 +343,48 @@ _cairo_surface_init (cairo_surface_t			*
+     surface->content = content;
+     surface->type = backend->type;
+ 
+     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->is_clear = FALSE;
++    surface->has_font_options = FALSE;
++    surface->permit_subpixel_antialiasing = TRUE;
+ 
+     _cairo_user_data_array_init (&surface->user_data);
+     _cairo_user_data_array_init (&surface->mime_data);
+ 
+     cairo_matrix_init_identity (&surface->device_transform);
+     cairo_matrix_init_identity (&surface->device_transform_inverse);
+ 
+     surface->x_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT;
+     surface->y_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT;
+ 
+     surface->x_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT;
+     surface->y_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT;
+ 
+     _cairo_array_init (&surface->snapshots, sizeof (cairo_surface_t *));
+     surface->snapshot_of = NULL;
+-
+-    surface->has_font_options = FALSE;
+ }
+ 
+ static void
+ _cairo_surface_copy_similar_properties (cairo_surface_t *surface,
+ 					cairo_surface_t *other)
+ {
+     if (other->has_font_options || other->backend != surface->backend) {
+ 	cairo_font_options_t options;
+ 
+ 	cairo_surface_get_font_options (other, &options);
+ 	_cairo_surface_set_font_options (surface, &options);
+     }
+ 
++    surface->permit_subpixel_antialiasing = other->permit_subpixel_antialiasing;
++
+     cairo_surface_set_fallback_resolution (surface,
+ 					   other->x_fallback_resolution,
+ 					   other->y_fallback_resolution);
+ }
+ 
+ cairo_surface_t *
+ _cairo_surface_create_similar_scratch (cairo_surface_t *other,
+ 				       cairo_content_t	content,
+@@ -2482,16 +2485,67 @@ cairo_surface_has_show_text_glyphs (cair
+ 
+     if (surface->backend->has_show_text_glyphs)
+ 	return surface->backend->has_show_text_glyphs (surface);
+     else
+ 	return surface->backend->show_text_glyphs != NULL;
+ }
+ slim_hidden_def (cairo_surface_has_show_text_glyphs);
+ 
++/**
++ * cairo_surface_set_subpixel_antialiasing:
++ * @surface: a #cairo_surface_t
++ *
++ * Sets whether the surface permits subpixel antialiasing. By default,
++ * surfaces permit subpixel antialiasing.
++ *
++ * Enabling subpixel antialiasing for CONTENT_COLOR_ALPHA surfaces generally
++ * requires that the pixels in the areas under a subpixel antialiasing
++ * operation already be opaque.
++ *
++ * Since: 1.12
++ **/
++void
++cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface,
++                                         cairo_subpixel_antialiasing_t enabled)
++{
++    if (surface->status)
++        return;
++
++    if (surface->finished) {
++        _cairo_surface_set_error (surface, CAIRO_STATUS_SURFACE_FINISHED);
++        return;
++    }
++
++    surface->permit_subpixel_antialiasing =
++        enabled == CAIRO_SUBPIXEL_ANTIALIASING_ENABLED;
++}
++slim_hidden_def (cairo_surface_set_subpixel_antialiasing);
++
++/**
++ * cairo_surface_get_subpixel_antialiasing:
++ * @surface: a #cairo_surface_t
++ *
++ * Gets whether the surface supports subpixel antialiasing. By default,
++ * CAIRO_CONTENT_COLOR surfaces support subpixel antialiasing but other
++ * surfaces do not.
++ *
++ * Since: 1.12
++ **/
++cairo_subpixel_antialiasing_t
++cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface)
++{
++    if (surface->status)
++        return CAIRO_SUBPIXEL_ANTIALIASING_DISABLED;
++
++    return surface->permit_subpixel_antialiasing ?
++        CAIRO_SUBPIXEL_ANTIALIASING_ENABLED : CAIRO_SUBPIXEL_ANTIALIASING_DISABLED;
++}
++slim_hidden_def (cairo_surface_get_subpixel_antialiasing);
++
+ /* Note: the backends may modify the contents of the glyph array as long as
+  * they do not return %CAIRO_INT_STATUS_UNSUPPORTED. This makes it possible to
+  * avoid copying the array again and again, and edit it in-place.
+  * Backends are in fact free to use the array as a generic buffer as they
+  * see fit.
+  *
+  * For show_glyphs backend method, and NOT for show_text_glyphs method,
+  * when they do return UNSUPPORTED, they may adjust remaining_glyphs to notify
+diff --git a/gfx/cairo/cairo/src/cairo-win32-font.c b/gfx/cairo/cairo/src/cairo-win32-font.c
+--- a/gfx/cairo/cairo/src/cairo-win32-font.c
++++ b/gfx/cairo/cairo/src/cairo-win32-font.c
+@@ -1380,16 +1380,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
+     cairo_win32_surface_t *surface = (cairo_win32_surface_t *)generic_surface;
+     cairo_status_t status;
+ 
+     if (width == 0 || height == 0)
+ 	return CAIRO_STATUS_SUCCESS;
+ 
+     if (_cairo_surface_is_win32 (generic_surface) &&
+ 	surface->format == CAIRO_FORMAT_RGB24 &&
++	(generic_surface->permit_subpixel_antialiasing || scaled_font->quality != CLEARTYPE_QUALITY) &&
+ 	op == CAIRO_OPERATOR_OVER &&
+ 	_cairo_pattern_is_opaque_solid (pattern)) {
+ 
+ 	cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)pattern;
+ 
+ 	/* When compositing OVER on a GDI-understood surface, with a
+ 	 * solid opaque color, we can just call ExtTextOut directly.
+ 	 */
+@@ -1411,16 +1412,18 @@ _cairo_win32_scaled_font_show_glyphs (vo
+ 	 * surface by drawing the the glyphs onto a DIB, black-on-white then
+ 	 * inverting. GDI outputs gamma-corrected images so inverted black-on-white
+ 	 * is very different from white-on-black. We favor the more common
+ 	 * case where the final output is dark-on-light.
+ 	 */
+ 	cairo_win32_surface_t *tmp_surface;
+ 	cairo_surface_t *mask_surface;
+ 	cairo_surface_pattern_t mask;
++	cairo_bool_t use_subpixel_antialiasing =
++	    scaled_font->quality == CLEARTYPE_QUALITY && generic_surface->permit_subpixel_antialiasing;
+ 	RECT r;
+ 
+ 	tmp_surface = (cairo_win32_surface_t *)cairo_win32_surface_create_with_dib (CAIRO_FORMAT_ARGB32, width, height);
+ 	if (tmp_surface->base.status)
+ 	    return tmp_surface->base.status;
+ 
+ 	r.left = 0;
+ 	r.top = 0;
+@@ -1432,17 +1435,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
+ 		                          scaled_font, RGB (0, 0, 0),
+ 					  dest_x, dest_y,
+ 					  glyphs, num_glyphs);
+ 	if (status) {
+ 	    cairo_surface_destroy (&tmp_surface->base);
+ 	    return status;
+ 	}
+ 
+-	if (scaled_font->quality == CLEARTYPE_QUALITY) {
++	if (use_subpixel_antialiasing) {
+ 	    /* For ClearType, we need a 4-channel mask. If we are compositing on
+ 	     * a surface with alpha, we need to compute the alpha channel of
+ 	     * the mask (we just copy the green channel). But for a destination
+ 	     * surface without alpha the alpha channel of the mask is ignored
+ 	     */
+ 
+ 	    if (surface->format != CAIRO_FORMAT_RGB24)
+ 		_compute_argb32_mask_alpha (tmp_surface);
+@@ -1460,17 +1463,17 @@ _cairo_win32_scaled_font_show_glyphs (vo
+ 
+ 	/* For op == OVER, no-cleartype, a possible optimization here is to
+ 	 * draw onto an intermediate ARGB32 surface and alpha-blend that with the
+ 	 * destination
+ 	 */
+ 	_cairo_pattern_init_for_surface (&mask, mask_surface);
+ 	cairo_surface_destroy (mask_surface);
+ 
+-	if (scaled_font->quality == CLEARTYPE_QUALITY)
++	if (use_subpixel_antialiasing)
+ 	    mask.base.has_component_alpha = TRUE;
+ 
+ 	status = _cairo_surface_composite (op, pattern,
+ 					   &mask.base,
+ 					   &surface->base,
+ 					   source_x, source_y,
+ 					   0, 0,
+ 					   dest_x, dest_y,
+diff --git a/gfx/cairo/cairo/src/cairo-xlib-surface.c b/gfx/cairo/cairo/src/cairo-xlib-surface.c
+--- a/gfx/cairo/cairo/src/cairo-xlib-surface.c
++++ b/gfx/cairo/cairo/src/cairo-xlib-surface.c
+@@ -3570,16 +3570,17 @@ typedef struct _cairo_xlib_font_glyphset
+     GlyphSet		glyphset;
+     cairo_format_t	format;
+     XRenderPictFormat	*xrender_format;
+     cairo_xlib_font_glyphset_free_glyphs_t *pending_free_glyphs;
+ } cairo_xlib_font_glyphset_info_t;
+ 
+ typedef struct _cairo_xlib_surface_font_private {
+     cairo_scaled_font_t		    *scaled_font;
++    cairo_scaled_font_t         *grayscale_font;
+     cairo_xlib_hook_t                close_display_hook;
+     cairo_xlib_display_t	    *display;
+     cairo_xlib_font_glyphset_info_t  glyphset_info[NUM_GLYPHSETS];
+ } cairo_xlib_surface_font_private_t;
+ 
+ /* callback from CloseDisplay */
+ static void
+ _cairo_xlib_surface_remove_scaled_font (cairo_xlib_display_t	*display,
+@@ -3599,16 +3600,20 @@ _cairo_xlib_surface_remove_scaled_font (
+ 
+     _cairo_scaled_font_reset_cache (scaled_font);
+     CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
+ 
+     if (font_private != NULL) {
+ 	Display *dpy;
+ 	int i;
+ 
++    if (font_private->grayscale_font) {
++        cairo_scaled_font_destroy (font_private->grayscale_font);
++    }
++
+ 	dpy = _cairo_xlib_display_get_dpy (display);
+ 	for (i = 0; i < NUM_GLYPHSETS; i++) {
+ 	    cairo_xlib_font_glyphset_info_t *glyphset_info;
+ 
+ 	    glyphset_info = &font_private->glyphset_info[i];
+ 	    if (glyphset_info->glyphset)
+ 		XRenderFreeGlyphSet (dpy, glyphset_info->glyphset);
+ 
+@@ -3629,16 +3634,17 @@ _cairo_xlib_surface_font_init (Display		
+     cairo_status_t status;
+     int i;
+ 
+     font_private = malloc (sizeof (cairo_xlib_surface_font_private_t));
+     if (unlikely (font_private == NULL))
+ 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ 
+     font_private->scaled_font = scaled_font;
++    font_private->grayscale_font = NULL;
+     status = _cairo_xlib_display_get (dpy, &font_private->display);
+     if (unlikely (status)) {
+ 	free (font_private);
+ 	return status;
+     }
+ 
+     /* initialize and hook into the CloseDisplay callback */
+     font_private->close_display_hook.func =
+@@ -3671,16 +3677,20 @@ _cairo_xlib_surface_scaled_font_fini (ca
+ {
+     cairo_xlib_surface_font_private_t *font_private;
+ 
+     font_private = scaled_font->surface_private;
+     if (font_private != NULL) {
+ 	cairo_xlib_display_t *display;
+ 	int i;
+ 
++	if (font_private->grayscale_font) {
++        cairo_scaled_font_destroy (font_private->grayscale_font);
++	}
++
+ 	display = font_private->display;
+ 	_cairo_xlib_remove_close_display_hook (display,
+ 					       &font_private->close_display_hook);
+ 
+ 	for (i = 0; i < NUM_GLYPHSETS; i++) {
+ 	    cairo_xlib_font_glyphset_info_t *glyphset_info;
+ 
+ 	    glyphset_info = &font_private->glyphset_info[i];
+@@ -4417,16 +4427,62 @@ _cairo_xlib_surface_owns_font (cairo_xli
+ 	(font_private != NULL && font_private->display != dst->display))
+     {
+ 	return FALSE;
+     }
+ 
+     return TRUE;
+ }
+ 
++/* Gets a grayscale version of scaled_font. The grayscale version is cached
++ * in our surface_private data.
++ */
++static cairo_scaled_font_t *
++_cairo_xlib_get_grayscale_font (cairo_xlib_surface_t *dst,
++                                cairo_scaled_font_t *scaled_font)
++{
++    cairo_xlib_surface_font_private_t *font_private = scaled_font->surface_private;
++    cairo_bool_t needs_font;
++
++    if (font_private == NULL) {
++        cairo_status_t status = _cairo_xlib_surface_font_init (dst->dpy, scaled_font);
++        if (unlikely (status))
++            return _cairo_scaled_font_create_in_error (status);
++        font_private = scaled_font->surface_private;
++    }
++
++    CAIRO_MUTEX_LOCK (scaled_font->mutex);
++    needs_font = !font_private->grayscale_font;
++    CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
++
++    if (needs_font) {
++        cairo_font_options_t options;
++        cairo_scaled_font_t *new_font;
++
++        options = scaled_font->options;
++        options.antialias = CAIRO_ANTIALIAS_GRAY;
++        new_font = cairo_scaled_font_create (scaled_font->font_face,
++                                             &scaled_font->font_matrix,
++                                             &scaled_font->ctm, &options);
++
++        CAIRO_MUTEX_LOCK (scaled_font->mutex);
++        if (!font_private->grayscale_font) {
++            font_private->grayscale_font = new_font;
++            new_font = NULL;
++        }
++        CAIRO_MUTEX_UNLOCK (scaled_font->mutex);
++
++        if (new_font) {
++            cairo_scaled_font_destroy (new_font);
++        }
++    }
++
++    return font_private->grayscale_font;
++}
++
+ static cairo_int_status_t
+ _cairo_xlib_surface_show_glyphs (void                *abstract_dst,
+ 				 cairo_operator_t     op,
+ 				 const cairo_pattern_t *src_pattern,
+ 				 cairo_glyph_t       *glyphs,
+ 				 int		      num_glyphs,
+ 				 cairo_scaled_font_t *scaled_font,
+ 				 cairo_clip_t	     *clip,
+@@ -4475,16 +4531,21 @@ _cairo_xlib_surface_show_glyphs (void   
+ 
+     operation = _categorize_composite_operation (dst, op, src_pattern, TRUE);
+     if (operation == DO_UNSUPPORTED)
+ 	return UNSUPPORTED ("unsupported op");
+ 
+     if (! _cairo_xlib_surface_owns_font (dst, scaled_font))
+ 	return UNSUPPORTED ("unowned font");
+ 
++    if (!dst->base.permit_subpixel_antialiasing &&
++        scaled_font->options.antialias == CAIRO_ANTIALIAS_SUBPIXEL) {
++        scaled_font = _cairo_xlib_get_grayscale_font (dst, scaled_font);
++    }
++
+     X_DEBUG ((dst->dpy, "show_glyphs (dst=%x)", (unsigned int) dst->drawable));
+ 
+     if (clip_region != NULL &&
+ 	cairo_region_num_rectangles (clip_region) == 1)
+     {
+ 	cairo_rectangle_int_t glyph_extents;
+ 	const cairo_rectangle_int_t *clip_extents;
+ 
+diff --git a/gfx/cairo/cairo/src/cairo.h b/gfx/cairo/cairo/src/cairo.h
+--- a/gfx/cairo/cairo/src/cairo.h
++++ b/gfx/cairo/cairo/src/cairo.h
+@@ -2101,16 +2101,35 @@ cairo_public void
+ cairo_surface_copy_page (cairo_surface_t *surface);
+ 
+ cairo_public void
+ cairo_surface_show_page (cairo_surface_t *surface);
+ 
+ cairo_public cairo_bool_t
+ cairo_surface_has_show_text_glyphs (cairo_surface_t *surface);
+ 
++/**
++ * _cairo_subpixel_antialiasing_t:
++ * @CAIRO_SUBPIXEL_ANTIALIASING_ENABLED: subpixel antialiasing is enabled
++ * for this surface.
++ * @CAIRO_SUBPIXEL_ANTIALIASING_DISABLED: subpixel antialiasing is disabled
++ * for this surface.
++ */
++typedef enum _cairo_subpixel_antialiasing_t {
++    CAIRO_SUBPIXEL_ANTIALIASING_ENABLED,
++    CAIRO_SUBPIXEL_ANTIALIASING_DISABLED
++} cairo_subpixel_antialiasing_t;
++
++cairo_public void
++cairo_surface_set_subpixel_antialiasing (cairo_surface_t *surface,
++                                         cairo_subpixel_antialiasing_t enabled);
++
++cairo_public cairo_subpixel_antialiasing_t
++cairo_surface_get_subpixel_antialiasing (cairo_surface_t *surface);
++
+ /* Image-surface functions */
+ 
+ /**
+  * cairo_format_t:
+  * @CAIRO_FORMAT_ARGB32: each pixel is a 32-bit quantity, with
+  *   alpha in the upper 8 bits, then red, then green, then blue.
+  *   The 32-bit quantities are stored native-endian. Pre-multiplied
+  *   alpha is used. (That is, 50% transparent red is 0x80800000,
+diff --git a/gfx/cairo/cairo/src/cairoint.h b/gfx/cairo/cairo/src/cairoint.h
+--- a/gfx/cairo/cairo/src/cairoint.h
++++ b/gfx/cairo/cairo/src/cairoint.h
+@@ -2750,16 +2750,18 @@ slim_hidden_proto (cairo_surface_destroy
+ slim_hidden_proto (cairo_surface_finish);
+ slim_hidden_proto (cairo_surface_flush);
+ slim_hidden_proto (cairo_surface_get_content);
+ slim_hidden_proto (cairo_surface_get_device_offset);
+ slim_hidden_proto (cairo_surface_get_font_options);
+ slim_hidden_proto (cairo_surface_get_mime_data);
+ slim_hidden_proto (cairo_surface_get_type);
+ slim_hidden_proto (cairo_surface_has_show_text_glyphs);
++slim_hidden_proto (cairo_surface_set_subpixel_antialiasing);
++slim_hidden_proto (cairo_surface_get_subpixel_antialiasing);
+ slim_hidden_proto (cairo_surface_mark_dirty_rectangle);
+ slim_hidden_proto_no_warn (cairo_surface_reference);
+ slim_hidden_proto (cairo_surface_set_device_offset);
+ slim_hidden_proto (cairo_surface_set_fallback_resolution);
+ slim_hidden_proto (cairo_surface_set_mime_data);
+ slim_hidden_proto (cairo_surface_show_page);
+ slim_hidden_proto (cairo_surface_status);
+ slim_hidden_proto (cairo_text_cluster_allocate);