summaryrefslogtreecommitdiffstats
path: root/gfx/thebes/gfxXlibNativeRenderer.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/thebes/gfxXlibNativeRenderer.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/thebes/gfxXlibNativeRenderer.cpp')
-rw-r--r--gfx/thebes/gfxXlibNativeRenderer.cpp620
1 files changed, 620 insertions, 0 deletions
diff --git a/gfx/thebes/gfxXlibNativeRenderer.cpp b/gfx/thebes/gfxXlibNativeRenderer.cpp
new file mode 100644
index 000000000..19213b4e7
--- /dev/null
+++ b/gfx/thebes/gfxXlibNativeRenderer.cpp
@@ -0,0 +1,620 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "gfxXlibNativeRenderer.h"
+
+#include "gfxXlibSurface.h"
+#include "gfxImageSurface.h"
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+#include "gfxAlphaRecovery.h"
+#include "cairo-xlib.h"
+#include "cairo-xlib-xrender.h"
+#include "mozilla/gfx/BorrowedContext.h"
+#include "mozilla/gfx/HelpersCairo.h"
+#include "gfx2DGlue.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+#if 0
+#include <stdio.h>
+#define NATIVE_DRAWING_NOTE(m) fprintf(stderr, m)
+#else
+#define NATIVE_DRAWING_NOTE(m) do {} while (0)
+#endif
+
+/* We have four basic strategies available:
+
+ 1) 'direct': If the target is an xlib surface, and other conditions are met,
+ we can pass the underlying drawable directly to the callback.
+
+ 2) 'simple': If the drawing is opaque, or we can draw to a surface with an
+ alpha channel, then we can create a temporary xlib surface, pass its
+ underlying drawable to the callback, and composite the result using
+ cairo.
+
+ 3) 'copy-background': If the drawing is not opaque but the target is
+ opaque, and we can draw to a surface with format such that pixel
+ conversion to and from the target format is exact, we can create a
+ temporary xlib surface, copy the background from the target, pass the
+ underlying drawable to the callback, and copy back to the target.
+
+ This strategy is not used if the pixel format conversion is not exact,
+ because that would mean that drawing intended to be very transparent
+ messes with other content.
+
+ The strategy is prefered over simple for non-opaque drawing and opaque
+ targets on the same screen as compositing without alpha is a simpler
+ operation.
+
+ 4) 'alpha-extraction': create a temporary xlib surface, fill with black,
+ pass its underlying drawable to the callback, copy the results to a
+ cairo image surface, repeat with a white background, update the on-black
+ image alpha values by comparing the two images, then paint the on-black
+ image using cairo.
+
+ Sure would be nice to have an X extension or GL to do this for us on the
+ server...
+*/
+
+static cairo_bool_t
+_convert_coord_to_int (double coord, int32_t *v)
+{
+ *v = (int32_t)coord;
+ /* XXX allow some tolerance here? */
+ return *v == coord;
+}
+
+static bool
+_get_rectangular_clip (cairo_t *cr,
+ const IntRect& bounds,
+ bool *need_clip,
+ IntRect *rectangles, int max_rectangles,
+ int *num_rectangles)
+{
+ cairo_rectangle_list_t *cliplist;
+ cairo_rectangle_t *clips;
+ int i;
+ bool retval = true;
+
+ cliplist = cairo_copy_clip_rectangle_list (cr);
+ if (cliplist->status != CAIRO_STATUS_SUCCESS) {
+ retval = false;
+ NATIVE_DRAWING_NOTE("FALLBACK: non-rectangular clip");
+ goto FINISH;
+ }
+
+ /* the clip is always in surface backend coordinates (i.e. native backend coords) */
+ clips = cliplist->rectangles;
+
+ for (i = 0; i < cliplist->num_rectangles; ++i) {
+
+ IntRect rect;
+ if (!_convert_coord_to_int (clips[i].x, &rect.x) ||
+ !_convert_coord_to_int (clips[i].y, &rect.y) ||
+ !_convert_coord_to_int (clips[i].width, &rect.width) ||
+ !_convert_coord_to_int (clips[i].height, &rect.height))
+ {
+ retval = false;
+ NATIVE_DRAWING_NOTE("FALLBACK: non-integer clip");
+ goto FINISH;
+ }
+
+ if (rect.IsEqualInterior(bounds)) {
+ /* the bounds are entirely inside the clip region so we don't need to clip. */
+ *need_clip = false;
+ goto FINISH;
+ }
+
+ NS_ASSERTION(bounds.Contains(rect),
+ "Was expecting to be clipped to bounds");
+
+ if (i >= max_rectangles) {
+ retval = false;
+ NATIVE_DRAWING_NOTE("FALLBACK: unsupported clip rectangle count");
+ goto FINISH;
+ }
+
+ rectangles[i] = rect;
+ }
+
+ *need_clip = true;
+ *num_rectangles = cliplist->num_rectangles;
+
+FINISH:
+ cairo_rectangle_list_destroy (cliplist);
+
+ return retval;
+}
+
+#define MAX_STATIC_CLIP_RECTANGLES 50
+
+/**
+ * Try the direct path.
+ * @return True if we took the direct path
+ */
+bool
+gfxXlibNativeRenderer::DrawDirect(DrawTarget* aDT, IntSize size,
+ uint32_t flags,
+ Screen *screen, Visual *visual)
+{
+ // We need to actually borrow the context because we want to read out the
+ // clip rectangles.
+ BorrowedCairoContext borrowed(aDT);
+ if (!borrowed.mCairo) {
+ return false;
+ }
+
+ bool direct = DrawCairo(borrowed.mCairo, size, flags, screen, visual);
+ borrowed.Finish();
+
+ return direct;
+}
+
+bool
+gfxXlibNativeRenderer::DrawCairo(cairo_t* cr, IntSize size,
+ uint32_t flags,
+ Screen *screen, Visual *visual)
+{
+ /* Check that the target surface is an xlib surface. */
+ cairo_surface_t *target = cairo_get_group_target (cr);
+ if (cairo_surface_get_type (target) != CAIRO_SURFACE_TYPE_XLIB) {
+ NATIVE_DRAWING_NOTE("FALLBACK: non-X surface");
+ return false;
+ }
+
+ cairo_matrix_t matrix;
+ cairo_get_matrix (cr, &matrix);
+ double device_offset_x, device_offset_y;
+ cairo_surface_get_device_offset (target, &device_offset_x, &device_offset_y);
+
+ /* Draw() checked that the matrix contained only a very-close-to-integer
+ translation. Here (and in several other places and thebes) device
+ offsets are assumed to be integer. */
+ NS_ASSERTION(int32_t(device_offset_x) == device_offset_x &&
+ int32_t(device_offset_y) == device_offset_y,
+ "Expected integer device offsets");
+ IntPoint offset(NS_lroundf(matrix.x0 + device_offset_x),
+ NS_lroundf(matrix.y0 + device_offset_y));
+
+ int max_rectangles = 0;
+ if (flags & DRAW_SUPPORTS_CLIP_RECT) {
+ max_rectangles = 1;
+ }
+ if (flags & DRAW_SUPPORTS_CLIP_LIST) {
+ max_rectangles = MAX_STATIC_CLIP_RECTANGLES;
+ }
+
+ /* The client won't draw outside the surface so consider this when
+ analysing clip rectangles. */
+ IntRect bounds(offset, size);
+ bounds.IntersectRect(bounds,
+ IntRect(0, 0,
+ cairo_xlib_surface_get_width(target),
+ cairo_xlib_surface_get_height(target)));
+
+ bool needs_clip = true;
+ IntRect rectangles[MAX_STATIC_CLIP_RECTANGLES];
+ int rect_count = 0;
+
+ /* Check that the clip is rectangular and aligned on unit boundaries. */
+ /* Temporarily set the matrix for _get_rectangular_clip. It's basically
+ the identity matrix, but we must adjust for the fact that our
+ offset-rect is in device coordinates. */
+ cairo_identity_matrix (cr);
+ cairo_translate (cr, -device_offset_x, -device_offset_y);
+ bool have_rectangular_clip =
+ _get_rectangular_clip (cr, bounds, &needs_clip,
+ rectangles, max_rectangles, &rect_count);
+ cairo_set_matrix (cr, &matrix);
+ if (!have_rectangular_clip)
+ return false;
+
+ /* Stop now if everything is clipped out */
+ if (needs_clip && rect_count == 0)
+ return true;
+
+ /* Check that the screen is supported.
+ Visuals belong to screens, so, if alternate visuals are not supported,
+ then alternate screens cannot be supported. */
+ bool supports_alternate_visual =
+ (flags & DRAW_SUPPORTS_ALTERNATE_VISUAL) != 0;
+ bool supports_alternate_screen = supports_alternate_visual &&
+ (flags & DRAW_SUPPORTS_ALTERNATE_SCREEN);
+ if (!supports_alternate_screen &&
+ cairo_xlib_surface_get_screen (target) != screen) {
+ NATIVE_DRAWING_NOTE("FALLBACK: non-default screen");
+ return false;
+ }
+
+ /* Check that there is a visual */
+ Visual *target_visual = cairo_xlib_surface_get_visual (target);
+ if (!target_visual) {
+ NATIVE_DRAWING_NOTE("FALLBACK: no Visual for surface");
+ return false;
+ }
+ /* Check that the visual is supported */
+ if (!supports_alternate_visual && target_visual != visual) {
+ // Only the format of the visual is important (not the GLX properties)
+ // for Xlib or XRender drawing.
+ XRenderPictFormat *target_format =
+ cairo_xlib_surface_get_xrender_format (target);
+ if (!target_format ||
+ (target_format !=
+ XRenderFindVisualFormat (DisplayOfScreen(screen), visual))) {
+ NATIVE_DRAWING_NOTE("FALLBACK: unsupported Visual");
+ return false;
+ }
+ }
+
+ /* we're good to go! */
+ NATIVE_DRAWING_NOTE("TAKING FAST PATH\n");
+ cairo_surface_flush (target);
+ nsresult rv = DrawWithXlib(target,
+ offset, rectangles,
+ needs_clip ? rect_count : 0);
+ if (NS_SUCCEEDED(rv)) {
+ cairo_surface_mark_dirty (target);
+ return true;
+ }
+ return false;
+}
+
+static bool
+VisualHasAlpha(Screen *screen, Visual *visual) {
+ // There may be some other visuals format with alpha but usually this is
+ // the only one we care about.
+ return visual->c_class == TrueColor &&
+ visual->bits_per_rgb == 8 &&
+ visual->red_mask == 0xff0000 &&
+ visual->green_mask == 0xff00 &&
+ visual->blue_mask == 0xff &&
+ gfxXlibSurface::DepthOfVisual(screen, visual) == 32;
+}
+
+// Returns whether pixel conversion between visual and format is exact (in
+// both directions).
+static bool
+FormatConversionIsExact(Screen *screen, Visual *visual, XRenderPictFormat *format) {
+ if (!format ||
+ visual->c_class != TrueColor ||
+ format->type != PictTypeDirect ||
+ gfxXlibSurface::DepthOfVisual(screen, visual) != format->depth)
+ return false;
+
+ XRenderPictFormat *visualFormat =
+ XRenderFindVisualFormat(DisplayOfScreen(screen), visual);
+
+ if (visualFormat->type != PictTypeDirect )
+ return false;
+
+ const XRenderDirectFormat& a = visualFormat->direct;
+ const XRenderDirectFormat& b = format->direct;
+ return a.redMask == b.redMask &&
+ a.greenMask == b.greenMask &&
+ a.blueMask == b.blueMask;
+}
+
+// The 3 non-direct strategies described above.
+// The surface format and strategy are inter-dependent.
+enum DrawingMethod {
+ eSimple,
+ eCopyBackground,
+ eAlphaExtraction
+};
+
+static cairo_surface_t*
+CreateTempXlibSurface (cairo_surface_t* cairoTarget,
+ DrawTarget* drawTarget,
+ IntSize size,
+ bool canDrawOverBackground,
+ uint32_t flags, Screen *screen, Visual *visual,
+ DrawingMethod *method)
+{
+ NS_ASSERTION(cairoTarget || drawTarget, "Must have some type");
+
+ bool drawIsOpaque = (flags & gfxXlibNativeRenderer::DRAW_IS_OPAQUE) != 0;
+ bool supportsAlternateVisual =
+ (flags & gfxXlibNativeRenderer::DRAW_SUPPORTS_ALTERNATE_VISUAL) != 0;
+ bool supportsAlternateScreen = supportsAlternateVisual &&
+ (flags & gfxXlibNativeRenderer::DRAW_SUPPORTS_ALTERNATE_SCREEN);
+
+ cairo_surface_type_t cairoTargetType =
+ cairoTarget ? cairo_surface_get_type (cairoTarget) : (cairo_surface_type_t)0xFF;
+
+ Screen *target_screen = cairoTargetType == CAIRO_SURFACE_TYPE_XLIB ?
+ cairo_xlib_surface_get_screen (cairoTarget) : screen;
+
+ // When the background has an alpha channel, we need to draw with an alpha
+ // channel anyway, so there is no need to copy the background. If
+ // doCopyBackground is set here, we'll also need to check below that the
+ // background can copied without any loss in format conversions.
+ bool doCopyBackground = !drawIsOpaque && canDrawOverBackground &&
+ cairoTarget && cairo_surface_get_content (cairoTarget) == CAIRO_CONTENT_COLOR;
+
+ if (supportsAlternateScreen && screen != target_screen && drawIsOpaque) {
+ // Prefer a visual on the target screen.
+ // (If !drawIsOpaque, we'll need doCopyBackground or an alpha channel.)
+ visual = DefaultVisualOfScreen(target_screen);
+ screen = target_screen;
+
+ } else if (doCopyBackground || (supportsAlternateVisual && drawIsOpaque)) {
+ // Analyse the pixel formats either to check whether we can
+ // doCopyBackground or to see if we can find a better visual for
+ // opaque drawing.
+ Visual *target_visual = nullptr;
+ XRenderPictFormat *target_format = nullptr;
+ if (cairoTargetType == CAIRO_SURFACE_TYPE_XLIB) {
+ target_visual = cairo_xlib_surface_get_visual (cairoTarget);
+ target_format = cairo_xlib_surface_get_xrender_format (cairoTarget);
+ } else if (cairoTargetType == CAIRO_SURFACE_TYPE_IMAGE || drawTarget) {
+ gfxImageFormat imageFormat =
+ drawTarget ? SurfaceFormatToImageFormat(drawTarget->GetFormat()) :
+ CairoFormatToGfxFormat(cairo_image_surface_get_format(cairoTarget));
+ target_visual = gfxXlibSurface::FindVisual(screen, imageFormat);
+ Display *dpy = DisplayOfScreen(screen);
+ if (target_visual) {
+ target_format = XRenderFindVisualFormat(dpy, target_visual);
+ } else {
+ target_format =
+ gfxXlibSurface::FindRenderFormat(dpy, imageFormat);
+ }
+ }
+
+ if (supportsAlternateVisual &&
+ (supportsAlternateScreen || screen == target_screen)) {
+ if (target_visual) {
+ visual = target_visual;
+ screen = target_screen;
+ }
+ }
+ // Could try harder to match formats across screens for background
+ // copying when !supportsAlternateScreen, if we cared. Preferably
+ // we'll find a visual below with an alpha channel anyway; if so, the
+ // background won't need to be copied.
+
+ if (doCopyBackground && visual != target_visual &&
+ !FormatConversionIsExact(screen, visual, target_format)) {
+ doCopyBackground = false;
+ }
+ }
+
+ if (supportsAlternateVisual && !drawIsOpaque &&
+ (screen != target_screen ||
+ !(doCopyBackground || VisualHasAlpha(screen, visual)))) {
+ // Try to find a visual with an alpha channel.
+ Screen *visualScreen =
+ supportsAlternateScreen ? target_screen : screen;
+ Visual *argbVisual =
+ gfxXlibSurface::FindVisual(visualScreen,
+ SurfaceFormat::A8R8G8B8_UINT32);
+ if (argbVisual) {
+ visual = argbVisual;
+ screen = visualScreen;
+ } else if (!doCopyBackground &&
+ gfxXlibSurface::DepthOfVisual(screen, visual) != 24) {
+ // Will need to do alpha extraction; prefer a 24-bit visual.
+ // No advantage in using the target screen.
+ Visual *rgb24Visual =
+ gfxXlibSurface::FindVisual(screen,
+ SurfaceFormat::X8R8G8B8_UINT32);
+ if (rgb24Visual) {
+ visual = rgb24Visual;
+ }
+ }
+ }
+
+ Drawable drawable =
+ (screen == target_screen && cairoTargetType == CAIRO_SURFACE_TYPE_XLIB) ?
+ cairo_xlib_surface_get_drawable (cairoTarget) : RootWindowOfScreen(screen);
+
+ cairo_surface_t *surface =
+ gfxXlibSurface::CreateCairoSurface(screen, visual,
+ IntSize(size.width, size.height),
+ drawable);
+ if (!surface) {
+ return nullptr;
+ }
+
+ if (drawIsOpaque ||
+ cairo_surface_get_content(surface) == CAIRO_CONTENT_COLOR_ALPHA) {
+ NATIVE_DRAWING_NOTE(drawIsOpaque ?
+ ", SIMPLE OPAQUE\n" : ", SIMPLE WITH ALPHA");
+ *method = eSimple;
+ } else if (doCopyBackground) {
+ NATIVE_DRAWING_NOTE(", COPY BACKGROUND\n");
+ *method = eCopyBackground;
+ } else {
+ NATIVE_DRAWING_NOTE(", SLOW ALPHA EXTRACTION\n");
+ *method = eAlphaExtraction;
+ }
+
+ return surface;
+}
+
+bool
+gfxXlibNativeRenderer::DrawOntoTempSurface(cairo_surface_t *tempXlibSurface,
+ IntPoint offset)
+{
+ cairo_surface_flush(tempXlibSurface);
+ /* no clipping is needed because the callback can't draw outside the native
+ surface anyway */
+ nsresult rv = DrawWithXlib(tempXlibSurface, offset, nullptr, 0);
+ cairo_surface_mark_dirty(tempXlibSurface);
+ return NS_SUCCEEDED(rv);
+}
+
+static already_AddRefed<gfxImageSurface>
+CopyXlibSurfaceToImage(cairo_surface_t *tempXlibSurface,
+ IntSize size,
+ gfxImageFormat format)
+{
+ RefPtr<gfxImageSurface> result = new gfxImageSurface(size, format);
+
+ cairo_t* copyCtx = cairo_create(result->CairoSurface());
+ cairo_set_source_surface(copyCtx, tempXlibSurface, 0, 0);
+ cairo_set_operator(copyCtx, CAIRO_OPERATOR_SOURCE);
+ cairo_paint(copyCtx);
+ cairo_destroy(copyCtx);
+
+ return result.forget();
+}
+
+void
+gfxXlibNativeRenderer::Draw(gfxContext* ctx, IntSize size,
+ uint32_t flags, Screen *screen, Visual *visual)
+{
+ gfxMatrix matrix = ctx->CurrentMatrix();
+
+ // We can only draw direct or onto a copied background if pixels align and
+ // native drawing is compatible with the current operator. (The matrix is
+ // actually also pixel-exact for flips and right-angle rotations, which
+ // would permit copying the background but not drawing direct.)
+ bool matrixIsIntegerTranslation = !matrix.HasNonIntegerTranslation();
+ bool canDrawOverBackground = matrixIsIntegerTranslation &&
+ ctx->CurrentOp() == CompositionOp::OP_OVER;
+
+ // The padding of 0.5 for non-pixel-exact transformations used here is
+ // the same as what _cairo_pattern_analyze_filter uses.
+ const gfxFloat filterRadius = 0.5;
+ gfxRect affectedRect(0.0, 0.0, size.width, size.height);
+ if (!matrixIsIntegerTranslation) {
+ // The filter footprint means that the affected rectangle is a
+ // little larger than the drawingRect;
+ affectedRect.Inflate(filterRadius);
+
+ NATIVE_DRAWING_NOTE("FALLBACK: matrix not integer translation");
+ } else if (!canDrawOverBackground) {
+ NATIVE_DRAWING_NOTE("FALLBACK: unsupported operator");
+ }
+
+ DrawTarget* drawTarget = ctx->GetDrawTarget();
+ if (!drawTarget) {
+ gfxCriticalError() << "gfxContext without a DrawTarget";
+ return;
+ }
+
+ // Clipping to the region affected by drawing allows us to consider only
+ // the portions of the clip region that will be affected by drawing.
+ gfxRect clipExtents;
+ {
+ gfxContextAutoSaveRestore autoSR(ctx);
+ ctx->Clip(affectedRect);
+
+ clipExtents = ctx->GetClipExtents();
+ if (clipExtents.IsEmpty()) {
+ return; // nothing to do
+ }
+ if (canDrawOverBackground &&
+ DrawDirect(drawTarget, size, flags, screen, visual)) {
+ return;
+ }
+ }
+
+ IntRect drawingRect(IntPoint(0, 0), size);
+ // Drawing need only be performed within the clip extents
+ // (and padding for the filter).
+ if (!matrixIsIntegerTranslation) {
+ // The source surface may need to be a little larger than the clip
+ // extents due to the filter footprint.
+ clipExtents.Inflate(filterRadius);
+ }
+ clipExtents.RoundOut();
+
+ IntRect intExtents(int32_t(clipExtents.X()),
+ int32_t(clipExtents.Y()),
+ int32_t(clipExtents.Width()),
+ int32_t(clipExtents.Height()));
+ drawingRect.IntersectRect(drawingRect, intExtents);
+
+ gfxPoint offset(drawingRect.x, drawingRect.y);
+
+ DrawingMethod method;
+ Matrix dtTransform = drawTarget->GetTransform();
+ gfxPoint deviceTranslation = gfxPoint(dtTransform._31, dtTransform._32);
+ cairo_t* cairo = static_cast<cairo_t*>
+ (drawTarget->GetNativeSurface(NativeSurfaceType::CAIRO_CONTEXT));
+ cairo_surface_t* cairoTarget = cairo ? cairo_get_group_target(cairo) : nullptr;
+ cairo_surface_t* tempXlibSurface =
+ CreateTempXlibSurface(cairoTarget, drawTarget, size,
+ canDrawOverBackground, flags, screen, visual,
+ &method);
+ if (!tempXlibSurface) {
+ return;
+ }
+
+ bool drawIsOpaque = (flags & DRAW_IS_OPAQUE) != 0;
+ if (!drawIsOpaque) {
+ cairo_t* tmpCtx = cairo_create(tempXlibSurface);
+ if (method == eCopyBackground) {
+ NS_ASSERTION(cairoTarget, "eCopyBackground only used when there's a cairoTarget");
+ cairo_set_operator(tmpCtx, CAIRO_OPERATOR_SOURCE);
+ gfxPoint pt = -(offset + deviceTranslation);
+ cairo_set_source_surface(tmpCtx, cairoTarget, pt.x, pt.y);
+ // The copy from the tempXlibSurface to the target context should
+ // use operator SOURCE, but that would need a mask to bound the
+ // operation. Here we only copy opaque backgrounds so operator
+ // OVER will behave like SOURCE masked by the surface.
+ NS_ASSERTION(cairo_surface_get_content(tempXlibSurface) == CAIRO_CONTENT_COLOR,
+ "Don't copy background with a transparent surface");
+ } else {
+ cairo_set_operator(tmpCtx, CAIRO_OPERATOR_CLEAR);
+ }
+ cairo_paint(tmpCtx);
+ cairo_destroy(tmpCtx);
+ }
+
+ if (!DrawOntoTempSurface(tempXlibSurface, -drawingRect.TopLeft())) {
+ cairo_surface_destroy(tempXlibSurface);
+ return;
+ }
+
+ SurfaceFormat moz2DFormat =
+ cairo_surface_get_content(tempXlibSurface) == CAIRO_CONTENT_COLOR ?
+ SurfaceFormat::B8G8R8A8 : SurfaceFormat::B8G8R8X8;
+ if (method != eAlphaExtraction) {
+ RefPtr<SourceSurface> sourceSurface =
+ Factory::CreateSourceSurfaceForCairoSurface(tempXlibSurface, size, moz2DFormat);
+ if (sourceSurface) {
+ drawTarget->DrawSurface(sourceSurface,
+ Rect(offset.x, offset.y, size.width, size.height),
+ Rect(0, 0, size.width, size.height));
+ }
+ cairo_surface_destroy(tempXlibSurface);
+ return;
+ }
+
+ RefPtr<gfxImageSurface> blackImage =
+ CopyXlibSurfaceToImage(tempXlibSurface, size, SurfaceFormat::A8R8G8B8_UINT32);
+
+ cairo_t* tmpCtx = cairo_create(tempXlibSurface);
+ cairo_set_source_rgba(tmpCtx, 1.0, 1.0, 1.0, 1.0);
+ cairo_set_operator(tmpCtx, CAIRO_OPERATOR_SOURCE);
+ cairo_paint(tmpCtx);
+ cairo_destroy(tmpCtx);
+ DrawOntoTempSurface(tempXlibSurface, -drawingRect.TopLeft());
+ RefPtr<gfxImageSurface> whiteImage =
+ CopyXlibSurfaceToImage(tempXlibSurface, size, SurfaceFormat::X8R8G8B8_UINT32);
+
+ if (blackImage->CairoStatus() == CAIRO_STATUS_SUCCESS &&
+ whiteImage->CairoStatus() == CAIRO_STATUS_SUCCESS) {
+ if (!gfxAlphaRecovery::RecoverAlpha(blackImage, whiteImage)) {
+ cairo_surface_destroy(tempXlibSurface);
+ return;
+ }
+
+ gfxASurface* paintSurface = blackImage;
+ RefPtr<SourceSurface> sourceSurface =
+ Factory::CreateSourceSurfaceForCairoSurface(paintSurface->CairoSurface(),
+ size, moz2DFormat);
+ if (sourceSurface) {
+ drawTarget->DrawSurface(sourceSurface,
+ Rect(offset.x, offset.y, size.width, size.height),
+ Rect(0, 0, size.width, size.height));
+ }
+ }
+ cairo_surface_destroy(tempXlibSurface);
+}