Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1164 insertions, 0 deletions

diff --git a/dom/canvas/CanvasRenderingContext2D.h b/dom/canvas/CanvasRenderingContext2D.h
new file mode 100644
index 0000000000..3376e1033c
--- /dev/null
+++ b/dom/canvas/CanvasRenderingContext2D.h
@@ -0,0 +1,1164 @@
+/* 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/. */
+
+#ifndef CanvasRenderingContext2D_h
+#define CanvasRenderingContext2D_h
+
+#include <vector>
+#include "mozilla/dom/CanvasRenderingContext2DBinding.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/intl/Bidi.h"
+#include "mozilla/gfx/Rect.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/EnumeratedArray.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MruCache.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/SurfaceFromElementResult.h"
+#include "mozilla/ThreadLocal.h"
+#include "mozilla/UniquePtr.h"
+#include "FilterDescription.h"
+#include "gfx2DGlue.h"
+#include "gfxFontConstants.h"
+#include "gfxTextRun.h"
+#include "gfxUtils.h"
+#include "nsICanvasRenderingContextInternal.h"
+#include "nsColor.h"
+#include "nsRFPService.h"
+#include "nsIFrame.h"
+
+class gfxFontGroup;
+class nsGlobalWindowInner;
+class nsXULElement;
+
+namespace mozilla {
+class ErrorResult;
+class PresShell;
+
+namespace gl {
+class SourceSurface;
+}  // namespace gl
+
+namespace layers {
+class PersistentBufferProvider;
+enum class LayersBackend : int8_t;
+}  // namespace layers
+
+namespace dom {
+class
+    HTMLImageElementOrSVGImageElementOrHTMLCanvasElementOrHTMLVideoElementOrOffscreenCanvasOrImageBitmapOrVideoFrame;
+using CanvasImageSource =
+    HTMLImageElementOrSVGImageElementOrHTMLCanvasElementOrHTMLVideoElementOrOffscreenCanvasOrImageBitmapOrVideoFrame;
+class ImageBitmap;
+class ImageData;
+class UTF8StringOrCanvasGradientOrCanvasPattern;
+class OwningUTF8StringOrCanvasGradientOrCanvasPattern;
+class TextMetrics;
+class CanvasGradient;
+class CanvasPath;
+class CanvasPattern;
+
+extern const mozilla::gfx::Float SIGMA_MAX;
+
+template <typename T>
+class Optional;
+
+struct CanvasBidiProcessor;
+class CanvasDrawObserver;
+class CanvasShutdownObserver;
+
+class DOMMatrix;
+class DOMMatrixReadOnly;
+struct DOMMatrix2DInit;
+
+/**
+ ** CanvasRenderingContext2D
+ **/
+class CanvasRenderingContext2D : public nsICanvasRenderingContextInternal,
+                                 public nsWrapperCache {
+ protected:
+  virtual ~CanvasRenderingContext2D();
+
+ public:
+  explicit CanvasRenderingContext2D(layers::LayersBackend aCompositorBackend);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  HTMLCanvasElement* GetCanvas() const {
+    if (!mCanvasElement || mCanvasElement->IsInNativeAnonymousSubtree()) {
+      return nullptr;
+    }
+
+    // corresponds to changes to the old bindings made in bug 745025
+    return mCanvasElement->GetOriginalCanvas();
+  }
+
+  void GetContextAttributes(CanvasRenderingContext2DSettings& aSettings) const;
+
+  void OnMemoryPressure() override;
+  void OnBeforePaintTransaction() override;
+  void OnDidPaintTransaction() override;
+  layers::PersistentBufferProvider* GetBufferProvider() override;
+
+  Maybe<layers::SurfaceDescriptor> GetFrontBuffer(
+      WebGLFramebufferJS*, const bool webvr = false) override;
+
+  already_AddRefed<layers::FwdTransactionTracker> UseCompositableForwarder(
+      layers::CompositableForwarder* aForwarder) override;
+
+  void Save();
+  void Restore();
+
+  void Reset() {
+    // reset the rendering context to its default state
+    // Userland polyfill is `c2d.width = c2d.width;`
+    SetDimensions(GetWidth(), GetHeight());
+  }
+
+  void Scale(double aX, double aY, mozilla::ErrorResult& aError);
+  void Rotate(double aAngle, mozilla::ErrorResult& aError);
+  void Translate(double aX, double aY, mozilla::ErrorResult& aError);
+  void Transform(double aM11, double aM12, double aM21, double aM22, double aDx,
+                 double aDy, mozilla::ErrorResult& aError);
+  already_AddRefed<DOMMatrix> GetTransform(mozilla::ErrorResult& aError);
+  void SetTransform(double aM11, double aM12, double aM21, double aM22,
+                    double aDx, double aDy, mozilla::ErrorResult& aError);
+  void SetTransform(const DOMMatrix2DInit& aInit, mozilla::ErrorResult& aError);
+  void ResetTransform(mozilla::ErrorResult& aError);
+
+  double GlobalAlpha() { return CurrentState().globalAlpha; }
+
+  // Useful for silencing cast warnings
+  static mozilla::gfx::Float ToFloat(double aValue) {
+    return mozilla::gfx::Float(aValue);
+  }
+
+  void SetGlobalAlpha(double aGlobalAlpha) {
+    if (aGlobalAlpha >= 0.0 && aGlobalAlpha <= 1.0) {
+      CurrentState().globalAlpha = ToFloat(aGlobalAlpha);
+    }
+  }
+
+  enum class ResolveCurrentColor : bool { No, Yes };
+  Maybe<nscolor> ParseColor(const nsACString&,
+                            ResolveCurrentColor = ResolveCurrentColor::Yes);
+
+  void GetGlobalCompositeOperation(nsAString& aOp,
+                                   mozilla::ErrorResult& aError);
+  void SetGlobalCompositeOperation(const nsAString& aOp,
+                                   mozilla::ErrorResult& aError);
+
+  void GetStrokeStyle(OwningUTF8StringOrCanvasGradientOrCanvasPattern& aValue) {
+    GetStyleAsUnion(aValue, Style::STROKE);
+  }
+
+  void SetStrokeStyle(const UTF8StringOrCanvasGradientOrCanvasPattern& aValue) {
+    SetStyleFromUnion(aValue, Style::STROKE);
+  }
+
+  void GetFillStyle(OwningUTF8StringOrCanvasGradientOrCanvasPattern& aValue) {
+    GetStyleAsUnion(aValue, Style::FILL);
+  }
+
+  void SetFillStyle(const UTF8StringOrCanvasGradientOrCanvasPattern& aValue) {
+    SetStyleFromUnion(aValue, Style::FILL);
+  }
+
+  already_AddRefed<CanvasGradient> CreateLinearGradient(double aX0, double aY0,
+                                                        double aX1, double aY1);
+  already_AddRefed<CanvasGradient> CreateRadialGradient(double aX0, double aY0,
+                                                        double aR0, double aX1,
+                                                        double aY1, double aR1,
+                                                        ErrorResult& aError);
+  already_AddRefed<CanvasGradient> CreateConicGradient(double aAngle,
+                                                       double aCx, double aCy);
+  already_AddRefed<CanvasPattern> CreatePattern(
+      const CanvasImageSource& aElement, const nsAString& aRepeat,
+      ErrorResult& aError);
+
+  double ShadowOffsetX() { return CurrentState().shadowOffset.x; }
+
+  void SetShadowOffsetX(double aShadowOffsetX) {
+    CurrentState().shadowOffset.x = ToFloat(aShadowOffsetX);
+  }
+
+  double ShadowOffsetY() { return CurrentState().shadowOffset.y; }
+
+  void SetShadowOffsetY(double aShadowOffsetY) {
+    CurrentState().shadowOffset.y = ToFloat(aShadowOffsetY);
+  }
+
+  double ShadowBlur() { return CurrentState().shadowBlur; }
+
+  void SetShadowBlur(double aShadowBlur) {
+    if (aShadowBlur >= 0.0) {
+      CurrentState().shadowBlur = ToFloat(aShadowBlur);
+    }
+  }
+
+  void GetShadowColor(nsACString& aShadowColor) {
+    StyleColorToString(CurrentState().shadowColor, aShadowColor);
+  }
+
+  void GetFilter(nsACString& aFilter) { aFilter = CurrentState().filterString; }
+
+  void SetShadowColor(const nsACString& aShadowColor);
+  void SetFilter(const nsACString& aFilter, mozilla::ErrorResult& aError);
+  void ClearRect(double aX, double aY, double aW, double aH);
+  void FillRect(double aX, double aY, double aW, double aH);
+  void StrokeRect(double aX, double aY, double aW, double aH);
+  void BeginPath();
+  void Fill(const CanvasWindingRule& aWinding);
+  void Fill(const CanvasPath& aPath, const CanvasWindingRule& aWinding);
+  void Stroke();
+  void Stroke(const CanvasPath& aPath);
+  void DrawFocusIfNeeded(mozilla::dom::Element& aElement, ErrorResult& aRv);
+  bool DrawCustomFocusRing(mozilla::dom::Element& aElement);
+  void Clip(const CanvasWindingRule& aWinding);
+  void Clip(const CanvasPath& aPath, const CanvasWindingRule& aWinding);
+  bool IsPointInPath(JSContext* aCx, double aX, double aY,
+                     const CanvasWindingRule& aWinding,
+                     nsIPrincipal& aSubjectPrincipal);
+  bool IsPointInPath(JSContext* aCx, const CanvasPath& aPath, double aX,
+                     double aY, const CanvasWindingRule& aWinding,
+                     nsIPrincipal&);
+  bool IsPointInStroke(JSContext* aCx, double aX, double aY,
+                       nsIPrincipal& aSubjectPrincipal);
+  bool IsPointInStroke(JSContext* aCx, const CanvasPath& aPath, double aX,
+                       double aY, nsIPrincipal&);
+  void FillText(const nsAString& aText, double aX, double aY,
+                const Optional<double>& aMaxWidth,
+                mozilla::ErrorResult& aError);
+  void StrokeText(const nsAString& aText, double aX, double aY,
+                  const Optional<double>& aMaxWidth,
+                  mozilla::ErrorResult& aError);
+  UniquePtr<TextMetrics> MeasureText(const nsAString& aRawText,
+                                     mozilla::ErrorResult& aError);
+
+  void DrawImage(const CanvasImageSource& aImage, double aDx, double aDy,
+                 mozilla::ErrorResult& aError) {
+    DrawImage(aImage, 0.0, 0.0, 0.0, 0.0, aDx, aDy, 0.0, 0.0, 0, aError);
+  }
+
+  void DrawImage(const CanvasImageSource& aImage, double aDx, double aDy,
+                 double aDw, double aDh, mozilla::ErrorResult& aError) {
+    DrawImage(aImage, 0.0, 0.0, 0.0, 0.0, aDx, aDy, aDw, aDh, 2, aError);
+  }
+
+  void DrawImage(const CanvasImageSource& aImage, double aSx, double aSy,
+                 double aSw, double aSh, double aDx, double aDy, double aDw,
+                 double aDh, mozilla::ErrorResult& aError) {
+    DrawImage(aImage, aSx, aSy, aSw, aSh, aDx, aDy, aDw, aDh, 6, aError);
+  }
+
+  already_AddRefed<ImageData> CreateImageData(JSContext*, int32_t aSw,
+                                              int32_t aSh, ErrorResult&);
+  already_AddRefed<ImageData> CreateImageData(JSContext*, ImageData&,
+                                              ErrorResult&);
+  already_AddRefed<ImageData> GetImageData(JSContext*, int32_t aSx, int32_t aSy,
+                                           int32_t aSw, int32_t aSh,
+                                           nsIPrincipal& aSubjectPrincipal,
+                                           ErrorResult&);
+  void PutImageData(ImageData&, int32_t aDx, int32_t aDy, ErrorResult&);
+  void PutImageData(ImageData&, int32_t aDx, int32_t aDy, int32_t aDirtyX,
+                    int32_t aDirtyY, int32_t aDirtyWidth, int32_t aDirtyHeight,
+                    ErrorResult&);
+
+  double LineWidth() { return CurrentState().lineWidth; }
+
+  void SetLineWidth(double aWidth) {
+    if (aWidth > 0.0) {
+      CurrentState().lineWidth = ToFloat(aWidth);
+    }
+  }
+
+  CanvasLineCap LineCap() { return CurrentState().lineCap; }
+  void SetLineCap(const CanvasLineCap& aLinecapStyle) {
+    CurrentState().lineCap = aLinecapStyle;
+  }
+
+  CanvasLineJoin LineJoin() { return CurrentState().lineJoin; }
+  void SetLineJoin(const CanvasLineJoin& aLinejoinStyle) {
+    CurrentState().lineJoin = aLinejoinStyle;
+  }
+
+  double MiterLimit() { return CurrentState().miterLimit; }
+
+  void SetMiterLimit(double aMiter) {
+    if (aMiter > 0.0) {
+      CurrentState().miterLimit = ToFloat(aMiter);
+    }
+  }
+
+  void GetFont(nsACString& aFont) { aFont = GetFont(); }
+
+  void SetFont(const nsACString& aFont, mozilla::ErrorResult& aError);
+
+  CanvasTextAlign TextAlign() { return CurrentState().textAlign; }
+  void SetTextAlign(const CanvasTextAlign& aTextAlign) {
+    CurrentState().textAlign = aTextAlign;
+  }
+
+  CanvasTextBaseline TextBaseline() { return CurrentState().textBaseline; }
+  void SetTextBaseline(const CanvasTextBaseline& aTextBaseline) {
+    CurrentState().textBaseline = aTextBaseline;
+  }
+
+  CanvasDirection Direction() { return CurrentState().textDirection; }
+  void SetDirection(const CanvasDirection& aDirection) {
+    CurrentState().textDirection = aDirection;
+  }
+
+  CanvasFontKerning FontKerning() { return CurrentState().fontKerning; }
+  void SetFontKerning(const CanvasFontKerning& aFontKerning) {
+    if (CurrentState().fontKerning != aFontKerning) {
+      CurrentState().fontKerning = aFontKerning;
+      CurrentState().fontGroup = nullptr;
+    }
+  }
+
+  CanvasFontStretch FontStretch() { return CurrentState().fontStretch; }
+  void SetFontStretch(const CanvasFontStretch& aFontStretch) {
+    if (CurrentState().fontStretch != aFontStretch) {
+      CurrentState().fontStretch = aFontStretch;
+      CurrentState().fontGroup = nullptr;
+    }
+  }
+
+  CanvasFontVariantCaps FontVariantCaps() {
+    return CurrentState().fontVariantCaps;
+  }
+  void SetFontVariantCaps(const CanvasFontVariantCaps& aFontVariantCaps) {
+    if (CurrentState().fontVariantCaps != aFontVariantCaps) {
+      CurrentState().fontVariantCaps = aFontVariantCaps;
+      CurrentState().fontGroup = nullptr;
+    }
+  }
+
+  CanvasTextRendering TextRendering() { return CurrentState().textRendering; }
+  void SetTextRendering(const CanvasTextRendering& aTextRendering) {
+    CurrentState().textRendering = aTextRendering;
+  }
+
+  void GetLetterSpacing(nsACString& aLetterSpacing);
+  void SetLetterSpacing(const nsACString& aLetterSpacing);
+  void GetWordSpacing(nsACString& aWordSpacing);
+  void SetWordSpacing(const nsACString& aWordSpacing);
+
+  void EnsureCapped() {
+    if (mPathPruned) {
+      mPathBuilder->LineTo(mPathBuilder->CurrentPoint());
+      mPathPruned = false;
+    }
+  }
+
+  void EnsureActivePath() {
+    if (mPathPruned && !mPathBuilder->IsActive()) {
+      mPathBuilder->MoveTo(mPathBuilder->CurrentPoint());
+      mPathPruned = false;
+    }
+  }
+
+  void ClosePath() {
+    EnsureWritablePath();
+
+    mPathBuilder->Close();
+    mPathPruned = false;
+  }
+
+  void MoveTo(double aX, double aY) {
+    EnsureWritablePath();
+
+    mozilla::gfx::Point pos(ToFloat(aX), ToFloat(aY));
+    if (!pos.IsFinite()) {
+      return;
+    }
+
+    EnsureCapped();
+    mPathBuilder->MoveTo(pos);
+  }
+
+  void LineTo(double aX, double aY) {
+    EnsureWritablePath();
+
+    LineTo(mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
+  }
+
+  void QuadraticCurveTo(double aCpx, double aCpy, double aX, double aY) {
+    EnsureWritablePath();
+
+    mozilla::gfx::Point cp1(ToFloat(aCpx), ToFloat(aCpy));
+    mozilla::gfx::Point cp2(ToFloat(aX), ToFloat(aY));
+    if (!cp1.IsFinite() || !cp2.IsFinite()) {
+      return;
+    }
+
+    if (cp1 == mPathBuilder->CurrentPoint() && cp1 == cp2) {
+      mPathPruned = true;
+      return;
+    }
+    EnsureActivePath();
+    mPathBuilder->QuadraticBezierTo(cp1, cp2);
+    mPathPruned = false;
+  }
+
+  void BezierCurveTo(double aCp1x, double aCp1y, double aCp2x, double aCp2y,
+                     double aX, double aY) {
+    EnsureWritablePath();
+
+    BezierTo(mozilla::gfx::Point(ToFloat(aCp1x), ToFloat(aCp1y)),
+             mozilla::gfx::Point(ToFloat(aCp2x), ToFloat(aCp2y)),
+             mozilla::gfx::Point(ToFloat(aX), ToFloat(aY)));
+  }
+
+  void ArcTo(double aX1, double aY1, double aX2, double aY2, double aRadius,
+             mozilla::ErrorResult& aError);
+  void Rect(double aX, double aY, double aW, double aH);
+  void RoundRect(
+      double aX, double aY, double aW, double aH,
+      const UnrestrictedDoubleOrDOMPointInitOrUnrestrictedDoubleOrDOMPointInitSequence&
+          aRadii,
+      ErrorResult& aError);
+  void Arc(double aX, double aY, double aRadius, double aStartAngle,
+           double aEndAngle, bool aAnticlockwise, mozilla::ErrorResult& aError);
+  void Ellipse(double aX, double aY, double aRadiusX, double aRadiusY,
+               double aRotation, double aStartAngle, double aEndAngle,
+               bool aAnticlockwise, ErrorResult& aError);
+
+  void GetFillRule(nsAString& aFillRule);
+  void SetFillRule(const nsAString& aFillRule);
+
+  void SetLineDash(const Sequence<double>& aSegments,
+                   mozilla::ErrorResult& aRv);
+  void GetLineDash(nsTArray<double>& aSegments) const;
+
+  void SetLineDashOffset(double aOffset);
+  double LineDashOffset() const;
+
+  bool ImageSmoothingEnabled() { return CurrentState().imageSmoothingEnabled; }
+
+  void SetImageSmoothingEnabled(bool aImageSmoothingEnabled) {
+    if (aImageSmoothingEnabled != CurrentState().imageSmoothingEnabled) {
+      CurrentState().imageSmoothingEnabled = aImageSmoothingEnabled;
+    }
+  }
+
+  void DrawWindow(nsGlobalWindowInner& aWindow, double aX, double aY, double aW,
+                  double aH, const nsACString& aBgColor, uint32_t aFlags,
+                  nsIPrincipal& aSubjectPrincipal,
+                  mozilla::ErrorResult& aError);
+
+  // Eventually this should be deprecated. Keeping for now to keep the binding
+  // functional.
+  void Demote();
+
+  nsresult Redraw();
+
+  gfx::IntSize GetSize() const { return gfx::IntSize(mWidth, mHeight); }
+  int32_t GetWidth() override { return GetSize().width; }
+  int32_t GetHeight() override { return GetSize().height; }
+
+  // nsICanvasRenderingContextInternal
+  /**
+   * Gets the pres shell from either the canvas element or the doc shell
+   */
+  PresShell* GetPresShell() final;
+  nsresult Initialize() override;
+  NS_IMETHOD SetDimensions(int32_t aWidth, int32_t aHeight) override;
+  NS_IMETHOD InitializeWithDrawTarget(
+      nsIDocShell* aShell, NotNull<gfx::DrawTarget*> aTarget) override;
+
+  NS_IMETHOD GetInputStream(const char* aMimeType,
+                            const nsAString& aEncoderOptions,
+                            nsIInputStream** aStream) override;
+
+  already_AddRefed<mozilla::gfx::SourceSurface> GetOptimizedSnapshot(
+      mozilla::gfx::DrawTarget* aTarget, gfxAlphaType* aOutAlphaType) override;
+
+  already_AddRefed<mozilla::gfx::SourceSurface> GetSurfaceSnapshot(
+      gfxAlphaType* aOutAlphaType = nullptr) override {
+    return GetOptimizedSnapshot(nullptr, aOutAlphaType);
+  }
+
+  virtual void SetOpaqueValueFromOpaqueAttr(bool aOpaqueAttrValue) override;
+  bool GetIsOpaque() override { return mOpaque; }
+  void ResetBitmap(bool aFreeBuffer);
+  void ResetBitmap() override { ResetBitmap(true); }
+
+  bool UpdateWebRenderCanvasData(nsDisplayListBuilder* aBuilder,
+                                 WebRenderCanvasData* aCanvasData) override;
+
+  bool InitializeCanvasRenderer(nsDisplayListBuilder* aBuilder,
+                                CanvasRenderer* aRenderer) override;
+  void MarkContextClean() override;
+  void MarkContextCleanForFrameCapture() override {
+    mFrameCaptureState = FrameCaptureState::CLEAN;
+  }
+  Watchable<FrameCaptureState>* GetFrameCaptureState() override {
+    return &mFrameCaptureState;
+  }
+  // this rect is in canvas device space
+  void Redraw(const mozilla::gfx::Rect& aR);
+  NS_IMETHOD Redraw(const gfxRect& aR) override {
+    Redraw(ToRect(aR));
+    return NS_OK;
+  }
+  NS_IMETHOD SetContextOptions(JSContext* aCx, JS::Handle<JS::Value> aOptions,
+                               ErrorResult& aRvForDictionaryInit) override;
+
+  /**
+   * An abstract base class to be implemented by callers wanting to be notified
+   * that a refresh has occurred. Callers must ensure an observer is removed
+   * before it is destroyed.
+   */
+  virtual void DidRefresh() override;
+
+  // this rect is in mTarget's current user space
+  void RedrawUser(const gfxRect& aR);
+
+  // nsISupports interface + CC
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+
+  NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS(
+      CanvasRenderingContext2D)
+
+  enum class CanvasMultiGetterType : uint8_t {
+    STRING = 0,
+    PATTERN = 1,
+    GRADIENT = 2
+  };
+
+  enum class Style : uint8_t { STROKE = 0, FILL, MAX };
+
+  void LineTo(const mozilla::gfx::Point& aPoint) {
+    mFeatureUsage |= CanvasFeatureUsage::LineTo;
+
+    if (!aPoint.IsFinite()) {
+      return;
+    }
+    if (mPathBuilder->CurrentPoint() == aPoint) {
+      mPathPruned = true;
+      return;
+    }
+    EnsureActivePath();
+    mPathBuilder->LineTo(aPoint);
+    mPathPruned = false;
+  }
+
+  void BezierTo(const mozilla::gfx::Point& aCP1,
+                const mozilla::gfx::Point& aCP2,
+                const mozilla::gfx::Point& aCP3) {
+    if (!aCP1.IsFinite() || !aCP2.IsFinite() || !aCP3.IsFinite()) {
+      return;
+    }
+
+    if (aCP1 == mPathBuilder->CurrentPoint() && aCP1 == aCP2 && aCP1 == aCP3) {
+      mPathPruned = true;
+      return;
+    }
+    EnsureActivePath();
+    mPathBuilder->BezierTo(aCP1, aCP2, aCP3);
+    mPathPruned = false;
+  }
+
+  virtual UniquePtr<uint8_t[]> GetImageBuffer(
+      int32_t* out_format, gfx::IntSize* out_imageSize) override;
+
+  void OnShutdown();
+
+  /**
+   * Update CurrentState().filter with the filter description for
+   * CurrentState().filterChain.
+   * Flushes the PresShell if aFlushIsNeeded is true, so the world can change
+   * if you call this function.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void UpdateFilter(bool aFlushIfNeeded);
+
+  CanvasFeatureUsage FeatureUsage() const { return mFeatureUsage; }
+
+ protected:
+  /**
+   * Helper to parse a value for the letterSpacing or wordSpacing attribute.
+   * If successful, returns the result in aValue, and the whitespace-normalized
+   * value string in aNormalized; if unsuccessful these are left untouched.
+   */
+  void ParseSpacing(const nsACString& aSpacing, float* aValue,
+                    nsACString& aNormalized);
+
+  already_AddRefed<const ComputedStyle> ResolveStyleForProperty(
+      nsCSSPropertyID aProperty, const nsACString& aValue);
+
+  nsresult GetImageDataArray(JSContext* aCx, int32_t aX, int32_t aY,
+                             uint32_t aWidth, uint32_t aHeight,
+                             nsIPrincipal& aSubjectPrincipal,
+                             JSObject** aRetval);
+
+  void PutImageData_explicit(int32_t aX, int32_t aY, ImageData&,
+                             bool aHasDirtyRect, int32_t aDirtyX,
+                             int32_t aDirtyY, int32_t aDirtyWidth,
+                             int32_t aDirtyHeight, ErrorResult&);
+
+  bool CopyBufferProvider(layers::PersistentBufferProvider& aOld,
+                          gfx::DrawTarget& aTarget, gfx::IntRect aCopyRect);
+
+  /**
+   * Internal method to complete initialisation, expects mTarget to have been
+   * set
+   */
+  nsresult Initialize(int32_t aWidth, int32_t aHeight);
+
+  nsresult InitializeWithTarget(mozilla::gfx::DrawTarget* aSurface,
+                                int32_t aWidth, int32_t aHeight);
+
+  /**
+   * The number of living nsCanvasRenderingContexts.  When this goes down to
+   * 0, we free the premultiply and unpremultiply tables, if they exist.
+   */
+  static MOZ_THREAD_LOCAL(uintptr_t) sNumLivingContexts;
+
+  static MOZ_THREAD_LOCAL(mozilla::gfx::DrawTarget*) sErrorTarget;
+
+  void SetTransformInternal(const mozilla::gfx::Matrix& aTransform);
+
+  // Some helpers.  Doesn't modify a color on failure.
+  void SetStyleFromUnion(
+      const UTF8StringOrCanvasGradientOrCanvasPattern& aValue,
+      Style aWhichStyle);
+  void SetStyleFromString(const nsACString& aStr, Style aWhichStyle);
+
+  void SetStyleFromGradient(CanvasGradient& aGradient, Style aWhichStyle) {
+    CurrentState().SetGradientStyle(aWhichStyle, &aGradient);
+  }
+
+  void SetStyleFromPattern(CanvasPattern& aPattern, Style aWhichStyle) {
+    CurrentState().SetPatternStyle(aWhichStyle, &aPattern);
+  }
+
+  void GetStyleAsUnion(OwningUTF8StringOrCanvasGradientOrCanvasPattern& aValue,
+                       Style aWhichStyle);
+
+  static void StyleColorToString(const nscolor& aColor, nsACString& aStr);
+
+  // Returns whether a filter was successfully parsed.
+  bool ParseFilter(const nsACString& aString,
+                   StyleOwnedSlice<StyleFilter>& aFilterChain,
+                   ErrorResult& aError);
+
+  // Returns whether the font was successfully updated.
+  bool SetFontInternal(const nsACString& aFont, mozilla::ErrorResult& aError);
+
+  // Helper for SetFontInternal in the case where we have no PresShell.
+  bool SetFontInternalDisconnected(const nsACString& aFont,
+                                   mozilla::ErrorResult& aError);
+
+  // Update the resolved values for letterSpacing and wordSpacing, if present,
+  // following a potential change to font-relative dimensions.
+  void UpdateSpacing();
+
+  // Clears the target and updates mOpaque based on mOpaqueAttrValue and
+  // mContextAttributesHasAlpha.
+  void UpdateIsOpaque();
+
+  // Shared implementation for Stroke() and Stroke(CanvasPath) methods.
+  void StrokeImpl(const mozilla::gfx::Path& aPath);
+
+  // Shared implementation for Fill() methods.
+  void FillImpl(const mozilla::gfx::Path& aPath);
+
+  /**
+   * Creates the error target, if it doesn't exist
+   */
+  static void EnsureErrorTarget();
+
+  /* This function ensures there is a writable pathbuilder available
+   */
+  void EnsureWritablePath();
+
+  // Ensures a path in UserSpace is available.
+  void EnsureUserSpacePath(
+      const CanvasWindingRule& aWinding = CanvasWindingRule::Nonzero);
+
+  /**
+   * Needs to be called before updating the transform. This makes a call to
+   * EnsureTarget() so you don't have to.
+   */
+  void TransformCurrentPath(const mozilla::gfx::Matrix& aTransform);
+
+  // Report the fillRule has changed.
+  void FillRuleChanged();
+
+  /**
+   * Create the backing surfacing, if it doesn't exist. If there is an error
+   * in creating the target then it will put sErrorTarget in place. If there
+   * is in turn an error in creating the sErrorTarget then they would both
+   * be null so IsTargetValid() would still return null.
+   *
+   * Returns true on success.
+   */
+  bool EnsureTarget(const gfx::Rect* aCoveredRect = nullptr,
+                    bool aWillClear = false);
+  // Attempt to borrow a new target from an existing buffer provider.
+  bool BorrowTarget(const gfx::IntRect& aPersistedRect, bool aNeedsClear);
+
+  void RestoreClipsAndTransformToTarget();
+
+  bool TryAcceleratedTarget(
+      RefPtr<gfx::DrawTarget>& aOutDT,
+      RefPtr<layers::PersistentBufferProvider>& aOutProvider);
+
+  bool TrySharedTarget(RefPtr<gfx::DrawTarget>& aOutDT,
+                       RefPtr<layers::PersistentBufferProvider>& aOutProvider);
+
+  bool TryBasicTarget(RefPtr<gfx::DrawTarget>& aOutDT,
+                      RefPtr<layers::PersistentBufferProvider>& aOutProvider);
+
+  void RegisterAllocation();
+
+  void SetInitialState();
+
+  void SetErrorState();
+
+  /**
+   * This method is run at the end of the event-loop spin where
+   * ScheduleStableStateCallback was called.
+   *
+   * We use it to unlock resources that need to be locked while drawing.
+   */
+  void OnStableState();
+
+  /**
+   * Cf. OnStableState.
+   */
+  void ScheduleStableStateCallback();
+
+  /**
+   * Disposes an old target and prepares to lazily create a new target.
+   *
+   * Parameters are the new dimensions to be used, or if either is negative,
+   * existing dimensions will be left unchanged.
+   */
+  void ClearTarget(int32_t aWidth = -1, int32_t aHeight = -1);
+
+  /*
+   * Returns the target to the buffer provider. i.e. this will queue a frame for
+   * rendering.
+   */
+  void ReturnTarget(bool aForceReset = false);
+
+  /**
+   * Check if the target is valid after calling EnsureTarget.
+   */
+  bool IsTargetValid() const {
+    return !!mTarget && mTarget != sErrorTarget.get();
+  }
+
+  /**
+   * Returns the surface format this canvas should be allocated using. Takes
+   * into account mOpaque, platform requirements, etc.
+   */
+  mozilla::gfx::SurfaceFormat GetSurfaceFormat() const;
+
+  /**
+   * Returns true if we know for sure that the pattern for a given style is
+   * opaque. Usefull to know if we can discard the content below in certain
+   * situations. Optionally checks if the pattern is a color pattern.
+   */
+  bool PatternIsOpaque(Style aStyle, bool* aIsColor = nullptr) const;
+
+  SurfaceFromElementResult CachedSurfaceFromElement(Element* aElement);
+
+  void DrawImage(const CanvasImageSource& aImgElt, double aSx, double aSy,
+                 double aSw, double aSh, double aDx, double aDy, double aDw,
+                 double aDh, uint8_t aOptional_argc,
+                 mozilla::ErrorResult& aError);
+
+  void DrawDirectlyToCanvas(const DirectDrawInfo& aImage,
+                            mozilla::gfx::Rect* aBounds,
+                            mozilla::gfx::Rect aDest, mozilla::gfx::Rect aSrc,
+                            gfx::IntSize aImgSize);
+
+  nsCString& GetFont() {
+    /* will initilize the value if not set, else does nothing */
+    GetCurrentFontStyle();
+
+    return CurrentState().font;
+  }
+
+  bool GetEffectiveWillReadFrequently() const;
+
+  // Member vars
+  int32_t mWidth, mHeight;
+
+  // This is true when the canvas is valid, but of zero size, this requires
+  // specific behavior on some operations.
+  bool mZero;
+
+  // The two ways to set the opaqueness of the canvas.
+  // mOpaqueAttrValue: Whether the <canvas> element has the moz-opaque attribute
+  // set. Can change during the lifetime of the context. Non-standard, should
+  // hopefully go away soon.
+  // mContextAttributesHasAlpha: The standard way of setting canvas opaqueness.
+  // Set at context initialization time and never changes.
+  bool mOpaqueAttrValue;
+  bool mContextAttributesHasAlpha;
+
+  // Determines the context's opaqueness. Is computed from mOpaqueAttrValue and
+  // mContextAttributesHasAlpha in UpdateIsOpaque().
+  bool mOpaque;
+
+  // This is true when the next time our layer is retrieved we need to
+  // recreate it (i.e. our backing surface changed)
+  bool mResetLayer;
+  // This is needed for drawing in drawAsyncXULElement
+  bool mIPC;
+
+  bool mHasPendingStableStateCallback;
+
+  // If mCanvasElement is not provided, then a docshell is
+  nsCOMPtr<nsIDocShell> mDocShell;
+
+  // This is created lazily so it is necessary to call EnsureTarget before
+  // accessing it. In the event of an error it will be equal to
+  // sErrorTarget.
+  RefPtr<mozilla::gfx::DrawTarget> mTarget;
+
+  RefPtr<mozilla::layers::PersistentBufferProvider> mBufferProvider;
+  bool mBufferNeedsClear = false;
+
+  // Whether we should try to create an accelerated buffer provider.
+  bool mAllowAcceleration = true;
+  // Whether the application expects to use operations that perform poorly with
+  // acceleration.
+  bool mWillReadFrequently = false;
+  // Whether or not we have already shutdown.
+  bool mHasShutdown = false;
+
+  RefPtr<CanvasShutdownObserver> mShutdownObserver;
+  bool AddShutdownObserver();
+  void RemoveShutdownObserver();
+  bool AlreadyShutDown() const { return mHasShutdown; }
+
+  /**
+   * Flag to avoid duplicate calls to InvalidateFrame. Set to true whenever
+   * Redraw is called, reset to false when Render is called.
+   */
+  bool mIsEntireFrameInvalid;
+  /**
+   * When this is set, the first call to Redraw(gfxRect) should set
+   * mIsEntireFrameInvalid since we expect it will be followed by
+   * many more Redraw calls.
+   */
+  bool mPredictManyRedrawCalls;
+
+  /**
+   * Flag to avoid unnecessary surface copies to FrameCaptureListeners in the
+   * case when the canvas is not currently being drawn into and not rendered
+   * but canvas capturing is still ongoing.
+   */
+  Watchable<FrameCaptureState> mFrameCaptureState;
+
+  /**
+   * We also have a device space pathbuilder. The reason for this is as
+   * follows, when a path is being built, but the transform changes, we
+   * can no longer keep a single path in userspace, considering there's
+   * several 'user spaces' now. We therefore transform the current path
+   * into device space, and add all operations to this path in device
+   * space.
+   *
+   * When then finally executing a render, the Azure drawing API expects
+   * the path to be in userspace. We could then set an identity transform
+   * on the DrawTarget and do all drawing in device space. This is
+   * undesirable because it requires transforming patterns, gradients,
+   * clips, etc. into device space and it would not work for stroking.
+   * What we do instead is convert the path back to user space when it is
+   * drawn, and draw it with the current transform. This makes all drawing
+   * occur correctly.
+   *
+   * There's never both a device space path builder and a user space path
+   * builder present at the same time. There is also never a path and a
+   * path builder present at the same time. When writing proceeds on an
+   * existing path the Path is cleared and a new builder is created.
+   *
+   * mPath is always in user-space.
+   */
+  RefPtr<mozilla::gfx::Path> mPath;
+  RefPtr<mozilla::gfx::PathBuilder> mPathBuilder;
+  bool mPathPruned = false;
+  mozilla::gfx::Matrix mPathTransform;
+  bool mPathTransformDirty = false;
+
+  void FlushPathTransform();
+
+  /**
+   * Number of times we've invalidated before calling redraw
+   */
+  uint32_t mInvalidateCount;
+  static const uint32_t kCanvasMaxInvalidateCount = 100;
+
+  mozilla::intl::Bidi mBidiEngine;
+
+  /**
+   * Returns true if a shadow should be drawn along with a
+   * drawing operation.
+   */
+  bool NeedToDrawShadow() {
+    const ContextState& state = CurrentState();
+
+    // The spec says we should not draw shadows if the operator is OVER.
+    // If it's over and the alpha value is zero, nothing needs to be drawn.
+    return NS_GET_A(state.shadowColor) != 0 &&
+           (state.shadowBlur != 0.f || state.shadowOffset.x != 0.f ||
+            state.shadowOffset.y != 0.f);
+  }
+
+  /**
+   * Returns true if the result of a drawing operation should be
+   * drawn with a filter.
+   */
+  bool NeedToApplyFilter() {
+    return EnsureUpdatedFilter().mPrimitives.Length() > 0;
+  }
+
+  /**
+   * Calls UpdateFilter if the canvas's WriteOnly state has changed between the
+   * last call to UpdateFilter and now.
+   */
+  const gfx::FilterDescription& EnsureUpdatedFilter() {
+    bool isWriteOnly = mCanvasElement && mCanvasElement->IsWriteOnly();
+    if (CurrentState().filterSourceGraphicTainted != isWriteOnly) {
+      UpdateFilter(/* aFlushIfNeeded = */ true);
+      EnsureTarget();
+    }
+    MOZ_ASSERT(CurrentState().filterSourceGraphicTainted == isWriteOnly);
+    return CurrentState().filter;
+  }
+
+  bool NeedToCalculateBounds() {
+    return NeedToDrawShadow() || NeedToApplyFilter();
+  }
+
+  // text
+
+ public:
+  gfxFontGroup* GetCurrentFontStyle();
+
+ protected:
+  enum class TextDrawOperation : uint8_t { FILL, STROKE, MEASURE };
+
+  /**
+   * Implementation of the fillText, strokeText, and measure functions with
+   * the operation abstracted to a flag.
+   * Returns a TextMetrics object _only_ if the operation is measure;
+   * drawing operations (fill or stroke) always return nullptr.
+   */
+  UniquePtr<TextMetrics> DrawOrMeasureText(const nsAString& aText, float aX,
+                                           float aY,
+                                           const Optional<double>& aMaxWidth,
+                                           TextDrawOperation aOp,
+                                           ErrorResult& aError);
+
+  // A clip or a transform, recorded and restored in order.
+  struct ClipState {
+    explicit ClipState(mozilla::gfx::Path* aClip) : clip(aClip) {}
+
+    explicit ClipState(const mozilla::gfx::Matrix& aTransform)
+        : transform(aTransform) {}
+
+    bool IsClip() const { return !!clip; }
+
+    RefPtr<mozilla::gfx::Path> clip;
+    mozilla::gfx::Matrix transform;
+  };
+
+  // state stack handling
+  class ContextState {
+   public:
+    ContextState();
+    ContextState(const ContextState& aOther);
+    ~ContextState();
+
+    void SetColorStyle(Style aWhichStyle, nscolor aColor);
+    void SetPatternStyle(Style aWhichStyle, CanvasPattern* aPat);
+    void SetGradientStyle(Style aWhichStyle, CanvasGradient* aGrad);
+
+    /**
+     * returns true iff the given style is a solid color.
+     */
+    bool StyleIsColor(Style aWhichStyle) const {
+      return !(patternStyles[aWhichStyle] || gradientStyles[aWhichStyle]);
+    }
+
+    int32_t ShadowBlurRadius() const {
+      static const gfxFloat GAUSSIAN_SCALE_FACTOR =
+          (3 * sqrt(2 * M_PI) / 4) * 1.5;
+      return (int32_t)floor(ShadowBlurSigma() * GAUSSIAN_SCALE_FACTOR + 0.5);
+    }
+
+    mozilla::gfx::Float ShadowBlurSigma() const {
+      return std::min(SIGMA_MAX, shadowBlur / 2.0f);
+    }
+
+    ElementOrArray<ClipState> clipsAndTransforms;
+
+    RefPtr<gfxFontGroup> fontGroup;
+    RefPtr<nsAtom> fontLanguage;
+    nsFont fontFont;
+
+    EnumeratedArray<Style, Style::MAX, RefPtr<CanvasGradient>> gradientStyles;
+    EnumeratedArray<Style, Style::MAX, RefPtr<CanvasPattern>> patternStyles;
+    EnumeratedArray<Style, Style::MAX, nscolor> colorStyles;
+
+    nsCString font;
+    CanvasTextAlign textAlign = CanvasTextAlign::Start;
+    CanvasTextBaseline textBaseline = CanvasTextBaseline::Alphabetic;
+    CanvasDirection textDirection = CanvasDirection::Inherit;
+    CanvasFontKerning fontKerning = CanvasFontKerning::Auto;
+    CanvasFontStretch fontStretch = CanvasFontStretch::Normal;
+    CanvasFontVariantCaps fontVariantCaps = CanvasFontVariantCaps::Normal;
+    CanvasTextRendering textRendering = CanvasTextRendering::Auto;
+
+    gfx::Float letterSpacing = 0.0f;
+    gfx::Float wordSpacing = 0.0f;
+    nsCString letterSpacingStr;
+    nsCString wordSpacingStr;
+
+    nscolor shadowColor = 0;
+
+    mozilla::gfx::Matrix transform;
+    mozilla::gfx::Point shadowOffset;
+    mozilla::gfx::Float lineWidth = 1.0f;
+    mozilla::gfx::Float miterLimit = 10.0f;
+    mozilla::gfx::Float globalAlpha = 1.0f;
+    mozilla::gfx::Float shadowBlur = 0.0f;
+
+    nsTArray<mozilla::gfx::Float> dash;
+    mozilla::gfx::Float dashOffset = 0.0f;
+
+    mozilla::gfx::CompositionOp op = mozilla::gfx::CompositionOp::OP_OVER;
+    mozilla::gfx::FillRule fillRule = mozilla::gfx::FillRule::FILL_WINDING;
+    CanvasLineCap lineCap = CanvasLineCap::Butt;
+    CanvasLineJoin lineJoin = CanvasLineJoin::Miter;
+
+    nsCString filterString{"none"};
+    StyleOwnedSlice<StyleFilter> filterChain;
+    // RAII object that we obtain when we start to observer SVG filter elements
+    // for rendering changes.  When released we stop observing the SVG elements.
+    nsCOMPtr<nsISupports> autoSVGFiltersObserver;
+    mozilla::gfx::FilterDescription filter;
+    nsTArray<RefPtr<mozilla::gfx::SourceSurface>> filterAdditionalImages;
+
+    // This keeps track of whether the canvas was "tainted" or not when
+    // we last used a filter. This is a security measure, whereby the
+    // canvas is flipped to write-only if a cross-origin image is drawn to it.
+    // This is to stop bad actors from reading back data they shouldn't have
+    // access to.
+    //
+    // This also limits what filters we can apply to the context; in particular
+    // feDisplacementMap is restricted.
+    //
+    // We keep track of this to ensure that if this gets out of sync with the
+    // tainted state of the canvas itself, we update our filters accordingly.
+    bool filterSourceGraphicTainted = false;
+
+    bool imageSmoothingEnabled = true;
+    bool fontExplicitLanguage = false;
+  };
+
+  AutoTArray<ContextState, 3> mStyleStack;
+
+  inline ContextState& CurrentState() {
+    return mStyleStack[mStyleStack.Length() - 1];
+  }
+
+  inline const ContextState& CurrentState() const {
+    return mStyleStack[mStyleStack.Length() - 1];
+  }
+
+  struct FontStyleCacheKey {
+    FontStyleCacheKey() = default;
+    FontStyleCacheKey(const nsACString& aFont, uint64_t aGeneration)
+        : mFont(aFont), mGeneration(aGeneration) {}
+    nsCString mFont;
+    uint64_t mGeneration = 0;
+  };
+
+  struct FontStyleData {
+    FontStyleCacheKey mKey;
+    nsCString mUsedFont;
+    RefPtr<const ComputedStyle> mStyle;
+  };
+
+  class FontStyleCache
+      : public MruCache<FontStyleCacheKey, FontStyleData, FontStyleCache> {
+   public:
+    static HashNumber Hash(const FontStyleCacheKey& aKey) {
+      HashNumber hash = HashString(aKey.mFont);
+      return AddToHash(hash, aKey.mGeneration);
+    }
+    static bool Match(const FontStyleCacheKey& aKey,
+                      const FontStyleData& aVal) {
+      return aVal.mKey.mGeneration == aKey.mGeneration &&
+             aVal.mKey.mFont == aKey.mFont;
+    }
+  };
+
+  FontStyleCache mFontStyleCache;
+
+  struct ColorStyleCacheEntry {
+    nsCString mKey;
+    Maybe<nscolor> mColor;
+    bool mWasCurrentColor = false;
+  };
+  class ColorStyleCache
+      : public MruCache<nsACString, ColorStyleCacheEntry, ColorStyleCache> {
+   public:
+    static HashNumber Hash(const nsACString& aKey) { return HashString(aKey); }
+    static bool Match(const nsACString& aKey,
+                      const ColorStyleCacheEntry& aVal) {
+      return aVal.mKey == aKey;
+    }
+  };
+  ColorStyleCache mColorStyleCache;
+
+  ColorStyleCacheEntry ParseColorSlow(const nsACString&);
+
+  mozilla::gfx::PaletteCache mPaletteCache;
+
+  friend class CanvasGeneralPattern;
+  friend class AdjustedTarget;
+  friend class AdjustedTargetForShadow;
+  friend class AdjustedTargetForFilter;
+
+  // other helpers
+  void GetAppUnitsValues(int32_t* aPerDevPixel, int32_t* aPerCSSPixel);
+
+  friend struct CanvasBidiProcessor;
+  friend class CanvasDrawObserver;
+  friend class ImageBitmap;
+
+  void SetWriteOnly();
+
+  bool IsWriteOnly() const { return mWriteOnly; }
+
+  bool mWriteOnly;
+  bool mClipsNeedConverting = false;
+
+  uint8_t mFillTextCalls = 0;
+  // Flags used by the fingerprinting detection heuristic
+  CanvasFeatureUsage mFeatureUsage = CanvasFeatureUsage::None;
+
+  virtual void AddZoneWaitingForGC();
+  virtual void AddAssociatedMemory();
+  virtual void RemoveAssociatedMemory();
+};
+
+size_t BindingJSObjectMallocBytes(CanvasRenderingContext2D* aContext);
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* CanvasRenderingContext2D_h */