[meta] Rename cairo_meta_surface_t to cairo_recording_surface_t.

The new name is more descriptive than the rather opaque meta surface.
Discussed with vigour on the mailing list and #cairo:

http://lists.cairographics.org/archives/cairo/2009-July/017571.html

27 files changed, 582 insertions, 582 deletions

diff --git a/src/Makefile.sources b/src/Makefile.sources
index df958881..1e04ed2e 100644
--- a/src/Makefile.sources
+++ b/src/Makefile.sources
@@ -67,7 +67,7 @@ cairo_private = \
 	cairo-image-info-private.h \
 	cairo-list-private.h \
 	cairo-malloc-private.h \
-	cairo-meta-surface-private.h \
+	cairo-recording-surface-private.h \
 	cairo-mutex-impl-private.h \
 	cairo-mutex-list-private.h \
 	cairo-mutex-private.h \
@@ -122,7 +122,7 @@ cairo_sources = \
 	cairo-image-surface.c \
 	cairo-lzw.c \
 	cairo-matrix.c \
-	cairo-meta-surface.c \
+	cairo-recording-surface.c \
 	cairo-misc.c \
 	cairo-mutex.c \
 	cairo-output-stream.c \
diff --git a/src/Makefile.win32.features b/src/Makefile.win32.features
index 4e55642d..048c9211 100644
--- a/src/Makefile.win32.features
+++ b/src/Makefile.win32.features
@@ -428,13 +428,13 @@ enabled_cairo_headers += $(cairo_image_headers)
 enabled_cairo_private += $(cairo_image_private)
 enabled_cairo_sources += $(cairo_image_sources)
 
-supported_cairo_headers += $(cairo_meta_headers)
-all_cairo_headers += $(cairo_meta_headers)
-all_cairo_private += $(cairo_meta_private)
-all_cairo_sources += $(cairo_meta_sources)
-enabled_cairo_headers += $(cairo_meta_headers)
-enabled_cairo_private += $(cairo_meta_private)
-enabled_cairo_sources += $(cairo_meta_sources)
+supported_cairo_headers += $(cairo_recording_headers)
+all_cairo_headers += $(cairo_recording_headers)
+all_cairo_private += $(cairo_recording_private)
+all_cairo_sources += $(cairo_recording_sources)
+enabled_cairo_headers += $(cairo_recording_headers)
+enabled_cairo_private += $(cairo_recording_private)
+enabled_cairo_sources += $(cairo_recording_sources)
 
 supported_cairo_headers += $(cairo_tee_headers)
 all_cairo_headers += $(cairo_tee_headers)
diff --git a/src/cairo-analysis-surface.c b/src/cairo-analysis-surface.c
index 5faa1b96..0ba667d4 100644
--- a/src/cairo-analysis-surface.c
+++ b/src/cairo-analysis-surface.c
@@ -38,7 +38,7 @@
 
 #include "cairo-analysis-surface-private.h"
 #include "cairo-paginated-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-region-private.h"
 
 typedef struct {
@@ -76,9 +76,9 @@ _cairo_analysis_surface_merge_status (cairo_int_status_t status_a,
 	status_b == CAIRO_INT_STATUS_IMAGE_FALLBACK)
 	return CAIRO_INT_STATUS_IMAGE_FALLBACK;
 
-    if (status_a == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN ||
-	status_b == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	return CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN;
+    if (status_a == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN ||
+	status_b == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
 
     if (status_a == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY ||
 	status_b == CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY)
@@ -92,8 +92,8 @@ _cairo_analysis_surface_merge_status (cairo_int_status_t status_a,
 }
 
 static cairo_int_status_t
-_analyze_meta_surface_pattern (cairo_analysis_surface_t	*surface,
-			       const cairo_pattern_t *pattern)
+_analyze_recording_surface_pattern (cairo_analysis_surface_t *surface,
+				    const cairo_pattern_t    *pattern)
 {
     const cairo_surface_pattern_t *surface_pattern;
     cairo_bool_t old_has_ctm;
@@ -102,7 +102,7 @@ _analyze_meta_surface_pattern (cairo_analysis_surface_t	*surface,
 
     assert (pattern->type == CAIRO_PATTERN_TYPE_SURFACE);
     surface_pattern = (const cairo_surface_pattern_t *) pattern;
-    assert (_cairo_surface_is_meta (surface_pattern->surface));
+    assert (_cairo_surface_is_recording (surface_pattern->surface));
 
     old_ctm = surface->ctm;
     old_has_ctm = surface->has_ctm;
@@ -114,7 +114,7 @@ _analyze_meta_surface_pattern (cairo_analysis_surface_t	*surface,
     cairo_matrix_multiply (&surface->ctm, &p2d, &surface->ctm);
     surface->has_ctm = ! _cairo_matrix_is_identity (&surface->ctm);
 
-    status = _cairo_meta_surface_replay_and_create_regions (surface_pattern->surface,
+    status = _cairo_recording_surface_replay_and_create_regions (surface_pattern->surface,
 							    &surface->base);
 
     surface->ctm = old_ctm;
@@ -227,7 +227,7 @@ _add_operation (cairo_analysis_surface_t *surface,
     status = cairo_region_union_rectangle (&surface->fallback_region, rect);
 
     /* The status CAIRO_INT_STATUS_IMAGE_FALLBACK is used to indicate
-     * unsupported operations to the meta surface as using
+     * unsupported operations to the recording surface as using
      * CAIRO_INT_STATUS_UNSUPPORTED would cause cairo-surface to
      * invoke the cairo-surface-fallback path then return
      * CAIRO_STATUS_SUCCESS.
@@ -315,8 +315,8 @@ _cairo_analysis_surface_paint (void			*abstract_surface,
 	    return backend_status;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	backend_status = _analyze_meta_surface_pattern (surface, source);
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	backend_status = _analyze_recording_surface_pattern (surface, source);
 
     _cairo_analysis_surface_operation_extents (surface,
 					       op, source, clip,
@@ -347,15 +347,15 @@ _cairo_analysis_surface_mask (void			*abstract_surface,
 	    return backend_status;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN) {
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN) {
 	cairo_int_status_t backend_source_status = CAIRO_STATUS_SUCCESS;
 	cairo_int_status_t backend_mask_status = CAIRO_STATUS_SUCCESS;
 
 	if (source->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	    const cairo_surface_pattern_t *surface_pattern = (const cairo_surface_pattern_t *) source;
-	    if (_cairo_surface_is_meta (surface_pattern->surface)) {
+	    if (_cairo_surface_is_recording (surface_pattern->surface)) {
 		backend_source_status =
-		    _analyze_meta_surface_pattern (surface, source);
+		    _analyze_recording_surface_pattern (surface, source);
 		if (_cairo_status_is_error (backend_source_status))
 		    return backend_source_status;
 	    }
@@ -363,9 +363,9 @@ _cairo_analysis_surface_mask (void			*abstract_surface,
 
 	if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	    cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) mask;
-	    if (_cairo_surface_is_meta (surface_pattern->surface)) {
+	    if (_cairo_surface_is_recording (surface_pattern->surface)) {
 		backend_mask_status =
-		    _analyze_meta_surface_pattern (surface, mask);
+		    _analyze_recording_surface_pattern (surface, mask);
 		if (_cairo_status_is_error (backend_mask_status))
 		    return backend_mask_status;
 	    }
@@ -421,8 +421,8 @@ _cairo_analysis_surface_stroke (void			*abstract_surface,
 	    return backend_status;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	backend_status = _analyze_meta_surface_pattern (surface, source);
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	backend_status = _analyze_recording_surface_pattern (surface, source);
 
     _cairo_analysis_surface_operation_extents (surface,
 					       op, source, clip,
@@ -485,8 +485,8 @@ _cairo_analysis_surface_fill (void			*abstract_surface,
 	    return backend_status;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	backend_status = _analyze_meta_surface_pattern (surface, source);
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	backend_status = _analyze_recording_surface_pattern (surface, source);
 
     _cairo_analysis_surface_operation_extents (surface,
 					       op, source, clip,
@@ -557,8 +557,8 @@ _cairo_analysis_surface_show_glyphs (void		  *abstract_surface,
 	backend_status = CAIRO_INT_STATUS_UNSUPPORTED;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	backend_status = _analyze_meta_surface_pattern (surface, source);
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	backend_status = _analyze_recording_surface_pattern (surface, source);
 
     _cairo_analysis_surface_operation_extents (surface,
 					       op, source, clip,
@@ -641,8 +641,8 @@ _cairo_analysis_surface_show_text_glyphs (void			    *abstract_surface,
 	    backend_status = CAIRO_STATUS_SUCCESS;
     }
 
-    if (backend_status == CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN)
-	backend_status = _analyze_meta_surface_pattern (surface, source);
+    if (backend_status == CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN)
+	backend_status = _analyze_recording_surface_pattern (surface, source);
 
     _cairo_analysis_surface_operation_extents (surface,
 					       op, source, clip,
diff --git a/src/cairo-paginated-private.h b/src/cairo-paginated-private.h
index 0841a2b1..33358b98 100644
--- a/src/cairo-paginated-private.h
+++ b/src/cairo-paginated-private.h
@@ -98,7 +98,7 @@ struct _cairo_paginated_surface_backend {
  * to follow.
  *
  * What the paginated surface does is first save all drawing
- * operations for a page into a meta-surface. Then when the user calls
+ * operations for a page into a recording-surface. Then when the user calls
  * cairo_show_page(), the paginated surface performs the following
  * sequence of operations (using the backend functions passed to
  * cairo_paginated_surface_create()):
@@ -109,7 +109,7 @@ struct _cairo_paginated_surface_backend {
  *
  * 2. Calls set_paginated_mode() with an argument of %CAIRO_PAGINATED_MODE_ANALYZE
  *
- * 3. Replays the meta-surface to the target surface, (with an
+ * 3. Replays the recording-surface to the target surface, (with an
  *    analysis surface inserted between which watches the return value
  *    from each operation). This analysis stage is used to decide which
  *    operations will require fallbacks.
@@ -119,7 +119,7 @@ struct _cairo_paginated_surface_backend {
  *
  * 5. Calls set_paginated_mode() with an argument of %CAIRO_PAGINATED_MODE_RENDER
  *
- * 6. Replays a subset of the meta-surface operations to the target surface
+ * 6. Replays a subset of the recording-surface operations to the target surface
  *
  * 7. Calls set_paginated_mode() with an argument of %CAIRO_PAGINATED_MODE_FALLBACK
  *
diff --git a/src/cairo-paginated-surface-private.h b/src/cairo-paginated-surface-private.h
index 6c130727..a494e581 100644
--- a/src/cairo-paginated-surface-private.h
+++ b/src/cairo-paginated-surface-private.h
@@ -51,10 +51,10 @@ typedef struct _cairo_paginated_surface {
     /* Paginated-surface specific functions for the target */
     const cairo_paginated_surface_backend_t *backend;
 
-    /* A cairo_meta_surface to record all operations. To be replayed
+    /* A cairo_recording_surface to record all operations. To be replayed
      * against target, and also against image surface as necessary for
      * fallbacks. */
-    cairo_surface_t *meta;
+    cairo_surface_t *recording_surface;
 
     int page_num;
     cairo_bool_t page_is_blank;
diff --git a/src/cairo-paginated-surface.c b/src/cairo-paginated-surface.c
index 680bcf53..dff5e831 100644
--- a/src/cairo-paginated-surface.c
+++ b/src/cairo-paginated-surface.c
@@ -46,7 +46,7 @@
 
 #include "cairo-paginated-private.h"
 #include "cairo-paginated-surface-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-analysis-surface-private.h"
 
 static const cairo_surface_backend_t cairo_paginated_surface_backend;
@@ -64,26 +64,26 @@ _cairo_paginated_surface_create_similar (void			*abstract_surface,
     rect.x = rect.y = 0.;
     rect.width = width;
     rect.height = height;
-    return cairo_meta_surface_create (content, &rect);
+    return cairo_recording_surface_create (content, &rect);
 }
 
 static cairo_surface_t *
-_create_meta_surface_for_target (cairo_surface_t *target,
-				 cairo_content_t content)
+_create_recording_surface_for_target (cairo_surface_t *target,
+				      cairo_content_t content)
 {
     cairo_rectangle_int_t rect;
 
     if (_cairo_surface_get_extents (target, &rect)) {
-	cairo_rectangle_t meta_extents;
+	cairo_rectangle_t recording_extents;
 
-	meta_extents.x = rect.x;
-	meta_extents.y = rect.y;
-	meta_extents.width = rect.width;
-	meta_extents.height = rect.height;
+	recording_extents.x = rect.x;
+	recording_extents.y = rect.y;
+	recording_extents.width = rect.width;
+	recording_extents.height = rect.height;
 
-	return cairo_meta_surface_create (content, &meta_extents);
+	return cairo_recording_surface_create (content, &recording_extents);
     } else {
-	return cairo_meta_surface_create (content, NULL);
+	return cairo_recording_surface_create (content, NULL);
     }
 }
 
@@ -113,8 +113,8 @@ _cairo_paginated_surface_create (cairo_surface_t				*target,
     surface->content = content;
     surface->backend = backend;
 
-    surface->meta = _create_meta_surface_for_target (target, content);
-    status = surface->meta->status;
+    surface->recording_surface = _create_recording_surface_for_target (target, content);
+    status = surface->recording_surface->status;
     if (unlikely (status))
 	goto FAIL_CLEANUP_SURFACE;
 
@@ -171,10 +171,10 @@ _cairo_paginated_surface_finish (void *abstract_surface)
     }
     cairo_surface_destroy (surface->target);
 
-    cairo_surface_finish (surface->meta);
+    cairo_surface_finish (surface->recording_surface);
     if (status == CAIRO_STATUS_SUCCESS)
-	status = cairo_surface_status (surface->meta);
-    cairo_surface_destroy (surface->meta);
+	status = cairo_surface_status (surface->recording_surface);
+    cairo_surface_destroy (surface->recording_surface);
 
     return status;
 }
@@ -217,7 +217,7 @@ _cairo_paginated_surface_acquire_source_image (void	       *abstract_surface,
 							   extents.width,
 							   extents.height);
 
-    status = _cairo_meta_surface_replay (surface->meta, image);
+    status = _cairo_recording_surface_replay (surface->recording_surface, image);
     if (unlikely (status)) {
 	cairo_surface_destroy (image);
 	return status;
@@ -261,7 +261,7 @@ _paint_fallback_image (cairo_paginated_surface_t *surface,
      * so we have to do the scaling manually. */
     cairo_surface_set_device_offset (image, -x*x_scale, -y*y_scale);
 
-    status = _cairo_meta_surface_replay (surface->meta, image);
+    status = _cairo_recording_surface_replay (surface->recording_surface, image);
     if (unlikely (status))
 	goto CLEANUP_IMAGE;
 
@@ -305,8 +305,8 @@ _paint_page (cairo_paginated_surface_t *surface)
 
     surface->backend->set_paginated_mode (surface->target,
 	                                  CAIRO_PAGINATED_MODE_ANALYZE);
-    status = _cairo_meta_surface_replay_and_create_regions (surface->meta,
-	                                                    analysis);
+    status = _cairo_recording_surface_replay_and_create_regions (surface->recording_surface,
+								 analysis);
     if (status || analysis->status) {
 	if (status == CAIRO_STATUS_SUCCESS)
 	    status = analysis->status;
@@ -356,9 +356,9 @@ _paint_page (cairo_paginated_surface_t *surface)
 	surface->backend->set_paginated_mode (surface->target,
 		                              CAIRO_PAGINATED_MODE_RENDER);
 
-	status = _cairo_meta_surface_replay_region (surface->meta,
-						    surface->target,
-						    CAIRO_META_REGION_NATIVE);
+	status = _cairo_recording_surface_replay_region (surface->recording_surface,
+							 surface->target,
+							 CAIRO_RECORDING_REGION_NATIVE);
 	assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
 	if (unlikely (status))
 	    goto FAIL;
@@ -442,7 +442,7 @@ _cairo_paginated_surface_copy_page (void *abstract_surface)
      * optimization for the output, but the interaction with image
      * fallbacks gets tricky. For now, we just let the target see a
      * show_page and we implement the copying by simply not destroying
-     * the meta-surface. */
+     * the recording-surface. */
 
     cairo_surface_show_page (surface->target);
     return cairo_surface_status (surface->target);
@@ -467,15 +467,15 @@ _cairo_paginated_surface_show_page (void *abstract_surface)
     if (unlikely (status))
 	return status;
 
-    status = surface->meta->status;
+    status = surface->recording_surface->status;
     if (unlikely (status))
 	return status;
 
-    cairo_surface_destroy (surface->meta);
+    cairo_surface_destroy (surface->recording_surface);
 
-    surface->meta = _create_meta_surface_for_target (surface->target,
-						     surface->content);
-    status = surface->meta->status;
+    surface->recording_surface = _create_recording_surface_for_target (surface->target,
+								       surface->content);
+    status = surface->recording_surface->status;
     if (unlikely (status))
 	return status;
 
@@ -517,7 +517,7 @@ _cairo_paginated_surface_paint (void			*abstract_surface,
 
     surface->page_is_blank = FALSE;
 
-    return _cairo_surface_paint (surface->meta, op, source, clip);
+    return _cairo_surface_paint (surface->recording_surface, op, source, clip);
 }
 
 static cairo_int_status_t
@@ -535,7 +535,7 @@ _cairo_paginated_surface_mask (void		*abstract_surface,
 
     surface->page_is_blank = FALSE;
 
-    return _cairo_surface_mask (surface->meta, op, source, mask, clip);
+    return _cairo_surface_mask (surface->recording_surface, op, source, mask, clip);
 }
 
 static cairo_int_status_t
@@ -558,7 +558,7 @@ _cairo_paginated_surface_stroke (void			*abstract_surface,
 
     surface->page_is_blank = FALSE;
 
-    return _cairo_surface_stroke (surface->meta, op, source,
+    return _cairo_surface_stroke (surface->recording_surface, op, source,
 				  path, style,
 				  ctm, ctm_inverse,
 				  tolerance, antialias,
@@ -583,7 +583,7 @@ _cairo_paginated_surface_fill (void			*abstract_surface,
 
     surface->page_is_blank = FALSE;
 
-    return _cairo_surface_fill (surface->meta, op, source,
+    return _cairo_surface_fill (surface->recording_surface, op, source,
 				path, fill_rule,
 				tolerance, antialias,
 				clip);
@@ -598,18 +598,18 @@ _cairo_paginated_surface_has_show_text_glyphs (void *abstract_surface)
 }
 
 static cairo_int_status_t
-_cairo_paginated_surface_show_text_glyphs (void			    *abstract_surface,
-					   cairo_operator_t	     op,
-					   const cairo_pattern_t	    *source,
-					   const char		    *utf8,
-					   int			     utf8_len,
-					   cairo_glyph_t		    *glyphs,
-					   int			     num_glyphs,
+_cairo_paginated_surface_show_text_glyphs (void			      *abstract_surface,
+					   cairo_operator_t	       op,
+					   const cairo_pattern_t      *source,
+					   const char		      *utf8,
+					   int			       utf8_len,
+					   cairo_glyph_t	      *glyphs,
+					   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)
+					   int			       num_clusters,
+					   cairo_text_cluster_flags_t  cluster_flags,
+					   cairo_scaled_font_t	      *scaled_font,
+					   cairo_clip_t		      *clip)
 {
     cairo_paginated_surface_t *surface = abstract_surface;
 
@@ -619,7 +619,7 @@ _cairo_paginated_surface_show_text_glyphs (void			    *abstract_surface,
 
     surface->page_is_blank = FALSE;
 
-    return _cairo_surface_show_text_glyphs (surface->meta, op, source,
+    return _cairo_surface_show_text_glyphs (surface->recording_surface, op, source,
 					    utf8, utf8_len,
 					    glyphs, num_glyphs,
 					    clusters, num_clusters,
@@ -633,7 +633,7 @@ _cairo_paginated_surface_snapshot (void *abstract_other)
 {
     cairo_paginated_surface_t *other = abstract_other;
 
-    return _cairo_surface_snapshot (other->meta);
+    return _cairo_surface_snapshot (other->recording_surface);
 }
 
 static const cairo_surface_backend_t cairo_paginated_surface_backend = {
diff --git a/src/cairo-pattern.c b/src/cairo-pattern.c
index a566183c..cf6dab24 100644
--- a/src/cairo-pattern.c
+++ b/src/cairo-pattern.c
@@ -333,7 +333,7 @@ void
 _cairo_pattern_fini_snapshot (cairo_pattern_t *pattern)
 {
     /* XXX this is quite ugly, but currently necessary to break the circular
-     * references with snapshot-cow and the meta-surface.
+     * references with snapshot-cow and the recording-surface.
      * This operation remains safe only whilst _cairo_surface_snapshot() is
      * not public...
      */
diff --git a/src/cairo-pdf-surface.c b/src/cairo-pdf-surface.c
index 60ebfe5e..cdf38748 100644
--- a/src/cairo-pdf-surface.c
+++ b/src/cairo-pdf-surface.c
@@ -46,7 +46,7 @@
 #include "cairo-pdf-operators-private.h"
 #include "cairo-analysis-surface-private.h"
 #include "cairo-image-info-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-output-stream-private.h"
 #include "cairo-paginated-private.h"
 #include "cairo-scaled-font-subsets-private.h"
@@ -1046,11 +1046,11 @@ _get_source_surface_size (cairo_surface_t         *source,
     const unsigned char *mime_data;
     unsigned int mime_data_length;
 
-    if (_cairo_surface_is_meta (source)) {
-	cairo_meta_surface_t *meta_surface = (cairo_meta_surface_t *) source;
+    if (_cairo_surface_is_recording (source)) {
+	cairo_recording_surface_t *recording_surface = (cairo_recording_surface_t *) source;
 	cairo_box_t bbox;
 
-	status = _cairo_meta_surface_get_bbox (meta_surface, &bbox, NULL);
+	status = _cairo_recording_surface_get_bbox (recording_surface, &bbox, NULL);
 	if (unlikely (status))
 	    return status;
 
@@ -2198,18 +2198,18 @@ BAIL:
 
 
 static cairo_status_t
-_cairo_pdf_surface_emit_meta_surface (cairo_pdf_surface_t  *surface,
-				      cairo_surface_t      *meta_surface,
-				      cairo_pdf_resource_t  resource)
+_cairo_pdf_surface_emit_recording_surface (cairo_pdf_surface_t  *surface,
+					   cairo_surface_t      *recording_surface,
+					   cairo_pdf_resource_t  resource)
 {
     double old_width, old_height;
     cairo_paginated_mode_t old_paginated_mode;
-    cairo_rectangle_int_t meta_extents;
+    cairo_rectangle_int_t recording_extents;
     cairo_bool_t is_bounded;
     cairo_status_t status;
     int alpha = 0;
 
-    is_bounded = _cairo_surface_get_extents (meta_surface, &meta_extents);
+    is_bounded = _cairo_surface_get_extents (recording_surface, &recording_extents);
     assert (is_bounded);
 
     old_width = surface->width;
@@ -2217,10 +2217,10 @@ _cairo_pdf_surface_emit_meta_surface (cairo_pdf_surface_t  *surface,
     old_paginated_mode = surface->paginated_mode;
 
     _cairo_pdf_surface_set_size_internal (surface,
-					  meta_extents.width,
-					  meta_extents.height);
+					  recording_extents.width,
+					  recording_extents.height);
     /* Patterns are emitted after fallback images. The paginated mode
-     * needs to be set to _RENDER while the meta surface is replayed
+     * needs to be set to _RENDER while the recording surface is replayed
      * back to this surface.
      */
     surface->paginated_mode = CAIRO_PAGINATED_MODE_RENDER;
@@ -2229,7 +2229,7 @@ _cairo_pdf_surface_emit_meta_surface (cairo_pdf_surface_t  *surface,
     if (unlikely (status))
 	return status;
 
-    if (cairo_surface_get_content (meta_surface) == CAIRO_CONTENT_COLOR) {
+    if (cairo_surface_get_content (recording_surface) == CAIRO_CONTENT_COLOR) {
 	status = _cairo_pdf_surface_add_alpha (surface, 1.0, &alpha);
 	if (unlikely (status))
 	    return status;
@@ -2241,8 +2241,8 @@ _cairo_pdf_surface_emit_meta_surface (cairo_pdf_surface_t  *surface,
 				     surface->height);
     }
 
-    status = _cairo_meta_surface_replay_region (meta_surface, &surface->base,
-						CAIRO_META_REGION_NATIVE);
+    status = _cairo_recording_surface_replay_region (recording_surface, &surface->base,
+						     CAIRO_RECORDING_REGION_NATIVE);
     assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
     if (unlikely (status))
 	return status;
@@ -2261,8 +2261,8 @@ static cairo_status_t
 _cairo_pdf_surface_emit_surface (cairo_pdf_surface_t        *surface,
 				 cairo_pdf_source_surface_t *src_surface)
 {
-    if (_cairo_surface_is_meta (src_surface->surface)) {
-	return _cairo_pdf_surface_emit_meta_surface (surface,
+    if (_cairo_surface_is_recording (src_surface->surface)) {
+	return _cairo_pdf_surface_emit_recording_surface (surface,
 						     src_surface->surface,
 						     src_surface->hash_entry->surface_res);
     } else {
@@ -2291,7 +2291,7 @@ _cairo_pdf_surface_emit_surface_pattern (cairo_pdf_surface_t	*surface,
     char draw_surface[200];
 
     if (pattern->base.extend == CAIRO_EXTEND_PAD &&
-	 ! _cairo_surface_is_meta (pattern->surface))
+	 ! _cairo_surface_is_recording (pattern->surface))
     {
 	status = _cairo_pdf_surface_emit_padded_image_surface (surface,
 							       pdf_pattern,
@@ -2422,7 +2422,7 @@ _cairo_pdf_surface_emit_surface_pattern (cairo_pdf_surface_t	*surface,
     if (unlikely (status))
 	return status;
 
-    if (_cairo_surface_is_meta (pattern->surface)) {
+    if (_cairo_surface_is_recording (pattern->surface)) {
 	snprintf(draw_surface,
 		 sizeof (draw_surface),
 		 "/x%d Do\n",
@@ -3293,7 +3293,7 @@ _cairo_pdf_surface_paint_surface_pattern (cairo_pdf_surface_t     *surface,
     cairo_matrix_multiply (&pdf_p2d, &cairo_p2d, &pdf_p2d);
     cairo_matrix_translate (&pdf_p2d, 0.0, height);
     cairo_matrix_scale (&pdf_p2d, 1.0, -1.0);
-    if (! _cairo_surface_is_meta (source->surface))
+    if (! _cairo_surface_is_recording (source->surface))
 	cairo_matrix_scale (&pdf_p2d, width, height);
 
     status = _cairo_pdf_operators_flush (&surface->pdf_operators);
@@ -4935,7 +4935,7 @@ _cairo_pdf_surface_write_patterns_and_smask_groups (cairo_pdf_surface_t *surface
      * to be appended to surface->smask_groups. Additional patterns
      * may also be appended to surface->patterns.
      *
-     * Writing meta surface patterns will cause additional patterns
+     * Writing recording surface patterns will cause additional patterns
      * and groups to be appended.
      */
     pattern_index = 0;
@@ -5091,7 +5091,7 @@ _surface_pattern_supported (cairo_surface_pattern_t *pattern)
 {
     cairo_extend_t extend;
 
-    if (_cairo_surface_is_meta (pattern->surface))
+    if (_cairo_surface_is_recording (pattern->surface))
 	return TRUE;
 
     if (pattern->surface->backend->acquire_source_image == NULL)
@@ -5230,11 +5230,11 @@ _cairo_pdf_surface_analyze_operation (cairo_pdf_surface_t  *surface,
 	if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	    cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
 
-	    if ( _cairo_surface_is_meta (surface_pattern->surface)) {
+	    if ( _cairo_surface_is_recording (surface_pattern->surface)) {
 		if (pattern->extend == CAIRO_EXTEND_PAD)
 		    return CAIRO_INT_STATUS_UNSUPPORTED;
 		else
-		    return CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN;
+		    return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
 	    }
 	}
 
@@ -5248,14 +5248,14 @@ _cairo_pdf_surface_analyze_operation (cairo_pdf_surface_t  *surface,
 	if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	    cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
 
-	    if (_cairo_surface_is_meta (surface_pattern->surface)) {
+	    if (_cairo_surface_is_recording (surface_pattern->surface)) {
 		if (_cairo_pattern_is_opaque (pattern)) {
-		    return CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN;
+		    return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
 		} else {
 		    /* FIXME: The analysis surface does not yet have
-		     * the capability to analyze a non opaque meta
+		     * the capability to analyze a non opaque recording
 		     * surface and mark it supported if there is
-		     * nothing underneath. For now meta surfaces of
+		     * nothing underneath. For now recording surfaces of
 		     * type CONTENT_COLOR_ALPHA painted with
 		     * OPERATOR_SOURCE will result in a fallback
 		     * image. */
diff --git a/src/cairo-ps-surface.c b/src/cairo-ps-surface.c
index 0ef787cd..6785c126 100644
--- a/src/cairo-ps-surface.c
+++ b/src/cairo-ps-surface.c
@@ -60,7 +60,7 @@
 #include "cairo-pdf-operators-private.h"
 #include "cairo-scaled-font-subsets-private.h"
 #include "cairo-paginated-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-surface-clipper-private.h"
 #include "cairo-output-stream-private.h"
 #include "cairo-type3-glyph-surface-private.h"
@@ -1648,7 +1648,7 @@ _cairo_ps_surface_analyze_surface_pattern_transparency (cairo_ps_surface_t
 static cairo_bool_t
 surface_pattern_supported (const cairo_surface_pattern_t *pattern)
 {
-    if (_cairo_surface_is_meta (pattern->surface))
+    if (_cairo_surface_is_recording (pattern->surface))
 	return TRUE;
 
     if (pattern->surface->backend->acquire_source_image == NULL)
@@ -1758,11 +1758,11 @@ _cairo_ps_surface_analyze_operation (cairo_ps_surface_t    *surface,
     if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
 
-	if ( _cairo_surface_is_meta (surface_pattern->surface)) {
+	if ( _cairo_surface_is_recording (surface_pattern->surface)) {
 	    if (pattern->extend == CAIRO_EXTEND_PAD)
 		return CAIRO_INT_STATUS_UNSUPPORTED;
 	    else
-		return CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN;
+		return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
 	}
     }
 
@@ -1963,7 +1963,7 @@ _base85_array_stream_create (cairo_output_stream_t *output)
 }
 
 
-/* PS Output - this section handles output of the parts of the meta
+/* PS Output - this section handles output of the parts of the recording
  * surface we can render natively in PS. */
 
 static cairo_status_t
@@ -2402,8 +2402,8 @@ _cairo_ps_surface_emit_jpeg_image (cairo_ps_surface_t    *surface,
 }
 
 static cairo_status_t
-_cairo_ps_surface_emit_meta_surface (cairo_ps_surface_t  *surface,
-				     cairo_surface_t      *meta_surface)
+_cairo_ps_surface_emit_recording_surface (cairo_ps_surface_t *surface,
+					  cairo_surface_t    *recording_surface)
 {
     double old_width, old_height;
     cairo_matrix_t old_cairo_to_ps;
@@ -2419,15 +2419,15 @@ _cairo_ps_surface_emit_meta_surface (cairo_ps_surface_t  *surface,
     old_cairo_to_ps = surface->cairo_to_ps;
 
     status =
-	_cairo_meta_surface_get_bbox ((cairo_meta_surface_t *) meta_surface,
-				      &bbox,
-				      NULL);
+	_cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
+					   &bbox,
+					   NULL);
     if (unlikely (status))
 	return status;
 
 #if DEBUG_PS
     _cairo_output_stream_printf (surface->stream,
-				 "%% _cairo_ps_surface_emit_meta_surface (%f, %f), (%f, %f)\n",
+				 "%% _cairo_ps_surface_emit_recording_surface (%f, %f), (%f, %f)\n",
 				 _cairo_fixed_to_double (bbox.p1.x),
 				 _cairo_fixed_to_double (bbox.p1.y),
 				 _cairo_fixed_to_double (bbox.p2.x),
@@ -2445,7 +2445,7 @@ _cairo_ps_surface_emit_meta_surface (cairo_ps_surface_t  *surface,
 						  &surface->cairo_to_ps);
     _cairo_output_stream_printf (surface->stream, "  q\n");
 
-    if (cairo_surface_get_content (meta_surface) == CAIRO_CONTENT_COLOR) {
+    if (cairo_surface_get_content (recording_surface) == CAIRO_CONTENT_COLOR) {
 	surface->content = CAIRO_CONTENT_COLOR;
 	_cairo_output_stream_printf (surface->stream,
 				     "  0 g %d %d %d %d rectfill\n",
@@ -2455,8 +2455,8 @@ _cairo_ps_surface_emit_meta_surface (cairo_ps_surface_t  *surface,
 				     surface->page_bbox.height);
     }
 
-    status = _cairo_meta_surface_replay_region (meta_surface, &surface->base,
-						CAIRO_META_REGION_NATIVE);
+    status = _cairo_recording_surface_replay_region (recording_surface, &surface->base,
+						     CAIRO_RECORDING_REGION_NATIVE);
     assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
     if (unlikely (status))
 	return status;
@@ -2539,12 +2539,12 @@ _cairo_ps_surface_acquire_surface (cairo_ps_surface_t      *surface,
     surface->acquired_image = NULL;
     surface->image = NULL;
 
-    if (_cairo_surface_is_meta (pattern->surface)) {
-	cairo_meta_surface_t *meta_surface = (cairo_meta_surface_t *) pattern->surface;
+    if (_cairo_surface_is_recording (pattern->surface)) {
+	cairo_recording_surface_t *recording_surface = (cairo_recording_surface_t *) pattern->surface;
 	cairo_box_t bbox;
 	cairo_rectangle_int_t extents;
 
-	status = _cairo_meta_surface_get_bbox (meta_surface, &bbox, NULL);
+	status = _cairo_recording_surface_get_bbox (recording_surface, &bbox, NULL);
 	if (unlikely (status))
 	    return status;
 
@@ -2624,10 +2624,10 @@ _cairo_ps_surface_emit_surface (cairo_ps_surface_t      *surface,
 {
     cairo_status_t status;
 
-    if (_cairo_surface_is_meta (pattern->surface)) {
-	cairo_surface_t *meta_surface = pattern->surface;
+    if (_cairo_surface_is_recording (pattern->surface)) {
+	cairo_surface_t *recording_surface = pattern->surface;
 
-	status = _cairo_ps_surface_emit_meta_surface (surface, meta_surface);
+	status = _cairo_ps_surface_emit_recording_surface (surface, recording_surface);
     } else {
 	if (pattern->base.extend != CAIRO_EXTEND_PAD) {
 	    status = _cairo_ps_surface_emit_jpeg_image (surface, pattern->surface,
@@ -2650,7 +2650,7 @@ _cairo_ps_surface_release_surface (cairo_ps_surface_t      *surface,
     if (surface->image != surface->acquired_image)
 	cairo_surface_destroy (&surface->image->base);
 
-    if (! _cairo_surface_is_meta (pattern->surface)) {
+    if (! _cairo_surface_is_recording (pattern->surface)) {
 	_cairo_surface_release_source_image (pattern->surface,
 					     surface->acquired_image,
 					     surface->image_extra);
diff --git a/src/cairo-meta-surface-private.h b/src/cairo-recording-surface-private.h
index 6790eab7..f0824f50 100644
--- a/src/cairo-meta-surface-private.h
+++ b/src/cairo-recording-surface-private.h
@@ -34,8 +34,8 @@
  *	Adrian Johnson <ajohnson@redneon.com>
  */
 
-#ifndef CAIRO_META_SURFACE_H
-#define CAIRO_META_SURFACE_H
+#ifndef CAIRO_RECORDING_SURFACE_H
+#define CAIRO_RECORDING_SURFACE_H
 
 #include "cairoint.h"
 #include "cairo-path-fixed-private.h"
@@ -51,14 +51,14 @@ typedef enum {
 } cairo_command_type_t;
 
 typedef enum {
-    CAIRO_META_REGION_ALL,
-    CAIRO_META_REGION_NATIVE,
-    CAIRO_META_REGION_IMAGE_FALLBACK
-} cairo_meta_region_type_t;
+    CAIRO_RECORDING_REGION_ALL,
+    CAIRO_RECORDING_REGION_NATIVE,
+    CAIRO_RECORDING_REGION_IMAGE_FALLBACK
+} cairo_recording_region_type_t;
 
 typedef struct _cairo_command_header {
     cairo_command_type_t	 type;
-    cairo_meta_region_type_t     region;
+    cairo_recording_region_type_t     region;
     cairo_operator_t		 op;
     cairo_clip_t		 clip;
 } cairo_command_header_t;
@@ -117,12 +117,12 @@ typedef union _cairo_command {
     cairo_command_show_text_glyphs_t		show_text_glyphs;
 } cairo_command_t;
 
-typedef struct _cairo_meta_surface {
+typedef struct _cairo_recording_surface {
     cairo_surface_t base;
 
     cairo_content_t content;
 
-    /* A meta-surface is logically unbounded, but when used as a
+    /* A recording-surface is logically unbounded, but when used as a
      * source we need to render it to an image, so we need a size at
      * which to create that image. */
     cairo_rectangle_t extents_pixels;
@@ -135,37 +135,37 @@ typedef struct _cairo_meta_surface {
     cairo_surface_t *commands_owner;
 
     int replay_start_idx;
-} cairo_meta_surface_t;
+} cairo_recording_surface_t;
 
-slim_hidden_proto (cairo_meta_surface_create);
+slim_hidden_proto (cairo_recording_surface_create);
 
 cairo_private cairo_int_status_t
-_cairo_meta_surface_get_path (cairo_surface_t	 *surface,
-			      cairo_path_fixed_t *path);
+_cairo_recording_surface_get_path (cairo_surface_t	 *surface,
+				   cairo_path_fixed_t *path);
 
 cairo_private cairo_status_t
-_cairo_meta_surface_replay (cairo_surface_t *surface,
-			    cairo_surface_t *target);
+_cairo_recording_surface_replay (cairo_surface_t *surface,
+				 cairo_surface_t *target);
 
 
 cairo_private cairo_status_t
-_cairo_meta_surface_replay_analyze_meta_pattern (cairo_surface_t *surface,
-						 cairo_surface_t *target);
+_cairo_recording_surface_replay_analyze_recording_pattern (cairo_surface_t *surface,
+							   cairo_surface_t *target);
 
 cairo_private cairo_status_t
-_cairo_meta_surface_replay_and_create_regions (cairo_surface_t *surface,
-					       cairo_surface_t *target);
+_cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface,
+						    cairo_surface_t *target);
 cairo_private cairo_status_t
-_cairo_meta_surface_replay_region (cairo_surface_t          *surface,
-				   cairo_surface_t          *target,
-				   cairo_meta_region_type_t  region);
+_cairo_recording_surface_replay_region (cairo_surface_t			*surface,
+					cairo_surface_t			*target,
+					cairo_recording_region_type_t	region);
 
 cairo_private cairo_status_t
-_cairo_meta_surface_get_bbox (cairo_meta_surface_t *meta,
-			      cairo_box_t *bbox,
-			      const cairo_matrix_t *transform);
+_cairo_recording_surface_get_bbox (cairo_recording_surface_t *recording,
+				   cairo_box_t *bbox,
+				   const cairo_matrix_t *transform);
 
 cairo_private cairo_bool_t
-_cairo_surface_is_meta (const cairo_surface_t *surface);
+_cairo_surface_is_recording (const cairo_surface_t *surface);
 
-#endif /* CAIRO_META_SURFACE_H */
+#endif /* CAIRO_RECORDING_SURFACE_H */
diff --git a/src/cairo-meta-surface.c b/src/cairo-recording-surface.c
index 8abb9aba..c50b330e 100644
--- a/src/cairo-meta-surface.c
+++ b/src/cairo-recording-surface.c
@@ -37,34 +37,34 @@
  *	Adrian Johnson <ajohnson@redneon.com>
  */
 
-/* A meta surface is a surface that records all drawing operations at
+/* A recording surface is a surface that records all drawing operations at
  * the highest level of the surface backend interface, (that is, the
- * level of paint, mask, stroke, fill, and show_text_glyphs). The meta
+ * level of paint, mask, stroke, fill, and show_text_glyphs). The recording
  * surface can then be "replayed" against any target surface by using it
  * as a source surface.
  *
  * If you want to replay a surface so that the results in target will be
  * identical to the results that would have been obtained if the original
- * operations applied to the meta surface had instead been applied to the
+ * operations applied to the recording surface had instead been applied to the
  * target surface, you can use code like this:
  * <informalexample><programlisting>
  *      cairo_t *cr;
  *
  *	cr = cairo_create (target);
- *	cairo_set_source_surface (cr, meta, 0.0, 0.0);
+ *	cairo_set_source_surface (cr, recording_surface, 0.0, 0.0);
  *	cairo_paint (cr);
  *	cairo_destroy (cr);
  * </programlisting></informalexample>
  *
- * A meta surface is logically unbounded, i.e. it has no implicit constraint
+ * A recording surface is logically unbounded, i.e. it has no implicit constraint
  * on the size of the drawing surface. However, in practice this is rarely
  * useful as you wish to replay against a particular target surface with
  * known bounds. For this case, it is more efficient to specify the target
- * extents to the meta surface upon creation.
+ * extents to the recording surface upon creation.
  *
- * The recording phase of the meta surface is careful to snapshot all
+ * The recording phase of the recording surface is careful to snapshot all
  * necessary objects (paths, patterns, etc.), in order to achieve
- * accurate replay. The efficiency of the meta surface could be
+ * accurate replay. The efficiency of the recording surface could be
  * improved by improving the implementation of snapshot for the
  * various objects. For example, it would be nice to have a
  * copy-on-write implementation for _cairo_surface_snapshot.
@@ -74,20 +74,20 @@
 
 #include "cairoint.h"
 #include "cairo-analysis-surface-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-clip-private.h"
 #include "cairo-surface-wrapper-private.h"
 
 typedef enum {
-    CAIRO_META_REPLAY,
-    CAIRO_META_CREATE_REGIONS
-} cairo_meta_replay_type_t;
+    CAIRO_RECORDING_REPLAY,
+    CAIRO_RECORDING_CREATE_REGIONS
+} cairo_recording_replay_type_t;
 
-static const cairo_surface_backend_t cairo_meta_surface_backend;
+static const cairo_surface_backend_t cairo_recording_surface_backend;
 
-/* Currently all meta surfaces do have a size which should be passed
+/* Currently all recording surfaces do have a size which should be passed
  * in as the maximum size of any target surface against which the
- * meta-surface will ever be replayed.
+ * recording-surface will ever be replayed.
  *
  * XXX: The naming of "pixels" in the size here is a misnomer. It's
  * actually a size in whatever device-space units are desired (again,
@@ -95,95 +95,95 @@ static const cairo_surface_backend_t cairo_meta_surface_backend;
  */
 
 /**
- * cairo_meta_surface_create:
- * @content: the content of the meta surface
+ * cairo_recording_surface_create:
+ * @content: the content of the recording surface
  * @extents_pixels: the extents to record in pixels, can be %NULL to record
  *                  unbounded operations.
  *
- * Creates a meta-surface which can be used to record all drawing operations
+ * Creates a recording-surface which can be used to record all drawing operations
  * at the highest level (that is, the level of paint, mask, stroke, fill
- * and show_text_glyphs). The meta surface can then be "replayed" against
+ * and show_text_glyphs). The recording surface can then be "replayed" against
  * any target surface by using it as a source to drawing operations.
  *
- * The recording phase of the meta surface is careful to snapshot all
+ * The recording phase of the recording surface is careful to snapshot all
  * necessary objects (paths, patterns, etc.), in order to achieve
  * accurate replay.
  *
  * Since 1.10
  **/
 cairo_surface_t *
-cairo_meta_surface_create (cairo_content_t		 content,
-			   const cairo_rectangle_t	*extents)
+cairo_recording_surface_create (cairo_content_t		 content,
+				const cairo_rectangle_t	*extents)
 {
-    cairo_meta_surface_t *meta;
+    cairo_recording_surface_t *recording_surface;
     cairo_status_t status;
 
-    meta = malloc (sizeof (cairo_meta_surface_t));
-    if (unlikely (meta == NULL))
+    recording_surface = malloc (sizeof (cairo_recording_surface_t));
+    if (unlikely (recording_surface == NULL))
 	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
 
-    _cairo_surface_init (&meta->base, &cairo_meta_surface_backend, content);
+    _cairo_surface_init (&recording_surface->base, &cairo_recording_surface_backend, content);
 
-    meta->content = content;
+    recording_surface->content = content;
 
     /* unbounded -> 'infinite' extents */
     if (extents != NULL) {
-	meta->extents_pixels = *extents;
+	recording_surface->extents_pixels = *extents;
 
 	/* XXX check for overflow */
-	meta->extents.x = floor (extents->x);
-	meta->extents.y = floor (extents->y);
-	meta->extents.width = ceil (extents->x + extents->width) - meta->extents.x;
-	meta->extents.height = ceil (extents->y + extents->height) - meta->extents.y;
+	recording_surface->extents.x = floor (extents->x);
+	recording_surface->extents.y = floor (extents->y);
+	recording_surface->extents.width = ceil (extents->x + extents->width) - recording_surface->extents.x;
+	recording_surface->extents.height = ceil (extents->y + extents->height) - recording_surface->extents.y;
 
-	status = _cairo_clip_init_rectangle (&meta->clip, &meta->extents);
+	status = _cairo_clip_init_rectangle (&recording_surface->clip, &recording_surface->extents);
 	if (unlikely (status)) {
-	    free (meta);
+	    free (recording_surface);
 	    return _cairo_surface_create_in_error (status);
 	}
 
-	meta->unbounded = FALSE;
+	recording_surface->unbounded = FALSE;
     } else {
-	meta->unbounded = TRUE;
-	_cairo_clip_init (&meta->clip);
+	recording_surface->unbounded = TRUE;
+	_cairo_clip_init (&recording_surface->clip);
     }
 
-    _cairo_array_init (&meta->commands, sizeof (cairo_command_t *));
-    meta->commands_owner = NULL;
+    _cairo_array_init (&recording_surface->commands, sizeof (cairo_command_t *));
+    recording_surface->commands_owner = NULL;
 
-    meta->replay_start_idx = 0;
+    recording_surface->replay_start_idx = 0;
 
-    return &meta->base;
+    return &recording_surface->base;
 }
-slim_hidden_def (cairo_meta_surface_create);
+slim_hidden_def (cairo_recording_surface_create);
 
 static cairo_surface_t *
-_cairo_meta_surface_create_similar (void	       *abstract_surface,
-				    cairo_content_t	content,
-				    int			width,
-				    int			height)
+_cairo_recording_surface_create_similar (void		       *abstract_surface,
+					 cairo_content_t	content,
+					 int			width,
+					 int			height)
 {
     cairo_rectangle_t extents;
     extents.x = extents.y = 0;
     extents.width = width;
     extents.height = height;
-    return cairo_meta_surface_create (content, &extents);
+    return cairo_recording_surface_create (content, &extents);
 }
 
 static cairo_status_t
-_cairo_meta_surface_finish (void *abstract_surface)
+_cairo_recording_surface_finish (void *abstract_surface)
 {
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_t **elements;
     int i, num_elements;
 
-    if (meta->commands_owner) {
-	cairo_surface_destroy (meta->commands_owner);
+    if (recording_surface->commands_owner) {
+	cairo_surface_destroy (recording_surface->commands_owner);
 	return CAIRO_STATUS_SUCCESS;
     }
 
-    num_elements = meta->commands.num_elements;
-    elements = _cairo_array_index (&meta->commands, 0);
+    num_elements = recording_surface->commands.num_elements;
+    elements = _cairo_array_index (&recording_surface->commands, 0);
     for (i = 0; i < num_elements; i++) {
 	cairo_command_t *command = elements[i];
 
@@ -228,19 +228,19 @@ _cairo_meta_surface_finish (void *abstract_surface)
 	}
     }
 
-    _cairo_array_fini (&meta->commands);
-    _cairo_clip_reset (&meta->clip);
+    _cairo_array_fini (&recording_surface->commands);
+    _cairo_clip_reset (&recording_surface->clip);
 
     return CAIRO_STATUS_SUCCESS;
 }
 
 static cairo_status_t
-_cairo_meta_surface_acquire_source_image (void			 *abstract_surface,
-					  cairo_image_surface_t	**image_out,
-					  void			**image_extra)
+_cairo_recording_surface_acquire_source_image (void			 *abstract_surface,
+					       cairo_image_surface_t	**image_out,
+					       void			**image_extra)
 {
     cairo_status_t status;
-    cairo_meta_surface_t *surface = abstract_surface;
+    cairo_recording_surface_t *surface = abstract_surface;
     cairo_surface_t *image;
 
     image = _cairo_surface_has_snapshot (&surface->base,
@@ -262,7 +262,7 @@ _cairo_meta_surface_acquire_source_image (void			 *abstract_surface,
 				     -surface->extents.x,
 				     -surface->extents.y);
 
-    status = _cairo_meta_surface_replay (&surface->base, image);
+    status = _cairo_recording_surface_replay (&surface->base, image);
     if (unlikely (status)) {
 	cairo_surface_destroy (image);
 	return status;
@@ -280,15 +280,15 @@ _cairo_meta_surface_acquire_source_image (void			 *abstract_surface,
 }
 
 static void
-_cairo_meta_surface_release_source_image (void			*abstract_surface,
-					  cairo_image_surface_t	*image,
-					  void			*image_extra)
+_cairo_recording_surface_release_source_image (void			*abstract_surface,
+					       cairo_image_surface_t	*image,
+					       void			*image_extra)
 {
     cairo_surface_destroy (&image->base);
 }
 
 static cairo_status_t
-_command_init (cairo_meta_surface_t *meta,
+_command_init (cairo_recording_surface_t *recording_surface,
 	       cairo_command_header_t *command,
 	       cairo_command_type_t type,
 	       cairo_operator_t op,
@@ -298,29 +298,29 @@ _command_init (cairo_meta_surface_t *meta,
 
     command->type = type;
     command->op = op;
-    command->region = CAIRO_META_REGION_ALL;
+    command->region = CAIRO_RECORDING_REGION_ALL;
     _cairo_clip_init_copy (&command->clip, clip);
-    if (meta->clip.path != NULL)
-	status = _cairo_clip_apply_clip (&command->clip, &meta->clip);
+    if (recording_surface->clip.path != NULL)
+	status = _cairo_clip_apply_clip (&command->clip, &recording_surface->clip);
 
     return status;
 }
 
 static cairo_int_status_t
-_cairo_meta_surface_paint (void			  *abstract_surface,
-			   cairo_operator_t	   op,
-			   const cairo_pattern_t  *source,
-			   cairo_clip_t		  *clip)
+_cairo_recording_surface_paint (void			  *abstract_surface,
+				cairo_operator_t	   op,
+				const cairo_pattern_t	  *source,
+				cairo_clip_t		  *clip)
 {
     cairo_status_t status;
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_paint_t *command;
 
     command = malloc (sizeof (cairo_command_paint_t));
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-    status = _command_init (meta,
+    status = _command_init (recording_surface,
 			    &command->header, CAIRO_COMMAND_PAINT, op, clip);
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
@@ -329,7 +329,7 @@ _cairo_meta_surface_paint (void			  *abstract_surface,
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
 
-    status = _cairo_array_append (&meta->commands, &command);
+    status = _cairo_array_append (&recording_surface->commands, &command);
     if (unlikely (status))
 	goto CLEANUP_SOURCE;
 
@@ -337,7 +337,7 @@ _cairo_meta_surface_paint (void			  *abstract_surface,
      * before surface is cleared. We don't erase recorded commands
      * since we may have earlier snapshots of this surface. */
     if (op == CAIRO_OPERATOR_CLEAR && clip == NULL)
-	meta->replay_start_idx = meta->commands.num_elements;
+	recording_surface->replay_start_idx = recording_surface->commands.num_elements;
 
     return CAIRO_STATUS_SUCCESS;
 
@@ -349,21 +349,21 @@ _cairo_meta_surface_paint (void			  *abstract_surface,
 }
 
 static cairo_int_status_t
-_cairo_meta_surface_mask (void			*abstract_surface,
-			  cairo_operator_t	 op,
-			  const cairo_pattern_t	*source,
-			  const cairo_pattern_t	*mask,
-			  cairo_clip_t		*clip)
+_cairo_recording_surface_mask (void			*abstract_surface,
+			       cairo_operator_t		 op,
+			       const cairo_pattern_t	*source,
+			       const cairo_pattern_t	*mask,
+			       cairo_clip_t		*clip)
 {
     cairo_status_t status;
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_mask_t *command;
 
     command = malloc (sizeof (cairo_command_mask_t));
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-    status = _command_init (meta,
+    status = _command_init (recording_surface,
 			    &command->header, CAIRO_COMMAND_MASK, op, clip);
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
@@ -376,7 +376,7 @@ _cairo_meta_surface_mask (void			*abstract_surface,
     if (unlikely (status))
 	goto CLEANUP_SOURCE;
 
-    status = _cairo_array_append (&meta->commands, &command);
+    status = _cairo_array_append (&recording_surface->commands, &command);
     if (unlikely (status))
 	goto CLEANUP_MASK;
 
@@ -392,26 +392,26 @@ _cairo_meta_surface_mask (void			*abstract_surface,
 }
 
 static cairo_int_status_t
-_cairo_meta_surface_stroke (void			*abstract_surface,
-			    cairo_operator_t		 op,
-			    const 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,
-			    cairo_clip_t		*clip)
+_cairo_recording_surface_stroke (void			*abstract_surface,
+				 cairo_operator_t	 op,
+				 const 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,
+				 cairo_clip_t		*clip)
 {
     cairo_status_t status;
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_stroke_t *command;
 
     command = malloc (sizeof (cairo_command_stroke_t));
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-    status = _command_init (meta,
+    status = _command_init (recording_surface,
 			    &command->header, CAIRO_COMMAND_STROKE, op, clip);
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
@@ -433,7 +433,7 @@ _cairo_meta_surface_stroke (void			*abstract_surface,
     command->tolerance = tolerance;
     command->antialias = antialias;
 
-    status = _cairo_array_append (&meta->commands, &command);
+    status = _cairo_array_append (&recording_surface->commands, &command);
     if (unlikely (status))
 	goto CLEANUP_STYLE;
 
@@ -451,24 +451,24 @@ _cairo_meta_surface_stroke (void			*abstract_surface,
 }
 
 static cairo_int_status_t
-_cairo_meta_surface_fill (void			*abstract_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_recording_surface_fill (void			*abstract_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_status_t status;
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_fill_t *command;
 
     command = malloc (sizeof (cairo_command_fill_t));
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-    status =_command_init (meta,
+    status =_command_init (recording_surface,
 			   &command->header, CAIRO_COMMAND_FILL, op, clip);
     if (unlikely (status))
 	goto CLEANUP_COMMAND;
@@ -485,7 +485,7 @@ _cairo_meta_surface_fill (void			*abstract_surface,
     command->tolerance = tolerance;
     command->antialias = antialias;
 
-    status = _cairo_array_append (&meta->commands, &command);
+    status = _cairo_array_append (&recording_surface->commands, &command);
     if (unlikely (status))
 	goto CLEANUP_PATH;
 
@@ -501,34 +501,34 @@ _cairo_meta_surface_fill (void			*abstract_surface,
 }
 
 static cairo_bool_t
-_cairo_meta_surface_has_show_text_glyphs (void *abstract_surface)
+_cairo_recording_surface_has_show_text_glyphs (void *abstract_surface)
 {
     return TRUE;
 }
 
 static cairo_int_status_t
-_cairo_meta_surface_show_text_glyphs (void			    *abstract_surface,
-				      cairo_operator_t		     op,
-				      const cairo_pattern_t	    *source,
-				      const char		    *utf8,
-				      int			     utf8_len,
-				      cairo_glyph_t		    *glyphs,
-				      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)
+_cairo_recording_surface_show_text_glyphs (void				*abstract_surface,
+					   cairo_operator_t		 op,
+					   const cairo_pattern_t	*source,
+					   const char			*utf8,
+					   int				 utf8_len,
+					   cairo_glyph_t		*glyphs,
+					   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)
 {
     cairo_status_t status;
-    cairo_meta_surface_t *meta = abstract_surface;
+    cairo_recording_surface_t *recording_surface = abstract_surface;
     cairo_command_show_text_glyphs_t *command;
 
     command = malloc (sizeof (cairo_command_show_text_glyphs_t));
     if (unlikely (command == NULL))
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-    status = _command_init (meta,
+    status = _command_init (recording_surface,
 			    &command->header, CAIRO_COMMAND_SHOW_TEXT_GLYPHS,
 			    op, clip);
     if (unlikely (status))
@@ -574,7 +574,7 @@ _cairo_meta_surface_show_text_glyphs (void			    *abstract_surface,
 
     command->scaled_font = cairo_scaled_font_reference (scaled_font);
 
-    status = _cairo_array_append (&meta->commands, &command);
+    status = _cairo_array_append (&recording_surface->commands, &command);
     if (unlikely (status))
 	goto CLEANUP_SCALED_FONT;
 
@@ -594,8 +594,8 @@ _cairo_meta_surface_show_text_glyphs (void			    *abstract_surface,
 }
 
 /**
- * _cairo_meta_surface_snapshot
- * @surface: a #cairo_surface_t which must be a meta surface
+ * _cairo_recording_surface_snapshot
+ * @surface: a #cairo_surface_t which must be a recording surface
  *
  * Make an immutable copy of @surface. It is an error to call a
  * surface-modifying function on the result of this function.
@@ -607,37 +607,37 @@ _cairo_meta_surface_show_text_glyphs (void			    *abstract_surface,
  * Return value: The snapshot surface.
  **/
 static cairo_surface_t *
-_cairo_meta_surface_snapshot (void *abstract_other)
+_cairo_recording_surface_snapshot (void *abstract_other)
 {
-    cairo_meta_surface_t *other = abstract_other;
-    cairo_meta_surface_t *meta;
+    cairo_recording_surface_t *other = abstract_other;
+    cairo_recording_surface_t *recording_surface;
 
-    meta = malloc (sizeof (cairo_meta_surface_t));
-    if (unlikely (meta == NULL))
+    recording_surface = malloc (sizeof (cairo_recording_surface_t));
+    if (unlikely (recording_surface == NULL))
 	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
 
-    _cairo_surface_init (&meta->base, &cairo_meta_surface_backend,
+    _cairo_surface_init (&recording_surface->base, &cairo_recording_surface_backend,
 			 other->base.content);
 
-    meta->extents_pixels = other->extents_pixels;
-    meta->extents = other->extents;
-    meta->unbounded = other->unbounded;
-    meta->replay_start_idx = other->replay_start_idx;
-    meta->content = other->content;
+    recording_surface->extents_pixels = other->extents_pixels;
+    recording_surface->extents = other->extents;
+    recording_surface->unbounded = other->unbounded;
+    recording_surface->replay_start_idx = other->replay_start_idx;
+    recording_surface->content = other->content;
 
-    _cairo_array_init_snapshot (&meta->commands, &other->commands);
-    meta->commands_owner = cairo_surface_reference (&other->base);
+    _cairo_array_init_snapshot (&recording_surface->commands, &other->commands);
+    recording_surface->commands_owner = cairo_surface_reference (&other->base);
 
-    _cairo_clip_init_copy (&meta->clip, &other->clip);
+    _cairo_clip_init_copy (&recording_surface->clip, &other->clip);
 
-    return &meta->base;
+    return &recording_surface->base;
 }
 
 static cairo_bool_t
-_cairo_meta_surface_get_extents (void			 *abstract_surface,
-				 cairo_rectangle_int_t   *rectangle)
+_cairo_recording_surface_get_extents (void		    *abstract_surface,
+				      cairo_rectangle_int_t *rectangle)
 {
-    cairo_meta_surface_t *surface = abstract_surface;
+    cairo_recording_surface_t *surface = abstract_surface;
 
     if (surface->unbounded)
 	return FALSE;
@@ -647,25 +647,25 @@ _cairo_meta_surface_get_extents (void			 *abstract_surface,
 }
 
 /**
- * _cairo_surface_is_meta:
+ * _cairo_surface_is_recording:
  * @surface: a #cairo_surface_t
  *
- * Checks if a surface is a #cairo_meta_surface_t
+ * Checks if a surface is a #cairo_recording_surface_t
  *
- * Return value: %TRUE if the surface is a meta surface
+ * Return value: %TRUE if the surface is a recording surface
  **/
 cairo_bool_t
-_cairo_surface_is_meta (const cairo_surface_t *surface)
+_cairo_surface_is_recording (const cairo_surface_t *surface)
 {
-    return surface->backend == &cairo_meta_surface_backend;
+    return surface->backend == &cairo_recording_surface_backend;
 }
 
-static const cairo_surface_backend_t cairo_meta_surface_backend = {
-    CAIRO_SURFACE_TYPE_META,
-    _cairo_meta_surface_create_similar,
-    _cairo_meta_surface_finish,
-    _cairo_meta_surface_acquire_source_image,
-    _cairo_meta_surface_release_source_image,
+static const cairo_surface_backend_t cairo_recording_surface_backend = {
+    CAIRO_SURFACE_TYPE_RECORDING,
+    _cairo_recording_surface_create_similar,
+    _cairo_recording_surface_finish,
+    _cairo_recording_surface_acquire_source_image,
+    _cairo_recording_surface_release_source_image,
     NULL, /* acquire_dest_image */
     NULL, /* release_dest_image */
     NULL, /* clone_similar */
@@ -676,7 +676,7 @@ static const cairo_surface_backend_t cairo_meta_surface_backend = {
     NULL, /* check_span_renderer */
     NULL, /* copy_page */
     NULL, /* show_page */
-    _cairo_meta_surface_get_extents,
+    _cairo_recording_surface_get_extents,
     NULL, /* old_show_glyphs */
     NULL, /* get_font_options */
     NULL, /* flush */
@@ -685,32 +685,32 @@ static const cairo_surface_backend_t cairo_meta_surface_backend = {
     NULL, /* scaled_glyph_fini */
 
     /* Here are the 5 basic drawing operations, (which are in some
-     * sense the only things that cairo_meta_surface should need to
+     * sense the only things that cairo_recording_surface should need to
      * implement).  However, we implement the more generic show_text_glyphs
      * instead of show_glyphs.  One or the other is eough. */
 
-    _cairo_meta_surface_paint,
-    _cairo_meta_surface_mask,
-    _cairo_meta_surface_stroke,
-    _cairo_meta_surface_fill,
+    _cairo_recording_surface_paint,
+    _cairo_recording_surface_mask,
+    _cairo_recording_surface_stroke,
+    _cairo_recording_surface_fill,
     NULL,
 
-    _cairo_meta_surface_snapshot,
+    _cairo_recording_surface_snapshot,
 
     NULL, /* is_similar */
     NULL, /* fill_stroke */
     NULL, /* create_solid_pattern_surface */
     NULL, /* can_repaint_solid_pattern_surface */
 
-    _cairo_meta_surface_has_show_text_glyphs,
-    _cairo_meta_surface_show_text_glyphs
+    _cairo_recording_surface_has_show_text_glyphs,
+    _cairo_recording_surface_show_text_glyphs
 };
 
 cairo_int_status_t
-_cairo_meta_surface_get_path (cairo_surface_t	 *surface,
-			      cairo_path_fixed_t *path)
+_cairo_recording_surface_get_path (cairo_surface_t    *surface,
+				   cairo_path_fixed_t *path)
 {
-    cairo_meta_surface_t *meta;
+    cairo_recording_surface_t *recording_surface;
     cairo_command_t **elements;
     int i, num_elements;
     cairo_int_status_t status;
@@ -718,12 +718,12 @@ _cairo_meta_surface_get_path (cairo_surface_t	 *surface,
     if (surface->status)
 	return surface->status;
 
-    meta = (cairo_meta_surface_t *) surface;
+    recording_surface = (cairo_recording_surface_t *) surface;
     status = CAIRO_STATUS_SUCCESS;
 
-    num_elements = meta->commands.num_elements;
-    elements = _cairo_array_index (&meta->commands, 0);
-    for (i = meta->replay_start_idx; i < num_elements; i++) {
+    num_elements = recording_surface->commands.num_elements;
+    elements = _cairo_array_index (&recording_surface->commands, 0);
+    for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
 	cairo_command_t *command = elements[i];
 
 	switch (command->header.type) {
@@ -781,12 +781,12 @@ _cairo_meta_surface_get_path (cairo_surface_t	 *surface,
 
 #define _clip(c) ((c)->header.clip.path ? &(c)->header.clip : NULL)
 static cairo_status_t
-_cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
-				     cairo_surface_t	     *target,
-				     cairo_meta_replay_type_t type,
-				     cairo_meta_region_type_t region)
+_cairo_recording_surface_replay_internal (cairo_surface_t	     *surface,
+					  cairo_surface_t	     *target,
+					  cairo_recording_replay_type_t type,
+					  cairo_recording_region_type_t region)
 {
-    cairo_meta_surface_t *meta;
+    cairo_recording_surface_t *recording_surface;
     cairo_command_t **elements;
     int i, num_elements;
     cairo_int_status_t status;
@@ -800,15 +800,15 @@ _cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
 
     _cairo_surface_wrapper_init (&wrapper, target);
 
-    meta = (cairo_meta_surface_t *) surface;
+    recording_surface = (cairo_recording_surface_t *) surface;
     status = CAIRO_STATUS_SUCCESS;
 
-    num_elements = meta->commands.num_elements;
-    elements = _cairo_array_index (&meta->commands, 0);
-    for (i = meta->replay_start_idx; i < num_elements; i++) {
+    num_elements = recording_surface->commands.num_elements;
+    elements = _cairo_array_index (&recording_surface->commands, 0);
+    for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
 	cairo_command_t *command = elements[i];
 
-	if (type == CAIRO_META_REPLAY && region != CAIRO_META_REGION_ALL) {
+	if (type == CAIRO_RECORDING_REPLAY && region != CAIRO_RECORDING_REGION_ALL) {
 	    if (command->header.region != region)
 		continue;
         }
@@ -848,12 +848,12 @@ _cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
 	    cairo_command_t *stroke_command;
 
 	    stroke_command = NULL;
-	    if (type != CAIRO_META_CREATE_REGIONS && i < num_elements - 1)
+	    if (type != CAIRO_RECORDING_CREATE_REGIONS && i < num_elements - 1)
 		stroke_command = elements[i + 1];
 
 	    if (stroke_command != NULL &&
-		type == CAIRO_META_REPLAY &&
-		region != CAIRO_META_REGION_ALL)
+		type == CAIRO_RECORDING_REPLAY &&
+		region != CAIRO_RECORDING_REGION_ALL)
 	    {
 		if (stroke_command->header.region != region)
 		    stroke_command = NULL;
@@ -928,11 +928,11 @@ _cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
 	    ASSERT_NOT_REACHED;
 	}
 
-	if (type == CAIRO_META_CREATE_REGIONS) {
+	if (type == CAIRO_RECORDING_CREATE_REGIONS) {
 	    if (status == CAIRO_STATUS_SUCCESS) {
-		command->header.region = CAIRO_META_REGION_NATIVE;
+		command->header.region = CAIRO_RECORDING_REGION_NATIVE;
 	    } else if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) {
-		command->header.region = CAIRO_META_REGION_IMAGE_FALLBACK;
+		command->header.region = CAIRO_RECORDING_REGION_IMAGE_FALLBACK;
 		status = CAIRO_STATUS_SUCCESS;
 	    } else {
 		assert (_cairo_status_is_error (status));
@@ -944,7 +944,7 @@ _cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
     }
 
     /* free up any caches */
-    for (i = meta->replay_start_idx; i < num_elements; i++) {
+    for (i = recording_surface->replay_start_idx; i < num_elements; i++) {
 	cairo_command_t *command = elements[i];
 
 	_cairo_clip_drop_cache (&command->header.clip);
@@ -956,58 +956,58 @@ _cairo_meta_surface_replay_internal (cairo_surface_t	     *surface,
 }
 
 /**
- * _cairo_meta_surface_replay:
- * @surface: the #cairo_meta_surface_t
+ * _cairo_recording_surface_replay:
+ * @surface: the #cairo_recording_surface_t
  * @target: a target #cairo_surface_t onto which to replay the operations
  * @width_pixels: width of the surface, in pixels
  * @height_pixels: height of the surface, in pixels
  *
- * A meta surface can be "replayed" against any target surface,
+ * A recording surface can be "replayed" against any target surface,
  * after which the results in target will be identical to the results
  * that would have been obtained if the original operations applied to
- * the meta surface had instead been applied to the target surface.
+ * the recording surface had instead been applied to the target surface.
  **/
 cairo_status_t
-_cairo_meta_surface_replay (cairo_surface_t *surface,
-			   cairo_surface_t *target)
+_cairo_recording_surface_replay (cairo_surface_t *surface,
+				 cairo_surface_t *target)
 {
-    return _cairo_meta_surface_replay_internal (surface,
-						target,
-						CAIRO_META_REPLAY,
-						CAIRO_META_REGION_ALL);
+    return _cairo_recording_surface_replay_internal (surface,
+						     target,
+						     CAIRO_RECORDING_REPLAY,
+						     CAIRO_RECORDING_REGION_ALL);
 }
 
-/* Replay meta to surface. When the return status of each operation is
+/* Replay recording to surface. When the return status of each operation is
  * one of %CAIRO_STATUS_SUCCESS, %CAIRO_INT_STATUS_UNSUPPORTED, or
  * %CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY the status of each operation
- * will be stored in the meta surface. Any other status will abort the
+ * will be stored in the recording surface. Any other status will abort the
  * replay and return the status.
  */
 cairo_status_t
-_cairo_meta_surface_replay_and_create_regions (cairo_surface_t *surface,
-					       cairo_surface_t *target)
+_cairo_recording_surface_replay_and_create_regions (cairo_surface_t *surface,
+						    cairo_surface_t *target)
 {
-    return _cairo_meta_surface_replay_internal (surface,
-						target,
-						CAIRO_META_CREATE_REGIONS,
-						CAIRO_META_REGION_ALL);
+    return _cairo_recording_surface_replay_internal (surface,
+						     target,
+						     CAIRO_RECORDING_CREATE_REGIONS,
+						     CAIRO_RECORDING_REGION_ALL);
 }
 
 cairo_status_t
-_cairo_meta_surface_replay_region (cairo_surface_t          *surface,
-				   cairo_surface_t          *target,
-				   cairo_meta_region_type_t  region)
+_cairo_recording_surface_replay_region (cairo_surface_t          *surface,
+					cairo_surface_t          *target,
+					cairo_recording_region_type_t  region)
 {
-    return _cairo_meta_surface_replay_internal (surface,
-						target,
-						CAIRO_META_REPLAY,
-						region);
+    return _cairo_recording_surface_replay_internal (surface,
+						     target,
+						     CAIRO_RECORDING_REPLAY,
+						     region);
 }
 
 static cairo_status_t
-_meta_surface_get_ink_bbox (cairo_meta_surface_t *surface,
-			    cairo_box_t *bbox,
-			    const cairo_matrix_t *transform)
+_recording_surface_get_ink_bbox (cairo_recording_surface_t *surface,
+				 cairo_box_t *bbox,
+				 const cairo_matrix_t *transform)
 {
     cairo_surface_t *null_surface;
     cairo_surface_t *analysis_surface;
@@ -1024,7 +1024,7 @@ _meta_surface_get_ink_bbox (cairo_meta_surface_t *surface,
     if (transform != NULL)
 	_cairo_analysis_surface_set_ctm (analysis_surface, transform);
 
-    status = _cairo_meta_surface_replay (&surface->base, analysis_surface);
+    status = _cairo_recording_surface_replay (&surface->base, analysis_surface);
     _cairo_analysis_surface_get_bounding_box (analysis_surface, bbox);
     cairo_surface_destroy (analysis_surface);
 
@@ -1032,37 +1032,37 @@ _meta_surface_get_ink_bbox (cairo_meta_surface_t *surface,
 }
 
 /**
- * cairo_meta_surface_ink_extents:
- * @surface: a #cairo_meta_surface_t
+ * cairo_recording_surface_ink_extents:
+ * @surface: a #cairo_recording_surface_t
  * @x0: the x-coordinate of the top-left of the ink bounding box
  * @y0: the y-coordinate of the top-left of the ink bounding box
  * @width: the width of the ink bounding box
  * @height: the height of the ink bounding box
  *
- * Measures the extents of the operations stored within the meta-surface.
+ * Measures the extents of the operations stored within the recording-surface.
  * This is useful to compute the required size of an image surface (or
  * equivalent) into which to replay the full sequence of drawing operations.
  *
  * Since: 1.10
  **/
 void
-cairo_meta_surface_ink_extents (cairo_surface_t *surface,
-				double *x0,
-				double *y0,
-				double *width,
-				double *height)
+cairo_recording_surface_ink_extents (cairo_surface_t *surface,
+				     double *x0,
+				     double *y0,
+				     double *width,
+				     double *height)
 {
     cairo_status_t status;
     cairo_box_t bbox;
 
     memset (&bbox, 0, sizeof (bbox));
 
-    if (! _cairo_surface_is_meta (surface)) {
+    if (! _cairo_surface_is_recording (surface)) {
 	_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
 	goto DONE;
     }
 
-    status = _meta_surface_get_ink_bbox ((cairo_meta_surface_t *) surface,
+    status = _recording_surface_get_ink_bbox ((cairo_recording_surface_t *) surface,
 					 &bbox,
 					 NULL);
     if (unlikely (status))
@@ -1080,9 +1080,9 @@ DONE:
 }
 
 cairo_status_t
-_cairo_meta_surface_get_bbox (cairo_meta_surface_t *surface,
-			      cairo_box_t *bbox,
-			      const cairo_matrix_t *transform)
+_cairo_recording_surface_get_bbox (cairo_recording_surface_t *surface,
+				   cairo_box_t *bbox,
+				   const cairo_matrix_t *transform)
 {
     if (! surface->unbounded) {
 	_cairo_box_from_rectangle (bbox, &surface->extents);
@@ -1092,5 +1092,5 @@ _cairo_meta_surface_get_bbox (cairo_meta_surface_t *surface,
 	return CAIRO_STATUS_SUCCESS;
     }
 
-    return _meta_surface_get_ink_bbox (surface, bbox, transform);
+    return _recording_surface_get_ink_bbox (surface, bbox, transform);
 }
diff --git a/src/cairo-scaled-font.c b/src/cairo-scaled-font.c
index 179844fc..5795d246 100644
--- a/src/cairo-scaled-font.c
+++ b/src/cairo-scaled-font.c
@@ -199,8 +199,8 @@ _cairo_scaled_glyph_fini (cairo_scaled_font_t *scaled_font,
     if (scaled_glyph->path != NULL)
 	_cairo_path_fixed_destroy (scaled_glyph->path);
 
-    if (scaled_glyph->meta_surface != NULL)
-	cairo_surface_destroy (scaled_glyph->meta_surface);
+    if (scaled_glyph->recording_surface != NULL)
+	cairo_surface_destroy (scaled_glyph->recording_surface);
 }
 
 #define ZOMBIE 0
@@ -2516,13 +2516,13 @@ _cairo_scaled_glyph_set_path (cairo_scaled_glyph_t *scaled_glyph,
 }
 
 void
-_cairo_scaled_glyph_set_meta_surface (cairo_scaled_glyph_t *scaled_glyph,
-				      cairo_scaled_font_t *scaled_font,
-				      cairo_surface_t *meta_surface)
+_cairo_scaled_glyph_set_recording_surface (cairo_scaled_glyph_t *scaled_glyph,
+					   cairo_scaled_font_t *scaled_font,
+					   cairo_surface_t *recording_surface)
 {
-    if (scaled_glyph->meta_surface != NULL)
-	cairo_surface_destroy (meta_surface);
-    scaled_glyph->meta_surface = meta_surface;
+    if (scaled_glyph->recording_surface != NULL)
+	cairo_surface_destroy (recording_surface);
+    scaled_glyph->recording_surface = recording_surface;
 }
 
 static cairo_bool_t
@@ -2703,10 +2703,10 @@ _cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font,
 	need_info |= CAIRO_SCALED_GLYPH_INFO_PATH;
     }
 
-    if ((info & CAIRO_SCALED_GLYPH_INFO_META_SURFACE) != 0 &&
-	scaled_glyph->meta_surface == NULL)
+    if ((info & CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE) != 0 &&
+	scaled_glyph->recording_surface == NULL)
     {
-	need_info |= CAIRO_SCALED_GLYPH_INFO_META_SURFACE;
+	need_info |= CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE;
     }
 
     if (need_info) {
@@ -2718,7 +2718,7 @@ _cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font,
 
 	/* Don't trust the scaled_glyph_init() return value, the font
 	 * backend may not even know about some of the info.  For example,
-	 * no backend other than the user-fonts knows about meta-surface
+	 * no backend other than the user-fonts knows about recording-surface
 	 * glyph info. */
 
 	if ((info & CAIRO_SCALED_GLYPH_INFO_SURFACE) != 0 &&
@@ -2735,8 +2735,8 @@ _cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font,
 	    goto CLEANUP;
 	}
 
-	if ((info & CAIRO_SCALED_GLYPH_INFO_META_SURFACE) != 0 &&
-	    scaled_glyph->meta_surface == NULL)
+	if ((info & CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE) != 0 &&
+	    scaled_glyph->recording_surface == NULL)
 	{
 	    status = CAIRO_INT_STATUS_UNSUPPORTED;
 	    goto CLEANUP;
diff --git a/src/cairo-script-surface.c b/src/cairo-script-surface.c
index 93b09da8..ec06364b 100644
--- a/src/cairo-script-surface.c
+++ b/src/cairo-script-surface.c
@@ -37,7 +37,7 @@
 /* The script surface is one that records all operations performed on
  * it in the form of a procedural script, similar in fashion to
  * PostScript but using Cairo's imaging model. In essence, this is
- * equivalent to the meta-surface, but as there is no impedance mismatch
+ * equivalent to the recording-surface, but as there is no impedance mismatch
  * between Cairo and CairoScript, we can generate output immediately
  * without having to copy and hold the data in memory.
  */
@@ -49,7 +49,7 @@
 #include "cairo-analysis-surface-private.h"
 #include "cairo-ft-private.h"
 #include "cairo-list-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-output-stream-private.h"
 #include "cairo-scaled-font-private.h"
 #include "cairo-surface-clipper-private.h"
@@ -929,22 +929,22 @@ _emit_radial_pattern (cairo_script_surface_t *surface,
 }
 
 static cairo_status_t
-_emit_meta_surface_pattern (cairo_script_surface_t *surface,
-			    const cairo_pattern_t *pattern)
+_emit_recording_surface_pattern (cairo_script_surface_t *surface,
+				 const cairo_pattern_t *pattern)
 {
     cairo_script_implicit_context_t old_cr;
     cairo_surface_pattern_t *surface_pattern;
-    cairo_meta_surface_t *source;
+    cairo_recording_surface_t *source;
     cairo_script_surface_t *similar;
     cairo_status_t status;
     cairo_box_t bbox;
     cairo_rectangle_int_t rect;
 
     surface_pattern = (cairo_surface_pattern_t *) pattern;
-    source = (cairo_meta_surface_t *) surface_pattern->surface;
+    source = (cairo_recording_surface_t *) surface_pattern->surface;
 
     /* first measure the extents */
-    status = _cairo_meta_surface_get_bbox (source, &bbox, NULL);
+    status = _cairo_recording_surface_get_bbox (source, &bbox, NULL);
     if (unlikely (status))
 	return status;
 
@@ -972,7 +972,7 @@ _emit_meta_surface_pattern (cairo_script_surface_t *surface,
 
     old_cr = surface->cr;
     _cairo_script_implicit_context_init (&surface->cr);
-    status = _cairo_meta_surface_replay (&source->base, &similar->base);
+    status = _cairo_recording_surface_replay (&source->base, &similar->base);
     surface->cr = old_cr;
 
     if (unlikely (status)) {
@@ -1346,8 +1346,8 @@ _emit_surface_pattern (cairo_script_surface_t *surface,
     source = surface_pattern->surface;
 
     switch ((int) source->type) {
-    case CAIRO_SURFACE_TYPE_META:
-	return _emit_meta_surface_pattern (surface, pattern);
+    case CAIRO_SURFACE_TYPE_RECORDING:
+	return _emit_recording_surface_pattern (surface, pattern);
     case CAIRO_SURFACE_TYPE_SCRIPT:
 	return _emit_script_surface_pattern (surface, pattern);
     default:
@@ -2655,8 +2655,8 @@ _emit_scaled_glyph_vector (cairo_script_surface_t *surface,
 
     old_cr = surface->cr;
     _cairo_script_implicit_context_init (&surface->cr);
-    status = _cairo_meta_surface_replay (scaled_glyph->meta_surface,
-					&surface->base);
+    status = _cairo_recording_surface_replay (scaled_glyph->recording_surface,
+					      &surface->base);
     surface->cr = old_cr;
 
     _cairo_output_stream_puts (surface->ctx->stream, "} >> set\n");
@@ -2763,7 +2763,7 @@ _emit_scaled_glyphs (cairo_script_surface_t *surface,
 
 	status = _cairo_scaled_glyph_lookup (scaled_font,
 					     glyphs[n].index,
-					     CAIRO_SCALED_GLYPH_INFO_META_SURFACE,
+					     CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE,
 					     &scaled_glyph);
 	if (_cairo_status_is_error (status))
 	    break;
@@ -3397,8 +3397,8 @@ cairo_script_surface_create_for_target (cairo_script_context_t *context,
 }
 
 cairo_status_t
-cairo_script_from_meta_surface (cairo_script_context_t *context,
-				cairo_surface_t *meta)
+cairo_script_from_recording_surface (cairo_script_context_t *context,
+				     cairo_surface_t *recording_surface)
 {
     cairo_box_t bbox;
     cairo_rectangle_int_t extents;
@@ -3408,13 +3408,13 @@ cairo_script_from_meta_surface (cairo_script_context_t *context,
     if (unlikely (context->status))
 	return context->status;
 
-    if (unlikely (meta->status))
-	return meta->status;
+    if (unlikely (recording_surface->status))
+	return recording_surface->status;
 
-    if (unlikely (! _cairo_surface_is_meta (meta)))
+    if (unlikely (! _cairo_surface_is_recording (recording_surface)))
 	return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
 
-    status = _cairo_meta_surface_get_bbox ((cairo_meta_surface_t *) meta,
+    status = _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
 					   &bbox, NULL);
     if (unlikely (status))
 	return status;
@@ -3422,7 +3422,7 @@ cairo_script_from_meta_surface (cairo_script_context_t *context,
     _cairo_box_round_to_rectangle (&bbox, &extents);
 
     surface = &_cairo_script_surface_create_internal (context,
-						      meta->content,
+						      recording_surface->content,
 						      extents.width,
 						      extents.height,
 						      NULL)->base;
@@ -3430,7 +3430,7 @@ cairo_script_from_meta_surface (cairo_script_context_t *context,
 	return surface->status;
 
     cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
-    status = _cairo_meta_surface_replay (meta, surface);
+    status = _cairo_recording_surface_replay (recording_surface, surface);
     cairo_surface_destroy (surface);
 
     return status;
diff --git a/src/cairo-script.h b/src/cairo-script.h
index c4183506..5af625c1 100644
--- a/src/cairo-script.h
+++ b/src/cairo-script.h
@@ -82,8 +82,8 @@ cairo_script_surface_create_for_target (cairo_script_context_t *context,
 					cairo_surface_t *target);
 
 cairo_public cairo_status_t
-cairo_script_from_meta_surface (cairo_script_context_t *context,
-				cairo_surface_t *meta);
+cairo_script_from_recording_surface (cairo_script_context_t *context,
+				     cairo_surface_t        *recording_surface);
 
 CAIRO_END_DECLS
 
diff --git a/src/cairo-surface.c b/src/cairo-surface.c
index aaab3134..9aa707f5 100644
--- a/src/cairo-surface.c
+++ b/src/cairo-surface.c
@@ -40,7 +40,7 @@
 
 #include "cairo-surface-fallback-private.h"
 #include "cairo-clip-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-region-private.h"
 #include "cairo-tee-surface-private.h"
 
@@ -1059,8 +1059,8 @@ slim_hidden_def (cairo_surface_mark_dirty_rectangle);
  *
  * Private function for setting an extra scale factor to affect all
  * drawing to a surface. This is used, for example, when replaying a
- * meta surface to an image fallback intended for an eventual
- * vector-oriented backend. Since the meta surface will record
+ * recording surface to an image fallback intended for an eventual
+ * vector-oriented backend. Since the recording surface will record
  * coordinates in one backend space, but the image fallback uses a
  * different backend space, (differing by the fallback resolution
  * scale factors), we need a scale factor correction.
@@ -1410,17 +1410,17 @@ _cairo_surface_release_dest_image (cairo_surface_t         *surface,
 }
 
 static cairo_status_t
-_cairo_meta_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_meta_surface_t *meta = (cairo_meta_surface_t *) src;
+_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;
     cairo_surface_t *similar;
     cairo_status_t status;
 
@@ -1434,8 +1434,8 @@ _cairo_meta_surface_clone_similar (cairo_surface_t  *surface,
 	return CAIRO_STATUS_SUCCESS;
     }
 
-    if (meta->unbounded ||
-	width*height*8 < meta->extents.width*meta->extents.height)
+    if (recorder->unbounded ||
+	width*height*8 < recorder->extents.width*recorder->extents.height)
     {
 	/* XXX use _solid to perform an initial CLEAR? */
 	similar = _cairo_surface_create_similar_scratch (surface,
@@ -1448,7 +1448,7 @@ _cairo_meta_surface_clone_similar (cairo_surface_t  *surface,
 
 	cairo_surface_set_device_offset (similar, -src_x, -src_y);
 
-	status = _cairo_meta_surface_replay (src, similar);
+	status = _cairo_recording_surface_replay (src, similar);
 	if (unlikely (status)) {
 	    cairo_surface_destroy (similar);
 	    return status;
@@ -1456,14 +1456,14 @@ _cairo_meta_surface_clone_similar (cairo_surface_t  *surface,
     } else {
 	similar = _cairo_surface_create_similar_scratch (surface,
 							 src->content,
-							 meta->extents.width,
-							 meta->extents.height);
+							 recorder->extents.width,
+							 recorder->extents.height);
 	if (similar == NULL)
 	    return CAIRO_INT_STATUS_UNSUPPORTED;
 	if (unlikely (similar->status))
 	    return similar->status;
 
-	status = _cairo_meta_surface_replay (src, similar);
+	status = _cairo_recording_surface_replay (src, similar);
 	if (unlikely (status)) {
 	    cairo_surface_destroy (similar);
 	    return status;
@@ -1548,13 +1548,13 @@ _cairo_surface_clone_similar (cairo_surface_t  *surface,
 		return CAIRO_INT_STATUS_UNSUPPORTED;
 
 	    /* First check to see if we can replay to a similar surface */
-	    if (_cairo_surface_is_meta (src)) {
-		return _cairo_meta_surface_clone_similar (surface, src,
-							  src_x, src_y,
-							  width, height,
-							  clone_offset_x,
-							  clone_offset_y,
-							  clone_out);
+	    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 */
@@ -1598,7 +1598,7 @@ _cairo_surface_clone_similar (cairo_surface_t  *surface,
 }
 
 /* XXX: Shouldn't really need to do this here. */
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 
 /**
  * _cairo_surface_snapshot
@@ -2339,7 +2339,7 @@ slim_hidden_def (cairo_surface_show_page);
  * possibly be recorded, in other words, it is the maximum extent of
  * potentially usable coordinates.
  *
- * For vector surfaces, (PDF, PS, SVG and meta-surfaces), the surface
+ * For vector surfaces, (PDF, PS, SVG and recording-surfaces), the surface
  * might be conceived as unbounded, but we force the user to provide a
  * maximum size at the time of surface_create. So get_extents uses
  * that size.
diff --git a/src/cairo-svg-surface.c b/src/cairo-svg-surface.c
index 6277af18..fa25b821 100644
--- a/src/cairo-svg-surface.c
+++ b/src/cairo-svg-surface.c
@@ -44,7 +44,7 @@
 #include "cairo-svg.h"
 #include "cairo-analysis-surface-private.h"
 #include "cairo-image-info-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-output-stream-private.h"
 #include "cairo-path-fixed-private.h"
 #include "cairo-paginated-private.h"
@@ -1268,8 +1268,8 @@ _cairo_svg_surface_emit_composite_surface_pattern (cairo_output_stream_t   *outp
 }
 
 static cairo_status_t
-_cairo_svg_surface_emit_meta_surface (cairo_svg_document_t *document,
-				      cairo_meta_surface_t *source)
+_cairo_svg_surface_emit_recording_surface (cairo_svg_document_t      *document,
+					   cairo_recording_surface_t *source)
 {
     cairo_status_t status;
     cairo_surface_t *paginated_surface;
@@ -1300,7 +1300,7 @@ _cairo_svg_surface_emit_meta_surface (cairo_svg_document_t *document,
 				     -source->extents_pixels.x,
 				     -source->extents_pixels.y);
 
-    status = _cairo_meta_surface_replay (&source->base, paginated_surface);
+    status = _cairo_recording_surface_replay (&source->base, paginated_surface);
     if (unlikely (status)) {
 	cairo_surface_destroy (paginated_surface);
 	return status;
@@ -1372,16 +1372,16 @@ _cairo_svg_surface_emit_meta_surface (cairo_svg_document_t *document,
 }
 
 static cairo_status_t
-_cairo_svg_surface_emit_composite_meta_pattern (cairo_output_stream_t	*output,
-						cairo_svg_surface_t	*surface,
-						cairo_operator_t	 op,
-						cairo_surface_pattern_t	*pattern,
-						int			 pattern_id,
-						const cairo_matrix_t	*parent_matrix,
-						const char		*extra_attributes)
+_cairo_svg_surface_emit_composite_recording_pattern (cairo_output_stream_t	*output,
+						     cairo_svg_surface_t	*surface,
+						     cairo_operator_t	         op,
+						     cairo_surface_pattern_t	*pattern,
+						     int			 pattern_id,
+						     const cairo_matrix_t	*parent_matrix,
+						     const char			*extra_attributes)
 {
     cairo_svg_document_t *document = surface->document;
-    cairo_meta_surface_t *meta_surface;
+    cairo_recording_surface_t *recording_surface;
     cairo_matrix_t p2u;
     cairo_status_t status;
 
@@ -1390,8 +1390,8 @@ _cairo_svg_surface_emit_composite_meta_pattern (cairo_output_stream_t	*output,
     /* cairo_pattern_set_matrix ensures the matrix is invertible */
     assert (status == CAIRO_STATUS_SUCCESS);
 
-    meta_surface = (cairo_meta_surface_t *) pattern->surface;
-    status = _cairo_svg_surface_emit_meta_surface (document, meta_surface);
+    recording_surface = (cairo_recording_surface_t *) pattern->surface;
+    status = _cairo_svg_surface_emit_recording_surface (document, recording_surface);
     if (unlikely (status))
 	return status;
 
@@ -1401,15 +1401,15 @@ _cairo_svg_surface_emit_composite_meta_pattern (cairo_output_stream_t	*output,
 				     "patternUnits=\"userSpaceOnUse\" "
 				     "width=\"%d\" height=\"%d\"",
 				     pattern_id,
-				     meta_surface->extents.width,
-				     meta_surface->extents.height);
+				     recording_surface->extents.width,
+				     recording_surface->extents.height);
 	_cairo_svg_surface_emit_transform (output, " patternTransform", &p2u, parent_matrix);
 	_cairo_output_stream_printf (output, ">\n");
     }
 
     _cairo_output_stream_printf (output,
 				 "<use xlink:href=\"#surface%d\"",
-				 meta_surface->base.unique_id);
+				 recording_surface->base.unique_id);
 
     if (pattern_id == invalid_pattern_id) {
 	_cairo_svg_surface_emit_operator (output, surface, op);
@@ -1437,12 +1437,12 @@ _cairo_svg_surface_emit_composite_pattern (cairo_output_stream_t   *output,
 					   const char		   *extra_attributes)
 {
 
-    if (_cairo_surface_is_meta (pattern->surface)) {
-	return _cairo_svg_surface_emit_composite_meta_pattern (output, surface,
-							       op, pattern,
-							       pattern_id,
-							       parent_matrix,
-							       extra_attributes);
+    if (_cairo_surface_is_recording (pattern->surface)) {
+	return _cairo_svg_surface_emit_composite_recording_pattern (output, surface,
+								    op, pattern,
+								    pattern_id,
+								    parent_matrix,
+								    extra_attributes);
     }
 
     return _cairo_svg_surface_emit_composite_surface_pattern (output, surface,
diff --git a/src/cairo-tee-surface.c b/src/cairo-tee-surface.c
index 56f3cc26..1111fa1b 100644
--- a/src/cairo-tee-surface.c
+++ b/src/cairo-tee-surface.c
@@ -159,14 +159,14 @@ _cairo_tee_surface_snapshot (void *abstract_surface)
     cairo_surface_wrapper_t *slaves;
     int num_slaves, n;
 
-    /* we prefer to use a meta surface for our snapshots */
-    if (_cairo_surface_is_meta (surface->master.target))
+    /* we prefer to use a recording surface for our snapshots */
+    if (_cairo_surface_is_recording (surface->master.target))
 	return _cairo_surface_wrapper_snapshot (&surface->master);
 
     num_slaves = _cairo_array_num_elements (&surface->slaves);
     slaves = _cairo_array_index (&surface->slaves, 0);
     for (n = 0; n < num_slaves; n++) {
-	if (_cairo_surface_is_meta (slaves[n].target))
+	if (_cairo_surface_is_recording (slaves[n].target))
 	    return _cairo_surface_wrapper_snapshot (&slaves[n]);
     }
 
diff --git a/src/cairo-type3-glyph-surface.c b/src/cairo-type3-glyph-surface.c
index f7699b8b..6878bbaa 100644
--- a/src/cairo-type3-glyph-surface.c
+++ b/src/cairo-type3-glyph-surface.c
@@ -40,7 +40,7 @@
 
 #include "cairo-type3-glyph-surface-private.h"
 #include "cairo-output-stream-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-analysis-surface-private.h"
 #include "cairo-surface-clipper-private.h"
 
@@ -438,7 +438,7 @@ _cairo_type3_glyph_surface_analyze_glyph (void		     *abstract_surface,
     status = _cairo_scaled_glyph_lookup (surface->scaled_font,
 					 glyph_index,
 					 CAIRO_SCALED_GLYPH_INFO_METRICS |
-					 CAIRO_SCALED_GLYPH_INFO_META_SURFACE,
+					 CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE,
 					 &scaled_glyph);
 
     if (_cairo_status_is_error (status))
@@ -449,8 +449,8 @@ _cairo_type3_glyph_surface_analyze_glyph (void		     *abstract_surface,
 	goto cleanup;
     }
 
-    status = _cairo_meta_surface_replay (scaled_glyph->meta_surface,
-					&surface->base);
+    status = _cairo_recording_surface_replay (scaled_glyph->recording_surface,
+					      &surface->base);
     if (unlikely (status))
 	goto cleanup;
 
@@ -493,7 +493,7 @@ _cairo_type3_glyph_surface_emit_glyph (void		     *abstract_surface,
     status = _cairo_scaled_glyph_lookup (surface->scaled_font,
 					 glyph_index,
 					 CAIRO_SCALED_GLYPH_INFO_METRICS |
-					 CAIRO_SCALED_GLYPH_INFO_META_SURFACE,
+					 CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE,
 					 &scaled_glyph);
     if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
 	status = _cairo_scaled_glyph_lookup (surface->scaled_font,
@@ -544,8 +544,8 @@ _cairo_type3_glyph_surface_emit_glyph (void		     *abstract_surface,
 	_cairo_type3_glyph_surface_set_stream (surface, mem_stream);
 
 	_cairo_output_stream_printf (surface->stream, "q\n");
-	status = _cairo_meta_surface_replay (scaled_glyph->meta_surface,
-					    &surface->base);
+	status = _cairo_recording_surface_replay (scaled_glyph->recording_surface,
+						  &surface->base);
 
 	status2 = _cairo_pdf_operators_flush (&surface->pdf_operators);
 	if (status == CAIRO_STATUS_SUCCESS)
diff --git a/src/cairo-types-private.h b/src/cairo-types-private.h
index 16b27c25..3a3b8496 100644
--- a/src/cairo-types-private.h
+++ b/src/cairo-types-private.h
@@ -158,7 +158,7 @@ typedef enum _cairo_int_status {
     CAIRO_INT_STATUS_NOTHING_TO_DO,
     CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY,
     CAIRO_INT_STATUS_IMAGE_FALLBACK,
-    CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN,
+    CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN,
 
     CAIRO_INT_STATUS_LAST_STATUS
 } cairo_int_status_t;
diff --git a/src/cairo-user-font.c b/src/cairo-user-font.c
index 1cd5ffcc..3304392f 100644
--- a/src/cairo-user-font.c
+++ b/src/cairo-user-font.c
@@ -36,7 +36,7 @@
 
 #include "cairoint.h"
 #include "cairo-user-font-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-analysis-surface-private.h"
 
 typedef struct _cairo_user_scaled_font_methods {
@@ -75,19 +75,19 @@ typedef struct _cairo_user_scaled_font {
 /* #cairo_user_scaled_font_t */
 
 static cairo_t *
-_cairo_user_scaled_font_create_meta_context (cairo_user_scaled_font_t *scaled_font)
+_cairo_user_scaled_font_create_recording_context (cairo_user_scaled_font_t *scaled_font)
 {
     cairo_content_t content;
-    cairo_surface_t *meta_surface;
+    cairo_surface_t *recording_surface;
     cairo_t *cr;
 
     content = scaled_font->base.options.antialias == CAIRO_ANTIALIAS_SUBPIXEL ?
 						     CAIRO_CONTENT_COLOR_ALPHA :
 						     CAIRO_CONTENT_ALPHA;
 
-    meta_surface = cairo_meta_surface_create (content, NULL);
-    cr = cairo_create (meta_surface);
-    cairo_surface_destroy (meta_surface);
+    recording_surface = cairo_recording_surface_create (content, NULL);
+    cr = cairo_create (recording_surface);
+    cairo_surface_destroy (recording_surface);
 
     cairo_set_matrix (cr, &scaled_font->base.scale);
     cairo_set_font_size (cr, 1.0);
@@ -104,15 +104,15 @@ _cairo_user_scaled_glyph_init (void			 *abstract_font,
 {
     cairo_int_status_t status = CAIRO_STATUS_SUCCESS;
     cairo_user_scaled_font_t *scaled_font = abstract_font;
-    cairo_surface_t *meta_surface = scaled_glyph->meta_surface;
+    cairo_surface_t *recording_surface = scaled_glyph->recording_surface;
 
-    if (!scaled_glyph->meta_surface) {
+    if (!scaled_glyph->recording_surface) {
 	cairo_user_font_face_t *face =
 	    (cairo_user_font_face_t *) scaled_font->base.font_face;
 	cairo_text_extents_t extents = scaled_font->default_glyph_extents;
 	cairo_t *cr;
 
-	cr = _cairo_user_scaled_font_create_meta_context (scaled_font);
+	cr = _cairo_user_scaled_font_create_recording_context (scaled_font);
 
 	if (face->scaled_font_methods.render_glyph) {
 	    status = face->scaled_font_methods.render_glyph ((cairo_scaled_font_t *)scaled_font,
@@ -124,18 +124,18 @@ _cairo_user_scaled_glyph_init (void			 *abstract_font,
 	if (status == CAIRO_STATUS_SUCCESS)
 	    status = cairo_status (cr);
 
-	meta_surface = cairo_surface_reference (cairo_get_target (cr));
+	recording_surface = cairo_surface_reference (cairo_get_target (cr));
 
 	cairo_destroy (cr);
 
 	if (unlikely (status)) {
-	    cairo_surface_destroy (meta_surface);
+	    cairo_surface_destroy (recording_surface);
 	    return status;
 	}
 
-	_cairo_scaled_glyph_set_meta_surface (scaled_glyph,
-					      &scaled_font->base,
-					      meta_surface);
+	_cairo_scaled_glyph_set_recording_surface (scaled_glyph,
+						   &scaled_font->base,
+						   recording_surface);
 
 
 	/* set metrics */
@@ -145,12 +145,12 @@ _cairo_user_scaled_glyph_init (void			 *abstract_font,
 	    double x1, y1, x2, y2;
 	    double x_scale, y_scale;
 
-	    /* Compute extents.x/y/width/height from meta_surface,
+	    /* Compute extents.x/y/width/height from recording_surface,
 	     * in font space.
 	     */
-	    status = _cairo_meta_surface_get_bbox ((cairo_meta_surface_t *) meta_surface,
-						   &bbox,
-						   &scaled_font->extent_scale);
+	    status = _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
+							&bbox,
+							&scaled_font->extent_scale);
 	    if (unlikely (status))
 		return status;
 
@@ -202,7 +202,7 @@ _cairo_user_scaled_glyph_init (void			 *abstract_font,
 	cairo_surface_set_device_offset (surface,
 	                                 - _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.x),
 	                                 - _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.y));
-	status = _cairo_meta_surface_replay (meta_surface, surface);
+	status = _cairo_recording_surface_replay (recording_surface, surface);
 
 	if (unlikely (status)) {
 	    cairo_surface_destroy(surface);
@@ -219,7 +219,7 @@ _cairo_user_scaled_glyph_init (void			 *abstract_font,
 	if (!path)
 	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 
-	status = _cairo_meta_surface_get_path (meta_surface, path);
+	status = _cairo_recording_surface_get_path (recording_surface, path);
 	if (unlikely (status)) {
 	    _cairo_path_fixed_destroy (path);
 	    return status;
@@ -421,7 +421,7 @@ _cairo_user_font_face_scaled_font_create (void                        *abstract_
 	if (status == CAIRO_STATUS_SUCCESS) {
 	    cairo_t *cr;
 
-	    cr = _cairo_user_scaled_font_create_meta_context (user_scaled_font);
+	    cr = _cairo_user_scaled_font_create_recording_context (user_scaled_font);
 
 	    status = font_face->scaled_font_methods.init (&user_scaled_font->base,
 							  cr,
diff --git a/src/cairo-vg-surface.c b/src/cairo-vg-surface.c
index de22c10d..5ca01b6e 100644
--- a/src/cairo-vg-surface.c
+++ b/src/cairo-vg-surface.c
@@ -39,7 +39,7 @@
 #include "cairo-vg.h"
 
 #include "cairo-path-fixed-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-surface-clipper-private.h"
 #include "cairo-cache-private.h"
 
@@ -840,7 +840,7 @@ _vg_setup_solid_source (cairo_vg_context_t *context,
 }
 
 static cairo_vg_surface_t *
-_vg_clone_meta_surface (cairo_vg_context_t *context,
+_vg_clone_recording_surface (cairo_vg_context_t *context,
 			cairo_surface_t *surface)
 {
     VGImage vg_image;
@@ -870,7 +870,7 @@ _vg_clone_meta_surface (cairo_vg_context_t *context,
 				     extents.width, extents.height);
     cairo_surface_set_device_offset (&clone->base, -extents.x, -extents.y);
 
-    status = _cairo_meta_surface_replay (surface, &clone->base);
+    status = _cairo_recording_surface_replay (surface, &clone->base);
     if (unlikely (status)) {
 	cairo_surface_destroy (&clone->base);
 	return (cairo_vg_surface_t *) _cairo_surface_create_in_error (status);
@@ -965,8 +965,8 @@ _vg_setup_surface_source (cairo_vg_context_t *context,
 	goto DONE;
     }
 
-    if (_cairo_surface_is_meta (spat->surface))
-	clone = _vg_clone_meta_surface (context, spat->surface);
+    if (_cairo_surface_is_recording (spat->surface))
+	clone = _vg_clone_recording_surface (context, spat->surface);
     else
 	clone = _vg_clone_image_surface (context, spat->surface);
     if (clone == NULL)
diff --git a/src/cairo-win32-printing-surface.c b/src/cairo-win32-printing-surface.c
index 8203e6a9..173c9334 100644
--- a/src/cairo-win32-printing-surface.c
+++ b/src/cairo-win32-printing-surface.c
@@ -50,7 +50,7 @@
 
 #include "cairo-clip-private.h"
 #include "cairo-win32-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 #include "cairo-scaled-font-subsets-private.h"
 #include "cairo-image-info-private.h"
 #include "cairo-surface-clipper-private.h"
@@ -195,7 +195,7 @@ analyze_surface_pattern_transparency (cairo_surface_pattern_t *pattern)
 static cairo_bool_t
 surface_pattern_supported (const cairo_surface_pattern_t *pattern)
 {
-    if (_cairo_surface_is_meta (pattern->surface))
+    if (_cairo_surface_is_recording (pattern->surface))
 	return TRUE;
 
     if (cairo_surface_get_type (pattern->surface) != CAIRO_SURFACE_TYPE_WIN32 &&
@@ -238,8 +238,8 @@ _cairo_win32_printing_surface_analyze_operation (cairo_win32_surface_t *surface,
     if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
 	cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
 
-	if ( _cairo_surface_is_meta (surface_pattern->surface))
-	    return CAIRO_INT_STATUS_ANALYZE_META_SURFACE_PATTERN;
+	if ( _cairo_surface_is_recording (surface_pattern->surface))
+	    return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
     }
 
     if (op == CAIRO_OPERATOR_SOURCE ||
@@ -384,20 +384,20 @@ _cairo_win32_printing_surface_paint_solid_pattern (cairo_win32_surface_t *surfac
 }
 
 static cairo_status_t
-_cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surface,
-						  cairo_surface_pattern_t *pattern)
+_cairo_win32_printing_surface_paint_recording_pattern (cairo_win32_surface_t   *surface,
+						       cairo_surface_pattern_t *pattern)
 {
     cairo_content_t old_content;
     cairo_matrix_t old_ctm;
     cairo_bool_t old_has_ctm;
-    cairo_rectangle_int_t meta_extents;
+    cairo_rectangle_int_t recording_extents;
     cairo_status_t status;
     cairo_extend_t extend;
     cairo_matrix_t p2d;
     XFORM xform;
     int x_tile, y_tile, left, right, top, bottom;
     RECT clip;
-    cairo_meta_surface_t *meta_surface = (cairo_meta_surface_t *) pattern->surface;
+    cairo_recording_surface_t *recording_surface = (cairo_recording_surface_t *) pattern->surface;
     cairo_box_t bbox;
 
     extend = cairo_pattern_get_extend (&pattern->base);
@@ -414,11 +414,11 @@ _cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surfa
     SaveDC (surface->dc);
     _cairo_matrix_to_win32_xform (&p2d, &xform);
 
-    status = _cairo_meta_surface_get_bbox (meta_surface, &bbox, NULL);
+    status = _cairo_recording_surface_get_bbox (recording_surface, &bbox, NULL);
     if (status)
 	return status;
 
-    _cairo_box_round_to_rectangle (&bbox, &meta_extents);
+    _cairo_box_round_to_rectangle (&bbox, &recording_extents);
 
     status = _cairo_win32_printing_surface_get_ctm_clip_box (surface, &clip);
     if (status)
@@ -437,7 +437,7 @@ _cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surfa
     }
 
     old_content = surface->content;
-    if (meta_surface->base.content == CAIRO_CONTENT_COLOR) {
+    if (recording_surface->base.content == CAIRO_CONTENT_COLOR) {
 	cairo_pattern_t  *source;
 	cairo_solid_pattern_t black;
 
@@ -457,15 +457,15 @@ _cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surfa
 	    SaveDC (surface->dc);
 	    m = p2d;
 	    cairo_matrix_translate (&m,
-				    x_tile*meta_extents.width,
-				    y_tile*meta_extents.height);
+				    x_tile*recording_extents.width,
+				    y_tile*recording_extents.height);
 	    if (extend == CAIRO_EXTEND_REFLECT) {
 		if (x_tile % 2) {
-		    cairo_matrix_translate (&m, meta_extents.width, 0);
+		    cairo_matrix_translate (&m, recording_extents.width, 0);
 		    cairo_matrix_scale (&m, -1, 1);
 		}
 		if (y_tile % 2) {
-		    cairo_matrix_translate (&m, 0, meta_extents.height);
+		    cairo_matrix_translate (&m, 0, recording_extents.height);
 		    cairo_matrix_scale (&m, 1, -1);
 		}
 	    }
@@ -480,18 +480,18 @@ _cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surfa
 	    cairo_matrix_transform_point (&surface->ctm, &x, &y);
 	    MoveToEx (surface->dc, (int) x, (int) y, NULL);
 
-	    x = meta_extents.width;
+	    x = recording_extents.width;
 	    y = 0;
 	    cairo_matrix_transform_point (&surface->ctm, &x, &y);
 	    LineTo (surface->dc, (int) x, (int) y);
 
-	    x = meta_extents.width;
-	    y = meta_extents.height;
+	    x = recording_extents.width;
+	    y = recording_extents.height;
 	    cairo_matrix_transform_point (&surface->ctm, &x, &y);
 	    LineTo (surface->dc, (int) x, (int) y);
 
 	    x = 0;
-	    y = meta_extents.height;
+	    y = recording_extents.height;
 	    cairo_matrix_transform_point (&surface->ctm, &x, &y);
 	    LineTo (surface->dc, (int) x, (int) y);
 
@@ -500,9 +500,9 @@ _cairo_win32_printing_surface_paint_meta_pattern (cairo_win32_surface_t   *surfa
 	    SelectClipPath (surface->dc, RGN_AND);
 
 	    SaveDC (surface->dc); /* Allow clip path to be reset during replay */
-	    status = _cairo_meta_surface_replay_region (&meta_surface->base,
-							&surface->base,
-							CAIRO_META_REGION_NATIVE);
+	    status = _cairo_recording_surface_replay_region (&recording_surface->base,
+							     &surface->base,
+							     CAIRO_RECORDING_REGION_NATIVE);
 	    assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
 	    /* Restore both the clip save and our earlier path SaveDC */
 	    RestoreDC (surface->dc, -2);
@@ -781,9 +781,9 @@ static cairo_status_t
 _cairo_win32_printing_surface_paint_surface_pattern (cairo_win32_surface_t   *surface,
                                                      cairo_surface_pattern_t *pattern)
 {
-    if (_cairo_surface_is_meta (pattern->surface)) {
-	return _cairo_win32_printing_surface_paint_meta_pattern (surface,
-								 pattern);
+    if (_cairo_surface_is_recording (pattern->surface)) {
+	return _cairo_win32_printing_surface_paint_recording_pattern (surface,
+								      pattern);
     } else {
 	return _cairo_win32_printing_surface_paint_image_pattern (surface,
 								  pattern);
@@ -1634,7 +1634,7 @@ _cairo_win32_printing_surface_create_similar (void		*abstract_surface,
     extents.x = extents.y = 0;
     extents.width  = width;
     extents.height = height;
-    return cairo_meta_surface_create (content, &extents);
+    return cairo_recording_surface_create (content, &extents);
 }
 
 static cairo_int_status_t
@@ -1650,16 +1650,16 @@ _cairo_win32_printing_surface_start_page (void *abstract_surface)
 
     /* As the logical coordinates used by GDI functions (eg LineTo)
      * are integers we need to do some additional work to prevent
-     * rounding errors. For example the obvious way to paint a meta
+     * rounding errors. For example the obvious way to paint a recording
      * pattern is to:
      *
      *   SaveDC()
      *   transform the device context DC by the pattern to device matrix
-     *   replay the meta surface
+     *   replay the recording surface
      *   RestoreDC()
      *
      * The problem here is that if the pattern to device matrix is
-     * [100 0 0 100 0 0], coordinates in the meta pattern such as
+     * [100 0 0 100 0 0], coordinates in the recording pattern such as
      * (1.56, 2.23) which correspond to (156, 223) in device space
      * will be rounded to (100, 200) due to (1.56, 2.23) being
      * truncated to integers.
@@ -1667,7 +1667,7 @@ _cairo_win32_printing_surface_start_page (void *abstract_surface)
      * This is solved by saving the current GDI CTM in surface->ctm,
      * switch the GDI CTM to identity, and transforming all
      * coordinates by surface->ctm before passing them to GDI. When
-     * painting a meta pattern, surface->ctm is transformed by the
+     * painting a recording pattern, surface->ctm is transformed by the
      * pattern to device matrix.
      *
      * For printing device contexts where 1 unit is 1 dpi, switching
diff --git a/src/cairo-xml-surface.c b/src/cairo-xml-surface.c
index c40f61fc..25e0bb22 100644
--- a/src/cairo-xml-surface.c
+++ b/src/cairo-xml-surface.c
@@ -46,7 +46,7 @@
 
 #include "cairo-clip-private.h"
 #include "cairo-output-stream-private.h"
-#include "cairo-meta-surface-private.h"
+#include "cairo-recording-surface-private.h"
 
 #define static cairo_warn static
 
@@ -69,7 +69,7 @@ struct _cairo_xml_surface {
     double width, height;
 };
 
-slim_hidden_proto (cairo_xml_for_meta_surface);
+slim_hidden_proto (cairo_xml_for_recording_surface);
 
 static const cairo_xml_t _nil_xml = {
     CAIRO_STATUS_NO_MEMORY,
@@ -348,7 +348,7 @@ _cairo_xml_surface_create_similar (void			*abstract_surface,
     extents.width  = width;
     extents.height = height;
 
-    return cairo_meta_surface_create (content, &extents);
+    return cairo_recording_surface_create (content, &extents);
 }
 
 static cairo_status_t
@@ -623,8 +623,8 @@ _cairo_xml_emit_surface (cairo_xml_t *xml,
     cairo_surface_t *source = pattern->surface;
     cairo_status_t status;
 
-    if (_cairo_surface_is_meta (source)) {
-	status = cairo_xml_for_meta_surface (xml, source);
+    if (_cairo_surface_is_recording (source)) {
+	status = cairo_xml_for_recording_surface (xml, source);
     } else {
 	cairo_image_surface_t *image;
 	void *image_extra;
@@ -1094,8 +1094,8 @@ cairo_xml_surface_create (cairo_xml_t *xml,
 }
 
 cairo_status_t
-cairo_xml_for_meta_surface (cairo_xml_t *xml,
-			    cairo_surface_t *meta)
+cairo_xml_for_recording_surface (cairo_xml_t 	 *xml,
+				 cairo_surface_t *recording_surface)
 {
     cairo_box_t bbox;
     cairo_rectangle_int_t extents;
@@ -1105,20 +1105,20 @@ cairo_xml_for_meta_surface (cairo_xml_t *xml,
     if (unlikely (xml->status))
 	return xml->status;
 
-    if (unlikely (meta->status))
-	return meta->status;
+    if (unlikely (recording_surface->status))
+	return recording_surface->status;
 
-    if (unlikely (! _cairo_surface_is_meta (meta)))
+    if (unlikely (! _cairo_surface_is_recording (recording_surface)))
 	return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
 
-    status = _cairo_meta_surface_get_bbox ((cairo_meta_surface_t *) meta,
-					   &bbox, NULL);
+    status = _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
+						&bbox, NULL);
     if (unlikely (status))
 	return status;
 
     _cairo_box_round_to_rectangle (&bbox, &extents);
     surface = _cairo_xml_surface_create_internal (xml,
-						  meta->content,
+						  recording_surface->content,
 						  extents.width,
 						  extents.height);
     if (unlikely (surface->status))
@@ -1126,12 +1126,12 @@ cairo_xml_for_meta_surface (cairo_xml_t *xml,
 
     _cairo_xml_printf (xml,
 		       "<surface content='%s' width='%d' height='%d'>",
-		       _content_to_string (meta->content),
+		       _content_to_string (recording_surface->content),
 		       extents.width, extents.height);
     _cairo_xml_indent (xml, 2);
 
     cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
-    status = _cairo_meta_surface_replay (meta, surface);
+    status = _cairo_recording_surface_replay (recording_surface, surface);
     cairo_surface_destroy (surface);
 
     _cairo_xml_indent (xml, -2);
@@ -1139,7 +1139,7 @@ cairo_xml_for_meta_surface (cairo_xml_t *xml,
 
     return status;
 }
-slim_hidden_def (cairo_xml_for_meta_surface);
+slim_hidden_def (cairo_xml_for_recording_surface);
 
 void
 cairo_xml_destroy (cairo_xml_t *xml)
diff --git a/src/cairo-xml.h b/src/cairo-xml.h
index 9bd17351..bba8adc0 100644
--- a/src/cairo-xml.h
+++ b/src/cairo-xml.h
@@ -60,8 +60,8 @@ cairo_xml_surface_create (cairo_xml_t *xml,
 			  double width, double height);
 
 cairo_public cairo_status_t
-cairo_xml_for_meta_surface (cairo_xml_t *context,
-			    cairo_surface_t *meta);
+cairo_xml_for_recording_surface (cairo_xml_t *context,
+				 cairo_surface_t *surface);
 
 CAIRO_END_DECLS
 
diff --git a/src/cairo.c b/src/cairo.c
index 383dc89e..8d163145 100644
--- a/src/cairo.c
+++ b/src/cairo.c
@@ -1933,7 +1933,7 @@ cairo_stroke_to_path (cairo_t *cr)
     if (unlikely (cr->status))
 	return;
 
-    /* The code in _cairo_meta_surface_get_path has a poorman's stroke_to_path */
+    /* The code in _cairo_recording_surface_get_path has a poorman's stroke_to_path */
 
     status = _cairo_gstate_stroke_path (cr->gstate);
     if (unlikely (status))
diff --git a/src/cairo.h b/src/cairo.h
index a43eae83..8be80439 100644
--- a/src/cairo.h
+++ b/src/cairo.h
@@ -1953,7 +1953,7 @@ cairo_surface_status (cairo_surface_t *surface);
  * @CAIRO_SURFACE_TYPE_QUARTZ_IMAGE: The surface is of type quartz_image
  * @CAIRO_SURFACE_TYPE_SCRIPT: The surface is of type script, since 1.10
  * @CAIRO_SURFACE_TYPE_QT: The surface is of type Qt, since 1.10
- * @CAIRO_SURFACE_TYPE_META: The surface is a meta-type, since 1.10
+ * @CAIRO_SURFACE_TYPE_RECORDING: The surface is of type recording, since 1.10
  * @CAIRO_SURFACE_TYPE_VG: The surface is a OpenVG surface, since 1.10
  * @CAIRO_SURFACE_TYPE_GL: The surface is of type OpenGL, since 1.10
  * @CAIRO_SURFACE_TYPE_DRM: The surface is of type Direct Render Manager, since 1.10
@@ -2001,7 +2001,7 @@ typedef enum _cairo_surface_type {
     CAIRO_SURFACE_TYPE_QUARTZ_IMAGE,
     CAIRO_SURFACE_TYPE_SCRIPT,
     CAIRO_SURFACE_TYPE_QT,
-    CAIRO_SURFACE_TYPE_META,
+    CAIRO_SURFACE_TYPE_RECORDING,
     CAIRO_SURFACE_TYPE_VG,
     CAIRO_SURFACE_TYPE_GL,
     CAIRO_SURFACE_TYPE_DRM,
@@ -2185,18 +2185,18 @@ cairo_image_surface_create_from_png_stream (cairo_read_func_t	read_func,
 
 #endif
 
-/* Meta-surface functions */
+/* Recording-surface functions */
 
 cairo_public cairo_surface_t *
-cairo_meta_surface_create (cairo_content_t	content,
-			   const cairo_rectangle_t   *extents);
+cairo_recording_surface_create (cairo_content_t		 content,
+                                const cairo_rectangle_t *extents);
 
 cairo_public void
-cairo_meta_surface_ink_extents (cairo_surface_t *surface,
-				double *x0,
-				double *y0,
-				double *width,
-				double *height);
+cairo_recording_surface_ink_extents (cairo_surface_t *surface,
+                                     double *x0,
+                                     double *y0,
+                                     double *width,
+                                     double *height);
 
 /* Tee-surface functions */
 
diff --git a/src/cairoint.h b/src/cairoint.h
index c309f3db..d03fd87a 100644
--- a/src/cairoint.h
+++ b/src/cairoint.h
@@ -392,7 +392,7 @@ typedef struct _cairo_scaled_glyph {
 
     cairo_image_surface_t   *surface;		/* device-space image */
     cairo_path_fixed_t	    *path;		/* device-space outline */
-    cairo_surface_t         *meta_surface;	/* device-space meta-surface */
+    cairo_surface_t         *recording_surface;	/* device-space recording-surface */
 
     void		    *surface_private;	/* for the surface backend */
 } cairo_scaled_glyph_t;
@@ -441,7 +441,7 @@ typedef enum _cairo_scaled_glyph_info {
     CAIRO_SCALED_GLYPH_INFO_METRICS	 = (1 << 0),
     CAIRO_SCALED_GLYPH_INFO_SURFACE	 = (1 << 1),
     CAIRO_SCALED_GLYPH_INFO_PATH	 = (1 << 2),
-    CAIRO_SCALED_GLYPH_INFO_META_SURFACE = (1 << 3)
+    CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE = (1 << 3)
 } cairo_scaled_glyph_info_t;
 
 typedef struct _cairo_scaled_font_subset {
@@ -1700,9 +1700,9 @@ _cairo_scaled_glyph_set_path (cairo_scaled_glyph_t *scaled_glyph,
 			      cairo_path_fixed_t *path);
 
 cairo_private void
-_cairo_scaled_glyph_set_meta_surface (cairo_scaled_glyph_t *scaled_glyph,
-				      cairo_scaled_font_t *scaled_font,
-				      cairo_surface_t *meta_surface);
+_cairo_scaled_glyph_set_recording_surface (cairo_scaled_glyph_t *scaled_glyph,
+                                           cairo_scaled_font_t *scaled_font,
+                                           cairo_surface_t *recording_surface);
 
 cairo_private cairo_int_status_t
 _cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font,
@@ -2210,7 +2210,7 @@ cairo_private cairo_bool_t
 _cairo_surface_is_image (const cairo_surface_t *surface) cairo_pure;
 
 cairo_private cairo_bool_t
-_cairo_surface_is_meta (const cairo_surface_t *surface) cairo_pure;
+_cairo_surface_is_recording (const cairo_surface_t *surface) cairo_pure;
 
 /* cairo-pen.c */
 cairo_private cairo_status_t