/* -*- Mode: C++; tab-width: 20; 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/. */ #include "DrawTargetRecording.h" #include "PathRecording.h" #include <stdio.h> #include "Logging.h" #include "Tools.h" #include "Filters.h" #include "mozilla/UniquePtr.h" #include "RecordingTypes.h" namespace mozilla { namespace gfx { struct RecordingSourceSurfaceUserData { void *refPtr; RefPtr<DrawEventRecorderPrivate> recorder; }; void RecordingSourceSurfaceUserDataFunc(void *aUserData) { RecordingSourceSurfaceUserData *userData = static_cast<RecordingSourceSurfaceUserData*>(aUserData); userData->recorder->RemoveStoredObject(userData->refPtr); userData->recorder->RecordEvent( RecordedSourceSurfaceDestruction(userData->refPtr)); delete userData; } static void StoreSourceSurface(DrawEventRecorderPrivate *aRecorder, SourceSurface *aSurface, DataSourceSurface *aDataSurf, const char *reason) { if (!aDataSurf) { gfxWarning() << "Recording failed to record SourceSurface for " << reason; // Insert a bogus source surface. int32_t stride = aSurface->GetSize().width * BytesPerPixel(aSurface->GetFormat()); UniquePtr<uint8_t[]> sourceData(new uint8_t[stride * aSurface->GetSize().height]()); aRecorder->RecordEvent( RecordedSourceSurfaceCreation(aSurface, sourceData.get(), stride, aSurface->GetSize(), aSurface->GetFormat())); } else { DataSourceSurface::ScopedMap map(aDataSurf, DataSourceSurface::READ); aRecorder->RecordEvent( RecordedSourceSurfaceCreation(aSurface, map.GetData(), map.GetStride(), aDataSurf->GetSize(), aDataSurf->GetFormat())); } } static void EnsureSurfaceStored(DrawEventRecorderPrivate *aRecorder, SourceSurface *aSurface, const char *reason) { if (aRecorder->HasStoredObject(aSurface)) { return; } RefPtr<DataSourceSurface> dataSurf = aSurface->GetDataSurface(); StoreSourceSurface(aRecorder, aSurface, dataSurf, reason); aRecorder->AddStoredObject(aSurface); RecordingSourceSurfaceUserData *userData = new RecordingSourceSurfaceUserData; userData->refPtr = aSurface; userData->recorder = aRecorder; aSurface->AddUserData(reinterpret_cast<UserDataKey*>(aRecorder), userData, &RecordingSourceSurfaceUserDataFunc); return; } class SourceSurfaceRecording : public SourceSurface { public: MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(SourceSurfaceRecording) SourceSurfaceRecording(SourceSurface *aFinalSurface, DrawEventRecorderPrivate *aRecorder) : mFinalSurface(aFinalSurface), mRecorder(aRecorder) { mRecorder->AddStoredObject(this); } ~SourceSurfaceRecording() { mRecorder->RemoveStoredObject(this); mRecorder->RecordEvent(RecordedSourceSurfaceDestruction(this)); } virtual SurfaceType GetType() const { return SurfaceType::RECORDING; } virtual IntSize GetSize() const { return mFinalSurface->GetSize(); } virtual SurfaceFormat GetFormat() const { return mFinalSurface->GetFormat(); } virtual already_AddRefed<DataSourceSurface> GetDataSurface() { return mFinalSurface->GetDataSurface(); } RefPtr<SourceSurface> mFinalSurface; RefPtr<DrawEventRecorderPrivate> mRecorder; }; class GradientStopsRecording : public GradientStops { public: MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GradientStopsRecording) GradientStopsRecording(GradientStops *aFinalGradientStops, DrawEventRecorderPrivate *aRecorder) : mFinalGradientStops(aFinalGradientStops), mRecorder(aRecorder) { mRecorder->AddStoredObject(this); } ~GradientStopsRecording() { mRecorder->RemoveStoredObject(this); mRecorder->RecordEvent(RecordedGradientStopsDestruction(this)); } virtual BackendType GetBackendType() const { return BackendType::RECORDING; } RefPtr<GradientStops> mFinalGradientStops; RefPtr<DrawEventRecorderPrivate> mRecorder; }; static SourceSurface * GetSourceSurface(SourceSurface *aSurface) { if (aSurface->GetType() != SurfaceType::RECORDING) { return aSurface; } return static_cast<SourceSurfaceRecording*>(aSurface)->mFinalSurface; } static GradientStops * GetGradientStops(GradientStops *aStops) { if (aStops->GetBackendType() != BackendType::RECORDING) { return aStops; } return static_cast<GradientStopsRecording*>(aStops)->mFinalGradientStops; } class FilterNodeRecording : public FilterNode { public: MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeRecording, override) using FilterNode::SetAttribute; FilterNodeRecording(FilterNode *aFinalFilterNode, DrawEventRecorderPrivate *aRecorder) : mFinalFilterNode(aFinalFilterNode), mRecorder(aRecorder) { mRecorder->AddStoredObject(this); } ~FilterNodeRecording() { mRecorder->RemoveStoredObject(this); mRecorder->RecordEvent(RecordedFilterNodeDestruction(this)); } static FilterNode* GetFilterNode(FilterNode* aNode) { if (aNode->GetBackendType() != FILTER_BACKEND_RECORDING) { gfxWarning() << "Non recording filter node used with recording DrawTarget!"; return aNode; } return static_cast<FilterNodeRecording*>(aNode)->mFinalFilterNode; } virtual void SetInput(uint32_t aIndex, SourceSurface *aSurface) override { EnsureSurfaceStored(mRecorder, aSurface, "SetInput"); mRecorder->RecordEvent(RecordedFilterNodeSetInput(this, aIndex, aSurface)); mFinalFilterNode->SetInput(aIndex, GetSourceSurface(aSurface)); } virtual void SetInput(uint32_t aIndex, FilterNode *aFilter) override { MOZ_ASSERT(mRecorder->HasStoredObject(aFilter)); mRecorder->RecordEvent(RecordedFilterNodeSetInput(this, aIndex, aFilter)); mFinalFilterNode->SetInput(aIndex, GetFilterNode(aFilter)); } #define FORWARD_SET_ATTRIBUTE(type, argtype) \ virtual void SetAttribute(uint32_t aIndex, type aValue) override { \ mRecorder->RecordEvent(RecordedFilterNodeSetAttribute(this, aIndex, aValue, RecordedFilterNodeSetAttribute::ARGTYPE_##argtype)); \ mFinalFilterNode->SetAttribute(aIndex, aValue); \ } FORWARD_SET_ATTRIBUTE(bool, BOOL); FORWARD_SET_ATTRIBUTE(uint32_t, UINT32); FORWARD_SET_ATTRIBUTE(Float, FLOAT); FORWARD_SET_ATTRIBUTE(const Size&, SIZE); FORWARD_SET_ATTRIBUTE(const IntSize&, INTSIZE); FORWARD_SET_ATTRIBUTE(const IntPoint&, INTPOINT); FORWARD_SET_ATTRIBUTE(const Rect&, RECT); FORWARD_SET_ATTRIBUTE(const IntRect&, INTRECT); FORWARD_SET_ATTRIBUTE(const Point&, POINT); FORWARD_SET_ATTRIBUTE(const Matrix&, MATRIX); FORWARD_SET_ATTRIBUTE(const Matrix5x4&, MATRIX5X4); FORWARD_SET_ATTRIBUTE(const Point3D&, POINT3D); FORWARD_SET_ATTRIBUTE(const Color&, COLOR); #undef FORWARD_SET_ATTRIBUTE virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) override { mRecorder->RecordEvent(RecordedFilterNodeSetAttribute(this, aIndex, aFloat, aSize)); mFinalFilterNode->SetAttribute(aIndex, aFloat, aSize); } virtual FilterBackend GetBackendType() override { return FILTER_BACKEND_RECORDING; } RefPtr<FilterNode> mFinalFilterNode; RefPtr<DrawEventRecorderPrivate> mRecorder; }; struct AdjustedPattern { explicit AdjustedPattern(const Pattern &aPattern) : mPattern(nullptr) { mOrigPattern = const_cast<Pattern*>(&aPattern); } ~AdjustedPattern() { if (mPattern) { mPattern->~Pattern(); } } operator Pattern*() { switch(mOrigPattern->GetType()) { case PatternType::COLOR: return mOrigPattern; case PatternType::SURFACE: { SurfacePattern *surfPat = static_cast<SurfacePattern*>(mOrigPattern); mPattern = new (mSurfPat) SurfacePattern(GetSourceSurface(surfPat->mSurface), surfPat->mExtendMode, surfPat->mMatrix, surfPat->mSamplingFilter, surfPat->mSamplingRect); return mPattern; } case PatternType::LINEAR_GRADIENT: { LinearGradientPattern *linGradPat = static_cast<LinearGradientPattern*>(mOrigPattern); mPattern = new (mLinGradPat) LinearGradientPattern(linGradPat->mBegin, linGradPat->mEnd, GetGradientStops(linGradPat->mStops), linGradPat->mMatrix); return mPattern; } case PatternType::RADIAL_GRADIENT: { RadialGradientPattern *radGradPat = static_cast<RadialGradientPattern*>(mOrigPattern); mPattern = new (mRadGradPat) RadialGradientPattern(radGradPat->mCenter1, radGradPat->mCenter2, radGradPat->mRadius1, radGradPat->mRadius2, GetGradientStops(radGradPat->mStops), radGradPat->mMatrix); return mPattern; } default: return new (mColPat) ColorPattern(Color()); } return mPattern; } union { char mColPat[sizeof(ColorPattern)]; char mLinGradPat[sizeof(LinearGradientPattern)]; char mRadGradPat[sizeof(RadialGradientPattern)]; char mSurfPat[sizeof(SurfacePattern)]; }; Pattern *mOrigPattern; Pattern *mPattern; }; DrawTargetRecording::DrawTargetRecording(DrawEventRecorder *aRecorder, DrawTarget *aDT, bool aHasData) : mRecorder(static_cast<DrawEventRecorderPrivate*>(aRecorder)) , mFinalDT(aDT) { RefPtr<SourceSurface> snapshot = aHasData ? mFinalDT->Snapshot() : nullptr; mRecorder->RecordEvent(RecordedDrawTargetCreation(this, mFinalDT->GetBackendType(), mFinalDT->GetSize(), mFinalDT->GetFormat(), aHasData, snapshot)); mFormat = mFinalDT->GetFormat(); } DrawTargetRecording::DrawTargetRecording(const DrawTargetRecording *aDT, DrawTarget *aSimilarDT) : mRecorder(aDT->mRecorder) , mFinalDT(aSimilarDT) { mRecorder->RecordEvent(RecordedCreateSimilarDrawTarget(this, mFinalDT->GetSize(), mFinalDT->GetFormat())); mFormat = mFinalDT->GetFormat(); } DrawTargetRecording::~DrawTargetRecording() { mRecorder->RecordEvent(RecordedDrawTargetDestruction(this)); } void DrawTargetRecording::FillRect(const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions) { EnsurePatternDependenciesStored(aPattern); mRecorder->RecordEvent(RecordedFillRect(this, aRect, aPattern, aOptions)); mFinalDT->FillRect(aRect, *AdjustedPattern(aPattern), aOptions); } void DrawTargetRecording::StrokeRect(const Rect &aRect, const Pattern &aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) { EnsurePatternDependenciesStored(aPattern); mRecorder->RecordEvent(RecordedStrokeRect(this, aRect, aPattern, aStrokeOptions, aOptions)); mFinalDT->StrokeRect(aRect, *AdjustedPattern(aPattern), aStrokeOptions, aOptions); } void DrawTargetRecording::StrokeLine(const Point &aBegin, const Point &aEnd, const Pattern &aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) { EnsurePatternDependenciesStored(aPattern); mRecorder->RecordEvent(RecordedStrokeLine(this, aBegin, aEnd, aPattern, aStrokeOptions, aOptions)); mFinalDT->StrokeLine(aBegin, aEnd, *AdjustedPattern(aPattern), aStrokeOptions, aOptions); } void DrawTargetRecording::Fill(const Path *aPath, const Pattern &aPattern, const DrawOptions &aOptions) { RefPtr<PathRecording> pathRecording = EnsurePathStored(aPath); EnsurePatternDependenciesStored(aPattern); mRecorder->RecordEvent(RecordedFill(this, pathRecording, aPattern, aOptions)); mFinalDT->Fill(pathRecording->mPath, *AdjustedPattern(aPattern), aOptions); } struct RecordingFontUserData { void *refPtr; RefPtr<DrawEventRecorderPrivate> recorder; }; void RecordingFontUserDataDestroyFunc(void *aUserData) { RecordingFontUserData *userData = static_cast<RecordingFontUserData*>(aUserData); userData->recorder->RecordEvent(RecordedScaledFontDestruction(userData->refPtr)); delete userData; } void DrawTargetRecording::FillGlyphs(ScaledFont *aFont, const GlyphBuffer &aBuffer, const Pattern &aPattern, const DrawOptions &aOptions, const GlyphRenderingOptions *aRenderingOptions) { EnsurePatternDependenciesStored(aPattern); if (!aFont->GetUserData(reinterpret_cast<UserDataKey*>(mRecorder.get()))) { RecordedFontData fontData(aFont); RecordedFontDetails fontDetails; if (fontData.GetFontDetails(fontDetails)) { // Try to serialise the whole font, just in case this is a web font that // is not present on the system. if (!mRecorder->HasStoredFontData(fontDetails.fontDataKey)) { mRecorder->RecordEvent(fontData); mRecorder->AddStoredFontData(fontDetails.fontDataKey); } mRecorder->RecordEvent(RecordedScaledFontCreation(aFont, fontDetails)); } else { // If that fails, record just the font description and try to load it from // the system on the other side. RecordedFontDescriptor fontDesc(aFont); if (fontDesc.IsValid()) { mRecorder->RecordEvent(fontDesc); } else { gfxWarning() << "DrawTargetRecording::FillGlyphs failed to serialise ScaledFont"; } } RecordingFontUserData *userData = new RecordingFontUserData; userData->refPtr = aFont; userData->recorder = mRecorder; aFont->AddUserData(reinterpret_cast<UserDataKey*>(mRecorder.get()), userData, &RecordingFontUserDataDestroyFunc); } mRecorder->RecordEvent(RecordedFillGlyphs(this, aFont, aPattern, aOptions, aBuffer.mGlyphs, aBuffer.mNumGlyphs)); mFinalDT->FillGlyphs(aFont, aBuffer, *AdjustedPattern(aPattern), aOptions, aRenderingOptions); } void DrawTargetRecording::Mask(const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions) { EnsurePatternDependenciesStored(aSource); EnsurePatternDependenciesStored(aMask); mRecorder->RecordEvent(RecordedMask(this, aSource, aMask, aOptions)); mFinalDT->Mask(*AdjustedPattern(aSource), *AdjustedPattern(aMask), aOptions); } void DrawTargetRecording::MaskSurface(const Pattern &aSource, SourceSurface *aMask, Point aOffset, const DrawOptions &aOptions) { EnsurePatternDependenciesStored(aSource); EnsureSurfaceStored(mRecorder, aMask, "MaskSurface"); mRecorder->RecordEvent(RecordedMaskSurface(this, aSource, aMask, aOffset, aOptions)); mFinalDT->MaskSurface(*AdjustedPattern(aSource), GetSourceSurface(aMask), aOffset, aOptions); } void DrawTargetRecording::Stroke(const Path *aPath, const Pattern &aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) { RefPtr<PathRecording> pathRecording = EnsurePathStored(aPath); EnsurePatternDependenciesStored(aPattern); mRecorder->RecordEvent(RecordedStroke(this, pathRecording, aPattern, aStrokeOptions, aOptions)); mFinalDT->Stroke(pathRecording->mPath, *AdjustedPattern(aPattern), aStrokeOptions, aOptions); } already_AddRefed<SourceSurface> DrawTargetRecording::Snapshot() { RefPtr<SourceSurface> surf = mFinalDT->Snapshot(); RefPtr<SourceSurface> retSurf = new SourceSurfaceRecording(surf, mRecorder); mRecorder->RecordEvent(RecordedSnapshot(retSurf, this)); return retSurf.forget(); } void DrawTargetRecording::DetachAllSnapshots() { mFinalDT->DetachAllSnapshots(); } void DrawTargetRecording::DrawSurface(SourceSurface *aSurface, const Rect &aDest, const Rect &aSource, const DrawSurfaceOptions &aSurfOptions, const DrawOptions &aOptions) { EnsureSurfaceStored(mRecorder, aSurface, "DrawSurface"); mRecorder->RecordEvent(RecordedDrawSurface(this, aSurface, aDest, aSource, aSurfOptions, aOptions)); mFinalDT->DrawSurface(GetSourceSurface(aSurface), aDest, aSource, aSurfOptions, aOptions); } void DrawTargetRecording::DrawSurfaceWithShadow(SourceSurface *aSurface, const Point &aDest, const Color &aColor, const Point &aOffset, Float aSigma, CompositionOp aOp) { EnsureSurfaceStored(mRecorder, aSurface, "DrawSurfaceWithShadow"); mRecorder->RecordEvent(RecordedDrawSurfaceWithShadow(this, aSurface, aDest, aColor, aOffset, aSigma, aOp)); mFinalDT->DrawSurfaceWithShadow(GetSourceSurface(aSurface), aDest, aColor, aOffset, aSigma, aOp); } void DrawTargetRecording::DrawFilter(FilterNode *aNode, const Rect &aSourceRect, const Point &aDestPoint, const DrawOptions &aOptions) { MOZ_ASSERT(mRecorder->HasStoredObject(aNode)); mRecorder->RecordEvent(RecordedDrawFilter(this, aNode, aSourceRect, aDestPoint, aOptions)); mFinalDT->DrawFilter(FilterNodeRecording::GetFilterNode(aNode), aSourceRect, aDestPoint, aOptions); } already_AddRefed<FilterNode> DrawTargetRecording::CreateFilter(FilterType aType) { RefPtr<FilterNode> node = mFinalDT->CreateFilter(aType); RefPtr<FilterNode> retNode = new FilterNodeRecording(node, mRecorder); mRecorder->RecordEvent(RecordedFilterNodeCreation(retNode, aType)); return retNode.forget(); } void DrawTargetRecording::ClearRect(const Rect &aRect) { mRecorder->RecordEvent(RecordedClearRect(this, aRect)); mFinalDT->ClearRect(aRect); } void DrawTargetRecording::CopySurface(SourceSurface *aSurface, const IntRect &aSourceRect, const IntPoint &aDestination) { EnsureSurfaceStored(mRecorder, aSurface, "CopySurface"); mRecorder->RecordEvent(RecordedCopySurface(this, aSurface, aSourceRect, aDestination)); mFinalDT->CopySurface(GetSourceSurface(aSurface), aSourceRect, aDestination); } void DrawTargetRecording::PushClip(const Path *aPath) { RefPtr<PathRecording> pathRecording = EnsurePathStored(aPath); mRecorder->RecordEvent(RecordedPushClip(this, pathRecording)); mFinalDT->PushClip(pathRecording->mPath); } void DrawTargetRecording::PushClipRect(const Rect &aRect) { mRecorder->RecordEvent(RecordedPushClipRect(this, aRect)); mFinalDT->PushClipRect(aRect); } void DrawTargetRecording::PopClip() { mRecorder->RecordEvent(RecordedPopClip(this)); mFinalDT->PopClip(); } void DrawTargetRecording::PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask, const Matrix& aMaskTransform, const IntRect& aBounds, bool aCopyBackground) { if (aMask) { EnsureSurfaceStored(mRecorder, aMask, "PushLayer"); } mRecorder->RecordEvent(RecordedPushLayer(this, aOpaque, aOpacity, aMask, aMaskTransform, aBounds, aCopyBackground)); mFinalDT->PushLayer(aOpaque, aOpacity, aMask, aMaskTransform, aBounds, aCopyBackground); } void DrawTargetRecording::PopLayer() { mRecorder->RecordEvent(RecordedPopLayer(this)); mFinalDT->PopLayer(); } already_AddRefed<SourceSurface> DrawTargetRecording::CreateSourceSurfaceFromData(unsigned char *aData, const IntSize &aSize, int32_t aStride, SurfaceFormat aFormat) const { RefPtr<SourceSurface> surf = mFinalDT->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat); RefPtr<SourceSurface> retSurf = new SourceSurfaceRecording(surf, mRecorder); mRecorder->RecordEvent(RecordedSourceSurfaceCreation(retSurf, aData, aStride, aSize, aFormat)); return retSurf.forget(); } already_AddRefed<SourceSurface> DrawTargetRecording::OptimizeSourceSurface(SourceSurface *aSurface) const { RefPtr<SourceSurface> surf = mFinalDT->OptimizeSourceSurface(aSurface); RefPtr<SourceSurface> retSurf = new SourceSurfaceRecording(surf, mRecorder); RefPtr<DataSourceSurface> dataSurf = surf->GetDataSurface(); if (!dataSurf) { // Let's try get it off the original surface. dataSurf = aSurface->GetDataSurface(); } StoreSourceSurface(mRecorder, retSurf, dataSurf, "OptimizeSourceSurface"); return retSurf.forget(); } already_AddRefed<SourceSurface> DrawTargetRecording::CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const { RefPtr<SourceSurface> surf = mFinalDT->CreateSourceSurfaceFromNativeSurface(aSurface); RefPtr<SourceSurface> retSurf = new SourceSurfaceRecording(surf, mRecorder); RefPtr<DataSourceSurface> dataSurf = surf->GetDataSurface(); StoreSourceSurface(mRecorder, retSurf, dataSurf, "CreateSourceSurfaceFromNativeSurface"); return retSurf.forget(); } already_AddRefed<DrawTarget> DrawTargetRecording::CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const { RefPtr<DrawTarget> similarDT = mFinalDT->CreateSimilarDrawTarget(aSize, aFormat); if (!similarDT) { return nullptr; } similarDT = new DrawTargetRecording(this, similarDT); return similarDT.forget(); } already_AddRefed<PathBuilder> DrawTargetRecording::CreatePathBuilder(FillRule aFillRule) const { RefPtr<PathBuilder> builder = mFinalDT->CreatePathBuilder(aFillRule); return MakeAndAddRef<PathBuilderRecording>(builder, aFillRule); } already_AddRefed<GradientStops> DrawTargetRecording::CreateGradientStops(GradientStop *aStops, uint32_t aNumStops, ExtendMode aExtendMode) const { RefPtr<GradientStops> stops = mFinalDT->CreateGradientStops(aStops, aNumStops, aExtendMode); RefPtr<GradientStops> retStops = new GradientStopsRecording(stops, mRecorder); mRecorder->RecordEvent(RecordedGradientStopsCreation(retStops, aStops, aNumStops, aExtendMode)); return retStops.forget(); } void DrawTargetRecording::SetTransform(const Matrix &aTransform) { mRecorder->RecordEvent(RecordedSetTransform(this, aTransform)); DrawTarget::SetTransform(aTransform); mFinalDT->SetTransform(aTransform); } already_AddRefed<PathRecording> DrawTargetRecording::EnsurePathStored(const Path *aPath) { RefPtr<PathRecording> pathRecording; if (aPath->GetBackendType() == BackendType::RECORDING) { pathRecording = const_cast<PathRecording*>(static_cast<const PathRecording*>(aPath)); if (mRecorder->HasStoredObject(aPath)) { return pathRecording.forget(); } } else { MOZ_ASSERT(!mRecorder->HasStoredObject(aPath)); FillRule fillRule = aPath->GetFillRule(); RefPtr<PathBuilder> builder = mFinalDT->CreatePathBuilder(fillRule); RefPtr<PathBuilderRecording> builderRecording = new PathBuilderRecording(builder, fillRule); aPath->StreamToSink(builderRecording); pathRecording = builderRecording->Finish().downcast<PathRecording>(); } mRecorder->RecordEvent(RecordedPathCreation(pathRecording)); mRecorder->AddStoredObject(pathRecording); pathRecording->mStoredRecorders.push_back(mRecorder); return pathRecording.forget(); } void DrawTargetRecording::EnsurePatternDependenciesStored(const Pattern &aPattern) { switch (aPattern.GetType()) { case PatternType::COLOR: // No dependencies here. return; case PatternType::LINEAR_GRADIENT: { MOZ_ASSERT(mRecorder->HasStoredObject(static_cast<const LinearGradientPattern*>(&aPattern)->mStops)); return; } case PatternType::RADIAL_GRADIENT: { MOZ_ASSERT(mRecorder->HasStoredObject(static_cast<const RadialGradientPattern*>(&aPattern)->mStops)); return; } case PatternType::SURFACE: { const SurfacePattern *pat = static_cast<const SurfacePattern*>(&aPattern); EnsureSurfaceStored(mRecorder, pat->mSurface, "EnsurePatternDependenciesStored"); return; } } } } // namespace gfx } // namespace mozilla