1 files changed, 997 insertions, 0 deletions
diff --git a/gfx/2d/DrawCommands.h b/gfx/2d/DrawCommands.h
new file mode 100644
index 0000000000..23db4c9be1
--- /dev/null
+++ b/gfx/2d/DrawCommands.h
@@ -0,0 +1,997 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 MOZILLA_GFX_DRAWCOMMANDS_H_
+#define MOZILLA_GFX_DRAWCOMMANDS_H_
+
+#include <math.h>
+
+#include "2D.h"
+#include "Blur.h"
+#include "Filters.h"
+#include <vector>
+#include "CaptureCommandList.h"
+#include "DrawCommand.h"
+#include "FilterNodeCapture.h"
+#include "Logging.h"
+#include "nsRegion.h"
+
+namespace mozilla {
+namespace gfx {
+
+#define CLONE_INTO(Type) new (aList->Append<Type>()) Type
+
+class StrokeOptionsCommand : public DrawingCommand {
+ public:
+  StrokeOptionsCommand(const StrokeOptions& aStrokeOptions)
+      : mStrokeOptions(aStrokeOptions) {
+    // Stroke Options dashes are owned by the caller.
+    // Have to copy them here so they don't get freed
+    // between now and replay.
+    if (aStrokeOptions.mDashLength) {
+      mDashes.resize(aStrokeOptions.mDashLength);
+      mStrokeOptions.mDashPattern = &mDashes.front();
+      PodCopy(&mDashes.front(), aStrokeOptions.mDashPattern,
+              mStrokeOptions.mDashLength);
+    }
+  }
+
+  virtual ~StrokeOptionsCommand() = default;
+
+ protected:
+  StrokeOptions mStrokeOptions;
+  std::vector<Float> mDashes;
+};
+
+class StoredPattern {
+ public:
+  explicit StoredPattern(const Pattern& aPattern) { Assign(aPattern); }
+
+  void Assign(const Pattern& aPattern) {
+    switch (aPattern.GetType()) {
+      case PatternType::COLOR:
+        new (mColor) ColorPattern(*static_cast<const ColorPattern*>(&aPattern));
+        return;
+      case PatternType::SURFACE: {
+        SurfacePattern* surfPat = new (mSurface)
+            SurfacePattern(*static_cast<const SurfacePattern*>(&aPattern));
+        surfPat->mSurface->GuaranteePersistance();
+        return;
+      }
+      case PatternType::LINEAR_GRADIENT:
+        new (mLinear) LinearGradientPattern(
+            *static_cast<const LinearGradientPattern*>(&aPattern));
+        return;
+      case PatternType::RADIAL_GRADIENT:
+        new (mRadial) RadialGradientPattern(
+            *static_cast<const RadialGradientPattern*>(&aPattern));
+        return;
+      case PatternType::CONIC_GRADIENT:
+        new (mConic) ConicGradientPattern(
+            *static_cast<const ConicGradientPattern*>(&aPattern));
+        return;
+    }
+  }
+
+  ~StoredPattern() { reinterpret_cast<Pattern*>(mPattern)->~Pattern(); }
+
+  Pattern* Get() { return reinterpret_cast<Pattern*>(mPattern); }
+
+  const Pattern* Get() const {
+    return reinterpret_cast<const Pattern*>(mPattern);
+  }
+
+  operator Pattern&() { return *reinterpret_cast<Pattern*>(mPattern); }
+
+  operator const Pattern&() const {
+    return *reinterpret_cast<const Pattern*>(mPattern);
+  }
+
+  StoredPattern(const StoredPattern& aPattern) { Assign(aPattern); }
+
+ private:
+  StoredPattern operator=(const StoredPattern& aOther) {
+    // Block this so that we notice if someone's doing excessive assigning.
+    return *this;
+  }
+
+  union {
+    char mPattern[sizeof(Pattern)];
+    char mColor[sizeof(ColorPattern)];
+    char mLinear[sizeof(LinearGradientPattern)];
+    char mRadial[sizeof(RadialGradientPattern)];
+    char mConic[sizeof(ConicGradientPattern)];
+    char mSurface[sizeof(SurfacePattern)];
+  };
+};
+
+class DrawSurfaceCommand : public DrawingCommand {
+ public:
+  DrawSurfaceCommand(SourceSurface* aSurface, const Rect& aDest,
+                     const Rect& aSource,
+                     const DrawSurfaceOptions& aSurfOptions,
+                     const DrawOptions& aOptions)
+      : mSurface(aSurface),
+        mDest(aDest),
+        mSource(aSource),
+        mSurfOptions(aSurfOptions),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return DrawSurfaceCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(DrawSurfaceCommand)
+    (mSurface, mDest, mSource, mSurfOptions, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->DrawSurface(mSurface, mDest, mSource, mSurfOptions, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[DrawSurface surf=" << mSurface;
+    aStream << " dest=" << mDest;
+    aStream << " src=" << mSource;
+    aStream << " surfOpt=" << mSurfOptions;
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::DRAWSURFACE;
+
+ private:
+  RefPtr<SourceSurface> mSurface;
+  Rect mDest;
+  Rect mSource;
+  DrawSurfaceOptions mSurfOptions;
+  DrawOptions mOptions;
+};
+
+class DrawSurfaceWithShadowCommand : public DrawingCommand {
+ public:
+  DrawSurfaceWithShadowCommand(SourceSurface* aSurface, const Point& aDest,
+                               const DeviceColor& aColor, const Point& aOffset,
+                               Float aSigma, CompositionOp aOperator)
+      : mSurface(aSurface),
+        mDest(aDest),
+        mColor(aColor),
+        mOffset(aOffset),
+        mSigma(aSigma),
+        mOperator(aOperator) {}
+
+  CommandType GetType() const override {
+    return DrawSurfaceWithShadowCommand::Type;
+  }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(DrawSurfaceWithShadowCommand)
+    (mSurface, mDest, mColor, mOffset, mSigma, mOperator);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->DrawSurfaceWithShadow(mSurface, mDest, mColor, mOffset, mSigma,
+                               mOperator);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[DrawSurfaceWithShadow surf=" << mSurface;
+    aStream << " dest=" << mDest;
+    aStream << " color=" << mColor;
+    aStream << " offset=" << mOffset;
+    aStream << " sigma=" << mSigma;
+    aStream << " op=" << mOperator;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::DRAWSURFACEWITHSHADOW;
+
+ private:
+  RefPtr<SourceSurface> mSurface;
+  Point mDest;
+  DeviceColor mColor;
+  Point mOffset;
+  Float mSigma;
+  CompositionOp mOperator;
+};
+
+class DrawFilterCommand : public DrawingCommand {
+ public:
+  DrawFilterCommand(FilterNode* aFilter, const Rect& aSourceRect,
+                    const Point& aDestPoint, const DrawOptions& aOptions)
+      : mFilter(aFilter),
+        mSourceRect(aSourceRect),
+        mDestPoint(aDestPoint),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return DrawFilterCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(DrawFilterCommand)(mFilter, mSourceRect, mDestPoint, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    RefPtr<FilterNode> filter = mFilter;
+    if (mFilter->GetBackendType() == FilterBackend::FILTER_BACKEND_CAPTURE) {
+      filter = static_cast<FilterNodeCapture*>(filter.get())->Validate(aDT);
+
+      // This can happen if the FilterNodeCapture is unable to create a
+      // backing FilterNode on the target backend. Normally this would be
+      // handled by the painting code, but here there's not much we can do.
+      if (!filter) {
+        return;
+      }
+    }
+    aDT->DrawFilter(filter, mSourceRect, mDestPoint, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[DrawFilter surf=" << mFilter;
+    aStream << " src=" << mSourceRect;
+    aStream << " dest=" << mDestPoint;
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::DRAWFILTER;
+
+ private:
+  RefPtr<FilterNode> mFilter;
+  Rect mSourceRect;
+  Point mDestPoint;
+  DrawOptions mOptions;
+};
+
+class ClearRectCommand : public DrawingCommand {
+ public:
+  explicit ClearRectCommand(const Rect& aRect) : mRect(aRect) {}
+
+  CommandType GetType() const override { return ClearRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(ClearRectCommand)(mRect);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->ClearRect(mRect);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[ClearRect rect=" << mRect << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::CLEARRECT;
+
+ private:
+  Rect mRect;
+};
+
+class CopySurfaceCommand : public DrawingCommand {
+ public:
+  CopySurfaceCommand(SourceSurface* aSurface, const IntRect& aSourceRect,
+                     const IntPoint& aDestination)
+      : mSurface(aSurface),
+        mSourceRect(aSourceRect),
+        mDestination(aDestination) {}
+
+  CommandType GetType() const override { return CopySurfaceCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(CopySurfaceCommand)(mSurface, mSourceRect, mDestination);
+  }
+
+  virtual void ExecuteOnDT(DrawTarget* aDT,
+                           const Matrix* aTransform) const override {
+    MOZ_ASSERT(!aTransform || !aTransform->HasNonIntegerTranslation());
+    Point dest(Float(mDestination.x), Float(mDestination.y));
+    if (aTransform) {
+      dest = aTransform->TransformPoint(dest);
+    }
+    aDT->CopySurface(mSurface, mSourceRect,
+                     IntPoint(uint32_t(dest.x), uint32_t(dest.y)));
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[CopySurface surf=" << mSurface;
+    aStream << " src=" << mSourceRect;
+    aStream << " dest=" << mDestination;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::COPYSURFACE;
+
+ private:
+  RefPtr<SourceSurface> mSurface;
+  IntRect mSourceRect;
+  IntPoint mDestination;
+};
+
+class CopyRectCommand : public DrawingCommand {
+ public:
+  CopyRectCommand(const IntRect& aSourceRect, const IntPoint& aDestination)
+      : mSourceRect(aSourceRect), mDestination(aDestination) {}
+
+  CommandType GetType() const override { return CopyRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(CopyRectCommand)(mSourceRect, mDestination);
+  }
+
+  virtual void ExecuteOnDT(DrawTarget* aDT,
+                           const Matrix* aTransform) const override {
+    aDT->CopyRect(mSourceRect, mDestination);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[CopyRect src=" << mSourceRect;
+    aStream << " dest=" << mDestination;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::COPYRECT;
+
+ private:
+  IntRect mSourceRect;
+  IntPoint mDestination;
+};
+
+class FillRectCommand : public DrawingCommand {
+ public:
+  FillRectCommand(const Rect& aRect, const Pattern& aPattern,
+                  const DrawOptions& aOptions)
+      : mRect(aRect), mPattern(aPattern), mOptions(aOptions) {}
+
+  CommandType GetType() const override { return FillRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(FillRectCommand)(mRect, mPattern, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->FillRect(mRect, mPattern, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[FillRect rect=" << mRect;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::FILLRECT;
+
+ private:
+  Rect mRect;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class FillRoundedRectCommand : public DrawingCommand {
+ public:
+  FillRoundedRectCommand(const RoundedRect& aRect, const Pattern& aPattern,
+                         const DrawOptions& aOptions)
+      : mRect(aRect), mPattern(aPattern), mOptions(aOptions) {}
+
+  CommandType GetType() const override { return FillRoundedRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(FillRoundedRectCommand)(mRect, mPattern, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->FillRoundedRect(mRect, mPattern, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[FillRoundedRect rect=" << mRect.rect;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::FILLROUNDEDRECT;
+
+ private:
+  RoundedRect mRect;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class StrokeRectCommand : public StrokeOptionsCommand {
+ public:
+  StrokeRectCommand(const Rect& aRect, const Pattern& aPattern,
+                    const StrokeOptions& aStrokeOptions,
+                    const DrawOptions& aOptions)
+      : StrokeOptionsCommand(aStrokeOptions),
+        mRect(aRect),
+        mPattern(aPattern),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return StrokeRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(StrokeRectCommand)(mRect, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->StrokeRect(mRect, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[StrokeRect rect=" << mRect;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::STROKERECT;
+
+ private:
+  Rect mRect;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class StrokeLineCommand : public StrokeOptionsCommand {
+ public:
+  StrokeLineCommand(const Point& aStart, const Point& aEnd,
+                    const Pattern& aPattern,
+                    const StrokeOptions& aStrokeOptions,
+                    const DrawOptions& aOptions)
+      : StrokeOptionsCommand(aStrokeOptions),
+        mStart(aStart),
+        mEnd(aEnd),
+        mPattern(aPattern),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return StrokeLineCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(StrokeLineCommand)
+    (mStart, mEnd, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->StrokeLine(mStart, mEnd, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[StrokeLine start=" << mStart;
+    aStream << " end=" << mEnd;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::STROKELINE;
+
+ private:
+  Point mStart;
+  Point mEnd;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class FillCommand : public DrawingCommand {
+ public:
+  FillCommand(const Path* aPath, const Pattern& aPattern,
+              const DrawOptions& aOptions)
+      : mPath(const_cast<Path*>(aPath)),
+        mPattern(aPattern),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return FillCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(FillCommand)(mPath, mPattern, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->Fill(mPath, mPattern, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[FillCommand path=" << mPath;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::FILL;
+
+ private:
+  RefPtr<Path> mPath;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class StrokeCommand : public StrokeOptionsCommand {
+ public:
+  StrokeCommand(const Path* aPath, const Pattern& aPattern,
+                const StrokeOptions& aStrokeOptions,
+                const DrawOptions& aOptions)
+      : StrokeOptionsCommand(aStrokeOptions),
+        mPath(const_cast<Path*>(aPath)),
+        mPattern(aPattern),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return StrokeCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(StrokeCommand)(mPath, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->Stroke(mPath, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[Stroke path=" << mPath;
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::STROKE;
+
+ private:
+  RefPtr<Path> mPath;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class FillGlyphsCommand : public DrawingCommand {
+  friend class DrawTargetCaptureImpl;
+
+ public:
+  FillGlyphsCommand(ScaledFont* aFont, const GlyphBuffer& aBuffer,
+                    const Pattern& aPattern, const DrawOptions& aOptions)
+      : mFont(aFont), mPattern(aPattern), mOptions(aOptions) {
+    mGlyphs.resize(aBuffer.mNumGlyphs);
+    memcpy(&mGlyphs.front(), aBuffer.mGlyphs,
+           sizeof(Glyph) * aBuffer.mNumGlyphs);
+  }
+
+  CommandType GetType() const override { return FillGlyphsCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    GlyphBuffer glyphs = {
+        mGlyphs.data(),
+        (uint32_t)mGlyphs.size(),
+    };
+    CLONE_INTO(FillGlyphsCommand)(mFont, glyphs, mPattern, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    GlyphBuffer buf;
+    buf.mNumGlyphs = mGlyphs.size();
+    buf.mGlyphs = &mGlyphs.front();
+    aDT->FillGlyphs(mFont, buf, mPattern, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[FillGlyphs font=" << mFont;
+    aStream << " glyphCount=" << mGlyphs.size();
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::FILLGLYPHS;
+
+ private:
+  RefPtr<ScaledFont> mFont;
+  std::vector<Glyph> mGlyphs;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class StrokeGlyphsCommand : public StrokeOptionsCommand {
+  friend class DrawTargetCaptureImpl;
+
+ public:
+  StrokeGlyphsCommand(ScaledFont* aFont, const GlyphBuffer& aBuffer,
+                      const Pattern& aPattern,
+                      const StrokeOptions& aStrokeOptions,
+                      const DrawOptions& aOptions)
+      : StrokeOptionsCommand(aStrokeOptions),
+        mFont(aFont),
+        mPattern(aPattern),
+        mOptions(aOptions) {
+    mGlyphs.resize(aBuffer.mNumGlyphs);
+    memcpy(&mGlyphs.front(), aBuffer.mGlyphs,
+           sizeof(Glyph) * aBuffer.mNumGlyphs);
+  }
+
+  CommandType GetType() const override { return StrokeGlyphsCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    GlyphBuffer glyphs = {
+        mGlyphs.data(),
+        (uint32_t)mGlyphs.size(),
+    };
+    CLONE_INTO(StrokeGlyphsCommand)
+    (mFont, glyphs, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    GlyphBuffer buf;
+    buf.mNumGlyphs = mGlyphs.size();
+    buf.mGlyphs = &mGlyphs.front();
+    aDT->StrokeGlyphs(mFont, buf, mPattern, mStrokeOptions, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[StrokeGlyphs font=" << mFont;
+    aStream << " glyphCount=" << mGlyphs.size();
+    aStream << " pattern=" << mPattern.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::STROKEGLYPHS;
+
+ private:
+  RefPtr<ScaledFont> mFont;
+  std::vector<Glyph> mGlyphs;
+  StoredPattern mPattern;
+  DrawOptions mOptions;
+};
+
+class MaskCommand : public DrawingCommand {
+ public:
+  MaskCommand(const Pattern& aSource, const Pattern& aMask,
+              const DrawOptions& aOptions)
+      : mSource(aSource), mMask(aMask), mOptions(aOptions) {}
+
+  CommandType GetType() const override { return MaskCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(MaskCommand)(mSource, mMask, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->Mask(mSource, mMask, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[Mask source=" << mSource.Get();
+    aStream << " mask=" << mMask.Get();
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::MASK;
+
+ private:
+  StoredPattern mSource;
+  StoredPattern mMask;
+  DrawOptions mOptions;
+};
+
+class MaskSurfaceCommand : public DrawingCommand {
+ public:
+  MaskSurfaceCommand(const Pattern& aSource, const SourceSurface* aMask,
+                     const Point& aOffset, const DrawOptions& aOptions)
+      : mSource(aSource),
+        mMask(const_cast<SourceSurface*>(aMask)),
+        mOffset(aOffset),
+        mOptions(aOptions) {}
+
+  CommandType GetType() const override { return MaskSurfaceCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(MaskSurfaceCommand)(mSource, mMask, mOffset, mOptions);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->MaskSurface(mSource, mMask, mOffset, mOptions);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[Mask source=" << mSource.Get();
+    aStream << " mask=" << mMask;
+    aStream << " offset=" << &mOffset;
+    aStream << " opt=" << mOptions;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::MASKSURFACE;
+
+ private:
+  StoredPattern mSource;
+  RefPtr<SourceSurface> mMask;
+  Point mOffset;
+  DrawOptions mOptions;
+};
+
+class PushClipCommand : public DrawingCommand {
+ public:
+  explicit PushClipCommand(const Path* aPath)
+      : mPath(const_cast<Path*>(aPath)) {}
+
+  CommandType GetType() const override { return PushClipCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PushClipCommand)(mPath);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PushClip(mPath);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[PushClip path=" << mPath << "]";
+  }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::PUSHCLIP;
+
+ private:
+  RefPtr<Path> mPath;
+};
+
+class PushClipRectCommand : public DrawingCommand {
+ public:
+  explicit PushClipRectCommand(const Rect& aRect) : mRect(aRect) {}
+
+  CommandType GetType() const override { return PushClipRectCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PushClipRectCommand)(mRect);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PushClipRect(mRect);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[PushClipRect rect=" << mRect << "]";
+  }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::PUSHCLIPRECT;
+
+ private:
+  Rect mRect;
+};
+
+class PushLayerCommand : public DrawingCommand {
+ public:
+  PushLayerCommand(const bool aOpaque, const Float aOpacity,
+                   SourceSurface* aMask, const Matrix& aMaskTransform,
+                   const IntRect& aBounds, bool aCopyBackground)
+      : mOpaque(aOpaque),
+        mOpacity(aOpacity),
+        mMask(aMask),
+        mMaskTransform(aMaskTransform),
+        mBounds(aBounds),
+        mCopyBackground(aCopyBackground) {}
+
+  CommandType GetType() const override { return PushLayerCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PushLayerCommand)
+    (mOpaque, mOpacity, mMask, mMaskTransform, mBounds, mCopyBackground);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PushLayer(mOpaque, mOpacity, mMask, mMaskTransform, mBounds,
+                   mCopyBackground);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[PushLayer opaque=" << mOpaque;
+    aStream << " opacity=" << mOpacity;
+    aStream << " mask=" << mMask;
+    aStream << " maskTransform=" << mMaskTransform;
+    aStream << " bounds=" << mBounds;
+    aStream << " copyBackground=" << mCopyBackground;
+    aStream << "]";
+  }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::PUSHLAYER;
+
+ private:
+  bool mOpaque;
+  float mOpacity;
+  RefPtr<SourceSurface> mMask;
+  Matrix mMaskTransform;
+  IntRect mBounds;
+  bool mCopyBackground;
+};
+
+class PopClipCommand : public DrawingCommand {
+ public:
+  PopClipCommand() = default;
+
+  CommandType GetType() const override { return PopClipCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PopClipCommand)();
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PopClip();
+  }
+
+  void Log(TreeLog<>& aStream) const override { aStream << "[PopClip]"; }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::POPCLIP;
+};
+
+class PopLayerCommand : public DrawingCommand {
+ public:
+  PopLayerCommand() = default;
+
+  CommandType GetType() const override { return PopLayerCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PopLayerCommand)();
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PopLayer();
+  }
+
+  void Log(TreeLog<>& aStream) const override { aStream << "[PopLayer]"; }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::POPLAYER;
+};
+
+class SetTransformCommand : public DrawingCommand {
+  friend class DrawTargetCaptureImpl;
+
+ public:
+  explicit SetTransformCommand(const Matrix& aTransform)
+      : mTransform(aTransform) {}
+
+  CommandType GetType() const override { return SetTransformCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(SetTransformCommand)(mTransform);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix* aMatrix) const override {
+    if (aMatrix) {
+      aDT->SetTransform(mTransform * (*aMatrix));
+    } else {
+      aDT->SetTransform(mTransform);
+    }
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[SetTransform transform=" << mTransform << "]";
+  }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::SETTRANSFORM;
+
+ private:
+  Matrix mTransform;
+};
+
+class SetPermitSubpixelAACommand : public DrawingCommand {
+  friend class DrawTargetCaptureImpl;
+
+ public:
+  explicit SetPermitSubpixelAACommand(bool aPermitSubpixelAA)
+      : mPermitSubpixelAA(aPermitSubpixelAA) {}
+
+  CommandType GetType() const override {
+    return SetPermitSubpixelAACommand::Type;
+  }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(SetPermitSubpixelAACommand)(mPermitSubpixelAA);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix* aMatrix) const override {
+    aDT->SetPermitSubpixelAA(mPermitSubpixelAA);
+  }
+
+  void Log(TreeLog<>& aStream) const override {
+    aStream << "[SetPermitSubpixelAA permitSubpixelAA=" << mPermitSubpixelAA
+            << "]";
+  }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::SETPERMITSUBPIXELAA;
+
+ private:
+  bool mPermitSubpixelAA;
+};
+
+class FlushCommand : public DrawingCommand {
+ public:
+  FlushCommand() = default;
+
+  CommandType GetType() const override { return FlushCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(FlushCommand)();
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->Flush();
+  }
+
+  void Log(TreeLog<>& aStream) const override { aStream << "[Flush]"; }
+
+  static const bool AffectsSnapshot = false;
+  static const CommandType Type = CommandType::FLUSH;
+};
+
+class BlurCommand : public DrawingCommand {
+ public:
+  explicit BlurCommand(const AlphaBoxBlur& aBlur) : mBlur(aBlur) {}
+
+  CommandType GetType() const override { return BlurCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(BlurCommand)(mBlur);
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->Blur(mBlur);
+  }
+
+  void Log(TreeLog<>& aStream) const override { aStream << "[Blur]"; }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::BLUR;
+
+ private:
+  AlphaBoxBlur mBlur;
+};
+
+class PadEdgesCommand : public DrawingCommand {
+ public:
+  explicit PadEdgesCommand(const IntRegion& aRegion) : mRegion(aRegion) {}
+
+  CommandType GetType() const override { return PadEdgesCommand::Type; }
+
+  void CloneInto(CaptureCommandList* aList) override {
+    CLONE_INTO(PadEdgesCommand)(IntRegion(mRegion));
+  }
+
+  void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override {
+    aDT->PadEdges(mRegion);
+  }
+
+  void Log(TreeLog<>& aStream) const override { aStream << "[PADEDGES]"; }
+
+  static const bool AffectsSnapshot = true;
+  static const CommandType Type = CommandType::PADEDGES;
+
+ private:
+  IntRegion mRegion;
+};
+
+#undef CLONE_INTO
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif /* MOZILLA_GFX_DRAWCOMMANDS_H_ */