Flesh test-paginated-surface out into a complete surface.

This adds an aactual test_paginated_surface_backend rather than just
having this test surface create a paginated surface around an image
surface. This is a more realistic test of what a paginated surface is
and should be more useful as an example of how to use the paginated
surface, (and in particular the analysis portions).

src/cairo-image-surface.c

@@ -861,7 +861,7 @@ _cairo_image_surface_composite_trapezoids (cairo_operator_t	op,
     return status;
 }
 
-static cairo_int_status_t
+cairo_int_status_t
 _cairo_image_surface_set_clip_region (void *abstract_surface,
 				      pixman_region16_t *region)
 {

src/cairoint.h

@@ -1862,6 +1862,19 @@ _cairo_image_surface_create_for_data_with_content (unsigned char	*data,
 cairo_private void
 _cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface);
 
+/* XXX: It's a nasty kludge that this appears here. Backend functions
+ * like this should really be static. But we're doing this to work
+ * around some general defects in the backend clipping interfaces,
+ * (see some notes in test-paginated-surface.c).
+ *
+ * I want to fix the real defects, but it's "hard" as they touch many
+ * backends, so doing that will require synchronizing several backend
+ * maintainers.
+ */
+cairo_private cairo_int_status_t
+_cairo_image_surface_set_clip_region (void *abstract_surface,
+				      pixman_region16_t *region);
+
 cairo_private cairo_bool_t
 _cairo_surface_is_image (const cairo_surface_t *surface);
 

src/test-paginated-surface.c

@@ -51,20 +51,21 @@
 
 #include "cairo-paginated-surface-private.h"
 
+typedef struct _test_paginated_surface {
+    cairo_surface_t base;
+    cairo_surface_t *target;
+    cairo_paginated_mode_t paginated_mode;
+} test_paginated_surface_t;
+
+static const cairo_surface_backend_t test_paginated_surface_backend;
+
 static void
-_test_paginated_surface_set_paginated_mode (cairo_surface_t *target,
+_test_paginated_surface_set_paginated_mode (cairo_surface_t *abstract_surface,
 					    cairo_paginated_mode_t mode)
 {
-    /* XXX: We don't do anything to save the paginated mode here. This
-     * means that all the rendering will hit the image surface
-     * twice. This will work (but less efficiently) for all tests that
-     * explicitly initialize all pixels. Tests that expect the
-     * background to initially be transparent and leave it that way in
-     * spots will likely fail.
-     *
-     * If we see this as worth fixing, it will just require shoving
-     * some set_paginated_mode support into cairo_image_surface_t.
-     */
+    test_paginated_surface_t *surface = (test_paginated_surface_t *) abstract_surface;
+
+    surface->paginated_mode = mode;
 }
 
 cairo_surface_t *
@@ -74,12 +75,204 @@ _test_paginated_surface_create_for_data (unsigned char		*data,
 					 int		 	 height,
 					 int		 	 stride)
 {
+    cairo_status_t status;
     cairo_surface_t *target;
+    test_paginated_surface_t *surface;
 
-    target = _cairo_image_surface_create_for_data_with_content (data, content,
+    target =  _cairo_image_surface_create_for_data_with_content (data, content,
 								width, height,
 								stride);
+    status = cairo_surface_status (target);
+    if (status) {
+	_cairo_error (status);
+	return (cairo_surface_t *) &_cairo_surface_nil;
+    }
 
-    return _cairo_paginated_surface_create (target, content, width, height,
+    surface = malloc (sizeof (test_paginated_surface_t));
+    if (surface == NULL) {
+	_cairo_error (CAIRO_STATUS_NO_MEMORY);
+	return (cairo_surface_t *) &_cairo_surface_nil;
+    }
+
+    _cairo_surface_init (&surface->base, &test_paginated_surface_backend);
+
+    surface->target = target;
+
+    return _cairo_paginated_surface_create (&surface->base, content, width, height,
 					    _test_paginated_surface_set_paginated_mode);
 }
+
+static cairo_int_status_t
+_test_paginated_surface_set_clip_region (void *abstract_surface,
+					 pixman_region16_t *region)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    /* XXX: The whole surface backend clipping interface is a giant
+     * disaster right now. In particular, its uncleanness shows up
+     * when trying to implement one surface that wraps another one (as
+     * we are doing here).
+     *
+     * Here are two of the problems that show up:
+     *
+     * 1. The most critical piece of information in all this stuff,
+     * the "clip" isn't getting passed to the backend
+     * functions. Instead the generic surface layer is caching that as
+     * surface->clip. This is a problem for surfaces like this one
+     * that do wrapping. Our base surface will have the clip set, but
+     * our target's surface will not.
+     *
+     * 2. We're here in our backend's set_clip_region function, and we
+     * want to call into our target surface's set_clip_region.
+     * Generally, we would do this by calling an equivalent
+     * _cairo_surface function, but _cairo_surface_set_clip_region
+     * does not have the same signature/semantics, (it has the
+     * clip_serial stuff as well).
+     *
+     * We kludge around each of these by manually copying the clip
+     * object from our base surface into the target's base surface
+     * (yuck!) and by reaching directly into the image surface's
+     * set_clip_region instead of calling into the generic
+     * _cairo_surface_set_clip_region (double yuck!).
+     */
+
+    surface->target->clip = surface->base.clip;
+
+    return _cairo_image_surface_set_clip_region (surface->target, region);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_get_extents (void	       *abstract_surface,
+				     cairo_rectangle_t *rectangle)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    return _cairo_surface_get_extents (surface->target, rectangle);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_paint (void		*abstract_surface,
+			       cairo_operator_t	 op,
+			       cairo_pattern_t	*source)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    return _cairo_surface_paint (surface->target, op, source);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_mask (void		*abstract_surface,
+			      cairo_operator_t	 op,
+			      cairo_pattern_t	*source,
+			      cairo_pattern_t	*mask)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    return _cairo_surface_mask (surface->target, op, source, mask);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_stroke (void			*abstract_surface,
+				cairo_operator_t	 op,
+				cairo_pattern_t		*source,
+				cairo_path_fixed_t	*path,
+				cairo_stroke_style_t	*style,
+				cairo_matrix_t		*ctm,
+				cairo_matrix_t		*ctm_inverse,
+				double			 tolerance,
+				cairo_antialias_t	 antialias)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    return _cairo_surface_stroke (surface->target, op, source,
+				  path, style,
+				  ctm, ctm_inverse,
+				  tolerance, antialias);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_fill (void			*abstract_surface,
+			      cairo_operator_t		 op,
+			      cairo_pattern_t		*source,
+			      cairo_path_fixed_t	*path,
+			      cairo_fill_rule_t		 fill_rule,
+			      double			 tolerance,
+			      cairo_antialias_t		 antialias)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    return _cairo_surface_fill (surface->target, op, source,
+				path, fill_rule,
+				tolerance, antialias);
+}
+
+static cairo_int_status_t
+_test_paginated_surface_show_glyphs (void			*abstract_surface,
+				     cairo_operator_t		 op,
+				     cairo_pattern_t		*source,
+				     const cairo_glyph_t	*glyphs,
+				     int			 num_glyphs,
+				     cairo_scaled_font_t	*scaled_font)
+{
+    test_paginated_surface_t *surface = abstract_surface;
+
+    if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+	return CAIRO_STATUS_SUCCESS;
+
+    return _cairo_surface_show_glyphs (surface->target, op, source,
+				       glyphs, num_glyphs, scaled_font);
+}
+
+static const cairo_surface_backend_t test_paginated_surface_backend = {
+    CAIRO_INTERNAL_SURFACE_TYPE_TEST_PAGINATED,
+
+    /* Since we are a paginated user, we get to regard most of the
+     * surface backend interface as historical cruft and ignore it. */
+
+    NULL, /* create_similar */
+    NULL, /* finish */
+    NULL, /* acquire_source_image */
+    NULL, /* release_source_image */
+    NULL, /* acquire_dest_image */
+    NULL, /* release_dest_image */
+    NULL, /* clone_similar */
+    NULL, /* composite */
+    NULL, /* fill_rectangles */
+    NULL, /* composite_trapezoids */
+    NULL, /* copy_page */
+    NULL, /* show_page */
+    _test_paginated_surface_set_clip_region,
+    NULL, /* intersect_clip_path */
+    _test_paginated_surface_get_extents,
+    NULL, /* old_show_glyphs */
+    NULL, /* get_font_options */
+    NULL, /* flush */
+    NULL, /* mark_dirty_rectangle */
+    NULL, /* scaled_font_fini */
+    NULL, /* scaled_glyph_fini */
+
+    /* Here is the more "modern" section of the surface backend
+     * interface which is mostly just drawing functions */
+
+    _test_paginated_surface_paint,
+    _test_paginated_surface_mask,
+    _test_paginated_surface_stroke,
+    _test_paginated_surface_fill,
+    _test_paginated_surface_show_glyphs,
+    NULL /* snapshot */
+};

test/cairo-test.c

@@ -1502,12 +1502,12 @@ cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
 	    { "test-meta", CAIRO_INTERNAL_SURFACE_TYPE_TEST_META,
 	      CAIRO_CONTENT_COLOR,
 	      create_test_meta_surface, cairo_surface_write_to_png, NULL },
-	    { "test-paginated", CAIRO_SURFACE_TYPE_IMAGE,
+	    { "test-paginated", CAIRO_INTERNAL_SURFACE_TYPE_TEST_PAGINATED,
 	      CAIRO_CONTENT_COLOR_ALPHA,
 	      create_test_paginated_surface,
 	      test_paginated_write_to_png,
 	      cleanup_test_paginated },
-	    { "test-paginated", CAIRO_SURFACE_TYPE_IMAGE,
+	    { "test-paginated", CAIRO_INTERNAL_SURFACE_TYPE_TEST_PAGINATED,
 	      CAIRO_CONTENT_COLOR,
 	      create_test_paginated_surface,
 	      test_paginated_write_to_png,