summaryrefslogtreecommitdiffstats
path: root/gfx/2d/RecordedEvent.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/2d/RecordedEvent.h')
-rw-r--r--gfx/2d/RecordedEvent.h1281
1 files changed, 1281 insertions, 0 deletions
diff --git a/gfx/2d/RecordedEvent.h b/gfx/2d/RecordedEvent.h
new file mode 100644
index 000000000..bf660ba24
--- /dev/null
+++ b/gfx/2d/RecordedEvent.h
@@ -0,0 +1,1281 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_RECORDEDEVENT_H_
+#define MOZILLA_GFX_RECORDEDEVENT_H_
+
+#include "2D.h"
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <vector>
+
+namespace mozilla {
+namespace gfx {
+
+struct PathOp;
+class PathRecording;
+
+const uint32_t kMagicInt = 0xc001feed;
+
+// A change in major revision means a change in event binary format, causing
+// loss of backwards compatibility. Old streams will not work in a player
+// using a newer major revision. And new streams will not work in a player
+// using an older major revision.
+const uint16_t kMajorRevision = 6;
+// A change in minor revision means additions of new events. New streams will
+// not play in older players.
+const uint16_t kMinorRevision = 0;
+
+struct ReferencePtr
+{
+ ReferencePtr()
+ : mLongPtr(0)
+ {}
+
+ MOZ_IMPLICIT ReferencePtr(const void* aLongPtr)
+ : mLongPtr(uint64_t(aLongPtr))
+ {}
+
+ template <typename T>
+ MOZ_IMPLICIT ReferencePtr(const RefPtr<T>& aPtr)
+ : mLongPtr(uint64_t(aPtr.get()))
+ {}
+
+ ReferencePtr &operator =(const void* aLongPtr) {
+ mLongPtr = uint64_t(aLongPtr);
+ return *this;
+ }
+
+ template <typename T>
+ ReferencePtr &operator =(const RefPtr<T>& aPtr) {
+ mLongPtr = uint64_t(aPtr.get());
+ return *this;
+ }
+
+ operator void*() const {
+ return (void*)mLongPtr;
+ }
+
+ uint64_t mLongPtr;
+};
+
+struct RecordedFontDetails
+{
+ uint64_t fontDataKey;
+ uint32_t size;
+ uint32_t index;
+ Float glyphSize;
+};
+
+// Used by the Azure drawing debugger (player2d)
+inline std::string StringFromPtr(ReferencePtr aPtr)
+{
+ std::stringstream stream;
+ stream << aPtr;
+ return stream.str();
+}
+
+class Translator
+{
+public:
+ virtual ~Translator() {}
+
+ virtual DrawTarget *LookupDrawTarget(ReferencePtr aRefPtr) = 0;
+ virtual Path *LookupPath(ReferencePtr aRefPtr) = 0;
+ virtual SourceSurface *LookupSourceSurface(ReferencePtr aRefPtr) = 0;
+ virtual FilterNode *LookupFilterNode(ReferencePtr aRefPtr) = 0;
+ virtual GradientStops *LookupGradientStops(ReferencePtr aRefPtr) = 0;
+ virtual ScaledFont *LookupScaledFont(ReferencePtr aRefPtr) = 0;
+ virtual NativeFontResource *LookupNativeFontResource(uint64_t aKey) = 0;
+ virtual void AddDrawTarget(ReferencePtr aRefPtr, DrawTarget *aDT) = 0;
+ virtual void RemoveDrawTarget(ReferencePtr aRefPtr) = 0;
+ virtual void AddPath(ReferencePtr aRefPtr, Path *aPath) = 0;
+ virtual void RemovePath(ReferencePtr aRefPtr) = 0;
+ virtual void AddSourceSurface(ReferencePtr aRefPtr, SourceSurface *aPath) = 0;
+ virtual void RemoveSourceSurface(ReferencePtr aRefPtr) = 0;
+ virtual void AddFilterNode(mozilla::gfx::ReferencePtr aRefPtr, FilterNode *aSurface) = 0;
+ virtual void RemoveFilterNode(mozilla::gfx::ReferencePtr aRefPtr) = 0;
+ virtual void AddGradientStops(ReferencePtr aRefPtr, GradientStops *aPath) = 0;
+ virtual void RemoveGradientStops(ReferencePtr aRefPtr) = 0;
+ virtual void AddScaledFont(ReferencePtr aRefPtr, ScaledFont *aScaledFont) = 0;
+ virtual void RemoveScaledFont(ReferencePtr aRefPtr) = 0;
+ virtual void AddNativeFontResource(uint64_t aKey,
+ NativeFontResource *aNativeFontResource) = 0;
+
+ virtual already_AddRefed<DrawTarget> CreateDrawTarget(ReferencePtr aRefPtr,
+ const IntSize &aSize,
+ SurfaceFormat aFormat);
+ virtual DrawTarget *GetReferenceDrawTarget() = 0;
+ virtual FontType GetDesiredFontType() = 0;
+};
+
+struct ColorPatternStorage
+{
+ Color mColor;
+};
+
+struct LinearGradientPatternStorage
+{
+ Point mBegin;
+ Point mEnd;
+ ReferencePtr mStops;
+ Matrix mMatrix;
+};
+
+struct RadialGradientPatternStorage
+{
+ Point mCenter1;
+ Point mCenter2;
+ Float mRadius1;
+ Float mRadius2;
+ ReferencePtr mStops;
+ Matrix mMatrix;
+};
+
+struct SurfacePatternStorage
+{
+ ExtendMode mExtend;
+ SamplingFilter mSamplingFilter;
+ ReferencePtr mSurface;
+ Matrix mMatrix;
+ IntRect mSamplingRect;
+};
+
+struct PatternStorage
+{
+ PatternType mType;
+ union {
+ char *mStorage;
+ char mColor[sizeof(ColorPatternStorage)];
+ char mLinear[sizeof(LinearGradientPatternStorage)];
+ char mRadial[sizeof(RadialGradientPatternStorage)];
+ char mSurface[sizeof(SurfacePatternStorage)];
+ };
+};
+
+class RecordedEvent {
+public:
+ enum EventType {
+ DRAWTARGETCREATION = 0,
+ DRAWTARGETDESTRUCTION,
+ FILLRECT,
+ STROKERECT,
+ STROKELINE,
+ CLEARRECT,
+ COPYSURFACE,
+ SETTRANSFORM,
+ PUSHCLIP,
+ PUSHCLIPRECT,
+ POPCLIP,
+ FILL,
+ FILLGLYPHS,
+ MASK,
+ STROKE,
+ DRAWSURFACE,
+ DRAWSURFACEWITHSHADOW,
+ PATHCREATION,
+ PATHDESTRUCTION,
+ SOURCESURFACECREATION,
+ SOURCESURFACEDESTRUCTION,
+ GRADIENTSTOPSCREATION,
+ GRADIENTSTOPSDESTRUCTION,
+ SNAPSHOT,
+ SCALEDFONTCREATION,
+ SCALEDFONTDESTRUCTION,
+ MASKSURFACE,
+ FILTERNODECREATION,
+ FILTERNODEDESTRUCTION,
+ DRAWFILTER,
+ FILTERNODESETATTRIBUTE,
+ FILTERNODESETINPUT,
+ CREATESIMILARDRAWTARGET,
+ FONTDATA,
+ FONTDESC,
+ PUSHLAYER,
+ POPLAYER,
+ };
+ static const uint32_t kTotalEventTypes = RecordedEvent::FILTERNODESETINPUT + 1;
+
+ virtual ~RecordedEvent() {}
+
+ static std::string GetEventName(EventType aType);
+
+ /**
+ * Play back this event using the translator. Note that derived classes should
+ * only return false when there is a fatal error, as it will probably mean the
+ * translation will abort.
+ * @param aTranslator Translator to be used for retrieving other referenced
+ * objects and making playback decisions.
+ * @return true unless a fatal problem has occurred and playback should abort.
+ */
+ virtual bool PlayEvent(Translator *aTranslator) const { return true; }
+
+ virtual void RecordToStream(std::ostream &aStream) const {}
+
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const { }
+
+ void RecordPatternData(std::ostream &aStream, const PatternStorage &aPatternStorage) const;
+ void ReadPatternData(std::istream &aStream, PatternStorage &aPatternStorage) const;
+ void StorePattern(PatternStorage &aDestination, const Pattern &aSource) const;
+ void RecordStrokeOptions(std::ostream &aStream, const StrokeOptions &aStrokeOptions) const;
+ void ReadStrokeOptions(std::istream &aStream, StrokeOptions &aStrokeOptions);
+
+ virtual std::string GetName() const = 0;
+
+ virtual ReferencePtr GetObjectRef() const = 0;
+
+ virtual ReferencePtr GetDestinedDT() { return nullptr; }
+
+ void OutputSimplePatternInfo(const PatternStorage &aStorage, std::stringstream &aOutput) const;
+
+ static RecordedEvent *LoadEventFromStream(std::istream &aStream, EventType aType);
+
+ EventType GetType() { return (EventType)mType; }
+protected:
+ friend class DrawEventRecorderPrivate;
+
+ MOZ_IMPLICIT RecordedEvent(int32_t aType) : mType(aType)
+ {}
+
+ int32_t mType;
+ std::vector<Float> mDashPatternStorage;
+};
+
+class RecordedDrawingEvent : public RecordedEvent
+{
+public:
+ virtual ReferencePtr GetDestinedDT() { return mDT; }
+
+protected:
+ RecordedDrawingEvent(EventType aType, DrawTarget *aTarget)
+ : RecordedEvent(aType), mDT(aTarget)
+ {
+ }
+
+ RecordedDrawingEvent(EventType aType, std::istream &aStream);
+ virtual void RecordToStream(std::ostream &aStream) const;
+
+ virtual ReferencePtr GetObjectRef() const;
+
+ ReferencePtr mDT;
+};
+
+class RecordedDrawTargetCreation : public RecordedEvent {
+public:
+ RecordedDrawTargetCreation(ReferencePtr aRefPtr, BackendType aType, const IntSize &aSize, SurfaceFormat aFormat,
+ bool aHasExistingData = false, SourceSurface *aExistingData = nullptr)
+ : RecordedEvent(DRAWTARGETCREATION), mRefPtr(aRefPtr), mBackendType(aType), mSize(aSize), mFormat(aFormat)
+ , mHasExistingData(aHasExistingData), mExistingData(aExistingData)
+ {}
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "DrawTarget Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+
+ ReferencePtr mRefPtr;
+ BackendType mBackendType;
+ IntSize mSize;
+ SurfaceFormat mFormat;
+ bool mHasExistingData;
+ RefPtr<SourceSurface> mExistingData;
+
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedDrawTargetCreation(std::istream &aStream);
+};
+
+class RecordedDrawTargetDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedDrawTargetDestruction(ReferencePtr aRefPtr)
+ : RecordedEvent(DRAWTARGETDESTRUCTION), mRefPtr(aRefPtr)
+ {}
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "DrawTarget Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+
+ ReferencePtr mRefPtr;
+
+ BackendType mBackendType;
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedDrawTargetDestruction(std::istream &aStream);
+};
+
+class RecordedCreateSimilarDrawTarget : public RecordedEvent
+{
+public:
+ RecordedCreateSimilarDrawTarget(ReferencePtr aRefPtr, const IntSize &aSize,
+ SurfaceFormat aFormat)
+ : RecordedEvent(CREATESIMILARDRAWTARGET)
+ , mRefPtr(aRefPtr) , mSize(aSize), mFormat(aFormat)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "CreateSimilarDrawTarget"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+
+ ReferencePtr mRefPtr;
+ IntSize mSize;
+ SurfaceFormat mFormat;
+
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedCreateSimilarDrawTarget(std::istream &aStream);
+};
+
+class RecordedFillRect : public RecordedDrawingEvent {
+public:
+ RecordedFillRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(FILLRECT, aDT), mRect(aRect), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "FillRect"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedFillRect(std::istream &aStream);
+
+ Rect mRect;
+ PatternStorage mPattern;
+ DrawOptions mOptions;
+};
+
+class RecordedStrokeRect : public RecordedDrawingEvent {
+public:
+ RecordedStrokeRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern,
+ const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(STROKERECT, aDT), mRect(aRect),
+ mStrokeOptions(aStrokeOptions), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "StrokeRect"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedStrokeRect(std::istream &aStream);
+
+ Rect mRect;
+ PatternStorage mPattern;
+ StrokeOptions mStrokeOptions;
+ DrawOptions mOptions;
+};
+
+class RecordedStrokeLine : public RecordedDrawingEvent {
+public:
+ RecordedStrokeLine(DrawTarget *aDT, const Point &aBegin, const Point &aEnd,
+ const Pattern &aPattern, const StrokeOptions &aStrokeOptions,
+ const DrawOptions &aOptions)
+ : RecordedDrawingEvent(STROKELINE, aDT), mBegin(aBegin), mEnd(aEnd),
+ mStrokeOptions(aStrokeOptions), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "StrokeLine"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedStrokeLine(std::istream &aStream);
+
+ Point mBegin;
+ Point mEnd;
+ PatternStorage mPattern;
+ StrokeOptions mStrokeOptions;
+ DrawOptions mOptions;
+};
+
+class RecordedFill : public RecordedDrawingEvent {
+public:
+ RecordedFill(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(FILL, aDT), mPath(aPath), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Fill"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedFill(std::istream &aStream);
+
+ ReferencePtr mPath;
+ PatternStorage mPattern;
+ DrawOptions mOptions;
+};
+
+class RecordedFillGlyphs : public RecordedDrawingEvent {
+public:
+ RecordedFillGlyphs(DrawTarget *aDT, ReferencePtr aScaledFont, const Pattern &aPattern, const DrawOptions &aOptions,
+ const Glyph *aGlyphs, uint32_t aNumGlyphs)
+ : RecordedDrawingEvent(FILLGLYPHS, aDT), mScaledFont(aScaledFont), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ mNumGlyphs = aNumGlyphs;
+ mGlyphs = new Glyph[aNumGlyphs];
+ memcpy(mGlyphs, aGlyphs, sizeof(Glyph) * aNumGlyphs);
+ }
+ virtual ~RecordedFillGlyphs();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "FillGlyphs"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedFillGlyphs(std::istream &aStream);
+
+ ReferencePtr mScaledFont;
+ PatternStorage mPattern;
+ DrawOptions mOptions;
+ Glyph *mGlyphs;
+ uint32_t mNumGlyphs;
+};
+
+class RecordedMask : public RecordedDrawingEvent {
+public:
+ RecordedMask(DrawTarget *aDT, const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(MASK, aDT), mOptions(aOptions)
+ {
+ StorePattern(mSource, aSource);
+ StorePattern(mMask, aMask);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Mask"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedMask(std::istream &aStream);
+
+ PatternStorage mSource;
+ PatternStorage mMask;
+ DrawOptions mOptions;
+};
+
+class RecordedStroke : public RecordedDrawingEvent {
+public:
+ RecordedStroke(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern,
+ const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(STROKE, aDT), mPath(aPath),
+ mStrokeOptions(aStrokeOptions), mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Stroke"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedStroke(std::istream &aStream);
+
+ ReferencePtr mPath;
+ PatternStorage mPattern;
+ StrokeOptions mStrokeOptions;
+ DrawOptions mOptions;
+};
+
+class RecordedClearRect : public RecordedDrawingEvent {
+public:
+ RecordedClearRect(DrawTarget *aDT, const Rect &aRect)
+ : RecordedDrawingEvent(CLEARRECT, aDT), mRect(aRect)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "ClearRect"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedClearRect(std::istream &aStream);
+
+ Rect mRect;
+};
+
+class RecordedCopySurface : public RecordedDrawingEvent {
+public:
+ RecordedCopySurface(DrawTarget *aDT, ReferencePtr aSourceSurface,
+ const IntRect &aSourceRect, const IntPoint &aDest)
+ : RecordedDrawingEvent(COPYSURFACE, aDT), mSourceSurface(aSourceSurface),
+ mSourceRect(aSourceRect), mDest(aDest)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "CopySurface"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedCopySurface(std::istream &aStream);
+
+ ReferencePtr mSourceSurface;
+ IntRect mSourceRect;
+ IntPoint mDest;
+};
+
+class RecordedPushClip : public RecordedDrawingEvent {
+public:
+ RecordedPushClip(DrawTarget *aDT, ReferencePtr aPath)
+ : RecordedDrawingEvent(PUSHCLIP, aDT), mPath(aPath)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "PushClip"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedPushClip(std::istream &aStream);
+
+ ReferencePtr mPath;
+};
+
+class RecordedPushClipRect : public RecordedDrawingEvent {
+public:
+ RecordedPushClipRect(DrawTarget *aDT, const Rect &aRect)
+ : RecordedDrawingEvent(PUSHCLIPRECT, aDT), mRect(aRect)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "PushClipRect"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedPushClipRect(std::istream &aStream);
+
+ Rect mRect;
+};
+
+class RecordedPopClip : public RecordedDrawingEvent {
+public:
+ MOZ_IMPLICIT RecordedPopClip(DrawTarget *aDT)
+ : RecordedDrawingEvent(POPCLIP, aDT)
+ {}
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "PopClip"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedPopClip(std::istream &aStream);
+};
+
+class RecordedPushLayer : public RecordedDrawingEvent {
+public:
+ RecordedPushLayer(DrawTarget* aDT, bool aOpaque, Float aOpacity,
+ SourceSurface* aMask, const Matrix& aMaskTransform,
+ const IntRect& aBounds, bool aCopyBackground)
+ : RecordedDrawingEvent(PUSHLAYER, aDT), mOpaque(aOpaque)
+ , mOpacity(aOpacity), mMask(aMask), mMaskTransform(aMaskTransform)
+ , mBounds(aBounds), mCopyBackground(aCopyBackground)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "PushLayer"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedPushLayer(std::istream &aStream);
+
+ bool mOpaque;
+ Float mOpacity;
+ ReferencePtr mMask;
+ Matrix mMaskTransform;
+ IntRect mBounds;
+ bool mCopyBackground;
+};
+
+class RecordedPopLayer : public RecordedDrawingEvent {
+public:
+ MOZ_IMPLICIT RecordedPopLayer(DrawTarget* aDT)
+ : RecordedDrawingEvent(POPLAYER, aDT)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "PopLayer"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedPopLayer(std::istream &aStream);
+};
+
+class RecordedSetTransform : public RecordedDrawingEvent {
+public:
+ RecordedSetTransform(DrawTarget *aDT, const Matrix &aTransform)
+ : RecordedDrawingEvent(SETTRANSFORM, aDT), mTransform(aTransform)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "SetTransform"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedSetTransform(std::istream &aStream);
+
+ Matrix mTransform;
+};
+
+class RecordedDrawSurface : public RecordedDrawingEvent {
+public:
+ RecordedDrawSurface(DrawTarget *aDT, ReferencePtr aRefSource, const Rect &aDest,
+ const Rect &aSource, const DrawSurfaceOptions &aDSOptions,
+ const DrawOptions &aOptions)
+ : RecordedDrawingEvent(DRAWSURFACE, aDT), mRefSource(aRefSource), mDest(aDest)
+ , mSource(aSource), mDSOptions(aDSOptions), mOptions(aOptions)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "DrawSurface"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedDrawSurface(std::istream &aStream);
+
+ ReferencePtr mRefSource;
+ Rect mDest;
+ Rect mSource;
+ DrawSurfaceOptions mDSOptions;
+ DrawOptions mOptions;
+};
+
+class RecordedDrawSurfaceWithShadow : public RecordedDrawingEvent {
+public:
+ RecordedDrawSurfaceWithShadow(DrawTarget *aDT, ReferencePtr aRefSource, const Point &aDest,
+ const Color &aColor, const Point &aOffset,
+ Float aSigma, CompositionOp aOp)
+ : RecordedDrawingEvent(DRAWSURFACEWITHSHADOW, aDT), mRefSource(aRefSource), mDest(aDest)
+ , mColor(aColor), mOffset(aOffset), mSigma(aSigma), mOp(aOp)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "DrawSurfaceWithShadow"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedDrawSurfaceWithShadow(std::istream &aStream);
+
+ ReferencePtr mRefSource;
+ Point mDest;
+ Color mColor;
+ Point mOffset;
+ Float mSigma;
+ CompositionOp mOp;
+};
+
+class RecordedDrawFilter : public RecordedDrawingEvent {
+public:
+ RecordedDrawFilter(DrawTarget *aDT, ReferencePtr aNode,
+ const Rect &aSourceRect,
+ const Point &aDestPoint,
+ const DrawOptions &aOptions)
+ : RecordedDrawingEvent(DRAWFILTER, aDT), mNode(aNode), mSourceRect(aSourceRect)
+ , mDestPoint(aDestPoint), mOptions(aOptions)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "DrawFilter"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedDrawFilter(std::istream &aStream);
+
+ ReferencePtr mNode;
+ Rect mSourceRect;
+ Point mDestPoint;
+ DrawOptions mOptions;
+};
+
+class RecordedPathCreation : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedPathCreation(PathRecording *aPath);
+ ~RecordedPathCreation();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Path Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ FillRule mFillRule;
+ std::vector<PathOp> mPathOps;
+
+ MOZ_IMPLICIT RecordedPathCreation(std::istream &aStream);
+};
+
+class RecordedPathDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedPathDestruction(PathRecording *aPath)
+ : RecordedEvent(PATHDESTRUCTION), mRefPtr(aPath)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Path Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedPathDestruction(std::istream &aStream);
+};
+
+class RecordedSourceSurfaceCreation : public RecordedEvent {
+public:
+ RecordedSourceSurfaceCreation(ReferencePtr aRefPtr, uint8_t *aData, int32_t aStride,
+ const IntSize &aSize, SurfaceFormat aFormat)
+ : RecordedEvent(SOURCESURFACECREATION), mRefPtr(aRefPtr), mData(aData)
+ , mStride(aStride), mSize(aSize), mFormat(aFormat), mDataOwned(false)
+ {
+ }
+
+ ~RecordedSourceSurfaceCreation();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "SourceSurface Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ uint8_t *mData;
+ int32_t mStride;
+ IntSize mSize;
+ SurfaceFormat mFormat;
+ bool mDataOwned;
+
+ MOZ_IMPLICIT RecordedSourceSurfaceCreation(std::istream &aStream);
+};
+
+class RecordedSourceSurfaceDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedSourceSurfaceDestruction(ReferencePtr aRefPtr)
+ : RecordedEvent(SOURCESURFACEDESTRUCTION), mRefPtr(aRefPtr)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "SourceSurface Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedSourceSurfaceDestruction(std::istream &aStream);
+};
+
+class RecordedFilterNodeCreation : public RecordedEvent {
+public:
+ RecordedFilterNodeCreation(ReferencePtr aRefPtr, FilterType aType)
+ : RecordedEvent(FILTERNODECREATION), mRefPtr(aRefPtr), mType(aType)
+ {
+ }
+
+ ~RecordedFilterNodeCreation();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "FilterNode Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ FilterType mType;
+
+ MOZ_IMPLICIT RecordedFilterNodeCreation(std::istream &aStream);
+};
+
+class RecordedFilterNodeDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedFilterNodeDestruction(ReferencePtr aRefPtr)
+ : RecordedEvent(FILTERNODEDESTRUCTION), mRefPtr(aRefPtr)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "FilterNode Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedFilterNodeDestruction(std::istream &aStream);
+};
+
+class RecordedGradientStopsCreation : public RecordedEvent {
+public:
+ RecordedGradientStopsCreation(ReferencePtr aRefPtr, GradientStop *aStops,
+ uint32_t aNumStops, ExtendMode aExtendMode)
+ : RecordedEvent(GRADIENTSTOPSCREATION), mRefPtr(aRefPtr), mStops(aStops)
+ , mNumStops(aNumStops), mExtendMode(aExtendMode), mDataOwned(false)
+ {
+ }
+
+ ~RecordedGradientStopsCreation();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "GradientStops Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ GradientStop *mStops;
+ uint32_t mNumStops;
+ ExtendMode mExtendMode;
+ bool mDataOwned;
+
+ MOZ_IMPLICIT RecordedGradientStopsCreation(std::istream &aStream);
+};
+
+class RecordedGradientStopsDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedGradientStopsDestruction(ReferencePtr aRefPtr)
+ : RecordedEvent(GRADIENTSTOPSDESTRUCTION), mRefPtr(aRefPtr)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "GradientStops Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedGradientStopsDestruction(std::istream &aStream);
+};
+
+class RecordedSnapshot : public RecordedEvent {
+public:
+ RecordedSnapshot(ReferencePtr aRefPtr, DrawTarget *aDT)
+ : RecordedEvent(SNAPSHOT), mRefPtr(aRefPtr), mDT(aDT)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Snapshot"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ ReferencePtr mDT;
+
+ MOZ_IMPLICIT RecordedSnapshot(std::istream &aStream);
+};
+
+class RecordedFontData : public RecordedEvent {
+public:
+
+ static void FontDataProc(const uint8_t *aData, uint32_t aSize,
+ uint32_t aIndex, Float aGlyphSize, void* aBaton)
+ {
+ auto recordedFontData = static_cast<RecordedFontData*>(aBaton);
+ recordedFontData->SetFontData(aData, aSize, aIndex, aGlyphSize);
+ }
+
+ explicit RecordedFontData(ScaledFont *aScaledFont)
+ : RecordedEvent(FONTDATA), mData(nullptr)
+ {
+ mGetFontFileDataSucceeded = aScaledFont->GetFontFileData(&FontDataProc, this);
+ }
+
+ ~RecordedFontData();
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Font Data"; }
+ virtual ReferencePtr GetObjectRef() const { return nullptr; };
+
+ void SetFontData(const uint8_t *aData, uint32_t aSize, uint32_t aIndex,
+ Float aGlyphSize);
+
+ bool GetFontDetails(RecordedFontDetails& fontDetails);
+
+private:
+ friend class RecordedEvent;
+
+ uint8_t *mData;
+ RecordedFontDetails mFontDetails;
+
+ bool mGetFontFileDataSucceeded = false;
+
+ MOZ_IMPLICIT RecordedFontData(std::istream &aStream);
+};
+
+class RecordedFontDescriptor : public RecordedEvent {
+public:
+
+ static void FontDescCb(const uint8_t *aData, uint32_t aSize,
+ Float aFontSize, void* aBaton)
+ {
+ auto recordedFontDesc = static_cast<RecordedFontDescriptor*>(aBaton);
+ recordedFontDesc->SetFontDescriptor(aData, aSize, aFontSize);
+ }
+
+ explicit RecordedFontDescriptor(ScaledFont* aScaledFont)
+ : RecordedEvent(FONTDESC)
+ , mType(aScaledFont->GetType())
+ , mRefPtr(aScaledFont)
+ {
+ mHasDesc = aScaledFont->GetFontDescriptor(FontDescCb, this);
+ }
+
+ ~RecordedFontDescriptor();
+
+ bool IsValid() const { return mHasDesc; }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "Font Desc"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+
+private:
+ friend class RecordedEvent;
+
+ void SetFontDescriptor(const uint8_t* aData, uint32_t aSize, Float aFontSize);
+
+ bool mHasDesc;
+
+ FontType mType;
+ Float mFontSize;
+ std::vector<uint8_t> mData;
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedFontDescriptor(std::istream &aStream);
+};
+
+class RecordedScaledFontCreation : public RecordedEvent {
+public:
+
+ static void FontInstanceDataProc(const uint8_t* aData, uint32_t aSize, void* aBaton)
+ {
+ auto recordedScaledFontCreation = static_cast<RecordedScaledFontCreation*>(aBaton);
+ recordedScaledFontCreation->SetFontInstanceData(aData, aSize);
+ }
+
+ RecordedScaledFontCreation(ScaledFont* aScaledFont,
+ RecordedFontDetails aFontDetails)
+ : RecordedEvent(SCALEDFONTCREATION), mRefPtr(aScaledFont)
+ , mFontDataKey(aFontDetails.fontDataKey)
+ , mGlyphSize(aFontDetails.glyphSize) , mIndex(aFontDetails.index)
+ {
+ aScaledFont->GetFontInstanceData(FontInstanceDataProc, this);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "ScaledFont Creation"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+
+ void SetFontInstanceData(const uint8_t *aData, uint32_t aSize);
+
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+ uint64_t mFontDataKey;
+ Float mGlyphSize;
+ uint32_t mIndex;
+ std::vector<uint8_t> mInstanceData;
+
+ MOZ_IMPLICIT RecordedScaledFontCreation(std::istream &aStream);
+};
+
+class RecordedScaledFontDestruction : public RecordedEvent {
+public:
+ MOZ_IMPLICIT RecordedScaledFontDestruction(ReferencePtr aRefPtr)
+ : RecordedEvent(SCALEDFONTDESTRUCTION), mRefPtr(aRefPtr)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "ScaledFont Destruction"; }
+ virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mRefPtr;
+
+ MOZ_IMPLICIT RecordedScaledFontDestruction(std::istream &aStream);
+};
+
+class RecordedMaskSurface : public RecordedDrawingEvent {
+public:
+ RecordedMaskSurface(DrawTarget *aDT, const Pattern &aPattern, ReferencePtr aRefMask,
+ const Point &aOffset, const DrawOptions &aOptions)
+ : RecordedDrawingEvent(MASKSURFACE, aDT), mRefMask(aRefMask), mOffset(aOffset)
+ , mOptions(aOptions)
+ {
+ StorePattern(mPattern, aPattern);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "MaskSurface"; }
+private:
+ friend class RecordedEvent;
+
+ MOZ_IMPLICIT RecordedMaskSurface(std::istream &aStream);
+
+ PatternStorage mPattern;
+ ReferencePtr mRefMask;
+ Point mOffset;
+ DrawOptions mOptions;
+};
+
+class RecordedFilterNodeSetAttribute : public RecordedEvent
+{
+public:
+ enum ArgType {
+ ARGTYPE_UINT32,
+ ARGTYPE_BOOL,
+ ARGTYPE_FLOAT,
+ ARGTYPE_SIZE,
+ ARGTYPE_INTSIZE,
+ ARGTYPE_INTPOINT,
+ ARGTYPE_RECT,
+ ARGTYPE_INTRECT,
+ ARGTYPE_POINT,
+ ARGTYPE_MATRIX,
+ ARGTYPE_MATRIX5X4,
+ ARGTYPE_POINT3D,
+ ARGTYPE_COLOR,
+ ARGTYPE_FLOAT_ARRAY
+ };
+
+ template<typename T>
+ RecordedFilterNodeSetAttribute(FilterNode *aNode, uint32_t aIndex, T aArgument, ArgType aArgType)
+ : RecordedEvent(FILTERNODESETATTRIBUTE), mNode(aNode), mIndex(aIndex), mArgType(aArgType)
+ {
+ mPayload.resize(sizeof(T));
+ memcpy(&mPayload.front(), &aArgument, sizeof(T));
+ }
+
+ RecordedFilterNodeSetAttribute(FilterNode *aNode, uint32_t aIndex, const Float *aFloat, uint32_t aSize)
+ : RecordedEvent(FILTERNODESETATTRIBUTE), mNode(aNode), mIndex(aIndex), mArgType(ARGTYPE_FLOAT_ARRAY)
+ {
+ mPayload.resize(sizeof(Float) * aSize);
+ memcpy(&mPayload.front(), aFloat, sizeof(Float) * aSize);
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "SetAttribute"; }
+
+ virtual ReferencePtr GetObjectRef() const { return mNode; }
+
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mNode;
+
+ uint32_t mIndex;
+ ArgType mArgType;
+ std::vector<uint8_t> mPayload;
+
+ MOZ_IMPLICIT RecordedFilterNodeSetAttribute(std::istream &aStream);
+};
+
+class RecordedFilterNodeSetInput : public RecordedEvent
+{
+public:
+ RecordedFilterNodeSetInput(FilterNode* aNode, uint32_t aIndex, FilterNode* aInputNode)
+ : RecordedEvent(FILTERNODESETINPUT), mNode(aNode), mIndex(aIndex)
+ , mInputFilter(aInputNode), mInputSurface(nullptr)
+ {
+ }
+
+ RecordedFilterNodeSetInput(FilterNode *aNode, uint32_t aIndex, SourceSurface *aInputSurface)
+ : RecordedEvent(FILTERNODESETINPUT), mNode(aNode), mIndex(aIndex)
+ , mInputFilter(nullptr), mInputSurface(aInputSurface)
+ {
+ }
+
+ virtual bool PlayEvent(Translator *aTranslator) const;
+ virtual void RecordToStream(std::ostream &aStream) const;
+ virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
+
+ virtual std::string GetName() const { return "SetInput"; }
+
+ virtual ReferencePtr GetObjectRef() const { return mNode; }
+
+private:
+ friend class RecordedEvent;
+
+ ReferencePtr mNode;
+ uint32_t mIndex;
+ ReferencePtr mInputFilter;
+ ReferencePtr mInputSurface;
+
+ MOZ_IMPLICIT RecordedFilterNodeSetInput(std::istream &aStream);
+};
+
+} // namespace gfx
+} // namespace mozilla
+
+#endif