The Tor Browser: gfx/thebes/gfxContext.cpp@b8a032363ba2 (annotated)

gfx/thebes/gfxContext.cpp@b8a032363ba2 (annotated)

gfx/thebes/gfxContext.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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,
 ,  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;
 }

The Tor Browser / annotate

gfx/thebes/gfxContext.cpp@b8a032363ba2 (annotated)

gfx/thebes/gfxContext.cpp