Add m-esr52 at 52.6.0

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);
+}