gecko-dev/gfx/2d/DrawCommands.h

/* -*- 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_ */