/* -*- 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();

    // We clip here to bind to the mask surface bounds, see above.
    mDT->MaskSurface(GeneralPattern(this), 
              sourceSurf,
              Point(offset.x - pt.x, offset.y -  pt.y),
              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;
}

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

  RefPtr<DrawTarget> newDT =
    mDT->CreateSimilarDrawTarget(IntSize(int32_t(clipBounds.width), int32_t(clipBounds.height)),
                                  gfxPlatform::GetPlatform()->Optimal2DFormatForContent(content));

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