diff options
Diffstat (limited to 'dom/canvas/CanvasRenderingContext2D.cpp')
| -rw-r--r-- | dom/canvas/CanvasRenderingContext2D.cpp | 6555 |
1 files changed, 6555 insertions, 0 deletions
diff --git a/dom/canvas/CanvasRenderingContext2D.cpp b/dom/canvas/CanvasRenderingContext2D.cpp new file mode 100644 index 000000000..2ed39627e --- /dev/null +++ b/dom/canvas/CanvasRenderingContext2D.cpp @@ -0,0 +1,6555 @@ +/* -*- 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 "mozilla/gfx/Helpers.h" +#include "nsXULElement.h" + +#include "nsAutoPtr.h" +#include "nsIServiceManager.h" +#include "nsMathUtils.h" +#include "SVGImageContext.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 "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 "nsContentUtils.h" + +#include "nsTArray.h" + +#include "ImageEncoder.h" +#include "ImageRegion.h" + +#include "gfxContext.h" +#include "gfxImageSurface.h" +#include "gfxPlatform.h" +#include "gfxFont.h" +#include "gfxBlur.h" +#include "gfxPrefs.h" +#include "gfxUtils.h" + +#include "nsFrameLoader.h" +#include "nsBidi.h" +#include "nsBidiPresUtils.h" +#include "Layers.h" +#include "LayerUserData.h" +#include "CanvasUtils.h" +#include "nsIMemoryReporter.h" +#include "nsStyleUtil.h" +#include "CanvasImageCache.h" + +#include <algorithm> + +#include "jsapi.h" +#include "jsfriendapi.h" +#include "js/Conversions.h" + +#include "mozilla/Alignment.h" +#include "mozilla/Assertions.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/ImageBitmap.h" +#include "mozilla/dom/ImageData.h" +#include "mozilla/dom/PBrowserParent.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/TypedArray.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Helpers.h" +#include "mozilla/gfx/Tools.h" +#include "mozilla/gfx/PathHelpers.h" +#include "mozilla/gfx/DataSurfaceHelpers.h" +#include "mozilla/gfx/PatternHelpers.h" +#include "mozilla/ipc/DocumentRendererParent.h" +#include "mozilla/ipc/PDocumentRendererParent.h" +#include "mozilla/layers/PersistentBufferProvider.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/Preferences.h" +#include "mozilla/Telemetry.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/Unused.h" +#include "nsCCUncollectableMarker.h" +#include "nsWrapperCacheInlines.h" +#include "mozilla/dom/CanvasRenderingContext2DBinding.h" +#include "mozilla/dom/CanvasPath.h" +#include "mozilla/dom/HTMLImageElement.h" +#include "mozilla/dom/HTMLVideoElement.h" +#include "mozilla/dom/SVGMatrix.h" +#include "mozilla/dom/TextMetrics.h" +#include "mozilla/dom/SVGMatrix.h" +#include "mozilla/FloatingPoint.h" +#include "nsGlobalWindow.h" +#include "GLContext.h" +#include "GLContextProvider.h" +#include "SVGContentUtils.h" +#include "nsIScreenManager.h" +#include "nsFilterInstance.h" +#include "nsSVGLength2.h" +#include "nsDeviceContext.h" +#include "nsFontMetrics.h" +#include "Units.h" +#include "CanvasUtils.h" +#include "mozilla/StyleSetHandle.h" +#include "mozilla/StyleSetHandleInlines.h" +#include "mozilla/layers/CanvasClient.h" + +#undef free // apparently defined by some windows header, clashing with a free() + // method in SkTypes.h +#include "SkiaGLGlue.h" +#ifdef USE_SKIA +#include "SurfaceTypes.h" +#include "GLBlitHelper.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::image; +using namespace mozilla::ipc; +using namespace mozilla::layers; + +namespace mozilla { +namespace dom { + +// Cap sigma to avoid overly large temp surfaces. +const Float SIGMA_MAX = 100; + +const size_t MAX_STYLE_STACK_SIZE = 1024; + +/* Memory reporter stuff */ +static int64_t gCanvasAzureMemoryUsed = 0; + +// Adds Save() / Restore() calls to the scope. +class MOZ_RAII AutoSaveRestore +{ +public: + explicit AutoSaveRestore(CanvasRenderingContext2D* aCtx + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : mCtx(aCtx) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + mCtx->Save(); + } + ~AutoSaveRestore() { mCtx->Restore(); } +private: + RefPtr<CanvasRenderingContext2D> mCtx; + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER +}; + +// 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 final : public nsIMemoryReporter +{ + ~Canvas2dPixelsReporter() {} +public: + NS_DECL_ISUPPORTS + + NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) override + { + MOZ_COLLECT_REPORT( + "canvas-2d-pixels", KIND_OTHER, UNITS_BYTES, gCanvasAzureMemoryUsed, + "Memory used by 2D canvases. Each canvas requires " + "(width * height * 4) bytes."); + + return NS_OK; + } +}; + +NS_IMPL_ISUPPORTS(Canvas2dPixelsReporter, nsIMemoryReporter) + +class CanvasRadialGradient : public CanvasGradient +{ +public: + CanvasRadialGradient(CanvasRenderingContext2D* aContext, + const Point& aBeginOrigin, Float aBeginRadius, + const Point& aEndOrigin, Float aEndRadius) + : CanvasGradient(aContext, 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, + const Point& aBegin, const Point& aEnd) + : CanvasGradient(aContext, Type::LINEAR) + , mBegin(aBegin) + , mEnd(aEnd) + { + } + +protected: + friend struct CanvasBidiProcessor; + friend class CanvasGeneralPattern; + + // Beginning of linear gradient. + Point mBegin; + // End of linear gradient. + Point mEnd; +}; + +bool +CanvasRenderingContext2D::PatternIsOpaque(CanvasRenderingContext2D::Style aStyle) const +{ + const ContextState& state = CurrentState(); + if (state.globalAlpha < 1.0) { + return false; + } + + if (state.patternStyles[aStyle] && state.patternStyles[aStyle]->mSurface) { + return IsOpaqueFormat(state.patternStyles[aStyle]->mSurface->GetFormat()); + } + + // TODO: for gradient patterns we could check that all stops are opaque + // colors. + + if (!state.gradientStyles[aStyle]) { + // it's a color pattern. + return Color::FromABGR(state.colorStyles[aStyle]).a >= 1.0; + } + + return false; +} + +// 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; + + 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.GetPattern(), "ForStyle() should only be called once on CanvasGeneralPattern!"); + + const ContextState& state = aCtx->CurrentState(); + + if (state.StyleIsColor(aStyle)) { + mPattern.InitColorPattern(ToDeviceColor(state.colorStyles[aStyle])); + } else if (state.gradientStyles[aStyle] && + state.gradientStyles[aStyle]->GetType() == CanvasGradient::Type::LINEAR) { + auto gradient = + static_cast<CanvasLinearGradient*>(state.gradientStyles[aStyle].get()); + + mPattern.InitLinearGradientPattern(gradient->mBegin, gradient->mEnd, + gradient->GetGradientStopsForTarget(aRT)); + } else if (state.gradientStyles[aStyle] && + state.gradientStyles[aStyle]->GetType() == CanvasGradient::Type::RADIAL) { + auto gradient = + static_cast<CanvasRadialGradient*>(state.gradientStyles[aStyle].get()); + + mPattern.InitRadialGradientPattern(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; + } + + SamplingFilter samplingFilter; + if (state.imageSmoothingEnabled) { + samplingFilter = SamplingFilter::GOOD; + } else { + samplingFilter = SamplingFilter::POINT; + } + + mPattern.InitSurfacePattern(state.patternStyles[aStyle]->mSurface, mode, + state.patternStyles[aStyle]->mTransform, + samplingFilter); + } + + return *mPattern.GetPattern(); + } + + GeneralPattern mPattern; +}; + +/* This is an RAII based class that can be used as a drawtarget for + * operations that need to have a filter applied to their results. + * All coordinates passed to the constructor are in device space. + */ +class AdjustedTargetForFilter +{ +public: + typedef CanvasRenderingContext2D::ContextState ContextState; + + AdjustedTargetForFilter(CanvasRenderingContext2D* aCtx, + DrawTarget* aFinalTarget, + const gfx::IntPoint& aFilterSpaceToTargetOffset, + const gfx::IntRect& aPreFilterBounds, + const gfx::IntRect& aPostFilterBounds, + gfx::CompositionOp aCompositionOp) + : mFinalTarget(aFinalTarget) + , mCtx(aCtx) + , mPostFilterBounds(aPostFilterBounds) + , mOffset(aFilterSpaceToTargetOffset) + , mCompositionOp(aCompositionOp) + { + nsIntRegion sourceGraphicNeededRegion; + nsIntRegion fillPaintNeededRegion; + nsIntRegion strokePaintNeededRegion; + + FilterSupport::ComputeSourceNeededRegions( + aCtx->CurrentState().filter, mPostFilterBounds, + sourceGraphicNeededRegion, fillPaintNeededRegion, + strokePaintNeededRegion); + + mSourceGraphicRect = sourceGraphicNeededRegion.GetBounds(); + mFillPaintRect = fillPaintNeededRegion.GetBounds(); + mStrokePaintRect = strokePaintNeededRegion.GetBounds(); + + mSourceGraphicRect = mSourceGraphicRect.Intersect(aPreFilterBounds); + + if (mSourceGraphicRect.IsEmpty()) { + // The filter might not make any use of the source graphic. We need to + // create a DrawTarget that we can return from DT() anyway, so we'll + // just use a 1x1-sized one. + mSourceGraphicRect.SizeTo(1, 1); + } + + mTarget = mFinalTarget->CreateSimilarDrawTarget(mSourceGraphicRect.Size(), + SurfaceFormat::B8G8R8A8); + + if (!mTarget) { + // XXX - Deal with the situation where our temp size is too big to + // fit in a texture (bug 1066622). + mTarget = mFinalTarget; + mCtx = nullptr; + mFinalTarget = nullptr; + return; + } + + mTarget->SetTransform( + mFinalTarget->GetTransform().PostTranslate(-mSourceGraphicRect.TopLeft() + mOffset)); + } + + // Return a SourceSurface that contains the FillPaint or StrokePaint source. + already_AddRefed<SourceSurface> + DoSourcePaint(gfx::IntRect& aRect, CanvasRenderingContext2D::Style aStyle) + { + if (aRect.IsEmpty()) { + return nullptr; + } + + RefPtr<DrawTarget> dt = + mFinalTarget->CreateSimilarDrawTarget(aRect.Size(), SurfaceFormat::B8G8R8A8); + if (!dt) { + aRect.SetEmpty(); + return nullptr; + } + + Matrix transform = + mFinalTarget->GetTransform().PostTranslate(-aRect.TopLeft() + mOffset); + + dt->SetTransform(transform); + + if (transform.Invert()) { + gfx::Rect dtBounds(0, 0, aRect.width, aRect.height); + gfx::Rect fillRect = transform.TransformBounds(dtBounds); + dt->FillRect(fillRect, CanvasGeneralPattern().ForStyle(mCtx, aStyle, dt)); + } + return dt->Snapshot(); + } + + ~AdjustedTargetForFilter() + { + if (!mCtx) { + return; + } + + RefPtr<SourceSurface> snapshot = mTarget->Snapshot(); + + RefPtr<SourceSurface> fillPaint = + DoSourcePaint(mFillPaintRect, CanvasRenderingContext2D::Style::FILL); + RefPtr<SourceSurface> strokePaint = + DoSourcePaint(mStrokePaintRect, CanvasRenderingContext2D::Style::STROKE); + + AutoRestoreTransform autoRestoreTransform(mFinalTarget); + mFinalTarget->SetTransform(Matrix()); + + MOZ_RELEASE_ASSERT(!mCtx->CurrentState().filter.mPrimitives.IsEmpty()); + gfx::FilterSupport::RenderFilterDescription( + mFinalTarget, mCtx->CurrentState().filter, + gfx::Rect(mPostFilterBounds), + snapshot, mSourceGraphicRect, + fillPaint, mFillPaintRect, + strokePaint, mStrokePaintRect, + mCtx->CurrentState().filterAdditionalImages, + mPostFilterBounds.TopLeft() - mOffset, + DrawOptions(1.0f, mCompositionOp)); + + const gfx::FilterDescription& filter = mCtx->CurrentState().filter; + MOZ_RELEASE_ASSERT(!filter.mPrimitives.IsEmpty()); + if (filter.mPrimitives.LastElement().IsTainted() && mCtx->mCanvasElement) { + mCtx->mCanvasElement->SetWriteOnly(); + } + } + + DrawTarget* DT() + { + return mTarget; + } + +private: + RefPtr<DrawTarget> mTarget; + RefPtr<DrawTarget> mFinalTarget; + CanvasRenderingContext2D* mCtx; + gfx::IntRect mSourceGraphicRect; + gfx::IntRect mFillPaintRect; + gfx::IntRect mStrokePaintRect; + gfx::IntRect mPostFilterBounds; + gfx::IntPoint mOffset; + gfx::CompositionOp mCompositionOp; +}; + +/* This is an RAII based class that can be used as a drawtarget for + * operations that need to have a shadow applied to their results. + * All coordinates passed to the constructor are in device space. + */ +class AdjustedTargetForShadow +{ +public: + typedef CanvasRenderingContext2D::ContextState ContextState; + + AdjustedTargetForShadow(CanvasRenderingContext2D* aCtx, + DrawTarget* aFinalTarget, + const gfx::Rect& aBounds, + gfx::CompositionOp aCompositionOp) + : mFinalTarget(aFinalTarget) + , mCtx(aCtx) + , mCompositionOp(aCompositionOp) + { + const ContextState& state = mCtx->CurrentState(); + mSigma = state.ShadowBlurSigma(); + + // 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. + gfx::Rect bounds = aBounds; + int32_t blurRadius = state.ShadowBlurRadius(); + bounds.Inflate(blurRadius); + bounds.RoundOut(); + bounds.ToIntRect(&mTempRect); + + mTarget = + mFinalTarget->CreateShadowDrawTarget(mTempRect.Size(), + SurfaceFormat::B8G8R8A8, mSigma); + + if (!mTarget) { + // XXX - Deal with the situation where our temp size is too big to + // fit in a texture (bug 1066622). + mTarget = mFinalTarget; + mCtx = nullptr; + mFinalTarget = nullptr; + } else { + mTarget->SetTransform( + mFinalTarget->GetTransform().PostTranslate(-mTempRect.TopLeft())); + } + } + + ~AdjustedTargetForShadow() + { + if (!mCtx) { + return; + } + + RefPtr<SourceSurface> snapshot = mTarget->Snapshot(); + + mFinalTarget->DrawSurfaceWithShadow(snapshot, mTempRect.TopLeft(), + Color::FromABGR(mCtx->CurrentState().shadowColor), + mCtx->CurrentState().shadowOffset, mSigma, + mCompositionOp); + } + + DrawTarget* DT() + { + return mTarget; + } + + gfx::IntPoint OffsetToFinalDT() + { + return mTempRect.TopLeft(); + } + +private: + RefPtr<DrawTarget> mTarget; + RefPtr<DrawTarget> mFinalTarget; + CanvasRenderingContext2D* mCtx; + Float mSigma; + gfx::IntRect mTempRect; + gfx::CompositionOp mCompositionOp; +}; + +/* + * This is an RAII based class that can be used as a drawtarget for + * operations that need a shadow or a filter drawn. It will automatically + * provide a temporary target when needed, and if so blend it back with a + * shadow, filter, or both. + * If both a shadow and a filter are needed, the filter is applied first, + * and the shadow is applied to the filtered results. + * + * aBounds specifies the bounds of the drawing operation that will be + * drawn to the target, it is given in device space! If this is nullptr the + * drawing operation will be assumed to cover the whole canvas. + */ +class AdjustedTarget +{ +public: + typedef CanvasRenderingContext2D::ContextState ContextState; + + explicit AdjustedTarget(CanvasRenderingContext2D* aCtx, + const gfx::Rect* aBounds = nullptr) + { + // All rects in this function are in the device space of ctx->mTarget. + + // In order to keep our temporary surfaces as small as possible, we first + // calculate what their maximum required bounds would need to be if we + // were to fill the whole canvas. Everything outside those bounds we don't + // need to render. + gfx::Rect r(0, 0, aCtx->mWidth, aCtx->mHeight); + gfx::Rect maxSourceNeededBoundsForShadow = + MaxSourceNeededBoundsForShadow(r, aCtx); + gfx::Rect maxSourceNeededBoundsForFilter = + MaxSourceNeededBoundsForFilter(maxSourceNeededBoundsForShadow, aCtx); + if (!aCtx->IsTargetValid()) { + return; + } + + gfx::Rect bounds = maxSourceNeededBoundsForFilter; + if (aBounds) { + bounds = bounds.Intersect(*aBounds); + } + gfx::Rect boundsAfterFilter = BoundsAfterFilter(bounds, aCtx); + if (!aCtx->IsTargetValid()) { + return; + } + + mozilla::gfx::CompositionOp op = aCtx->CurrentState().op; + + gfx::IntPoint offsetToFinalDT; + + // First set up the shadow draw target, because the shadow goes outside. + // It applies to the post-filter results, if both a filter and a shadow + // are used. + if (aCtx->NeedToDrawShadow()) { + mShadowTarget = MakeUnique<AdjustedTargetForShadow>( + aCtx, aCtx->mTarget, boundsAfterFilter, op); + mTarget = mShadowTarget->DT(); + offsetToFinalDT = mShadowTarget->OffsetToFinalDT(); + + // If we also have a filter, the filter needs to be drawn with OP_OVER + // because shadow drawing already applies op on the result. + op = gfx::CompositionOp::OP_OVER; + } + + // Now set up the filter draw target. + const bool applyFilter = aCtx->NeedToApplyFilter(); + if (!aCtx->IsTargetValid()) { + return; + } + if (applyFilter) { + bounds.RoundOut(); + + if (!mTarget) { + mTarget = aCtx->mTarget; + } + gfx::IntRect intBounds; + if (!bounds.ToIntRect(&intBounds)) { + return; + } + mFilterTarget = MakeUnique<AdjustedTargetForFilter>( + aCtx, mTarget, offsetToFinalDT, intBounds, + gfx::RoundedToInt(boundsAfterFilter), op); + mTarget = mFilterTarget->DT(); + } + if (!mTarget) { + mTarget = aCtx->mTarget; + } + } + + ~AdjustedTarget() + { + // The order in which the targets are finalized is important. + // Filters are inside, any shadow applies to the post-filter results. + mFilterTarget.reset(); + mShadowTarget.reset(); + } + + operator DrawTarget*() + { + return mTarget; + } + + DrawTarget* operator->() MOZ_NO_ADDREF_RELEASE_ON_RETURN + { + return mTarget; + } + +private: + + gfx::Rect + MaxSourceNeededBoundsForFilter(const gfx::Rect& aDestBounds, CanvasRenderingContext2D* aCtx) + { + const bool applyFilter = aCtx->NeedToApplyFilter(); + if (!aCtx->IsTargetValid()) { + return aDestBounds; + } + if (!applyFilter) { + return aDestBounds; + } + + nsIntRegion sourceGraphicNeededRegion; + nsIntRegion fillPaintNeededRegion; + nsIntRegion strokePaintNeededRegion; + + FilterSupport::ComputeSourceNeededRegions( + aCtx->CurrentState().filter, gfx::RoundedToInt(aDestBounds), + sourceGraphicNeededRegion, fillPaintNeededRegion, strokePaintNeededRegion); + + return gfx::Rect(sourceGraphicNeededRegion.GetBounds()); + } + + gfx::Rect + MaxSourceNeededBoundsForShadow(const gfx::Rect& aDestBounds, CanvasRenderingContext2D* aCtx) + { + if (!aCtx->NeedToDrawShadow()) { + return aDestBounds; + } + + const ContextState& state = aCtx->CurrentState(); + gfx::Rect sourceBounds = aDestBounds - state.shadowOffset; + sourceBounds.Inflate(state.ShadowBlurRadius()); + + // Union the shadow source with the original rect because we're going to + // draw both. + return sourceBounds.Union(aDestBounds); + } + + gfx::Rect + BoundsAfterFilter(const gfx::Rect& aBounds, CanvasRenderingContext2D* aCtx) + { + const bool applyFilter = aCtx->NeedToApplyFilter(); + if (!aCtx->IsTargetValid()) { + return aBounds; + } + if (!applyFilter) { + return aBounds; + } + + gfx::Rect bounds(aBounds); + bounds.RoundOut(); + + gfx::IntRect intBounds; + if (!bounds.ToIntRect(&intBounds)) { + return gfx::Rect(); + } + + nsIntRegion extents = + gfx::FilterSupport::ComputePostFilterExtents(aCtx->CurrentState().filter, + intBounds); + return gfx::Rect(extents.GetBounds()); + } + + RefPtr<DrawTarget> mTarget; + UniquePtr<AdjustedTargetForShadow> mShadowTarget; + UniquePtr<AdjustedTargetForFilter> mFilterTarget; +}; + +void +CanvasPattern::SetTransform(SVGMatrix& aMatrix) +{ + mTransform = ToMatrix(aMatrix.GetMatrix()); +} + +void +CanvasGradient::AddColorStop(float aOffset, const nsAString& aColorstr, ErrorResult& aRv) +{ + if (aOffset < 0.0 || aOffset > 1.0) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + nsCSSValue value; + nsCSSParser parser; + if (!parser.ParseColorString(aColorstr, nullptr, 0, value)) { + aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR); + return; + } + + nscolor color; + nsCOMPtr<nsIPresShell> presShell = mContext ? mContext->GetPresShell() : nullptr; + if (!nsRuleNode::ComputeColor(value, presShell ? presShell->GetPresContext() : nullptr, + nullptr, color)) { + aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR); + return; + } + + mStops = nullptr; + + GradientStop newStop; + + newStop.offset = aOffset; + 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(CanvasGradient, mContext) + +NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(CanvasPattern, AddRef) +NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(CanvasPattern, Release) + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(CanvasPattern, mContext) + +class CanvasShutdownObserver final : public nsIObserver +{ +public: + explicit CanvasShutdownObserver(CanvasRenderingContext2D* aCanvas) + : mCanvas(aCanvas) + {} + + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER +private: + ~CanvasShutdownObserver() {} + + CanvasRenderingContext2D* mCanvas; +}; + +NS_IMPL_ISUPPORTS(CanvasShutdownObserver, nsIObserver) + +NS_IMETHODIMP +CanvasShutdownObserver::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + if (mCanvas && strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) { + mCanvas->OnShutdown(); + nsContentUtils::UnregisterShutdownObserver(this); + } + + return NS_OK; +} + +class CanvasDrawObserver +{ +public: + explicit CanvasDrawObserver(CanvasRenderingContext2D* aCanvasContext); + + // Only enumerate draw calls that could affect the heuristic + enum DrawCallType { + PutImageData, + GetImageData, + DrawImage + }; + + // This is the one that we call on relevant draw calls and count + // GPU vs. CPU preferrable calls... + void DidDrawCall(DrawCallType aType); + + // When this returns true, the observer is done making the decisions. + // Right now, we expect to get rid of the observer after the FrameEnd + // returns true, though the decision could eventually change if the + // function calls shift. If we change to monitor the functions called + // and make decisions to change more than once, we would probably want + // FrameEnd to reset the timer and counters as it returns true. + bool FrameEnd(); + +private: + // These values will be picked up from preferences: + int32_t mMinFramesBeforeDecision; + float mMinSecondsBeforeDecision; + int32_t mMinCallsBeforeDecision; + + CanvasRenderingContext2D* mCanvasContext; + int32_t mSoftwarePreferredCalls; + int32_t mGPUPreferredCalls; + int32_t mFramesRendered; + TimeStamp mCreationTime; +}; + +// We are not checking for the validity of the preference values. For example, +// negative values will have an effect of a quick exit, so no harm done. +CanvasDrawObserver::CanvasDrawObserver(CanvasRenderingContext2D* aCanvasContext) + : mMinFramesBeforeDecision(gfxPrefs::CanvasAutoAccelerateMinFrames()) + , mMinSecondsBeforeDecision(gfxPrefs::CanvasAutoAccelerateMinSeconds()) + , mMinCallsBeforeDecision(gfxPrefs::CanvasAutoAccelerateMinCalls()) + , mCanvasContext(aCanvasContext) + , mSoftwarePreferredCalls(0) + , mGPUPreferredCalls(0) + , mFramesRendered(0) + , mCreationTime(TimeStamp::NowLoRes()) +{} + +void +CanvasDrawObserver::DidDrawCall(DrawCallType aType) +{ + switch (aType) { + case PutImageData: + case GetImageData: + if (mGPUPreferredCalls == 0 && mSoftwarePreferredCalls == 0) { + mCreationTime = TimeStamp::NowLoRes(); + } + mSoftwarePreferredCalls++; + break; + case DrawImage: + if (mGPUPreferredCalls == 0 && mSoftwarePreferredCalls == 0) { + mCreationTime = TimeStamp::NowLoRes(); + } + mGPUPreferredCalls++; + break; + } +} + +// If we return true, the observer is done making the decisions... +bool +CanvasDrawObserver::FrameEnd() +{ + mFramesRendered++; + + // We log the first mMinFramesBeforeDecision frames of any + // canvas object then make a call to determine whether it should + // be GPU or CPU backed + if ((mFramesRendered >= mMinFramesBeforeDecision) || + ((TimeStamp::NowLoRes() - mCreationTime).ToSeconds()) > mMinSecondsBeforeDecision) { + + // If we don't have enough data, don't bother changing... + if (mGPUPreferredCalls > mMinCallsBeforeDecision || + mSoftwarePreferredCalls > mMinCallsBeforeDecision) { + CanvasRenderingContext2D::RenderingMode switchToMode; + if (mGPUPreferredCalls >= mSoftwarePreferredCalls) { + switchToMode = CanvasRenderingContext2D::RenderingMode::OpenGLBackendMode; + } else { + switchToMode = CanvasRenderingContext2D::RenderingMode::SoftwareBackendMode; + } + if (switchToMode != mCanvasContext->mRenderingMode) { + if (!mCanvasContext->SwitchRenderingMode(switchToMode)) { + gfxDebug() << "Canvas acceleration failed mode switch to " << switchToMode; + } + } + } + + // If we ever redesign this class to constantly monitor the functions + // and keep making decisions, we would probably want to reset the counters + // and the timers here... + return true; + } + return false; +} + +class CanvasRenderingContext2DUserData : public LayerUserData { +public: + explicit CanvasRenderingContext2DUserData(CanvasRenderingContext2D* aContext) + : mContext(aContext) + { + aContext->mUserDatas.AppendElement(this); + } + ~CanvasRenderingContext2DUserData() + { + if (mContext) { + mContext->mUserDatas.RemoveElement(this); + } + } + + static void PreTransactionCallback(void* aData) + { + auto self = static_cast<CanvasRenderingContext2DUserData*>(aData); + CanvasRenderingContext2D* context = self->mContext; + if (!context || !context->mTarget) + return; + + context->OnStableState(); + } + + static void DidTransactionCallback(void* aData) + { + auto self = static_cast<CanvasRenderingContext2DUserData*>(aData); + if (self->mContext) { + self->mContext->MarkContextClean(); + if (self->mContext->mDrawObserver) { + if (self->mContext->mDrawObserver->FrameEnd()) { + // Note that this call deletes and nulls out mDrawObserver: + self->mContext->RemoveDrawObserver(); + } + } + } + } + bool IsForContext(CanvasRenderingContext2D* aContext) + { + return mContext == aContext; + } + void Forget() + { + mContext = nullptr; + } + +private: + CanvasRenderingContext2D* mContext; +}; + +class CanvasFilterChainObserver : public nsSVGFilterChainObserver +{ +public: + CanvasFilterChainObserver(nsTArray<nsStyleFilter>& aFilters, + Element* aCanvasElement, + CanvasRenderingContext2D* aContext) + : nsSVGFilterChainObserver(aFilters, aCanvasElement) + , mContext(aContext) + { + } + + virtual void DoUpdate() override + { + if (!mContext) { + MOZ_CRASH("GFX: This should never be called without a context"); + } + // Refresh the cached FilterDescription in mContext->CurrentState().filter. + // If this filter is not at the top of the state stack, we'll refresh the + // wrong filter, but that's ok, because we'll refresh the right filter + // when we pop the state stack in CanvasRenderingContext2D::Restore(). + RefPtr<CanvasRenderingContext2D> kungFuDeathGrip(mContext); + kungFuDeathGrip->UpdateFilter(); + } + + void DetachFromContext() { 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) + // Make sure we remove ourselves from the list of demotable contexts (raw pointers), + // since we're logically destructed at this point. + CanvasRenderingContext2D::RemoveDemotableContext(tmp); + 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]); + auto filterChainObserver = + static_cast<CanvasFilterChainObserver*>(tmp->mStyleStack[i].filterChainObserver.get()); + if (filterChainObserver) { + filterChainObserver->DetachFromContext(); + } + ImplCycleCollectionUnlink(tmp->mStyleStack[i].filterChainObserver); + } + for (size_t x = 0 ; x < tmp->mHitRegionsOptions.Length(); x++) { + RegionInfo& info = tmp->mHitRegionsOptions[x]; + if (info.mElement) { + ImplCycleCollectionUnlink(info.mElement); + } + } + 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"); + ImplCycleCollectionTraverse(cb, tmp->mStyleStack[i].filterChainObserver, "Filter Chain Observer"); + } + for (size_t x = 0 ; x < tmp->mHitRegionsOptions.Length(); x++) { + RegionInfo& info = tmp->mHitRegionsOptions[x]; + if (info.mElement) { + ImplCycleCollectionTraverse(cb, info.mElement, "Hit region fallback element"); + } + } + 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. +uintptr_t CanvasRenderingContext2D::sNumLivingContexts = 0; +DrawTarget* CanvasRenderingContext2D::sErrorTarget = nullptr; + + + +CanvasRenderingContext2D::CanvasRenderingContext2D(layers::LayersBackend aCompositorBackend) + : mRenderingMode(RenderingMode::OpenGLBackendMode) + , mCompositorBackend(aCompositorBackend) + // these are the default values from the Canvas spec + , mWidth(0), mHeight(0) + , mZero(false), mOpaque(false) + , mResetLayer(true) + , mIPC(false) + , mIsSkiaGL(false) + , mHasPendingStableStateCallback(false) + , mDrawObserver(nullptr) + , mIsEntireFrameInvalid(false) + , mPredictManyRedrawCalls(false) + , mIsCapturedFrameInvalid(false) + , mPathTransformWillUpdate(false) + , mInvalidateCount(0) +{ + sNumLivingContexts++; + + mShutdownObserver = new CanvasShutdownObserver(this); + nsContentUtils::RegisterShutdownObserver(mShutdownObserver); + + // The default is to use OpenGL mode + if (AllowOpenGLCanvas()) { + mDrawObserver = new CanvasDrawObserver(this); + } else { + mRenderingMode = RenderingMode::SoftwareBackendMode; + } +} + +CanvasRenderingContext2D::~CanvasRenderingContext2D() +{ + RemoveDrawObserver(); + RemovePostRefreshObserver(); + RemoveShutdownObserver(); + 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* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return CanvasRenderingContext2DBinding::Wrap(aCx, this, aGivenProto); +} + +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 + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + RefPtr<nsStyleContext> parentContext; + if (mCanvasElement && mCanvasElement->IsInUncomposedDoc()) { + // Inherit from the canvas element. + parentContext = nsComputedDOMStyle::GetStyleContextForElement( + mCanvasElement, nullptr, presShell); + } + + Unused << nsRuleNode::ComputeColor( + value, presShell ? presShell->GetPresContext() : nullptr, parentContext, + *aColor); + } + return true; +} + +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; + } + + bool forceReset = true; + ReturnTarget(forceReset); + mTarget = nullptr; + mBufferProvider = nullptr; + + // reset hit regions + mHitRegionsOptions.ClearAndRetainStorage(); + + // Since the target changes the backing texture will change, and this will + // no longer be valid. + mIsEntireFrameInvalid = false; + mPredictManyRedrawCalls = false; + mIsCapturedFrameInvalid = false; + + return NS_OK; +} + +void +CanvasRenderingContext2D::OnShutdown() +{ + mShutdownObserver = nullptr; + + RefPtr<PersistentBufferProvider> provider = mBufferProvider; + + Reset(); + + if (provider) { + provider->OnShutdown(); + } +} + +void +CanvasRenderingContext2D::RemoveShutdownObserver() +{ + if (mShutdownObserver) { + nsContentUtils::UnregisterShutdownObserver(mShutdownObserver); + mShutdownObserver = nullptr; + } +} + +void +CanvasRenderingContext2D::SetStyleFromString(const nsAString& aStr, + Style aWhichStyle) +{ + MOZ_ASSERT(!aStr.IsVoid()); + + nscolor color; + if (!ParseColor(aStr, &color)) { + return; + } + + CurrentState().SetColorStyle(aWhichStyle, 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() +{ + mIsCapturedFrameInvalid = true; + + 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 gfx::Rect& aR) +{ + mIsCapturedFrameInvalid = true; + + ++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(&aR); +} + +void +CanvasRenderingContext2D::DidRefresh() +{ + if (IsTargetValid() && mIsSkiaGL) { + SkiaGLGlue* glue = gfxPlatform::GetPlatform()->GetSkiaGLGlue(); + MOZ_ASSERT(glue); + + auto gl = glue->GetGLContext(); + gl->FlushIfHeavyGLCallsSinceLastFlush(); + } +} + +void +CanvasRenderingContext2D::RedrawUser(const gfxRect& aR) +{ + mIsCapturedFrameInvalid = true; + + if (mIsEntireFrameInvalid) { + ++mInvalidateCount; + return; + } + + gfx::Rect newr = mTarget->GetTransform().TransformBounds(ToRect(aR)); + Redraw(newr); +} + +bool +CanvasRenderingContext2D::AllowOpenGLCanvas() const +{ + // If we somehow didn't have the correct compositor in the constructor, + // we could do something like this to get it: + // + // HTMLCanvasElement* el = GetCanvas(); + // if (el) { + // mCompositorBackend = el->GetCompositorBackendType(); + // } + // + // We could have LAYERS_NONE if there was no widget at the time of + // canvas creation, but in that case the + // HTMLCanvasElement::GetCompositorBackendType would return LAYERS_NONE + // as well, so it wouldn't help much. + + return (mCompositorBackend == LayersBackend::LAYERS_OPENGL) && + gfxPlatform::GetPlatform()->AllowOpenGLCanvas(); +} + +bool CanvasRenderingContext2D::SwitchRenderingMode(RenderingMode aRenderingMode) +{ + if (!IsTargetValid() || mRenderingMode == aRenderingMode) { + return false; + } + + MOZ_ASSERT(mBufferProvider); + +#ifdef USE_SKIA_GPU + // Do not attempt to switch into GL mode if the platform doesn't allow it. + if ((aRenderingMode == RenderingMode::OpenGLBackendMode) && + !AllowOpenGLCanvas()) { + return false; + } +#endif + + RefPtr<PersistentBufferProvider> oldBufferProvider = mBufferProvider; + + // Return the old target to the buffer provider. + // We need to do this before calling EnsureTarget. + ReturnTarget(); + mTarget = nullptr; + mBufferProvider = nullptr; + mResetLayer = true; + + // Borrowing the snapshot must be done after ReturnTarget. + RefPtr<SourceSurface> snapshot = oldBufferProvider->BorrowSnapshot(); + + // Recreate mTarget using the new rendering mode + RenderingMode attemptedMode = EnsureTarget(nullptr, aRenderingMode); + if (!IsTargetValid()) { + oldBufferProvider->ReturnSnapshot(snapshot.forget()); + return false; + } + + // We succeeded, so update mRenderingMode to reflect reality + mRenderingMode = attemptedMode; + + // Restore the content from the old DrawTarget + // Clips and transform were already restored in EnsureTarget. + mTarget->CopySurface(snapshot, IntRect(0, 0, mWidth, mHeight), IntPoint()); + oldBufferProvider->ReturnSnapshot(snapshot.forget()); + return true; +} + +void CanvasRenderingContext2D::Demote() +{ + if (SwitchRenderingMode(RenderingMode::SoftwareBackendMode)) { + RemoveDemotableContext(this); + } +} + +std::vector<CanvasRenderingContext2D*>& +CanvasRenderingContext2D::DemotableContexts() +{ + // This is a list of raw pointers to cycle-collected objects. We need to ensure + // that we remove elements from it during UNLINK (which can happen considerably before + // the actual destructor) since the object is logically destroyed at that point + // and will be in an inconsistant state. + 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(); + if (oldest->SwitchRenderingMode(RenderingMode::SoftwareBackendMode)) { + RemoveDemotableContext(oldest); + } +} + +void +CanvasRenderingContext2D::AddDemotableContext(CanvasRenderingContext2D* aContext) +{ + std::vector<CanvasRenderingContext2D*>::iterator iter = std::find(DemotableContexts().begin(), DemotableContexts().end(), aContext); + if (iter != DemotableContexts().end()) + return; + + DemotableContexts().push_back(aContext); +} + +void +CanvasRenderingContext2D::RemoveDemotableContext(CanvasRenderingContext2D* aContext) +{ + std::vector<CanvasRenderingContext2D*>::iterator iter = std::find(DemotableContexts().begin(), DemotableContexts().end(), aContext); + if (iter != DemotableContexts().end()) + DemotableContexts().erase(iter); +} + +bool +CanvasRenderingContext2D::CheckSizeForSkiaGL(IntSize aSize) { + MOZ_ASSERT(NS_IsMainThread()); + + int minsize = Preferences::GetInt("gfx.canvas.min-size-for-skia-gl", 128); + if (aSize.width < minsize || aSize.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 aSize.width <= maxsize && aSize.height <= maxsize; + } + + // Cache the number of pixels on the primary screen + static int32_t gScreenPixels = -1; + if (gScreenPixels < 0) { + // Default to historical mobile screen size of 980x480, like FishIEtank. + // In addition, allow skia use up to this size even if the screen is smaller. + // A lot content expects this size to work well. + // See Bug 999841 + if (gfxPlatform::GetPlatform()->HasEnoughTotalSystemMemoryForSkiaGL()) { + gScreenPixels = 980 * 480; + } + + 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 = std::max(gScreenPixels, width * height); + } + } + } + + // Just always use a scale of 1.0. It can be changed if a lot of contents need it. + static double gDefaultScale = 1.0; + + double scale = gDefaultScale > 0 ? gDefaultScale : 1.0; + int32_t threshold = ceil(scale * scale * gScreenPixels); + + // screen size acts as max threshold + return threshold < 0 || (aSize.width * aSize.height) <= threshold; +} + +void +CanvasRenderingContext2D::ScheduleStableStateCallback() +{ + if (mHasPendingStableStateCallback) { + return; + } + mHasPendingStableStateCallback = true; + + nsContentUtils::RunInStableState( + NewRunnableMethod(this, &CanvasRenderingContext2D::OnStableState) + ); +} + +void +CanvasRenderingContext2D::OnStableState() +{ + if (!mHasPendingStableStateCallback) { + return; + } + + ReturnTarget(); + + mHasPendingStableStateCallback = false; +} + +void +CanvasRenderingContext2D::RestoreClipsAndTransformToTarget() +{ + // Restore clips and transform. + mTarget->SetTransform(Matrix()); + + if (mTarget->GetBackendType() == gfx::BackendType::CAIRO) { + // Cairo doesn't play well with huge clips. When given a very big clip it + // will try to allocate big mask surface without taking the target + // size into account which can cause OOM. See bug 1034593. + // This limits the clip extents to the size of the canvas. + // A fix in Cairo would probably be preferable, but requires somewhat + // invasive changes. + mTarget->PushClipRect(gfx::Rect(0, 0, mWidth, mHeight)); + } + + for (const auto& style : mStyleStack) { + for (const auto& clipOrTransform : style.clipsAndTransforms) { + if (clipOrTransform.IsClip()) { + mTarget->PushClip(clipOrTransform.clip); + } else { + mTarget->SetTransform(clipOrTransform.transform); + } + } + } +} + +CanvasRenderingContext2D::RenderingMode +CanvasRenderingContext2D::EnsureTarget(const gfx::Rect* aCoveredRect, + RenderingMode aRenderingMode) +{ + if (AlreadyShutDown()) { + gfxCriticalError() << "Attempt to render into a Canvas2d after shutdown."; + SetErrorState(); + return aRenderingMode; + } + + // This would make no sense, so make sure we don't get ourselves in a mess + MOZ_ASSERT(mRenderingMode != RenderingMode::DefaultBackendMode); + + RenderingMode mode = (aRenderingMode == RenderingMode::DefaultBackendMode) ? mRenderingMode : aRenderingMode; + + if (mTarget && mode == mRenderingMode) { + return mRenderingMode; + } + + // Check that the dimensions are sane + if (mWidth > gfxPrefs::MaxCanvasSize() || + mHeight > gfxPrefs::MaxCanvasSize() || + mWidth < 0 || mHeight < 0) { + + SetErrorState(); + return aRenderingMode; + } + + // If the next drawing command covers the entire canvas, we can skip copying + // from the previous frame and/or clearing the canvas. + gfx::Rect canvasRect(0, 0, mWidth, mHeight); + bool canDiscardContent = aCoveredRect && + CurrentState().transform.TransformBounds(*aCoveredRect).Contains(canvasRect); + + // If a clip is active we don't know for sure that the next drawing command + // will really cover the entire canvas. + for (const auto& style : mStyleStack) { + if (!canDiscardContent) { + break; + } + for (const auto& clipOrTransform : style.clipsAndTransforms) { + if (clipOrTransform.IsClip()) { + canDiscardContent = false; + break; + } + } + } + + ScheduleStableStateCallback(); + + IntRect persistedRect = canDiscardContent ? IntRect() + : IntRect(0, 0, mWidth, mHeight); + + if (mBufferProvider && mode == mRenderingMode) { + mTarget = mBufferProvider->BorrowDrawTarget(persistedRect); + + if (mTarget && !mBufferProvider->PreservesDrawingState()) { + RestoreClipsAndTransformToTarget(); + } + + if (mTarget) { + return mode; + } + } + + RefPtr<DrawTarget> newTarget; + RefPtr<PersistentBufferProvider> newProvider; + + if (mode == RenderingMode::OpenGLBackendMode && + !TrySkiaGLTarget(newTarget, newProvider)) { + // Fall back to software. + mode = RenderingMode::SoftwareBackendMode; + } + + if (mode == RenderingMode::SoftwareBackendMode && + !TrySharedTarget(newTarget, newProvider) && + !TryBasicTarget(newTarget, newProvider)) { + SetErrorState(); + return mode; + } + + MOZ_ASSERT(newTarget); + MOZ_ASSERT(newProvider); + + mTarget = newTarget.forget(); + mBufferProvider = newProvider.forget(); + + RegisterAllocation(); + + // Skia expects the unused X channel to contains 0 even for opaque operations + // so we can't skip clearing in that case, even if we are going to cover the + // entire canvas in the next drawing operation. + if (!canDiscardContent || mTarget->GetBackendType() == gfx::BackendType::SKIA) { + mTarget->ClearRect(canvasRect); + } + + RestoreClipsAndTransformToTarget(); + + // 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(); + + return mode; +} + +void +CanvasRenderingContext2D::SetInitialState() +{ + // Set up the initial canvas defaults + mPathBuilder = nullptr; + mPath = nullptr; + mDSPathBuilder = nullptr; + mPathTransformWillUpdate = false; + + mStyleStack.Clear(); + 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); +} + +void +CanvasRenderingContext2D::SetErrorState() +{ + EnsureErrorTarget(); + + if (mTarget && mTarget != sErrorTarget) { + gCanvasAzureMemoryUsed -= mWidth * mHeight * 4; + } + + mTarget = sErrorTarget; + mBufferProvider = nullptr; + + // clear transforms, clips, etc. + SetInitialState(); +} + +void +CanvasRenderingContext2D::RegisterAllocation() +{ + // XXX - It would make more sense to track the allocation in + // PeristentBufferProvider, rather than here. + static bool registered = false; + // FIXME: Disable the reporter for now, see bug 1241865 + if (!registered && false) { + registered = true; + RegisterStrongMemoryReporter(new Canvas2dPixelsReporter()); + } + + gCanvasAzureMemoryUsed += mWidth * mHeight * 4; + JSContext* context = nsContentUtils::GetCurrentJSContext(); + if (context) { + JS_updateMallocCounter(context, mWidth * mHeight * 4); + } +} + +static already_AddRefed<LayerManager> +LayerManagerFromCanvasElement(nsINode* aCanvasElement) +{ + if (!aCanvasElement || !aCanvasElement->OwnerDoc()) { + return nullptr; + } + + return nsContentUtils::PersistentLayerManagerForDocument(aCanvasElement->OwnerDoc()); +} + +bool +CanvasRenderingContext2D::TrySkiaGLTarget(RefPtr<gfx::DrawTarget>& aOutDT, + RefPtr<layers::PersistentBufferProvider>& aOutProvider) +{ + aOutDT = nullptr; + aOutProvider = nullptr; + + mIsSkiaGL = false; + + IntSize size(mWidth, mHeight); + if (!AllowOpenGLCanvas() || !CheckSizeForSkiaGL(size)) { + return false; + } + + + RefPtr<LayerManager> layerManager = LayerManagerFromCanvasElement(mCanvasElement); + + if (!layerManager) { + return false; + } + + DemoteOldestContextIfNecessary(); + mBufferProvider = nullptr; + +#ifdef USE_SKIA_GPU + SkiaGLGlue* glue = gfxPlatform::GetPlatform()->GetSkiaGLGlue(); + if (!glue || !glue->GetGrContext() || !glue->GetGLContext()) { + return false; + } + + SurfaceFormat format = GetSurfaceFormat(); + aOutDT = Factory::CreateDrawTargetSkiaWithGrContext(glue->GetGrContext(), + size, format); + if (!aOutDT) { + gfxCriticalNote << "Failed to create a SkiaGL DrawTarget, falling back to software\n"; + return false; + } + + MOZ_ASSERT(aOutDT->GetType() == DrawTargetType::HARDWARE_RASTER); + + AddDemotableContext(this); + aOutProvider = new PersistentBufferProviderBasic(aOutDT); + mIsSkiaGL = true; + // Drop a note in the debug builds if we ever use accelerated Skia canvas. + gfxWarningOnce() << "Using SkiaGL canvas."; +#endif + + // could still be null if USE_SKIA_GPU is not #defined. + return !!aOutDT; +} + +bool +CanvasRenderingContext2D::TrySharedTarget(RefPtr<gfx::DrawTarget>& aOutDT, + RefPtr<layers::PersistentBufferProvider>& aOutProvider) +{ + aOutDT = nullptr; + aOutProvider = nullptr; + + if (!mCanvasElement || !mCanvasElement->OwnerDoc()) { + return false; + } + + RefPtr<LayerManager> layerManager = LayerManagerFromCanvasElement(mCanvasElement); + + if (!layerManager) { + return false; + } + + aOutProvider = layerManager->CreatePersistentBufferProvider(GetSize(), GetSurfaceFormat()); + + if (!aOutProvider) { + return false; + } + + // We can pass an empty persisted rect since we just created the buffer + // provider (nothing to restore). + aOutDT = aOutProvider->BorrowDrawTarget(IntRect()); + MOZ_ASSERT(aOutDT); + + return !!aOutDT; +} + +bool +CanvasRenderingContext2D::TryBasicTarget(RefPtr<gfx::DrawTarget>& aOutDT, + RefPtr<layers::PersistentBufferProvider>& aOutProvider) +{ + aOutDT = gfxPlatform::GetPlatform()->CreateOffscreenCanvasDrawTarget(GetSize(), + GetSurfaceFormat()); + if (!aOutDT) { + return false; + } + + aOutProvider = new PersistentBufferProviderBasic(aOutDT); + return true; +} + +int32_t +CanvasRenderingContext2D::GetWidth() const +{ + return mWidth; +} + +int32_t +CanvasRenderingContext2D::GetHeight() const +{ + return mHeight; +} + +NS_IMETHODIMP +CanvasRenderingContext2D::SetDimensions(int32_t aWidth, int32_t aHeight) +{ + ClearTarget(); + + // Zero sized surfaces can cause problems. + mZero = false; + if (aHeight == 0) { + aHeight = 1; + mZero = true; + } + if (aWidth == 0) { + aWidth = 1; + mZero = true; + } + mWidth = aWidth; + mHeight = aHeight; + + return NS_OK; +} + +void +CanvasRenderingContext2D::ClearTarget() +{ + Reset(); + + mResetLayer = true; + + SetInitialState(); + + // For vertical writing-mode, unless text-orientation is sideways, + // we'll modify the initial value of textBaseline to 'middle'. + RefPtr<nsStyleContext> canvasStyle; + if (mCanvasElement && mCanvasElement->IsInUncomposedDoc()) { + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + if (presShell) { + canvasStyle = + nsComputedDOMStyle::GetStyleContextForElement(mCanvasElement, + nullptr, + presShell); + if (canvasStyle) { + WritingMode wm(canvasStyle); + if (wm.IsVertical() && !wm.IsSideways()) { + CurrentState().textBaseline = TextBaseline::MIDDLE; + } + } + } + } +} + +void +CanvasRenderingContext2D::ReturnTarget(bool aForceReset) +{ + if (mTarget && mBufferProvider && mTarget != sErrorTarget) { + CurrentState().transform = mTarget->GetTransform(); + if (aForceReset || !mBufferProvider->PreservesDrawingState()) { + for (const auto& style : mStyleStack) { + for (const auto& clipOrTransform : style.clipsAndTransforms) { + if (clipOrTransform.IsClip()) { + mTarget->PopClip(); + } + } + } + + if (mTarget->GetBackendType() == gfx::BackendType::CAIRO) { + // With the cairo backend we pushed an extra clip rect which we have to + // balance out here. See the comment in RestoreClipsAndTransformToTarget. + mTarget->PopClip(); + } + + mTarget->SetTransform(Matrix()); + } + + mBufferProvider->ReturnDrawTarget(mTarget.forget()); + } +} + +NS_IMETHODIMP +CanvasRenderingContext2D::InitializeWithDrawTarget(nsIDocShell* aShell, + NotNull<gfx::DrawTarget*> aTarget) +{ + RemovePostRefreshObserver(); + mDocShell = aShell; + AddPostRefreshObserverIfNecessary(); + + IntSize size = aTarget->GetSize(); + SetDimensions(size.width, size.height); + + mTarget = aTarget; + mBufferProvider = new PersistentBufferProviderBasic(aTarget); + + if (mTarget->GetBackendType() == gfx::BackendType::CAIRO) { + // Cf comment in EnsureTarget + mTarget->PushClipRect(gfx::Rect(Point(0, 0), Size(mWidth, mHeight))); + } + + return NS_OK; +} + +NS_IMETHODIMP +CanvasRenderingContext2D::SetIsOpaque(bool aIsOpaque) +{ + if (aIsOpaque != mOpaque) { + mOpaque = aIsOpaque; + ClearTarget(); + } + + return NS_OK; +} + +NS_IMETHODIMP +CanvasRenderingContext2D::SetIsIPC(bool aIsIPC) +{ + if (aIsIPC != mIPC) { + mIPC = aIsIPC; + ClearTarget(); + } + + return NS_OK; +} + +NS_IMETHODIMP +CanvasRenderingContext2D::SetContextOptions(JSContext* aCx, + JS::Handle<JS::Value> aOptions, + ErrorResult& aRvForDictionaryInit) +{ + if (aOptions.isNullOrUndefined()) { + return NS_OK; + } + + // This shouldn't be called before drawing starts, so there should be no drawtarget yet + MOZ_ASSERT(!mTarget); + + ContextAttributes2D attributes; + if (!attributes.Init(aCx, aOptions)) { + aRvForDictionaryInit.Throw(NS_ERROR_UNEXPECTED); + return NS_ERROR_UNEXPECTED; + } + + if (Preferences::GetBool("gfx.canvas.willReadFrequently.enable", false)) { + // Use software when there is going to be a lot of readback + if (attributes.mWillReadFrequently) { + + // We want to lock into software, so remove the observer that + // may potentially change that... + RemoveDrawObserver(); + mRenderingMode = RenderingMode::SoftwareBackendMode; + } + } + + if (!attributes.mAlpha) { + SetIsOpaque(true); + } + + return NS_OK; +} + +UniquePtr<uint8_t[]> +CanvasRenderingContext2D::GetImageBuffer(int32_t* aFormat) +{ + UniquePtr<uint8_t[]> ret; + + *aFormat = 0; + + RefPtr<SourceSurface> snapshot; + if (mTarget) { + snapshot = mTarget->Snapshot(); + } else if (mBufferProvider) { + snapshot = mBufferProvider->BorrowSnapshot(); + } else { + EnsureTarget(); + if (!IsTargetValid()) { + return nullptr; + } + snapshot = mTarget->Snapshot(); + } + + if (snapshot) { + RefPtr<DataSourceSurface> data = snapshot->GetDataSurface(); + if (data && data->GetSize() == GetSize()) { + *aFormat = imgIEncoder::INPUT_FORMAT_HOSTARGB; + ret = SurfaceToPackedBGRA(data); + } + } + + if (!mTarget && mBufferProvider) { + mBufferProvider->ReturnSnapshot(snapshot.forget()); + } + + return ret; +} + +nsString CanvasRenderingContext2D::GetHitRegion(const mozilla::gfx::Point& aPoint) +{ + for (size_t x = 0 ; x < mHitRegionsOptions.Length(); x++) { + RegionInfo& info = mHitRegionsOptions[x]; + if (info.mPath->ContainsPoint(aPoint, Matrix())) { + return info.mId; + } + } + return nsString(); +} + +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; + } + + int32_t format = 0; + UniquePtr<uint8_t[]> imageBuffer = GetImageBuffer(&format); + if (!imageBuffer) { + return NS_ERROR_FAILURE; + } + + return ImageEncoder::GetInputStream(mWidth, mHeight, imageBuffer.get(), + format, encoder, aEncoderOptions, + aStream); +} + +SurfaceFormat +CanvasRenderingContext2D::GetSurfaceFormat() const +{ + return mOpaque ? SurfaceFormat::B8G8R8X8 : SurfaceFormat::B8G8R8A8; +} + +// +// state +// + +void +CanvasRenderingContext2D::Save() +{ + EnsureTarget(); + if (MOZ_UNLIKELY(!mTarget || mStyleStack.IsEmpty())) { + SetErrorState(); + return; + } + mStyleStack[mStyleStack.Length() - 1].transform = mTarget->GetTransform(); + mStyleStack.SetCapacity(mStyleStack.Length() + 1); + mStyleStack.AppendElement(CurrentState()); + + if (mStyleStack.Length() > MAX_STYLE_STACK_SIZE) { + // This is not fast, but is better than OOMing and shouldn't be hit by + // reasonable code. + mStyleStack.RemoveElementAt(0); + } +} + +void +CanvasRenderingContext2D::Restore() +{ + if (MOZ_UNLIKELY(mStyleStack.Length() < 2)) { + return; + } + + TransformWillUpdate(); + if (!IsTargetValid()) { + return; + } + + for (const auto& clipOrTransform : CurrentState().clipsAndTransforms) { + if (clipOrTransform.IsClip()) { + mTarget->PopClip(); + } + } + + mStyleStack.RemoveElementAt(mStyleStack.Length() - 1); + + mTarget->SetTransform(CurrentState().transform); +} + +// +// transformations +// + +void +CanvasRenderingContext2D::Scale(double aX, double aY, ErrorResult& aError) +{ + TransformWillUpdate(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newMatrix = mTarget->GetTransform(); + newMatrix.PreScale(aX, aY); + + SetTransformInternal(newMatrix); +} + +void +CanvasRenderingContext2D::Rotate(double aAngle, ErrorResult& aError) +{ + TransformWillUpdate(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newMatrix = Matrix::Rotation(aAngle) * mTarget->GetTransform(); + + SetTransformInternal(newMatrix); +} + +void +CanvasRenderingContext2D::Translate(double aX, double aY, ErrorResult& aError) +{ + TransformWillUpdate(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newMatrix = mTarget->GetTransform(); + newMatrix.PreTranslate(aX, aY); + + SetTransformInternal(newMatrix); +} + +void +CanvasRenderingContext2D::Transform(double aM11, double aM12, double aM21, + double aM22, double aDx, double aDy, + ErrorResult& aError) +{ + TransformWillUpdate(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newMatrix(aM11, aM12, aM21, aM22, aDx, aDy); + newMatrix *= mTarget->GetTransform(); + + SetTransformInternal(newMatrix); +} + +void +CanvasRenderingContext2D::SetTransform(double aM11, double aM12, + double aM21, double aM22, + double aDx, double aDy, + ErrorResult& aError) +{ + TransformWillUpdate(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + SetTransformInternal(Matrix(aM11, aM12, aM21, aM22, aDx, aDy)); +} + +void +CanvasRenderingContext2D::SetTransformInternal(const Matrix& aTransform) +{ + if (!aTransform.IsFinite()) { + return; + } + + // Save the transform in the clip stack to be able to replay clips properly. + auto& clipsAndTransforms = CurrentState().clipsAndTransforms; + if (clipsAndTransforms.IsEmpty() || clipsAndTransforms.LastElement().IsClip()) { + clipsAndTransforms.AppendElement(ClipState(aTransform)); + } else { + // If the last item is a transform we can replace it instead of appending + // a new item. + clipsAndTransforms.LastElement().transform = aTransform; + } + mTarget->SetTransform(aTransform); +} + +void +CanvasRenderingContext2D::ResetTransform(ErrorResult& aError) +{ + SetTransform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, aError); +} + +static void +MatrixToJSObject(JSContext* aCx, const Matrix& aMatrix, + JS::MutableHandle<JSObject*> aResult, ErrorResult& aError) +{ + double elts[6] = { aMatrix._11, aMatrix._12, + aMatrix._21, aMatrix._22, + aMatrix._31, aMatrix._32 }; + + // XXX Should we enter GetWrapper()'s compartment? + JS::Rooted<JS::Value> val(aCx); + if (!ToJSValue(aCx, elts, &val)) { + aError.Throw(NS_ERROR_OUT_OF_MEMORY); + } else { + aResult.set(&val.toObject()); + } +} + +static bool +ObjectToMatrix(JSContext* aCx, JS::Handle<JSObject*> aObj, Matrix& aMatrix, + ErrorResult& aError) +{ + uint32_t length; + if (!JS_GetArrayLength(aCx, aObj, &length) || length != 6) { + // Not an array-like thing or wrong size + aError.Throw(NS_ERROR_INVALID_ARG); + return false; + } + + Float* elts[] = { &aMatrix._11, &aMatrix._12, &aMatrix._21, &aMatrix._22, + &aMatrix._31, &aMatrix._32 }; + for (uint32_t i = 0; i < 6; ++i) { + JS::Rooted<JS::Value> elt(aCx); + double d; + if (!JS_GetElement(aCx, aObj, i, &elt)) { + aError.Throw(NS_ERROR_FAILURE); + return false; + } + if (!CoerceDouble(elt, &d)) { + aError.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* aCx, + JS::Handle<JSObject*> aCurrentTransform, + ErrorResult& aError) +{ + EnsureTarget(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newCTM; + if (ObjectToMatrix(aCx, aCurrentTransform, newCTM, aError) && newCTM.IsFinite()) { + mTarget->SetTransform(newCTM); + } +} + +void +CanvasRenderingContext2D::GetMozCurrentTransform(JSContext* aCx, + JS::MutableHandle<JSObject*> aResult, + ErrorResult& aError) +{ + EnsureTarget(); + + MatrixToJSObject(aCx, mTarget ? mTarget->GetTransform() : Matrix(), + aResult, aError); +} + +void +CanvasRenderingContext2D::SetMozCurrentTransformInverse(JSContext* aCx, + JS::Handle<JSObject*> aCurrentTransform, + ErrorResult& aError) +{ + EnsureTarget(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + Matrix newCTMInverse; + if (ObjectToMatrix(aCx, aCurrentTransform, newCTMInverse, aError)) { + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + if (newCTMInverse.Invert() && newCTMInverse.IsFinite()) { + mTarget->SetTransform(newCTMInverse); + } + } +} + +void +CanvasRenderingContext2D::GetMozCurrentTransformInverse(JSContext* aCx, + JS::MutableHandle<JSObject*> aResult, + ErrorResult& aError) +{ + EnsureTarget(); + + if (!mTarget) { + MatrixToJSObject(aCx, Matrix(), aResult, aError); + return; + } + + Matrix ctm = mTarget->GetTransform(); + + if (!ctm.Invert()) { + double NaN = JS_GetNaNValue(aCx).toDouble(); + ctm = Matrix(NaN, NaN, NaN, NaN, NaN, NaN); + } + + MatrixToJSObject(aCx, ctm, aResult, aError); +} + +// +// colors +// + +void +CanvasRenderingContext2D::SetStyleFromUnion(const StringOrCanvasGradientOrCanvasPattern& aValue, + Style aWhichStyle) +{ + if (aValue.IsString()) { + SetStyleFromString(aValue.GetAsString(), aWhichStyle); + return; + } + + if (aValue.IsCanvasGradient()) { + SetStyleFromGradient(aValue.GetAsCanvasGradient(), aWhichStyle); + return; + } + + if (aValue.IsCanvasPattern()) { + SetStyleFromPattern(aValue.GetAsCanvasPattern(), aWhichStyle); + return; + } + + MOZ_ASSERT_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 aX0, double aY0, double aX1, double aY1) +{ + RefPtr<CanvasGradient> grad = + new CanvasLinearGradient(this, Point(aX0, aY0), Point(aX1, aY1)); + + return grad.forget(); +} + +already_AddRefed<CanvasGradient> +CanvasRenderingContext2D::CreateRadialGradient(double aX0, double aY0, double aR0, + double aX1, double aY1, double aR1, + ErrorResult& aError) +{ + if (aR0 < 0.0 || aR1 < 0.0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return nullptr; + } + + RefPtr<CanvasGradient> grad = + new CanvasRadialGradient(this, Point(aX0, aY0), aR0, Point(aX1, aY1), aR1); + + return grad.forget(); +} + +already_AddRefed<CanvasPattern> +CanvasRenderingContext2D::CreatePattern(const CanvasImageSource& aSource, + const nsAString& aRepeat, + ErrorResult& aError) +{ + CanvasPattern::RepeatMode repeatMode = + CanvasPattern::RepeatMode::NOREPEAT; + + if (aRepeat.IsEmpty() || aRepeat.EqualsLiteral("repeat")) { + repeatMode = CanvasPattern::RepeatMode::REPEAT; + } else if (aRepeat.EqualsLiteral("repeat-x")) { + repeatMode = CanvasPattern::RepeatMode::REPEATX; + } else if (aRepeat.EqualsLiteral("repeat-y")) { + repeatMode = CanvasPattern::RepeatMode::REPEATY; + } else if (aRepeat.EqualsLiteral("no-repeat")) { + repeatMode = CanvasPattern::RepeatMode::NOREPEAT; + } else { + aError.Throw(NS_ERROR_DOM_SYNTAX_ERR); + return nullptr; + } + + Element* htmlElement; + if (aSource.IsHTMLCanvasElement()) { + HTMLCanvasElement* canvas = &aSource.GetAsHTMLCanvasElement(); + htmlElement = canvas; + + nsIntSize size = canvas->GetSize(); + if (size.width == 0 || size.height == 0) { + aError.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(); + if (!srcSurf) { + JSContext* context = nsContentUtils::GetCurrentJSContext(); + if (context) { + JS_ReportWarningASCII(context, + "CanvasRenderingContext2D.createPattern()" + " failed to snapshot source canvas."); + } + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + + RefPtr<CanvasPattern> pat = + new CanvasPattern(this, srcSurf, repeatMode, htmlElement->NodePrincipal(), canvas->IsWriteOnly(), false); + + return pat.forget(); + } + } else if (aSource.IsHTMLImageElement()) { + HTMLImageElement* img = &aSource.GetAsHTMLImageElement(); + if (img->IntrinsicState().HasState(NS_EVENT_STATE_BROKEN)) { + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + + htmlElement = img; + } else if (aSource.IsHTMLVideoElement()) { + auto& video = aSource.GetAsHTMLVideoElement(); + video.MarkAsContentSource(mozilla::dom::HTMLVideoElement::CallerAPI::CREATE_PATTERN); + htmlElement = &video; + } else { + // Special case for ImageBitmap + ImageBitmap& imgBitmap = aSource.GetAsImageBitmap(); + EnsureTarget(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + RefPtr<SourceSurface> srcSurf = imgBitmap.PrepareForDrawTarget(mTarget); + if (!srcSurf) { + JSContext* context = nsContentUtils::GetCurrentJSContext(); + if (context) { + JS_ReportWarningASCII(context, + "CanvasRenderingContext2D.createPattern()" + " failed to prepare source ImageBitmap."); + } + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + + // An ImageBitmap never taints others so we set principalForSecurityCheck to + // nullptr and set CORSUsed to true for passing the security check in + // CanvasUtils::DoDrawImageSecurityCheck(). + RefPtr<CanvasPattern> pat = + new CanvasPattern(this, srcSurf, repeatMode, nullptr, false, true); + + return pat.forget(); + } + + EnsureTarget(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return nullptr; + } + + // 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.GetSourceSurface()) { + return nullptr; + } + + RefPtr<CanvasPattern> pat = new CanvasPattern(this, res.GetSourceSurface(), repeatMode, + res.mPrincipal, res.mIsWriteOnly, + res.mCORSUsed); + return pat.forget(); +} + +// +// shadows +// +void +CanvasRenderingContext2D::SetShadowColor(const nsAString& aShadowColor) +{ + nscolor color; + if (!ParseColor(aShadowColor, &color)) { + return; + } + + CurrentState().shadowColor = color; +} + +// +// filters +// + +static already_AddRefed<Declaration> +CreateDeclaration(nsINode* aNode, + const nsCSSPropertyID aProp1, const nsAString& aValue1, bool* aChanged1, + const nsCSSPropertyID aProp2, const nsAString& aValue2, bool* aChanged2) +{ + 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()); + + RefPtr<Declaration> declaration = + parser.ParseStyleAttribute(EmptyString(), docURL, baseURL, principal); + + if (aProp1 != eCSSProperty_UNKNOWN) { + parser.ParseProperty(aProp1, aValue1, docURL, baseURL, principal, + declaration, aChanged1, false); + } + + if (aProp2 != eCSSProperty_UNKNOWN) { + parser.ParseProperty(aProp2, aValue2, docURL, baseURL, principal, + declaration, aChanged2, false); + } + + declaration->SetImmutable(); + return declaration.forget(); +} + +static already_AddRefed<Declaration> +CreateFontDeclaration(const nsAString& aFont, + nsINode* aNode, + bool* aOutFontChanged) +{ + bool lineHeightChanged; + return CreateDeclaration(aNode, + eCSSProperty_font, aFont, aOutFontChanged, + eCSSProperty_line_height, NS_LITERAL_STRING("normal"), &lineHeightChanged); +} + +static already_AddRefed<nsStyleContext> +GetFontParentStyleContext(Element* aElement, nsIPresShell* aPresShell, + ErrorResult& aError) +{ + if (aElement && aElement->IsInUncomposedDoc()) { + // Inherit from the canvas element. + RefPtr<nsStyleContext> result = + nsComputedDOMStyle::GetStyleContextForElement(aElement, nullptr, + aPresShell); + if (!result) { + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + return result.forget(); + } + + // otherwise inherit from default (10px sans-serif) + + nsStyleSet* styleSet = aPresShell->StyleSet()->GetAsGecko(); + if (!styleSet) { + // XXXheycam ServoStyleSets do not support resolving style from a list of + // rules yet. + NS_ERROR("stylo: cannot resolve style for canvas from a ServoStyleSet yet"); + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + bool changed; + RefPtr<css::Declaration> parentRule = + CreateFontDeclaration(NS_LITERAL_STRING("10px sans-serif"), + aPresShell->GetDocument(), &changed); + + nsTArray<nsCOMPtr<nsIStyleRule>> parentRules; + parentRules.AppendElement(parentRule); + RefPtr<nsStyleContext> result = + styleSet->ResolveStyleForRules(nullptr, parentRules); + + if (!result) { + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + return result.forget(); +} + +static bool +PropertyIsInheritOrInitial(Declaration* aDeclaration, const nsCSSPropertyID aProperty) +{ + // We know the declaration is not !important, so we can use + // GetNormalBlock(). + const nsCSSValue* filterVal = + aDeclaration->GetNormalBlock()->ValueFor(aProperty); + return (!filterVal || (filterVal->GetUnit() == eCSSUnit_Unset || + filterVal->GetUnit() == eCSSUnit_Inherit || + filterVal->GetUnit() == eCSSUnit_Initial)); +} + +static already_AddRefed<nsStyleContext> +GetFontStyleContext(Element* aElement, const nsAString& aFont, + nsIPresShell* aPresShell, + nsAString& aOutUsedFont, + ErrorResult& aError) +{ + nsStyleSet* styleSet = aPresShell->StyleSet()->GetAsGecko(); + if (!styleSet) { + // XXXheycam ServoStyleSets do not support resolving style from a list of + // rules yet. + NS_ERROR("stylo: cannot resolve style for canvas from a ServoStyleSet yet"); + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + bool fontParsedSuccessfully = false; + RefPtr<css::Declaration> decl = + CreateFontDeclaration(aFont, aPresShell->GetDocument(), + &fontParsedSuccessfully); + + if (!fontParsedSuccessfully) { + // We got a syntax error. The spec says this value must be ignored. + return nullptr; + } + + // In addition to unparseable values, the spec says we need to reject + // 'inherit' and 'initial'. The easiest way to check for this is to look + // at font-size-adjust, which the font shorthand resets to either 'none' or + // '-moz-system-font'. + if (PropertyIsInheritOrInitial(decl, eCSSProperty_font_size_adjust)) { + return nullptr; + } + + // have to get a parent style context for inherit-like relative + // values (2em, bolder, etc.) + RefPtr<nsStyleContext> parentContext = + GetFontParentStyleContext(aElement, aPresShell, aError); + + if (aError.Failed()) { + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + MOZ_RELEASE_ASSERT(parentContext, + "GFX: GetFontParentStyleContext should have returned an error if it couldn't get a parent context."); + + MOZ_ASSERT(!aPresShell->IsDestroying(), + "GetFontParentStyleContext should have returned an error if the presshell is being destroyed."); + + nsTArray<nsCOMPtr<nsIStyleRule>> rules; + rules.AppendElement(decl); + // add a rule to prevent text zoom from affecting the style + rules.AppendElement(new nsDisableTextZoomStyleRule); + + RefPtr<nsStyleContext> sc = + styleSet->ResolveStyleForRules(parentContext, rules); + + // 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.) + decl->GetPropertyValueByID(eCSSProperty_font, aOutUsedFont); + + return sc.forget(); +} + +static already_AddRefed<Declaration> +CreateFilterDeclaration(const nsAString& aFilter, + nsINode* aNode, + bool* aOutFilterChanged) +{ + bool dummy; + return CreateDeclaration(aNode, + eCSSProperty_filter, aFilter, aOutFilterChanged, + eCSSProperty_UNKNOWN, EmptyString(), &dummy); +} + +static already_AddRefed<nsStyleContext> +ResolveStyleForFilter(const nsAString& aFilterString, + nsIPresShell* aPresShell, + nsStyleContext* aParentContext, + ErrorResult& aError) +{ + nsStyleSet* styleSet = aPresShell->StyleSet()->GetAsGecko(); + if (!styleSet) { + // XXXheycam ServoStyleSets do not support resolving style from a list of + // rules yet. + NS_ERROR("stylo: cannot resolve style for canvas from a ServoStyleSet yet"); + aError.Throw(NS_ERROR_FAILURE); + return nullptr; + } + + nsIDocument* document = aPresShell->GetDocument(); + bool filterChanged = false; + RefPtr<css::Declaration> decl = + CreateFilterDeclaration(aFilterString, document, &filterChanged); + + if (!filterChanged) { + // Refuse to accept the filter, but do not throw an error. + return nullptr; + } + + // In addition to unparseable values, the spec says we need to reject + // 'inherit' and 'initial'. + if (PropertyIsInheritOrInitial(decl, eCSSProperty_filter)) { + return nullptr; + } + + nsTArray<nsCOMPtr<nsIStyleRule>> rules; + rules.AppendElement(decl); + + RefPtr<nsStyleContext> sc = + styleSet->ResolveStyleForRules(aParentContext, rules); + + return sc.forget(); +} + +bool +CanvasRenderingContext2D::ParseFilter(const nsAString& aString, + nsTArray<nsStyleFilter>& aFilterChain, + ErrorResult& aError) +{ + if (!mCanvasElement && !mDocShell) { + NS_WARNING("Canvas element must be non-null or a docshell must be provided"); + aError.Throw(NS_ERROR_FAILURE); + return false; + } + + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + if (!presShell) { + aError.Throw(NS_ERROR_FAILURE); + return false; + } + + nsString usedFont; + RefPtr<nsStyleContext> parentContext = + GetFontStyleContext(mCanvasElement, GetFont(), + presShell, usedFont, aError); + if (!parentContext) { + aError.Throw(NS_ERROR_FAILURE); + return false; + } + + RefPtr<nsStyleContext> sc = + ResolveStyleForFilter(aString, presShell, parentContext, aError); + + if (!sc) { + return false; + } + + aFilterChain = sc->StyleEffects()->mFilters; + return true; +} + +void +CanvasRenderingContext2D::SetFilter(const nsAString& aFilter, ErrorResult& aError) +{ + nsTArray<nsStyleFilter> filterChain; + if (ParseFilter(aFilter, filterChain, aError)) { + CurrentState().filterString = aFilter; + filterChain.SwapElements(CurrentState().filterChain); + if (mCanvasElement) { + CurrentState().filterChainObserver = + new CanvasFilterChainObserver(CurrentState().filterChain, + mCanvasElement, this); + UpdateFilter(); + } + } +} + +class CanvasUserSpaceMetrics : public UserSpaceMetricsWithSize +{ +public: + CanvasUserSpaceMetrics(const gfx::IntSize& aSize, const nsFont& aFont, + nsIAtom* aFontLanguage, bool aExplicitLanguage, + nsPresContext* aPresContext) + : mSize(aSize) + , mFont(aFont) + , mFontLanguage(aFontLanguage) + , mExplicitLanguage(aExplicitLanguage) + , mPresContext(aPresContext) + { + } + + virtual float GetEmLength() const override + { + return NSAppUnitsToFloatPixels(mFont.size, + nsPresContext::AppUnitsPerCSSPixel()); + } + + virtual float GetExLength() const override + { + nsDeviceContext* dc = mPresContext->DeviceContext(); + nsFontMetrics::Params params; + params.language = mFontLanguage; + params.explicitLanguage = mExplicitLanguage; + params.textPerf = mPresContext->GetTextPerfMetrics(); + RefPtr<nsFontMetrics> fontMetrics = dc->GetMetricsFor(mFont, params); + return NSAppUnitsToFloatPixels(fontMetrics->XHeight(), + nsPresContext::AppUnitsPerCSSPixel()); + } + + virtual gfx::Size GetSize() const override + { return Size(mSize); } + +private: + gfx::IntSize mSize; + const nsFont& mFont; + nsIAtom* mFontLanguage; + bool mExplicitLanguage; + nsPresContext* mPresContext; +}; + +void +CanvasRenderingContext2D::UpdateFilter() +{ + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + if (!presShell || presShell->IsDestroying()) { + // Ensure we set an empty filter and update the state to + // reflect the current "taint" status of the canvas + CurrentState().filter = FilterDescription(); + CurrentState().filterSourceGraphicTainted = + (mCanvasElement && mCanvasElement->IsWriteOnly()); + return; + } + + // The filter might reference an SVG filter that is declared inside this + // document. Flush frames so that we'll have an nsSVGFilterFrame to work + // with. + presShell->FlushPendingNotifications(Flush_Frames); + MOZ_RELEASE_ASSERT(!mStyleStack.IsEmpty()); + if (MOZ_UNLIKELY(presShell->IsDestroying())) { + return; + } + + bool sourceGraphicIsTainted = + (mCanvasElement && mCanvasElement->IsWriteOnly()); + + CurrentState().filter = + nsFilterInstance::GetFilterDescription(mCanvasElement, + CurrentState().filterChain, + sourceGraphicIsTainted, + CanvasUserSpaceMetrics(GetSize(), + CurrentState().fontFont, + CurrentState().fontLanguage, + CurrentState().fontExplicitLanguage, + presShell->GetPresContext()), + gfxRect(0, 0, mWidth, mHeight), + CurrentState().filterAdditionalImages); + CurrentState().filterSourceGraphicTainted = sourceGraphicIsTainted; +} + +// +// rects +// + +static bool +ValidateRect(double& aX, double& aY, double& aWidth, double& aHeight, bool aIsZeroSizeValid) +{ + if (!aIsZeroSizeValid && (aWidth == 0.0 || aHeight == 0.0)) { + return false; + } + + // bug 1018527 + // The values of canvas API input are in double precision, but Moz2D APIs are + // using float precision. Bypass canvas API calls when the input is out of + // float precision to avoid precision problem + if (!std::isfinite((float)aX) | !std::isfinite((float)aY) | + !std::isfinite((float)aWidth) | !std::isfinite((float)aHeight)) { + return false; + } + + // bug 1074733 + // The canvas spec does not forbid rects with negative w or h, so given + // corners (x, y), (x+w, y), (x+w, y+h), and (x, y+h) we must generate + // the appropriate rect by flipping negative dimensions. This prevents + // draw targets from receiving "empty" rects later on. + if (aWidth < 0) { + aWidth = -aWidth; + aX -= aWidth; + } + if (aHeight < 0) { + aHeight = -aHeight; + aY -= aHeight; + } + return true; +} + +void +CanvasRenderingContext2D::ClearRect(double aX, double aY, double aW, + double aH) +{ + // Do not allow zeros - it's a no-op at that point per spec. + if (!ValidateRect(aX, aY, aW, aH, false)) { + return; + } + + gfx::Rect clearRect(aX, aY, aW, aH); + + EnsureTarget(&clearRect); + if (!IsTargetValid()) { + return; + } + + mTarget->ClearRect(clearRect); + + RedrawUser(gfxRect(aX, aY, aW, aH)); +} + +void +CanvasRenderingContext2D::FillRect(double aX, double aY, double aW, double aH) +{ + if (!ValidateRect(aX, aY, aW, aH, true)) { + return; + } + + 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 (aX < 0) { + aW += aX; + if (aW < 0) { + aW = 0; + } + + aX = 0; + } + if (aX + aW > patternSize.width) { + aW = patternSize.width - aX; + if (aW < 0) { + aW = 0; + } + } + } + if (limity) { + if (aY < 0) { + aH += aY; + if (aH < 0) { + aH = 0; + } + + aY = 0; + } + if (aY + aH > patternSize.height) { + aH = patternSize.height - aY; + if (aH < 0) { + aH = 0; + } + } + } + } + state = nullptr; + + CompositionOp op = UsedOperation(); + bool discardContent = PatternIsOpaque(Style::FILL) + && (op == CompositionOp::OP_OVER || op == CompositionOp::OP_SOURCE); + const gfx::Rect fillRect(aX, aY, aW, aH); + EnsureTarget(discardContent ? &fillRect : nullptr); + if (!IsTargetValid()) { + return; + } + + gfx::Rect bounds; + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + if (needBounds) { + bounds = mTarget->GetTransform().TransformBounds(fillRect); + } + + AntialiasMode antialiasMode = CurrentState().imageSmoothingEnabled ? + AntialiasMode::DEFAULT : AntialiasMode::NONE; + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + target->FillRect(gfx::Rect(aX, aY, aW, aH), + CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget), + DrawOptions(CurrentState().globalAlpha, op, antialiasMode)); + + RedrawUser(gfxRect(aX, aY, aW, aH)); +} + +void +CanvasRenderingContext2D::StrokeRect(double aX, double aY, double aW, double aH) +{ + if (!aW && !aH) { + return; + } + + if (!ValidateRect(aX, aY, aW, aH, true)) { + return; + } + + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + + gfx::Rect bounds; + if (needBounds) { + const ContextState& state = CurrentState(); + bounds = gfx::Rect(aX - state.lineWidth / 2.0f, aY - state.lineWidth / 2.0f, + aW + state.lineWidth, aH + state.lineWidth); + bounds = mTarget->GetTransform().TransformBounds(bounds); + } + + auto op = UsedOperation(); + if (!IsTargetValid()) { + return; + } + + if (!aH) { + CapStyle cap = CapStyle::BUTT; + if (CurrentState().lineJoin == JoinStyle::ROUND) { + cap = CapStyle::ROUND; + } + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + const ContextState& state = CurrentState(); + target-> + StrokeLine(Point(aX, aY), Point(aX + aW, aY), + 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, op)); + return; + } + + if (!aW) { + CapStyle cap = CapStyle::BUTT; + if (CurrentState().lineJoin == JoinStyle::ROUND) { + cap = CapStyle::ROUND; + } + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + const ContextState& state = CurrentState(); + target-> + StrokeLine(Point(aX, aY), Point(aX, aY + aH), + 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, op)); + return; + } + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + const ContextState& state = CurrentState(); + target-> + StrokeRect(gfx::Rect(aX, aY, aW, aH), + 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, op)); + + Redraw(); +} + +// +// path bits +// + +void +CanvasRenderingContext2D::BeginPath() +{ + mPath = nullptr; + mPathBuilder = nullptr; + mDSPathBuilder = nullptr; + mPathTransformWillUpdate = false; +} + +void +CanvasRenderingContext2D::Fill(const CanvasWindingRule& aWinding) +{ + EnsureUserSpacePath(aWinding); + + if (!mPath) { + return; + } + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + gfx::Rect bounds; + if (needBounds) { + bounds = mPath->GetBounds(mTarget->GetTransform()); + } + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + auto op = UsedOperation(); + if (!IsTargetValid() || !target) { + return; + } + target->Fill(mPath, + CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget), + DrawOptions(CurrentState().globalAlpha, op)); + Redraw(); +} + +void CanvasRenderingContext2D::Fill(const CanvasPath& aPath, const CanvasWindingRule& aWinding) +{ + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + RefPtr<gfx::Path> gfxpath = aPath.GetPath(aWinding, mTarget); + if (!gfxpath) { + return; + } + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + gfx::Rect bounds; + if (needBounds) { + bounds = gfxpath->GetBounds(mTarget->GetTransform()); + } + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + auto op = UsedOperation(); + if (!IsTargetValid() || !target) { + return; + } + target->Fill(gfxpath, + CanvasGeneralPattern().ForStyle(this, Style::FILL, mTarget), + DrawOptions(CurrentState().globalAlpha, op)); + 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); + state = nullptr; + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + gfx::Rect bounds; + if (needBounds) { + bounds = + mPath->GetStrokedBounds(strokeOptions, mTarget->GetTransform()); + } + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + auto op = UsedOperation(); + if (!IsTargetValid() || !target) { + return; + } + target->Stroke(mPath, + CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget), + strokeOptions, DrawOptions(CurrentState().globalAlpha, op)); + Redraw(); +} + +void +CanvasRenderingContext2D::Stroke(const CanvasPath& aPath) +{ + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + RefPtr<gfx::Path> gfxpath = aPath.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); + state = nullptr; + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + gfx::Rect bounds; + if (needBounds) { + bounds = + gfxpath->GetStrokedBounds(strokeOptions, mTarget->GetTransform()); + } + + AdjustedTarget target(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!target) { + return; + } + + auto op = UsedOperation(); + if (!IsTargetValid() || !target) { + return; + } + target->Stroke(gfxpath, + CanvasGeneralPattern().ForStyle(this, Style::STROKE, mTarget), + strokeOptions, DrawOptions(CurrentState().globalAlpha, op)); + Redraw(); +} + +void CanvasRenderingContext2D::DrawFocusIfNeeded(mozilla::dom::Element& aElement, + ErrorResult& aRv) +{ + EnsureUserSpacePath(); + if (!mPath) { + return; + } + + if (DrawCustomFocusRing(aElement)) { + AutoSaveRestore asr(this); + + // 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; + state->dash.Clear(); + + // color and style of the rings is the same as for image maps + // set the background focus color + state->SetColorStyle(Style::STROKE, NS_RGBA(255, 255, 255, 255)); + state = nullptr; + + // draw the focus ring + Stroke(); + if (!mPath) { + return; + } + + // set dashing for foreground + nsTArray<mozilla::gfx::Float>& dash = CurrentState().dash; + for (uint32_t i = 0; i < 2; ++i) { + if (!dash.AppendElement(1, fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + } + + // set the foreground focus color + CurrentState().SetColorStyle(Style::STROKE, NS_RGBA(0,0,0, 255)); + // draw the focus ring + Stroke(); + if (!mPath) { + return; + } + } +} + +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)) { + if (nsPIDOMWindowOuter* window = aElement.OwnerDoc()->GetWindow()) { + return window->ShouldShowFocusRing(); + } + } + } + + return false; +} + +void +CanvasRenderingContext2D::Clip(const CanvasWindingRule& aWinding) +{ + EnsureUserSpacePath(aWinding); + + if (!mPath) { + return; + } + + mTarget->PushClip(mPath); + CurrentState().clipsAndTransforms.AppendElement(ClipState(mPath)); +} + +void +CanvasRenderingContext2D::Clip(const CanvasPath& aPath, const CanvasWindingRule& aWinding) +{ + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + RefPtr<gfx::Path> gfxpath = aPath.GetPath(aWinding, mTarget); + + if (!gfxpath) { + return; + } + + mTarget->PushClip(gfxpath); + CurrentState().clipsAndTransforms.AppendElement(ClipState(gfxpath)); +} + +void +CanvasRenderingContext2D::ArcTo(double aX1, double aY1, double aX2, + double aY2, double aRadius, + ErrorResult& aError) +{ + if (aRadius < 0) { + aError.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.TransformPoint(mDSPathBuilder->CurrentPoint()); + } + + Point p1(aX1, aY1); + Point p2(aX2, aY2); + + // 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 || aRadius == 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-aX1)*(p0.x-aX1) + (p0.y-aY1)*(p0.y-aY1); + b2 = (aX1-aX2)*(aX1-aX2) + (aY1-aY2)*(aY1-aY2); + c2 = (p0.x-aX2)*(p0.x-aX2) + (p0.y-aY2)*(p0.y-aY2); + cosx = (a2+b2-c2)/(2*sqrt(a2*b2)); + + sinx = sqrt(1 - cosx*cosx); + d = aRadius / ((1 - cosx) / sinx); + + anx = (aX1-p0.x) / sqrt(a2); + any = (aY1-p0.y) / sqrt(a2); + bnx = (aX1-aX2) / sqrt(b2); + bny = (aY1-aY2) / sqrt(b2); + x3 = aX1 - anx*d; + y3 = aY1 - any*d; + x4 = aX1 - bnx*d; + y4 = aY1 - bny*d; + anticlockwise = (dir < 0); + cx = x3 + any*aRadius*(anticlockwise ? 1 : -1); + cy = y3 - anx*aRadius*(anticlockwise ? 1 : -1); + angle0 = atan2((y3-cy), (x3-cx)); + angle1 = atan2((y4-cy), (x4-cx)); + + + LineTo(x3, y3); + + Arc(cx, cy, aRadius, angle0, angle1, anticlockwise, aError); +} + +void +CanvasRenderingContext2D::Arc(double aX, double aY, double aR, + double aStartAngle, double aEndAngle, + bool aAnticlockwise, ErrorResult& aError) +{ + if (aR < 0.0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + EnsureWritablePath(); + + ArcToBezier(this, Point(aX, aY), Size(aR, aR), aStartAngle, aEndAngle, aAnticlockwise); +} + +void +CanvasRenderingContext2D::Rect(double aX, double aY, double aW, double aH) +{ + EnsureWritablePath(); + + if (mPathBuilder) { + mPathBuilder->MoveTo(Point(aX, aY)); + mPathBuilder->LineTo(Point(aX + aW, aY)); + mPathBuilder->LineTo(Point(aX + aW, aY + aH)); + mPathBuilder->LineTo(Point(aX, aY + aH)); + mPathBuilder->Close(); + } else { + mDSPathBuilder->MoveTo(mTarget->GetTransform().TransformPoint(Point(aX, aY))); + mDSPathBuilder->LineTo(mTarget->GetTransform().TransformPoint(Point(aX + aW, aY))); + mDSPathBuilder->LineTo(mTarget->GetTransform().TransformPoint(Point(aX + aW, aY + aH))); + mDSPathBuilder->LineTo(mTarget->GetTransform().TransformPoint(Point(aX, aY + aH))); + mDSPathBuilder->Close(); + } +} + +void +CanvasRenderingContext2D::Ellipse(double aX, double aY, double aRadiusX, double aRadiusY, + double aRotation, double aStartAngle, double aEndAngle, + bool aAnticlockwise, ErrorResult& aError) +{ + if (aRadiusX < 0.0 || aRadiusY < 0.0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + EnsureWritablePath(); + + ArcToBezier(this, Point(aX, aY), Size(aRadiusX, aRadiusY), aStartAngle, aEndAngle, + aAnticlockwise, aRotation); +} + +void +CanvasRenderingContext2D::EnsureWritablePath() +{ + EnsureTarget(); + // NOTE: IsTargetValid() may be false here (mTarget == sErrorTarget) but we + // go ahead and create a path anyway since callers depend on that. + + 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; + } + + 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& aWinding) +{ + FillRule fillRule = CurrentState().fillRule; + if (aWinding == CanvasWindingRule::Evenodd) + fillRule = FillRule::FILL_EVEN_ODD; + + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + if (!mPath && !mPathBuilder && !mDSPathBuilder) { + 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(); + if (!IsTargetValid()) { + return; + } + + // 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 +// + +void +CanvasRenderingContext2D::SetFont(const nsAString& aFont, + ErrorResult& aError) +{ + SetFontInternal(aFont, aError); +} + +bool +CanvasRenderingContext2D::SetFontInternal(const nsAString& aFont, + ErrorResult& aError) +{ + /* + * 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"); + aError.Throw(NS_ERROR_FAILURE); + return false; + } + + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + if (!presShell) { + aError.Throw(NS_ERROR_FAILURE); + return false; + } + + nsString usedFont; + RefPtr<nsStyleContext> sc = + GetFontStyleContext(mCanvasElement, aFont, presShell, usedFont, aError); + if (!sc) { + return false; + } + + const nsStyleFont* fontStyle = sc->StyleFont(); + + nsPresContext* c = presShell->GetPresContext(); + + // 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"); + nsFont resizedFont(fontStyle->mFont); + // Create a font group working in units of CSS pixels instead of the usual + // device pixels, to avoid being affected by page zoom. nsFontMetrics will + // convert nsFont size in app units to device pixels for the font group, so + // here we first apply to the size the equivalent of a conversion from device + // pixels to CSS pixels, to adjust for the difference in expectations from + // other nsFontMetrics clients. + resizedFont.size = + (fontStyle->mSize * c->AppUnitsPerDevPixel()) / c->AppUnitsPerCSSPixel(); + + nsFontMetrics::Params params; + params.language = fontStyle->mLanguage; + params.explicitLanguage = fontStyle->mExplicitLanguage; + params.userFontSet = c->GetUserFontSet(); + params.textPerf = c->GetTextPerfMetrics(); + RefPtr<nsFontMetrics> metrics = + c->DeviceContext()->GetMetricsFor(resizedFont, params); + + gfxFontGroup* newFontGroup = metrics->GetThebesFontGroup(); + CurrentState().fontGroup = newFontGroup; + NS_ASSERTION(CurrentState().fontGroup, "Could not get font group"); + CurrentState().font = usedFont; + CurrentState().fontFont = fontStyle->mFont; + CurrentState().fontFont.size = fontStyle->mSize; + CurrentState().fontLanguage = fontStyle->mLanguage; + CurrentState().fontExplicitLanguage = fontStyle->mExplicitLanguage; + + return true; +} + +void +CanvasRenderingContext2D::SetTextAlign(const nsAString& aTextAlign) +{ + if (aTextAlign.EqualsLiteral("start")) + CurrentState().textAlign = TextAlign::START; + else if (aTextAlign.EqualsLiteral("end")) + CurrentState().textAlign = TextAlign::END; + else if (aTextAlign.EqualsLiteral("left")) + CurrentState().textAlign = TextAlign::LEFT; + else if (aTextAlign.EqualsLiteral("right")) + CurrentState().textAlign = TextAlign::RIGHT; + else if (aTextAlign.EqualsLiteral("center")) + CurrentState().textAlign = TextAlign::CENTER; +} + +void +CanvasRenderingContext2D::GetTextAlign(nsAString& aTextAlign) +{ + switch (CurrentState().textAlign) + { + case TextAlign::START: + aTextAlign.AssignLiteral("start"); + break; + case TextAlign::END: + aTextAlign.AssignLiteral("end"); + break; + case TextAlign::LEFT: + aTextAlign.AssignLiteral("left"); + break; + case TextAlign::RIGHT: + aTextAlign.AssignLiteral("right"); + break; + case TextAlign::CENTER: + aTextAlign.AssignLiteral("center"); + break; + } +} + +void +CanvasRenderingContext2D::SetTextBaseline(const nsAString& aTextBaseline) +{ + if (aTextBaseline.EqualsLiteral("top")) + CurrentState().textBaseline = TextBaseline::TOP; + else if (aTextBaseline.EqualsLiteral("hanging")) + CurrentState().textBaseline = TextBaseline::HANGING; + else if (aTextBaseline.EqualsLiteral("middle")) + CurrentState().textBaseline = TextBaseline::MIDDLE; + else if (aTextBaseline.EqualsLiteral("alphabetic")) + CurrentState().textBaseline = TextBaseline::ALPHABETIC; + else if (aTextBaseline.EqualsLiteral("ideographic")) + CurrentState().textBaseline = TextBaseline::IDEOGRAPHIC; + else if (aTextBaseline.EqualsLiteral("bottom")) + CurrentState().textBaseline = TextBaseline::BOTTOM; +} + +void +CanvasRenderingContext2D::GetTextBaseline(nsAString& aTextBaseline) +{ + switch (CurrentState().textBaseline) + { + case TextBaseline::TOP: + aTextBaseline.AssignLiteral("top"); + break; + case TextBaseline::HANGING: + aTextBaseline.AssignLiteral("hanging"); + break; + case TextBaseline::MIDDLE: + aTextBaseline.AssignLiteral("middle"); + break; + case TextBaseline::ALPHABETIC: + aTextBaseline.AssignLiteral("alphabetic"); + break; + case TextBaseline::IDEOGRAPHIC: + aTextBaseline.AssignLiteral("ideographic"); + break; + case TextBaseline::BOTTOM: + aTextBaseline.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& aStr) +{ + aStr.ReplaceChar("\x09\x0A\x0B\x0C\x0D", char16_t(' ')); +} + +void +CanvasRenderingContext2D::FillText(const nsAString& aText, double aX, + double aY, + const Optional<double>& aMaxWidth, + ErrorResult& aError) +{ + aError = DrawOrMeasureText(aText, aX, aY, aMaxWidth, TextDrawOperation::FILL, nullptr); +} + +void +CanvasRenderingContext2D::StrokeText(const nsAString& aText, double aX, + double aY, + const Optional<double>& aMaxWidth, + ErrorResult& aError) +{ + aError = DrawOrMeasureText(aText, aX, aY, aMaxWidth, TextDrawOperation::STROKE, nullptr); +} + +TextMetrics* +CanvasRenderingContext2D::MeasureText(const nsAString& aRawText, + ErrorResult& aError) +{ + float width; + Optional<double> maxWidth; + aError = DrawOrMeasureText(aRawText, 0, 0, maxWidth, TextDrawOperation::MEASURE, &width); + if (aError.Failed()) { + return nullptr; + } + + return new TextMetrics(width); +} + +void +CanvasRenderingContext2D::AddHitRegion(const HitRegionOptions& aOptions, ErrorResult& aError) +{ + RefPtr<gfx::Path> path; + if (aOptions.mPath) { + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + path = aOptions.mPath->GetPath(CanvasWindingRule::Nonzero, mTarget); + } + + if (!path) { + // check if the path is valid + EnsureUserSpacePath(CanvasWindingRule::Nonzero); + path = mPath; + } + + if (!path) { + aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); + return; + } + + // get the bounds of the current path. They are relative to the canvas + gfx::Rect bounds(path->GetBounds(mTarget->GetTransform())); + if ((bounds.width == 0) || (bounds.height == 0) || !bounds.IsFinite()) { + // The specified region has no pixels. + aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); + return; + } + + // remove old hit region first + RemoveHitRegion(aOptions.mId); + + if (aOptions.mControl) { + // also remove regions with this control + for (size_t x = 0; x < mHitRegionsOptions.Length(); x++) { + RegionInfo& info = mHitRegionsOptions[x]; + if (info.mElement == aOptions.mControl) { + mHitRegionsOptions.RemoveElementAt(x); + break; + } + } +#ifdef ACCESSIBILITY + aOptions.mControl->SetProperty(nsGkAtoms::hitregion, new bool(true), + nsINode::DeleteProperty<bool>); +#endif + } + + // finally, add the region to the list + RegionInfo info; + info.mId = aOptions.mId; + info.mElement = aOptions.mControl; + RefPtr<PathBuilder> pathBuilder = path->TransformedCopyToBuilder(mTarget->GetTransform()); + info.mPath = pathBuilder->Finish(); + + mHitRegionsOptions.InsertElementAt(0, info); +} + +void +CanvasRenderingContext2D::RemoveHitRegion(const nsAString& aId) +{ + if (aId.Length() == 0) { + return; + } + + for (size_t x = 0; x < mHitRegionsOptions.Length(); x++) { + RegionInfo& info = mHitRegionsOptions[x]; + if (info.mId == aId) { + mHitRegionsOptions.RemoveElementAt(x); + + return; + } + } +} + +void +CanvasRenderingContext2D::ClearHitRegions() +{ + mHitRegionsOptions.Clear(); +} + +bool +CanvasRenderingContext2D::GetHitRegionRect(Element* aElement, nsRect& aRect) +{ + for (unsigned int x = 0; x < mHitRegionsOptions.Length(); x++) { + RegionInfo& info = mHitRegionsOptions[x]; + if (info.mElement == aElement) { + gfx::Rect bounds(info.mPath->GetBounds()); + gfxRect rect(bounds.x, bounds.y, bounds.width, bounds.height); + aRect = nsLayoutUtils::RoundGfxRectToAppRect(rect, AppUnitsPerCSSPixel()); + + return true; + } + } + + return false; +} + +/** + * Used for nsBidiPresUtils::ProcessText + */ +struct MOZ_STACK_CLASS CanvasBidiProcessor : public nsBidiPresUtils::BidiProcessor +{ + typedef CanvasRenderingContext2D::Style Style; + + CanvasBidiProcessor() + : nsBidiPresUtils::BidiProcessor() + { + if (Preferences::GetBool(GFX_MISSING_FONTS_NOTIFY_PREF)) { + mMissingFonts = new gfxMissingFontRecorder(); + } + } + + ~CanvasBidiProcessor() + { + // notify front-end code if we encountered missing glyphs in any script + if (mMissingFonts) { + mMissingFonts->Flush(); + } + } + + typedef CanvasRenderingContext2D::ContextState ContextState; + + virtual void SetText(const char16_t* aText, int32_t aLength, nsBidiDirection aDirection) + { + mFontgrp->UpdateUserFonts(); // ensure user font generation is current + // adjust flags for current direction run + uint32_t flags = mTextRunFlags; + if (aDirection == NSBIDI_RTL) { + flags |= gfxTextRunFactory::TEXT_IS_RTL; + } else { + flags &= ~gfxTextRunFactory::TEXT_IS_RTL; + } + mTextRun = mFontgrp->MakeTextRun(aText, + aLength, + mDrawTarget, + mAppUnitsPerDevPixel, + flags, + mMissingFonts); + } + + virtual nscoord GetWidth() + { + gfxTextRun::Metrics textRunMetrics = mTextRun->MeasureText( + mDoMeasureBoundingBox ? gfxFont::TIGHT_INK_EXTENTS + : gfxFont::LOOSE_INK_EXTENTS, mDrawTarget); + + // 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); + } + + already_AddRefed<gfxPattern> GetGradientFor(Style aStyle) + { + RefPtr<gfxPattern> pattern; + CanvasGradient* gradient = mCtx->CurrentState().gradientStyles[aStyle]; + CanvasGradient::Type type = gradient->GetType(); + + switch (type) { + case CanvasGradient::Type::RADIAL: { + auto radial = static_cast<CanvasRadialGradient*>(gradient); + pattern = new gfxPattern(radial->mCenter1.x, radial->mCenter1.y, + radial->mRadius1, radial->mCenter2.x, + radial->mCenter2.y, radial->mRadius2); + break; + } + case CanvasGradient::Type::LINEAR: { + auto linear = static_cast<CanvasLinearGradient*>(gradient); + pattern = new gfxPattern(linear->mBegin.x, linear->mBegin.y, + linear->mEnd.x, linear->mEnd.y); + break; + } + default: + MOZ_ASSERT(false, "Should be linear or radial gradient."); + return nullptr; + } + + for (auto stop : gradient->mRawStops) { + pattern->AddColorStop(stop.offset, stop.color); + } + + return pattern.forget(); + } + + gfx::ExtendMode CvtCanvasRepeatToGfxRepeat( + CanvasPattern::RepeatMode aRepeatMode) + { + switch (aRepeatMode) { + case CanvasPattern::RepeatMode::REPEAT: + return gfx::ExtendMode::REPEAT; + case CanvasPattern::RepeatMode::REPEATX: + return gfx::ExtendMode::REPEAT_X; + case CanvasPattern::RepeatMode::REPEATY: + return gfx::ExtendMode::REPEAT_Y; + case CanvasPattern::RepeatMode::NOREPEAT: + return gfx::ExtendMode::CLAMP; + default: + return gfx::ExtendMode::CLAMP; + } + } + + already_AddRefed<gfxPattern> GetPatternFor(Style aStyle) + { + const CanvasPattern* pat = mCtx->CurrentState().patternStyles[aStyle]; + RefPtr<gfxPattern> pattern = new gfxPattern(pat->mSurface, Matrix()); + pattern->SetExtend(CvtCanvasRepeatToGfxRepeat(pat->mRepeat)); + return pattern.forget(); + } + + virtual void DrawText(nscoord aXOffset, nscoord aWidth) + { + gfxPoint point = mPt; + bool rtl = mTextRun->IsRightToLeft(); + bool verticalRun = mTextRun->IsVertical(); + RefPtr<gfxPattern> pattern; + + gfxFloat& inlineCoord = verticalRun ? point.y : point.x; + inlineCoord += aXOffset; + + // offset is given in terms of left side of string + if (rtl) { + // 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(mDoMeasureBoundingBox ? + gfxFont::TIGHT_INK_EXTENTS : + gfxFont::LOOSE_INK_EXTENTS, + mDrawTarget); + inlineCoord += textRunMetrics.mAdvanceWidth; + // old code was: + // point.x += width * mAppUnitsPerDevPixel; + // TODO: restore this if/when we move to fractional coords + // throughout the text layout process + } + + mCtx->EnsureTarget(); + if (!mCtx->IsTargetValid()) { + return; + } + + // Defer the tasks to gfxTextRun which will handle color/svg-in-ot fonts + // appropriately. + StrokeOptions strokeOpts; + DrawOptions drawOpts; + Style style = (mOp == CanvasRenderingContext2D::TextDrawOperation::FILL) + ? Style::FILL + : Style::STROKE; + + AdjustedTarget target(mCtx); + if (!target) { + return; + } + + RefPtr<gfxContext> thebes = + gfxContext::CreatePreservingTransformOrNull(target); + if (!thebes) { + // If CreatePreservingTransformOrNull returns null, it will also have + // issued a gfxCriticalNote already, so here we'll just bail out. + return; + } + gfxTextRun::DrawParams params(thebes); + + const ContextState* state = &mCtx->CurrentState(); + if (state->StyleIsColor(style)) { // Color + nscolor fontColor = state->colorStyles[style]; + if (style == Style::FILL) { + params.context->SetColor(Color::FromABGR(fontColor)); + } else { + params.textStrokeColor = fontColor; + } + } else { + if (state->gradientStyles[style]) { // Gradient + pattern = GetGradientFor(style); + } else if (state->patternStyles[style]) { // Pattern + pattern = GetPatternFor(style); + } else { + MOZ_ASSERT(false, "Should never reach here."); + return; + } + MOZ_ASSERT(pattern, "No valid pattern."); + + if (style == Style::FILL) { + params.context->SetPattern(pattern); + } else { + params.textStrokePattern = pattern; + } + } + + drawOpts.mAlpha = state->globalAlpha; + drawOpts.mCompositionOp = mCtx->UsedOperation(); + if (!mCtx->IsTargetValid()) { + return; + } + state = &mCtx->CurrentState(); + params.drawOpts = &drawOpts; + + if (style == Style::STROKE) { + strokeOpts.mLineWidth = state->lineWidth; + strokeOpts.mLineJoin = state->lineJoin; + strokeOpts.mLineCap = state->lineCap; + strokeOpts.mMiterLimit = state->miterLimit; + strokeOpts.mDashLength = state->dash.Length(); + strokeOpts.mDashPattern = + (strokeOpts.mDashLength > 0) ? state->dash.Elements() : 0; + strokeOpts.mDashOffset = state->dashOffset; + + params.drawMode = DrawMode::GLYPH_STROKE; + params.strokeOpts = &strokeOpts; + } + + mTextRun->Draw(gfxTextRun::Range(mTextRun.get()), point, params); + } + + // current text run + RefPtr<gfxTextRun> mTextRun; + + // pointer to a screen reference context used to measure text and such + RefPtr<DrawTarget> mDrawTarget; + + // Pointer to the draw target we should fill our text to + CanvasRenderingContext2D* mCtx; + + // position of the left side of the string, alphabetic baseline + gfxPoint mPt; + + // current font + gfxFontGroup* mFontgrp; + + // to record any unsupported characters found in the text, + // and notify front-end if it is interested + nsAutoPtr<gfxMissingFontRecorder> mMissingFonts; + + // dev pixel conversion factor + int32_t mAppUnitsPerDevPixel; + + // operation (fill or stroke) + CanvasRenderingContext2D::TextDrawOperation mOp; + + // union of bounding boxes of all runs, needed for shadows + gfxRect mBoundingBox; + + // flags to use when creating textrun, based on CSS style + uint32_t mTextRunFlags; + + // true iff the bounding box should be measured + bool mDoMeasureBoundingBox; +}; + +nsresult +CanvasRenderingContext2D::DrawOrMeasureText(const nsAString& aRawText, + float aX, + float aY, + const Optional<double>& aMaxWidth, + TextDrawOperation aOp, + float* aWidth) +{ + nsresult rv; + + if (!mCanvasElement && !mDocShell) { + NS_WARNING("Canvas element must be non-null or a docshell must be provided"); + return NS_ERROR_FAILURE; + } + + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + if (!presShell) + return NS_ERROR_FAILURE; + + nsIDocument* document = presShell->GetDocument(); + + // replace all the whitespace characters with U+0020 SPACE + nsAutoString textToDraw(aRawText); + TextReplaceWhitespaceCharacters(textToDraw); + + // According to spec, the API should return an empty array if maxWidth was provided + // but is less than or equal to zero or equal to NaN. + if (aMaxWidth.WasPassed() && (aMaxWidth.Value() <= 0 || IsNaN(aMaxWidth.Value()))) { + textToDraw.Truncate(); + } + + // for now, default to ltr if not in doc + bool isRTL = false; + + RefPtr<nsStyleContext> canvasStyle; + if (mCanvasElement && mCanvasElement->IsInUncomposedDoc()) { + // try to find the closest context + canvasStyle = + nsComputedDOMStyle::GetStyleContextForElement(mCanvasElement, + nullptr, + presShell); + if (!canvasStyle) { + return NS_ERROR_FAILURE; + } + + isRTL = canvasStyle->StyleVisibility()->mDirection == + NS_STYLE_DIRECTION_RTL; + } else { + isRTL = GET_BIDI_OPTION_DIRECTION(document->GetBidiOptions()) == IBMBIDI_TEXTDIRECTION_RTL; + } + + // This is only needed to know if we can know the drawing bounding box easily. + const bool doCalculateBounds = NeedToCalculateBounds(); + if (presShell->IsDestroying()) { + return NS_ERROR_FAILURE; + } + + gfxFontGroup* currentFontStyle = GetCurrentFontStyle(); + if (!currentFontStyle) { + return NS_ERROR_FAILURE; + } + + MOZ_ASSERT(!presShell->IsDestroying(), + "GetCurrentFontStyle() should have returned null if the presshell is being destroyed"); + + // ensure user font set is up to date + currentFontStyle-> + SetUserFontSet(presShell->GetPresContext()->GetUserFontSet()); + + if (currentFontStyle->GetStyle()->size == 0.0F) { + if (aWidth) { + *aWidth = 0; + } + return NS_OK; + } + + if (!IsFinite(aX) || !IsFinite(aY)) { + return NS_OK; + } + + CanvasBidiProcessor processor; + + // If we don't have a style context, we can't set up vertical-text flags + // (for now, at least; perhaps we need new Canvas API to control this). + processor.mTextRunFlags = canvasStyle ? + nsLayoutUtils::GetTextRunFlagsForStyle(canvasStyle, + canvasStyle->StyleFont(), + canvasStyle->StyleText(), + 0) : 0; + + GetAppUnitsValues(&processor.mAppUnitsPerDevPixel, nullptr); + processor.mPt = gfxPoint(aX, aY); + processor.mDrawTarget = + gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget(); + + // If we don't have a target then we don't have a transform. A target won't + // be needed in the case where we're measuring the text size. This allows + // to avoid creating a target if it's only being used to measure text sizes. + if (mTarget) { + processor.mDrawTarget->SetTransform(mTarget->GetTransform()); + } + processor.mCtx = this; + processor.mOp = aOp; + processor.mBoundingBox = gfxRect(0, 0, 0, 0); + processor.mDoMeasureBoundingBox = doCalculateBounds || !mIsEntireFrameInvalid; + processor.mFontgrp = currentFontStyle; + + nscoord totalWidthCoord; + + // calls bidi algo twice since it needs the full text width and the + // bounding boxes before rendering anything + nsBidi bidiEngine; + rv = nsBidiPresUtils::ProcessText(textToDraw.get(), + textToDraw.Length(), + isRTL ? NSBIDI_RTL : NSBIDI_LTR, + presShell->GetPresContext(), + processor, + nsBidiPresUtils::MODE_MEASURE, + nullptr, + 0, + &totalWidthCoord, + &bidiEngine); + if (NS_FAILED(rv)) { + return rv; + } + + float totalWidth = float(totalWidthCoord) / processor.mAppUnitsPerDevPixel; + if (aWidth) { + *aWidth = totalWidth; + } + + // if only measuring, don't need to do any more work + if (aOp==TextDrawOperation::MEASURE) { + return NS_OK; + } + + // offset pt.x based on text align + gfxFloat anchorX; + + const ContextState& state = CurrentState(); + if (state.textAlign == TextAlign::CENTER) { + anchorX = .5; + } else if (state.textAlign == TextAlign::LEFT || + (!isRTL && state.textAlign == TextAlign::START) || + (isRTL && state.textAlign == TextAlign::END)) { + anchorX = 0; + } else { + anchorX = 1; + } + + processor.mPt.x -= anchorX * totalWidth; + + // offset pt.y (or pt.x, for vertical text) based on text baseline + processor.mFontgrp->UpdateUserFonts(); // ensure user font generation is current + const gfxFont::Metrics& fontMetrics = + processor.mFontgrp->GetFirstValidFont()->GetMetrics(gfxFont::eHorizontal); + + gfxFloat baselineAnchor; + + switch (state.textBaseline) + { + case TextBaseline::HANGING: + // fall through; best we can do with the information available + case TextBaseline::TOP: + baselineAnchor = fontMetrics.emAscent; + break; + case TextBaseline::MIDDLE: + baselineAnchor = (fontMetrics.emAscent - fontMetrics.emDescent) * .5f; + break; + case TextBaseline::IDEOGRAPHIC: + // fall through; best we can do with the information available + case TextBaseline::ALPHABETIC: + baselineAnchor = 0; + break; + case TextBaseline::BOTTOM: + baselineAnchor = -fontMetrics.emDescent; + break; + default: + MOZ_CRASH("GFX: unexpected TextBaseline"); + } + + // We can't query the textRun directly, as it may not have been created yet; + // so instead we check the flags that will be used to initialize it. + uint16_t runOrientation = + (processor.mTextRunFlags & gfxTextRunFactory::TEXT_ORIENT_MASK); + if (runOrientation != gfxTextRunFactory::TEXT_ORIENT_HORIZONTAL) { + if (runOrientation == gfxTextRunFactory::TEXT_ORIENT_VERTICAL_MIXED || + runOrientation == gfxTextRunFactory::TEXT_ORIENT_VERTICAL_UPRIGHT) { + // Adjust to account for mTextRun being shaped using center baseline + // rather than alphabetic. + baselineAnchor -= (fontMetrics.emAscent - fontMetrics.emDescent) * .5f; + } + processor.mPt.x -= baselineAnchor; + } else { + processor.mPt.y += baselineAnchor; + } + + // correct bounding box to get it to be the correct size/position + processor.mBoundingBox.width = totalWidth; + processor.mBoundingBox.MoveBy(processor.mPt); + + processor.mPt.x *= processor.mAppUnitsPerDevPixel; + processor.mPt.y *= processor.mAppUnitsPerDevPixel; + + EnsureTarget(); + if (!IsTargetValid()) { + return NS_ERROR_FAILURE; + } + + Matrix oldTransform = mTarget->GetTransform(); + // if text is over aMaxWidth, then scale the text horizontally such that its + // width is precisely aMaxWidth + if (aMaxWidth.WasPassed() && aMaxWidth.Value() > 0 && + totalWidth > aMaxWidth.Value()) { + Matrix newTransform = oldTransform; + + // Translate so that the anchor point is at 0,0, then scale and then + // translate back. + newTransform.PreTranslate(aX, 0); + newTransform.PreScale(aMaxWidth.Value() / totalWidth, 1); + newTransform.PreTranslate(-aX, 0); + /* we do this to avoid an ICE in the android compiler */ + Matrix androidCompilerBug = newTransform; + mTarget->SetTransform(androidCompilerBug); + } + + // save the previous bounding box + gfxRect boundingBox = processor.mBoundingBox; + + // don't ever need to measure the bounding box twice + processor.mDoMeasureBoundingBox = false; + + rv = nsBidiPresUtils::ProcessText(textToDraw.get(), + textToDraw.Length(), + isRTL ? NSBIDI_RTL : NSBIDI_LTR, + presShell->GetPresContext(), + processor, + nsBidiPresUtils::MODE_DRAW, + nullptr, + 0, + nullptr, + &bidiEngine); + + + mTarget->SetTransform(oldTransform); + + if (aOp == CanvasRenderingContext2D::TextDrawOperation::FILL && + !doCalculateBounds) { + RedrawUser(boundingBox); + return NS_OK; + } + + Redraw(); + return NS_OK; +} + +gfxFontGroup* +CanvasRenderingContext2D::GetCurrentFontStyle() +{ + // use lazy initilization for the font group since it's rather expensive + if (!CurrentState().fontGroup) { + ErrorResult err; + NS_NAMED_LITERAL_STRING(kDefaultFontStyle, "10px sans-serif"); + static float kDefaultFontSize = 10.0; + nsCOMPtr<nsIPresShell> presShell = GetPresShell(); + bool fontUpdated = SetFontInternal(kDefaultFontStyle, err); + if (err.Failed() || !fontUpdated) { + err.SuppressException(); + gfxFontStyle style; + style.size = kDefaultFontSize; + gfxTextPerfMetrics* tp = nullptr; + if (presShell && !presShell->IsDestroying()) { + tp = presShell->GetPresContext()->GetTextPerfMetrics(); + } + int32_t perDevPixel, perCSSPixel; + GetAppUnitsValues(&perDevPixel, &perCSSPixel); + gfxFloat devToCssSize = gfxFloat(perDevPixel) / gfxFloat(perCSSPixel); + CurrentState().fontGroup = + gfxPlatform::GetPlatform()->CreateFontGroup(FontFamilyList(eFamily_sans_serif), + &style, tp, + nullptr, devToCssSize); + if (CurrentState().fontGroup) { + CurrentState().font = kDefaultFontStyle; + } else { + NS_ERROR("Default canvas font is invalid"); + } + } + } + + return CurrentState().fontGroup; +} + +// +// line caps/joins +// + +void +CanvasRenderingContext2D::SetLineCap(const nsAString& aLinecapStyle) +{ + CapStyle cap; + + if (aLinecapStyle.EqualsLiteral("butt")) { + cap = CapStyle::BUTT; + } else if (aLinecapStyle.EqualsLiteral("round")) { + cap = CapStyle::ROUND; + } else if (aLinecapStyle.EqualsLiteral("square")) { + cap = CapStyle::SQUARE; + } else { + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + return; + } + + CurrentState().lineCap = cap; +} + +void +CanvasRenderingContext2D::GetLineCap(nsAString& aLinecapStyle) +{ + switch (CurrentState().lineCap) { + case CapStyle::BUTT: + aLinecapStyle.AssignLiteral("butt"); + break; + case CapStyle::ROUND: + aLinecapStyle.AssignLiteral("round"); + break; + case CapStyle::SQUARE: + aLinecapStyle.AssignLiteral("square"); + break; + } +} + +void +CanvasRenderingContext2D::SetLineJoin(const nsAString& aLinejoinStyle) +{ + JoinStyle j; + + if (aLinejoinStyle.EqualsLiteral("round")) { + j = JoinStyle::ROUND; + } else if (aLinejoinStyle.EqualsLiteral("bevel")) { + j = JoinStyle::BEVEL; + } else if (aLinejoinStyle.EqualsLiteral("miter")) { + j = JoinStyle::MITER_OR_BEVEL; + } else { + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + return; + } + + CurrentState().lineJoin = j; +} + +void +CanvasRenderingContext2D::GetLineJoin(nsAString& aLinejoinStyle, ErrorResult& aError) +{ + switch (CurrentState().lineJoin) { + case JoinStyle::ROUND: + aLinejoinStyle.AssignLiteral("round"); + break; + case JoinStyle::BEVEL: + aLinejoinStyle.AssignLiteral("bevel"); + break; + case JoinStyle::MITER_OR_BEVEL: + aLinejoinStyle.AssignLiteral("miter"); + break; + default: + aError.Throw(NS_ERROR_FAILURE); + } +} + +void +CanvasRenderingContext2D::SetLineDash(const Sequence<double>& aSegments, + ErrorResult& aRv) +{ + nsTArray<mozilla::gfx::Float> dash; + + for (uint32_t x = 0; x < aSegments.Length(); x++) { + if (aSegments[x] < 0.0) { + // Pattern elements must be finite "numbers" >= 0, with "finite" + // taken care of by WebIDL + return; + } + + if (!dash.AppendElement(aSegments[x], fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + } + if (aSegments.Length() % 2) { // If the number of elements is odd, concatenate again + for (uint32_t x = 0; x < aSegments.Length(); x++) { + if (!dash.AppendElement(aSegments[x], fallible)) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return; + } + } + } + + CurrentState().dash = Move(dash); +} + +void +CanvasRenderingContext2D::GetLineDash(nsTArray<double>& aSegments) const { + const nsTArray<mozilla::gfx::Float>& dash = CurrentState().dash; + aSegments.Clear(); + + for (uint32_t x = 0; x < dash.Length(); x++) { + aSegments.AppendElement(dash[x]); + } +} + +void +CanvasRenderingContext2D::SetLineDashOffset(double aOffset) { + CurrentState().dashOffset = aOffset; +} + +double +CanvasRenderingContext2D::LineDashOffset() const { + return CurrentState().dashOffset; +} + +bool +CanvasRenderingContext2D::IsPointInPath(double aX, double aY, const CanvasWindingRule& aWinding) +{ + if (!FloatValidate(aX, aY)) { + return false; + } + + EnsureUserSpacePath(aWinding); + if (!mPath) { + return false; + } + + if (mPathTransformWillUpdate) { + return mPath->ContainsPoint(Point(aX, aY), mPathToDS); + } + + return mPath->ContainsPoint(Point(aX, aY), mTarget->GetTransform()); +} + +bool CanvasRenderingContext2D::IsPointInPath(const CanvasPath& aPath, double aX, double aY, const CanvasWindingRule& aWinding) +{ + if (!FloatValidate(aX, aY)) { + return false; + } + + EnsureTarget(); + if (!IsTargetValid()) { + return false; + } + + RefPtr<gfx::Path> tempPath = aPath.GetPath(aWinding, mTarget); + + return tempPath->ContainsPoint(Point(aX, aY), mTarget->GetTransform()); +} + +bool +CanvasRenderingContext2D::IsPointInStroke(double aX, double aY) +{ + if (!FloatValidate(aX, aY)) { + return false; + } + + EnsureUserSpacePath(); + if (!mPath) { + return false; + } + + const ContextState &state = CurrentState(); + + StrokeOptions strokeOptions(state.lineWidth, + state.lineJoin, + state.lineCap, + state.miterLimit, + state.dash.Length(), + state.dash.Elements(), + state.dashOffset); + + if (mPathTransformWillUpdate) { + return mPath->StrokeContainsPoint(strokeOptions, Point(aX, aY), mPathToDS); + } + return mPath->StrokeContainsPoint(strokeOptions, Point(aX, aY), mTarget->GetTransform()); +} + +bool CanvasRenderingContext2D::IsPointInStroke(const CanvasPath& aPath, double aX, double aY) +{ + if (!FloatValidate(aX, aY)) { + return false; + } + + EnsureTarget(); + if (!IsTargetValid()) { + return false; + } + + RefPtr<gfx::Path> tempPath = aPath.GetPath(CanvasWindingRule::Nonzero, mTarget); + + const ContextState &state = CurrentState(); + + StrokeOptions strokeOptions(state.lineWidth, + state.lineJoin, + state.lineCap, + state.miterLimit, + state.dash.Length(), + state.dash.Elements(), + state.dashOffset); + + return tempPath->StrokeContainsPoint(strokeOptions, Point(aX, aY), mTarget->GetTransform()); +} + +// Returns a surface that contains only the part needed to draw aSourceRect. +// On entry, aSourceRect is relative to aSurface, and on return aSourceRect is +// relative to the returned surface. +static already_AddRefed<SourceSurface> +ExtractSubrect(SourceSurface* aSurface, gfx::Rect* aSourceRect, DrawTarget* aTargetDT) +{ + gfx::Rect roundedOutSourceRect = *aSourceRect; + roundedOutSourceRect.RoundOut(); + gfx::IntRect roundedOutSourceRectInt; + if (!roundedOutSourceRect.ToIntRect(&roundedOutSourceRectInt)) { + RefPtr<SourceSurface> surface(aSurface); + return surface.forget(); + } + + RefPtr<DrawTarget> subrectDT = + aTargetDT->CreateSimilarDrawTarget(roundedOutSourceRectInt.Size(), SurfaceFormat::B8G8R8A8); + + if (!subrectDT) { + RefPtr<SourceSurface> surface(aSurface); + return surface.forget(); + } + + *aSourceRect -= roundedOutSourceRect.TopLeft(); + + subrectDT->CopySurface(aSurface, roundedOutSourceRectInt, IntPoint()); + return subrectDT->Snapshot(); +} + +// +// image +// + +static void +ClipImageDimension(double& aSourceCoord, double& aSourceSize, int32_t aImageSize, + double& aDestCoord, double& aDestSize) +{ + double scale = aDestSize / aSourceSize; + if (aSourceCoord < 0.0) { + double destEnd = aDestCoord + aDestSize; + aDestCoord -= aSourceCoord * scale; + aDestSize = destEnd - aDestCoord; + aSourceSize += aSourceCoord; + aSourceCoord = 0.0; + } + double delta = aImageSize - (aSourceCoord + aSourceSize); + if (delta < 0.0) { + aDestSize += delta * scale; + aSourceSize = aImageSize - aSourceCoord; + } +} + +// Acts like nsLayoutUtils::SurfaceFromElement, but it'll attempt +// to pull a SourceSurface from our cache. This allows us to avoid +// reoptimizing surfaces if content and canvas backends are different. +nsLayoutUtils::SurfaceFromElementResult +CanvasRenderingContext2D::CachedSurfaceFromElement(Element* aElement) +{ + nsLayoutUtils::SurfaceFromElementResult res; + nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(aElement); + if (!imageLoader) { + return res; + } + + nsCOMPtr<imgIRequest> imgRequest; + imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST, + getter_AddRefs(imgRequest)); + if (!imgRequest) { + return res; + } + + uint32_t status = 0; + if (NS_FAILED(imgRequest->GetImageStatus(&status)) || + !(status & imgIRequest::STATUS_LOAD_COMPLETE)) { + return res; + } + + nsCOMPtr<nsIPrincipal> principal; + if (NS_FAILED(imgRequest->GetImagePrincipal(getter_AddRefs(principal))) || + !principal) { + return res; + } + + res.mSourceSurface = + CanvasImageCache::LookupAllCanvas(aElement, mIsSkiaGL); + if (!res.mSourceSurface) { + return res; + } + + int32_t corsmode = imgIRequest::CORS_NONE; + if (NS_SUCCEEDED(imgRequest->GetCORSMode(&corsmode))) { + res.mCORSUsed = corsmode != imgIRequest::CORS_NONE; + } + + res.mSize = res.mSourceSurface->GetSize(); + res.mPrincipal = principal.forget(); + res.mIsWriteOnly = false; + res.mImageRequest = imgRequest.forget(); + + return res; +} + +// drawImage(in HTMLImageElement image, in float dx, in float dy); +// -- render image from 0,0 at dx,dy top-left coords +// drawImage(in HTMLImageElement image, in float dx, in float dy, in float dw, in float dh); +// -- render image from 0,0 at dx,dy top-left coords clipping it to dw,dh +// drawImage(in HTMLImageElement image, in float sx, in float sy, in float sw, in float sh, in float dx, in float dy, in float dw, in float dh); +// -- render the region defined by (sx,sy,sw,wh) in image-local space into the region (dx,dy,dw,dh) on the canvas + +// If only dx and dy are passed in then optional_argc should be 0. If only +// dx, dy, dw and dh are passed in then optional_argc should be 2. The only +// other valid value for optional_argc is 6 if sx, sy, sw, sh, dx, dy, dw and dh +// are all passed in. + +void +CanvasRenderingContext2D::DrawImage(const CanvasImageSource& aImage, + double aSx, double aSy, double aSw, + double aSh, double aDx, double aDy, + double aDw, double aDh, + uint8_t aOptional_argc, + ErrorResult& aError) +{ + if (mDrawObserver) { + mDrawObserver->DidDrawCall(CanvasDrawObserver::DrawCallType::DrawImage); + } + + MOZ_ASSERT(aOptional_argc == 0 || aOptional_argc == 2 || aOptional_argc == 6); + + if (!ValidateRect(aDx, aDy, aDw, aDh, true)) { + return; + } + if (aOptional_argc == 6) { + if (!ValidateRect(aSx, aSy, aSw, aSh, true)) { + return; + } + } + + RefPtr<SourceSurface> srcSurf; + gfx::IntSize imgSize; + + Element* element = nullptr; + + EnsureTarget(); + if (!IsTargetValid()) { + return; + } + + if (aImage.IsHTMLCanvasElement()) { + HTMLCanvasElement* canvas = &aImage.GetAsHTMLCanvasElement(); + element = canvas; + nsIntSize size = canvas->GetSize(); + if (size.width == 0 || size.height == 0) { + aError.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + } else if (aImage.IsImageBitmap()) { + ImageBitmap& imageBitmap = aImage.GetAsImageBitmap(); + srcSurf = imageBitmap.PrepareForDrawTarget(mTarget); + + if (!srcSurf) { + return; + } + + imgSize = gfx::IntSize(imageBitmap.Width(), imageBitmap.Height()); + } + else { + if (aImage.IsHTMLImageElement()) { + HTMLImageElement* img = &aImage.GetAsHTMLImageElement(); + element = img; + } else { + HTMLVideoElement* video = &aImage.GetAsHTMLVideoElement(); + video->MarkAsContentSource(mozilla::dom::HTMLVideoElement::CallerAPI::DRAW_IMAGE); + element = video; + } + + srcSurf = + CanvasImageCache::LookupCanvas(element, mCanvasElement, &imgSize, mIsSkiaGL); + } + + nsLayoutUtils::DirectDrawInfo drawInfo; + +#ifdef USE_SKIA_GPU + if (mRenderingMode == RenderingMode::OpenGLBackendMode && + mIsSkiaGL && + !srcSurf && + aImage.IsHTMLVideoElement() && + AllowOpenGLCanvas()) { + mozilla::gl::GLContext* gl = gfxPlatform::GetPlatform()->GetSkiaGLGlue()->GetGLContext(); + MOZ_ASSERT(gl); + + HTMLVideoElement* video = &aImage.GetAsHTMLVideoElement(); + if (!video) { + return; + } + + if (video->ContainsRestrictedContent()) { + aError.Throw(NS_ERROR_NOT_AVAILABLE); + return; + } + + uint16_t readyState; + if (NS_SUCCEEDED(video->GetReadyState(&readyState)) && + readyState < nsIDOMHTMLMediaElement::HAVE_CURRENT_DATA) { + // still loading, just return + return; + } + + // If it doesn't have a principal, just bail + nsCOMPtr<nsIPrincipal> principal = video->GetCurrentVideoPrincipal(); + if (!principal) { + aError.Throw(NS_ERROR_NOT_AVAILABLE); + return; + } + + mozilla::layers::ImageContainer* container = video->GetImageContainer(); + if (!container) { + aError.Throw(NS_ERROR_NOT_AVAILABLE); + return; + } + + AutoLockImage lockImage(container); + layers::Image* srcImage = lockImage.GetImage(); + if (!srcImage) { + aError.Throw(NS_ERROR_NOT_AVAILABLE); + return; + } + + gl->MakeCurrent(); + GLuint videoTexture = 0; + gl->fGenTextures(1, &videoTexture); + // skiaGL expect upload on drawing, and uses texture 0 for texturing, + // so we must active texture 0 and bind the texture for it. + gl->fActiveTexture(LOCAL_GL_TEXTURE0); + gl->fBindTexture(LOCAL_GL_TEXTURE_2D, videoTexture); + + gl->fTexImage2D(LOCAL_GL_TEXTURE_2D, 0, LOCAL_GL_RGB, srcImage->GetSize().width, srcImage->GetSize().height, 0, LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_SHORT_5_6_5, nullptr); + gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S, LOCAL_GL_CLAMP_TO_EDGE); + gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T, LOCAL_GL_CLAMP_TO_EDGE); + gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_LINEAR); + gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_LINEAR); + + const gl::OriginPos destOrigin = gl::OriginPos::TopLeft; + bool ok = gl->BlitHelper()->BlitImageToTexture(srcImage, srcImage->GetSize(), + videoTexture, LOCAL_GL_TEXTURE_2D, + destOrigin); + if (ok) { + NativeSurface texSurf; + texSurf.mType = NativeSurfaceType::OPENGL_TEXTURE; + texSurf.mFormat = SurfaceFormat::R5G6B5_UINT16; + texSurf.mSize.width = srcImage->GetSize().width; + texSurf.mSize.height = srcImage->GetSize().height; + texSurf.mSurface = (void*)((uintptr_t)videoTexture); + + srcSurf = mTarget->CreateSourceSurfaceFromNativeSurface(texSurf); + if (!srcSurf) { + gl->fDeleteTextures(1, &videoTexture); + } + imgSize.width = srcImage->GetSize().width; + imgSize.height = srcImage->GetSize().height; + + int32_t displayWidth = video->VideoWidth(); + int32_t displayHeight = video->VideoHeight(); + aSw *= (double)imgSize.width / (double)displayWidth; + aSh *= (double)imgSize.height / (double)displayHeight; + } else { + gl->fDeleteTextures(1, &videoTexture); + } + srcImage = nullptr; + + if (mCanvasElement) { + CanvasUtils::DoDrawImageSecurityCheck(mCanvasElement, + principal, false, + video->GetCORSMode() != CORS_NONE); + } + } +#endif + if (!srcSurf) { + // The canvas spec says that drawImage should draw the first frame + // of animated images. We also don't want to rasterize vector images. + uint32_t sfeFlags = nsLayoutUtils::SFE_WANT_FIRST_FRAME | + nsLayoutUtils::SFE_NO_RASTERIZING_VECTORS; + + nsLayoutUtils::SurfaceFromElementResult res = + CanvasRenderingContext2D::CachedSurfaceFromElement(element); + + if (!res.mSourceSurface) { + res = nsLayoutUtils::SurfaceFromElement(element, sfeFlags, mTarget); + } + + if (!res.mSourceSurface && !res.mDrawInfo.mImgContainer) { + // The spec says to silently do nothing in the following cases: + // - The element is still loading. + // - The image is bad, but it's not in the broken state (i.e., we could + // decode the headers and get the size). + if (!res.mIsStillLoading && !res.mHasSize) { + aError.Throw(NS_ERROR_NOT_AVAILABLE); + } + return; + } + + imgSize = res.mSize; + + // Scale sw/sh based on aspect ratio + if (aImage.IsHTMLVideoElement()) { + HTMLVideoElement* video = &aImage.GetAsHTMLVideoElement(); + int32_t displayWidth = video->VideoWidth(); + int32_t displayHeight = video->VideoHeight(); + aSw *= (double)imgSize.width / (double)displayWidth; + aSh *= (double)imgSize.height / (double)displayHeight; + } + + if (mCanvasElement) { + CanvasUtils::DoDrawImageSecurityCheck(mCanvasElement, + res.mPrincipal, res.mIsWriteOnly, + res.mCORSUsed); + } + + if (res.mSourceSurface) { + if (res.mImageRequest) { + CanvasImageCache::NotifyDrawImage(element, mCanvasElement, res.mSourceSurface, imgSize, mIsSkiaGL); + } + srcSurf = res.mSourceSurface; + } else { + drawInfo = res.mDrawInfo; + } + } + + if (aOptional_argc == 0) { + aSx = aSy = 0.0; + aDw = aSw = (double) imgSize.width; + aDh = aSh = (double) imgSize.height; + } else if (aOptional_argc == 2) { + aSx = aSy = 0.0; + aSw = (double) imgSize.width; + aSh = (double) imgSize.height; + } + + if (aSw == 0.0 || aSh == 0.0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + ClipImageDimension(aSx, aSw, imgSize.width, aDx, aDw); + ClipImageDimension(aSy, aSh, imgSize.height, aDy, aDh); + + if (aSw <= 0.0 || aSh <= 0.0 || + aDw <= 0.0 || aDh <= 0.0) { + // source and/or destination are fully clipped, so nothing is painted + return; + } + + SamplingFilter samplingFilter; + AntialiasMode antialiasMode; + + if (CurrentState().imageSmoothingEnabled) { + samplingFilter = gfx::SamplingFilter::LINEAR; + antialiasMode = AntialiasMode::DEFAULT; + } else { + samplingFilter = gfx::SamplingFilter::POINT; + antialiasMode = AntialiasMode::NONE; + } + + const bool needBounds = NeedToCalculateBounds(); + if (!IsTargetValid()) { + return; + } + gfx::Rect bounds; + if (needBounds) { + bounds = gfx::Rect(aDx, aDy, aDw, aDh); + bounds = mTarget->GetTransform().TransformBounds(bounds); + } + + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + if (srcSurf) { + gfx::Rect sourceRect(aSx, aSy, aSw, aSh); + if (element == mCanvasElement) { + // srcSurf is a snapshot of mTarget. If we draw to mTarget now, we'll + // trigger a COW copy of the whole canvas into srcSurf. That's a huge + // waste if sourceRect doesn't cover the whole canvas. + // We avoid copying the whole canvas by manually copying just the part + // that we need. + srcSurf = ExtractSubrect(srcSurf, &sourceRect, mTarget); + } + AdjustedTarget tempTarget(this, bounds.IsEmpty() ? nullptr : &bounds); + if (!tempTarget) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + auto op = UsedOperation(); + if (!IsTargetValid() || !tempTarget) { + return; + } + tempTarget-> + DrawSurface(srcSurf, + gfx::Rect(aDx, aDy, aDw, aDh), + sourceRect, + DrawSurfaceOptions(samplingFilter, SamplingBounds::UNBOUNDED), + DrawOptions(CurrentState().globalAlpha, op, antialiasMode)); + } else { + DrawDirectlyToCanvas(drawInfo, &bounds, + gfx::Rect(aDx, aDy, aDw, aDh), + gfx::Rect(aSx, aSy, aSw, aSh), + imgSize); + } + + RedrawUser(gfxRect(aDx, aDy, aDw, aDh)); +} + +void +CanvasRenderingContext2D::DrawDirectlyToCanvas( + const nsLayoutUtils::DirectDrawInfo& aImage, + gfx::Rect* aBounds, + gfx::Rect aDest, + gfx::Rect aSrc, + gfx::IntSize aImgSize) +{ + MOZ_ASSERT(aSrc.width > 0 && aSrc.height > 0, + "Need positive source width and height"); + + AdjustedTarget tempTarget(this, aBounds->IsEmpty() ? nullptr: aBounds); + if (!tempTarget) { + return; + } + + // Get any existing transforms on the context, including transformations used + // for context shadow. + Matrix matrix = tempTarget->GetTransform(); + gfxMatrix contextMatrix; + contextMatrix = gfxMatrix(matrix._11, matrix._12, matrix._21, + matrix._22, matrix._31, matrix._32); + gfxSize contextScale(contextMatrix.ScaleFactors(true)); + + // Scale the dest rect to include the context scale. + aDest.Scale(contextScale.width, contextScale.height); + + // Scale the image size to the dest rect, and adjust the source rect to match. + gfxSize scale(aDest.width / aSrc.width, aDest.height / aSrc.height); + IntSize scaledImageSize = IntSize::Ceil(aImgSize.width * scale.width, + aImgSize.height * scale.height); + aSrc.Scale(scale.width, scale.height); + + // We're wrapping tempTarget's (our) DrawTarget here, so we need to restore + // the matrix even though this is a temp gfxContext. + AutoRestoreTransform autoRestoreTransform(mTarget); + + RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempTarget); + if (!context) { + gfxDevCrash(LogReason::InvalidContext) << "Canvas context problem"; + return; + } + context->SetMatrix(contextMatrix. + Scale(1.0 / contextScale.width, + 1.0 / contextScale.height). + Translate(aDest.x - aSrc.x, aDest.y - aSrc.y)); + + // FLAG_CLAMP is added for increased performance, since we never tile here. + uint32_t modifiedFlags = aImage.mDrawingFlags | imgIContainer::FLAG_CLAMP; + + CSSIntSize sz(scaledImageSize.width, scaledImageSize.height); // XXX hmm is scaledImageSize really in CSS pixels? + SVGImageContext svgContext(sz, Nothing(), CurrentState().globalAlpha); + + auto result = aImage.mImgContainer-> + Draw(context, scaledImageSize, + ImageRegion::Create(gfxRect(aSrc.x, aSrc.y, aSrc.width, aSrc.height)), + aImage.mWhichFrame, SamplingFilter::GOOD, Some(svgContext), modifiedFlags); + + if (result != DrawResult::SUCCESS) { + NS_WARNING("imgIContainer::Draw failed"); + } +} + +void +CanvasRenderingContext2D::SetGlobalCompositeOperation(const nsAString& aOp, + ErrorResult& aError) +{ + CompositionOp comp_op; + +#define CANVAS_OP_TO_GFX_OP(cvsop, op2d) \ + if (aOp.EqualsLiteral(cvsop)) \ + comp_op = CompositionOp::OP_##op2d; + + CANVAS_OP_TO_GFX_OP("copy", SOURCE) + else CANVAS_OP_TO_GFX_OP("source-atop", ATOP) + else CANVAS_OP_TO_GFX_OP("source-in", IN) + else CANVAS_OP_TO_GFX_OP("source-out", OUT) + else CANVAS_OP_TO_GFX_OP("source-over", OVER) + else CANVAS_OP_TO_GFX_OP("destination-in", DEST_IN) + else CANVAS_OP_TO_GFX_OP("destination-out", DEST_OUT) + else CANVAS_OP_TO_GFX_OP("destination-over", DEST_OVER) + else CANVAS_OP_TO_GFX_OP("destination-atop", DEST_ATOP) + else CANVAS_OP_TO_GFX_OP("lighter", ADD) + else CANVAS_OP_TO_GFX_OP("xor", XOR) + else CANVAS_OP_TO_GFX_OP("multiply", MULTIPLY) + else CANVAS_OP_TO_GFX_OP("screen", SCREEN) + else CANVAS_OP_TO_GFX_OP("overlay", OVERLAY) + else CANVAS_OP_TO_GFX_OP("darken", DARKEN) + else CANVAS_OP_TO_GFX_OP("lighten", LIGHTEN) + else CANVAS_OP_TO_GFX_OP("color-dodge", COLOR_DODGE) + else CANVAS_OP_TO_GFX_OP("color-burn", COLOR_BURN) + else CANVAS_OP_TO_GFX_OP("hard-light", HARD_LIGHT) + else CANVAS_OP_TO_GFX_OP("soft-light", SOFT_LIGHT) + else CANVAS_OP_TO_GFX_OP("difference", DIFFERENCE) + else CANVAS_OP_TO_GFX_OP("exclusion", EXCLUSION) + else CANVAS_OP_TO_GFX_OP("hue", HUE) + else CANVAS_OP_TO_GFX_OP("saturation", SATURATION) + else CANVAS_OP_TO_GFX_OP("color", COLOR) + else CANVAS_OP_TO_GFX_OP("luminosity", LUMINOSITY) + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + else return; + +#undef CANVAS_OP_TO_GFX_OP + CurrentState().op = comp_op; +} + +void +CanvasRenderingContext2D::GetGlobalCompositeOperation(nsAString& aOp, + ErrorResult& aError) +{ + CompositionOp comp_op = CurrentState().op; + +#define CANVAS_OP_TO_GFX_OP(cvsop, op2d) \ + if (comp_op == CompositionOp::OP_##op2d) \ + aOp.AssignLiteral(cvsop); + + CANVAS_OP_TO_GFX_OP("copy", SOURCE) + else CANVAS_OP_TO_GFX_OP("destination-atop", DEST_ATOP) + else CANVAS_OP_TO_GFX_OP("destination-in", DEST_IN) + else CANVAS_OP_TO_GFX_OP("destination-out", DEST_OUT) + else CANVAS_OP_TO_GFX_OP("destination-over", DEST_OVER) + else CANVAS_OP_TO_GFX_OP("lighter", ADD) + else CANVAS_OP_TO_GFX_OP("source-atop", ATOP) + else CANVAS_OP_TO_GFX_OP("source-in", IN) + else CANVAS_OP_TO_GFX_OP("source-out", OUT) + else CANVAS_OP_TO_GFX_OP("source-over", OVER) + else CANVAS_OP_TO_GFX_OP("xor", XOR) + else CANVAS_OP_TO_GFX_OP("multiply", MULTIPLY) + else CANVAS_OP_TO_GFX_OP("screen", SCREEN) + else CANVAS_OP_TO_GFX_OP("overlay", OVERLAY) + else CANVAS_OP_TO_GFX_OP("darken", DARKEN) + else CANVAS_OP_TO_GFX_OP("lighten", LIGHTEN) + else CANVAS_OP_TO_GFX_OP("color-dodge", COLOR_DODGE) + else CANVAS_OP_TO_GFX_OP("color-burn", COLOR_BURN) + else CANVAS_OP_TO_GFX_OP("hard-light", HARD_LIGHT) + else CANVAS_OP_TO_GFX_OP("soft-light", SOFT_LIGHT) + else CANVAS_OP_TO_GFX_OP("difference", DIFFERENCE) + else CANVAS_OP_TO_GFX_OP("exclusion", EXCLUSION) + else CANVAS_OP_TO_GFX_OP("hue", HUE) + else CANVAS_OP_TO_GFX_OP("saturation", SATURATION) + else CANVAS_OP_TO_GFX_OP("color", COLOR) + else CANVAS_OP_TO_GFX_OP("luminosity", LUMINOSITY) + else { + aError.Throw(NS_ERROR_FAILURE); + } + +#undef CANVAS_OP_TO_GFX_OP +} + +void +CanvasRenderingContext2D::DrawWindow(nsGlobalWindow& aWindow, double aX, + double aY, double aW, double aH, + const nsAString& aBgColor, + uint32_t aFlags, ErrorResult& aError) +{ + MOZ_ASSERT(aWindow.IsInnerWindow()); + + if (int32_t(aW) == 0 || int32_t(aH) == 0) { + return; + } + + // protect against too-large surfaces that will cause allocation + // or overflow issues + if (!Factory::CheckSurfaceSize(IntSize(int32_t(aW), int32_t(aH)), 0xffff)) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + // Flush layout updates + if (!(aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DO_NOT_FLUSH)) { + nsContentUtils::FlushLayoutForTree(aWindow.AsInner()->GetOuterWindow()); + } + + CompositionOp op = UsedOperation(); + bool discardContent = GlobalAlpha() == 1.0f + && (op == CompositionOp::OP_OVER || op == CompositionOp::OP_SOURCE); + const gfx::Rect drawRect(aX, aY, aW, aH); + EnsureTarget(discardContent ? &drawRect : nullptr); + + if (!IsTargetValid()) { + return; + } + + // We can't allow web apps to call this until we fix at least the + // following potential security issues: + // -- rendering cross-domain IFRAMEs and then extracting the results + // -- rendering the user's theme and then extracting the results + // -- rendering native anonymous content (e.g., file input paths; + // scrollbars should be allowed) + if (!nsContentUtils::IsCallerChrome()) { + // not permitted to use DrawWindow + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + aError.Throw(NS_ERROR_DOM_SECURITY_ERR); + return; + } + + RefPtr<nsPresContext> presContext; + nsIDocShell* docshell = aWindow.GetDocShell(); + if (docshell) { + docshell->GetPresContext(getter_AddRefs(presContext)); + } + if (!presContext) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + nscolor backgroundColor; + if (!ParseColor(aBgColor, &backgroundColor)) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + nsRect r(nsPresContext::CSSPixelsToAppUnits((float)aX), + nsPresContext::CSSPixelsToAppUnits((float)aY), + nsPresContext::CSSPixelsToAppUnits((float)aW), + nsPresContext::CSSPixelsToAppUnits((float)aH)); + uint32_t renderDocFlags = (nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING | + nsIPresShell::RENDER_DOCUMENT_RELATIVE); + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DRAW_CARET) { + renderDocFlags |= nsIPresShell::RENDER_CARET; + } + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DRAW_VIEW) { + renderDocFlags &= ~(nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING | + nsIPresShell::RENDER_DOCUMENT_RELATIVE); + } + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_USE_WIDGET_LAYERS) { + renderDocFlags |= nsIPresShell::RENDER_USE_WIDGET_LAYERS; + } + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_ASYNC_DECODE_IMAGES) { + renderDocFlags |= nsIPresShell::RENDER_ASYNC_DECODE_IMAGES; + } + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DO_NOT_FLUSH) { + renderDocFlags |= nsIPresShell::RENDER_DRAWWINDOW_NOT_FLUSHING; + } + + // gfxContext-over-Azure may modify the DrawTarget's transform, so + // save and restore it + Matrix matrix = mTarget->GetTransform(); + double sw = matrix._11 * aW; + double sh = matrix._22 * aH; + if (!sw || !sh) { + return; + } + + RefPtr<gfxContext> thebes; + RefPtr<DrawTarget> drawDT; + // Rendering directly is faster and can be done if mTarget supports Azure + // and does not need alpha blending. + // Since the pre-transaction callback calls ReturnTarget, we can't have a + // gfxContext wrapped around it when using a shared buffer provider because + // the DrawTarget's shared buffer may be unmapped in ReturnTarget. + op = CompositionOp::OP_ADD; + if (gfxPlatform::GetPlatform()->SupportsAzureContentForDrawTarget(mTarget) && + GlobalAlpha() == 1.0f) { + op = UsedOperation(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + } + if (op == CompositionOp::OP_OVER && + (!mBufferProvider || mBufferProvider->GetType() != LayersBackend::LAYERS_CLIENT)) + { + thebes = gfxContext::CreateOrNull(mTarget); + MOZ_ASSERT(thebes); // already checked the draw target above + // (in SupportsAzureContentForDrawTarget) + thebes->SetMatrix(gfxMatrix(matrix._11, matrix._12, matrix._21, + matrix._22, matrix._31, matrix._32)); + } else { + IntSize dtSize = IntSize::Ceil(sw, sh); + if (!Factory::AllowedSurfaceSize(dtSize)) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + drawDT = + gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(dtSize, + SurfaceFormat::B8G8R8A8); + if (!drawDT || !drawDT->IsValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + thebes = gfxContext::CreateOrNull(drawDT); + MOZ_ASSERT(thebes); // alrady checked the draw target above + thebes->SetMatrix(gfxMatrix::Scaling(matrix._11, matrix._22)); + } + + nsCOMPtr<nsIPresShell> shell = presContext->PresShell(); + + Unused << shell->RenderDocument(r, renderDocFlags, backgroundColor, thebes); + // If this canvas was contained in the drawn window, the pre-transaction callback + // may have returned its DT. If so, we must reacquire it here. + EnsureTarget(discardContent ? &drawRect : nullptr); + + if (drawDT) { + RefPtr<SourceSurface> snapshot = drawDT->Snapshot(); + if (NS_WARN_IF(!snapshot)) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + RefPtr<DataSourceSurface> data = snapshot->GetDataSurface(); + if (!data || !Factory::AllowedSurfaceSize(data->GetSize())) { + gfxCriticalError() << "Unexpected invalid data source surface " << + (data ? data->GetSize() : IntSize(0,0)); + aError.Throw(NS_ERROR_FAILURE); + return; + } + + DataSourceSurface::MappedSurface rawData; + if (NS_WARN_IF(!data->Map(DataSourceSurface::READ, &rawData))) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + RefPtr<SourceSurface> source = + mTarget->CreateSourceSurfaceFromData(rawData.mData, + data->GetSize(), + rawData.mStride, + data->GetFormat()); + data->Unmap(); + + if (!source) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + op = UsedOperation(); + if (!IsTargetValid()) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + gfx::Rect destRect(0, 0, aW, aH); + gfx::Rect sourceRect(0, 0, sw, sh); + mTarget->DrawSurface(source, destRect, sourceRect, + DrawSurfaceOptions(gfx::SamplingFilter::POINT), + DrawOptions(GlobalAlpha(), op, + AntialiasMode::NONE)); + } else { + mTarget->SetTransform(matrix); + } + + // note that x and y are coordinates in the document that + // we're drawing; x and y are drawn to 0,0 in current user + // space. + RedrawUser(gfxRect(0, 0, aW, aH)); +} + +void +CanvasRenderingContext2D::AsyncDrawXULElement(nsXULElement& aElem, + double aX, double aY, + double aW, double aH, + const nsAString& aBgColor, + uint32_t aFlags, + ErrorResult& aError) +{ + // We can't allow web apps to call this until we fix at least the + // following potential security issues: + // -- rendering cross-domain IFRAMEs and then extracting the results + // -- rendering the user's theme and then extracting the results + // -- rendering native anonymous content (e.g., file input paths; + // scrollbars should be allowed) + if (!nsContentUtils::IsCallerChrome()) { + // not permitted to use DrawWindow + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + aError.Throw(NS_ERROR_DOM_SECURITY_ERR); + return; + } + +#if 0 + nsCOMPtr<nsIFrameLoaderOwner> loaderOwner = do_QueryInterface(&elem); + if (!loaderOwner) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + RefPtr<nsFrameLoader> frameloader = loaderOwner->GetFrameLoader(); + if (!frameloader) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + PBrowserParent *child = frameloader->GetRemoteBrowser(); + if (!child) { + nsIDocShell* docShell = frameLoader->GetExistingDocShell(); + if (!docShell) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + nsCOMPtr<nsPIDOMWindowOuter> window = docShell->GetWindow(); + if (!window) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + return DrawWindow(window->GetCurrentInnerWindow(), aX, aY, aW, aH, + aBgColor, aFlags); + } + + // protect against too-large surfaces that will cause allocation + // or overflow issues + if (!Factory::CheckSurfaceSize(IntSize(aW, aH), 0xffff)) { + aError.Throw(NS_ERROR_FAILURE); + return; + } + + bool flush = + (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DO_NOT_FLUSH) == 0; + + uint32_t renderDocFlags = nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING; + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DRAW_CARET) { + renderDocFlags |= nsIPresShell::RENDER_CARET; + } + if (aFlags & nsIDOMCanvasRenderingContext2D::DRAWWINDOW_DRAW_VIEW) { + renderDocFlags &= ~nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING; + } + + nsRect rect(nsPresContext::CSSPixelsToAppUnits(aX), + nsPresContext::CSSPixelsToAppUnits(aY), + nsPresContext::CSSPixelsToAppUnits(aW), + nsPresContext::CSSPixelsToAppUnits(aH)); + if (mIPC) { + PDocumentRendererParent *pdocrender = + child->SendPDocumentRendererConstructor(rect, + mThebes->CurrentMatrix(), + nsString(aBGColor), + renderDocFlags, flush, + nsIntSize(mWidth, mHeight)); + if (!pdocrender) + return NS_ERROR_FAILURE; + + DocumentRendererParent *docrender = + static_cast<DocumentRendererParent *>(pdocrender); + + docrender->SetCanvasContext(this, mThebes); + } +#endif +} + +// +// device pixel getting/setting +// + +already_AddRefed<ImageData> +CanvasRenderingContext2D::GetImageData(JSContext* aCx, double aSx, + double aSy, double aSw, + double aSh, ErrorResult& aError) +{ + if (mDrawObserver) { + mDrawObserver->DidDrawCall(CanvasDrawObserver::DrawCallType::GetImageData); + } + + if (!mCanvasElement && !mDocShell) { + NS_ERROR("No canvas element and no docshell in GetImageData!!!"); + aError.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + // Check only if we have a canvas element; if we were created with a docshell, + // then it's special internal use. + if (mCanvasElement && mCanvasElement->IsWriteOnly() && + !nsContentUtils::IsCallerChrome()) + { + // XXX ERRMSG we need to report an error to developers here! (bug 329026) + aError.Throw(NS_ERROR_DOM_SECURITY_ERR); + return nullptr; + } + + if (!IsFinite(aSx) || !IsFinite(aSy) || + !IsFinite(aSw) || !IsFinite(aSh)) { + aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); + return nullptr; + } + + if (!aSw || !aSh) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return nullptr; + } + + int32_t x = JS::ToInt32(aSx); + int32_t y = JS::ToInt32(aSy); + int32_t wi = JS::ToInt32(aSw); + int32_t hi = JS::ToInt32(aSh); + + // Handle negative width and height by flipping the rectangle over in the + // relevant direction. + uint32_t w, h; + if (aSw < 0) { + w = -wi; + x -= w; + } else { + w = wi; + } + if (aSh < 0) { + h = -hi; + y -= h; + } else { + h = hi; + } + + if (w == 0) { + w = 1; + } + if (h == 0) { + h = 1; + } + + JS::Rooted<JSObject*> array(aCx); + aError = GetImageDataArray(aCx, x, y, w, h, array.address()); + if (aError.Failed()) { + return nullptr; + } + MOZ_ASSERT(array); + + RefPtr<ImageData> imageData = new ImageData(w, h, *array); + return imageData.forget(); +} + +nsresult +CanvasRenderingContext2D::GetImageDataArray(JSContext* aCx, + int32_t aX, + int32_t aY, + uint32_t aWidth, + uint32_t aHeight, + JSObject** aRetval) +{ + if (mDrawObserver) { + mDrawObserver->DidDrawCall(CanvasDrawObserver::DrawCallType::GetImageData); + } + + MOZ_ASSERT(aWidth && aHeight); + + CheckedInt<uint32_t> len = CheckedInt<uint32_t>(aWidth) * aHeight * 4; + if (!len.isValid()) { + return NS_ERROR_DOM_INDEX_SIZE_ERR; + } + + CheckedInt<int32_t> rightMost = CheckedInt<int32_t>(aX) + aWidth; + CheckedInt<int32_t> bottomMost = CheckedInt<int32_t>(aY) + aHeight; + + if (!rightMost.isValid() || !bottomMost.isValid()) { + return NS_ERROR_DOM_SYNTAX_ERR; + } + + JS::Rooted<JSObject*> darray(aCx, JS_NewUint8ClampedArray(aCx, len.value())); + if (!darray) { + return NS_ERROR_OUT_OF_MEMORY; + } + + if (mZero) { + *aRetval = darray; + return NS_OK; + } + + IntRect srcRect(0, 0, mWidth, mHeight); + IntRect destRect(aX, aY, aWidth, aHeight); + IntRect srcReadRect = srcRect.Intersect(destRect); + RefPtr<DataSourceSurface> readback; + DataSourceSurface::MappedSurface rawData; + if (!srcReadRect.IsEmpty()) { + RefPtr<SourceSurface> snapshot; + if (!mTarget && mBufferProvider) { + snapshot = mBufferProvider->BorrowSnapshot(); + } else { + EnsureTarget(); + if (!IsTargetValid()) { + return NS_ERROR_FAILURE; + } + snapshot = mTarget->Snapshot(); + } + + if (snapshot) { + readback = snapshot->GetDataSurface(); + } + + if (!mTarget && mBufferProvider) { + mBufferProvider->ReturnSnapshot(snapshot.forget()); + } + + if (!readback || !readback->Map(DataSourceSurface::READ, &rawData)) { + return NS_ERROR_OUT_OF_MEMORY; + } + } + + IntRect dstWriteRect = srcReadRect; + dstWriteRect.MoveBy(-aX, -aY); + + JS::AutoCheckCannotGC nogc; + bool isShared; + uint8_t* data = JS_GetUint8ClampedArrayData(darray, &isShared, nogc); + MOZ_ASSERT(!isShared); // Should not happen, data was created above + + uint8_t* src; + uint32_t srcStride; + if (readback) { + srcStride = rawData.mStride; + src = rawData.mData + srcReadRect.y * srcStride + srcReadRect.x * 4; + } else { + src = data; + srcStride = aWidth * 4; + } + + uint8_t* dst = data + dstWriteRect.y * (aWidth * 4) + dstWriteRect.x * 4; + + if (mOpaque) { + for (int32_t j = 0; j < dstWriteRect.height; ++j) { + for (int32_t i = 0; i < dstWriteRect.width; ++i) { + // XXX Is there some useful swizzle MMX we can use here? +#if MOZ_LITTLE_ENDIAN + uint8_t b = *src++; + uint8_t g = *src++; + uint8_t r = *src++; + src++; +#else + src++; + uint8_t r = *src++; + uint8_t g = *src++; + uint8_t b = *src++; +#endif + *dst++ = r; + *dst++ = g; + *dst++ = b; + *dst++ = 255; + } + src += srcStride - (dstWriteRect.width * 4); + dst += (aWidth * 4) - (dstWriteRect.width * 4); + } + } else + for (int32_t j = 0; j < dstWriteRect.height; ++j) { + for (int32_t i = 0; i < dstWriteRect.width; ++i) { + // XXX Is there some useful swizzle MMX we can use here? +#if MOZ_LITTLE_ENDIAN + uint8_t b = *src++; + uint8_t g = *src++; + uint8_t r = *src++; + uint8_t a = *src++; +#else + uint8_t a = *src++; + uint8_t r = *src++; + uint8_t g = *src++; + uint8_t b = *src++; +#endif + // Convert to non-premultiplied color + *dst++ = gfxUtils::sUnpremultiplyTable[a * 256 + r]; + *dst++ = gfxUtils::sUnpremultiplyTable[a * 256 + g]; + *dst++ = gfxUtils::sUnpremultiplyTable[a * 256 + b]; + *dst++ = a; + } + src += srcStride - (dstWriteRect.width * 4); + dst += (aWidth * 4) - (dstWriteRect.width * 4); + } + + if (readback) { + readback->Unmap(); + } + + *aRetval = darray; + return NS_OK; +} + +void +CanvasRenderingContext2D::EnsureErrorTarget() +{ + if (sErrorTarget) { + return; + } + + RefPtr<DrawTarget> errorTarget = gfxPlatform::GetPlatform()->CreateOffscreenCanvasDrawTarget(IntSize(1, 1), SurfaceFormat::B8G8R8A8); + MOZ_ASSERT(errorTarget, "Failed to allocate the error target!"); + + sErrorTarget = errorTarget; + NS_ADDREF(sErrorTarget); +} + +void +CanvasRenderingContext2D::FillRuleChanged() +{ + if (mPath) { + mPathBuilder = mPath->CopyToBuilder(CurrentState().fillRule); + mPath = nullptr; + } +} + +void +CanvasRenderingContext2D::PutImageData(ImageData& aImageData, double aDx, + double aDy, ErrorResult& aError) +{ + RootedTypedArray<Uint8ClampedArray> arr(RootingCx()); + DebugOnly<bool> inited = arr.Init(aImageData.GetDataObject()); + MOZ_ASSERT(inited); + + aError = PutImageData_explicit(JS::ToInt32(aDx), JS::ToInt32(aDy), + aImageData.Width(), aImageData.Height(), + &arr, false, 0, 0, 0, 0); +} + +void +CanvasRenderingContext2D::PutImageData(ImageData& aImageData, double aDx, + double aDy, double aDirtyX, + double aDirtyY, double aDirtyWidth, + double aDirtyHeight, + ErrorResult& aError) +{ + RootedTypedArray<Uint8ClampedArray> arr(RootingCx()); + DebugOnly<bool> inited = arr.Init(aImageData.GetDataObject()); + MOZ_ASSERT(inited); + + aError = PutImageData_explicit(JS::ToInt32(aDx), JS::ToInt32(aDy), + aImageData.Width(), aImageData.Height(), + &arr, true, + JS::ToInt32(aDirtyX), + JS::ToInt32(aDirtyY), + JS::ToInt32(aDirtyWidth), + JS::ToInt32(aDirtyHeight)); +} + +nsresult +CanvasRenderingContext2D::PutImageData_explicit(int32_t aX, int32_t aY, uint32_t aW, uint32_t aH, + dom::Uint8ClampedArray* aArray, + bool aHasDirtyRect, int32_t aDirtyX, int32_t aDirtyY, + int32_t aDirtyWidth, int32_t aDirtyHeight) +{ + if (mDrawObserver) { + mDrawObserver->DidDrawCall(CanvasDrawObserver::DrawCallType::PutImageData); + } + + if (aW == 0 || aH == 0) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + IntRect dirtyRect; + IntRect imageDataRect(0, 0, aW, aH); + + if (aHasDirtyRect) { + // fix up negative dimensions + if (aDirtyWidth < 0) { + NS_ENSURE_TRUE(aDirtyWidth != INT_MIN, NS_ERROR_DOM_INDEX_SIZE_ERR); + + CheckedInt32 checkedDirtyX = CheckedInt32(aDirtyX) + aDirtyWidth; + + if (!checkedDirtyX.isValid()) + return NS_ERROR_DOM_INDEX_SIZE_ERR; + + aDirtyX = checkedDirtyX.value(); + aDirtyWidth = -aDirtyWidth; + } + + if (aDirtyHeight < 0) { + NS_ENSURE_TRUE(aDirtyHeight != INT_MIN, NS_ERROR_DOM_INDEX_SIZE_ERR); + + CheckedInt32 checkedDirtyY = CheckedInt32(aDirtyY) + aDirtyHeight; + + if (!checkedDirtyY.isValid()) + return NS_ERROR_DOM_INDEX_SIZE_ERR; + + aDirtyY = checkedDirtyY.value(); + aDirtyHeight = -aDirtyHeight; + } + + // bound the dirty rect within the imageData rectangle + dirtyRect = imageDataRect.Intersect(IntRect(aDirtyX, aDirtyY, aDirtyWidth, aDirtyHeight)); + + if (dirtyRect.Width() <= 0 || dirtyRect.Height() <= 0) + return NS_OK; + } else { + dirtyRect = imageDataRect; + } + + dirtyRect.MoveBy(IntPoint(aX, aY)); + dirtyRect = IntRect(0, 0, mWidth, mHeight).Intersect(dirtyRect); + + if (dirtyRect.Width() <= 0 || dirtyRect.Height() <= 0) { + return NS_OK; + } + + aArray->ComputeLengthAndData(); + + uint32_t dataLen = aArray->Length(); + + uint32_t len = aW * aH * 4; + if (dataLen != len) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + + uint32_t copyWidth = dirtyRect.Width(); + uint32_t copyHeight = dirtyRect.Height(); + RefPtr<gfxImageSurface> imgsurf = new gfxImageSurface(gfx::IntSize(copyWidth, copyHeight), + SurfaceFormat::A8R8G8B8_UINT32, + false); + if (!imgsurf || imgsurf->CairoStatus()) { + return NS_ERROR_FAILURE; + } + + uint32_t copyX = dirtyRect.x - aX; + uint32_t copyY = dirtyRect.y - aY; + //uint8_t *src = aArray->Data(); + uint8_t *dst = imgsurf->Data(); + uint8_t* srcLine = aArray->Data() + copyY * (aW * 4) + copyX * 4; + // For opaque canvases, we must still premultiply the RGB components, but write the alpha as opaque. + uint8_t alphaMask = mOpaque ? 255 : 0; +#if 0 + printf("PutImageData_explicit: dirty x=%d y=%d w=%d h=%d copy x=%d y=%d w=%d h=%d ext x=%d y=%d w=%d h=%d\n", + dirtyRect.x, dirtyRect.y, copyWidth, copyHeight, + copyX, copyY, copyWidth, copyHeight, + x, y, w, h); +#endif + for (uint32_t j = 0; j < copyHeight; j++) { + uint8_t *src = srcLine; + for (uint32_t i = 0; i < copyWidth; i++) { + uint8_t r = *src++; + uint8_t g = *src++; + uint8_t b = *src++; + uint8_t a = *src++; + + // Convert to premultiplied color (losslessly if the input came from getImageData) +#if MOZ_LITTLE_ENDIAN + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + b]; + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + g]; + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + r]; + *dst++ = a | alphaMask; +#else + *dst++ = a | alphaMask; + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + r]; + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + g]; + *dst++ = gfxUtils::sPremultiplyTable[a * 256 + b]; +#endif + } + srcLine += aW * 4; + } + + // The canvas spec says that the current path, transformation matrix, shadow attributes, + // global alpha, the clipping region, and global composition operator must not affect the + // getImageData() and putImageData() methods. + const gfx::Rect putRect(dirtyRect); + EnsureTarget(&putRect); + + if (!IsTargetValid()) { + return NS_ERROR_FAILURE; + } + + RefPtr<SourceSurface> sourceSurface = + mTarget->CreateSourceSurfaceFromData(imgsurf->Data(), IntSize(copyWidth, copyHeight), imgsurf->Stride(), SurfaceFormat::B8G8R8A8); + + // In certain scenarios, requesting larger than 8k image fails. Bug 803568 + // covers the details of how to run into it, but the full detailed + // investigation hasn't been done to determine the underlying cause. We + // will just handle the failure to allocate the surface to avoid a crash. + if (!sourceSurface) { + return NS_ERROR_FAILURE; + } + + mTarget->CopySurface(sourceSurface, + IntRect(0, 0, + dirtyRect.width, dirtyRect.height), + IntPoint(dirtyRect.x, dirtyRect.y)); + + Redraw(gfx::Rect(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height)); + + return NS_OK; +} + +static already_AddRefed<ImageData> +CreateImageData(JSContext* aCx, CanvasRenderingContext2D* aContext, + uint32_t aW, uint32_t aH, ErrorResult& aError) +{ + if (aW == 0) + aW = 1; + if (aH == 0) + aH = 1; + + CheckedInt<uint32_t> len = CheckedInt<uint32_t>(aW) * aH * 4; + if (!len.isValid()) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return nullptr; + } + + // Create the fast typed array; it's initialized to 0 by default. + JSObject* darray = Uint8ClampedArray::Create(aCx, aContext, len.value()); + if (!darray) { + aError.Throw(NS_ERROR_OUT_OF_MEMORY); + return nullptr; + } + + RefPtr<mozilla::dom::ImageData> imageData = + new mozilla::dom::ImageData(aW, aH, *darray); + return imageData.forget(); +} + +already_AddRefed<ImageData> +CanvasRenderingContext2D::CreateImageData(JSContext* aCx, double aSw, + double aSh, ErrorResult& aError) +{ + if (!aSw || !aSh) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return nullptr; + } + + int32_t wi = JS::ToInt32(aSw); + int32_t hi = JS::ToInt32(aSh); + + uint32_t w = Abs(wi); + uint32_t h = Abs(hi); + return mozilla::dom::CreateImageData(aCx, this, w, h, aError); +} + +already_AddRefed<ImageData> +CanvasRenderingContext2D::CreateImageData(JSContext* aCx, + ImageData& aImagedata, + ErrorResult& aError) +{ + return mozilla::dom::CreateImageData(aCx, this, aImagedata.Width(), + aImagedata.Height(), aError); +} + +static uint8_t g2DContextLayerUserData; + + +uint32_t +CanvasRenderingContext2D::SkiaGLTex() const +{ + if (!mTarget) { + return 0; + } + MOZ_ASSERT(IsTargetValid()); + return (uint32_t)(uintptr_t)mTarget->GetNativeSurface(NativeSurfaceType::OPENGL_TEXTURE); +} + +void CanvasRenderingContext2D::RemoveDrawObserver() +{ + if (mDrawObserver) { + delete mDrawObserver; + mDrawObserver = nullptr; + } +} + +already_AddRefed<Layer> +CanvasRenderingContext2D::GetCanvasLayer(nsDisplayListBuilder* aBuilder, + Layer* aOldLayer, + LayerManager* aManager, + bool aMirror /* = false */) +{ + if (aMirror) { + // Not supported for CanvasRenderingContext2D + return nullptr; + } + + if (mOpaque || mIsSkiaGL) { + // If we're opaque then make sure we have a surface so we paint black + // instead of transparent. + // If we're using SkiaGL, then SkiaGLTex() below needs the target to + // be accessible. + EnsureTarget(); + } + + // Don't call EnsureTarget() ... if there isn't already a surface, then + // we have nothing to paint and there is no need to create a surface just + // to paint nothing. Also, EnsureTarget() can cause creation of a persistent + // layer manager which must NOT happen during a paint. + if ((!mBufferProvider && !mTarget) || !IsTargetValid()) { + // No DidTransactionCallback will be received, so mark the context clean + // now so future invalidations will be dispatched. + MarkContextClean(); + return nullptr; + } + + if (!mResetLayer && aOldLayer) { + auto userData = + static_cast<CanvasRenderingContext2DUserData*>( + aOldLayer->GetUserData(&g2DContextLayerUserData)); + + CanvasLayer::Data data; + + if (mIsSkiaGL) { + GLuint skiaGLTex = SkiaGLTex(); + if (skiaGLTex) { + SkiaGLGlue* glue = gfxPlatform::GetPlatform()->GetSkiaGLGlue(); + MOZ_ASSERT(glue); + data.mGLContext = glue->GetGLContext(); + data.mFrontbufferGLTex = skiaGLTex; + } + } + + data.mBufferProvider = mBufferProvider; + + if (userData && + userData->IsForContext(this) && + static_cast<CanvasLayer*>(aOldLayer)->IsDataValid(data)) { + RefPtr<Layer> ret = aOldLayer; + return ret.forget(); + } + } + + RefPtr<CanvasLayer> canvasLayer = aManager->CreateCanvasLayer(); + if (!canvasLayer) { + NS_WARNING("CreateCanvasLayer returned null!"); + // No DidTransactionCallback will be received, so mark the context clean + // now so future invalidations will be dispatched. + MarkContextClean(); + return nullptr; + } + CanvasRenderingContext2DUserData* userData = nullptr; + // Make the layer tell us whenever a transaction finishes (including + // the current transaction), so we can clear our invalidation state and + // start invalidating again. We need to do this for all layers since + // callers of DrawWindow may be expecting to receive normal invalidation + // notifications after this paint. + + // The layer will be destroyed when we tear down the presentation + // (at the latest), at which time this userData will be destroyed, + // releasing the reference to the element. + // The userData will receive DidTransactionCallbacks, which flush the + // the invalidation state to indicate that the canvas is up to date. + userData = new CanvasRenderingContext2DUserData(this); + canvasLayer->SetDidTransactionCallback( + CanvasRenderingContext2DUserData::DidTransactionCallback, userData); + canvasLayer->SetUserData(&g2DContextLayerUserData, userData); + + CanvasLayer::Data data; + data.mSize = GetSize(); + data.mHasAlpha = !mOpaque; + + canvasLayer->SetPreTransactionCallback( + CanvasRenderingContext2DUserData::PreTransactionCallback, userData); + + + if (mIsSkiaGL) { + GLuint skiaGLTex = SkiaGLTex(); + if (skiaGLTex) { + SkiaGLGlue* glue = gfxPlatform::GetPlatform()->GetSkiaGLGlue(); + MOZ_ASSERT(glue); + data.mGLContext = glue->GetGLContext(); + data.mFrontbufferGLTex = skiaGLTex; + } + } + + data.mBufferProvider = mBufferProvider; + + canvasLayer->Initialize(data); + uint32_t flags = mOpaque ? Layer::CONTENT_OPAQUE : 0; + canvasLayer->SetContentFlags(flags); + canvasLayer->Updated(); + + mResetLayer = false; + + return canvasLayer.forget(); +} + +void +CanvasRenderingContext2D::MarkContextClean() +{ + if (mInvalidateCount > 0) { + mPredictManyRedrawCalls = mInvalidateCount > kCanvasMaxInvalidateCount; + } + mIsEntireFrameInvalid = false; + mInvalidateCount = 0; +} + +void +CanvasRenderingContext2D::MarkContextCleanForFrameCapture() +{ + mIsCapturedFrameInvalid = false; +} + +bool +CanvasRenderingContext2D::IsContextCleanForFrameCapture() +{ + return !mIsCapturedFrameInvalid; +} + +bool +CanvasRenderingContext2D::ShouldForceInactiveLayer(LayerManager* aManager) +{ + return !aManager->CanUseCanvasLayerForSize(GetSize()); +} + +NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(CanvasPath, AddRef) +NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(CanvasPath, Release) + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(CanvasPath, mParent) + +CanvasPath::CanvasPath(nsISupports* aParent) + : mParent(aParent) +{ + mPathBuilder = gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget()->CreatePathBuilder(); +} + +CanvasPath::CanvasPath(nsISupports* aParent, already_AddRefed<PathBuilder> aPathBuilder) + : mParent(aParent), mPathBuilder(aPathBuilder) +{ + if (!mPathBuilder) { + mPathBuilder = gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget()->CreatePathBuilder(); + } +} + +JSObject* +CanvasPath::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) +{ + return Path2DBinding::Wrap(aCx, this, aGivenProto); +} + +already_AddRefed<CanvasPath> +CanvasPath::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv) +{ + RefPtr<CanvasPath> path = new CanvasPath(aGlobal.GetAsSupports()); + return path.forget(); +} + +already_AddRefed<CanvasPath> +CanvasPath::Constructor(const GlobalObject& aGlobal, CanvasPath& aCanvasPath, ErrorResult& aRv) +{ + RefPtr<gfx::Path> tempPath = aCanvasPath.GetPath(CanvasWindingRule::Nonzero, + gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget()); + + RefPtr<CanvasPath> path = new CanvasPath(aGlobal.GetAsSupports(), tempPath->CopyToBuilder()); + return path.forget(); +} + +already_AddRefed<CanvasPath> +CanvasPath::Constructor(const GlobalObject& aGlobal, const nsAString& aPathString, ErrorResult& aRv) +{ + RefPtr<gfx::Path> tempPath = SVGContentUtils::GetPath(aPathString); + if (!tempPath) { + return Constructor(aGlobal, aRv); + } + + RefPtr<CanvasPath> path = new CanvasPath(aGlobal.GetAsSupports(), tempPath->CopyToBuilder()); + return path.forget(); +} + +void +CanvasPath::ClosePath() +{ + EnsurePathBuilder(); + + mPathBuilder->Close(); +} + +void +CanvasPath::MoveTo(double aX, double aY) +{ + EnsurePathBuilder(); + + mPathBuilder->MoveTo(Point(ToFloat(aX), ToFloat(aY))); +} + +void +CanvasPath::LineTo(double aX, double aY) +{ + EnsurePathBuilder(); + + mPathBuilder->LineTo(Point(ToFloat(aX), ToFloat(aY))); +} + +void +CanvasPath::QuadraticCurveTo(double aCpx, double aCpy, double aX, double aY) +{ + EnsurePathBuilder(); + + mPathBuilder->QuadraticBezierTo(gfx::Point(ToFloat(aCpx), ToFloat(aCpy)), + gfx::Point(ToFloat(aX), ToFloat(aY))); +} + +void +CanvasPath::BezierCurveTo(double aCp1x, double aCp1y, + double aCp2x, double aCp2y, + double aX, double aY) +{ + BezierTo(gfx::Point(ToFloat(aCp1x), ToFloat(aCp1y)), + gfx::Point(ToFloat(aCp2x), ToFloat(aCp2y)), + gfx::Point(ToFloat(aX), ToFloat(aY))); +} + +void +CanvasPath::ArcTo(double aX1, double aY1, double aX2, double aY2, double aRadius, + ErrorResult& aError) +{ + if (aRadius < 0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + EnsurePathBuilder(); + + // Current point in user space! + Point p0 = mPathBuilder->CurrentPoint(); + Point p1(aX1, aY1); + Point p2(aX2, aY2); + + // 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 || aRadius == 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-aX1)*(p0.x-aX1) + (p0.y-aY1)*(p0.y-aY1); + b2 = (aX1-aX2)*(aX1-aX2) + (aY1-aY2)*(aY1-aY2); + c2 = (p0.x-aX2)*(p0.x-aX2) + (p0.y-aY2)*(p0.y-aY2); + cosx = (a2+b2-c2)/(2*sqrt(a2*b2)); + + sinx = sqrt(1 - cosx*cosx); + d = aRadius / ((1 - cosx) / sinx); + + anx = (aX1-p0.x) / sqrt(a2); + any = (aY1-p0.y) / sqrt(a2); + bnx = (aX1-aX2) / sqrt(b2); + bny = (aY1-aY2) / sqrt(b2); + x3 = aX1 - anx*d; + y3 = aY1 - any*d; + x4 = aX1 - bnx*d; + y4 = aY1 - bny*d; + anticlockwise = (dir < 0); + cx = x3 + any*aRadius*(anticlockwise ? 1 : -1); + cy = y3 - anx*aRadius*(anticlockwise ? 1 : -1); + angle0 = atan2((y3-cy), (x3-cx)); + angle1 = atan2((y4-cy), (x4-cx)); + + + LineTo(x3, y3); + + Arc(cx, cy, aRadius, angle0, angle1, anticlockwise, aError); +} + +void +CanvasPath::Rect(double aX, double aY, double aW, double aH) +{ + MoveTo(aX, aY); + LineTo(aX + aW, aY); + LineTo(aX + aW, aY + aH); + LineTo(aX, aY + aH); + ClosePath(); +} + +void +CanvasPath::Arc(double aX, double aY, double aRadius, + double aStartAngle, double aEndAngle, bool aAnticlockwise, + ErrorResult& aError) +{ + if (aRadius < 0.0) { + aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + EnsurePathBuilder(); + + ArcToBezier(this, Point(aX, aY), Size(aRadius, aRadius), aStartAngle, aEndAngle, aAnticlockwise); +} + +void +CanvasPath::Ellipse(double x, double y, double radiusX, double radiusY, + double rotation, double startAngle, double endAngle, + bool anticlockwise, ErrorResult& error) +{ + if (radiusX < 0.0 || radiusY < 0.0) { + error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } + + EnsurePathBuilder(); + + ArcToBezier(this, Point(x, y), Size(radiusX, radiusY), startAngle, endAngle, + anticlockwise, rotation); +} + +void +CanvasPath::LineTo(const gfx::Point& aPoint) +{ + EnsurePathBuilder(); + + mPathBuilder->LineTo(aPoint); +} + +void +CanvasPath::BezierTo(const gfx::Point& aCP1, + const gfx::Point& aCP2, + const gfx::Point& aCP3) +{ + EnsurePathBuilder(); + + mPathBuilder->BezierTo(aCP1, aCP2, aCP3); +} + +void +CanvasPath::AddPath(CanvasPath& aCanvasPath, const Optional<NonNull<SVGMatrix>>& aMatrix) +{ + RefPtr<gfx::Path> tempPath = aCanvasPath.GetPath(CanvasWindingRule::Nonzero, + gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget()); + + if (aMatrix.WasPassed()) { + const SVGMatrix& m = aMatrix.Value(); + Matrix transform(m.A(), m.B(), m.C(), m.D(), m.E(), m.F()); + + if (!transform.IsIdentity()) { + RefPtr<PathBuilder> tempBuilder = tempPath->TransformedCopyToBuilder(transform, FillRule::FILL_WINDING); + tempPath = tempBuilder->Finish(); + } + } + + EnsurePathBuilder(); // in case a path is added to itself + tempPath->StreamToSink(mPathBuilder); +} + +already_AddRefed<gfx::Path> +CanvasPath::GetPath(const CanvasWindingRule& aWinding, const DrawTarget* aTarget) const +{ + FillRule fillRule = FillRule::FILL_WINDING; + if (aWinding == CanvasWindingRule::Evenodd) { + fillRule = FillRule::FILL_EVEN_ODD; + } + + if (mPath && + (mPath->GetBackendType() == aTarget->GetBackendType()) && + (mPath->GetFillRule() == fillRule)) { + RefPtr<gfx::Path> path(mPath); + return path.forget(); + } + + if (!mPath) { + // if there is no path, there must be a pathbuilder + MOZ_ASSERT(mPathBuilder); + mPath = mPathBuilder->Finish(); + if (!mPath) { + RefPtr<gfx::Path> path(mPath); + return path.forget(); + } + + mPathBuilder = nullptr; + } + + // retarget our backend if we're used with a different backend + if (mPath->GetBackendType() != aTarget->GetBackendType()) { + RefPtr<PathBuilder> tmpPathBuilder = aTarget->CreatePathBuilder(fillRule); + mPath->StreamToSink(tmpPathBuilder); + mPath = tmpPathBuilder->Finish(); + } else if (mPath->GetFillRule() != fillRule) { + RefPtr<PathBuilder> tmpPathBuilder = mPath->CopyToBuilder(fillRule); + mPath = tmpPathBuilder->Finish(); + } + + RefPtr<gfx::Path> path(mPath); + return path.forget(); +} + +void +CanvasPath::EnsurePathBuilder() const +{ + if (mPathBuilder) { + return; + } + + // if there is not pathbuilder, there must be a path + MOZ_ASSERT(mPath); + mPathBuilder = mPath->CopyToBuilder(); + mPath = nullptr; +} + +} // namespace dom +} // namespace mozilla |