The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * 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/. */

 #ifdef _MSC_VER

 #define _USE_MATH_DEFINES

 #endif

 #include <math.h>

 #include "mozilla/Alignment.h"

 #include "cairo.h"

 #include "gfxContext.h"

 #include "gfxColor.h"

 #include "gfxMatrix.h"

 #include "gfxASurface.h"

 #include "gfxPattern.h"

 #include "gfxPlatform.h"

 #include "gfxTeeSurface.h"

 #include "GeckoProfiler.h"

 #include "gfx2DGlue.h"

 #include "mozilla/gfx/PathHelpers.h"

 #include <algorithm>

 #if CAIRO_HAS_DWRITE_FONT

 #include "gfxWindowsPlatform.h"

 #endif

 using namespace mozilla;

 using namespace mozilla::gfx;

 UserDataKey gfxContext::sDontUseAsSourceKey;

 /* This class lives on the stack and allows gfxContext users to easily, and

  * performantly get a gfx::Pattern to use for drawing in their current context.

  */

 class GeneralPattern

 {

 public:    

   GeneralPattern(gfxContext *aContext) : mContext(aContext), mPattern(nullptr) {}

   ~GeneralPattern() { if (mPattern) { mPattern->~Pattern(); } }

   operator mozilla::gfx::Pattern&()

   {

     gfxContext::AzureState &state = mContext->CurrentState();

     if (state.pattern) {

       return *state.pattern->GetPattern(mContext->mDT, state.patternTransformChanged ? &state.patternTransform : nullptr);

     } else if (state.sourceSurface) {

       Matrix transform = state.surfTransform;

       if (state.patternTransformChanged) {

         Matrix mat = mContext->GetDTTransform();

         mat.Invert();

         transform = transform * state.patternTransform * mat;

       }

       mPattern = new (mSurfacePattern.addr())

         SurfacePattern(state.sourceSurface, ExtendMode::CLAMP, transform);

       return *mPattern;

     } else {

       mPattern = new (mColorPattern.addr())

         ColorPattern(state.color);

       return *mPattern;

     }

   }

 private:

   union {

     mozilla::AlignedStorage2<mozilla::gfx::ColorPattern> mColorPattern;

     mozilla::AlignedStorage2<mozilla::gfx::SurfacePattern> mSurfacePattern;

   };

   gfxContext *mContext;

   Pattern *mPattern;

 };

 gfxContext::gfxContext(gfxASurface *surface)

   : mRefCairo(nullptr)

   , mSurface(surface)

 {

   MOZ_COUNT_CTOR(gfxContext);

   mCairo = cairo_create(surface->CairoSurface());

   mFlags = surface->GetDefaultContextFlags();

   if (mSurface->GetRotateForLandscape()) {

     // Rotate page 90 degrees to draw landscape page on portrait paper

     gfxIntSize size = mSurface->GetSize();

     Translate(gfxPoint(0, size.width));

     gfxMatrix matrix(0, -1,

                       1,  0,

                       0,  0);

     Multiply(matrix);

   }

 }

 gfxContext::gfxContext(DrawTarget *aTarget, const Point& aDeviceOffset)

   : mPathIsRect(false)

   , mTransformChanged(false)

   , mCairo(nullptr)

   , mRefCairo(nullptr)

   , mSurface(nullptr)

   , mFlags(0)

   , mDT(aTarget)

   , mOriginalDT(aTarget)

 {

   MOZ_COUNT_CTOR(gfxContext);

   mStateStack.SetLength(1);

   CurrentState().drawTarget = mDT;

   CurrentState().deviceOffset = aDeviceOffset;

   mDT->SetTransform(Matrix());

 }

 /* static */ already_AddRefed<gfxContext>

 gfxContext::ContextForDrawTarget(DrawTarget* aTarget)

 {

   Matrix transform = aTarget->GetTransform();

   nsRefPtr<gfxContext> result = new gfxContext(aTarget);

   result->SetMatrix(ThebesMatrix(transform));

   return result.forget();

 }

 gfxContext::~gfxContext()

 {

   if (mCairo) {

     cairo_destroy(mCairo);

   }

   if (mRefCairo) {

     cairo_destroy(mRefCairo);

   }

   if (mDT) {

     for (int i = mStateStack.Length() - 1; i >= 0; i--) {

       for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {

         mDT->PopClip();

       }

       if (mStateStack[i].clipWasReset) {

         break;

       }

     }

     mDT->Flush();

   }

   MOZ_COUNT_DTOR(gfxContext);

 }

 gfxASurface *

 gfxContext::OriginalSurface()

 {

     if (mCairo || mSurface) {

         return mSurface;

     }

     if (mOriginalDT && mOriginalDT->GetType() == BackendType::CAIRO) {

         cairo_surface_t *s =

             (cairo_surface_t*)mOriginalDT->GetNativeSurface(NativeSurfaceType::CAIRO_SURFACE);

         if (s) {

             mSurface = gfxASurface::Wrap(s);

             return mSurface;

         }

     }

     return nullptr;

 }

 already_AddRefed<gfxASurface>

 gfxContext::CurrentSurface(gfxFloat *dx, gfxFloat *dy)

 {

   if (mCairo) {

     cairo_surface_t *s = cairo_get_group_target(mCairo);

     if (s == mSurface->CairoSurface()) {

         if (dx && dy)

             cairo_surface_get_device_offset(s, dx, dy);

         nsRefPtr<gfxASurface> ret = mSurface;

         return ret.forget();

     }

     if (dx && dy)

         cairo_surface_get_device_offset(s, dx, dy);

     return gfxASurface::Wrap(s);

   } else {

     if (mDT->GetType() == BackendType::CAIRO) {

         cairo_surface_t *s =

             (cairo_surface_t*)mDT->GetNativeSurface(NativeSurfaceType::CAIRO_SURFACE);

         if (s) {

             if (dx && dy) {

                 *dx = -CurrentState().deviceOffset.x;

                 *dy = -CurrentState().deviceOffset.y;

             }

             return gfxASurface::Wrap(s);

         }

     }

     if (dx && dy) {

       *dx = *dy = 0;

     }

     // An Azure context doesn't have a surface backing it.

     return nullptr;

   }

 }

 cairo_t *

 gfxContext::GetCairo()

 {

   if (mCairo) {

     return mCairo;

   }

   if (mDT->GetType() == BackendType::CAIRO) {

     cairo_t *ctx =

       (cairo_t*)mDT->GetNativeSurface(NativeSurfaceType::CAIRO_CONTEXT);

     if (ctx) {

       return ctx;

     }

   }

   if (mRefCairo) {

     // Set transform!

     return mRefCairo;

   }

   mRefCairo = cairo_create(gfxPlatform::GetPlatform()->ScreenReferenceSurface()->CairoSurface()); 

   return mRefCairo;

 }

 void

 gfxContext::Save()

 {

   if (mCairo) {

     cairo_save(mCairo);

   } else {

     CurrentState().transform = mTransform;

     mStateStack.AppendElement(AzureState(CurrentState()));

     CurrentState().clipWasReset = false;

     CurrentState().pushedClips.Clear();

   }

 }

 void

 gfxContext::Restore()

 {

   if (mCairo) {

     cairo_restore(mCairo);

   } else {

     for (unsigned int c = 0; c < CurrentState().pushedClips.Length(); c++) {

       mDT->PopClip();

     }

     if (CurrentState().clipWasReset &&

         CurrentState().drawTarget == mStateStack[mStateStack.Length() - 2].drawTarget) {

       PushClipsToDT(mDT);

     }

     mStateStack.RemoveElementAt(mStateStack.Length() - 1);

     mDT = CurrentState().drawTarget;

     ChangeTransform(CurrentState().transform, false);

   }

 }

 // drawing

 void

 gfxContext::NewPath()

 {

   if (mCairo) {

     cairo_new_path(mCairo);

   } else {

     mPath = nullptr;

     mPathBuilder = nullptr;

     mPathIsRect = false;

     mTransformChanged = false;

   }

 }

 void

 gfxContext::ClosePath()

 {

   if (mCairo) {

     cairo_close_path(mCairo);

   } else {

     EnsurePathBuilder();

     mPathBuilder->Close();

   }

 }

 already_AddRefed<gfxPath> gfxContext::CopyPath()

 {

   nsRefPtr<gfxPath> path;

   if (mCairo) {

     path = new gfxPath(cairo_copy_path(mCairo));

   } else {

     EnsurePath();

     path = new gfxPath(mPath);

   }

   return path.forget();

 }

 void gfxContext::SetPath(gfxPath* path)

 {

   if (mCairo) {

     cairo_new_path(mCairo);

     if (path->mPath->status == CAIRO_STATUS_SUCCESS && path->mPath->num_data != 0)

         cairo_append_path(mCairo, path->mPath);

   } else {

     MOZ_ASSERT(path->mMoz2DPath, "Can't mix cairo and azure paths!");

     MOZ_ASSERT(path->mMoz2DPath->GetBackendType() == mDT->GetType());

     mPath = path->mMoz2DPath;

     mPathBuilder = nullptr;

     mPathIsRect = false;

     mTransformChanged = false;

   }

 }

 gfxPoint

 gfxContext::CurrentPoint()

 {

   if (mCairo) {

     double x, y;

     cairo_get_current_point(mCairo, &x, &y);

     return gfxPoint(x, y);

   } else {

     EnsurePathBuilder();

     return ThebesPoint(mPathBuilder->CurrentPoint());

   }

 }

 void

 gfxContext::Stroke()

 {

   if (mCairo) {

     cairo_stroke_preserve(mCairo);

   } else {

     AzureState &state = CurrentState();

     if (mPathIsRect) {

       MOZ_ASSERT(!mTransformChanged);

       mDT->StrokeRect(mRect, GeneralPattern(this),

                       state.strokeOptions,

                       DrawOptions(1.0f, GetOp(), state.aaMode));

     } else {

       EnsurePath();

       mDT->Stroke(mPath, GeneralPattern(this), state.strokeOptions,

                   DrawOptions(1.0f, GetOp(), state.aaMode));

     }

   }

 }

 void

 gfxContext::Fill()

 {

   PROFILER_LABEL("gfxContext", "Fill");

   if (mCairo) {

     cairo_fill_preserve(mCairo);

   } else {

     FillAzure(1.0f);

   }

 }

 void

 gfxContext::FillWithOpacity(gfxFloat aOpacity)

 {

   if (mCairo) {

     // This method exists in the hope that one day cairo gets a direct

     // API for this, and then we would change this method to use that

     // API instead.

     if (aOpacity != 1.0) {

       gfxContextAutoSaveRestore saveRestore(this);

       Clip();

       Paint(aOpacity);

     } else {

       Fill();

     }

   } else {

     FillAzure(Float(aOpacity));

   }

 }

 void

 gfxContext::MoveTo(const gfxPoint& pt)

 {

   if (mCairo) {

     cairo_move_to(mCairo, pt.x, pt.y);

   } else {

     EnsurePathBuilder();

     mPathBuilder->MoveTo(ToPoint(pt));

   }

 }

 void

 gfxContext::NewSubPath()

 {

   if (mCairo) {

     cairo_new_sub_path(mCairo);

   } else {

     // XXX - This has no users, we should kill it, it should be equivelant to a

     // MoveTo to the path's current point.

   }

 }

 void

 gfxContext::LineTo(const gfxPoint& pt)

 {

   if (mCairo) {

     cairo_line_to(mCairo, pt.x, pt.y);

   } else {

     EnsurePathBuilder();

     mPathBuilder->LineTo(ToPoint(pt));

   }

 }

 void

 gfxContext::CurveTo(const gfxPoint& pt1, const gfxPoint& pt2, const gfxPoint& pt3)

 {

   if (mCairo) {

     cairo_curve_to(mCairo, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y);

   } else {

     EnsurePathBuilder();

     mPathBuilder->BezierTo(ToPoint(pt1), ToPoint(pt2), ToPoint(pt3));

   }

 }

 void

 gfxContext::QuadraticCurveTo(const gfxPoint& pt1, const gfxPoint& pt2)

 {

   if (mCairo) {

     double cx, cy;

     cairo_get_current_point(mCairo, &cx, &cy);

     cairo_curve_to(mCairo,

                    (cx + pt1.x * 2.0) / 3.0,

                    (cy + pt1.y * 2.0) / 3.0,

                    (pt1.x * 2.0 + pt2.x) / 3.0,

                    (pt1.y * 2.0 + pt2.y) / 3.0,

                    pt2.x,

                    pt2.y);

   } else {

     EnsurePathBuilder();

     mPathBuilder->QuadraticBezierTo(ToPoint(pt1), ToPoint(pt2));

   }

 }

 void

 gfxContext::Arc(const gfxPoint& center, gfxFloat radius,

                 gfxFloat angle1, gfxFloat angle2)

 {

   if (mCairo) {

     cairo_arc(mCairo, center.x, center.y, radius, angle1, angle2);

   } else {

     EnsurePathBuilder();

     mPathBuilder->Arc(ToPoint(center), Float(radius), Float(angle1), Float(angle2));

   }

 }

 void

 gfxContext::NegativeArc(const gfxPoint& center, gfxFloat radius,

                         gfxFloat angle1, gfxFloat angle2)

 {

   if (mCairo) {

     cairo_arc_negative(mCairo, center.x, center.y, radius, angle1, angle2);

   } else {

     EnsurePathBuilder();

     mPathBuilder->Arc(ToPoint(center), Float(radius), Float(angle2), Float(angle1));

   }

 }

 void

 gfxContext::Line(const gfxPoint& start, const gfxPoint& end)

 {

   if (mCairo) {

     MoveTo(start);

     LineTo(end);

   } else {

     EnsurePathBuilder();

     mPathBuilder->MoveTo(ToPoint(start));

     mPathBuilder->LineTo(ToPoint(end));

   }

 }

 // XXX snapToPixels is only valid when snapping for filled

 // rectangles and for even-width stroked rectangles.

 // For odd-width stroked rectangles, we need to offset x/y by

 // 0.5...

 void

 gfxContext::Rectangle(const gfxRect& rect, bool snapToPixels)

 {

   if (mCairo) {

     if (snapToPixels) {

         gfxRect snappedRect(rect);

         if (UserToDevicePixelSnapped(snappedRect, true))

         {

             cairo_matrix_t mat;

             cairo_get_matrix(mCairo, &mat);

             cairo_identity_matrix(mCairo);

             Rectangle(snappedRect);

             cairo_set_matrix(mCairo, &mat);

             return;

         }

     }

     cairo_rectangle(mCairo, rect.X(), rect.Y(), rect.Width(), rect.Height());

   } else {

     Rect rec = ToRect(rect);

     if (snapToPixels) {

       gfxRect newRect(rect);

       if (UserToDevicePixelSnapped(newRect, true)) {

         gfxMatrix mat = ThebesMatrix(mTransform);

         mat.Invert();

         // We need the user space rect.

         rec = ToRect(mat.TransformBounds(newRect));

       }

     }

     if (!mPathBuilder && !mPathIsRect) {

       mPathIsRect = true;

       mRect = rec;

       return;

     }

     EnsurePathBuilder();

     mPathBuilder->MoveTo(rec.TopLeft());

     mPathBuilder->LineTo(rec.TopRight());

     mPathBuilder->LineTo(rec.BottomRight());

     mPathBuilder->LineTo(rec.BottomLeft());

     mPathBuilder->Close();

   }

 }

 void

 gfxContext::Ellipse(const gfxPoint& center, const gfxSize& dimensions)

 {

   gfxSize halfDim = dimensions / 2.0;

   gfxRect r(center - gfxPoint(halfDim.width, halfDim.height), dimensions);

   gfxCornerSizes c(halfDim, halfDim, halfDim, halfDim);

   RoundedRectangle (r, c);

 }

 void

 gfxContext::Polygon(const gfxPoint *points, uint32_t numPoints)

 {

   if (mCairo) {

     if (numPoints == 0)

         return;

     cairo_move_to(mCairo, points[0].x, points[0].y);

     for (uint32_t i = 1; i < numPoints; ++i) {

         cairo_line_to(mCairo, points[i].x, points[i].y);

     }

   } else {

     if (numPoints == 0) {

       return;

     }

     EnsurePathBuilder();

     mPathBuilder->MoveTo(ToPoint(points[0]));

     for (uint32_t i = 1; i < numPoints; i++) {

       mPathBuilder->LineTo(ToPoint(points[i]));

     }

   }

 }

 void

 gfxContext::DrawSurface(gfxASurface *surface, const gfxSize& size)

 {

   if (mCairo) {

     cairo_save(mCairo);

     cairo_set_source_surface(mCairo, surface->CairoSurface(), 0, 0);

     cairo_new_path(mCairo);

     // pixel-snap this

     Rectangle(gfxRect(gfxPoint(0.0, 0.0), size), true);

     cairo_fill(mCairo);

     cairo_restore(mCairo);

   } else {

     // Lifetime needs to be limited here since we may wrap surface's data.

     RefPtr<SourceSurface> surf =

       gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(mDT, surface);

     if (!surf) {

       return;

     }

     Rect rect(0, 0, Float(size.width), Float(size.height));

     rect.Intersect(Rect(0, 0, Float(surf->GetSize().width), Float(surf->GetSize().height)));

     // XXX - Should fix pixel snapping.

     mDT->DrawSurface(surf, rect, rect);

   }

 }

 // transform stuff

 void

 gfxContext::Translate(const gfxPoint& pt)

 {

   if (mCairo) {

     cairo_translate(mCairo, pt.x, pt.y);

   } else {

     Matrix newMatrix = mTransform;

     ChangeTransform(newMatrix.Translate(Float(pt.x), Float(pt.y)));

   }

 }

 void

 gfxContext::Scale(gfxFloat x, gfxFloat y)

 {

   if (mCairo) {

     cairo_scale(mCairo, x, y);

   } else {

     Matrix newMatrix = mTransform;

     ChangeTransform(newMatrix.Scale(Float(x), Float(y)));

   }

 }

 void

 gfxContext::Rotate(gfxFloat angle)

 {

   if (mCairo) {

     cairo_rotate(mCairo, angle);

   } else {

     Matrix rotation = Matrix::Rotation(Float(angle));

     ChangeTransform(rotation * mTransform);

   }

 }

 void

 gfxContext::Multiply(const gfxMatrix& matrix)

 {

   if (mCairo) {

     const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);

     cairo_transform(mCairo, &mat);

   } else {

     ChangeTransform(ToMatrix(matrix) * mTransform);

   }

 }

 void

 gfxContext::MultiplyAndNudgeToIntegers(const gfxMatrix& matrix)

 {

   if (mCairo) {

     const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);

     cairo_transform(mCairo, &mat);

     // XXX nudging to integers not currently supported for Thebes

   } else {

     Matrix transform = ToMatrix(matrix) * mTransform;

     transform.NudgeToIntegers();

     ChangeTransform(transform);

   }

 }

 void

 gfxContext::SetMatrix(const gfxMatrix& matrix)

 {

   if (mCairo) {

     const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);

     cairo_set_matrix(mCairo, &mat);

   } else {

     ChangeTransform(ToMatrix(matrix));

   }

 }

 void

 gfxContext::IdentityMatrix()

 {

   if (mCairo) {

     cairo_identity_matrix(mCairo);

   } else {

     ChangeTransform(Matrix());

   }

 }

 gfxMatrix

 gfxContext::CurrentMatrix() const

 {

   if (mCairo) {

     cairo_matrix_t mat;

     cairo_get_matrix(mCairo, &mat);

     return gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat));

   } else {

     return ThebesMatrix(mTransform);

   }

 }

 void

 gfxContext::NudgeCurrentMatrixToIntegers()

 {

   if (mCairo) {

     cairo_matrix_t mat;

     cairo_get_matrix(mCairo, &mat);

     gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat)).NudgeToIntegers();

     cairo_set_matrix(mCairo, &mat);

   } else {

     gfxMatrix matrix = ThebesMatrix(mTransform);

     matrix.NudgeToIntegers();

     ChangeTransform(ToMatrix(matrix));

   }

 }

 gfxPoint

 gfxContext::DeviceToUser(const gfxPoint& point) const

 {

   if (mCairo) {

     gfxPoint ret = point;

     cairo_device_to_user(mCairo, &ret.x, &ret.y);

     return ret;

   } else {

     Matrix matrix = mTransform;

     matrix.Invert();

     return ThebesPoint(matrix * ToPoint(point));

   }

 }

 gfxSize

 gfxContext::DeviceToUser(const gfxSize& size) const

 {

   if (mCairo) {

     gfxSize ret = size;

     cairo_device_to_user_distance(mCairo, &ret.width, &ret.height);

     return ret;

   } else {

     Matrix matrix = mTransform;

     matrix.Invert();

     return ThebesSize(matrix * ToSize(size));

   }

 }

 gfxRect

 gfxContext::DeviceToUser(const gfxRect& rect) const

 {

   if (mCairo) {

     gfxRect ret = rect;

     cairo_device_to_user(mCairo, &ret.x, &ret.y);

     cairo_device_to_user_distance(mCairo, &ret.width, &ret.height);

     return ret;

   } else {

     Matrix matrix = mTransform;

     matrix.Invert();

     return ThebesRect(matrix.TransformBounds(ToRect(rect)));

   }

 }

 gfxPoint

 gfxContext::UserToDevice(const gfxPoint& point) const

 {

   if (mCairo) {

     gfxPoint ret = point;

     cairo_user_to_device(mCairo, &ret.x, &ret.y);

     return ret;

   } else {

     return ThebesPoint(mTransform * ToPoint(point));

   }

 }

 gfxSize

 gfxContext::UserToDevice(const gfxSize& size) const

 {

   if (mCairo) {

     gfxSize ret = size;

     cairo_user_to_device_distance(mCairo, &ret.width, &ret.height);

     return ret;

   } else {

     const Matrix &matrix = mTransform;

     gfxSize newSize;

     newSize.width = size.width * matrix._11 + size.height * matrix._12;

     newSize.height = size.width * matrix._21 + size.height * matrix._22;

     return newSize;

   }

 }

 gfxRect

 gfxContext::UserToDevice(const gfxRect& rect) const

 {

   if (mCairo) {

     double xmin = rect.X(), ymin = rect.Y(), xmax = rect.XMost(), ymax = rect.YMost();

     double x[3], y[3];

     x[0] = xmin;  y[0] = ymax;

     x[1] = xmax;  y[1] = ymax;

     x[2] = xmax;  y[2] = ymin;

     cairo_user_to_device(mCairo, &xmin, &ymin);

     xmax = xmin;

     ymax = ymin;

     for (int i = 0; i < 3; i++) {

         cairo_user_to_device(mCairo, &x[i], &y[i]);

         xmin = std::min(xmin, x[i]);

         xmax = std::max(xmax, x[i]);

         ymin = std::min(ymin, y[i]);

         ymax = std::max(ymax, y[i]);

     }

     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);

   } else {

     const Matrix &matrix = mTransform;

     return ThebesRect(matrix.TransformBounds(ToRect(rect)));

   }

 }

 bool

 gfxContext::UserToDevicePixelSnapped(gfxRect& rect, bool ignoreScale) const

 {

   if (GetFlags() & FLAG_DISABLE_SNAPPING)

       return false;

   // if we're not at 1.0 scale, don't snap, unless we're

   // ignoring the scale.  If we're not -just- a scale,

   // never snap.

   const gfxFloat epsilon = 0.0000001;

 #define WITHIN_E(a,b) (fabs((a)-(b)) < epsilon)

   if (mCairo) {

     cairo_matrix_t mat;

     cairo_get_matrix(mCairo, &mat);

     if (!ignoreScale &&

         (!WITHIN_E(mat.xx,1.0) || !WITHIN_E(mat.yy,1.0) ||

           !WITHIN_E(mat.xy,0.0) || !WITHIN_E(mat.yx,0.0)))

         return false;

   } else {

     Matrix mat = mTransform;

     if (!ignoreScale &&

         (!WITHIN_E(mat._11,1.0) || !WITHIN_E(mat._22,1.0) ||

           !WITHIN_E(mat._12,0.0) || !WITHIN_E(mat._21,0.0)))

         return false;

   }

 #undef WITHIN_E

   gfxPoint p1 = UserToDevice(rect.TopLeft());

   gfxPoint p2 = UserToDevice(rect.TopRight());

   gfxPoint p3 = UserToDevice(rect.BottomRight());

   // Check that the rectangle is axis-aligned. For an axis-aligned rectangle,

   // two opposite corners define the entire rectangle. So check if

   // the axis-aligned rectangle with opposite corners p1 and p3

   // define an axis-aligned rectangle whose other corners are p2 and p4.

   // We actually only need to check one of p2 and p4, since an affine

   // transform maps parallelograms to parallelograms.

   if (p2 == gfxPoint(p1.x, p3.y) || p2 == gfxPoint(p3.x, p1.y)) {

       p1.Round();

       p3.Round();

       rect.MoveTo(gfxPoint(std::min(p1.x, p3.x), std::min(p1.y, p3.y)));

       rect.SizeTo(gfxSize(std::max(p1.x, p3.x) - rect.X(),

                           std::max(p1.y, p3.y) - rect.Y()));

       return true;

   }

   return false;

 }

 bool

 gfxContext::UserToDevicePixelSnapped(gfxPoint& pt, bool ignoreScale) const

 {

   if (GetFlags() & FLAG_DISABLE_SNAPPING)

       return false;

   // if we're not at 1.0 scale, don't snap, unless we're

   // ignoring the scale.  If we're not -just- a scale,

   // never snap.

   const gfxFloat epsilon = 0.0000001;

 #define WITHIN_E(a,b) (fabs((a)-(b)) < epsilon)

   if (mCairo) {

     cairo_matrix_t mat;

     cairo_get_matrix(mCairo, &mat);

     if (!ignoreScale &&

         (!WITHIN_E(mat.xx,1.0) || !WITHIN_E(mat.yy,1.0) ||

           !WITHIN_E(mat.xy,0.0) || !WITHIN_E(mat.yx,0.0)))

         return false;

   } else {

     Matrix mat = mTransform;

     if (!ignoreScale &&

         (!WITHIN_E(mat._11,1.0) || !WITHIN_E(mat._22,1.0) ||

           !WITHIN_E(mat._12,0.0) || !WITHIN_E(mat._21,0.0)))

         return false;

   }

 #undef WITHIN_E

   pt = UserToDevice(pt);

   pt.Round();

   return true;

 }

 void

 gfxContext::PixelSnappedRectangleAndSetPattern(const gfxRect& rect,

                                                gfxPattern *pattern)

 {

   gfxRect r(rect);

   // Bob attempts to pixel-snap the rectangle, and returns true if

   // the snapping succeeds.  If it does, we need to set up an

   // identity matrix, because the rectangle given back is in device

   // coordinates.

   //

   // We then have to call a translate to dr.pos afterwards, to make

   // sure the image lines up in the right place with our pixel

   // snapped rectangle.

   //

   // If snapping wasn't successful, we just translate to where the

   // pattern would normally start (in app coordinates) and do the

   // same thing.

   Rectangle(r, true);

   SetPattern(pattern);

 }

 void

 gfxContext::SetAntialiasMode(AntialiasMode mode)

 {

   if (mCairo) {

     if (mode == MODE_ALIASED) {

         cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_NONE);

     } else if (mode == MODE_COVERAGE) {

         cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_DEFAULT);

     }

   } else {

     if (mode == MODE_ALIASED) {

       CurrentState().aaMode = gfx::AntialiasMode::NONE;

     } else if (mode == MODE_COVERAGE) {

       CurrentState().aaMode = gfx::AntialiasMode::SUBPIXEL;

     }

   }

 }

 gfxContext::AntialiasMode

 gfxContext::CurrentAntialiasMode() const

 {

   if (mCairo) {

     cairo_antialias_t aa = cairo_get_antialias(mCairo);

     if (aa == CAIRO_ANTIALIAS_NONE)

         return MODE_ALIASED;

     return MODE_COVERAGE;

   } else {

     if (CurrentState().aaMode == gfx::AntialiasMode::NONE) {

       return MODE_ALIASED;

     }

     return MODE_COVERAGE;

   }

 }

 void

 gfxContext::SetDash(gfxLineType ltype)

 {

   static double dash[] = {5.0, 5.0};

   static double dot[] = {1.0, 1.0};

   switch (ltype) {

       case gfxLineDashed:

           SetDash(dash, 2, 0.0);

           break;

       case gfxLineDotted:

           SetDash(dot, 2, 0.0);

           break;

       case gfxLineSolid:

       default:

           SetDash(nullptr, 0, 0.0);

           break;

   }

 }

 void

 gfxContext::SetDash(gfxFloat *dashes, int ndash, gfxFloat offset)

 {

   if (mCairo) {

     cairo_set_dash(mCairo, dashes, ndash, offset);

   } else {

     AzureState &state = CurrentState();

     state.dashPattern.SetLength(ndash);

     for (int i = 0; i < ndash; i++) {

       state.dashPattern[i] = Float(dashes[i]);

     }

     state.strokeOptions.mDashLength = ndash;

     state.strokeOptions.mDashOffset = Float(offset);

     state.strokeOptions.mDashPattern = ndash ? state.dashPattern.Elements()

                                              : nullptr;

   }

 }

 bool

 gfxContext::CurrentDash(FallibleTArray<gfxFloat>& dashes, gfxFloat* offset) const

 {

   if (mCairo) {

     int count = cairo_get_dash_count(mCairo);

     if (count <= 0 || !dashes.SetLength(count)) {

         return false;

     }

     cairo_get_dash(mCairo, dashes.Elements(), offset);

     return true;

   } else {

     const AzureState &state = CurrentState();

     int count = state.strokeOptions.mDashLength;

     if (count <= 0 || !dashes.SetLength(count)) {

       return false;

     }

     for (int i = 0; i < count; i++) {

       dashes[i] = state.dashPattern[i];

     }

     *offset = state.strokeOptions.mDashOffset;

     return true;

   }

 }

 gfxFloat

 gfxContext::CurrentDashOffset() const

 {

   if (mCairo) {

     if (cairo_get_dash_count(mCairo) <= 0) {

         return 0.0;

     }

     gfxFloat offset;

     cairo_get_dash(mCairo, nullptr, &offset);

     return offset;

   } else {

     return CurrentState().strokeOptions.mDashOffset;

   }

 }

 void

 gfxContext::SetLineWidth(gfxFloat width)

 {

   if (mCairo) {

     cairo_set_line_width(mCairo, width);

   } else {

     CurrentState().strokeOptions.mLineWidth = Float(width);

   }

 }

 gfxFloat

 gfxContext::CurrentLineWidth() const

 {

   if (mCairo) {

     return cairo_get_line_width(mCairo);

   } else {

     return CurrentState().strokeOptions.mLineWidth;

   }

 }

 void

 gfxContext::SetOperator(GraphicsOperator op)

 {

   if (mCairo) {

     if (mFlags & FLAG_SIMPLIFY_OPERATORS) {

         if (op != OPERATOR_SOURCE &&

             op != OPERATOR_CLEAR &&

             op != OPERATOR_OVER)

             op = OPERATOR_OVER;

     }

     cairo_set_operator(mCairo, (cairo_operator_t)op);

   } else {

     if (op == OPERATOR_CLEAR) {

       CurrentState().opIsClear = true;

       return;

     }

     CurrentState().opIsClear = false;

     CurrentState().op = CompositionOpForOp(op);

   }

 }

 gfxContext::GraphicsOperator

 gfxContext::CurrentOperator() const

 {

   if (mCairo) {

     return (GraphicsOperator)cairo_get_operator(mCairo);

   } else {

     return ThebesOp(CurrentState().op);

   }

 }

 void

 gfxContext::SetLineCap(GraphicsLineCap cap)

 {

   if (mCairo) {

     cairo_set_line_cap(mCairo, (cairo_line_cap_t)cap);

   } else {

     CurrentState().strokeOptions.mLineCap = ToCapStyle(cap);

   }

 }

 gfxContext::GraphicsLineCap

 gfxContext::CurrentLineCap() const

 {

   if (mCairo) {

     return (GraphicsLineCap)cairo_get_line_cap(mCairo);

   } else {

     return ThebesLineCap(CurrentState().strokeOptions.mLineCap);

   }

 }

 void

 gfxContext::SetLineJoin(GraphicsLineJoin join)

 {

   if (mCairo) {

     cairo_set_line_join(mCairo, (cairo_line_join_t)join);

   } else {

     CurrentState().strokeOptions.mLineJoin = ToJoinStyle(join);

   }

 }

 gfxContext::GraphicsLineJoin

 gfxContext::CurrentLineJoin() const

 {

   if (mCairo) {

     return (GraphicsLineJoin)cairo_get_line_join(mCairo);

   } else {

     return ThebesLineJoin(CurrentState().strokeOptions.mLineJoin);

   }

 }

 void

 gfxContext::SetMiterLimit(gfxFloat limit)

 {

   if (mCairo) {

     cairo_set_miter_limit(mCairo, limit);

   } else {

     CurrentState().strokeOptions.mMiterLimit = Float(limit);

   }

 }

 gfxFloat

 gfxContext::CurrentMiterLimit() const

 {

   if (mCairo) {

     return cairo_get_miter_limit(mCairo);

   } else {

     return CurrentState().strokeOptions.mMiterLimit;

   }

 }

 void

 gfxContext::SetFillRule(FillRule rule)

 {

   if (mCairo) {

     cairo_set_fill_rule(mCairo, (cairo_fill_rule_t)rule);

   } else {

     CurrentState().fillRule = rule == FILL_RULE_WINDING ? gfx::FillRule::FILL_WINDING : gfx::FillRule::FILL_EVEN_ODD;

   }

 }

 gfxContext::FillRule

 gfxContext::CurrentFillRule() const

 {

   if (mCairo) {

     return (FillRule)cairo_get_fill_rule(mCairo);

   } else {

     return FILL_RULE_WINDING;

   }

 }

 // clipping

 void

 gfxContext::Clip(const gfxRect& rect)

 {

   if (mCairo) {

     cairo_new_path(mCairo);

     cairo_rectangle(mCairo, rect.X(), rect.Y(), rect.Width(), rect.Height());

     cairo_clip(mCairo);

   } else {

     AzureState::PushedClip clip = { nullptr, ToRect(rect), mTransform };

     CurrentState().pushedClips.AppendElement(clip);

     mDT->PushClipRect(ToRect(rect));

     NewPath();

   }

 }

 void

 gfxContext::Clip()

 {

   if (mCairo) {

     cairo_clip_preserve(mCairo);

   } else {

     if (mPathIsRect) {

       MOZ_ASSERT(!mTransformChanged);

       AzureState::PushedClip clip = { nullptr, mRect, mTransform };

       CurrentState().pushedClips.AppendElement(clip);

       mDT->PushClipRect(mRect);

     } else {

       EnsurePath();

       mDT->PushClip(mPath);

       AzureState::PushedClip clip = { mPath, Rect(), mTransform };

       CurrentState().pushedClips.AppendElement(clip);

     }

   }

 }

 void

 gfxContext::ResetClip()

 {

   if (mCairo) {

     cairo_reset_clip(mCairo);

   } else {

     for (int i = mStateStack.Length() - 1; i >= 0; i--) {

       for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {

         mDT->PopClip();

       }

       if (mStateStack[i].clipWasReset) {

         break;

       }

     }

     CurrentState().pushedClips.Clear();

     CurrentState().clipWasReset = true;

   }

 }

 void

 gfxContext::UpdateSurfaceClip()

 {

   if (mCairo) {

     NewPath();

     // we paint an empty rectangle to ensure the clip is propagated to

     // the destination surface

     SetDeviceColor(gfxRGBA(0,0,0,0));

     Rectangle(gfxRect(0,1,1,0));

     Fill();

   }

 }

 gfxRect

 gfxContext::GetClipExtents()

 {

   if (mCairo) {

     double xmin, ymin, xmax, ymax;

     cairo_clip_extents(mCairo, &xmin, &ymin, &xmax, &ymax);

     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);

   } else {

     Rect rect = GetAzureDeviceSpaceClipBounds();

     if (rect.width == 0 || rect.height == 0) {

       return gfxRect(0, 0, 0, 0);

     }

     Matrix mat = mTransform;

     mat.Invert();

     rect = mat.TransformBounds(rect);

     return ThebesRect(rect);

   }

 }

 bool

 gfxContext::ClipContainsRect(const gfxRect& aRect)

 {

   if (mCairo) {

     cairo_rectangle_list_t *clip =

         cairo_copy_clip_rectangle_list(mCairo);

     bool result = false;

     if (clip->status == CAIRO_STATUS_SUCCESS) {

         for (int i = 0; i < clip->num_rectangles; i++) {

             gfxRect rect(clip->rectangles[i].x, clip->rectangles[i].y,

                          clip->rectangles[i].width, clip->rectangles[i].height);

             if (rect.Contains(aRect)) {

                 result = true;

                 break;

             }

         }

     }

     cairo_rectangle_list_destroy(clip);

     return result;

   } else {

     unsigned int lastReset = 0;

     for (int i = mStateStack.Length() - 2; i > 0; i--) {

       if (mStateStack[i].clipWasReset) {

         lastReset = i;

         break;

       }

     }

     // Since we always return false when the clip list contains a

     // non-rectangular clip or a non-rectilinear transform, our 'total' clip

     // is always a rectangle if we hit the end of this function.

     Rect clipBounds(0, 0, Float(mDT->GetSize().width), Float(mDT->GetSize().height));

     for (unsigned int i = lastReset; i < mStateStack.Length(); i++) {

       for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {

         AzureState::PushedClip &clip = mStateStack[i].pushedClips[c];

         if (clip.path || !clip.transform.IsRectilinear()) {

           // Cairo behavior is we return false if the clip contains a non-

           // rectangle.

           return false;

         } else {

           Rect clipRect = mTransform.TransformBounds(clip.rect);

           clipBounds.IntersectRect(clipBounds, clipRect);

         }

       }

     }

     return clipBounds.Contains(ToRect(aRect));

   }

 }

 // rendering sources

 void

 gfxContext::SetColor(const gfxRGBA& c)

 {

   if (mCairo) {

     if (gfxPlatform::GetCMSMode() == eCMSMode_All) {

         gfxRGBA cms;

         qcms_transform *transform = gfxPlatform::GetCMSRGBTransform();

         if (transform)

           gfxPlatform::TransformPixel(c, cms, transform);

         // Use the original alpha to avoid unnecessary float->byte->float

         // conversion errors

         cairo_set_source_rgba(mCairo, cms.r, cms.g, cms.b, c.a);

     }

     else

         cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);

   } else {

     CurrentState().pattern = nullptr;

     CurrentState().sourceSurfCairo = nullptr;

     CurrentState().sourceSurface = nullptr;

     if (gfxPlatform::GetCMSMode() == eCMSMode_All) {

         gfxRGBA cms;

         qcms_transform *transform = gfxPlatform::GetCMSRGBTransform();

         if (transform)

           gfxPlatform::TransformPixel(c, cms, transform);

         // Use the original alpha to avoid unnecessary float->byte->float

         // conversion errors

         CurrentState().color = ToColor(cms);

     }

     else

         CurrentState().color = ToColor(c);

   }

 }

 void

 gfxContext::SetDeviceColor(const gfxRGBA& c)

 {

   if (mCairo) {

     cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);

   } else {

     CurrentState().pattern = nullptr;

     CurrentState().sourceSurfCairo = nullptr;

     CurrentState().sourceSurface = nullptr;

     CurrentState().color = ToColor(c);

   }

 }

 bool

 gfxContext::GetDeviceColor(gfxRGBA& c)

 {

   if (mCairo) {

     return cairo_pattern_get_rgba(cairo_get_source(mCairo),

                                   &c.r,

                                   &c.g,

                                   &c.b,

                                   &c.a) == CAIRO_STATUS_SUCCESS;

   } else {

     if (CurrentState().sourceSurface) {

       return false;

     }

     if (CurrentState().pattern) {

       gfxRGBA color;

       return CurrentState().pattern->GetSolidColor(c);

     }

     c = ThebesRGBA(CurrentState().color);

     return true;

   }

 }

 void

 gfxContext::SetSource(gfxASurface *surface, const gfxPoint& offset)

 {

   if (mCairo) {

     NS_ASSERTION(surface->GetAllowUseAsSource(), "Surface not allowed to be used as source!");

     cairo_set_source_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);

   } else {

     CurrentState().surfTransform = Matrix(1.0f, 0, 0, 1.0f, Float(offset.x), Float(offset.y));

     CurrentState().pattern = nullptr;

     CurrentState().patternTransformChanged = false;

     // Keep the underlying cairo surface around while we keep the

     // sourceSurface.

     CurrentState().sourceSurfCairo = surface;

     CurrentState().sourceSurface =

       gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(mDT, surface);

     CurrentState().color = Color(0, 0, 0, 0);

   }

 }

 void

 gfxContext::SetPattern(gfxPattern *pattern)

 {

   if (mCairo) {

     MOZ_ASSERT(!pattern->IsAzure());

     cairo_set_source(mCairo, pattern->CairoPattern());

   } else {

     CurrentState().sourceSurfCairo = nullptr;

     CurrentState().sourceSurface = nullptr;

     CurrentState().patternTransformChanged = false;

     CurrentState().pattern = pattern;

   }

 }

 already_AddRefed<gfxPattern>

 gfxContext::GetPattern()

 {

   if (mCairo) {

     cairo_pattern_t *pat = cairo_get_source(mCairo);

     NS_ASSERTION(pat, "I was told this couldn't be null");

     nsRefPtr<gfxPattern> wrapper;

     if (pat)

         wrapper = new gfxPattern(pat);

     else

         wrapper = new gfxPattern(gfxRGBA(0,0,0,0));

     return wrapper.forget();

   } else {

     nsRefPtr<gfxPattern> pat;

     AzureState &state = CurrentState();

     if (state.pattern) {

       pat = state.pattern;

     } else if (state.sourceSurface) {

       NS_ASSERTION(false, "Ugh, this isn't good.");

     } else {

       pat = new gfxPattern(ThebesRGBA(state.color));

     }

     return pat.forget();

   }

 }

 // masking

 void

 gfxContext::Mask(gfxPattern *pattern)

 {

   if (mCairo) {

     MOZ_ASSERT(!pattern->IsAzure());

     cairo_mask(mCairo, pattern->CairoPattern());

   } else {

     if (pattern->Extend() == gfxPattern::EXTEND_NONE) {

       // In this situation the mask will be fully transparent (i.e. nothing

       // will be drawn) outside of the bounds of the surface. We can support

       // that by clipping out drawing to that area.

       Point offset;

       if (pattern->IsAzure()) {

         // This is an Azure pattern. i.e. this was the result of a PopGroup and

         // then the extend mode was changed to EXTEND_NONE.

         // XXX - We may need some additional magic here in theory to support

         // device offsets in these patterns, but no problems have been observed

         // yet because of this. And it would complicate things a little further.

         offset = Point(0.f, 0.f);

       } else if (pattern->GetType() == gfxPattern::PATTERN_SURFACE) {

         nsRefPtr<gfxASurface> asurf = pattern->GetSurface();

         gfxPoint deviceOffset = asurf->GetDeviceOffset();

         offset = Point(-deviceOffset.x, -deviceOffset.y);

         // this lets GetAzureSurface work

         pattern->GetPattern(mDT);

       }

       if (pattern->IsAzure() || pattern->GetType() == gfxPattern::PATTERN_SURFACE) {

         RefPtr<SourceSurface> mask = pattern->GetAzureSurface();

         Matrix mat = ToMatrix(pattern->GetInverseMatrix());

         Matrix old = mTransform;

         // add in the inverse of the pattern transform so that when we

         // MaskSurface we are transformed to the place matching the pattern transform

         mat = mat * mTransform;

         ChangeTransform(mat);

         mDT->MaskSurface(GeneralPattern(this), mask, offset, DrawOptions(1.0f, CurrentState().op, CurrentState().aaMode));

         ChangeTransform(old);

         return;

       }

     }

     mDT->Mask(GeneralPattern(this), *pattern->GetPattern(mDT), DrawOptions(1.0f, CurrentState().op, CurrentState().aaMode));

   }

 }

 void

 gfxContext::Mask(gfxASurface *surface, const gfxPoint& offset)

 {

   PROFILER_LABEL("gfxContext", "Mask");

   if (mCairo) {

     cairo_mask_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);

   } else {

     // Lifetime needs to be limited here as we may simply wrap surface's data.

     RefPtr<SourceSurface> sourceSurf =

       gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(mDT, surface);

     if (!sourceSurf) {

       return;

     }

     gfxPoint pt = surface->GetDeviceOffset();

     Mask(sourceSurf, Point(offset.x - pt.x, offset.y - pt.y));

   }

 }

 void

 gfxContext::Mask(SourceSurface *surface, const Point& offset)

 {

   MOZ_ASSERT(mDT);

   // We clip here to bind to the mask surface bounds, see above.

   mDT->MaskSurface(GeneralPattern(this),

             surface,

             offset,

             DrawOptions(1.0f, CurrentState().op, CurrentState().aaMode));

 }

 void

 gfxContext::Paint(gfxFloat alpha)

 {

   PROFILER_LABEL("gfxContext", "Paint");

   if (mCairo) {

     cairo_paint_with_alpha(mCairo, alpha);

   } else {

     AzureState &state = CurrentState();

     if (state.sourceSurface && !state.sourceSurfCairo &&

         !state.patternTransformChanged && !state.opIsClear)

     {

       // This is the case where a PopGroupToSource has been done and this

       // paint is executed without changing the transform or the source.

       Matrix oldMat = mDT->GetTransform();

       IntSize surfSize = state.sourceSurface->GetSize();

       Matrix mat;

       mat.Translate(-state.deviceOffset.x, -state.deviceOffset.y);

       mDT->SetTransform(mat);

       mDT->DrawSurface(state.sourceSurface,

                        Rect(state.sourceSurfaceDeviceOffset, Size(surfSize.width, surfSize.height)),

                        Rect(Point(), Size(surfSize.width, surfSize.height)),

                        DrawSurfaceOptions(), DrawOptions(alpha, GetOp()));

       mDT->SetTransform(oldMat);

       return;

     }

     Matrix mat = mDT->GetTransform();

     mat.Invert();

     Rect paintRect = mat.TransformBounds(Rect(Point(0, 0), Size(mDT->GetSize())));

     if (state.opIsClear) {

       mDT->ClearRect(paintRect);

     } else {

       mDT->FillRect(paintRect, GeneralPattern(this),

                     DrawOptions(Float(alpha), GetOp()));

     }

   }

 }

 // groups

 void

 gfxContext::PushGroup(gfxContentType content)

 {

   if (mCairo) {

     cairo_push_group_with_content(mCairo, (cairo_content_t)(int) content);

   } else {

     PushNewDT(content);

     PushClipsToDT(mDT);

     mDT->SetTransform(GetDTTransform());

   }

 }

 static gfxRect

 GetRoundOutDeviceClipExtents(gfxContext* aCtx)

 {

   gfxContextMatrixAutoSaveRestore save(aCtx);

   aCtx->IdentityMatrix();

   gfxRect r = aCtx->GetClipExtents();

   r.RoundOut();

   return r;

 }

 /**

  * Copy the contents of aSrc to aDest, translated by aTranslation.

  */

 static void

 CopySurface(gfxASurface* aSrc, gfxASurface* aDest, const gfxPoint& aTranslation)

 {

   cairo_t *cr = cairo_create(aDest->CairoSurface());

   cairo_set_source_surface(cr, aSrc->CairoSurface(), aTranslation.x, aTranslation.y);

   cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

   cairo_paint(cr);

   cairo_destroy(cr);

 }

 void

 gfxContext::PushGroupAndCopyBackground(gfxContentType content)

 {

   if (mCairo) {

     if (content == gfxContentType::COLOR_ALPHA &&

       !(GetFlags() & FLAG_DISABLE_COPY_BACKGROUND)) {

       nsRefPtr<gfxASurface> s = CurrentSurface();

       if ((s->GetAllowUseAsSource() || s->GetType() == gfxSurfaceType::Tee) &&

           (s->GetContentType() == gfxContentType::COLOR ||

               s->GetOpaqueRect().Contains(GetRoundOutDeviceClipExtents(this)))) {

         cairo_push_group_with_content(mCairo, CAIRO_CONTENT_COLOR);

         nsRefPtr<gfxASurface> d = CurrentSurface();

         if (d->GetType() == gfxSurfaceType::Tee) {

           NS_ASSERTION(s->GetType() == gfxSurfaceType::Tee, "Mismatched types");

           nsAutoTArray<nsRefPtr<gfxASurface>,2> ss;

           nsAutoTArray<nsRefPtr<gfxASurface>,2> ds;

           static_cast<gfxTeeSurface*>(s.get())->GetSurfaces(&ss);

           static_cast<gfxTeeSurface*>(d.get())->GetSurfaces(&ds);

           NS_ASSERTION(ss.Length() == ds.Length(), "Mismatched lengths");

           gfxPoint translation = d->GetDeviceOffset() - s->GetDeviceOffset();

           for (uint32_t i = 0; i < ss.Length(); ++i) {

               CopySurface(ss[i], ds[i], translation);

           }

         } else {

           CopySurface(s, d, gfxPoint(0, 0));

         }

         d->SetOpaqueRect(s->GetOpaqueRect());

         return;

       }

     }

   } else {

     IntRect clipExtents;

     if (mDT->GetFormat() != SurfaceFormat::B8G8R8X8) {

       gfxRect clipRect = GetRoundOutDeviceClipExtents(this);

       clipExtents = IntRect(clipRect.x, clipRect.y, clipRect.width, clipRect.height);

     }

     if ((mDT->GetFormat() == SurfaceFormat::B8G8R8X8 ||

          mDT->GetOpaqueRect().Contains(clipExtents)) &&

         !mDT->GetUserData(&sDontUseAsSourceKey)) {

       DrawTarget *oldDT = mDT;

       RefPtr<SourceSurface> source = mDT->Snapshot();

       Point oldDeviceOffset = CurrentState().deviceOffset;

       PushNewDT(gfxContentType::COLOR);

       Point offset = CurrentState().deviceOffset - oldDeviceOffset;

       Rect surfRect(0, 0, Float(mDT->GetSize().width), Float(mDT->GetSize().height));

       Rect sourceRect = surfRect;

       sourceRect.x += offset.x;

       sourceRect.y += offset.y;

       mDT->SetTransform(Matrix());

       mDT->DrawSurface(source, surfRect, sourceRect);

       mDT->SetOpaqueRect(oldDT->GetOpaqueRect());

       PushClipsToDT(mDT);

       mDT->SetTransform(GetDTTransform());

       return;

     }

   }

   PushGroup(content);

 }

 already_AddRefed<gfxPattern>

 gfxContext::PopGroup()

 {

   if (mCairo) {

     cairo_pattern_t *pat = cairo_pop_group(mCairo);

     nsRefPtr<gfxPattern> wrapper = new gfxPattern(pat);

     cairo_pattern_destroy(pat);

     return wrapper.forget();

   } else {

     RefPtr<SourceSurface> src = mDT->Snapshot();

     Point deviceOffset = CurrentState().deviceOffset;

     Restore();

     Matrix mat = mTransform;

     mat.Invert();

     Matrix deviceOffsetTranslation;

     deviceOffsetTranslation.Translate(deviceOffset.x, deviceOffset.y);

     nsRefPtr<gfxPattern> pat = new gfxPattern(src, deviceOffsetTranslation * mat);

     return pat.forget();

   }

 }

 void

 gfxContext::PopGroupToSource()

 {

   if (mCairo) {

     cairo_pop_group_to_source(mCairo);

   } else {

     RefPtr<SourceSurface> src = mDT->Snapshot();

     Point deviceOffset = CurrentState().deviceOffset;

     Restore();

     CurrentState().sourceSurfCairo = nullptr;

     CurrentState().sourceSurface = src;

     CurrentState().sourceSurfaceDeviceOffset = deviceOffset;

     CurrentState().pattern = nullptr;

     CurrentState().patternTransformChanged = false;

     Matrix mat = mTransform;

     mat.Invert();

     Matrix deviceOffsetTranslation;

     deviceOffsetTranslation.Translate(deviceOffset.x, deviceOffset.y);

     CurrentState().surfTransform = deviceOffsetTranslation * mat;

   }

 }

 bool

 gfxContext::PointInFill(const gfxPoint& pt)

 {

   if (mCairo) {

     return cairo_in_fill(mCairo, pt.x, pt.y);

   } else {

     EnsurePath();

     return mPath->ContainsPoint(ToPoint(pt), Matrix());

   }

 }

 bool

 gfxContext::PointInStroke(const gfxPoint& pt)

 {

   if (mCairo) {

     return cairo_in_stroke(mCairo, pt.x, pt.y);

   } else {

     EnsurePath();

     return mPath->StrokeContainsPoint(CurrentState().strokeOptions,

                                       ToPoint(pt),

                                       Matrix());

   }

 }

 gfxRect

 gfxContext::GetUserPathExtent()

 {

   if (mCairo) {

     double xmin, ymin, xmax, ymax;

     cairo_path_extents(mCairo, &xmin, &ymin, &xmax, &ymax);

     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);

   } else {

     EnsurePath();

     return ThebesRect(mPath->GetBounds());

   }

 }

 gfxRect

 gfxContext::GetUserFillExtent()

 {

   if (mCairo) {

     double xmin, ymin, xmax, ymax;

     cairo_fill_extents(mCairo, &xmin, &ymin, &xmax, &ymax);

     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);

   } else {

     EnsurePath();

     return ThebesRect(mPath->GetBounds());

   }

 }

 gfxRect

 gfxContext::GetUserStrokeExtent()

 {

   if (mCairo) {

     double xmin, ymin, xmax, ymax;

     cairo_stroke_extents(mCairo, &xmin, &ymin, &xmax, &ymax);

     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);

   } else {

     EnsurePath();

     return ThebesRect(mPath->GetStrokedBounds(CurrentState().strokeOptions, mTransform));

   }

 }

 bool

 gfxContext::HasError()

 {

   if (mCairo) {

     return cairo_status(mCairo) != CAIRO_STATUS_SUCCESS;

   } else {

     // As far as this is concerned, an Azure context is never in error.

     return false;

   }

 }

 void

 gfxContext::RoundedRectangle(const gfxRect& rect,

                              const gfxCornerSizes& corners,

                              bool draw_clockwise)

 {

     //

     // For CW drawing, this looks like:

     //

     //  ...******0**      1    C

     //              ****

     //                  ***    2

     //                     **

     //                       *

     //                        *

     //                         3

     //                         *

     //                         *

     //

     // Where 0, 1, 2, 3 are the control points of the Bezier curve for

     // the corner, and C is the actual corner point.

     //

     // At the start of the loop, the current point is assumed to be

     // the point adjacent to the top left corner on the top

     // horizontal.  Note that corner indices start at the top left and

     // continue clockwise, whereas in our loop i = 0 refers to the top

     // right corner.

     //

     // When going CCW, the control points are swapped, and the first

     // corner that's drawn is the top left (along with the top segment).

     //

     // There is considerable latitude in how one chooses the four

     // control points for a Bezier curve approximation to an ellipse.

     // For the overall path to be continuous and show no corner at the

     // endpoints of the arc, points 0 and 3 must be at the ends of the

     // straight segments of the rectangle; points 0, 1, and C must be

     // collinear; and points 3, 2, and C must also be collinear.  This

     // leaves only two free parameters: the ratio of the line segments

     // 01 and 0C, and the ratio of the line segments 32 and 3C.  See

     // the following papers for extensive discussion of how to choose

     // these ratios:

     //

     //   Dokken, Tor, et al. "Good approximation of circles by

     //      curvature-continuous Bezier curves."  Computer-Aided

     //      Geometric Design 7(1990) 33--41.

     //   Goldapp, Michael. "Approximation of circular arcs by cubic

     //      polynomials." Computer-Aided Geometric Design 8(1991) 227--238.

     //   Maisonobe, Luc. "Drawing an elliptical arc using polylines,

     //      quadratic, or cubic Bezier curves."

     //      http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf

     //

     // We follow the approach in section 2 of Goldapp (least-error,

     // Hermite-type approximation) and make both ratios equal to

     //

     //          2   2 + n - sqrt(2n + 28)

     //  alpha = - * ---------------------

     //          3           n - 4

     //

     // where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ).

     //

     // This is the result of Goldapp's equation (10b) when the angle

     // swept out by the arc is pi/2, and the parameter "a-bar" is the

     // expression given immediately below equation (21).

     //

     // Using this value, the maximum radial error for a circle, as a

     // fraction of the radius, is on the order of 0.2 x 10^-3.

     // Neither Dokken nor Goldapp discusses error for a general

     // ellipse; Maisonobe does, but his choice of control points

     // follows different constraints, and Goldapp's expression for

     // 'alpha' gives much smaller radial error, even for very flat

     // ellipses, than Maisonobe's equivalent.

     //

     // For the various corners and for each axis, the sign of this

     // constant changes, or it might be 0 -- it's multiplied by the

     // appropriate multiplier from the list before using.

   if (mCairo) {

     const gfxFloat alpha = 0.55191497064665766025;

     typedef struct { gfxFloat a, b; } twoFloats;

     twoFloats cwCornerMults[4] = { { -1,  0 },

                                    {  0, -1 },

                                    { +1,  0 },

                                    {  0, +1 } };

     twoFloats ccwCornerMults[4] = { { +1,  0 },

                                     {  0, -1 },

                                     { -1,  0 },

                                     {  0, +1 } };

     twoFloats *cornerMults = draw_clockwise ? cwCornerMults : ccwCornerMults;

     gfxPoint pc, p0, p1, p2, p3;

     if (draw_clockwise)

         cairo_move_to(mCairo, rect.X() + corners[NS_CORNER_TOP_LEFT].width, rect.Y());

     else

         cairo_move_to(mCairo, rect.X() + rect.Width() - corners[NS_CORNER_TOP_RIGHT].width, rect.Y());

     NS_FOR_CSS_CORNERS(i) {

         // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)

         mozilla::css::Corner c = mozilla::css::Corner(draw_clockwise ? ((i+1) % 4) : ((4-i) % 4));

         // i+2 and i+3 respectively.  These are used to index into the corner

         // multiplier table, and were deduced by calculating out the long form

         // of each corner and finding a pattern in the signs and values.

         int i2 = (i+2) % 4;

         int i3 = (i+3) % 4;

         pc = rect.AtCorner(c);

         if (corners[c].width > 0.0 && corners[c].height > 0.0) {

             p0.x = pc.x + cornerMults[i].a * corners[c].width;

             p0.y = pc.y + cornerMults[i].b * corners[c].height;

             p3.x = pc.x + cornerMults[i3].a * corners[c].width;

             p3.y = pc.y + cornerMults[i3].b * corners[c].height;

             p1.x = p0.x + alpha * cornerMults[i2].a * corners[c].width;

             p1.y = p0.y + alpha * cornerMults[i2].b * corners[c].height;

             p2.x = p3.x - alpha * cornerMults[i3].a * corners[c].width;

             p2.y = p3.y - alpha * cornerMults[i3].b * corners[c].height;

             cairo_line_to (mCairo, p0.x, p0.y);

             cairo_curve_to (mCairo,

                             p1.x, p1.y,

                             p2.x, p2.y,

                             p3.x, p3.y);

         } else {

             cairo_line_to (mCairo, pc.x, pc.y);

         }

     }

     cairo_close_path (mCairo);

   } else {

     EnsurePathBuilder();

     Size radii[] = { ToSize(corners[NS_CORNER_TOP_LEFT]),

                      ToSize(corners[NS_CORNER_TOP_RIGHT]),

                      ToSize(corners[NS_CORNER_BOTTOM_RIGHT]),

                      ToSize(corners[NS_CORNER_BOTTOM_LEFT]) };

     AppendRoundedRectToPath(mPathBuilder, ToRect(rect), radii, draw_clockwise);

   }

 }

 #ifdef MOZ_DUMP_PAINTING

 void

 gfxContext::WriteAsPNG(const char* aFile)

 { 

   nsRefPtr<gfxASurface> surf = CurrentSurface();

   if (surf) {

     surf->WriteAsPNG(aFile);

   } else {

     NS_WARNING("No surface found!");

   }

 }

 void 

 gfxContext::DumpAsDataURL()

 { 

   nsRefPtr<gfxASurface> surf = CurrentSurface();

   if (surf) {

     surf->DumpAsDataURL();

   } else {

     NS_WARNING("No surface found!");

   }

 }

 void 

 gfxContext::CopyAsDataURL()

 { 

   nsRefPtr<gfxASurface> surf = CurrentSurface();

   if (surf) {

     surf->CopyAsDataURL();

   } else {

     NS_WARNING("No surface found!");

   }

 }

 #endif

 void

 gfxContext::EnsurePath()

 {

   if (mPathBuilder) {

     mPath = mPathBuilder->Finish();

     mPathBuilder = nullptr;

   }

   if (mPath) {

     if (mTransformChanged) {

       Matrix mat = mTransform;

       mat.Invert();

       mat = mPathTransform * mat;

       mPathBuilder = mPath->TransformedCopyToBuilder(mat, CurrentState().fillRule);

       mPath = mPathBuilder->Finish();

       mPathBuilder = nullptr;

       mTransformChanged = false;

     }

     if (CurrentState().fillRule == mPath->GetFillRule()) {

       return;

     }

     mPathBuilder = mPath->CopyToBuilder(CurrentState().fillRule);

     mPath = mPathBuilder->Finish();

     mPathBuilder = nullptr;

     return;

   }

   EnsurePathBuilder();

   mPath = mPathBuilder->Finish();

   mPathBuilder = nullptr;

 }

 void

 gfxContext::EnsurePathBuilder()

 {

   if (mPathBuilder && !mTransformChanged) {

     return;

   }

   if (mPath) {

     if (!mTransformChanged) {

       mPathBuilder = mPath->CopyToBuilder(CurrentState().fillRule);

       mPath = nullptr;

     } else {

       Matrix invTransform = mTransform;

       invTransform.Invert();

       Matrix toNewUS = mPathTransform * invTransform;

       mPathBuilder = mPath->TransformedCopyToBuilder(toNewUS, CurrentState().fillRule);

     }

     return;

   }

   DebugOnly<PathBuilder*> oldPath = mPathBuilder.get();

   if (!mPathBuilder) {

     mPathBuilder = mDT->CreatePathBuilder(CurrentState().fillRule);

     if (mPathIsRect) {

       mPathBuilder->MoveTo(mRect.TopLeft());

       mPathBuilder->LineTo(mRect.TopRight());

       mPathBuilder->LineTo(mRect.BottomRight());

       mPathBuilder->LineTo(mRect.BottomLeft());

       mPathBuilder->Close();

     }

   }

   if (mTransformChanged) {

     // This could be an else if since this should never happen when

     // mPathBuilder is nullptr and mPath is nullptr. But this way we can

     // assert if all the state is as expected.

     MOZ_ASSERT(oldPath);

     MOZ_ASSERT(!mPathIsRect);

     Matrix invTransform = mTransform;

     invTransform.Invert();

     Matrix toNewUS = mPathTransform * invTransform;

     RefPtr<Path> path = mPathBuilder->Finish();

     mPathBuilder = path->TransformedCopyToBuilder(toNewUS, CurrentState().fillRule);

   }

   mPathIsRect = false;

 }

 void

 gfxContext::FillAzure(Float aOpacity)

 {

   AzureState &state = CurrentState();

   CompositionOp op = GetOp();

   if (mPathIsRect) {

     MOZ_ASSERT(!mTransformChanged);

     if (state.opIsClear) {

       mDT->ClearRect(mRect);

     } else if (op == CompositionOp::OP_SOURCE) {

       // Emulate cairo operator source which is bound by mask!

       mDT->ClearRect(mRect);

       mDT->FillRect(mRect, GeneralPattern(this), DrawOptions(aOpacity));

     } else {

       mDT->FillRect(mRect, GeneralPattern(this), DrawOptions(aOpacity, op, state.aaMode));

     }

   } else {

     EnsurePath();

     NS_ASSERTION(!state.opIsClear, "We shouldn't be clearing complex paths!");

     mDT->Fill(mPath, GeneralPattern(this), DrawOptions(aOpacity, op, state.aaMode));

   }

 }

 void

 gfxContext::PushClipsToDT(DrawTarget *aDT)

 {

   // Tricky, we have to restore all clips -since the last time- the clip

   // was reset. If we didn't reset the clip, just popping the clips we

   // added was fine.

   unsigned int lastReset = 0;

   for (int i = mStateStack.Length() - 2; i > 0; i--) {

     if (mStateStack[i].clipWasReset) {

       lastReset = i;

       break;

     }

   }

   // Don't need to save the old transform, we'll be setting a new one soon!

   // Push all clips from the last state on the stack where the clip was

   // reset to the clip before ours.

   for (unsigned int i = lastReset; i < mStateStack.Length() - 1; i++) {

     for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {

       aDT->SetTransform(mStateStack[i].pushedClips[c].transform * GetDeviceTransform());

       if (mStateStack[i].pushedClips[c].path) {

         aDT->PushClip(mStateStack[i].pushedClips[c].path);

       } else {

         aDT->PushClipRect(mStateStack[i].pushedClips[c].rect);

       }

     }

   }

 }

 CompositionOp

 gfxContext::GetOp()

 {

   if (CurrentState().op != CompositionOp::OP_SOURCE) {

     return CurrentState().op;

   }

   AzureState &state = CurrentState();

   if (state.pattern) {

     if (state.pattern->IsOpaque()) {

       return CompositionOp::OP_OVER;

     } else {

       return CompositionOp::OP_SOURCE;

     }

   } else if (state.sourceSurface) {

     if (state.sourceSurface->GetFormat() == SurfaceFormat::B8G8R8X8) {

       return CompositionOp::OP_OVER;

     } else {

       return CompositionOp::OP_SOURCE;

     }

   } else {

     if (state.color.a > 0.999) {

       return CompositionOp::OP_OVER;

     } else {

       return CompositionOp::OP_SOURCE;

     }

   }

 }

 /* SVG font code can change the transform after having set the pattern on the

  * context. When the pattern is set it is in user space, if the transform is

  * changed after doing so the pattern needs to be converted back into userspace.

  * We just store the old pattern transform here so that we only do the work

  * needed here if the pattern is actually used.

  * We need to avoid doing this when this ChangeTransform comes from a restore,

  * since the current pattern and the current transform are both part of the

  * state we know the new CurrentState()'s values are valid. But if we assume

  * a change they might become invalid since patternTransformChanged is part of

  * the state and might be false for the restored AzureState.

  */

 void

 gfxContext::ChangeTransform(const Matrix &aNewMatrix, bool aUpdatePatternTransform)

 {

   AzureState &state = CurrentState();

   if (aUpdatePatternTransform && (state.pattern || state.sourceSurface)

       && !state.patternTransformChanged) {

     state.patternTransform = GetDTTransform();

     state.patternTransformChanged = true;

   }

   if (mPathIsRect) {

     Matrix invMatrix = aNewMatrix;

     invMatrix.Invert();

     Matrix toNewUS = mTransform * invMatrix;

     if (toNewUS.IsRectilinear()) {

       mRect = toNewUS.TransformBounds(mRect);

       mRect.NudgeToIntegers();

     } else {

       mPathBuilder = mDT->CreatePathBuilder(CurrentState().fillRule);

       mPathBuilder->MoveTo(toNewUS * mRect.TopLeft());

       mPathBuilder->LineTo(toNewUS * mRect.TopRight());

       mPathBuilder->LineTo(toNewUS * mRect.BottomRight());

       mPathBuilder->LineTo(toNewUS * mRect.BottomLeft());

       mPathBuilder->Close();

       mPathIsRect = false;

     }

     // No need to consider the transform changed now!

     mTransformChanged = false;

   } else if ((mPath || mPathBuilder) && !mTransformChanged) {

     mTransformChanged = true;

     mPathTransform = mTransform;

   }

   mTransform = aNewMatrix;

   mDT->SetTransform(GetDTTransform());

 }

 Rect

 gfxContext::GetAzureDeviceSpaceClipBounds()

 {

   unsigned int lastReset = 0;

   for (int i = mStateStack.Length() - 1; i > 0; i--) {

     if (mStateStack[i].clipWasReset) {

       lastReset = i;

       break;

     }

   }

   Rect rect(CurrentState().deviceOffset.x, CurrentState().deviceOffset.y,

             Float(mDT->GetSize().width), Float(mDT->GetSize().height));

   for (unsigned int i = lastReset; i < mStateStack.Length(); i++) {

     for (unsigned int c = 0; c < mStateStack[i].pushedClips.Length(); c++) {

       AzureState::PushedClip &clip = mStateStack[i].pushedClips[c];

       if (clip.path) {

         Rect bounds = clip.path->GetBounds(clip.transform);

         rect.IntersectRect(rect, bounds);

       } else {

         rect.IntersectRect(rect, clip.transform.TransformBounds(clip.rect));

       }

     }

   }

   return rect;

 }

 Point

 gfxContext::GetDeviceOffset() const

 {

   return CurrentState().deviceOffset;

 }

 Matrix

 gfxContext::GetDeviceTransform() const

 {

   Matrix mat;

   mat.Translate(-CurrentState().deviceOffset.x, -CurrentState().deviceOffset.y);

   return mat;

 }

 Matrix

 gfxContext::GetDTTransform() const

 {

   Matrix mat = mTransform;

   mat._31 -= CurrentState().deviceOffset.x;

   mat._32 -= CurrentState().deviceOffset.y;

   return mat;

 }

 void

 gfxContext::PushNewDT(gfxContentType content)

 {

   Rect clipBounds = GetAzureDeviceSpaceClipBounds();

   clipBounds.RoundOut();

   clipBounds.width = std::max(1.0f, clipBounds.width);

   clipBounds.height = std::max(1.0f, clipBounds.height);

   SurfaceFormat format = gfxPlatform::GetPlatform()->Optimal2DFormatForContent(content);

   RefPtr<DrawTarget> newDT =

     mDT->CreateSimilarDrawTarget(IntSize(int32_t(clipBounds.width), int32_t(clipBounds.height)),

                                  format);

   if (!newDT) {

     NS_WARNING("Failed to create DrawTarget of sufficient size.");

     newDT = mDT->CreateSimilarDrawTarget(IntSize(64, 64), format);

     if (!newDT) {

       // If even this fails.. we're most likely just out of memory!

       NS_ABORT_OOM(BytesPerPixel(format) * 64 * 64);

     }

   }

   Save();

   CurrentState().drawTarget = newDT;

   CurrentState().deviceOffset = clipBounds.TopLeft();

   mDT = newDT;

 }

 /**

  * Work out whether cairo will snap inter-glyph spacing to pixels.

  *

  * Layout does not align text to pixel boundaries, so, with font drawing

  * backends that snap glyph positions to pixels, it is important that

  * inter-glyph spacing within words is always an integer number of pixels.

  * This ensures that the drawing backend snaps all of the word's glyphs in the

  * same direction and so inter-glyph spacing remains the same.

  */

 void

 gfxContext::GetRoundOffsetsToPixels(bool *aRoundX, bool *aRoundY)

 {

     *aRoundX = false;

     // Could do something fancy here for ScaleFactors of

     // AxisAlignedTransforms, but we leave things simple.

     // Not much point rounding if a matrix will mess things up anyway.

     // Also return false for non-cairo contexts.

     if (CurrentMatrix().HasNonTranslation() || mDT) {

         *aRoundY = false;

         return;

     }

     // All raster backends snap glyphs to pixels vertically.

     // Print backends set CAIRO_HINT_METRICS_OFF.

     *aRoundY = true;

     cairo_t *cr = GetCairo();

     cairo_scaled_font_t *scaled_font = cairo_get_scaled_font(cr);

     // Sometimes hint metrics gets set for us, most notably for printing.

     cairo_font_options_t *font_options = cairo_font_options_create();

     cairo_scaled_font_get_font_options(scaled_font, font_options);

     cairo_hint_metrics_t hint_metrics =

         cairo_font_options_get_hint_metrics(font_options);

     cairo_font_options_destroy(font_options);

     switch (hint_metrics) {

     case CAIRO_HINT_METRICS_OFF:

         *aRoundY = false;

         return;

     case CAIRO_HINT_METRICS_DEFAULT:

         // Here we mimic what cairo surface/font backends do.  Printing

         // surfaces have already been handled by hint_metrics.  The

         // fallback show_glyphs implementation composites pixel-aligned

         // glyph surfaces, so we just pick surface/font combinations that

         // override this.

         switch (cairo_scaled_font_get_type(scaled_font)) {

 #if CAIRO_HAS_DWRITE_FONT // dwrite backend is not in std cairo releases yet

         case CAIRO_FONT_TYPE_DWRITE:

             // show_glyphs is implemented on the font and so is used for

             // all surface types; however, it may pixel-snap depending on

             // the dwrite rendering mode

             if (!cairo_dwrite_scaled_font_get_force_GDI_classic(scaled_font) &&

                 gfxWindowsPlatform::GetPlatform()->DWriteMeasuringMode() ==

                     DWRITE_MEASURING_MODE_NATURAL) {

                 return;

             }

 #endif

         case CAIRO_FONT_TYPE_QUARTZ:

             // Quartz surfaces implement show_glyphs for Quartz fonts

             if (cairo_surface_get_type(cairo_get_target(cr)) ==

                 CAIRO_SURFACE_TYPE_QUARTZ) {

                 return;

             }

         default:

             break;

         }

         // fall through:

     case CAIRO_HINT_METRICS_ON:

         break;

     }

     *aRoundX = true;

     return;

 }