The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; 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/. */

 #include "CanvasRenderingContext2D.h"

 #include "nsXULElement.h"

 #include "nsIServiceManager.h"

 #include "nsMathUtils.h"

 #include "nsContentUtils.h"

 #include "nsIDocument.h"

 #include "mozilla/dom/HTMLCanvasElement.h"

 #include "nsSVGEffects.h"

 #include "nsPresContext.h"

 #include "nsIPresShell.h"

 #include "nsIInterfaceRequestorUtils.h"

 #include "nsIFrame.h"

 #include "nsError.h"

 #include "nsCSSParser.h"

 #include "mozilla/css/StyleRule.h"

 #include "mozilla/css/Declaration.h"

 #include "mozilla/css/Loader.h"

 #include "nsComputedDOMStyle.h"

 #include "nsStyleSet.h"

 #include "nsPrintfCString.h"

 #include "nsReadableUtils.h"

 #include "nsColor.h"

 #include "nsGfxCIID.h"

 #include "nsIDocShell.h"

 #include "nsIDOMWindow.h"

 #include "nsPIDOMWindow.h"

 #include "nsDisplayList.h"

 #include "nsFocusManager.h"

 #include "nsTArray.h"

 #include "ImageEncoder.h"

 #include "gfxContext.h"

 #include "gfxASurface.h"

 #include "gfxImageSurface.h"

 #include "gfxPlatform.h"

 #include "gfxFont.h"

 #include "gfxBlur.h"

 #include "gfxUtils.h"

 #include "nsFrameManager.h"

 #include "nsFrameLoader.h"

 #include "nsBidi.h"

 #include "nsBidiPresUtils.h"

 #include "Layers.h"

 #include "CanvasUtils.h"

 #include "nsIMemoryReporter.h"

 #include "nsStyleUtil.h"

 #include "CanvasImageCache.h"

 #include <algorithm>

 #include "jsapi.h"

 #include "jsfriendapi.h"

 #include "mozilla/Alignment.h"

 #include "mozilla/Assertions.h"

 #include "mozilla/CheckedInt.h"

 #include "mozilla/dom/ContentParent.h"

 #include "mozilla/dom/ImageData.h"

 #include "mozilla/dom/PBrowserParent.h"

 #include "mozilla/dom/ToJSValue.h"

 #include "mozilla/dom/TypedArray.h"

 #include "mozilla/Endian.h"

 #include "mozilla/gfx/2D.h"

 #include "mozilla/gfx/PathHelpers.h"

 #include "mozilla/gfx/DataSurfaceHelpers.h"

 #include "mozilla/ipc/DocumentRendererParent.h"

 #include "mozilla/ipc/PDocumentRendererParent.h"

 #include "mozilla/MathAlgorithms.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/Telemetry.h"

 #include "mozilla/unused.h"

 #include "nsCCUncollectableMarker.h"

 #include "nsWrapperCacheInlines.h"

 #include "mozilla/dom/CanvasRenderingContext2DBinding.h"

 #include "mozilla/dom/HTMLImageElement.h"

 #include "mozilla/dom/HTMLVideoElement.h"

 #include "mozilla/dom/TextMetrics.h"

 #include "mozilla/dom/UnionTypes.h"

 #include "nsGlobalWindow.h"

 #include "GLContext.h"

 #include "GLContextProvider.h"

 #include "SVGContentUtils.h"

 #include "nsIScreenManager.h"

 #undef free // apparently defined by some windows header, clashing with a free()

             // method in SkTypes.h

 #ifdef USE_SKIA

 #include "SkiaGLGlue.h"

 #include "SurfaceStream.h"

 #include "SurfaceTypes.h"

 #endif

 using mozilla::gl::GLContext;

 using mozilla::gl::SkiaGLGlue;

 using mozilla::gl::GLContextProvider;

 #ifdef XP_WIN

 #include "gfxWindowsPlatform.h"

 #endif

 #ifdef MOZ_WIDGET_GONK

 #include "mozilla/layers/ShadowLayers.h"

 #endif

 // windows.h (included by chromium code) defines this, in its infinite wisdom

 #undef DrawText

 using namespace mozilla;

 using namespace mozilla::CanvasUtils;

 using namespace mozilla::css;

 using namespace mozilla::gfx;

 using namespace mozilla::ipc;

 using namespace mozilla::layers;

 namespace mgfx = mozilla::gfx;

 namespace mozilla {

 namespace dom {

 // Cap sigma to avoid overly large temp surfaces.

 const Float SIGMA_MAX = 100;

 /* Memory reporter stuff */

 static int64_t gCanvasAzureMemoryUsed = 0;

 // This is KIND_OTHER because it's not always clear where in memory the pixels

 // of a canvas are stored.  Furthermore, this memory will be tracked by the

 // underlying surface implementations.  See bug 655638 for details.

 class Canvas2dPixelsReporter MOZ_FINAL : public nsIMemoryReporter

 {

 public:

   NS_DECL_ISUPPORTS

   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,

                             nsISupports* aData)

   {

     return MOZ_COLLECT_REPORT(

       "canvas-2d-pixels", KIND_OTHER, UNITS_BYTES,

       gCanvasAzureMemoryUsed,

       "Memory used by 2D canvases. Each canvas requires "

       "(width * height * 4) bytes.");

   }

 };

 NS_IMPL_ISUPPORTS(Canvas2dPixelsReporter, nsIMemoryReporter)

 class CanvasRadialGradient : public CanvasGradient

 {

 public:

   CanvasRadialGradient(CanvasRenderingContext2D* aContext,

                        mozilla::css::Loader *aLoader,

                        const Point &aBeginOrigin, Float aBeginRadius,

                        const Point &aEndOrigin, Float aEndRadius)

     : CanvasGradient(aContext, aLoader, Type::RADIAL)

     , mCenter1(aBeginOrigin)

     , mCenter2(aEndOrigin)

     , mRadius1(aBeginRadius)

     , mRadius2(aEndRadius)

   {

   }

   Point mCenter1;

   Point mCenter2;

   Float mRadius1;

   Float mRadius2;

 };

 class CanvasLinearGradient : public CanvasGradient

 {

 public:

   CanvasLinearGradient(CanvasRenderingContext2D* aContext,

                        mozilla::css::Loader *aLoader,

                        const Point &aBegin, const Point &aEnd)

     : CanvasGradient(aContext, aLoader, Type::LINEAR)

     , mBegin(aBegin)

     , mEnd(aEnd)

   {

   }

 protected:

   friend class CanvasGeneralPattern;

   // Beginning of linear gradient.

   Point mBegin;

   // End of linear gradient.

   Point mEnd;

 };

 // This class is named 'GeneralCanvasPattern' instead of just

 // 'GeneralPattern' to keep Windows PGO builds from confusing the

 // GeneralPattern class in gfxContext.cpp with this one.

 class CanvasGeneralPattern

 {

 public:

   typedef CanvasRenderingContext2D::Style Style;

   typedef CanvasRenderingContext2D::ContextState ContextState;

   CanvasGeneralPattern() : mPattern(nullptr) {}

   ~CanvasGeneralPattern()

   {

     if (mPattern) {

       mPattern->~Pattern();

     }

   }

   Pattern& ForStyle(CanvasRenderingContext2D *aCtx,

                     Style aStyle,

                     DrawTarget *aRT)

   {

     // This should only be called once or the mPattern destructor will

     // not be executed.

     NS_ASSERTION(!mPattern, "ForStyle() should only be called once on CanvasGeneralPattern!");

     const ContextState &state = aCtx->CurrentState();

     if (state.StyleIsColor(aStyle)) {

       mPattern = new (mColorPattern.addr()) ColorPattern(Color::FromABGR(state.colorStyles[aStyle]));

     } else if (state.gradientStyles[aStyle] &&

                state.gradientStyles[aStyle]->GetType() == CanvasGradient::Type::LINEAR) {

       CanvasLinearGradient *gradient =

         static_cast<CanvasLinearGradient*>(state.gradientStyles[aStyle].get());

       mPattern = new (mLinearGradientPattern.addr())

         LinearGradientPattern(gradient->mBegin, gradient->mEnd,

                               gradient->GetGradientStopsForTarget(aRT));

     } else if (state.gradientStyles[aStyle] &&

                state.gradientStyles[aStyle]->GetType() == CanvasGradient::Type::RADIAL) {

       CanvasRadialGradient *gradient =

         static_cast<CanvasRadialGradient*>(state.gradientStyles[aStyle].get());

       mPattern = new (mRadialGradientPattern.addr())

         RadialGradientPattern(gradient->mCenter1, gradient->mCenter2, gradient->mRadius1,

                               gradient->mRadius2, gradient->GetGradientStopsForTarget(aRT));

     } else if (state.patternStyles[aStyle]) {

       if (aCtx->mCanvasElement) {

         CanvasUtils::DoDrawImageSecurityCheck(aCtx->mCanvasElement,

                                               state.patternStyles[aStyle]->mPrincipal,

                                               state.patternStyles[aStyle]->mForceWriteOnly,

                                               state.patternStyles[aStyle]->mCORSUsed);

       }

       ExtendMode mode;

       if (state.patternStyles[aStyle]->mRepeat == CanvasPattern::RepeatMode::NOREPEAT) {

         mode = ExtendMode::CLAMP;

       } else {

         mode = ExtendMode::REPEAT;

       }

       mPattern = new (mSurfacePattern.addr())

         SurfacePattern(state.patternStyles[aStyle]->mSurface, mode);

     }

     return *mPattern;

   }

   union {

     AlignedStorage2<ColorPattern> mColorPattern;

     AlignedStorage2<LinearGradientPattern> mLinearGradientPattern;

     AlignedStorage2<RadialGradientPattern> mRadialGradientPattern;

     AlignedStorage2<SurfacePattern> mSurfacePattern;

   };

   Pattern *mPattern;

 };

 /* This is an RAII based class that can be used as a drawtarget for

  * operations that need a shadow drawn. It will automatically provide a

  * temporary target when needed, and if so blend it back with a shadow.

  *

  * aBounds specifies the bounds of the drawing operation that will be

  * drawn to the target, it is given in device space! This function will

  * change aBounds to incorporate shadow bounds. If this is nullptr the drawing

  * operation will be assumed to cover an infinite rect.

  */

 class AdjustedTarget

 {

 public:

   typedef CanvasRenderingContext2D::ContextState ContextState;

   AdjustedTarget(CanvasRenderingContext2D *ctx,

                  mgfx::Rect *aBounds = nullptr)

     : mCtx(nullptr)

   {

     if (!ctx->NeedToDrawShadow()) {

       mTarget = ctx->mTarget;

       return;

     }

     mCtx = ctx;

     const ContextState &state = mCtx->CurrentState();

     mSigma = state.shadowBlur / 2.0f;

     if (mSigma > SIGMA_MAX) {

       mSigma = SIGMA_MAX;

     }

     Matrix transform = mCtx->mTarget->GetTransform();

     mTempRect = mgfx::Rect(0, 0, ctx->mWidth, ctx->mHeight);

     static const gfxFloat GAUSSIAN_SCALE_FACTOR = (3 * sqrt(2 * M_PI) / 4) * 1.5;

     int32_t blurRadius = (int32_t) floor(mSigma * GAUSSIAN_SCALE_FACTOR + 0.5);

     // We need to enlarge and possibly offset our temporary surface

     // so that things outside of the canvas may cast shadows.

     mTempRect.Inflate(Margin(blurRadius + std::max<Float>(state.shadowOffset.y, 0),

                              blurRadius + std::max<Float>(-state.shadowOffset.x, 0),

                              blurRadius + std::max<Float>(-state.shadowOffset.y, 0),

                              blurRadius + std::max<Float>(state.shadowOffset.x, 0)));

     if (aBounds) {

       // We actually include the bounds of the shadow blur, this makes it

       // easier to execute the actual blur on hardware, and shouldn't affect

       // the amount of pixels that need to be touched.

       aBounds->Inflate(Margin(blurRadius, blurRadius,

                               blurRadius, blurRadius));

       mTempRect = mTempRect.Intersect(*aBounds);

     }

     mTempRect.ScaleRoundOut(1.0f);

     transform._31 -= mTempRect.x;

     transform._32 -= mTempRect.y;

     mTarget =

       mCtx->mTarget->CreateShadowDrawTarget(IntSize(int32_t(mTempRect.width), int32_t(mTempRect.height)),

                                             SurfaceFormat::B8G8R8A8, mSigma);

     if (!mTarget) {

       // XXX - Deal with the situation where our temp size is too big to

       // fit in a texture.

       mTarget = ctx->mTarget;

       mCtx = nullptr;

     } else {

       mTarget->SetTransform(transform);

     }

   }

   ~AdjustedTarget()

   {

     if (!mCtx) {

       return;

     }

     RefPtr<SourceSurface> snapshot = mTarget->Snapshot();

     mCtx->mTarget->DrawSurfaceWithShadow(snapshot, mTempRect.TopLeft(),

                                          Color::FromABGR(mCtx->CurrentState().shadowColor),

                                          mCtx->CurrentState().shadowOffset, mSigma,

                                          mCtx->CurrentState().op);

   }

   operator DrawTarget*() 

   {

     return mTarget;

   }

   DrawTarget* operator->()

   {

     return mTarget;

   }

 private:

   RefPtr<DrawTarget> mTarget;

   CanvasRenderingContext2D *mCtx;

   Float mSigma;

   mgfx::Rect mTempRect;

 };

 void

 CanvasGradient::AddColorStop(float offset, const nsAString& colorstr, ErrorResult& rv)

 {

   if (offset < 0.0 || offset > 1.0) {

     rv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);

     return;

   }

   nsCSSValue value;

   nsCSSParser parser;

   if (!parser.ParseColorString(colorstr, nullptr, 0, value)) {

     rv.Throw(NS_ERROR_DOM_SYNTAX_ERR);

     return;

   }

   nsIPresShell* presShell = nullptr;

   if (mCSSLoader) {

     nsIDocument *doc = mCSSLoader->GetDocument();

     if (doc)

       presShell = doc->GetShell();

   }

   nscolor color;

   if (!nsRuleNode::ComputeColor(value, presShell ? presShell->GetPresContext() : nullptr,

                                 nullptr, color)) {

     rv.Throw(NS_ERROR_DOM_SYNTAX_ERR);

     return;

   }

   mStops = nullptr;

   GradientStop newStop;

   newStop.offset = offset;

   newStop.color = Color::FromABGR(color);

   mRawStops.AppendElement(newStop);

 }

 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(CanvasGradient, AddRef)

 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(CanvasGradient, Release)

 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(CanvasGradient, mContext)

 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(CanvasPattern, AddRef)

 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(CanvasPattern, Release)

 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(CanvasPattern, mContext)

 class CanvasRenderingContext2DUserData : public LayerUserData {

 public:

     CanvasRenderingContext2DUserData(CanvasRenderingContext2D *aContext)

     : mContext(aContext)

   {

     aContext->mUserDatas.AppendElement(this);

   }

   ~CanvasRenderingContext2DUserData()

   {

     if (mContext) {

       mContext->mUserDatas.RemoveElement(this);

     }

   }

   static void PreTransactionCallback(void* aData)

   {

     CanvasRenderingContext2DUserData* self =

       static_cast<CanvasRenderingContext2DUserData*>(aData);

     CanvasRenderingContext2D* context = self->mContext;

     if (!context || !context->mStream || !context->mTarget)

       return;

     // Since SkiaGL default to store drawing command until flush

     // We will have to flush it before present.

     context->mTarget->Flush();

   }

   static void DidTransactionCallback(void* aData)

   {

     CanvasRenderingContext2DUserData* self =

       static_cast<CanvasRenderingContext2DUserData*>(aData);

     if (self->mContext) {

       self->mContext->MarkContextClean();

     }

   }

   bool IsForContext(CanvasRenderingContext2D *aContext)

   {

     return mContext == aContext;

   }

   void Forget()

   {

     mContext = nullptr;

   }

 private:

   CanvasRenderingContext2D *mContext;

 };

 NS_IMPL_CYCLE_COLLECTING_ADDREF(CanvasRenderingContext2D)

 NS_IMPL_CYCLE_COLLECTING_RELEASE(CanvasRenderingContext2D)

 NS_IMPL_CYCLE_COLLECTION_CLASS(CanvasRenderingContext2D)

 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CanvasRenderingContext2D)

   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCanvasElement)

   for (uint32_t i = 0; i < tmp->mStyleStack.Length(); i++) {

     ImplCycleCollectionUnlink(tmp->mStyleStack[i].patternStyles[Style::STROKE]);

     ImplCycleCollectionUnlink(tmp->mStyleStack[i].patternStyles[Style::FILL]);

     ImplCycleCollectionUnlink(tmp->mStyleStack[i].gradientStyles[Style::STROKE]);

     ImplCycleCollectionUnlink(tmp->mStyleStack[i].gradientStyles[Style::FILL]);

   }

   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER

 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(CanvasRenderingContext2D)

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCanvasElement)

   for (uint32_t i = 0; i < tmp->mStyleStack.Length(); i++) {

     ImplCycleCollectionTraverse(cb, tmp->mStyleStack[i].patternStyles[Style::STROKE], "Stroke CanvasPattern");

     ImplCycleCollectionTraverse(cb, tmp->mStyleStack[i].patternStyles[Style::FILL], "Fill CanvasPattern");

     ImplCycleCollectionTraverse(cb, tmp->mStyleStack[i].gradientStyles[Style::STROKE], "Stroke CanvasGradient");

     ImplCycleCollectionTraverse(cb, tmp->mStyleStack[i].gradientStyles[Style::FILL], "Fill CanvasGradient");

   }

   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS

 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

 NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(CanvasRenderingContext2D)

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(CanvasRenderingContext2D)

  if (nsCCUncollectableMarker::sGeneration && tmp->IsBlack()) {

    dom::Element* canvasElement = tmp->mCanvasElement;

     if (canvasElement) {

       if (canvasElement->IsPurple()) {

         canvasElement->RemovePurple();

       }

       dom::Element::MarkNodeChildren(canvasElement);

     }

     return true;

   }

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(CanvasRenderingContext2D)

   return nsCCUncollectableMarker::sGeneration && tmp->IsBlack();

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(CanvasRenderingContext2D)

   return nsCCUncollectableMarker::sGeneration && tmp->IsBlack();

 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CanvasRenderingContext2D)

   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

   NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)

   NS_INTERFACE_MAP_ENTRY(nsISupports)

 NS_INTERFACE_MAP_END

 /**

  ** CanvasRenderingContext2D impl

  **/

 // Initialize our static variables.

 uint32_t CanvasRenderingContext2D::sNumLivingContexts = 0;

 DrawTarget* CanvasRenderingContext2D::sErrorTarget = nullptr;

 CanvasRenderingContext2D::CanvasRenderingContext2D()

   : mForceSoftware(false), mZero(false), mOpaque(false), mResetLayer(true)

   , mIPC(false)

   , mStream(nullptr)

   , mIsEntireFrameInvalid(false)

   , mPredictManyRedrawCalls(false), mPathTransformWillUpdate(false)

   , mInvalidateCount(0)

 {

   sNumLivingContexts++;

   SetIsDOMBinding();

 }

 CanvasRenderingContext2D::~CanvasRenderingContext2D()

 {

   Reset();

   // Drop references from all CanvasRenderingContext2DUserData to this context

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

     mUserDatas[i]->Forget();

   }

   sNumLivingContexts--;

   if (!sNumLivingContexts) {

     NS_IF_RELEASE(sErrorTarget);

   }

   RemoveDemotableContext(this);

 }

 JSObject*

 CanvasRenderingContext2D::WrapObject(JSContext *cx)

 {

   return CanvasRenderingContext2DBinding::Wrap(cx, this);

 }

 bool

 CanvasRenderingContext2D::ParseColor(const nsAString& aString,

                                      nscolor* aColor)

 {

   nsIDocument* document = mCanvasElement

                           ? mCanvasElement->OwnerDoc()

                           : nullptr;

   // Pass the CSS Loader object to the parser, to allow parser error

   // reports to include the outer window ID.

   nsCSSParser parser(document ? document->CSSLoader() : nullptr);

   nsCSSValue value;

   if (!parser.ParseColorString(aString, nullptr, 0, value)) {

     return false;

   }

   if (value.IsNumericColorUnit()) {

     // if we already have a color we can just use it directly

     *aColor = value.GetColorValue();

   } else {

     // otherwise resolve it

     nsIPresShell* presShell = GetPresShell();

     nsRefPtr<nsStyleContext> parentContext;

     if (mCanvasElement && mCanvasElement->IsInDoc()) {

       // Inherit from the canvas element.

       parentContext = nsComputedDOMStyle::GetStyleContextForElement(

         mCanvasElement, nullptr, presShell);

     }

     unused << nsRuleNode::ComputeColor(

       value, presShell ? presShell->GetPresContext() : nullptr, parentContext,

       *aColor);

   }

   return true;

 }

 #ifdef ACCESSIBILITY

 PLDHashOperator

 CanvasRenderingContext2D::RemoveHitRegionProperty(RegionInfo* aEntry, void*)

 {

   aEntry->mElement->DeleteProperty(nsGkAtoms::hitregion);

   return PL_DHASH_NEXT;

 }

 #endif

 nsresult

 CanvasRenderingContext2D::Reset()

 {

   if (mCanvasElement) {

     mCanvasElement->InvalidateCanvas();

   }

   // only do this for non-docshell created contexts,

   // since those are the ones that we created a surface for

   if (mTarget && IsTargetValid() && !mDocShell) {

     gCanvasAzureMemoryUsed -= mWidth * mHeight * 4;

   }

   mTarget = nullptr;

   mStream = nullptr;

   // reset hit regions

 #ifdef ACCESSIBILITY

   mHitRegionsOptions.EnumerateEntries(RemoveHitRegionProperty, nullptr);

 #endif

   mHitRegionsOptions.Clear();

   // Since the target changes the backing texture will change, and this will

   // no longer be valid.

   mIsEntireFrameInvalid = false;

   mPredictManyRedrawCalls = false;

   return NS_OK;

 }

 void

 CanvasRenderingContext2D::SetStyleFromString(const nsAString& str,

                                              Style whichStyle)

 {

   MOZ_ASSERT(!str.IsVoid());

   nscolor color;

   if (!ParseColor(str, &color)) {

     return;

   }

   CurrentState().SetColorStyle(whichStyle, color);

 }

 void

 CanvasRenderingContext2D::GetStyleAsUnion(OwningStringOrCanvasGradientOrCanvasPattern& aValue,

                                           Style aWhichStyle)

 {

   const ContextState &state = CurrentState();

   if (state.patternStyles[aWhichStyle]) {

     aValue.SetAsCanvasPattern() = state.patternStyles[aWhichStyle];

   } else if (state.gradientStyles[aWhichStyle]) {

     aValue.SetAsCanvasGradient() = state.gradientStyles[aWhichStyle];

   } else {

     StyleColorToString(state.colorStyles[aWhichStyle], aValue.SetAsString());

   }

 }

 // static

 void

 CanvasRenderingContext2D::StyleColorToString(const nscolor& aColor, nsAString& aStr)

 {

   // We can't reuse the normal CSS color stringification code,

   // because the spec calls for a different algorithm for canvas.

   if (NS_GET_A(aColor) == 255) {

     CopyUTF8toUTF16(nsPrintfCString("#%02x%02x%02x",

                                     NS_GET_R(aColor),

                                     NS_GET_G(aColor),

                                     NS_GET_B(aColor)),

                     aStr);

   } else {

     CopyUTF8toUTF16(nsPrintfCString("rgba(%d, %d, %d, ",

                                     NS_GET_R(aColor),

                                     NS_GET_G(aColor),

                                     NS_GET_B(aColor)),

                     aStr);

     aStr.AppendFloat(nsStyleUtil::ColorComponentToFloat(NS_GET_A(aColor)));

     aStr.Append(')');

   }

 }

 nsresult

 CanvasRenderingContext2D::Redraw()

 {

   if (mIsEntireFrameInvalid) {

     return NS_OK;

   }

   mIsEntireFrameInvalid = true;

   if (!mCanvasElement) {

     NS_ASSERTION(mDocShell, "Redraw with no canvas element or docshell!");

     return NS_OK;

   }

   nsSVGEffects::InvalidateDirectRenderingObservers(mCanvasElement);

   mCanvasElement->InvalidateCanvasContent(nullptr);

   return NS_OK;

 }

 void

 CanvasRenderingContext2D::Redraw(const mgfx::Rect &r)

 {

   ++mInvalidateCount;

   if (mIsEntireFrameInvalid) {

     return;

   }

   if (mPredictManyRedrawCalls ||

     mInvalidateCount > kCanvasMaxInvalidateCount) {

     Redraw();

     return;

   }

   if (!mCanvasElement) {

     NS_ASSERTION(mDocShell, "Redraw with no canvas element or docshell!");

     return;

   }

   nsSVGEffects::InvalidateDirectRenderingObservers(mCanvasElement);

   mCanvasElement->InvalidateCanvasContent(&r);

 }

 void

 CanvasRenderingContext2D::RedrawUser(const gfxRect& r)

 {

   if (mIsEntireFrameInvalid) {

     ++mInvalidateCount;

     return;

   }

   mgfx::Rect newr =

     mTarget->GetTransform().TransformBounds(ToRect(r));

   Redraw(newr);

 }

 void CanvasRenderingContext2D::Demote()

 {

   if (!IsTargetValid() || mForceSoftware || !mStream)

     return;

   RemoveDemotableContext(this);

   RefPtr<SourceSurface> snapshot = mTarget->Snapshot();

   RefPtr<DrawTarget> oldTarget = mTarget;

   mTarget = nullptr;

   mStream = nullptr;

   mResetLayer = true;

   mForceSoftware = true;

   // Recreate target, now demoted to software only

   EnsureTarget();

   if (!IsTargetValid())

     return;

   // Restore the content from the old DrawTarget

   mgfx::Rect r(0, 0, mWidth, mHeight);

   mTarget->DrawSurface(snapshot, r, r);

   // Restore the clips and transform

   for (uint32_t i = 0; i < CurrentState().clipsPushed.size(); i++) {

     mTarget->PushClip(CurrentState().clipsPushed[i]);

   }

   mTarget->SetTransform(oldTarget->GetTransform());

 }

 std::vector<CanvasRenderingContext2D*>&

 CanvasRenderingContext2D::DemotableContexts()

 {

   static std::vector<CanvasRenderingContext2D*> contexts;

   return contexts;

 }

 void

 CanvasRenderingContext2D::DemoteOldestContextIfNecessary()

 {

   const size_t kMaxContexts = 64;

   std::vector<CanvasRenderingContext2D*>& contexts = DemotableContexts();

   if (contexts.size() < kMaxContexts)

     return;

   CanvasRenderingContext2D* oldest = contexts.front();

   oldest->Demote();

 }

 void

 CanvasRenderingContext2D::AddDemotableContext(CanvasRenderingContext2D* context)

 {

   std::vector<CanvasRenderingContext2D*>::iterator iter = std::find(DemotableContexts().begin(), DemotableContexts().end(), context);

   if (iter != DemotableContexts().end())

     return;

   DemotableContexts().push_back(context);

 }

 void

 CanvasRenderingContext2D::RemoveDemotableContext(CanvasRenderingContext2D* context)

 {

   std::vector<CanvasRenderingContext2D*>::iterator iter = std::find(DemotableContexts().begin(), DemotableContexts().end(), context);

   if (iter != DemotableContexts().end())

     DemotableContexts().erase(iter);

 }

 bool

 CheckSizeForSkiaGL(IntSize size) {

   MOZ_ASSERT(NS_IsMainThread());

   int minsize = Preferences::GetInt("gfx.canvas.min-size-for-skia-gl", 128);

   if (size.width < minsize || size.height < minsize) {

     return false;

   }

   // Maximum pref allows 3 different options:

   //  0   means unlimited size

   //  > 0 means use value as an absolute threshold

   //  < 0 means use the number of screen pixels as a threshold

   int maxsize = Preferences::GetInt("gfx.canvas.max-size-for-skia-gl", 0);

   // unlimited max size

   if (!maxsize) {

     return true;

   }

   // absolute max size threshold

   if (maxsize > 0) {

     return size.width <= maxsize && size.height <= maxsize;

   }

   // Cache the number of pixels on the primary screen

   static int32_t gScreenPixels = -1;

   if (gScreenPixels < 0) {

     nsCOMPtr<nsIScreenManager> screenManager =

       do_GetService("@mozilla.org/gfx/screenmanager;1");

     if (screenManager) {

       nsCOMPtr<nsIScreen> primaryScreen;

       screenManager->GetPrimaryScreen(getter_AddRefs(primaryScreen));

       if (primaryScreen) {

         int32_t x, y, width, height;

         primaryScreen->GetRect(&x, &y, &width, &height);

         gScreenPixels = width * height;

       }

     }

   }

   // screen size acts as max threshold

   return gScreenPixels < 0 || (size.width * size.height) <= gScreenPixels;

 }

 void

 CanvasRenderingContext2D::EnsureTarget()

 {

   if (mTarget) {

     return;

   }

    // Check that the dimensions are sane

   IntSize size(mWidth, mHeight);

   if (size.width <= 0xFFFF && size.height <= 0xFFFF &&

       size.width >= 0 && size.height >= 0) {

     SurfaceFormat format = GetSurfaceFormat();

     nsIDocument* ownerDoc = nullptr;

     if (mCanvasElement) {

       ownerDoc = mCanvasElement->OwnerDoc();

     }

     nsRefPtr<LayerManager> layerManager = nullptr;

     if (ownerDoc) {

       layerManager =

         nsContentUtils::PersistentLayerManagerForDocument(ownerDoc);

     }

      if (layerManager) {

       if (gfxPlatform::GetPlatform()->UseAcceleratedSkiaCanvas() &&

           !mForceSoftware &&

           CheckSizeForSkiaGL(size)) {

         DemoteOldestContextIfNecessary();

         SkiaGLGlue* glue = gfxPlatform::GetPlatform()->GetSkiaGLGlue();

 #if USE_SKIA

         if (glue && glue->GetGrContext() && glue->GetGLContext()) {

           mTarget = Factory::CreateDrawTargetSkiaWithGrContext(glue->GetGrContext(), size, format);

           if (mTarget) {

             mStream = gfx::SurfaceStream::CreateForType(SurfaceStreamType::TripleBuffer, glue->GetGLContext());

             AddDemotableContext(this);

           } else {

             printf_stderr("Failed to create a SkiaGL DrawTarget, falling back to software\n");

           }

         }

 #endif

         if (!mTarget) {

           mTarget = layerManager->CreateDrawTarget(size, format);

         }

       } else

         mTarget = layerManager->CreateDrawTarget(size, format);

      } else {

         mTarget = gfxPlatform::GetPlatform()->CreateOffscreenCanvasDrawTarget(size, format);

      }

   }

   if (mTarget) {

     static bool registered = false;

     if (!registered) {

       registered = true;

       RegisterStrongMemoryReporter(new Canvas2dPixelsReporter());

     }

     gCanvasAzureMemoryUsed += mWidth * mHeight * 4;

     JSContext* context = nsContentUtils::GetCurrentJSContext();

     if (context) {

       JS_updateMallocCounter(context, mWidth * mHeight * 4);

     }

     mTarget->ClearRect(mgfx::Rect(Point(0, 0), Size(mWidth, mHeight)));

     // Force a full layer transaction since we didn't have a layer before

     // and now we might need one.

     if (mCanvasElement) {

       mCanvasElement->InvalidateCanvas();

     }

     // Calling Redraw() tells our invalidation machinery that the entire

     // canvas is already invalid, which can speed up future drawing.

     Redraw();

   } else {

     EnsureErrorTarget();

     mTarget = sErrorTarget;

   }

 }

 #ifdef DEBUG

 int32_t

 CanvasRenderingContext2D::GetWidth() const

 {

   return mWidth;

 }

 int32_t

 CanvasRenderingContext2D::GetHeight() const

 {

   return mHeight;

 }

 #endif

 NS_IMETHODIMP

 CanvasRenderingContext2D::SetDimensions(int32_t width, int32_t height)

 {

   ClearTarget();

   // Zero sized surfaces can cause problems.

   mZero = false;

   if (height == 0) {

     height = 1;

     mZero = true;

   }

   if (width == 0) {

     width = 1;

     mZero = true;

   }

   mWidth = width;

   mHeight = height;

   return NS_OK;

 }

 void

 CanvasRenderingContext2D::ClearTarget()

 {

   Reset();

   mResetLayer = true;

   // set up the initial canvas defaults

   mStyleStack.Clear();

   mPathBuilder = nullptr;

   mPath = nullptr;

   mDSPathBuilder = nullptr;

   ContextState *state = mStyleStack.AppendElement();

   state->globalAlpha = 1.0;

   state->colorStyles[Style::FILL] = NS_RGB(0,0,0);

   state->colorStyles[Style::STROKE] = NS_RGB(0,0,0);

   state->shadowColor = NS_RGBA(0,0,0,0);

 }

 NS_IMETHODIMP

 CanvasRenderingContext2D::InitializeWithSurface(nsIDocShell *shell,

                                                 gfxASurface *surface,

                                                 int32_t width,

                                                 int32_t height)

 {

   mDocShell = shell;

   SetDimensions(width, height);

   mTarget = gfxPlatform::GetPlatform()->

     CreateDrawTargetForSurface(surface, IntSize(width, height));

   if (!mTarget) {

     EnsureErrorTarget();

     mTarget = sErrorTarget;

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 CanvasRenderingContext2D::SetIsOpaque(bool isOpaque)

 {

   if (isOpaque != mOpaque) {

     mOpaque = isOpaque;

     ClearTarget();

   }

   if (mOpaque) {

     EnsureTarget();

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 CanvasRenderingContext2D::SetIsIPC(bool isIPC)

 {

   if (isIPC != mIPC) {

     mIPC = isIPC;

     ClearTarget();

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 CanvasRenderingContext2D::SetContextOptions(JSContext* aCx, JS::Handle<JS::Value> aOptions)

 {

   if (aOptions.isNullOrUndefined()) {

     return NS_OK;

   }

   ContextAttributes2D attributes;

   NS_ENSURE_TRUE(attributes.Init(aCx, aOptions), NS_ERROR_UNEXPECTED);

   if (Preferences::GetBool("gfx.canvas.willReadFrequently.enable", false)) {

     // Use software when there is going to be a lot of readback

     mForceSoftware = attributes.mWillReadFrequently;

   }

   if (!attributes.mAlpha) {

     SetIsOpaque(true);

   }

   return NS_OK;

 }

 void

 CanvasRenderingContext2D::GetImageBuffer(uint8_t** aImageBuffer,

                                          int32_t* aFormat)

 {

   *aImageBuffer = nullptr;

   *aFormat = 0;

   EnsureTarget();

   RefPtr<SourceSurface> snapshot = mTarget->Snapshot();

   if (!snapshot) {

     return;

   }

   RefPtr<DataSourceSurface> data = snapshot->GetDataSurface();

   if (!data || data->GetSize() != IntSize(mWidth, mHeight)) {

     return;

   }

   *aImageBuffer = SurfaceToPackedBGRA(data);

   *aFormat = imgIEncoder::INPUT_FORMAT_HOSTARGB;

 }

 NS_IMETHODIMP

 CanvasRenderingContext2D::GetInputStream(const char *aMimeType,

                                          const char16_t *aEncoderOptions,

                                          nsIInputStream **aStream)

 {

   nsCString enccid("@mozilla.org/image/encoder;2?type=");

   enccid += aMimeType;

   nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(enccid.get());

   if (!encoder) {

     return NS_ERROR_FAILURE;

   }

   nsAutoArrayPtr<uint8_t> imageBuffer;

   int32_t format = 0;

   GetImageBuffer(getter_Transfers(imageBuffer), &format);

   if (!imageBuffer) {

     return NS_ERROR_FAILURE;

   }

   return ImageEncoder::GetInputStream(mWidth, mHeight, imageBuffer, format,

                                       encoder, aEncoderOptions, aStream);

 }

 SurfaceFormat

 CanvasRenderingContext2D::GetSurfaceFormat() const

 {

   return mOpaque ? SurfaceFormat::B8G8R8X8 : SurfaceFormat::B8G8R8A8;

 }

 //

 // state

 //

 void

 CanvasRenderingContext2D::Save()

 {

   EnsureTarget();

   mStyleStack[mStyleStack.Length() - 1].transform = mTarget->GetTransform();

   mStyleStack.SetCapacity(mStyleStack.Length() + 1);

   mStyleStack.AppendElement(CurrentState());

 }

 void

 CanvasRenderingContext2D::Restore()

 {

   if (mStyleStack.Length() - 1 == 0)

     return;

   TransformWillUpdate();

   for (uint32_t i = 0; i < CurrentState().clipsPushed.size(); i++) {

     mTarget->PopClip();

   }

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

   mTarget->SetTransform(CurrentState().transform);

 }

 //

 // transformations

 //

 void

 CanvasRenderingContext2D::Scale(double x, double y, ErrorResult& error)

 {

   TransformWillUpdate();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix newMatrix = mTarget->GetTransform();

   mTarget->SetTransform(newMatrix.Scale(x, y));

 }

 void

 CanvasRenderingContext2D::Rotate(double angle, ErrorResult& error)

 {

   TransformWillUpdate();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix rotation = Matrix::Rotation(angle);

   mTarget->SetTransform(rotation * mTarget->GetTransform());

 }

 void

 CanvasRenderingContext2D::Translate(double x, double y, ErrorResult& error)

 {

   TransformWillUpdate();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix newMatrix = mTarget->GetTransform();

   mTarget->SetTransform(newMatrix.Translate(x, y));

 }

 void

 CanvasRenderingContext2D::Transform(double m11, double m12, double m21,

                                     double m22, double dx, double dy,

                                     ErrorResult& error)

 {

   TransformWillUpdate();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix matrix(m11, m12, m21, m22, dx, dy);

   mTarget->SetTransform(matrix * mTarget->GetTransform());

 }

 void

 CanvasRenderingContext2D::SetTransform(double m11, double m12,

                                        double m21, double m22,

                                        double dx, double dy,

                                        ErrorResult& error)

 {

   TransformWillUpdate();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix matrix(m11, m12, m21, m22, dx, dy);

   mTarget->SetTransform(matrix);

 }

 static void

 MatrixToJSObject(JSContext* cx, const Matrix& matrix,

                  JS::MutableHandle<JSObject*> result, ErrorResult& error)

 {

   double elts[6] = { matrix._11, matrix._12,

                      matrix._21, matrix._22,

                      matrix._31, matrix._32 };

   // XXX Should we enter GetWrapper()'s compartment?

   JS::Rooted<JS::Value> val(cx);

   if (!ToJSValue(cx, elts, &val)) {

     error.Throw(NS_ERROR_OUT_OF_MEMORY);

   } else {

     result.set(&val.toObject());

   }

 }

 static bool

 ObjectToMatrix(JSContext* cx, JS::Handle<JSObject*> obj, Matrix& matrix,

                ErrorResult& error)

 {

   uint32_t length;

   if (!JS_GetArrayLength(cx, obj, &length) || length != 6) {

     // Not an array-like thing or wrong size

     error.Throw(NS_ERROR_INVALID_ARG);

     return false;

   }

   Float* elts[] = { &matrix._11, &matrix._12, &matrix._21, &matrix._22,

                     &matrix._31, &matrix._32 };

   for (uint32_t i = 0; i < 6; ++i) {

     JS::Rooted<JS::Value> elt(cx);

     double d;

     if (!JS_GetElement(cx, obj, i, &elt)) {

       error.Throw(NS_ERROR_FAILURE);

       return false;

     }

     if (!CoerceDouble(elt, &d)) {

       error.Throw(NS_ERROR_INVALID_ARG);

       return false;

     }

     if (!FloatValidate(d)) {

       // This is weird, but it's the behavior of SetTransform()

       return false;

     }

     *elts[i] = Float(d);

   }

   return true;

 }

 void

 CanvasRenderingContext2D::SetMozCurrentTransform(JSContext* cx,

                                                  JS::Handle<JSObject*> currentTransform,

                                                  ErrorResult& error)

 {

   EnsureTarget();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix newCTM;

   if (ObjectToMatrix(cx, currentTransform, newCTM, error)) {

     mTarget->SetTransform(newCTM);

   }

 }

 void

 CanvasRenderingContext2D::GetMozCurrentTransform(JSContext* cx,

                                                  JS::MutableHandle<JSObject*> result,

                                                  ErrorResult& error) const

 {

   MatrixToJSObject(cx, mTarget ? mTarget->GetTransform() : Matrix(),

                    result, error);

 }

 void

 CanvasRenderingContext2D::SetMozCurrentTransformInverse(JSContext* cx,

                                                         JS::Handle<JSObject*> currentTransform,

                                                         ErrorResult& error)

 {

   EnsureTarget();

   if (!IsTargetValid()) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   Matrix newCTMInverse;

   if (ObjectToMatrix(cx, currentTransform, newCTMInverse, error)) {

     // XXX ERRMSG we need to report an error to developers here! (bug 329026)

     if (newCTMInverse.Invert()) {

       mTarget->SetTransform(newCTMInverse);

     }

   }

 }

 void

 CanvasRenderingContext2D::GetMozCurrentTransformInverse(JSContext* cx,

                                                         JS::MutableHandle<JSObject*> result,

                                                         ErrorResult& error) const

 {

   if (!mTarget) {

     MatrixToJSObject(cx, Matrix(), result, error);

     return;

   }

   Matrix ctm = mTarget->GetTransform();

   if (!ctm.Invert()) {

     double NaN = JSVAL_TO_DOUBLE(JS_GetNaNValue(cx));

     ctm = Matrix(NaN, NaN, NaN, NaN, NaN, NaN);

   }

   MatrixToJSObject(cx, ctm, result, error);

 }

 //

 // colors

 //

 void

 CanvasRenderingContext2D::SetStyleFromUnion(const StringOrCanvasGradientOrCanvasPattern& value,

                                             Style whichStyle)

 {

   if (value.IsString()) {

     SetStyleFromString(value.GetAsString(), whichStyle);

     return;

   }

   if (value.IsCanvasGradient()) {

     SetStyleFromGradient(value.GetAsCanvasGradient(), whichStyle);

     return;

   }

   if (value.IsCanvasPattern()) {

     SetStyleFromPattern(value.GetAsCanvasPattern(), whichStyle);

     return;

   }

   MOZ_ASSUME_UNREACHABLE("Invalid union value");

 }

 void

 CanvasRenderingContext2D::SetFillRule(const nsAString& aString)

 {

   FillRule rule;

   if (aString.EqualsLiteral("evenodd"))

     rule = FillRule::FILL_EVEN_ODD;

   else if (aString.EqualsLiteral("nonzero"))

     rule = FillRule::FILL_WINDING;

   else

     return;

   CurrentState().fillRule = rule;

 }

 void

 CanvasRenderingContext2D::GetFillRule(nsAString& aString)

 {

   switch (CurrentState().fillRule) {

   case FillRule::FILL_WINDING:

     aString.AssignLiteral("nonzero"); break;

   case FillRule::FILL_EVEN_ODD:

     aString.AssignLiteral("evenodd"); break;

   }

 }

 //

 // gradients and patterns

 //

 already_AddRefed<CanvasGradient>

 CanvasRenderingContext2D::CreateLinearGradient(double x0, double y0, double x1, double y1)

 {

   nsIDocument *doc = mCanvasElement ? mCanvasElement->OwnerDoc() : nullptr;

   mozilla::css::Loader *cssLoader = doc ? doc->CSSLoader() : nullptr;

   nsRefPtr<CanvasGradient> grad =

     new CanvasLinearGradient(this, cssLoader, Point(x0, y0), Point(x1, y1));

   return grad.forget();

 }

 already_AddRefed<CanvasGradient>

 CanvasRenderingContext2D::CreateRadialGradient(double x0, double y0, double r0,

                                                double x1, double y1, double r1,

                                                ErrorResult& aError)

 {

   if (r0 < 0.0 || r1 < 0.0) {

     aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);

     return nullptr;

   }

   nsIDocument *doc = mCanvasElement ? mCanvasElement->OwnerDoc() : nullptr;

   mozilla::css::Loader *cssLoader = doc ? doc->CSSLoader() : nullptr;

   nsRefPtr<CanvasGradient> grad =

     new CanvasRadialGradient(this, cssLoader, Point(x0, y0), r0, Point(x1, y1), r1);

   return grad.forget();

 }

 already_AddRefed<CanvasPattern>

 CanvasRenderingContext2D::CreatePattern(const HTMLImageOrCanvasOrVideoElement& element,

                                         const nsAString& repeat,

                                         ErrorResult& error)

 {

   CanvasPattern::RepeatMode repeatMode =

     CanvasPattern::RepeatMode::NOREPEAT;

   if (repeat.IsEmpty() || repeat.EqualsLiteral("repeat")) {

     repeatMode = CanvasPattern::RepeatMode::REPEAT;

   } else if (repeat.EqualsLiteral("repeat-x")) {

     repeatMode = CanvasPattern::RepeatMode::REPEATX;

   } else if (repeat.EqualsLiteral("repeat-y")) {

     repeatMode = CanvasPattern::RepeatMode::REPEATY;

   } else if (repeat.EqualsLiteral("no-repeat")) {

     repeatMode = CanvasPattern::RepeatMode::NOREPEAT;

   } else {

     error.Throw(NS_ERROR_DOM_SYNTAX_ERR);

     return nullptr;

   }

   Element* htmlElement;

   if (element.IsHTMLCanvasElement()) {

     HTMLCanvasElement* canvas = &element.GetAsHTMLCanvasElement();

     htmlElement = canvas;

     nsIntSize size = canvas->GetSize();

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

       error.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);

       return nullptr;

     }

     // Special case for Canvas, which could be an Azure canvas!

     nsICanvasRenderingContextInternal *srcCanvas = canvas->GetContextAtIndex(0);

     if (srcCanvas) {

       // This might not be an Azure canvas!

       RefPtr<SourceSurface> srcSurf = srcCanvas->GetSurfaceSnapshot();

       nsRefPtr<CanvasPattern> pat =

         new CanvasPattern(this, srcSurf, repeatMode, htmlElement->NodePrincipal(), canvas->IsWriteOnly(), false);

       return pat.forget();

     }

   } else if (element.IsHTMLImageElement()) {

     htmlElement = &element.GetAsHTMLImageElement();

   } else {

     htmlElement = &element.GetAsHTMLVideoElement();

   }

   EnsureTarget();

   // The canvas spec says that createPattern should use the first frame

   // of animated images

   nsLayoutUtils::SurfaceFromElementResult res =

     nsLayoutUtils::SurfaceFromElement(htmlElement,

       nsLayoutUtils::SFE_WANT_FIRST_FRAME, mTarget);

   if (!res.mSourceSurface) {

     error.Throw(NS_ERROR_NOT_AVAILABLE);

     return nullptr;

   }

   nsRefPtr<CanvasPattern> pat =

     new CanvasPattern(this, res.mSourceSurface, repeatMode, res.mPrincipal,

                              res.mIsWriteOnly, res.mCORSUsed);

   return pat.forget();

 }

 //

 // shadows

 //

 void

 CanvasRenderingContext2D::SetShadowColor(const nsAString& shadowColor)

 {

   nscolor color;

   if (!ParseColor(shadowColor, &color)) {

     return;

   }

   CurrentState().shadowColor = color;

 }

 //

 // rects

 //

 void

 CanvasRenderingContext2D::ClearRect(double x, double y, double w,

                                     double h)

 {

   if (!mTarget) {

     return;

   }

   mTarget->ClearRect(mgfx::Rect(x, y, w, h));

   RedrawUser(gfxRect(x, y, w, h));

 }

 void

 CanvasRenderingContext2D::FillRect(double x, double y, double w,

                                    double h)

 {

   const ContextState &state = CurrentState();

   if (state.patternStyles[Style::FILL]) {

     CanvasPattern::RepeatMode repeat =

       state.patternStyles[Style::FILL]->mRepeat;

     // In the FillRect case repeat modes are easy to deal with.

     bool limitx = repeat == CanvasPattern::RepeatMode::NOREPEAT || repeat == CanvasPattern::RepeatMode::REPEATY;

     bool limity = repeat == CanvasPattern::RepeatMode::NOREPEAT || repeat == CanvasPattern::RepeatMode::REPEATX;

     IntSize patternSize =

       state.patternStyles[Style::FILL]->mSurface->GetSize();

     // We always need to execute painting for non-over operators, even if

     // we end up with w/h = 0.

     if (limitx) {

       if (x < 0) {

         w += x;

         if (w < 0) {

           w = 0;

         }

         x = 0;

       }

       if (x + w > patternSize.width) {

         w = patternSize.width - x;

         if (w < 0) {

           w = 0;

         }

       }

     }

     if (limity) {

       if (y < 0) {

         h += y;

         if (h < 0) {

           h = 0;

         }

         y = 0;

       }

       if (y + h > patternSize.height) {

         h = patternSize.height - y;

         if (h < 0) {

           h = 0;

         }

       }

     }

   }

   mgfx::Rect bounds;

   EnsureTarget();

   if (NeedToDrawShadow()) {

     bounds = mgfx::Rect(x, y, w, h);

     bounds = mTarget->GetTransform().TransformBounds(bounds);

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     FillRect(mgfx::Rect(x, y, w, h),

              CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget),

              DrawOptions(state.globalAlpha, UsedOperation()));

   RedrawUser(gfxRect(x, y, w, h));

 }

 void

 CanvasRenderingContext2D::StrokeRect(double x, double y, double w,

                                      double h)

 {

   const ContextState &state = CurrentState();

   mgfx::Rect bounds;

   if (!w && !h) {

     return;

   }

   EnsureTarget();

   if (!IsTargetValid()) {

     return;

   }

   if (NeedToDrawShadow()) {

     bounds = mgfx::Rect(x - state.lineWidth / 2.0f, y - state.lineWidth / 2.0f,

                         w + state.lineWidth, h + state.lineWidth);

     bounds = mTarget->GetTransform().TransformBounds(bounds);

   }

   if (!h) {

     CapStyle cap = CapStyle::BUTT;

     if (state.lineJoin == JoinStyle::ROUND) {

       cap = CapStyle::ROUND;

     }

     AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

       StrokeLine(Point(x, y), Point(x + w, y),

                   CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget),

                   StrokeOptions(state.lineWidth, state.lineJoin,

                                 cap, state.miterLimit,

                                 state.dash.Length(),

                                 state.dash.Elements(),

                                 state.dashOffset),

                   DrawOptions(state.globalAlpha, UsedOperation()));

     return;

   }

   if (!w) {

     CapStyle cap = CapStyle::BUTT;

     if (state.lineJoin == JoinStyle::ROUND) {

       cap = CapStyle::ROUND;

     }

     AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

       StrokeLine(Point(x, y), Point(x, y + h),

                   CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget),

                   StrokeOptions(state.lineWidth, state.lineJoin,

                                 cap, state.miterLimit,

                                 state.dash.Length(),

                                 state.dash.Elements(),

                                 state.dashOffset),

                   DrawOptions(state.globalAlpha, UsedOperation()));

     return;

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     StrokeRect(mgfx::Rect(x, y, w, h),

                 CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget),

                 StrokeOptions(state.lineWidth, state.lineJoin,

                               state.lineCap, state.miterLimit,

                               state.dash.Length(),

                               state.dash.Elements(),

                               state.dashOffset),

                 DrawOptions(state.globalAlpha, UsedOperation()));

   Redraw();

 }

 //

 // path bits

 //

 void

 CanvasRenderingContext2D::BeginPath()

 {

   mPath = nullptr;

   mPathBuilder = nullptr;

   mDSPathBuilder = nullptr;

   mPathTransformWillUpdate = false;

 }

 void

 CanvasRenderingContext2D::Fill(const CanvasWindingRule& winding)

 {

   EnsureUserSpacePath(winding);

   if (!mPath) {

     return;

   }

   mgfx::Rect bounds;

   if (NeedToDrawShadow()) {

     bounds = mPath->GetBounds(mTarget->GetTransform());

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     Fill(mPath, CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget),

          DrawOptions(CurrentState().globalAlpha, UsedOperation()));

   Redraw();

 }

 void CanvasRenderingContext2D::Fill(const CanvasPath& path, const CanvasWindingRule& winding)

 {

   EnsureTarget();

   RefPtr<gfx::Path> gfxpath = path.GetPath(winding, mTarget);

   if (!gfxpath) {

     return;

   }

   mgfx::Rect bounds;

   if (NeedToDrawShadow()) {

     bounds = gfxpath->GetBounds(mTarget->GetTransform());

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     Fill(gfxpath, CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget),

          DrawOptions(CurrentState().globalAlpha, UsedOperation()));

   Redraw();

 }

 void

 CanvasRenderingContext2D::Stroke()

 {

   EnsureUserSpacePath();

   if (!mPath) {

     return;

   }

   const ContextState &state = CurrentState();

   StrokeOptions strokeOptions(state.lineWidth, state.lineJoin,

                               state.lineCap, state.miterLimit,

                               state.dash.Length(), state.dash.Elements(),

                               state.dashOffset);

   mgfx::Rect bounds;

   if (NeedToDrawShadow()) {

     bounds =

       mPath->GetStrokedBounds(strokeOptions, mTarget->GetTransform());

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     Stroke(mPath, CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget),

            strokeOptions, DrawOptions(state.globalAlpha, UsedOperation()));

   Redraw();

 }

 void

 CanvasRenderingContext2D::Stroke(const CanvasPath& path)

 {

   EnsureTarget();

   RefPtr<gfx::Path> gfxpath = path.GetPath(CanvasWindingRule::Nonzero, mTarget);

   if (!gfxpath) {

     return;

   }

   const ContextState &state = CurrentState();

   StrokeOptions strokeOptions(state.lineWidth, state.lineJoin,

                               state.lineCap, state.miterLimit,

                               state.dash.Length(), state.dash.Elements(),

                               state.dashOffset);

   mgfx::Rect bounds;

   if (NeedToDrawShadow()) {

     bounds =

       gfxpath->GetStrokedBounds(strokeOptions, mTarget->GetTransform());

   }

   AdjustedTarget(this, bounds.IsEmpty() ? nullptr : &bounds)->

     Stroke(gfxpath, CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget),

            strokeOptions, DrawOptions(state.globalAlpha, UsedOperation()));

   Redraw();

 }

 void CanvasRenderingContext2D::DrawFocusIfNeeded(mozilla::dom::Element& aElement)

 {

   EnsureUserSpacePath();

   if (!mPath) {

     return;

   }

   if(DrawCustomFocusRing(aElement)) {

     Save();

     // set state to conforming focus state

     ContextState& state = CurrentState();

     state.globalAlpha = 1.0;

     state.shadowBlur = 0;

     state.shadowOffset.x = 0;

     state.shadowOffset.y = 0;

     state.op = mozilla::gfx::CompositionOp::OP_OVER;

     state.lineCap = CapStyle::BUTT;

     state.lineJoin = mozilla::gfx::JoinStyle::MITER_OR_BEVEL;

     state.lineWidth = 1;

     CurrentState().dash.Clear();

     // color and style of the rings is the same as for image maps

     // set the background focus color

     CurrentState().SetColorStyle(Style::STROKE, NS_RGBA(255, 255, 255, 255));

     // draw the focus ring

     Stroke();

     // set dashing for foreground

     FallibleTArray<mozilla::gfx::Float>& dash = CurrentState().dash;

     dash.AppendElement(1);

     dash.AppendElement(1);

     // set the foreground focus color

     CurrentState().SetColorStyle(Style::STROKE, NS_RGBA(0,0,0, 255));

     // draw the focus ring

     Stroke();

     Restore();

   }

 }

 bool CanvasRenderingContext2D::DrawCustomFocusRing(mozilla::dom::Element& aElement)

 {

   EnsureUserSpacePath();

   HTMLCanvasElement* canvas = GetCanvas();

   if (!canvas|| !nsContentUtils::ContentIsDescendantOf(&aElement, canvas)) {

     return false;

   }

   nsIFocusManager* fm = nsFocusManager::GetFocusManager();

   if (fm) {

     // check that the element i focused

     nsCOMPtr<nsIDOMElement> focusedElement;

     fm->GetFocusedElement(getter_AddRefs(focusedElement));

     if (SameCOMIdentity(aElement.AsDOMNode(), focusedElement)) {

       return true;

     }

   }

   return false;

 }

 void

 CanvasRenderingContext2D::Clip(const CanvasWindingRule& winding)

 {

   EnsureUserSpacePath(winding);

   if (!mPath) {

     return;

   }

   mTarget->PushClip(mPath);

   CurrentState().clipsPushed.push_back(mPath);

 }

 void

 CanvasRenderingContext2D::Clip(const CanvasPath& path, const CanvasWindingRule& winding)

 {

   EnsureTarget();

   RefPtr<gfx::Path> gfxpath = path.GetPath(winding, mTarget);

   if (!gfxpath) {

     return;

   }

   mTarget->PushClip(gfxpath);

   CurrentState().clipsPushed.push_back(gfxpath);

 }

 void

 CanvasRenderingContext2D::ArcTo(double x1, double y1, double x2,

                                 double y2, double radius,

                                 ErrorResult& error)

 {

   if (radius < 0) {

     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);

     return;

   }

   EnsureWritablePath();

   // Current point in user space!

   Point p0;

   if (mPathBuilder) {

     p0 = mPathBuilder->CurrentPoint();

   } else {

     Matrix invTransform = mTarget->GetTransform();

     if (!invTransform.Invert()) {

       return;

     }

     p0 = invTransform * mDSPathBuilder->CurrentPoint();

   }

   Point p1(x1, y1);

   Point p2(x2, y2);

   // Execute these calculations in double precision to avoid cumulative

   // rounding errors.

   double dir, a2, b2, c2, cosx, sinx, d, anx, any,

          bnx, bny, x3, y3, x4, y4, cx, cy, angle0, angle1;

   bool anticlockwise;

   if (p0 == p1 || p1 == p2 || radius == 0) {

     LineTo(p1.x, p1.y);

     return;

   }

   // Check for colinearity

   dir = (p2.x - p1.x) * (p0.y - p1.y) + (p2.y - p1.y) * (p1.x - p0.x);

   if (dir == 0) {

     LineTo(p1.x, p1.y);

     return;

   }

   // XXX - Math for this code was already available from the non-azure code

   // and would be well tested. Perhaps converting to bezier directly might

   // be more efficient longer run.

   a2 = (p0.x-x1)*(p0.x-x1) + (p0.y-y1)*(p0.y-y1);

   b2 = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);

   c2 = (p0.x-x2)*(p0.x-x2) + (p0.y-y2)*(p0.y-y2);

   cosx = (a2+b2-c2)/(2*sqrt(a2*b2));

   sinx = sqrt(1 - cosx*cosx);

   d = radius / ((1 - cosx) / sinx);

   anx = (x1-p0.x) / sqrt(a2);

   any = (y1-p0.y) / sqrt(a2);

   bnx = (x1-x2) / sqrt(b2);

   bny = (y1-y2) / sqrt(b2);

   x3 = x1 - anx*d;

   y3 = y1 - any*d;

   x4 = x1 - bnx*d;

   y4 = y1 - bny*d;

   anticlockwise = (dir < 0);

   cx = x3 + any*radius*(anticlockwise ? 1 : -1);

   cy = y3 - anx*radius*(anticlockwise ? 1 : -1);

   angle0 = atan2((y3-cy), (x3-cx));

   angle1 = atan2((y4-cy), (x4-cx));

   LineTo(x3, y3);

   Arc(cx, cy, radius, angle0, angle1, anticlockwise, error);

 }

 void

 CanvasRenderingContext2D::Arc(double x, double y, double r,

                               double startAngle, double endAngle,

                               bool anticlockwise, ErrorResult& error)

 {

   if (r < 0.0) {

     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);

     return;

   }

   EnsureWritablePath();

   ArcToBezier(this, Point(x, y), Size(r, r), startAngle, endAngle, anticlockwise);

 }

 void

 CanvasRenderingContext2D::Rect(double x, double y, double w, double h)

 {

   EnsureWritablePath();

   if (mPathBuilder) {

     mPathBuilder->MoveTo(Point(x, y));

     mPathBuilder->LineTo(Point(x + w, y));

     mPathBuilder->LineTo(Point(x + w, y + h));

     mPathBuilder->LineTo(Point(x, y + h));

     mPathBuilder->Close();

   } else {

     mDSPathBuilder->MoveTo(mTarget->GetTransform() * Point(x, y));

     mDSPathBuilder->LineTo(mTarget->GetTransform() * Point(x + w, y));

     mDSPathBuilder->LineTo(mTarget->GetTransform() * Point(x + w, y + h));

     mDSPathBuilder->LineTo(mTarget->GetTransform() * Point(x, y + h));

     mDSPathBuilder->Close();

   }

 }

 void

 CanvasRenderingContext2D::EnsureWritablePath()

 {

   if (mDSPathBuilder) {

     return;

   }

   FillRule fillRule = CurrentState().fillRule;

   if (mPathBuilder) {

     if (mPathTransformWillUpdate) {

       mPath = mPathBuilder->Finish();

       mDSPathBuilder =

         mPath->TransformedCopyToBuilder(mPathToDS, fillRule);

       mPath = nullptr;

       mPathBuilder = nullptr;

       mPathTransformWillUpdate = false;

     }

     return;

   }

   EnsureTarget();

   if (!mPath) {

     NS_ASSERTION(!mPathTransformWillUpdate, "mPathTransformWillUpdate should be false, if all paths are null");

     mPathBuilder = mTarget->CreatePathBuilder(fillRule);

   } else if (!mPathTransformWillUpdate) {

     mPathBuilder = mPath->CopyToBuilder(fillRule);

   } else {

     mDSPathBuilder =

       mPath->TransformedCopyToBuilder(mPathToDS, fillRule);

     mPathTransformWillUpdate = false;

     mPath = nullptr;

   }

 }

 void

 CanvasRenderingContext2D::EnsureUserSpacePath(const CanvasWindingRule& winding)

 {

   FillRule fillRule = CurrentState().fillRule;

   if(winding == CanvasWindingRule::Evenodd)

     fillRule = FillRule::FILL_EVEN_ODD;

   if (!mPath && !mPathBuilder && !mDSPathBuilder) {

     EnsureTarget();

     mPathBuilder = mTarget->CreatePathBuilder(fillRule);

   }

   if (mPathBuilder) {

     mPath = mPathBuilder->Finish();

     mPathBuilder = nullptr;

   }

   if (mPath &&

       mPathTransformWillUpdate) {

     mDSPathBuilder =

       mPath->TransformedCopyToBuilder(mPathToDS, fillRule);

     mPath = nullptr;

     mPathTransformWillUpdate = false;

   }

   if (mDSPathBuilder) {

     RefPtr<Path> dsPath;

     dsPath = mDSPathBuilder->Finish();

     mDSPathBuilder = nullptr;

     Matrix inverse = mTarget->GetTransform();

     if (!inverse.Invert()) {

       NS_WARNING("Could not invert transform");

       return;

     }

     mPathBuilder =

       dsPath->TransformedCopyToBuilder(inverse, fillRule);

     mPath = mPathBuilder->Finish();

     mPathBuilder = nullptr;

   }

   if (mPath && mPath->GetFillRule() != fillRule) {

     mPathBuilder = mPath->CopyToBuilder(fillRule);

     mPath = mPathBuilder->Finish();

     mPathBuilder = nullptr;

   }

   NS_ASSERTION(mPath, "mPath should exist");

 }

 void

 CanvasRenderingContext2D::TransformWillUpdate()

 {

   EnsureTarget();

   // Store the matrix that would transform the current path to device

   // space.

   if (mPath || mPathBuilder) {

     if (!mPathTransformWillUpdate) {

       // If the transform has already been updated, but a device space builder

       // has not been created yet mPathToDS contains the right transform to

       // transform the current mPath into device space.

       // We should leave it alone.

       mPathToDS = mTarget->GetTransform();

     }

     mPathTransformWillUpdate = true;

   }

 }

 //

 // text

 //

 /**

  * Helper function for SetFont that creates a style rule for the given font.

  * @param aFont The CSS font string

  * @param aNode The canvas element

  * @param aResult Pointer in which to place the new style rule.

  * @remark Assumes all pointer arguments are non-null.

  */

 static nsresult

 CreateFontStyleRule(const nsAString& aFont,

                     nsINode* aNode,

                     StyleRule** aResult)

 {

   nsRefPtr<StyleRule> rule;

   bool changed;

   nsIPrincipal* principal = aNode->NodePrincipal();

   nsIDocument* document = aNode->OwnerDoc();

   nsIURI* docURL = document->GetDocumentURI();

   nsIURI* baseURL = document->GetDocBaseURI();

   // Pass the CSS Loader object to the parser, to allow parser error reports

   // to include the outer window ID.

   nsCSSParser parser(document->CSSLoader());

   nsresult rv = parser.ParseStyleAttribute(EmptyString(), docURL, baseURL,

                                            principal, getter_AddRefs(rule));

   if (NS_FAILED(rv)) {

     return rv;

   }

   rv = parser.ParseProperty(eCSSProperty_font, aFont, docURL, baseURL,

                             principal, rule->GetDeclaration(), &changed,

                             false);

   if (NS_FAILED(rv))

     return rv;

   rv = parser.ParseProperty(eCSSProperty_line_height,

                             NS_LITERAL_STRING("normal"), docURL, baseURL,

                             principal, rule->GetDeclaration(), &changed,

                             false);

   if (NS_FAILED(rv)) {

     return rv;

   }

   rule->RuleMatched();

   rule.forget(aResult);

   return NS_OK;

 }

 void

 CanvasRenderingContext2D::SetFont(const nsAString& font,

                                   ErrorResult& error)

 {

   /*

     * If font is defined with relative units (e.g. ems) and the parent

     * style context changes in between calls, setting the font to the

     * same value as previous could result in a different computed value,

     * so we cannot have the optimization where we check if the new font

     * string is equal to the old one.

     */

   if (!mCanvasElement && !mDocShell) {

     NS_WARNING("Canvas element must be non-null or a docshell must be provided");

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   nsIPresShell* presShell = GetPresShell();

   if (!presShell) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   nsIDocument* document = presShell->GetDocument();

   nsRefPtr<css::StyleRule> rule;

   error = CreateFontStyleRule(font, document, getter_AddRefs(rule));

   if (error.Failed()) {

     return;

   }

   css::Declaration *declaration = rule->GetDeclaration();

   // The easiest way to see whether we got a syntax error or whether

   // we got 'inherit' or 'initial' is to look at font-size-adjust,

   // which the shorthand resets to either 'none' or

   // '-moz-system-font'.

   // We know the declaration is not !important, so we can use

   // GetNormalBlock().

   const nsCSSValue *fsaVal =

     declaration->GetNormalBlock()->ValueFor(eCSSProperty_font_size_adjust);

   if (!fsaVal || (fsaVal->GetUnit() != eCSSUnit_None &&

                   fsaVal->GetUnit() != eCSSUnit_System_Font)) {

       // We got an all-property value or a syntax error.  The spec says

       // this value must be ignored.

     return;

   }

   nsTArray< nsCOMPtr<nsIStyleRule> > rules;

   rules.AppendElement(rule);

   nsStyleSet* styleSet = presShell->StyleSet();

   // have to get a parent style context for inherit-like relative

   // values (2em, bolder, etc.)

   nsRefPtr<nsStyleContext> parentContext;

   if (mCanvasElement && mCanvasElement->IsInDoc()) {

       // inherit from the canvas element

       parentContext = nsComputedDOMStyle::GetStyleContextForElement(

               mCanvasElement,

               nullptr,

               presShell);

   } else {

     // otherwise inherit from default (10px sans-serif)

     nsRefPtr<css::StyleRule> parentRule;

     error = CreateFontStyleRule(NS_LITERAL_STRING("10px sans-serif"),

                                 document,

                                 getter_AddRefs(parentRule));

     if (error.Failed()) {

       return;

     }

     nsTArray< nsCOMPtr<nsIStyleRule> > parentRules;

     parentRules.AppendElement(parentRule);

     parentContext = styleSet->ResolveStyleForRules(nullptr, parentRules);

   }

   if (!parentContext) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   // add a rule to prevent text zoom from affecting the style

   rules.AppendElement(new nsDisableTextZoomStyleRule);

   nsRefPtr<nsStyleContext> sc =

       styleSet->ResolveStyleForRules(parentContext, rules);

   if (!sc) {

     error.Throw(NS_ERROR_FAILURE);

     return;

   }

   const nsStyleFont* fontStyle = sc->StyleFont();

   NS_ASSERTION(fontStyle, "Could not obtain font style");

   nsIAtom* language = sc->StyleFont()->mLanguage;

   if (!language) {

     language = presShell->GetPresContext()->GetLanguageFromCharset();

   }

   // use CSS pixels instead of dev pixels to avoid being affected by page zoom

   const uint32_t aupcp = nsPresContext::AppUnitsPerCSSPixel();

   bool printerFont = (presShell->GetPresContext()->Type() == nsPresContext::eContext_PrintPreview ||

                       presShell->GetPresContext()->Type() == nsPresContext::eContext_Print);

   // Purposely ignore the font size that respects the user's minimum

   // font preference (fontStyle->mFont.size) in favor of the computed

   // size (fontStyle->mSize).  See

   // https://bugzilla.mozilla.org/show_bug.cgi?id=698652.

   MOZ_ASSERT(!fontStyle->mAllowZoom,

              "expected text zoom to be disabled on this nsStyleFont");

   gfxFontStyle style(fontStyle->mFont.style,

                      fontStyle->mFont.weight,

                      fontStyle->mFont.stretch,

                      NSAppUnitsToFloatPixels(fontStyle->mSize, float(aupcp)),

                      language,

                      fontStyle->mFont.sizeAdjust,

                      fontStyle->mFont.systemFont,

                      printerFont,

                      fontStyle->mFont.languageOverride);

   fontStyle->mFont.AddFontFeaturesToStyle(&style);

   nsPresContext *c = presShell->GetPresContext();

   CurrentState().fontGroup =

       gfxPlatform::GetPlatform()->CreateFontGroup(fontStyle->mFont.name,

                                                   &style,

                                                   c->GetUserFontSet());

   NS_ASSERTION(CurrentState().fontGroup, "Could not get font group");

   CurrentState().fontGroup->SetTextPerfMetrics(c->GetTextPerfMetrics());

   // The font getter is required to be reserialized based on what we

   // parsed (including having line-height removed).  (Older drafts of

   // the spec required font sizes be converted to pixels, but that no

   // longer seems to be required.)

   declaration->GetValue(eCSSProperty_font, CurrentState().font);

 }

 void

 CanvasRenderingContext2D::SetTextAlign(const nsAString& ta)

 {

   if (ta.EqualsLiteral("start"))

     CurrentState().textAlign = TextAlign::START;

   else if (ta.EqualsLiteral("end"))

     CurrentState().textAlign = TextAlign::END;

   else if (ta.EqualsLiteral("left"))

     CurrentState().textAlign = TextAlign::LEFT;

   else if (ta.EqualsLiteral("right"))

     CurrentState().textAlign = TextAlign::RIGHT;

   else if (ta.EqualsLiteral("center"))

     CurrentState().textAlign = TextAlign::CENTER;

 }

 void

 CanvasRenderingContext2D::GetTextAlign(nsAString& ta)

 {

   switch (CurrentState().textAlign)

   {

   case TextAlign::START:

     ta.AssignLiteral("start");

     break;

   case TextAlign::END:

     ta.AssignLiteral("end");

     break;

   case TextAlign::LEFT:

     ta.AssignLiteral("left");

     break;

   case TextAlign::RIGHT:

     ta.AssignLiteral("right");

     break;

   case TextAlign::CENTER:

     ta.AssignLiteral("center");

     break;

   }

 }

 void

 CanvasRenderingContext2D::SetTextBaseline(const nsAString& tb)

 {

   if (tb.EqualsLiteral("top"))

     CurrentState().textBaseline = TextBaseline::TOP;

   else if (tb.EqualsLiteral("hanging"))

     CurrentState().textBaseline = TextBaseline::HANGING;

   else if (tb.EqualsLiteral("middle"))

     CurrentState().textBaseline = TextBaseline::MIDDLE;

   else if (tb.EqualsLiteral("alphabetic"))

     CurrentState().textBaseline = TextBaseline::ALPHABETIC;

   else if (tb.EqualsLiteral("ideographic"))

     CurrentState().textBaseline = TextBaseline::IDEOGRAPHIC;

   else if (tb.EqualsLiteral("bottom"))

     CurrentState().textBaseline = TextBaseline::BOTTOM;

 }

 void

 CanvasRenderingContext2D::GetTextBaseline(nsAString& tb)

 {

   switch (CurrentState().textBaseline)

   {

   case TextBaseline::TOP:

     tb.AssignLiteral("top");

     break;

   case TextBaseline::HANGING:

     tb.AssignLiteral("hanging");

     break;

   case TextBaseline::MIDDLE:

     tb.AssignLiteral("middle");

     break;

   case TextBaseline::ALPHABETIC:

     tb.AssignLiteral("alphabetic");

     break;

   case TextBaseline::IDEOGRAPHIC:

     tb.AssignLiteral("ideographic");

     break;

   case TextBaseline::BOTTOM:

     tb.AssignLiteral("bottom");

     break;

   }

 }

 /*

  * Helper function that replaces the whitespace characters in a string

  * with U+0020 SPACE. The whitespace characters are defined as U+0020 SPACE,

  * U+0009 CHARACTER TABULATION (tab), U+000A LINE FEED (LF), U+000B LINE

  * TABULATION, U+000C FORM FEED (FF), and U+000D CARRIAGE RETURN (CR).

  * @param str The string whose whitespace characters to replace.

  */

 static inline void

 TextReplaceWhitespaceCharacters(nsAutoString& str)

 {

   str.ReplaceChar("\x09\x0A\x0B\x0C\x0D", char16_t(' '));

 }

 void

 CanvasRenderingContext2D::FillText(const nsAString& text, double x,

                                    double y,

                                    const Optional<double>& maxWidth,

                                    ErrorResult& error)

 {

   error = DrawOrMeasureText(text, x, y, maxWidth, TextDrawOperation::FILL, nullptr);

 }

 void

 CanvasRenderingContext2D::StrokeText(const nsAString& text, double x,

                                      double y,

                                      const Optional<double>& maxWidth,

                                      ErrorResult& error)

 {

   error = DrawOrMeasureText(text, x, y, maxWidth, TextDrawOperation::STROKE, nullptr);

 }

 TextMetrics*

 CanvasRenderingContext2D::MeasureText(const nsAString& rawText,

                                       ErrorResult& error)

 {

   float width;

   Optional<double> maxWidth;

   error = DrawOrMeasureText(rawText, 0, 0, maxWidth, TextDrawOperation::MEASURE, &width);

   if (error.Failed()) {

     return nullptr;

   }

   return new TextMetrics(width);

 }

 void

 CanvasRenderingContext2D::AddHitRegion(const HitRegionOptions& options, ErrorResult& error)

 {

   // remove old hit region first

   RemoveHitRegion(options.mId);

   // for now, we require a fallback element

   if (options.mControl == NULL) {

     error.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);

     return;

   }

   // check if the control is a descendant of our canvas

   HTMLCanvasElement* canvas = GetCanvas();

   bool isDescendant = true;

   if (!canvas || !nsContentUtils::ContentIsDescendantOf(options.mControl, canvas)) {

     isDescendant = false;

   }

   // check if the path is valid

   EnsureUserSpacePath(CanvasWindingRule::Nonzero);

   if(!mPath) {

     error.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);

     return;

   }

   // get the bounds of the current path. They are relative to the canvas

   mgfx::Rect bounds(mPath->GetBounds(mTarget->GetTransform()));

   if ((bounds.width == 0) || (bounds.height == 0) || !bounds.IsFinite()) {

     // The specified region has no pixels.

     error.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);

     return;

   }

 #ifdef ACCESSIBILITY

   if (isDescendant) {

     nsRect* nsBounds = new nsRect();

     gfxRect rect(bounds.x, bounds.y, bounds.width, bounds.height);

     *nsBounds = nsLayoutUtils::RoundGfxRectToAppRect(rect, AppUnitsPerCSSPixel());

     options.mControl->DeleteProperty(nsGkAtoms::hitregion);

     options.mControl->SetProperty(nsGkAtoms::hitregion, nsBounds,

                                   nsINode::DeleteProperty<nsRect>);

   }

 #endif

   // finally, add the region to the list if it has an ID

   if (options.mId.Length() != 0) {

     mHitRegionsOptions.PutEntry(options.mId)->mElement = options.mControl;

   }

 }

 void

 CanvasRenderingContext2D::RemoveHitRegion(const nsAString& id)

 {

   RegionInfo* info = mHitRegionsOptions.GetEntry(id);

   if (!info) {

     return;

   }

 #ifdef ACCESSIBILITY

   info->mElement->DeleteProperty(nsGkAtoms::hitregion);

 #endif

   mHitRegionsOptions.RemoveEntry(id);

 }

 /**

  * Used for nsBidiPresUtils::ProcessText

  */

 struct MOZ_STACK_CLASS CanvasBidiProcessor : public nsBidiPresUtils::BidiProcessor

 {

   typedef CanvasRenderingContext2D::ContextState ContextState;

   virtual void SetText(const char16_t* text, int32_t length, nsBidiDirection direction)

   {

     mFontgrp->UpdateFontList(); // ensure user font generation is current

     mTextRun = mFontgrp->MakeTextRun(text,

                                      length,

                                      mThebes,

                                      mAppUnitsPerDevPixel,

                                      direction==NSBIDI_RTL ? gfxTextRunFactory::TEXT_IS_RTL : 0);

   }

   virtual nscoord GetWidth()

   {

     gfxTextRun::Metrics textRunMetrics = mTextRun->MeasureText(0,

                                                                mTextRun->GetLength(),

                                                                mDoMeasureBoundingBox ?

                                                                  gfxFont::TIGHT_INK_EXTENTS :

                                                                  gfxFont::LOOSE_INK_EXTENTS,

                                                                mThebes,

                                                                nullptr);

     // this only measures the height; the total width is gotten from the

     // the return value of ProcessText.

     if (mDoMeasureBoundingBox) {

       textRunMetrics.mBoundingBox.Scale(1.0 / mAppUnitsPerDevPixel);

       mBoundingBox = mBoundingBox.Union(textRunMetrics.mBoundingBox);

     }

     return NSToCoordRound(textRunMetrics.mAdvanceWidth);

   }

   virtual void DrawText(nscoord xOffset, nscoord width)

   {

     gfxPoint point = mPt;

     point.x += xOffset;

     // offset is given in terms of left side of string

     if (mTextRun->IsRightToLeft()) {

       // Bug 581092 - don't use rounded pixel width to advance to

       // right-hand end of run, because this will cause different

       // glyph positioning for LTR vs RTL drawing of the same

       // glyph string on OS X and DWrite where textrun widths may

       // involve fractional pixels.

       gfxTextRun::Metrics textRunMetrics =

         mTextRun->MeasureText(0,

                               mTextRun->GetLength(),

                               mDoMeasureBoundingBox ?

                                   gfxFont::TIGHT_INK_EXTENTS :

                                   gfxFont::LOOSE_INK_EXTENTS,

                               mThebes,

                               nullptr);

       point.x += textRunMetrics.mAdvanceWidth;

       // old code was:

       //   point.x += width * mAppUnitsPerDevPixel;

       // TODO: restore this if/when we move to fractional coords

       // throughout the text layout process

     }

     uint32_t numRuns;

     const gfxTextRun::GlyphRun *runs = mTextRun->GetGlyphRuns(&numRuns);

     const int32_t appUnitsPerDevUnit = mAppUnitsPerDevPixel;

     const double devUnitsPerAppUnit = 1.0/double(appUnitsPerDevUnit);

     Point baselineOrigin =

       Point(point.x * devUnitsPerAppUnit, point.y * devUnitsPerAppUnit);

     float advanceSum = 0;

     mCtx->EnsureTarget();

     for (uint32_t c = 0; c < numRuns; c++) {

       gfxFont *font = runs[c].mFont;

       uint32_t endRun = 0;

       if (c + 1 < numRuns) {

         endRun = runs[c + 1].mCharacterOffset;

       } else {

         endRun = mTextRun->GetLength();

       }

       const gfxTextRun::CompressedGlyph *glyphs = mTextRun->GetCharacterGlyphs();

       RefPtr<ScaledFont> scaledFont =

         gfxPlatform::GetPlatform()->GetScaledFontForFont(mCtx->mTarget, font);

       if (!scaledFont) {

         // This can occur when something switched DirectWrite off.

         return;

       }

       RefPtr<GlyphRenderingOptions> renderingOptions = font->GetGlyphRenderingOptions();

       GlyphBuffer buffer;

       std::vector<Glyph> glyphBuf;

       for (uint32_t i = runs[c].mCharacterOffset; i < endRun; i++) {

         Glyph newGlyph;

         if (glyphs[i].IsSimpleGlyph()) {

           newGlyph.mIndex = glyphs[i].GetSimpleGlyph();

           if (mTextRun->IsRightToLeft()) {

             newGlyph.mPosition.x = baselineOrigin.x - advanceSum -

               glyphs[i].GetSimpleAdvance() * devUnitsPerAppUnit;

           } else {

             newGlyph.mPosition.x = baselineOrigin.x + advanceSum;

           }

           newGlyph.mPosition.y = baselineOrigin.y;

           advanceSum += glyphs[i].GetSimpleAdvance() * devUnitsPerAppUnit;

           glyphBuf.push_back(newGlyph);

           continue;

         }

         if (!glyphs[i].GetGlyphCount()) {

           continue;

         }

         gfxTextRun::DetailedGlyph *detailedGlyphs =

           mTextRun->GetDetailedGlyphs(i);

         if (glyphs[i].IsMissing()) {

           newGlyph.mIndex = 0;

           if (mTextRun->IsRightToLeft()) {

             newGlyph.mPosition.x = baselineOrigin.x - advanceSum -

               detailedGlyphs[0].mAdvance * devUnitsPerAppUnit;

           } else {

             newGlyph.mPosition.x = baselineOrigin.x + advanceSum;

           }

           newGlyph.mPosition.y = baselineOrigin.y;

           advanceSum += detailedGlyphs[0].mAdvance * devUnitsPerAppUnit;

           glyphBuf.push_back(newGlyph);

           continue;

         }

         for (uint32_t c = 0; c < glyphs[i].GetGlyphCount(); c++) {

           newGlyph.mIndex = detailedGlyphs[c].mGlyphID;

           if (mTextRun->IsRightToLeft()) {

             newGlyph.mPosition.x = baselineOrigin.x + detailedGlyphs[c].mXOffset * devUnitsPerAppUnit -

               advanceSum - detailedGlyphs[c].mAdvance * devUnitsPerAppUnit;

           } else {

             newGlyph.mPosition.x = baselineOrigin.x + detailedGlyphs[c].mXOffset * devUnitsPerAppUnit + advanceSum;

           }

           newGlyph.mPosition.y = baselineOrigin.y + detailedGlyphs[c].mYOffset * devUnitsPerAppUnit;

           glyphBuf.push_back(newGlyph);

           advanceSum += detailedGlyphs[c].mAdvance * devUnitsPerAppUnit;