From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- gfx/2d/RecordedEvent.h | 1281 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1281 insertions(+) create mode 100644 gfx/2d/RecordedEvent.h (limited to 'gfx/2d/RecordedEvent.h') 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 +#include +#include +#include + +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 + MOZ_IMPLICIT ReferencePtr(const RefPtr& aPtr) + : mLongPtr(uint64_t(aPtr.get())) + {} + + ReferencePtr &operator =(const void* aLongPtr) { + mLongPtr = uint64_t(aLongPtr); + return *this; + } + + template + ReferencePtr &operator =(const RefPtr& 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 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 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 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 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(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(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 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(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 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 + 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 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 -- cgit v1.2.3