gfx/2d/DrawTargetCairo.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "DrawTargetCairo.h"

#include "SourceSurfaceCairo.h"
#include "PathCairo.h"
#include "HelpersCairo.h"
#include "BorrowedContext.h"
#include "FilterNodeSoftware.h"
#include "mozilla/Scoped.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Vector.h"
#include "mozilla/StaticPrefs_print.h"

#include "cairo.h"
#include "cairo-tee.h"
#include <string.h>

#include "Blur.h"
#include "Logging.h"
#include "Tools.h"

#ifdef CAIRO_HAS_QUARTZ_SURFACE
#  include "cairo-quartz.h"
#  ifdef MOZ_WIDGET_COCOA
#    include <ApplicationServices/ApplicationServices.h>
#  endif
#endif

#ifdef CAIRO_HAS_XLIB_SURFACE
#  include "cairo-xlib.h"
#  include "cairo-xlib-xrender.h"
#endif

#ifdef CAIRO_HAS_WIN32_SURFACE
#  include "cairo-win32.h"
#endif

#define PIXMAN_DONT_DEFINE_STDINT
#include "pixman.h"

#include <algorithm>

// 2^23
#define CAIRO_COORD_MAX (Float(0x7fffff))

namespace mozilla {

MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE(ScopedCairoSurface, cairo_surface_t,
                                          cairo_surface_destroy);

namespace gfx {

cairo_surface_t* DrawTargetCairo::mDummySurface;

namespace {

// An RAII class to prepare to draw a context and optional path. Saves and
// restores the context on construction/destruction.
class AutoPrepareForDrawing {
 public:
  AutoPrepareForDrawing(DrawTargetCairo* dt, cairo_t* ctx) : mCtx(ctx) {
    dt->PrepareForDrawing(ctx);
    cairo_save(mCtx);
    MOZ_ASSERT(cairo_status(mCtx) ||
               dt->GetTransform().FuzzyEquals(GetTransform()));
  }

  AutoPrepareForDrawing(DrawTargetCairo* dt, cairo_t* ctx, const Path* path)
      : mCtx(ctx) {
    dt->PrepareForDrawing(ctx, path);
    cairo_save(mCtx);
    MOZ_ASSERT(cairo_status(mCtx) ||
               dt->GetTransform().FuzzyEquals(GetTransform()));
  }

  ~AutoPrepareForDrawing() {
    cairo_restore(mCtx);
    cairo_status_t status = cairo_status(mCtx);
    if (status) {
      gfxWarning() << "DrawTargetCairo context in error state: "
                   << cairo_status_to_string(status) << "(" << status << ")";
    }
  }

 private:
#ifdef DEBUG
  Matrix GetTransform() {
    cairo_matrix_t mat;
    cairo_get_matrix(mCtx, &mat);
    return Matrix(mat.xx, mat.yx, mat.xy, mat.yy, mat.x0, mat.y0);
  }
#endif

  cairo_t* mCtx;
};

/* Clamp r to (0,0) (2^23,2^23)
 * these are to be device coordinates.
 *
 * Returns false if the rectangle is completely out of bounds,
 * true otherwise.
 *
 * This function assumes that it will be called with a rectangle being
 * drawn into a surface with an identity transformation matrix; that
 * is, anything above or to the left of (0,0) will be offscreen.
 *
 * First it checks if the rectangle is entirely beyond
 * CAIRO_COORD_MAX; if so, it can't ever appear on the screen --
 * false is returned.
 *
 * Then it shifts any rectangles with x/y < 0 so that x and y are = 0,
 * and adjusts the width and height appropriately.  For example, a
 * rectangle from (0,-5) with dimensions (5,10) will become a
 * rectangle from (0,0) with dimensions (5,5).
 *
 * If after negative x/y adjustment to 0, either the width or height
 * is negative, then the rectangle is completely offscreen, and
 * nothing is drawn -- false is returned.
 *
 * Finally, if x+width or y+height are greater than CAIRO_COORD_MAX,
 * the width and height are clamped such x+width or y+height are equal
 * to CAIRO_COORD_MAX, and true is returned.
 */
static bool ConditionRect(Rect& r) {
  // if either x or y is way out of bounds;
  // note that we don't handle negative w/h here
  if (r.X() > CAIRO_COORD_MAX || r.Y() > CAIRO_COORD_MAX) return false;

  if (r.X() < 0.f) {
    r.SetWidth(r.XMost());
    if (r.Width() < 0.f) return false;
    r.MoveToX(0.f);
  }

  if (r.XMost() > CAIRO_COORD_MAX) {
    r.SetRightEdge(CAIRO_COORD_MAX);
  }

  if (r.Y() < 0.f) {
    r.SetHeight(r.YMost());
    if (r.Height() < 0.f) return false;

    r.MoveToY(0.f);
  }

  if (r.YMost() > CAIRO_COORD_MAX) {
    r.SetBottomEdge(CAIRO_COORD_MAX);
  }
  return true;
}

}  // end anonymous namespace

static bool SupportsSelfCopy(cairo_surface_t* surface) {
  switch (cairo_surface_get_type(surface)) {
#ifdef CAIRO_HAS_QUARTZ_SURFACE
    case CAIRO_SURFACE_TYPE_QUARTZ:
      return true;
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
    case CAIRO_SURFACE_TYPE_WIN32:
    case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
      return true;
#endif
    default:
      return false;
  }
}

static bool PatternIsCompatible(const Pattern& aPattern) {
  switch (aPattern.GetType()) {
    case PatternType::LINEAR_GRADIENT: {
      const LinearGradientPattern& pattern =
          static_cast<const LinearGradientPattern&>(aPattern);
      return pattern.mStops->GetBackendType() == BackendType::CAIRO;
    }
    case PatternType::RADIAL_GRADIENT: {
      const RadialGradientPattern& pattern =
          static_cast<const RadialGradientPattern&>(aPattern);
      return pattern.mStops->GetBackendType() == BackendType::CAIRO;
    }
    case PatternType::CONIC_GRADIENT: {
      const ConicGradientPattern& pattern =
          static_cast<const ConicGradientPattern&>(aPattern);
      return pattern.mStops->GetBackendType() == BackendType::CAIRO;
    }
    default:
      return true;
  }
}

static cairo_user_data_key_t surfaceDataKey;

static void ReleaseData(void* aData) {
  DataSourceSurface* data = static_cast<DataSourceSurface*>(aData);
  data->Unmap();
  data->Release();
}

static cairo_surface_t* CopyToImageSurface(unsigned char* aData,
                                           const IntRect& aRect,
                                           int32_t aStride,
                                           SurfaceFormat aFormat) {
  MOZ_ASSERT(aData);

  auto aRectWidth = aRect.Width();
  auto aRectHeight = aRect.Height();

  cairo_surface_t* surf = cairo_image_surface_create(
      GfxFormatToCairoFormat(aFormat), aRectWidth, aRectHeight);
  // In certain scenarios, requesting larger than 8k image fails.  Bug 803568
  // covers the details of how to run into it, but the full detailed
  // investigation hasn't been done to determine the underlying cause.  We
  // will just handle the failure to allocate the surface to avoid a crash.
  if (cairo_surface_status(surf)) {
    gfxWarning() << "Invalid surface DTC " << cairo_surface_status(surf);
    return nullptr;
  }

  unsigned char* surfData = cairo_image_surface_get_data(surf);
  int surfStride = cairo_image_surface_get_stride(surf);
  int32_t pixelWidth = BytesPerPixel(aFormat);

  unsigned char* source = aData + aRect.Y() * aStride + aRect.X() * pixelWidth;

  MOZ_ASSERT(aStride >= aRectWidth * pixelWidth);
  for (int32_t y = 0; y < aRectHeight; ++y) {
    memcpy(surfData + y * surfStride, source + y * aStride,
           aRectWidth * pixelWidth);
  }
  cairo_surface_mark_dirty(surf);
  return surf;
}

/**
 * If aSurface can be represented as a surface of type
 * CAIRO_SURFACE_TYPE_IMAGE then returns that surface. Does
 * not add a reference.
 */
static cairo_surface_t* GetAsImageSurface(cairo_surface_t* aSurface) {
  if (cairo_surface_get_type(aSurface) == CAIRO_SURFACE_TYPE_IMAGE) {
    return aSurface;
#ifdef CAIRO_HAS_WIN32_SURFACE
  } else if (cairo_surface_get_type(aSurface) == CAIRO_SURFACE_TYPE_WIN32) {
    return cairo_win32_surface_get_image(aSurface);
#endif
  }

  return nullptr;
}

static cairo_surface_t* CreateSubImageForData(unsigned char* aData,
                                              const IntRect& aRect, int aStride,
                                              SurfaceFormat aFormat) {
  if (!aData) {
    gfxWarning() << "DrawTargetCairo.CreateSubImageForData null aData";
    return nullptr;
  }
  unsigned char* data =
      aData + aRect.Y() * aStride + aRect.X() * BytesPerPixel(aFormat);

  cairo_surface_t* image = cairo_image_surface_create_for_data(
      data, GfxFormatToCairoFormat(aFormat), aRect.Width(), aRect.Height(),
      aStride);
  cairo_surface_set_device_offset(image, -aRect.X(), -aRect.Y());
  return image;
}

/**
 * Returns a referenced cairo_surface_t representing the
 * sub-image specified by aSubImage.
 */
static cairo_surface_t* ExtractSubImage(cairo_surface_t* aSurface,
                                        const IntRect& aSubImage,
                                        SurfaceFormat aFormat) {
  // No need to worry about retaining a reference to the original
  // surface since the only caller of this function guarantees
  // that aSurface will stay alive as long as the result

  cairo_surface_t* image = GetAsImageSurface(aSurface);
  if (image) {
    image =
        CreateSubImageForData(cairo_image_surface_get_data(image), aSubImage,
                              cairo_image_surface_get_stride(image), aFormat);
    return image;
  }

  cairo_surface_t* similar = cairo_surface_create_similar(
      aSurface, cairo_surface_get_content(aSurface), aSubImage.Width(),
      aSubImage.Height());

  cairo_t* ctx = cairo_create(similar);
  cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
  cairo_set_source_surface(ctx, aSurface, -aSubImage.X(), -aSubImage.Y());
  cairo_paint(ctx);
  cairo_destroy(ctx);

  cairo_surface_set_device_offset(similar, -aSubImage.X(), -aSubImage.Y());
  return similar;
}

/**
 * Returns cairo surface for the given SourceSurface.
 * If possible, it will use the cairo_surface associated with aSurface,
 * otherwise, it will create a new cairo_surface.
 * In either case, the caller must call cairo_surface_destroy on the
 * result when it is done with it.
 */
static cairo_surface_t* GetCairoSurfaceForSourceSurface(
    SourceSurface* aSurface, bool aExistingOnly = false,
    const IntRect& aSubImage = IntRect()) {
  if (!aSurface) {
    return nullptr;
  }

  IntRect subimage = IntRect(IntPoint(), aSurface->GetSize());
  if (!aSubImage.IsEmpty()) {
    MOZ_ASSERT(!aExistingOnly);
    MOZ_ASSERT(subimage.Contains(aSubImage));
    subimage = aSubImage;
  }

  if (aSurface->GetType() == SurfaceType::CAIRO) {
    cairo_surface_t* surf =
        static_cast<SourceSurfaceCairo*>(aSurface)->GetSurface();
    if (aSubImage.IsEmpty()) {
      cairo_surface_reference(surf);
    } else {
      surf = ExtractSubImage(surf, subimage, aSurface->GetFormat());
    }
    return surf;
  }

  if (aSurface->GetType() == SurfaceType::CAIRO_IMAGE) {
    cairo_surface_t* surf =
        static_cast<const DataSourceSurfaceCairo*>(aSurface)->GetSurface();
    if (aSubImage.IsEmpty()) {
      cairo_surface_reference(surf);
    } else {
      surf = ExtractSubImage(surf, subimage, aSurface->GetFormat());
    }
    return surf;
  }

  if (aExistingOnly) {
    return nullptr;
  }

  RefPtr<DataSourceSurface> data = aSurface->GetDataSurface();
  if (!data) {
    return nullptr;
  }

  DataSourceSurface::MappedSurface map;
  if (!data->Map(DataSourceSurface::READ, &map)) {
    return nullptr;
  }

  cairo_surface_t* surf = CreateSubImageForData(map.mData, subimage,
                                                map.mStride, data->GetFormat());

  // In certain scenarios, requesting larger than 8k image fails.  Bug 803568
  // covers the details of how to run into it, but the full detailed
  // investigation hasn't been done to determine the underlying cause.  We
  // will just handle the failure to allocate the surface to avoid a crash.
  if (!surf || cairo_surface_status(surf)) {
    if (surf && (cairo_surface_status(surf) == CAIRO_STATUS_INVALID_STRIDE)) {
      // If we failed because of an invalid stride then copy into
      // a new surface with a stride that cairo chooses. No need to
      // set user data since we're not dependent on the original
      // data.
      cairo_surface_t* result = CopyToImageSurface(
          map.mData, subimage, map.mStride, data->GetFormat());
      data->Unmap();
      return result;
    }
    data->Unmap();
    return nullptr;
  }

  cairo_surface_set_user_data(surf, &surfaceDataKey, data.forget().take(),
                              ReleaseData);
  return surf;
}

// An RAII class to temporarily clear any device offset set
// on a surface. Note that this does not take a reference to the
// surface.
class AutoClearDeviceOffset final {
 public:
  explicit AutoClearDeviceOffset(SourceSurface* aSurface)
      : mSurface(nullptr), mX(0), mY(0) {
    Init(aSurface);
  }

  explicit AutoClearDeviceOffset(const Pattern& aPattern)
      : mSurface(nullptr), mX(0.0), mY(0.0) {
    if (aPattern.GetType() == PatternType::SURFACE) {
      const SurfacePattern& pattern =
          static_cast<const SurfacePattern&>(aPattern);
      Init(pattern.mSurface);
    }
  }

  ~AutoClearDeviceOffset() {
    if (mSurface) {
      cairo_surface_set_device_offset(mSurface, mX, mY);
    }
  }

 private:
  void Init(SourceSurface* aSurface) {
    cairo_surface_t* surface = GetCairoSurfaceForSourceSurface(aSurface, true);
    if (surface) {
      Init(surface);
      cairo_surface_destroy(surface);
    }
  }

  void Init(cairo_surface_t* aSurface) {
    mSurface = aSurface;
    cairo_surface_get_device_offset(mSurface, &mX, &mY);
    cairo_surface_set_device_offset(mSurface, 0, 0);
  }

  cairo_surface_t* mSurface;
  double mX;
  double mY;
};

static inline void CairoPatternAddGradientStop(cairo_pattern_t* aPattern,
                                               const GradientStop& aStop,
                                               Float aNudge = 0) {
  cairo_pattern_add_color_stop_rgba(aPattern, aStop.offset + aNudge,
                                    aStop.color.r, aStop.color.g, aStop.color.b,
                                    aStop.color.a);
}

// Never returns nullptr. As such, you must always pass in Cairo-compatible
// patterns, most notably gradients with a GradientStopCairo.
// The pattern returned must have cairo_pattern_destroy() called on it by the
// caller.
// As the cairo_pattern_t returned may depend on the Pattern passed in, the
// lifetime of the cairo_pattern_t returned must not exceed the lifetime of the
// Pattern passed in.
static cairo_pattern_t* GfxPatternToCairoPattern(const Pattern& aPattern,
                                                 Float aAlpha,
                                                 const Matrix& aTransform) {
  cairo_pattern_t* pat;
  const Matrix* matrix = nullptr;

  switch (aPattern.GetType()) {
    case PatternType::COLOR: {
      DeviceColor color = static_cast<const ColorPattern&>(aPattern).mColor;
      pat = cairo_pattern_create_rgba(color.r, color.g, color.b,
                                      color.a * aAlpha);
      break;
    }

    case PatternType::SURFACE: {
      const SurfacePattern& pattern =
          static_cast<const SurfacePattern&>(aPattern);
      cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(
          pattern.mSurface, false, pattern.mSamplingRect);
      if (!surf) return nullptr;

      pat = cairo_pattern_create_for_surface(surf);

      matrix = &pattern.mMatrix;

      cairo_pattern_set_filter(
          pat, GfxSamplingFilterToCairoFilter(pattern.mSamplingFilter));
      cairo_pattern_set_extend(pat,
                               GfxExtendToCairoExtend(pattern.mExtendMode));

      cairo_surface_destroy(surf);
      break;
    }
    case PatternType::LINEAR_GRADIENT: {
      const LinearGradientPattern& pattern =
          static_cast<const LinearGradientPattern&>(aPattern);

      pat = cairo_pattern_create_linear(pattern.mBegin.x, pattern.mBegin.y,
                                        pattern.mEnd.x, pattern.mEnd.y);

      MOZ_ASSERT(pattern.mStops->GetBackendType() == BackendType::CAIRO);
      GradientStopsCairo* cairoStops =
          static_cast<GradientStopsCairo*>(pattern.mStops.get());
      cairo_pattern_set_extend(
          pat, GfxExtendToCairoExtend(cairoStops->GetExtendMode()));

      matrix = &pattern.mMatrix;

      const std::vector<GradientStop>& stops = cairoStops->GetStops();
      for (size_t i = 0; i < stops.size(); ++i) {
        CairoPatternAddGradientStop(pat, stops[i]);
      }

      break;
    }
    case PatternType::RADIAL_GRADIENT: {
      const RadialGradientPattern& pattern =
          static_cast<const RadialGradientPattern&>(aPattern);

      pat = cairo_pattern_create_radial(pattern.mCenter1.x, pattern.mCenter1.y,
                                        pattern.mRadius1, pattern.mCenter2.x,
                                        pattern.mCenter2.y, pattern.mRadius2);

      MOZ_ASSERT(pattern.mStops->GetBackendType() == BackendType::CAIRO);
      GradientStopsCairo* cairoStops =
          static_cast<GradientStopsCairo*>(pattern.mStops.get());
      cairo_pattern_set_extend(
          pat, GfxExtendToCairoExtend(cairoStops->GetExtendMode()));

      matrix = &pattern.mMatrix;

      const std::vector<GradientStop>& stops = cairoStops->GetStops();
      for (size_t i = 0; i < stops.size(); ++i) {
        CairoPatternAddGradientStop(pat, stops[i]);
      }

      break;
    }
    case PatternType::CONIC_GRADIENT: {
      // XXX(ntim): Bug 1617039 - Implement conic-gradient for Cairo
      pat = cairo_pattern_create_rgba(0.0, 0.0, 0.0, 0.0);

      break;
    }
    default: {
      // We should support all pattern types!
      MOZ_ASSERT(false);
    }
  }

  // The pattern matrix is a matrix that transforms the pattern into user
  // space. Cairo takes a matrix that converts from user space to pattern
  // space. Cairo therefore needs the inverse.
  if (matrix) {
    cairo_matrix_t mat;
    GfxMatrixToCairoMatrix(*matrix, mat);
    cairo_matrix_invert(&mat);
    cairo_pattern_set_matrix(pat, &mat);
  }

  return pat;
}

static bool NeedIntermediateSurface(const Pattern& aPattern,
                                    const DrawOptions& aOptions) {
  // We pre-multiply colours' alpha by the global alpha, so we don't need to
  // use an intermediate surface for them.
  if (aPattern.GetType() == PatternType::COLOR) return false;

  if (aOptions.mAlpha == 1.0) return false;

  return true;
}

DrawTargetCairo::DrawTargetCairo()
    : mContext(nullptr),
      mSurface(nullptr),
      mTransformSingular(false),
      mLockedBits(nullptr),
      mFontOptions(nullptr) {}

DrawTargetCairo::~DrawTargetCairo() {
  cairo_destroy(mContext);
  if (mSurface) {
    cairo_surface_destroy(mSurface);
    mSurface = nullptr;
  }
  if (mFontOptions) {
    cairo_font_options_destroy(mFontOptions);
    mFontOptions = nullptr;
  }
  MOZ_ASSERT(!mLockedBits);
}

bool DrawTargetCairo::IsValid() const {
  return mSurface && !cairo_surface_status(mSurface) && mContext &&
         !cairo_surface_status(cairo_get_group_target(mContext));
}

DrawTargetType DrawTargetCairo::GetType() const {
  if (mContext) {
    cairo_surface_type_t type = cairo_surface_get_type(mSurface);
    if (type == CAIRO_SURFACE_TYPE_TEE) {
      type = cairo_surface_get_type(cairo_tee_surface_index(mSurface, 0));
      MOZ_ASSERT(type != CAIRO_SURFACE_TYPE_TEE, "C'mon!");
      MOZ_ASSERT(
          type == cairo_surface_get_type(cairo_tee_surface_index(mSurface, 1)),
          "What should we do here?");
    }
    switch (type) {
      case CAIRO_SURFACE_TYPE_PDF:
      case CAIRO_SURFACE_TYPE_PS:
      case CAIRO_SURFACE_TYPE_SVG:
      case CAIRO_SURFACE_TYPE_WIN32_PRINTING:
      case CAIRO_SURFACE_TYPE_XML:
        return DrawTargetType::VECTOR;

      case CAIRO_SURFACE_TYPE_VG:
      case CAIRO_SURFACE_TYPE_GL:
      case CAIRO_SURFACE_TYPE_GLITZ:
      case CAIRO_SURFACE_TYPE_QUARTZ:
      case CAIRO_SURFACE_TYPE_DIRECTFB:
        return DrawTargetType::HARDWARE_RASTER;

      case CAIRO_SURFACE_TYPE_SKIA:
      case CAIRO_SURFACE_TYPE_QT:
        MOZ_FALLTHROUGH_ASSERT(
            "Can't determine actual DrawTargetType for DrawTargetCairo - "
            "assuming SOFTWARE_RASTER");
      case CAIRO_SURFACE_TYPE_IMAGE:
      case CAIRO_SURFACE_TYPE_XLIB:
      case CAIRO_SURFACE_TYPE_XCB:
      case CAIRO_SURFACE_TYPE_WIN32:
      case CAIRO_SURFACE_TYPE_BEOS:
      case CAIRO_SURFACE_TYPE_OS2:
      case CAIRO_SURFACE_TYPE_QUARTZ_IMAGE:
      case CAIRO_SURFACE_TYPE_SCRIPT:
      case CAIRO_SURFACE_TYPE_RECORDING:
      case CAIRO_SURFACE_TYPE_DRM:
      case CAIRO_SURFACE_TYPE_SUBSURFACE:
      case CAIRO_SURFACE_TYPE_TEE:  // included to silence warning about
                                    // unhandled enum value
        return DrawTargetType::SOFTWARE_RASTER;
      default:
        MOZ_CRASH("GFX: Unsupported cairo surface type");
    }
  }
  MOZ_ASSERT(false, "Could not determine DrawTargetType for DrawTargetCairo");
  return DrawTargetType::SOFTWARE_RASTER;
}

IntSize DrawTargetCairo::GetSize() const { return mSize; }

SurfaceFormat GfxFormatForCairoSurface(cairo_surface_t* surface) {
  cairo_surface_type_t type = cairo_surface_get_type(surface);
  if (type == CAIRO_SURFACE_TYPE_IMAGE) {
    return CairoFormatToGfxFormat(cairo_image_surface_get_format(surface));
  }
#ifdef CAIRO_HAS_XLIB_SURFACE
  // xlib is currently the only Cairo backend that creates 16bpp surfaces
  if (type == CAIRO_SURFACE_TYPE_XLIB &&
      cairo_xlib_surface_get_depth(surface) == 16) {
    return SurfaceFormat::R5G6B5_UINT16;
  }
#endif
  return CairoContentToGfxFormat(cairo_surface_get_content(surface));
}

already_AddRefed<SourceSurface> DrawTargetCairo::Snapshot() {
  if (!IsValid()) {
    gfxCriticalNote << "DrawTargetCairo::Snapshot with bad surface "
                    << hexa(mSurface) << ", context " << hexa(mContext)
                    << ", status "
                    << (mSurface ? cairo_surface_status(mSurface) : -1);
    return nullptr;
  }
  if (mSnapshot) {
    RefPtr<SourceSurface> snapshot(mSnapshot);
    return snapshot.forget();
  }

  IntSize size = GetSize();

  mSnapshot = new SourceSurfaceCairo(mSurface, size,
                                     GfxFormatForCairoSurface(mSurface), this);
  RefPtr<SourceSurface> snapshot(mSnapshot);
  return snapshot.forget();
}

bool DrawTargetCairo::LockBits(uint8_t** aData, IntSize* aSize,
                               int32_t* aStride, SurfaceFormat* aFormat,
                               IntPoint* aOrigin) {
  cairo_surface_t* target = cairo_get_group_target(mContext);
  cairo_surface_t* surf = target;
#ifdef CAIRO_HAS_WIN32_SURFACE
  if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_WIN32) {
    cairo_surface_t* imgsurf = cairo_win32_surface_get_image(surf);
    if (imgsurf) {
      surf = imgsurf;
    }
  }
#endif
  if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_IMAGE &&
      cairo_surface_status(surf) == CAIRO_STATUS_SUCCESS) {
    PointDouble offset;
    cairo_surface_get_device_offset(target, &offset.x, &offset.y);
    // verify the device offset can be converted to integers suitable for a
    // bounds rect
    IntPoint origin(int32_t(-offset.x), int32_t(-offset.y));
    if (-PointDouble(origin) != offset || (!aOrigin && origin != IntPoint())) {
      return false;
    }

    WillChange();
    Flush();

    mLockedBits = cairo_image_surface_get_data(surf);
    *aData = mLockedBits;
    *aSize = IntSize(cairo_image_surface_get_width(surf),
                     cairo_image_surface_get_height(surf));
    *aStride = cairo_image_surface_get_stride(surf);
    *aFormat = CairoFormatToGfxFormat(cairo_image_surface_get_format(surf));
    if (aOrigin) {
      *aOrigin = origin;
    }
    return true;
  }

  return false;
}

void DrawTargetCairo::ReleaseBits(uint8_t* aData) {
  MOZ_ASSERT(mLockedBits == aData);
  mLockedBits = nullptr;
  cairo_surface_t* surf = cairo_get_group_target(mContext);
#ifdef CAIRO_HAS_WIN32_SURFACE
  if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_WIN32) {
    cairo_surface_t* imgsurf = cairo_win32_surface_get_image(surf);
    if (imgsurf) {
      cairo_surface_mark_dirty(imgsurf);
    }
  }
#endif
  cairo_surface_mark_dirty(surf);
}

void DrawTargetCairo::Flush() {
  cairo_surface_t* surf = cairo_get_group_target(mContext);
  cairo_surface_flush(surf);
}

void DrawTargetCairo::PrepareForDrawing(cairo_t* aContext,
                                        const Path* aPath /* = nullptr */) {
  WillChange(aPath);
}

cairo_surface_t* DrawTargetCairo::GetDummySurface() {
  if (mDummySurface) {
    return mDummySurface;
  }

  mDummySurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);

  return mDummySurface;
}

static void PaintWithAlpha(cairo_t* aContext, const DrawOptions& aOptions) {
  if (aOptions.mCompositionOp == CompositionOp::OP_SOURCE) {
    // Cairo treats the source operator like a lerp when alpha is < 1.
    // Approximate the desired operator by: out = 0; out += src*alpha;
    if (aOptions.mAlpha == 1) {
      cairo_set_operator(aContext, CAIRO_OPERATOR_SOURCE);
      cairo_paint(aContext);
    } else {
      cairo_set_operator(aContext, CAIRO_OPERATOR_CLEAR);
      cairo_paint(aContext);
      cairo_set_operator(aContext, CAIRO_OPERATOR_ADD);
      cairo_paint_with_alpha(aContext, aOptions.mAlpha);
    }
  } else {
    cairo_set_operator(aContext, GfxOpToCairoOp(aOptions.mCompositionOp));
    cairo_paint_with_alpha(aContext, aOptions.mAlpha);
  }
}

void DrawTargetCairo::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
                                  const Rect& aSource,
                                  const DrawSurfaceOptions& aSurfOptions,
                                  const DrawOptions& aOptions) {
  if (mTransformSingular || aDest.IsEmpty()) {
    return;
  }

  if (!IsValid() || !aSurface) {
    gfxCriticalNote << "DrawSurface with bad surface "
                    << cairo_surface_status(cairo_get_group_target(mContext));
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);
  AutoClearDeviceOffset clear(aSurface);

  float sx = aSource.Width() / aDest.Width();
  float sy = aSource.Height() / aDest.Height();

  cairo_matrix_t src_mat;
  cairo_matrix_init_translate(&src_mat, aSource.X(), aSource.Y());
  cairo_matrix_scale(&src_mat, sx, sy);

  cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aSurface);
  if (!surf) {
    gfxWarning()
        << "Failed to create cairo surface for DrawTargetCairo::DrawSurface";
    return;
  }
  cairo_pattern_t* pat = cairo_pattern_create_for_surface(surf);
  cairo_surface_destroy(surf);

  cairo_pattern_set_matrix(pat, &src_mat);
  cairo_pattern_set_filter(
      pat, GfxSamplingFilterToCairoFilter(aSurfOptions.mSamplingFilter));
  cairo_pattern_set_extend(pat, CAIRO_EXTEND_PAD);

  cairo_set_antialias(mContext,
                      GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));

  // If the destination rect covers the entire clipped area, then unbounded and
  // bounded operations are identical, and we don't need to push a group.
  bool needsGroup = !IsOperatorBoundByMask(aOptions.mCompositionOp) &&
                    !aDest.Contains(GetUserSpaceClip());

  cairo_translate(mContext, aDest.X(), aDest.Y());

  if (needsGroup) {
    cairo_push_group(mContext);
    cairo_new_path(mContext);
    cairo_rectangle(mContext, 0, 0, aDest.Width(), aDest.Height());
    cairo_set_source(mContext, pat);
    cairo_fill(mContext);
    cairo_pop_group_to_source(mContext);
  } else {
    cairo_new_path(mContext);
    cairo_rectangle(mContext, 0, 0, aDest.Width(), aDest.Height());
    cairo_clip(mContext);
    cairo_set_source(mContext, pat);
  }

  PaintWithAlpha(mContext, aOptions);

  cairo_pattern_destroy(pat);
}

void DrawTargetCairo::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
                                 const Point& aDestPoint,
                                 const DrawOptions& aOptions) {
  FilterNodeSoftware* filter = static_cast<FilterNodeSoftware*>(aNode);
  filter->Draw(this, aSourceRect, aDestPoint, aOptions);
}

void DrawTargetCairo::DrawSurfaceWithShadow(SourceSurface* aSurface,
                                            const Point& aDest,
                                            const DeviceColor& aColor,
                                            const Point& aOffset, Float aSigma,
                                            CompositionOp aOperator) {
  if (!IsValid() || !aSurface) {
    gfxCriticalNote << "DrawSurfaceWithShadow with bad surface "
                    << cairo_surface_status(cairo_get_group_target(mContext));
    return;
  }

  if (aSurface->GetType() != SurfaceType::CAIRO) {
    return;
  }

  AutoClearDeviceOffset clear(aSurface);

  Float width = Float(aSurface->GetSize().width);
  Float height = Float(aSurface->GetSize().height);

  SourceSurfaceCairo* source = static_cast<SourceSurfaceCairo*>(aSurface);
  cairo_surface_t* sourcesurf = source->GetSurface();
  cairo_surface_t* blursurf;
  cairo_surface_t* surf;

  // We only use the A8 surface for blurred shadows. Unblurred shadows can just
  // use the RGBA surface directly.
  if (cairo_surface_get_type(sourcesurf) == CAIRO_SURFACE_TYPE_TEE) {
    blursurf = cairo_tee_surface_index(sourcesurf, 0);
    surf = cairo_tee_surface_index(sourcesurf, 1);
  } else {
    blursurf = sourcesurf;
    surf = sourcesurf;
  }

  if (aSigma != 0.0f) {
    MOZ_ASSERT(cairo_surface_get_type(blursurf) == CAIRO_SURFACE_TYPE_IMAGE);
    Rect extents(0, 0, width, height);
    AlphaBoxBlur blur(extents, cairo_image_surface_get_stride(blursurf), aSigma,
                      aSigma);
    blur.Blur(cairo_image_surface_get_data(blursurf));
  }

  WillChange();
  ClearSurfaceForUnboundedSource(aOperator);

  cairo_save(mContext);
  cairo_set_operator(mContext, GfxOpToCairoOp(aOperator));
  cairo_identity_matrix(mContext);
  cairo_translate(mContext, aDest.x, aDest.y);

  bool needsGroup = !IsOperatorBoundByMask(aOperator);
  if (needsGroup) {
    cairo_push_group(mContext);
  }

  cairo_set_source_rgba(mContext, aColor.r, aColor.g, aColor.b, aColor.a);
  cairo_mask_surface(mContext, blursurf, aOffset.x, aOffset.y);

  if (blursurf != surf || aSurface->GetFormat() != SurfaceFormat::A8) {
    // Now that the shadow has been drawn, we can draw the surface on top.
    cairo_set_source_surface(mContext, surf, 0, 0);
    cairo_new_path(mContext);
    cairo_rectangle(mContext, 0, 0, width, height);
    cairo_fill(mContext);
  }

  if (needsGroup) {
    cairo_pop_group_to_source(mContext);
    cairo_paint(mContext);
  }

  cairo_restore(mContext);
}

void DrawTargetCairo::DrawPattern(const Pattern& aPattern,
                                  const StrokeOptions& aStrokeOptions,
                                  const DrawOptions& aOptions,
                                  DrawPatternType aDrawType,
                                  bool aPathBoundsClip) {
  if (!PatternIsCompatible(aPattern)) {
    return;
  }

  AutoClearDeviceOffset clear(aPattern);

  cairo_pattern_t* pat =
      GfxPatternToCairoPattern(aPattern, aOptions.mAlpha, GetTransform());
  if (!pat) {
    return;
  }
  if (cairo_pattern_status(pat)) {
    cairo_pattern_destroy(pat);
    gfxWarning() << "Invalid pattern";
    return;
  }

  cairo_set_source(mContext, pat);

  cairo_set_antialias(mContext,
                      GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));

  if (NeedIntermediateSurface(aPattern, aOptions) ||
      (!IsOperatorBoundByMask(aOptions.mCompositionOp) && !aPathBoundsClip)) {
    cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);

    // Don't want operators to be applied twice
    cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);

    if (aDrawType == DRAW_STROKE) {
      SetCairoStrokeOptions(mContext, aStrokeOptions);
      cairo_stroke_preserve(mContext);
    } else {
      cairo_fill_preserve(mContext);
    }

    cairo_pop_group_to_source(mContext);

    // Now draw the content using the desired operator
    PaintWithAlpha(mContext, aOptions);
  } else {
    cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));

    if (aDrawType == DRAW_STROKE) {
      SetCairoStrokeOptions(mContext, aStrokeOptions);
      cairo_stroke_preserve(mContext);
    } else {
      cairo_fill_preserve(mContext);
    }
  }

  cairo_pattern_destroy(pat);
}

void DrawTargetCairo::FillRect(const Rect& aRect, const Pattern& aPattern,
                               const DrawOptions& aOptions) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);

  bool restoreTransform = false;
  Matrix mat;
  Rect r = aRect;

  /* Clamp coordinates to work around a design bug in cairo */
  if (r.Width() > CAIRO_COORD_MAX || r.Height() > CAIRO_COORD_MAX ||
      r.X() < -CAIRO_COORD_MAX || r.X() > CAIRO_COORD_MAX ||
      r.Y() < -CAIRO_COORD_MAX || r.Y() > CAIRO_COORD_MAX) {
    if (!mat.IsRectilinear()) {
      gfxWarning() << "DrawTargetCairo::FillRect() misdrawing huge Rect "
                      "with non-rectilinear transform";
    }

    mat = GetTransform();
    r = mat.TransformBounds(r);

    if (!ConditionRect(r)) {
      gfxWarning() << "Ignoring DrawTargetCairo::FillRect() call with "
                      "out-of-bounds Rect";
      return;
    }

    restoreTransform = true;
    SetTransform(Matrix());
  }

  cairo_new_path(mContext);
  cairo_rectangle(mContext, r.X(), r.Y(), r.Width(), r.Height());

  bool pathBoundsClip = false;

  if (r.Contains(GetUserSpaceClip())) {
    pathBoundsClip = true;
  }

  DrawPattern(aPattern, StrokeOptions(), aOptions, DRAW_FILL, pathBoundsClip);

  if (restoreTransform) {
    SetTransform(mat);
  }
}

void DrawTargetCairo::CopySurfaceInternal(cairo_surface_t* aSurface,
                                          const IntRect& aSource,
                                          const IntPoint& aDest) {
  if (cairo_surface_status(aSurface)) {
    gfxWarning() << "Invalid surface" << cairo_surface_status(aSurface);
    return;
  }

  cairo_identity_matrix(mContext);

  cairo_set_source_surface(mContext, aSurface, aDest.x - aSource.X(),
                           aDest.y - aSource.Y());
  cairo_set_operator(mContext, CAIRO_OPERATOR_SOURCE);
  cairo_set_antialias(mContext, CAIRO_ANTIALIAS_NONE);

  cairo_reset_clip(mContext);
  cairo_new_path(mContext);
  cairo_rectangle(mContext, aDest.x, aDest.y, aSource.Width(),
                  aSource.Height());
  cairo_fill(mContext);
}

void DrawTargetCairo::CopySurface(SourceSurface* aSurface,
                                  const IntRect& aSource,
                                  const IntPoint& aDest) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);
  AutoClearDeviceOffset clear(aSurface);

  if (!aSurface) {
    gfxWarning() << "Unsupported surface type specified";
    return;
  }

  cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aSurface);
  if (!surf) {
    gfxWarning() << "Unsupported surface type specified";
    return;
  }

  CopySurfaceInternal(surf, aSource, aDest);
  cairo_surface_destroy(surf);
}

void DrawTargetCairo::CopyRect(const IntRect& aSource, const IntPoint& aDest) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);

  IntRect source = aSource;
  cairo_surface_t* surf = mSurface;

  if (!SupportsSelfCopy(mSurface) && aSource.ContainsY(aDest.y)) {
    cairo_surface_t* similar = cairo_surface_create_similar(
        mSurface, GfxFormatToCairoContent(GetFormat()), aSource.Width(),
        aSource.Height());
    cairo_t* ctx = cairo_create(similar);
    cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
    cairo_set_source_surface(ctx, surf, -aSource.X(), -aSource.Y());
    cairo_paint(ctx);
    cairo_destroy(ctx);

    source.MoveTo(0, 0);
    surf = similar;
  }

  CopySurfaceInternal(surf, source, aDest);

  if (surf != mSurface) {
    cairo_surface_destroy(surf);
  }
}

void DrawTargetCairo::ClearRect(const Rect& aRect) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);

  if (!mContext || aRect.Width() < 0 || aRect.Height() < 0 ||
      !IsFinite(aRect.X()) || !IsFinite(aRect.Width()) ||
      !IsFinite(aRect.Y()) || !IsFinite(aRect.Height())) {
    gfxCriticalNote << "ClearRect with invalid argument " << gfx::hexa(mContext)
                    << " with " << aRect.Width() << "x" << aRect.Height()
                    << " [" << aRect.X() << ", " << aRect.Y() << "]";
  }

  cairo_set_antialias(mContext, CAIRO_ANTIALIAS_NONE);
  cairo_new_path(mContext);
  cairo_set_operator(mContext, CAIRO_OPERATOR_CLEAR);
  cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
                  aRect.Height());
  cairo_fill(mContext);
}

void DrawTargetCairo::StrokeRect(
    const Rect& aRect, const Pattern& aPattern,
    const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
    const DrawOptions& aOptions /* = DrawOptions() */) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);

  cairo_new_path(mContext);
  cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
                  aRect.Height());

  DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}

void DrawTargetCairo::StrokeLine(
    const Point& aStart, const Point& aEnd, const Pattern& aPattern,
    const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
    const DrawOptions& aOptions /* = DrawOptions() */) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);

  cairo_new_path(mContext);
  cairo_move_to(mContext, aStart.x, aStart.y);
  cairo_line_to(mContext, aEnd.x, aEnd.y);

  DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}

void DrawTargetCairo::Stroke(
    const Path* aPath, const Pattern& aPattern,
    const StrokeOptions& aStrokeOptions /* = StrokeOptions() */,
    const DrawOptions& aOptions /* = DrawOptions() */) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext, aPath);

  if (aPath->GetBackendType() != BackendType::CAIRO) return;

  PathCairo* path =
      const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));
  path->SetPathOnContext(mContext);

  DrawPattern(aPattern, aStrokeOptions, aOptions, DRAW_STROKE);
}

void DrawTargetCairo::Fill(const Path* aPath, const Pattern& aPattern,
                           const DrawOptions& aOptions /* = DrawOptions() */) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext, aPath);

  if (aPath->GetBackendType() != BackendType::CAIRO) return;

  PathCairo* path =
      const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));
  path->SetPathOnContext(mContext);

  DrawPattern(aPattern, StrokeOptions(), aOptions, DRAW_FILL);
}

bool DrawTargetCairo::IsCurrentGroupOpaque() {
  cairo_surface_t* surf = cairo_get_group_target(mContext);

  if (!surf) {
    return false;
  }

  return cairo_surface_get_content(surf) == CAIRO_CONTENT_COLOR;
}

void DrawTargetCairo::SetFontOptions(cairo_antialias_t aAAMode) {
  //   This will attempt to detect if the currently set scaled font on the
  // context has enabled subpixel AA. If it is not permitted, then it will
  // downgrade to grayscale AA.
  //   This only currently works effectively for the cairo-ft backend relative
  // to system defaults, as only cairo-ft reflect system defaults in the scaled
  // font state. However, this will work for cairo-ft on both tree Cairo and
  // system Cairo.
  //   Other backends leave the CAIRO_ANTIALIAS_DEFAULT setting untouched while
  // potentially interpreting it as subpixel or even other types of AA that
  // can't be safely equivocated with grayscale AA. For this reason we don't
  // try to also detect and modify the default AA setting, only explicit
  // subpixel AA. These other backends must instead rely on tree Cairo's
  // cairo_surface_set_subpixel_antialiasing extension.

  // If allowing subpixel AA, then leave Cairo's default AA state.
  if (mPermitSubpixelAA && aAAMode == CAIRO_ANTIALIAS_DEFAULT) {
    return;
  }

  if (!mFontOptions) {
    mFontOptions = cairo_font_options_create();
    if (!mFontOptions) {
      gfxWarning() << "Failed allocating Cairo font options";
      return;
    }
  }

  cairo_get_font_options(mContext, mFontOptions);
  cairo_antialias_t oldAA = cairo_font_options_get_antialias(mFontOptions);
  cairo_antialias_t newAA =
      aAAMode == CAIRO_ANTIALIAS_DEFAULT ? oldAA : aAAMode;
  // Nothing to change if switching to default AA.
  if (newAA == CAIRO_ANTIALIAS_DEFAULT) {
    return;
  }
  // If the current font requests subpixel AA, force it to gray since we don't
  // allow subpixel AA.
  if (!mPermitSubpixelAA && newAA == CAIRO_ANTIALIAS_SUBPIXEL) {
    newAA = CAIRO_ANTIALIAS_GRAY;
  }
  // Only override old AA with lower levels of AA.
  if (oldAA == CAIRO_ANTIALIAS_DEFAULT || (int)newAA < (int)oldAA) {
    cairo_font_options_set_antialias(mFontOptions, newAA);
    cairo_set_font_options(mContext, mFontOptions);
  }
}

void DrawTargetCairo::SetPermitSubpixelAA(bool aPermitSubpixelAA) {
  DrawTarget::SetPermitSubpixelAA(aPermitSubpixelAA);
#ifdef MOZ_TREE_CAIRO
  cairo_surface_set_subpixel_antialiasing(
      cairo_get_group_target(mContext),
      aPermitSubpixelAA ? CAIRO_SUBPIXEL_ANTIALIASING_ENABLED
                        : CAIRO_SUBPIXEL_ANTIALIASING_DISABLED);
#endif
}

static bool SupportsVariationSettings(cairo_surface_t* surface) {
  switch (cairo_surface_get_type(surface)) {
    case CAIRO_SURFACE_TYPE_PDF:
    case CAIRO_SURFACE_TYPE_PS:
      return false;
    default:
      return true;
  }
}

void DrawTargetCairo::FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,
                                 const Pattern& aPattern,
                                 const DrawOptions& aOptions) {
  if (mTransformSingular) {
    return;
  }

  if (!IsValid()) {
    gfxDebug() << "FillGlyphs bad surface "
               << cairo_surface_status(cairo_get_group_target(mContext));
    return;
  }

  cairo_scaled_font_t* cairoScaledFont =
      aFont ? aFont->GetCairoScaledFont() : nullptr;
  if (!cairoScaledFont) {
    gfxDevCrash(LogReason::InvalidFont) << "Invalid scaled font";
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);
  AutoClearDeviceOffset clear(aPattern);

  cairo_set_scaled_font(mContext, cairoScaledFont);

  cairo_pattern_t* pat =
      GfxPatternToCairoPattern(aPattern, aOptions.mAlpha, GetTransform());
  if (!pat) return;

  cairo_set_source(mContext, pat);
  cairo_pattern_destroy(pat);

  cairo_antialias_t aa = GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode);
  cairo_set_antialias(mContext, aa);

  // Override any font-specific options as necessary.
  SetFontOptions(aa);

  // Convert our GlyphBuffer into a vector of Cairo glyphs. This code can
  // execute millions of times in short periods, so we want to avoid heap
  // allocation whenever possible. So we use an inline vector capacity of 1024
  // bytes (the maximum allowed by mozilla::Vector), which gives an inline
  // length of 1024 / 24 = 42 elements, which is enough to typically avoid heap
  // allocation in ~99% of cases.
  Vector<cairo_glyph_t, 1024 / sizeof(cairo_glyph_t)> glyphs;
  if (!glyphs.resizeUninitialized(aBuffer.mNumGlyphs)) {
    gfxDevCrash(LogReason::GlyphAllocFailedCairo) << "glyphs allocation failed";
    return;
  }
  for (uint32_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
    glyphs[i].index = aBuffer.mGlyphs[i].mIndex;
    glyphs[i].x = aBuffer.mGlyphs[i].mPosition.x;
    glyphs[i].y = aBuffer.mGlyphs[i].mPosition.y;
  }

  if (!SupportsVariationSettings(mSurface) && aFont->HasVariationSettings() &&
      StaticPrefs::print_font_variations_as_paths()) {
    cairo_set_fill_rule(mContext, CAIRO_FILL_RULE_WINDING);
    cairo_new_path(mContext);
    cairo_glyph_path(mContext, &glyphs[0], aBuffer.mNumGlyphs);
    cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
    cairo_fill(mContext);
  } else {
    cairo_show_glyphs(mContext, &glyphs[0], aBuffer.mNumGlyphs);
  }

  if (cairo_surface_status(cairo_get_group_target(mContext))) {
    gfxDebug() << "Ending FillGlyphs with a bad surface "
               << cairo_surface_status(cairo_get_group_target(mContext));
  }
}

void DrawTargetCairo::Mask(const Pattern& aSource, const Pattern& aMask,
                           const DrawOptions& aOptions /* = DrawOptions() */) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);
  AutoClearDeviceOffset clearSource(aSource);
  AutoClearDeviceOffset clearMask(aMask);

  cairo_set_antialias(mContext,
                      GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));

  cairo_pattern_t* source =
      GfxPatternToCairoPattern(aSource, aOptions.mAlpha, GetTransform());
  if (!source) {
    return;
  }

  cairo_pattern_t* mask =
      GfxPatternToCairoPattern(aMask, aOptions.mAlpha, GetTransform());
  if (!mask) {
    cairo_pattern_destroy(source);
    return;
  }

  if (cairo_pattern_status(source) || cairo_pattern_status(mask)) {
    cairo_pattern_destroy(source);
    cairo_pattern_destroy(mask);
    gfxWarning() << "Invalid pattern";
    return;
  }

  cairo_set_source(mContext, source);
  cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));
  cairo_mask(mContext, mask);

  cairo_pattern_destroy(mask);
  cairo_pattern_destroy(source);
}

void DrawTargetCairo::MaskSurface(const Pattern& aSource, SourceSurface* aMask,
                                  Point aOffset, const DrawOptions& aOptions) {
  if (mTransformSingular) {
    return;
  }

  AutoPrepareForDrawing prep(this, mContext);
  AutoClearDeviceOffset clearSource(aSource);
  AutoClearDeviceOffset clearMask(aMask);

  if (!PatternIsCompatible(aSource)) {
    return;
  }

  cairo_set_antialias(mContext,
                      GfxAntialiasToCairoAntialias(aOptions.mAntialiasMode));

  cairo_pattern_t* pat =
      GfxPatternToCairoPattern(aSource, aOptions.mAlpha, GetTransform());
  if (!pat) {
    return;
  }

  if (cairo_pattern_status(pat)) {
    cairo_pattern_destroy(pat);
    gfxWarning() << "Invalid pattern";
    return;
  }

  cairo_set_source(mContext, pat);

  if (NeedIntermediateSurface(aSource, aOptions)) {
    cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);

    // Don't want operators to be applied twice
    cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);

    // Now draw the content using the desired operator
    cairo_paint_with_alpha(mContext, aOptions.mAlpha);

    cairo_pop_group_to_source(mContext);
  }

  cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aMask);
  if (!surf) {
    cairo_pattern_destroy(pat);
    return;
  }
  cairo_pattern_t* mask = cairo_pattern_create_for_surface(surf);
  cairo_matrix_t matrix;

  cairo_matrix_init_translate(&matrix, -aOffset.x - aMask->GetRect().x,
                              -aOffset.y - aMask->GetRect().y);
  cairo_pattern_set_matrix(mask, &matrix);

  cairo_set_operator(mContext, GfxOpToCairoOp(aOptions.mCompositionOp));

  cairo_mask(mContext, mask);

  cairo_surface_destroy(surf);
  cairo_pattern_destroy(mask);
  cairo_pattern_destroy(pat);
}

void DrawTargetCairo::PushClip(const Path* aPath) {
  if (aPath->GetBackendType() != BackendType::CAIRO) {
    return;
  }

  WillChange(aPath);
  cairo_save(mContext);

  PathCairo* path =
      const_cast<PathCairo*>(static_cast<const PathCairo*>(aPath));

  if (mTransformSingular) {
    cairo_new_path(mContext);
    cairo_rectangle(mContext, 0, 0, 0, 0);
  } else {
    path->SetPathOnContext(mContext);
  }
  cairo_clip_preserve(mContext);
}

void DrawTargetCairo::PushClipRect(const Rect& aRect) {
  WillChange();
  cairo_save(mContext);

  cairo_new_path(mContext);
  if (mTransformSingular) {
    cairo_rectangle(mContext, 0, 0, 0, 0);
  } else {
    cairo_rectangle(mContext, aRect.X(), aRect.Y(), aRect.Width(),
                    aRect.Height());
  }
  cairo_clip_preserve(mContext);
}

void DrawTargetCairo::PopClip() {
  // save/restore does not affect the path, so no need to call WillChange()

  // cairo_restore will restore the transform too and we don't want to do that
  // so we'll save it now and restore it after the cairo_restore
  cairo_matrix_t mat;
  cairo_get_matrix(mContext, &mat);

  cairo_restore(mContext);

  cairo_set_matrix(mContext, &mat);
}

void DrawTargetCairo::PushLayer(bool aOpaque, Float aOpacity,
                                SourceSurface* aMask,
                                const Matrix& aMaskTransform,
                                const IntRect& aBounds, bool aCopyBackground) {
  cairo_content_t content = CAIRO_CONTENT_COLOR_ALPHA;

  if (mFormat == SurfaceFormat::A8) {
    content = CAIRO_CONTENT_ALPHA;
  } else if (aOpaque) {
    content = CAIRO_CONTENT_COLOR;
  }

  if (aCopyBackground) {
    cairo_surface_t* source = cairo_get_group_target(mContext);
    cairo_push_group_with_content(mContext, content);
    cairo_surface_t* dest = cairo_get_group_target(mContext);
    cairo_t* ctx = cairo_create(dest);
    cairo_set_source_surface(ctx, source, 0, 0);
    cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
    cairo_paint(ctx);
    cairo_destroy(ctx);
  } else {
    cairo_push_group_with_content(mContext, content);
  }

  PushedLayer layer(aOpacity, mPermitSubpixelAA);

  if (aMask) {
    cairo_surface_t* surf = GetCairoSurfaceForSourceSurface(aMask);
    if (surf) {
      layer.mMaskPattern = cairo_pattern_create_for_surface(surf);
      Matrix maskTransform = aMaskTransform;
      maskTransform.PreTranslate(aMask->GetRect().X(), aMask->GetRect().Y());
      cairo_matrix_t mat;
      GfxMatrixToCairoMatrix(maskTransform, mat);
      cairo_matrix_invert(&mat);
      cairo_pattern_set_matrix(layer.mMaskPattern, &mat);
      cairo_surface_destroy(surf);
    } else {
      gfxCriticalError() << "Failed to get cairo surface for mask surface!";
    }
  }

  mPushedLayers.push_back(layer);

  SetPermitSubpixelAA(aOpaque);
}

void DrawTargetCairo::PopLayer() {
  MOZ_ASSERT(mPushedLayers.size());

  cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);

  cairo_pop_group_to_source(mContext);

  PushedLayer layer = mPushedLayers.back();
  mPushedLayers.pop_back();

  if (!layer.mMaskPattern) {
    cairo_paint_with_alpha(mContext, layer.mOpacity);
  } else {
    if (layer.mOpacity != Float(1.0)) {
      cairo_push_group_with_content(mContext, CAIRO_CONTENT_COLOR_ALPHA);

      // Now draw the content using the desired operator
      cairo_paint_with_alpha(mContext, layer.mOpacity);

      cairo_pop_group_to_source(mContext);
    }
    cairo_mask(mContext, layer.mMaskPattern);
  }

  cairo_matrix_t mat;
  GfxMatrixToCairoMatrix(mTransform, mat);
  cairo_set_matrix(mContext, &mat);

  cairo_pattern_destroy(layer.mMaskPattern);
  SetPermitSubpixelAA(layer.mWasPermittingSubpixelAA);
}

already_AddRefed<PathBuilder> DrawTargetCairo::CreatePathBuilder(
    FillRule aFillRule /* = FillRule::FILL_WINDING */) const {
  return MakeAndAddRef<PathBuilderCairo>(aFillRule);
}

void DrawTargetCairo::ClearSurfaceForUnboundedSource(
    const CompositionOp& aOperator) {
  if (aOperator != CompositionOp::OP_SOURCE) return;
  cairo_set_operator(mContext, CAIRO_OPERATOR_CLEAR);
  // It doesn't really matter what the source is here, since Paint
  // isn't bounded by the source and the mask covers the entire clip
  // region.
  cairo_paint(mContext);
}

already_AddRefed<GradientStops> DrawTargetCairo::CreateGradientStops(
    GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode) const {
  return MakeAndAddRef<GradientStopsCairo>(aStops, aNumStops, aExtendMode);
}

already_AddRefed<FilterNode> DrawTargetCairo::CreateFilter(FilterType aType) {
  return FilterNodeSoftware::Create(aType);
}

already_AddRefed<SourceSurface> DrawTargetCairo::CreateSourceSurfaceFromData(
    unsigned char* aData, const IntSize& aSize, int32_t aStride,
    SurfaceFormat aFormat) const {
  if (!aData) {
    gfxWarning() << "DrawTargetCairo::CreateSourceSurfaceFromData null aData";
    return nullptr;
  }

  cairo_surface_t* surf =
      CopyToImageSurface(aData, IntRect(IntPoint(), aSize), aStride, aFormat);
  if (!surf) {
    return nullptr;
  }

  RefPtr<SourceSurfaceCairo> source_surf =
      new SourceSurfaceCairo(surf, aSize, aFormat);
  cairo_surface_destroy(surf);

  return source_surf.forget();
}

#ifdef CAIRO_HAS_XLIB_SURFACE
static cairo_user_data_key_t gDestroyPixmapKey;

struct DestroyPixmapClosure {
  DestroyPixmapClosure(Drawable d, Screen* s) : mPixmap(d), mScreen(s) {}
  ~DestroyPixmapClosure() { XFreePixmap(DisplayOfScreen(mScreen), mPixmap); }
  Drawable mPixmap;
  Screen* mScreen;
};

static void DestroyPixmap(void* data) {
  delete static_cast<DestroyPixmapClosure*>(data);
}
#endif

already_AddRefed<SourceSurface> DrawTargetCairo::OptimizeSourceSurface(
    SourceSurface* aSurface) const {
  RefPtr<SourceSurface> surface(aSurface);
#ifdef CAIRO_HAS_XLIB_SURFACE
  cairo_surface_type_t ctype = cairo_surface_get_type(mSurface);
  if (aSurface->GetType() == SurfaceType::CAIRO &&
      cairo_surface_get_type(
          static_cast<SourceSurfaceCairo*>(aSurface)->GetSurface()) == ctype) {
    return surface.forget();
  }

  if (ctype != CAIRO_SURFACE_TYPE_XLIB) {
    return surface.forget();
  }

  IntSize size = aSurface->GetSize();
  if (!size.width || !size.height) {
    return surface.forget();
  }

// Although the dimension parameters in the xCreatePixmapReq wire protocol are
// 16-bit unsigned integers, the server's CreatePixmap returns BadAlloc if
// either dimension cannot be represented by a 16-bit *signed* integer.
#  define XLIB_IMAGE_SIDE_SIZE_LIMIT 0x7fff

  if (size.width > XLIB_IMAGE_SIDE_SIZE_LIMIT ||
      size.height > XLIB_IMAGE_SIDE_SIZE_LIMIT) {
    return surface.forget();
  }

  SurfaceFormat format = aSurface->GetFormat();
  Screen* screen = cairo_xlib_surface_get_screen(mSurface);
  Display* dpy = DisplayOfScreen(screen);
  XRenderPictFormat* xrenderFormat = nullptr;
  switch (format) {
    case SurfaceFormat::A8R8G8B8_UINT32:
      xrenderFormat = XRenderFindStandardFormat(dpy, PictStandardARGB32);
      break;
    case SurfaceFormat::X8R8G8B8_UINT32:
      xrenderFormat = XRenderFindStandardFormat(dpy, PictStandardRGB24);
      break;
    case SurfaceFormat::A8:
      xrenderFormat = XRenderFindStandardFormat(dpy, PictStandardA8);
      break;
    default:
      return surface.forget();
  }
  if (!xrenderFormat) {
    return surface.forget();
  }

  Drawable pixmap = XCreatePixmap(dpy, RootWindowOfScreen(screen), size.width,
                                  size.height, xrenderFormat->depth);
  if (!pixmap) {
    return surface.forget();
  }

  auto closure = MakeUnique<DestroyPixmapClosure>(pixmap, screen);

  ScopedCairoSurface csurf(cairo_xlib_surface_create_with_xrender_format(
      dpy, pixmap, screen, xrenderFormat, size.width, size.height));
  if (!csurf || cairo_surface_status(csurf)) {
    return surface.forget();
  }

  cairo_surface_set_user_data(csurf, &gDestroyPixmapKey, closure.release(),
                              DestroyPixmap);

  RefPtr<DrawTargetCairo> dt = new DrawTargetCairo();
  if (!dt->Init(csurf, size, &format)) {
    return surface.forget();
  }

  dt->CopySurface(aSurface, IntRect(0, 0, size.width, size.height),
                  IntPoint(0, 0));
  dt->Flush();

  surface = new SourceSurfaceCairo(csurf, size, format);
#endif

  return surface.forget();
}

already_AddRefed<SourceSurface>
DrawTargetCairo::CreateSourceSurfaceFromNativeSurface(
    const NativeSurface& aSurface) const {
  return nullptr;
}

already_AddRefed<DrawTarget> DrawTargetCairo::CreateSimilarDrawTarget(
    const IntSize& aSize, SurfaceFormat aFormat) const {
  if (cairo_surface_status(cairo_get_group_target(mContext))) {
    RefPtr<DrawTargetCairo> target = new DrawTargetCairo();
    if (target->Init(aSize, aFormat)) {
      return target.forget();
    }
  }

  cairo_surface_t* similar;
  switch (cairo_surface_get_type(mSurface)) {
#ifdef CAIRO_HAS_WIN32_SURFACE
    case CAIRO_SURFACE_TYPE_WIN32:
      similar = cairo_win32_surface_create_with_dib(
          GfxFormatToCairoFormat(aFormat), aSize.width, aSize.height);
      break;
#endif
#ifdef CAIRO_HAS_QUARTZ_SURFACE
    case CAIRO_SURFACE_TYPE_QUARTZ:
      similar = cairo_quartz_surface_create_cg_layer(
          mSurface, GfxFormatToCairoContent(aFormat), aSize.width,
          aSize.height);
      break;
#endif
    default:
      similar = cairo_surface_create_similar(mSurface,
                                             GfxFormatToCairoContent(aFormat),
                                             aSize.width, aSize.height);
      break;
  }

  if (!cairo_surface_status(similar)) {
    RefPtr<DrawTargetCairo> target = new DrawTargetCairo();
    if (target->InitAlreadyReferenced(similar, aSize)) {
      return target.forget();
    }
  }

  gfxCriticalError(
      CriticalLog::DefaultOptions(Factory::ReasonableSurfaceSize(aSize)))
      << "Failed to create similar cairo surface! Size: " << aSize
      << " Status: " << cairo_surface_status(similar)
      << cairo_surface_status(cairo_get_group_target(mContext)) << " format "
      << (int)aFormat;
  cairo_surface_destroy(similar);

  return nullptr;
}

RefPtr<DrawTarget> DrawTargetCairo::CreateClippedDrawTarget(
    const Rect& aBounds, SurfaceFormat aFormat) {
  RefPtr<DrawTarget> result;
  // Doing this save()/restore() dance is wasteful
  cairo_save(mContext);

  if (!aBounds.IsEmpty()) {
    cairo_new_path(mContext);
    cairo_rectangle(mContext, aBounds.X(), aBounds.Y(), aBounds.Width(),
                    aBounds.Height());
    cairo_clip(mContext);
  }
  cairo_identity_matrix(mContext);
  IntRect clipBounds = IntRect::RoundOut(GetUserSpaceClip());
  if (!clipBounds.IsEmpty()) {
    RefPtr<DrawTarget> dt = CreateSimilarDrawTarget(
        IntSize(clipBounds.width, clipBounds.height), aFormat);
    result = gfx::Factory::CreateOffsetDrawTarget(
        dt, IntPoint(clipBounds.x, clipBounds.y));
    result->SetTransform(mTransform);
  } else {
    // Everything is clipped but we still want some kind of surface
    result = CreateSimilarDrawTarget(IntSize(1, 1), aFormat);
  }

  cairo_restore(mContext);
  return result;
}
bool DrawTargetCairo::InitAlreadyReferenced(cairo_surface_t* aSurface,
                                            const IntSize& aSize,
                                            SurfaceFormat* aFormat) {
  if (cairo_surface_status(aSurface)) {
    gfxCriticalNote << "Attempt to create DrawTarget for invalid surface. "
                    << aSize
                    << " Cairo Status: " << cairo_surface_status(aSurface);
    cairo_surface_destroy(aSurface);
    return false;
  }

  mContext = cairo_create(aSurface);
  mSurface = aSurface;
  mSize = aSize;
  mFormat = aFormat ? *aFormat : GfxFormatForCairoSurface(aSurface);

  // Cairo image surface have a bug where they will allocate a mask surface (for
  // clipping) the size of the clip extents, and don't take the surface extents
  // into account. Add a manual clip to the surface extents to prevent this.
  cairo_new_path(mContext);
  cairo_rectangle(mContext, 0, 0, mSize.width, mSize.height);
  cairo_clip(mContext);

  if (mFormat == SurfaceFormat::A8R8G8B8_UINT32 ||
      mFormat == SurfaceFormat::R8G8B8A8) {
    SetPermitSubpixelAA(false);
  } else {
    SetPermitSubpixelAA(true);
  }

  return true;
}

already_AddRefed<DrawTarget> DrawTargetCairo::CreateShadowDrawTarget(
    const IntSize& aSize, SurfaceFormat aFormat, float aSigma) const {
  cairo_surface_t* similar = cairo_surface_create_similar(
      cairo_get_target(mContext), GfxFormatToCairoContent(aFormat), aSize.width,
      aSize.height);

  if (cairo_surface_status(similar)) {
    return nullptr;
  }

  // If we don't have a blur then we can use the RGBA mask and keep all the
  // operations in graphics memory.
  if (aSigma == 0.0f || aFormat == SurfaceFormat::A8) {
    RefPtr<DrawTargetCairo> target = new DrawTargetCairo();
    if (target->InitAlreadyReferenced(similar, aSize)) {
      return target.forget();
    } else {
      return nullptr;
    }
  }

  cairo_surface_t* blursurf =
      cairo_image_surface_create(CAIRO_FORMAT_A8, aSize.width, aSize.height);

  if (cairo_surface_status(blursurf)) {
    return nullptr;
  }

  cairo_surface_t* tee = cairo_tee_surface_create(blursurf);
  cairo_surface_destroy(blursurf);
  if (cairo_surface_status(tee)) {
    cairo_surface_destroy(similar);
    return nullptr;
  }

  cairo_tee_surface_add(tee, similar);
  cairo_surface_destroy(similar);

  RefPtr<DrawTargetCairo> target = new DrawTargetCairo();
  if (target->InitAlreadyReferenced(tee, aSize)) {
    return target.forget();
  }
  return nullptr;
}

#ifndef USE_SKIA
static inline pixman_format_code_t GfxFormatToPixmanFormat(
    SurfaceFormat aFormat) {
  switch (aFormat) {
    case SurfaceFormat::A8R8G8B8_UINT32:
      return PIXMAN_a8r8g8b8;
    case SurfaceFormat::X8R8G8B8_UINT32:
      return PIXMAN_x8r8g8b8;
    case SurfaceFormat::R5G6B5_UINT16:
      return PIXMAN_r5g6b5;
    case SurfaceFormat::A8:
      return PIXMAN_a8;
    default:
      // Allow both BGRA and ARGB formats to be passed through unmodified,
      // even though even though we are actually rendering to A8R8G8B8_UINT32.
      if (aFormat == SurfaceFormat::B8G8R8A8 ||
          aFormat == SurfaceFormat::A8R8G8B8) {
        return PIXMAN_a8r8g8b8;
      }
      return (pixman_format_code_t)0;
  }
}
#endif

static inline bool GfxMatrixToPixmanTransform(const Matrix4x4& aMatrix,
                                              pixman_transform* aResult) {
  pixman_f_transform fTransform = {{{aMatrix._11, aMatrix._21, aMatrix._41},
                                    {aMatrix._12, aMatrix._22, aMatrix._42},
                                    {aMatrix._14, aMatrix._24, aMatrix._44}}};
  return pixman_transform_from_pixman_f_transform(aResult, &fTransform);
}

#ifndef USE_SKIA
bool DrawTarget::Draw3DTransformedSurface(SourceSurface* aSurface,
                                          const Matrix4x4& aMatrix) {
  // Composite the 3D transform with the DT's transform.
  Matrix4x4 fullMat = aMatrix * Matrix4x4::From2D(mTransform);
  // Transform the surface bounds and clip to this DT.
  IntRect xformBounds = RoundedOut(fullMat.TransformAndClipBounds(
      Rect(Point(0, 0), Size(aSurface->GetSize())),
      Rect(Point(0, 0), Size(GetSize()))));
  if (xformBounds.IsEmpty()) {
    return true;
  }
  // Offset the matrix by the transformed origin.
  fullMat.PostTranslate(-xformBounds.x, -xformBounds.y, 0);
  // Invert the matrix into a pattern matrix for pixman.
  if (!fullMat.Invert()) {
    return false;
  }
  pixman_transform xform;
  if (!GfxMatrixToPixmanTransform(fullMat, &xform)) {
    return false;
  }

  // Read in the source data.
  RefPtr<DataSourceSurface> srcSurf = aSurface->GetDataSurface();
  pixman_format_code_t srcFormat =
      GfxFormatToPixmanFormat(srcSurf->GetFormat());
  if (!srcFormat) {
    return false;
  }
  DataSourceSurface::ScopedMap srcMap(srcSurf, DataSourceSurface::READ);
  if (!srcMap.IsMapped()) {
    return false;
  }

  // Set up an intermediate destination surface only the size of the transformed
  // bounds. Try to pass through the source's format unmodified in both the BGRA
  // and ARGB cases.
  RefPtr<DataSourceSurface> dstSurf = Factory::CreateDataSourceSurface(
      xformBounds.Size(), srcFormat == PIXMAN_a8r8g8b8
                              ? srcSurf->GetFormat()
                              : SurfaceFormat::A8R8G8B8_UINT32);
  if (!dstSurf) {
    return false;
  }

  // Wrap the surfaces in pixman images and do the transform.
  pixman_image_t* dst = pixman_image_create_bits(
      PIXMAN_a8r8g8b8, xformBounds.width, xformBounds.height,
      (uint32_t*)dstSurf->GetData(), dstSurf->Stride());
  if (!dst) {
    return false;
  }
  pixman_image_t* src = pixman_image_create_bits(
      srcFormat, srcSurf->GetSize().width, srcSurf->GetSize().height,
      (uint32_t*)srcMap.GetData(), srcMap.GetStride());
  if (!src) {
    pixman_image_unref(dst);
    return false;
  }

  pixman_image_set_filter(src, PIXMAN_FILTER_BILINEAR, nullptr, 0);
  pixman_image_set_transform(src, &xform);

  pixman_image_composite32(PIXMAN_OP_SRC, src, nullptr, dst, 0, 0, 0, 0, 0, 0,
                           xformBounds.width, xformBounds.height);

  pixman_image_unref(dst);
  pixman_image_unref(src);

  // Temporarily reset the DT's transform, since it has already been composed
  // above.
  Matrix origTransform = mTransform;
  SetTransform(Matrix());

  // Draw the transformed surface within the transformed bounds.
  DrawSurface(dstSurf, Rect(xformBounds),
              Rect(Point(0, 0), Size(xformBounds.Size())));

  SetTransform(origTransform);

  return true;
}
#endif

#ifdef CAIRO_HAS_XLIB_SURFACE
static bool gXRenderInitialized = false;
static bool gXRenderHasTransform = false;

static bool SupportsXRender(cairo_surface_t* surface) {
  if (!surface || cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_XLIB ||
      !cairo_xlib_surface_get_xrender_format(surface)) {
    return false;
  }

  if (gXRenderInitialized) {
    return true;
  }
  gXRenderInitialized = true;

  cairo_device_t* device = cairo_surface_get_device(surface);
  if (cairo_device_acquire(device) != CAIRO_STATUS_SUCCESS) {
    return false;
  }

  Display* display = cairo_xlib_surface_get_display(surface);
  int major, minor;
  if (XRenderQueryVersion(display, &major, &minor)) {
    if (major > 0 || (major == 0 && minor >= 6)) {
      gXRenderHasTransform = true;
    }
  }

  cairo_device_release(device);

  return true;
}
#endif

bool DrawTargetCairo::Draw3DTransformedSurface(SourceSurface* aSurface,
                                               const Matrix4x4& aMatrix) {
#if CAIRO_HAS_XLIB_SURFACE
  cairo_surface_t* srcSurf =
      aSurface->GetType() == SurfaceType::CAIRO
          ? static_cast<SourceSurfaceCairo*>(aSurface)->GetSurface()
          : nullptr;
  if (!SupportsXRender(srcSurf) || !gXRenderHasTransform) {
    return DrawTarget::Draw3DTransformedSurface(aSurface, aMatrix);
  }

  Matrix4x4 fullMat = aMatrix * Matrix4x4::From2D(mTransform);
  IntRect xformBounds = RoundedOut(fullMat.TransformAndClipBounds(
      Rect(Point(0, 0), Size(aSurface->GetSize())),
      Rect(Point(0, 0), Size(GetSize()))));
  if (xformBounds.IsEmpty()) {
    return true;
  }
  fullMat.PostTranslate(-xformBounds.X(), -xformBounds.Y(), 0);
  if (!fullMat.Invert()) {
    return false;
  }
  pixman_transform xform;
  if (!GfxMatrixToPixmanTransform(fullMat, &xform)) {
    return false;
  }

  cairo_surface_t* xformSurf =
      cairo_surface_create_similar(srcSurf, CAIRO_CONTENT_COLOR_ALPHA,
                                   xformBounds.Width(), xformBounds.Height());
  if (!SupportsXRender(xformSurf)) {
    cairo_surface_destroy(xformSurf);
    return false;
  }
  cairo_device_t* device = cairo_surface_get_device(xformSurf);
  if (cairo_device_acquire(device) != CAIRO_STATUS_SUCCESS) {
    cairo_surface_destroy(xformSurf);
    return false;
  }

  Display* display = cairo_xlib_surface_get_display(xformSurf);

  Picture srcPict = XRenderCreatePicture(
      display, cairo_xlib_surface_get_drawable(srcSurf),
      cairo_xlib_surface_get_xrender_format(srcSurf), 0, nullptr);
  XRenderSetPictureFilter(display, srcPict, FilterBilinear, nullptr, 0);
  XRenderSetPictureTransform(display, srcPict, (XTransform*)&xform);

  Picture dstPict = XRenderCreatePicture(
      display, cairo_xlib_surface_get_drawable(xformSurf),
      cairo_xlib_surface_get_xrender_format(xformSurf), 0, nullptr);

  XRenderComposite(display, PictOpSrc, srcPict, X11None, dstPict, 0, 0, 0, 0, 0,
                   0, xformBounds.Width(), xformBounds.Height());

  XRenderFreePicture(display, srcPict);
  XRenderFreePicture(display, dstPict);

  cairo_device_release(device);
  cairo_surface_mark_dirty(xformSurf);

  AutoPrepareForDrawing(this, mContext);

  cairo_identity_matrix(mContext);

  cairo_set_operator(mContext, CAIRO_OPERATOR_OVER);
  cairo_set_antialias(mContext, CAIRO_ANTIALIAS_DEFAULT);
  cairo_set_source_surface(mContext, xformSurf, xformBounds.X(),
                           xformBounds.Y());

  cairo_new_path(mContext);
  cairo_rectangle(mContext, xformBounds.X(), xformBounds.Y(),
                  xformBounds.Width(), xformBounds.Height());
  cairo_fill(mContext);

  cairo_surface_destroy(xformSurf);

  return true;
#else
  return DrawTarget::Draw3DTransformedSurface(aSurface, aMatrix);
#endif
}

bool DrawTargetCairo::Init(cairo_surface_t* aSurface, const IntSize& aSize,
                           SurfaceFormat* aFormat) {
  cairo_surface_reference(aSurface);
  return InitAlreadyReferenced(aSurface, aSize, aFormat);
}

bool DrawTargetCairo::Init(const IntSize& aSize, SurfaceFormat aFormat) {
  cairo_surface_t* surf = cairo_image_surface_create(
      GfxFormatToCairoFormat(aFormat), aSize.width, aSize.height);
  return InitAlreadyReferenced(surf, aSize);
}

bool DrawTargetCairo::Init(unsigned char* aData, const IntSize& aSize,
                           int32_t aStride, SurfaceFormat aFormat) {
  cairo_surface_t* surf = cairo_image_surface_create_for_data(
      aData, GfxFormatToCairoFormat(aFormat), aSize.width, aSize.height,
      aStride);
  return InitAlreadyReferenced(surf, aSize);
}

void* DrawTargetCairo::GetNativeSurface(NativeSurfaceType aType) {
  if (aType == NativeSurfaceType::CAIRO_CONTEXT) {
    return mContext;
  }

  return nullptr;
}

void DrawTargetCairo::MarkSnapshotIndependent() {
  if (mSnapshot) {
    if (mSnapshot->refCount() > 1) {
      // We only need to worry about snapshots that someone else knows about
      mSnapshot->DrawTargetWillChange();
    }
    mSnapshot = nullptr;
  }
}

void DrawTargetCairo::WillChange(const Path* aPath /* = nullptr */) {
  MarkSnapshotIndependent();
  MOZ_ASSERT(!mLockedBits);
}

void DrawTargetCairo::SetTransform(const Matrix& aTransform) {
  DrawTarget::SetTransform(aTransform);

  mTransformSingular = aTransform.IsSingular();
  if (!mTransformSingular) {
    cairo_matrix_t mat;
    GfxMatrixToCairoMatrix(mTransform, mat);
    cairo_set_matrix(mContext, &mat);
  }
}

Rect DrawTargetCairo::GetUserSpaceClip() const {
  double clipX1, clipY1, clipX2, clipY2;
  cairo_clip_extents(mContext, &clipX1, &clipY1, &clipX2, &clipY2);
  return Rect(clipX1, clipY1, clipX2 - clipX1,
              clipY2 - clipY1);  // Narrowing of doubles to floats
}

cairo_t* BorrowedCairoContext::BorrowCairoContextFromDrawTarget(
    DrawTarget* aDT) {
  if (aDT->GetBackendType() != BackendType::CAIRO || aDT->IsDualDrawTarget() ||
      aDT->IsTiledDrawTarget() || aDT->IsCaptureDT()) {
    return nullptr;
  }
  DrawTargetCairo* cairoDT = static_cast<DrawTargetCairo*>(aDT);

  cairoDT->WillChange();

  // save the state to make it easier for callers to avoid mucking with things
  cairo_save(cairoDT->mContext);

  // Neuter the DrawTarget while the context is being borrowed
  cairo_t* cairo = cairoDT->mContext;
  cairoDT->mContext = nullptr;

  return cairo;
}

void BorrowedCairoContext::ReturnCairoContextToDrawTarget(DrawTarget* aDT,
                                                          cairo_t* aCairo) {
  if (aDT->GetBackendType() != BackendType::CAIRO || aDT->IsDualDrawTarget() ||
      aDT->IsTiledDrawTarget()) {
    return;
  }
  DrawTargetCairo* cairoDT = static_cast<DrawTargetCairo*>(aDT);

  cairo_restore(aCairo);
  cairoDT->mContext = aCairo;
}

#ifdef MOZ_X11
bool BorrowedXlibDrawable::Init(DrawTarget* aDT) {
  MOZ_ASSERT(aDT, "Caller should check for nullptr");
  MOZ_ASSERT(!mDT, "Can't initialize twice!");
  mDT = aDT;
  mDrawable = X11None;

#  ifdef CAIRO_HAS_XLIB_SURFACE
  if (aDT->GetBackendType() != BackendType::CAIRO || aDT->IsDualDrawTarget() ||
      aDT->IsTiledDrawTarget()) {
    return false;
  }

  DrawTargetCairo* cairoDT = static_cast<DrawTargetCairo*>(aDT);
  cairo_surface_t* surf = cairo_get_group_target(cairoDT->mContext);
  if (cairo_surface_get_type(surf) != CAIRO_SURFACE_TYPE_XLIB) {
    return false;
  }
  cairo_surface_flush(surf);

  cairoDT->WillChange();

  mDisplay = cairo_xlib_surface_get_display(surf);
  mDrawable = cairo_xlib_surface_get_drawable(surf);
  mScreen = cairo_xlib_surface_get_screen(surf);
  mVisual = cairo_xlib_surface_get_visual(surf);
  mXRenderFormat = cairo_xlib_surface_get_xrender_format(surf);
  mSize.width = cairo_xlib_surface_get_width(surf);
  mSize.height = cairo_xlib_surface_get_height(surf);

  double x = 0, y = 0;
  cairo_surface_get_device_offset(surf, &x, &y);
  mOffset = Point(x, y);

  return true;
#  else
  return false;
#  endif
}

void BorrowedXlibDrawable::Finish() {
  DrawTargetCairo* cairoDT = static_cast<DrawTargetCairo*>(mDT);
  cairo_surface_t* surf = cairo_get_group_target(cairoDT->mContext);
  cairo_surface_mark_dirty(surf);
  if (mDrawable) {
    mDrawable = X11None;
  }
}
#endif

}  // namespace gfx
}  // namespace mozilla