/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h

Bug Summary

File:	var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h
Warning:	line 2717, column 3 Memory allocated by malloc() should be deallocated by free(), not 'delete[]'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name InlineTranslator.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/gfx/2d -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/gfx/2d -resource-dir /usr/lib/llvm-19/lib/clang/19 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D USE_SSE2 -D USE_CAIRO -D MOZ2D_HAS_MOZ_CAIRO -D MOZ_ENABLE_FREETYPE -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /var/lib/jenkins/workspace/firefox-scan-build/gfx/2d -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/gfx/2d -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/gfx/skia -I /var/lib/jenkins/workspace/firefox-scan-build/gfx/skia/skia -I /var/lib/jenkins/workspace/firefox-scan-build/gfx/cairo/cairo/src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/freetype2 -I /usr/include/libpng16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-09-22-115206-3586786-1 -x c++ /var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/InlineTranslator.cpp

/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/InlineTranslator.cpp

→

1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 
7#include "InlineTranslator.h"
8#include "RecordedEventImpl.h"
9 
10#include "mozilla/gfx/RecordingTypes.h"
11 
12using namespace mozilla::gfx;
13 
14namespace mozilla::gfx {
15 
16InlineTranslator::InlineTranslator() : mFontContext(nullptr) {}
17 
18InlineTranslator::InlineTranslator(DrawTarget* aDT, void* aFontContext)
19    : mBaseDT(aDT), mFontContext(aFontContext) {}
20 
21bool InlineTranslator::TranslateRecording(char* aData, size_t aLen) {
22  MemReader reader(aData, aLen);
23 
24  uint32_t magicInt;
25  ReadElement(reader, magicInt);
26  if (magicInt != mozilla::gfx::kMagicInt) {
1
Assuming 'magicInt' is equal to 'kMagicInt'→
2
←
Taking false branch→
27    mError = "Magic";
28    return false;
29  }
30 
31  uint16_t majorRevision;
32  ReadElement(reader, majorRevision);
33  if (majorRevision != kMajorRevision) {
3
←
Assuming 'majorRevision' is equal to 'kMajorRevision'→
4
←
Taking false branch→
34    mError = "Major";
35    return false;
36  }
37 
38  uint16_t minorRevision;
39  ReadElement(reader, minorRevision);
40  if (minorRevision > kMinorRevision) {
5
←
Assuming 'minorRevision' is <= 'kMinorRevision'→
6
←
Taking false branch→
41    mError = "Minor";
42    return false;
43  }
44 
45  uint8_t eventType = RecordedEvent::EventType::INVALID;
46  ReadElement(reader, eventType);
47  while (reader.good()) {
7
←
Loop condition is true.  Entering loop body→
9
←
Loop condition is true.  Entering loop body→
48    bool success = RecordedEvent::DoWithEvent(
10
←
Calling 'RecordedEvent::DoWithEvent'→
49        reader, static_cast<RecordedEvent::EventType>(eventType),
50        [&](RecordedEvent* recordedEvent) -> bool {
51          // Make sure that the whole event was read from the stream
52          // successfully.
53          if (!reader.good()) {
54            mError = " READ";
55            return false;
56          }
57 
58          if (!recordedEvent->PlayEvent(this)) {
59            mError = " PLAY";
60            return false;
61          }
62 
63          return true;
64        });
65    if (!success7.1
'success' is true
7.1
'success' is true
7.1
'success' is true
) {
8
←
Taking false branch→
66      mError = RecordedEvent::GetEventName(
67                   static_cast<RecordedEvent::EventType>(eventType)) +
68               mError;
69      return false;
70    }
71 
72    ReadElement(reader, eventType);
73  }
74 
75  return true;
76}
77 
78already_AddRefed<DrawTarget> InlineTranslator::CreateDrawTarget(
79    ReferencePtr aRefPtr, const gfx::IntSize& aSize,
80    gfx::SurfaceFormat aFormat) {
81  MOZ_ASSERT(mBaseDT, "mBaseDT has not been initialized.")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mBaseDT)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mBaseDT))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mBaseDT" " (" "mBaseDT has not been initialized."
 ")", "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/InlineTranslator.cpp"
, 81); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mBaseDT" ") ("
 "mBaseDT has not been initialized." ")"); do { *((volatile int
*)__null) = 81; __attribute__((nomerge)) ::abort(); } while (
false); } } while (false);
82 
83  RefPtr<DrawTarget> drawTarget = mBaseDT;
84  AddDrawTarget(aRefPtr, drawTarget);
85  return drawTarget.forget();
86}
87 
88already_AddRefed<SourceSurface> InlineTranslator::LookupExternalSurface(
89    uint64_t aKey) {
90  if (!mExternalSurfaces) {
91    return nullptr;
92  }
93  RefPtr<SourceSurface> surface = mExternalSurfaces->Get(aKey);
94  return surface.forget();
95}
96 
97}  // namespace mozilla::gfx

←

/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h

→

1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* 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/. */

7#ifndef MOZILLA_GFX_RECORDEDEVENTIMPL_H_
8#define MOZILLA_GFX_RECORDEDEVENTIMPL_H_

10#include "RecordedEvent.h"

12#include "PathRecording.h"
13#include "RecordingTypes.h"
14#include "Tools.h"
15#include "Filters.h"
16#include "Logging.h"
17#include "ScaledFontBase.h"
18#include "SFNTData.h"

20#include "mozilla/layers/LayersSurfaces.h"

22namespace mozilla {
23namespace gfx {

25class RecordedDrawTargetCreation
  : public RecordedEventDerived<RecordedDrawTargetCreation> {
public:
RecordedDrawTargetCreation(ReferencePtr aRefPtr, BackendType aType,
                           const IntRect& aRect, SurfaceFormat aFormat,
                           bool aHasExistingData = false,
                           SourceSurface* aExistingData = nullptr)
    : RecordedEventDerived(DRAWTARGETCREATION),
      mRefPtr(aRefPtr),
      mBackendType(aType),
      mRect(aRect),
      mFormat(aFormat),
      mHasExistingData(aHasExistingData),
      mExistingData(aExistingData) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawTarget Creation"; }

ReferencePtr mRefPtr;
BackendType mBackendType;
IntRect mRect;
SurfaceFormat mFormat;
bool mHasExistingData = false;
RefPtr<SourceSurface> mExistingData;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawTargetCreation(S& aStream);
61};

63class RecordedDrawTargetDestruction
  : public RecordedEventDerived<RecordedDrawTargetDestruction> {
public:
MOZ_IMPLICIT RecordedDrawTargetDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(DRAWTARGETDESTRUCTION),
      mRefPtr(aRefPtr),
      mBackendType(BackendType::NONE) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawTarget Destruction"; }

ReferencePtr mRefPtr;

BackendType mBackendType;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawTargetDestruction(S& aStream);
88};

90class RecordedSetCurrentDrawTarget
  : public RecordedEventDerived<RecordedSetCurrentDrawTarget> {
public:
MOZ_IMPLICIT RecordedSetCurrentDrawTarget(ReferencePtr aRefPtr)
    : RecordedEventDerived(SETCURRENTDRAWTARGET), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SetCurrentDrawTarget"; }

ReferencePtr mRefPtr;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedSetCurrentDrawTarget(S& aStream);
111};

113class RecordedCreateSimilarDrawTarget
  : public RecordedEventDerived<RecordedCreateSimilarDrawTarget> {
public:
RecordedCreateSimilarDrawTarget(ReferencePtr aRefPtr, const IntSize& aSize,
                                SurfaceFormat aFormat)
    : RecordedEventDerived(CREATESIMILARDRAWTARGET),
      mRefPtr(aRefPtr),
      mSize(aSize),
      mFormat(aFormat) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override { return "CreateSimilarDrawTarget"; }

ReferencePtr mRefPtr;
IntSize mSize;
SurfaceFormat mFormat;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedCreateSimilarDrawTarget(S& aStream);
141};

143class RecordedCreateClippedDrawTarget
  : public RecordedEventDerived<RecordedCreateClippedDrawTarget> {
public:
RecordedCreateClippedDrawTarget(ReferencePtr aRefPtr, const Rect& aBounds,
                                SurfaceFormat aFormat)
    : RecordedEventDerived(CREATECLIPPEDDRAWTARGET),
      mRefPtr(aRefPtr),
      mBounds(aBounds),
      mFormat(aFormat) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override { return "CreateClippedDrawTarget"; }

ReferencePtr mRefPtr;
Rect mBounds;
SurfaceFormat mFormat;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedCreateClippedDrawTarget(S& aStream);
171};

173class RecordedCreateDrawTargetForFilter
  : public RecordedEventDerived<RecordedCreateDrawTargetForFilter> {
public:
RecordedCreateDrawTargetForFilter(ReferencePtr aRefPtr,
                                  const IntSize& aMaxSize,
                                  SurfaceFormat aFormat, FilterNode* aFilter,
                                  FilterNode* aSource,
                                  const Rect& aSourceRect,
                                  const Point& aDestPoint)
    : RecordedEventDerived(CREATEDRAWTARGETFORFILTER),
      mRefPtr(aRefPtr),
      mMaxSize(aMaxSize),
      mFormat(aFormat),
      mFilter(aFilter),
      mSource(aSource),
      mSourceRect(aSourceRect),
      mDestPoint(aDestPoint) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override {
  return "CreateSimilarDrawTargetForFilter";
}

ReferencePtr mRefPtr;
IntSize mMaxSize;
SurfaceFormat mFormat;
ReferencePtr mFilter;
ReferencePtr mSource;
Rect mSourceRect;
Point mDestPoint;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedCreateDrawTargetForFilter(S& aStream);
215};

217class RecordedFillRect : public RecordedEventDerived<RecordedFillRect> {
public:
RecordedFillRect(const Rect& aRect, const Pattern& aPattern,
                 const DrawOptions& aOptions)
    : RecordedEventDerived(FILLRECT),
      mRect(aRect),
      mPattern(),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "FillRect"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedFillRect(S& aStream);

Rect mRect;
PatternStorage mPattern;
DrawOptions mOptions;
245};

247class RecordedStrokeRect : public RecordedEventDerived<RecordedStrokeRect> {
public:
RecordedStrokeRect(const Rect& aRect, const Pattern& aPattern,
                   const StrokeOptions& aStrokeOptions,
                   const DrawOptions& aOptions)
    : RecordedEventDerived(STROKERECT),
      mRect(aRect),
      mPattern(),
      mStrokeOptions(aStrokeOptions),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "StrokeRect"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedStrokeRect(S& aStream);

Rect mRect;
PatternStorage mPattern;
StrokeOptions mStrokeOptions;
DrawOptions mOptions;
278};

280class RecordedStrokeLine : public RecordedEventDerived<RecordedStrokeLine> {
public:
RecordedStrokeLine(const Point& aBegin, const Point& aEnd,
                   const Pattern& aPattern,
                   const StrokeOptions& aStrokeOptions,
                   const DrawOptions& aOptions)
    : RecordedEventDerived(STROKELINE),
      mBegin(aBegin),
      mEnd(aEnd),
      mPattern(),
      mStrokeOptions(aStrokeOptions),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "StrokeLine"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedStrokeLine(S& aStream);

Point mBegin;
Point mEnd;
PatternStorage mPattern;
StrokeOptions mStrokeOptions;
DrawOptions mOptions;
314};

316class RecordedStrokeCircle : public RecordedEventDerived<RecordedStrokeCircle> {
public:
RecordedStrokeCircle(Circle aCircle, const Pattern& aPattern,
                     const StrokeOptions& aStrokeOptions,
                     const DrawOptions& aOptions)
    : RecordedEventDerived(STROKECIRCLE),
      mCircle(aCircle),
      mPattern(),
      mStrokeOptions(aStrokeOptions),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "StrokeCircle"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedStrokeCircle(S& aStream);

Circle mCircle;
PatternStorage mPattern;
StrokeOptions mStrokeOptions;
DrawOptions mOptions;
347};

349class RecordedFill : public RecordedEventDerived<RecordedFill> {
public:
RecordedFill(ReferencePtr aPath, const Pattern& aPattern,
             const DrawOptions& aOptions)
    : RecordedEventDerived(FILL),
      mPath(aPath),
      mPattern(),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Fill"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedFill(S& aStream);

ReferencePtr mPath;
PatternStorage mPattern;
DrawOptions mOptions;
377};

379class RecordedFillCircle : public RecordedEventDerived<RecordedFillCircle> {
public:
RecordedFillCircle(Circle aCircle, const Pattern& aPattern,
                   const DrawOptions& aOptions)
    : RecordedEventDerived(FILLCIRCLE),
      mCircle(aCircle),
      mPattern(),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "FillCircle"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedFillCircle(S& aStream);

Circle mCircle;
PatternStorage mPattern;
DrawOptions mOptions;
407};

409template <class Derived>
410class RecordedDrawGlyphs : public RecordedEventDerived<Derived> {
public:
RecordedDrawGlyphs(RecordedEvent::EventType aType, ReferencePtr aScaledFont,
                   const Pattern& aPattern, const DrawOptions& aOptions,
                   const Glyph* aGlyphs, uint32_t aNumGlyphs)
    : RecordedEventDerived<Derived>(aType),
      mScaledFont(aScaledFont),
      mPattern(),
      mOptions(aOptions) {
  this->StorePattern(mPattern, aPattern);
  mNumGlyphs = aNumGlyphs;
  mGlyphs = new Glyph[aNumGlyphs];
  memcpy(mGlyphs, aGlyphs, sizeof(Glyph) * aNumGlyphs);
}
virtual ~RecordedDrawGlyphs();

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

protected:
friend class RecordedEvent;

template <class S>
RecordedDrawGlyphs(RecordedEvent::EventType aType, S& aStream);

virtual void DrawGlyphs(DrawTarget* aDT, ScaledFont* aScaledFont,
                        const GlyphBuffer& aBuffer,
                        const Pattern& aPattern) const = 0;

ReferencePtr mScaledFont;
PatternStorage mPattern;
DrawOptions mOptions;
Glyph* mGlyphs = nullptr;
uint32_t mNumGlyphs = 0;
447};

449class RecordedFillGlyphs : public RecordedDrawGlyphs<RecordedFillGlyphs> {
public:
RecordedFillGlyphs(ReferencePtr aScaledFont, const Pattern& aPattern,
                   const DrawOptions& aOptions, const Glyph* aGlyphs,
                   uint32_t aNumGlyphs)
    : RecordedDrawGlyphs(FILLGLYPHS, aScaledFont, aPattern, aOptions, aGlyphs,
                         aNumGlyphs) {}

std::string GetName() const override { return "FillGlyphs"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedFillGlyphs(S& aStream)
    : RecordedDrawGlyphs(FILLGLYPHS, aStream) {}
13
←
Calling constructor for 'RecordedDrawGlyphs<mozilla::gfx::RecordedFillGlyphs>'→
22
←
Returning from constructor for 'RecordedDrawGlyphs<mozilla::gfx::RecordedFillGlyphs>'→

void DrawGlyphs(DrawTarget* aDT, ScaledFont* aScaledFont,
                const GlyphBuffer& aBuffer,
                const Pattern& aPattern) const override {
  aDT->FillGlyphs(aScaledFont, aBuffer, aPattern, mOptions);
}
471};

473class RecordedStrokeGlyphs : public RecordedDrawGlyphs<RecordedStrokeGlyphs> {
public:
RecordedStrokeGlyphs(ReferencePtr aScaledFont, const Pattern& aPattern,
                     const StrokeOptions& aStrokeOptions,
                     const DrawOptions& aOptions, const Glyph* aGlyphs,
                     uint32_t aNumGlyphs)
    : RecordedDrawGlyphs(STROKEGLYPHS, aScaledFont, aPattern, aOptions,
                         aGlyphs, aNumGlyphs),
      mStrokeOptions(aStrokeOptions) {}

std::string GetName() const override { return "StrokeGlyphs"; }

template <class S>
void Record(S& aStream) const {
  RecordedDrawGlyphs::Record(aStream);
  RecordStrokeOptions(aStream, mStrokeOptions);
}

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedStrokeGlyphs(S& aStream)
    : RecordedDrawGlyphs(STROKEGLYPHS, aStream) {
  ReadStrokeOptions(aStream, mStrokeOptions);
}

void DrawGlyphs(DrawTarget* aDT, ScaledFont* aScaledFont,
                const GlyphBuffer& aBuffer,
                const Pattern& aPattern) const override {
  aDT->StrokeGlyphs(aScaledFont, aBuffer, aPattern, mStrokeOptions, mOptions);
}

StrokeOptions mStrokeOptions;
507};

509class RecordedMask : public RecordedEventDerived<RecordedMask> {
public:
RecordedMask(const Pattern& aSource, const Pattern& aMask,
             const DrawOptions& aOptions)
    : RecordedEventDerived(MASK), mSource(), mMask(), mOptions(aOptions) {
  StorePattern(mSource, aSource);
  StorePattern(mMask, aMask);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Mask"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedMask(S& aStream);

PatternStorage mSource;
PatternStorage mMask;
DrawOptions mOptions;
535};

537class RecordedStroke : public RecordedEventDerived<RecordedStroke> {
public:
RecordedStroke(ReferencePtr aPath, const Pattern& aPattern,
               const StrokeOptions& aStrokeOptions,
               const DrawOptions& aOptions)
    : RecordedEventDerived(STROKE),
      mPath(aPath),
      mPattern(),
      mStrokeOptions(aStrokeOptions),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Stroke"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedStroke(S& aStream);

ReferencePtr mPath;
PatternStorage mPattern;
StrokeOptions mStrokeOptions;
DrawOptions mOptions;
569};

571class RecordedClearRect : public RecordedEventDerived<RecordedClearRect> {
public:
explicit RecordedClearRect(const Rect& aRect)
    : RecordedEventDerived(CLEARRECT), mRect(aRect) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "ClearRect"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedClearRect(S& aStream);

Rect mRect;
591};

593class RecordedCopySurface : public RecordedEventDerived<RecordedCopySurface> {
public:
RecordedCopySurface(ReferencePtr aSourceSurface, const IntRect& aSourceRect,
                    const IntPoint& aDest)
    : RecordedEventDerived(COPYSURFACE),
      mSourceSurface(aSourceSurface),
      mSourceRect(aSourceRect),
      mDest(aDest) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "CopySurface"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedCopySurface(S& aStream);

ReferencePtr mSourceSurface;
IntRect mSourceRect;
IntPoint mDest;
619};

621class RecordedPushClip : public RecordedEventDerived<RecordedPushClip> {
public:
explicit RecordedPushClip(ReferencePtr aPath)
    : RecordedEventDerived(PUSHCLIP), mPath(aPath) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PushClip"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPushClip(S& aStream);

ReferencePtr mPath;
641};

643class RecordedPushClipRect : public RecordedEventDerived<RecordedPushClipRect> {
public:
explicit RecordedPushClipRect(const Rect& aRect)
    : RecordedEventDerived(PUSHCLIPRECT), mRect(aRect) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PushClipRect"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPushClipRect(S& aStream);

Rect mRect;
663};

665class RecordedPopClip : public RecordedEventDerived<RecordedPopClip> {
public:
MOZ_IMPLICIT RecordedPopClip() : RecordedEventDerived(POPCLIP) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PopClip"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPopClip(S& aStream);
682};

684class RecordedRemoveAllClips
  : public RecordedEventDerived<RecordedRemoveAllClips> {
public:
MOZ_IMPLICIT RecordedRemoveAllClips()
    : RecordedEventDerived(REMOVEALLCLIPS) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "RemoveAllClips"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedRemoveAllClips(S& aStream);
703};

705class RecordedPushLayer : public RecordedEventDerived<RecordedPushLayer> {
public:
RecordedPushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask,
                  const Matrix& aMaskTransform, const IntRect& aBounds,
                  bool aCopyBackground)
    : RecordedEventDerived(PUSHLAYER),
      mOpaque(aOpaque),
      mOpacity(aOpacity),
      mMask(aMask),
      mMaskTransform(aMaskTransform),
      mBounds(aBounds),
      mCopyBackground(aCopyBackground) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PushLayer"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPushLayer(S& aStream);

bool mOpaque;
Float mOpacity;
ReferencePtr mMask;
Matrix mMaskTransform;
IntRect mBounds;
bool mCopyBackground;
738};

740class RecordedPushLayerWithBlend
  : public RecordedEventDerived<RecordedPushLayerWithBlend> {
public:
RecordedPushLayerWithBlend(bool aOpaque, Float aOpacity, SourceSurface* aMask,
                           const Matrix& aMaskTransform,
                           const IntRect& aBounds, bool aCopyBackground,
                           CompositionOp aCompositionOp)
    : RecordedEventDerived(PUSHLAYERWITHBLEND),
      mOpaque(aOpaque),
      mOpacity(aOpacity),
      mMask(aMask),
      mMaskTransform(aMaskTransform),
      mBounds(aBounds),
      mCopyBackground(aCopyBackground),
      mCompositionOp(aCompositionOp) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PushLayerWithBlend"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPushLayerWithBlend(S& aStream);

bool mOpaque;
Float mOpacity;
ReferencePtr mMask;
Matrix mMaskTransform;
IntRect mBounds;
bool mCopyBackground;
CompositionOp mCompositionOp;
778};

780class RecordedPopLayer : public RecordedEventDerived<RecordedPopLayer> {
public:
RecordedPopLayer() : RecordedEventDerived(POPLAYER) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "PopLayer"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedPopLayer(S& aStream);
797};

799class RecordedSetPermitSubpixelAA
  : public RecordedEventDerived<RecordedSetPermitSubpixelAA> {
public:
explicit RecordedSetPermitSubpixelAA(bool aPermitSubpixelAA)
    : RecordedEventDerived(SETPERMITSUBPIXELAA),
      mPermitSubpixelAA(aPermitSubpixelAA) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SetPermitSubpixelAA"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedSetPermitSubpixelAA(S& aStream);

bool mPermitSubpixelAA = false;
821};

823class RecordedSetTransform : public RecordedEventDerived<RecordedSetTransform> {
public:
explicit RecordedSetTransform(const Matrix& aTransform)
    : RecordedEventDerived(SETTRANSFORM), mTransform(aTransform) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SetTransform"; }

Matrix mTransform;

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedSetTransform(S& aStream);
843};

845class RecordedDrawSurface : public RecordedEventDerived<RecordedDrawSurface> {
public:
RecordedDrawSurface(ReferencePtr aRefSource, const Rect& aDest,
                    const Rect& aSource, const DrawSurfaceOptions& aDSOptions,
                    const DrawOptions& aOptions)
    : RecordedEventDerived(DRAWSURFACE),
      mRefSource(aRefSource),
      mDest(aDest),
      mSource(aSource),
      mDSOptions(aDSOptions),
      mOptions(aOptions) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawSurface"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawSurface(S& aStream);

ReferencePtr mRefSource;
Rect mDest;
Rect mSource;
DrawSurfaceOptions mDSOptions;
DrawOptions mOptions;
876};

878class RecordedDrawSurfaceDescriptor
  : public RecordedEventDerived<RecordedDrawSurfaceDescriptor> {
public:
RecordedDrawSurfaceDescriptor(const layers::SurfaceDescriptor& aDesc,
                              const Rect& aDest, const Rect& aSource,
                              const DrawSurfaceOptions& aDSOptions,
                              const DrawOptions& aOptions)
    : RecordedEventDerived(DRAWSURFACEDESCRIPTOR),
      mDesc(aDesc),
      mDest(aDest),
      mSource(aSource),
      mDSOptions(aDSOptions),
      mOptions(aOptions) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawSurfaceDescriptor"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawSurfaceDescriptor(S& aStream);

layers::SurfaceDescriptor mDesc;
Rect mDest;
Rect mSource;
DrawSurfaceOptions mDSOptions;
DrawOptions mOptions;
911};

913class RecordedDrawDependentSurface
  : public RecordedEventDerived<RecordedDrawDependentSurface> {
public:
RecordedDrawDependentSurface(uint64_t aId, const Rect& aDest)
    : RecordedEventDerived(DRAWDEPENDENTSURFACE), mId(aId), mDest(aDest) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawDependentSurface"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawDependentSurface(S& aStream);

uint64_t mId;
Rect mDest;
935};

937class RecordedDrawSurfaceWithShadow
  : public RecordedEventDerived<RecordedDrawSurfaceWithShadow> {
public:
RecordedDrawSurfaceWithShadow(ReferencePtr aRefSource, const Point& aDest,
                              const ShadowOptions& aShadow, CompositionOp aOp)
    : RecordedEventDerived(DRAWSURFACEWITHSHADOW),
      mRefSource(aRefSource),
      mDest(aDest),
      mShadow(aShadow),
      mOp(aOp) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawSurfaceWithShadow"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawSurfaceWithShadow(S& aStream);

ReferencePtr mRefSource;
Point mDest;
ShadowOptions mShadow;
CompositionOp mOp;
966};

968class RecordedDrawShadow : public RecordedEventDerived<RecordedDrawShadow> {
public:
RecordedDrawShadow(ReferencePtr aPath, const Pattern& aPattern,
                   const ShadowOptions& aShadow, const DrawOptions& aOptions,
                   const StrokeOptions* aStrokeOptions)
    : RecordedEventDerived(DRAWSHADOW),
      mPath(aPath),
      mPattern(),
      mShadow(aShadow),
      mOptions(aOptions),
      mHasStrokeOptions(!!aStrokeOptions),
      mStrokeOptions(aStrokeOptions ? *aStrokeOptions : StrokeOptions()) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawShadow"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawShadow(S& aStream);

ReferencePtr mPath;
PatternStorage mPattern;
ShadowOptions mShadow;
DrawOptions mOptions;
bool mHasStrokeOptions;
StrokeOptions mStrokeOptions;
1003};

1005class RecordedDrawFilter : public RecordedEventDerived<RecordedDrawFilter> {
public:
RecordedDrawFilter(ReferencePtr aNode, const Rect& aSourceRect,
                   const Point& aDestPoint, const DrawOptions& aOptions)
    : RecordedEventDerived(DRAWFILTER),
      mNode(aNode),
      mSourceRect(aSourceRect),
      mDestPoint(aDestPoint),
      mOptions(aOptions) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "DrawFilter"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDrawFilter(S& aStream);

ReferencePtr mNode;
Rect mSourceRect;
Point mDestPoint;
DrawOptions mOptions;
1033};

1035class RecordedPathCreation : public RecordedEventDerived<RecordedPathCreation> {
public:
MOZ_IMPLICIT RecordedPathCreation(PathRecording* aPath);

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Path Creation"; }

private:
friend class RecordedEvent;

ReferencePtr mDT;
ReferencePtr mRefPtr;
FillRule mFillRule;
RefPtr<PathRecording> mPath;
UniquePtr<PathOps> mPathOps;

template <class S>
MOZ_IMPLICIT RecordedPathCreation(S& aStream);
1058};

1060class RecordedPathDestruction
  : public RecordedEventDerived<RecordedPathDestruction> {
public:
MOZ_IMPLICIT RecordedPathDestruction(PathRecording* aPath)
    : RecordedEventDerived(PATHDESTRUCTION), mRefPtr(aPath) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Path Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedPathDestruction(S& aStream);
1081};

1083class RecordedSourceSurfaceCreation
  : public RecordedEventDerived<RecordedSourceSurfaceCreation> {
public:
RecordedSourceSurfaceCreation(ReferencePtr aRefPtr, uint8_t* aData,
                              int32_t aStride, const IntSize& aSize,
                              SurfaceFormat aFormat)
    : RecordedEventDerived(SOURCESURFACECREATION),
      mRefPtr(aRefPtr),
      mData(aData),
      mStride(aStride),
      mSize(aSize),
      mFormat(aFormat),
      mDataOwned(false) {}

~RecordedSourceSurfaceCreation();

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SourceSurface Creation"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
uint8_t* mData = nullptr;
int32_t mStride;
IntSize mSize;
SurfaceFormat mFormat;
mutable bool mDataOwned;

template <class S>
MOZ_IMPLICIT RecordedSourceSurfaceCreation(S& aStream);
1119};

1121class RecordedSourceSurfaceDestruction
  : public RecordedEventDerived<RecordedSourceSurfaceDestruction> {
public:
MOZ_IMPLICIT RecordedSourceSurfaceDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(SOURCESURFACEDESTRUCTION), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SourceSurface Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedSourceSurfaceDestruction(S& aStream);
1142};

1144class RecordedOptimizeSourceSurface
  : public RecordedEventDerived<RecordedOptimizeSourceSurface> {
public:
RecordedOptimizeSourceSurface(ReferencePtr aSurface,
                              ReferencePtr aOptimizedSurface)
    : RecordedEventDerived(OPTIMIZESOURCESURFACE),
      mSurface(aSurface),
      mOptimizedSurface(aOptimizedSurface) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "OptimizeSourceSurface"; }

private:
friend class RecordedEvent;

ReferencePtr mSurface;
ReferencePtr mOptimizedSurface;

template <class S>
MOZ_IMPLICIT RecordedOptimizeSourceSurface(S& aStream);
1169};

1171class RecordedExternalSurfaceCreation
  : public RecordedEventDerived<RecordedExternalSurfaceCreation> {
public:
RecordedExternalSurfaceCreation(ReferencePtr aRefPtr, const uint64_t aKey)
    : RecordedEventDerived(EXTERNALSURFACECREATION),
      mRefPtr(aRefPtr),
      mKey(aKey) {}

~RecordedExternalSurfaceCreation() = default;

virtual bool PlayEvent(Translator* aTranslator) const;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(std::stringstream& aStringStream) const;

virtual std::string GetName() const {
  return "SourceSurfaceSharedData Creation";
}

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
uint64_t mKey;

template <class S>
MOZ_IMPLICIT RecordedExternalSurfaceCreation(S& aStream);
1199};

1201class RecordedFilterNodeCreation
  : public RecordedEventDerived<RecordedFilterNodeCreation> {
public:
RecordedFilterNodeCreation(ReferencePtr aRefPtr, FilterType aType)
    : RecordedEventDerived(FILTERNODECREATION),
      mRefPtr(aRefPtr),
      mType(aType) {}

~RecordedFilterNodeCreation();

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "FilterNode Creation"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
FilterType mType;

template <class S>
MOZ_IMPLICIT RecordedFilterNodeCreation(S& aStream);
1227};

1229class RecordedFilterNodeDestruction
  : public RecordedEventDerived<RecordedFilterNodeDestruction> {
public:
MOZ_IMPLICIT RecordedFilterNodeDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(FILTERNODEDESTRUCTION), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "FilterNode Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedFilterNodeDestruction(S& aStream);
1250};

1252class RecordedGradientStopsCreation
  : public RecordedEventDerived<RecordedGradientStopsCreation> {
public:
RecordedGradientStopsCreation(ReferencePtr aRefPtr, GradientStop* aStops,
                              uint32_t aNumStops, ExtendMode aExtendMode)
    : RecordedEventDerived(GRADIENTSTOPSCREATION),
      mRefPtr(aRefPtr),
      mStops(aStops),
      mNumStops(aNumStops),
      mExtendMode(aExtendMode),
      mDataOwned(false) {}

~RecordedGradientStopsCreation();

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "GradientStops Creation"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
GradientStop* mStops = nullptr;
uint32_t mNumStops = 0;
ExtendMode mExtendMode;
bool mDataOwned;

template <class S>
MOZ_IMPLICIT RecordedGradientStopsCreation(S& aStream);
1285};

1287class RecordedGradientStopsDestruction
  : public RecordedEventDerived<RecordedGradientStopsDestruction> {
public:
MOZ_IMPLICIT RecordedGradientStopsDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(GRADIENTSTOPSDESTRUCTION), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "GradientStops Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedGradientStopsDestruction(S& aStream);
1308};

1310class RecordedFlush : public RecordedEventDerived<RecordedFlush> {
public:
explicit RecordedFlush() : RecordedEventDerived(FLUSH) {}

bool PlayEvent(Translator* aTranslator) const final;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

virtual std::string GetName() const override { return "Flush"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedFlush(S& aStream);
1328};

1330class RecordedDetachAllSnapshots
  : public RecordedEventDerived<RecordedDetachAllSnapshots> {
public:
explicit RecordedDetachAllSnapshots()
    : RecordedEventDerived(DETACHALLSNAPSHOTS) {}

bool PlayEvent(Translator* aTranslator) const final;

template <class S>
void Record(S& aStream) const;
virtual void OutputSimpleEventInfo(
    std::stringstream& aStringStream) const override;

virtual std::string GetName() const override { return "DetachAllSnapshots"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedDetachAllSnapshots(S& aStream);
1350};

1352class RecordedSnapshot : public RecordedEventDerived<RecordedSnapshot> {
public:
explicit RecordedSnapshot(ReferencePtr aRefPtr)
    : RecordedEventDerived(SNAPSHOT), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Snapshot"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedSnapshot(S& aStream);
1372};

1374class RecordedIntoLuminanceSource
  : public RecordedEventDerived<RecordedIntoLuminanceSource> {
public:
RecordedIntoLuminanceSource(ReferencePtr aRefPtr,
                            LuminanceType aLuminanceType, float aOpacity)
    : RecordedEventDerived(INTOLUMINANCE),
      mRefPtr(aRefPtr),
      mLuminanceType(aLuminanceType),
      mOpacity(aOpacity) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "IntoLuminanceSource"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
LuminanceType mLuminanceType;
float mOpacity;

template <class S>
MOZ_IMPLICIT RecordedIntoLuminanceSource(S& aStream);
1401};

1403class RecordedExtractSubrect
  : public RecordedEventDerived<RecordedExtractSubrect> {
public:
RecordedExtractSubrect(ReferencePtr aRefPtr, ReferencePtr aSourceSurface,
                       const IntRect& aSubrect)
    : RecordedEventDerived(EXTRACTSUBRECT),
      mRefPtr(aRefPtr),
      mSourceSurface(aSourceSurface),
      mSubrect(aSubrect) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "ExtractSubrect"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
ReferencePtr mSourceSurface;
IntRect mSubrect;

template <class S>
MOZ_IMPLICIT RecordedExtractSubrect(S& aStream);
1430};

1432class RecordedFontData : public RecordedEventDerived<RecordedFontData> {
public:
static void FontDataProc(const uint8_t* aData, uint32_t aSize,
                         uint32_t aIndex, void* aBaton) {
  auto recordedFontData = static_cast<RecordedFontData*>(aBaton);
  recordedFontData->SetFontData(aData, aSize, aIndex);
}

explicit RecordedFontData(UnscaledFont* aUnscaledFont)
    : RecordedEventDerived(FONTDATA),
      mType(aUnscaledFont->GetType()),
      mFontDetails() {
  mGetFontFileDataSucceeded =
      aUnscaledFont->GetFontFileData(&FontDataProc, this) && mData;
}

virtual ~RecordedFontData();

bool IsValid() const { return mGetFontFileDataSucceeded; }

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Font Data"; }

void SetFontData(const uint8_t* aData, uint32_t aSize, uint32_t aIndex);

bool GetFontDetails(RecordedFontDetails& fontDetails);

private:
friend class RecordedEvent;

FontType mType;
uint8_t* mData = nullptr;
RecordedFontDetails mFontDetails;

bool mGetFontFileDataSucceeded;

template <class S>
MOZ_IMPLICIT RecordedFontData(S& aStream);
1475};

1477class RecordedFontDescriptor
  : public RecordedEventDerived<RecordedFontDescriptor> {
public:
static void FontDescCb(const uint8_t* aData, uint32_t aSize, uint32_t aIndex,
                       void* aBaton) {
  auto recordedFontDesc = static_cast<RecordedFontDescriptor*>(aBaton);
  recordedFontDesc->SetFontDescriptor(aData, aSize, aIndex);
}

explicit RecordedFontDescriptor(UnscaledFont* aUnscaledFont)
    : RecordedEventDerived(FONTDESC),
      mType(aUnscaledFont->GetType()),
      mIndex(0),
      mRefPtr(aUnscaledFont) {
  mHasDesc = aUnscaledFont->GetFontDescriptor(FontDescCb, this);
}

virtual ~RecordedFontDescriptor();

bool IsValid() const { return mHasDesc; }

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Font Desc"; }

private:
friend class RecordedEvent;

void SetFontDescriptor(const uint8_t* aData, uint32_t aSize, uint32_t aIndex);

bool mHasDesc;

FontType mType;
std::vector<uint8_t> mData;
uint32_t mIndex;
ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedFontDescriptor(S& aStream);
1520};

1522class RecordedUnscaledFontCreation
  : public RecordedEventDerived<RecordedUnscaledFontCreation> {
public:
static void FontInstanceDataProc(const uint8_t* aData, uint32_t aSize,
                                 void* aBaton) {
  auto recordedUnscaledFontCreation =
      static_cast<RecordedUnscaledFontCreation*>(aBaton);
  recordedUnscaledFontCreation->SetFontInstanceData(aData, aSize);
}

RecordedUnscaledFontCreation(UnscaledFont* aUnscaledFont,
                             RecordedFontDetails aFontDetails)
    : RecordedEventDerived(UNSCALEDFONTCREATION),
      mRefPtr(aUnscaledFont),
      mFontDataKey(aFontDetails.fontDataKey),
      mIndex(aFontDetails.index) {
  aUnscaledFont->GetFontInstanceData(FontInstanceDataProc, this);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "UnscaledFont Creation"; }

void SetFontInstanceData(const uint8_t* aData, uint32_t aSize);

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
uint64_t mFontDataKey;
uint32_t mIndex;
std::vector<uint8_t> mInstanceData;

template <class S>
MOZ_IMPLICIT RecordedUnscaledFontCreation(S& aStream);
1561};

1563class RecordedUnscaledFontDestruction
  : public RecordedEventDerived<RecordedUnscaledFontDestruction> {
public:
MOZ_IMPLICIT RecordedUnscaledFontDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(UNSCALEDFONTDESTRUCTION), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;
template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "UnscaledFont Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedUnscaledFontDestruction(S& aStream);
1583};

1585class RecordedScaledFontCreation
  : public RecordedEventDerived<RecordedScaledFontCreation> {
public:
static void FontInstanceDataProc(const uint8_t* aData, uint32_t aSize,
                                 const FontVariation* aVariations,
                                 uint32_t aNumVariations, void* aBaton) {
  auto recordedScaledFontCreation =
      static_cast<RecordedScaledFontCreation*>(aBaton);
  recordedScaledFontCreation->SetFontInstanceData(aData, aSize, aVariations,
                                                  aNumVariations);
}

RecordedScaledFontCreation(ScaledFont* aScaledFont,
                           UnscaledFont* aUnscaledFont)
    : RecordedEventDerived(SCALEDFONTCREATION),
      mRefPtr(aScaledFont),
      mUnscaledFont(aUnscaledFont),
      mGlyphSize(aScaledFont->GetSize()) {
  aScaledFont->GetFontInstanceData(FontInstanceDataProc, this);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "ScaledFont Creation"; }

void SetFontInstanceData(const uint8_t* aData, uint32_t aSize,
                         const FontVariation* aVariations,
                         uint32_t aNumVariations);

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;
ReferencePtr mUnscaledFont;
Float mGlyphSize;
std::vector<uint8_t> mInstanceData;
std::vector<FontVariation> mVariations;

template <class S>
MOZ_IMPLICIT RecordedScaledFontCreation(S& aStream);
1629};

1631class RecordedScaledFontDestruction
  : public RecordedEventDerived<RecordedScaledFontDestruction> {
public:
MOZ_IMPLICIT RecordedScaledFontDestruction(ReferencePtr aRefPtr)
    : RecordedEventDerived(SCALEDFONTDESTRUCTION), mRefPtr(aRefPtr) {}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "ScaledFont Destruction"; }

private:
friend class RecordedEvent;

ReferencePtr mRefPtr;

template <class S>
MOZ_IMPLICIT RecordedScaledFontDestruction(S& aStream);
1652};

1654class RecordedMaskSurface : public RecordedEventDerived<RecordedMaskSurface> {
public:
RecordedMaskSurface(const Pattern& aPattern, ReferencePtr aRefMask,
                    const Point& aOffset, const DrawOptions& aOptions)
    : RecordedEventDerived(MASKSURFACE),
      mPattern(),
      mRefMask(aRefMask),
      mOffset(aOffset),
      mOptions(aOptions) {
  StorePattern(mPattern, aPattern);
}

bool PlayEvent(Translator* aTranslator) const override;

template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "MaskSurface"; }

private:
friend class RecordedEvent;

template <class S>
MOZ_IMPLICIT RecordedMaskSurface(S& aStream);

PatternStorage mPattern;
ReferencePtr mRefMask;
Point mOffset;
DrawOptions mOptions;
1684};

1686class RecordedFilterNodeSetAttribute
  : public RecordedEventDerived<RecordedFilterNodeSetAttribute> {
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)
    : RecordedEventDerived(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)
    : RecordedEventDerived(FILTERNODESETATTRIBUTE),
      mNode(aNode),
      mIndex(aIndex),
      mArgType(ARGTYPE_FLOAT_ARRAY) {
  mPayload.resize(sizeof(Float) * aSize);
  memcpy(&mPayload.front(), aFloat, sizeof(Float) * aSize);
}

bool PlayEvent(Translator* aTranslator) const override;
template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SetAttribute"; }

private:
friend class RecordedEvent;

ReferencePtr mNode;

uint32_t mIndex;
ArgType mArgType;
std::vector<uint8_t> mPayload;

template <class S>
MOZ_IMPLICIT RecordedFilterNodeSetAttribute(S& aStream);
1745};

1747class RecordedFilterNodeSetInput
  : public RecordedEventDerived<RecordedFilterNodeSetInput> {
public:
RecordedFilterNodeSetInput(FilterNode* aNode, uint32_t aIndex,
                           FilterNode* aInputNode)
    : RecordedEventDerived(FILTERNODESETINPUT),
      mNode(aNode),
      mIndex(aIndex),
      mInputFilter(aInputNode),
      mInputSurface(nullptr) {}

RecordedFilterNodeSetInput(FilterNode* aNode, uint32_t aIndex,
                           SourceSurface* aInputSurface)
    : RecordedEventDerived(FILTERNODESETINPUT),
      mNode(aNode),
      mIndex(aIndex),
      mInputFilter(nullptr),
      mInputSurface(aInputSurface) {}

bool PlayEvent(Translator* aTranslator) const override;
template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "SetInput"; }

private:
friend class RecordedEvent;

ReferencePtr mNode;
uint32_t mIndex;
ReferencePtr mInputFilter;
ReferencePtr mInputSurface;

template <class S>
MOZ_IMPLICIT RecordedFilterNodeSetInput(S& aStream);
1783};

1785class RecordedLink : public RecordedEventDerived<RecordedLink> {
public:
RecordedLink(const char* aLocalDest, const char* aURI, const Rect& aRect)
    : RecordedEventDerived(LINK),
      mLocalDest(aLocalDest),
      mURI(aURI),
      mRect(aRect) {}

bool PlayEvent(Translator* aTranslator) const override;
template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Link"; }

private:
friend class RecordedEvent;

std::string mLocalDest;
std::string mURI;
Rect mRect;

template <class S>
MOZ_IMPLICIT RecordedLink(S& aStream);
1809};

1811class RecordedDestination : public RecordedEventDerived<RecordedDestination> {
public:
RecordedDestination(const char* aDestination, const Point& aPoint)
    : RecordedEventDerived(DESTINATION),
      mDestination(aDestination),
      mPoint(aPoint) {}

bool PlayEvent(Translator* aTranslator) const override;
template <class S>
void Record(S& aStream) const;
void OutputSimpleEventInfo(std::stringstream& aStringStream) const override;

std::string GetName() const override { return "Destination"; }

private:
friend class RecordedEvent;

std::string mDestination;
Point mPoint;

template <class S>
MOZ_IMPLICIT RecordedDestination(S& aStream);
1833};

1835static std::string NameFromBackend(BackendType aType) {
switch (aType) {
  case BackendType::NONE:
    return "None";
  case BackendType::DIRECT2D:
    return "Direct2D";
  default:
    return "Unknown";
}
1844}

1846template <class S>
1847void RecordedEvent::RecordPatternData(S& aStream,
                                    const PatternStorage& aPattern) const {
WriteElement(aStream, aPattern.mType);

switch (aPattern.mType) {
  case PatternType::COLOR: {
    WriteElement(aStream, *reinterpret_cast<const ColorPatternStorage*>(
                              &aPattern.mStorage));
    return;
  }
  case PatternType::LINEAR_GRADIENT: {
    WriteElement(aStream,
                 *reinterpret_cast<const LinearGradientPatternStorage*>(
                     &aPattern.mStorage));
    return;
  }
  case PatternType::RADIAL_GRADIENT: {
    WriteElement(aStream,
                 *reinterpret_cast<const RadialGradientPatternStorage*>(
                     &aPattern.mStorage));
    return;
  }
  case PatternType::CONIC_GRADIENT: {
    WriteElement(aStream,
                 *reinterpret_cast<const ConicGradientPatternStorage*>(
                     &aPattern.mStorage));
    return;
  }
  case PatternType::SURFACE: {
    WriteElement(aStream, *reinterpret_cast<const SurfacePatternStorage*>(
                              &aPattern.mStorage));
    return;
  }
  default:
    return;
}
1883}

1885template <class S>
1886void RecordedEvent::ReadPatternData(S& aStream,
                                  PatternStorage& aPattern) const {
ReadElementConstrained(aStream, aPattern.mType, PatternType::COLOR,
                       kHighestPatternType);

switch (aPattern.mType) {
  case PatternType::COLOR: {
    ReadElement(aStream,
                *reinterpret_cast<ColorPatternStorage*>(&aPattern.mStorage));
    return;
  }
  case PatternType::LINEAR_GRADIENT: {
    ReadElement(aStream, *reinterpret_cast<LinearGradientPatternStorage*>(
                             &aPattern.mStorage));
    return;
  }
  case PatternType::RADIAL_GRADIENT: {
    ReadElement(aStream, *reinterpret_cast<RadialGradientPatternStorage*>(
                             &aPattern.mStorage));
    return;
  }
  case PatternType::CONIC_GRADIENT: {
    ReadElement(aStream, *reinterpret_cast<ConicGradientPatternStorage*>(
                             &aPattern.mStorage));
    return;
  }
  case PatternType::SURFACE: {
    SurfacePatternStorage* sps =
        reinterpret_cast<SurfacePatternStorage*>(&aPattern.mStorage);
    ReadElement(aStream, *sps);
    if (sps->mExtend < ExtendMode::CLAMP ||
        sps->mExtend > ExtendMode::REFLECT) {
      aStream.SetIsBad();
      return;
    }

    if (sps->mSamplingFilter < SamplingFilter::GOOD ||
        sps->mSamplingFilter >= SamplingFilter::SENTINEL) {
      aStream.SetIsBad();
    }
    return;
  }
  default:
    return;
}
1931}

1933inline void RecordedEvent::StorePattern(PatternStorage& aDestination,
                                      const Pattern& aSource) const {
aDestination.mType = aSource.GetType();

switch (aSource.GetType()) {
  case PatternType::COLOR: {
    reinterpret_cast<ColorPatternStorage*>(&aDestination.mStorage)->mColor =
        static_cast<const ColorPattern*>(&aSource)->mColor;
    return;
  }
  case PatternType::LINEAR_GRADIENT: {
    LinearGradientPatternStorage* store =
        reinterpret_cast<LinearGradientPatternStorage*>(
            &aDestination.mStorage);
    const LinearGradientPattern* pat =
        static_cast<const LinearGradientPattern*>(&aSource);
    store->mBegin = pat->mBegin;
    store->mEnd = pat->mEnd;
    store->mMatrix = pat->mMatrix;
    store->mStops = pat->mStops.get();
    return;
  }
  case PatternType::RADIAL_GRADIENT: {
    RadialGradientPatternStorage* store =
        reinterpret_cast<RadialGradientPatternStorage*>(
            &aDestination.mStorage);
    const RadialGradientPattern* pat =
        static_cast<const RadialGradientPattern*>(&aSource);
    store->mCenter1 = pat->mCenter1;
    store->mCenter2 = pat->mCenter2;
    store->mRadius1 = pat->mRadius1;
    store->mRadius2 = pat->mRadius2;
    store->mMatrix = pat->mMatrix;
    store->mStops = pat->mStops.get();
    return;
  }
  case PatternType::CONIC_GRADIENT: {
    ConicGradientPatternStorage* store =
        reinterpret_cast<ConicGradientPatternStorage*>(
            &aDestination.mStorage);
    const ConicGradientPattern* pat =
        static_cast<const ConicGradientPattern*>(&aSource);
    store->mCenter = pat->mCenter;
    store->mAngle = pat->mAngle;
    store->mStartOffset = pat->mStartOffset;
    store->mEndOffset = pat->mEndOffset;
    store->mMatrix = pat->mMatrix;
    store->mStops = pat->mStops.get();
    return;
  }
  case PatternType::SURFACE: {
    SurfacePatternStorage* store =
        reinterpret_cast<SurfacePatternStorage*>(&aDestination.mStorage);
    const SurfacePattern* pat = static_cast<const SurfacePattern*>(&aSource);
    store->mExtend = pat->mExtendMode;
    store->mSamplingFilter = pat->mSamplingFilter;
    store->mMatrix = pat->mMatrix;
    store->mSurface = pat->mSurface;
    store->mSamplingRect = pat->mSamplingRect;
    return;
  }
}
1995}

1997template <class S>
1998void RecordedEvent::RecordStrokeOptions(
  S& aStream, const StrokeOptions& aStrokeOptions) const {
JoinStyle joinStyle = aStrokeOptions.mLineJoin;
CapStyle capStyle = aStrokeOptions.mLineCap;

WriteElement(aStream, uint64_t(aStrokeOptions.mDashLength));
WriteElement(aStream, aStrokeOptions.mLineWidth);
WriteElement(aStream, aStrokeOptions.mMiterLimit);
WriteElement(aStream, joinStyle);
WriteElement(aStream, capStyle);

if (!aStrokeOptions.mDashPattern) {
  return;
}

WriteElement(aStream, aStrokeOptions.mDashOffset);
aStream.write((char*)aStrokeOptions.mDashPattern,
              sizeof(Float) * aStrokeOptions.mDashLength);
2016}

2018template <class S>
2019void RecordedEvent::ReadStrokeOptions(S& aStream,
                                    StrokeOptions& aStrokeOptions) {
uint64_t dashLength;
JoinStyle joinStyle;
CapStyle capStyle;

ReadElement(aStream, dashLength);
ReadElement(aStream, aStrokeOptions.mLineWidth);
ReadElement(aStream, aStrokeOptions.mMiterLimit);
ReadElementConstrained(aStream, joinStyle, JoinStyle::BEVEL,
                       JoinStyle::MITER_OR_BEVEL);
ReadElementConstrained(aStream, capStyle, CapStyle::BUTT, CapStyle::SQUARE);
// On 32 bit we truncate the value of dashLength.
// See also bug 811850 for history.
aStrokeOptions.mDashLength = size_t(dashLength);
aStrokeOptions.mLineJoin = joinStyle;
aStrokeOptions.mLineCap = capStyle;

if (!aStrokeOptions.mDashLength || !aStream.good()) {
  return;
}

ReadElement(aStream, aStrokeOptions.mDashOffset);

mDashPatternStorage.resize(aStrokeOptions.mDashLength);
aStrokeOptions.mDashPattern = &mDashPatternStorage.front();
aStream.read((char*)aStrokeOptions.mDashPattern,
             sizeof(Float) * aStrokeOptions.mDashLength);
2047}

2049template <class S>
2050static void ReadDrawOptions(S& aStream, DrawOptions& aDrawOptions) {
ReadElement(aStream, aDrawOptions);
if (aDrawOptions.mAntialiasMode < AntialiasMode::NONE ||
    aDrawOptions.mAntialiasMode > AntialiasMode::DEFAULT) {
  aStream.SetIsBad();
  return;
}

if (aDrawOptions.mCompositionOp < CompositionOp::OP_CLEAR ||
    aDrawOptions.mCompositionOp > CompositionOp::OP_COUNT) {
  aStream.SetIsBad();
}
2062}

2064template <class S>
2065static void ReadDrawSurfaceOptions(S& aStream,
                                 DrawSurfaceOptions& aDrawSurfaceOptions) {
ReadElement(aStream, aDrawSurfaceOptions);
if (aDrawSurfaceOptions.mSamplingFilter < SamplingFilter::GOOD ||
    aDrawSurfaceOptions.mSamplingFilter >= SamplingFilter::SENTINEL) {
  aStream.SetIsBad();
  return;
}

if (aDrawSurfaceOptions.mSamplingBounds < SamplingBounds::UNBOUNDED ||
    aDrawSurfaceOptions.mSamplingBounds > SamplingBounds::BOUNDED) {
  aStream.SetIsBad();
}
2078}

2080inline void RecordedEvent::OutputSimplePatternInfo(
  const PatternStorage& aStorage, std::stringstream& aOutput) const {
switch (aStorage.mType) {
  case PatternType::COLOR: {
    const DeviceColor color =
        reinterpret_cast<const ColorPatternStorage*>(&aStorage.mStorage)
            ->mColor;
    aOutput << "DeviceColor: (" << color.r << ", " << color.g << ", "
            << color.b << ", " << color.a << ")";
    return;
  }
  case PatternType::LINEAR_GRADIENT: {
    const LinearGradientPatternStorage* store =
        reinterpret_cast<const LinearGradientPatternStorage*>(
            &aStorage.mStorage);

    aOutput << "LinearGradient (" << store->mBegin.x << ", "
            << store->mBegin.y << ") - (" << store->mEnd.x << ", "
            << store->mEnd.y << ") Stops: " << store->mStops;
    return;
  }
  case PatternType::RADIAL_GRADIENT: {
    const RadialGradientPatternStorage* store =
        reinterpret_cast<const RadialGradientPatternStorage*>(
            &aStorage.mStorage);
    aOutput << "RadialGradient (Center 1: (" << store->mCenter1.x << ", "
            << store->mCenter2.y << ") Radius 2: " << store->mRadius2;
    return;
  }
  case PatternType::CONIC_GRADIENT: {
    const ConicGradientPatternStorage* store =
        reinterpret_cast<const ConicGradientPatternStorage*>(
            &aStorage.mStorage);
    aOutput << "ConicGradient (Center: (" << store->mCenter.x << ", "
            << store->mCenter.y << ") Angle: " << store->mAngle
            << " Range:" << store->mStartOffset << " - " << store->mEndOffset;
    return;
  }
  case PatternType::SURFACE: {
    const SurfacePatternStorage* store =
        reinterpret_cast<const SurfacePatternStorage*>(&aStorage.mStorage);
    aOutput << "Surface (0x" << store->mSurface << ")";
    return;
  }
}
2125}

2127inline bool RecordedDrawTargetCreation::PlayEvent(
  Translator* aTranslator) const {
RefPtr<DrawTarget> newDT =
    aTranslator->CreateDrawTarget(mRefPtr, mRect.Size(), mFormat);

// If we couldn't create a DrawTarget this will probably cause us to crash
// with nullptr later in the playback, so return false to abort.
if (!newDT) {
  return false;
}

if (mHasExistingData) {
  Rect dataRect(0, 0, mExistingData->GetSize().width,
                mExistingData->GetSize().height);
  newDT->DrawSurface(mExistingData, dataRect, dataRect);
}

return true;
2145}

2147template <class S>
2148void RecordedDrawTargetCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mBackendType);
WriteElement(aStream, mRect);
WriteElement(aStream, mFormat);
WriteElement(aStream, mHasExistingData);

if (mHasExistingData) {
  MOZ_ASSERT(mExistingData)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mExistingData)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mExistingData))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("mExistingData",
 "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h"
, 2156); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mExistingData"
 ")"); do { *((volatile int*)__null) = 2156; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(mExistingData->GetSize() == mRect.Size())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mExistingData->GetSize() == mRect.Size())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mExistingData->GetSize() == mRect.Size()))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("mExistingData->GetSize() == mRect.Size()"
, "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h"
, 2157); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mExistingData->GetSize() == mRect.Size()"
 ")"); do { *((volatile int*)__null) = 2157; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  RefPtr<DataSourceSurface> dataSurf = mExistingData->GetDataSurface();

  DataSourceSurface::ScopedMap map(dataSurf, DataSourceSurface::READ);
  for (int y = 0; y < mRect.height; y++) {
    aStream.write((const char*)map.GetData() + y * map.GetStride(),
                  BytesPerPixel(mFormat) * mRect.width);
  }
}
2166}

2168template <class S>
2169RecordedDrawTargetCreation::RecordedDrawTargetCreation(S& aStream)
  : RecordedEventDerived(DRAWTARGETCREATION), mExistingData(nullptr) {
ReadElement(aStream, mRefPtr);
ReadElementConstrained(aStream, mBackendType, BackendType::NONE,
                       BackendType::WEBRENDER_TEXT);
ReadElement(aStream, mRect);
ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32,
                       SurfaceFormat::UNKNOWN);
ReadElement(aStream, mHasExistingData);

if (mHasExistingData) {
  RefPtr<DataSourceSurface> dataSurf =
      Factory::CreateDataSourceSurface(mRect.Size(), mFormat);
  if (!dataSurf) {
    gfxWarningmozilla::gfx::WarningLog()
        << "RecordedDrawTargetCreation had to reset mHasExistingData";
    mHasExistingData = false;
    return;
  }

  DataSourceSurface::ScopedMap map(dataSurf, DataSourceSurface::READ);
  for (int y = 0; y < mRect.height; y++) {
    aStream.read((char*)map.GetData() + y * map.GetStride(),
                 BytesPerPixel(mFormat) * mRect.width);
  }
  mExistingData = dataSurf;
}
2196}

2198inline void RecordedDrawTargetCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] DrawTarget Creation (Type: "
              << NameFromBackend(mBackendType) << ", Size: " << mRect.width
              << "x" << mRect.height << ")";
2203}

2205inline bool RecordedDrawTargetDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveDrawTarget(mRefPtr);
return true;
2209}

2211template <class S>
2212void RecordedDrawTargetDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
2214}

2216template <class S>
2217RecordedDrawTargetDestruction::RecordedDrawTargetDestruction(S& aStream)
  : RecordedEventDerived(DRAWTARGETDESTRUCTION) {
ReadElement(aStream, mRefPtr);
2220}

2222inline void RecordedDrawTargetDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] DrawTarget Destruction";
2225}

2227inline bool RecordedSetCurrentDrawTarget::PlayEvent(
  Translator* aTranslator) const {
return aTranslator->SetCurrentDrawTarget(mRefPtr);
2230}

2232template <class S>
2233void RecordedSetCurrentDrawTarget::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
2235}

2237template <class S>
2238RecordedSetCurrentDrawTarget::RecordedSetCurrentDrawTarget(S& aStream)
  : RecordedEventDerived(SETCURRENTDRAWTARGET) {
ReadElement(aStream, mRefPtr);
2241}

2243inline void RecordedSetCurrentDrawTarget::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] SetCurrentDrawTarget";
2246}

2248inline bool RecordedCreateSimilarDrawTarget::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* drawTarget = aTranslator->GetCurrentDrawTarget();
if (!drawTarget) {
  return false;
}

RefPtr<DrawTarget> newDT =
    drawTarget->CreateSimilarDrawTarget(mSize, mFormat);

// If we couldn't create a DrawTarget this will probably cause us to crash
// with nullptr later in the playback, so return false to abort.
if (!newDT) {
  return false;
}

aTranslator->AddDrawTarget(mRefPtr, newDT);
return true;
2266}

2268template <class S>
2269void RecordedCreateSimilarDrawTarget::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mSize);
WriteElement(aStream, mFormat);
2273}

2275template <class S>
2276RecordedCreateSimilarDrawTarget::RecordedCreateSimilarDrawTarget(S& aStream)
  : RecordedEventDerived(CREATESIMILARDRAWTARGET) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mSize);
ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32,
                       SurfaceFormat::UNKNOWN);
2282}

2284inline void RecordedCreateSimilarDrawTarget::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr
              << "] CreateSimilarDrawTarget (Size: " << mSize.width << "x"
              << mSize.height << ")";
2289}

2291inline bool RecordedCreateDrawTargetForFilter::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

IntRect baseRect = dt->GetRect();

auto maxRect = IntRect(IntPoint(0, 0), mMaxSize);

auto clone = dt->GetTransform();
bool invertible = clone.Invert();
// mSourceRect is in filter space. The filter outputs from mSourceRect need
// to be drawn at mDestPoint in user space.
Rect userSpaceSource = Rect(mDestPoint, mSourceRect.Size());
if (invertible) {
  // Try to reduce the source rect so that it's not much bigger
  // than the draw target. The result is not minimal. Examples
  // are left as an exercise for the reader.
  auto destRect = IntRectToRect(baseRect);
  Rect userSpaceBounds = clone.TransformBounds(destRect);
  userSpaceSource = userSpaceSource.Intersect(userSpaceBounds);
}

// Compute how much we moved the top-left of the source rect by, and use that
// to compute the new dest point, and move our intersected source rect back
// into the (new) filter space.
Point shift = userSpaceSource.TopLeft() - mDestPoint;
Rect filterSpaceSource =
    Rect(mSourceRect.TopLeft() + shift, userSpaceSource.Size());

baseRect = RoundedOut(filterSpaceSource);
FilterNode* filter = aTranslator->LookupFilterNode(mFilter);
if (!filter) {
  return false;
}

IntRect transformedRect = filter->MapRectToSource(
    baseRect, maxRect, aTranslator->LookupFilterNode(mSource));

// Intersect with maxRect to make sure we didn't end up with something bigger
transformedRect = transformedRect.Intersect(maxRect);

// If we end up with an empty rect make it 1x1 so that things don't break.
if (transformedRect.IsEmpty()) {
  transformedRect = IntRect(0, 0, 1, 1);
}

RefPtr<DrawTarget> newDT =
    dt->CreateSimilarDrawTarget(transformedRect.Size(), mFormat);
if (!newDT) {
  return false;
}
newDT =
    gfx::Factory::CreateOffsetDrawTarget(newDT, transformedRect.TopLeft());

// If we couldn't create a DrawTarget this will probably cause us to crash
// with nullptr later in the playback, so return false to abort.
if (!newDT) {
  return false;
}

aTranslator->AddDrawTarget(mRefPtr, newDT);
return true;
2356}

2358inline bool RecordedCreateClippedDrawTarget::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

RefPtr<DrawTarget> newDT = dt->CreateClippedDrawTarget(mBounds, mFormat);

// If we couldn't create a DrawTarget this will probably cause us to crash
// with nullptr later in the playback, so return false to abort.
if (!newDT) {
  return false;
}

aTranslator->AddDrawTarget(mRefPtr, newDT);
return true;
2375}

2377template <class S>
2378void RecordedCreateClippedDrawTarget::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mBounds);
WriteElement(aStream, mFormat);
2382}

2384template <class S>
2385RecordedCreateClippedDrawTarget::RecordedCreateClippedDrawTarget(S& aStream)
  : RecordedEventDerived(CREATECLIPPEDDRAWTARGET) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mBounds);
ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32,
                       SurfaceFormat::UNKNOWN);
2391}

2393inline void RecordedCreateClippedDrawTarget::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] CreateClippedDrawTarget ()";
2396}

2398template <class S>
2399void RecordedCreateDrawTargetForFilter::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mMaxSize);
WriteElement(aStream, mFormat);
WriteElement(aStream, mFilter);
WriteElement(aStream, mSource);
WriteElement(aStream, mSourceRect);
WriteElement(aStream, mDestPoint);
2407}

2409template <class S>
2410RecordedCreateDrawTargetForFilter::RecordedCreateDrawTargetForFilter(S& aStream)
  : RecordedEventDerived(CREATEDRAWTARGETFORFILTER) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mMaxSize);
ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32,
                       SurfaceFormat::UNKNOWN);
ReadElement(aStream, mFilter);
ReadElement(aStream, mSource);
ReadElement(aStream, mSourceRect);
ReadElement(aStream, mDestPoint);
2420}

2422inline void RecordedCreateDrawTargetForFilter::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] CreateDrawTargetForFilter ()";
2425}

2427struct GenericPattern {
GenericPattern(const PatternStorage& aStorage, Translator* aTranslator)
    : mPattern(nullptr), mTranslator(aTranslator) {
  mStorage = const_cast<PatternStorage*>(&aStorage);
}

~GenericPattern() {
  if (mPattern) {
    mPattern->~Pattern();
  }
}

operator Pattern*() {
  switch (mStorage->mType) {
    case PatternType::COLOR:
      return new (mColPat) ColorPattern(
          reinterpret_cast<ColorPatternStorage*>(&mStorage->mStorage)
              ->mColor);
    case PatternType::SURFACE: {
      SurfacePatternStorage* storage =
          reinterpret_cast<SurfacePatternStorage*>(&mStorage->mStorage);
      mPattern = new (mSurfPat)
          SurfacePattern(mTranslator->LookupSourceSurface(storage->mSurface),
                         storage->mExtend, storage->mMatrix,
                         storage->mSamplingFilter, storage->mSamplingRect);
      return mPattern;
    }
    case PatternType::LINEAR_GRADIENT: {
      LinearGradientPatternStorage* storage =
          reinterpret_cast<LinearGradientPatternStorage*>(
              &mStorage->mStorage);
      mPattern = new (mLinGradPat) LinearGradientPattern(
          storage->mBegin, storage->mEnd,
          storage->mStops ? mTranslator->LookupGradientStops(storage->mStops)
                          : nullptr,
          storage->mMatrix);
      return mPattern;
    }
    case PatternType::RADIAL_GRADIENT: {
      RadialGradientPatternStorage* storage =
          reinterpret_cast<RadialGradientPatternStorage*>(
              &mStorage->mStorage);
      mPattern = new (mRadGradPat) RadialGradientPattern(
          storage->mCenter1, storage->mCenter2, storage->mRadius1,
          storage->mRadius2,
          storage->mStops ? mTranslator->LookupGradientStops(storage->mStops)
                          : nullptr,
          storage->mMatrix);
      return mPattern;
    }
    case PatternType::CONIC_GRADIENT: {
      ConicGradientPatternStorage* storage =
          reinterpret_cast<ConicGradientPatternStorage*>(&mStorage->mStorage);
      mPattern = new (mConGradPat) ConicGradientPattern(
          storage->mCenter, storage->mAngle, storage->mStartOffset,
          storage->mEndOffset,
          storage->mStops ? mTranslator->LookupGradientStops(storage->mStops)
                          : nullptr,
          storage->mMatrix);
      return mPattern;
    }
    default:
      return new (mColPat) ColorPattern(DeviceColor());
  }

  return mPattern;
}

union {
  char mColPat[sizeof(ColorPattern)];
  char mLinGradPat[sizeof(LinearGradientPattern)];
  char mRadGradPat[sizeof(RadialGradientPattern)];
  char mConGradPat[sizeof(ConicGradientPattern)];
  char mSurfPat[sizeof(SurfacePattern)];
};

PatternStorage* mStorage;
Pattern* mPattern;
Translator* mTranslator;
2506};

2508inline bool RecordedFillRect::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->FillRect(mRect, *GenericPattern(mPattern, aTranslator), mOptions);
return true;
2516}

2518template <class S>
2519void RecordedFillRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2523}

2525template <class S>
2526RecordedFillRect::RecordedFillRect(S& aStream)
  : RecordedEventDerived(FILLRECT) {
ReadElement(aStream, mRect);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2531}

2533inline void RecordedFillRect::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "FillRect (" << mRect.X() << ", " << mRect.Y() << " - "
              << mRect.Width() << " x " << mRect.Height() << ") ";
OutputSimplePatternInfo(mPattern, aStringStream);
2538}

2540inline bool RecordedStrokeRect::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->StrokeRect(mRect, *GenericPattern(mPattern, aTranslator), mStrokeOptions,
               mOptions);
return true;
2549}

2551template <class S>
2552void RecordedStrokeRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
RecordStrokeOptions(aStream, mStrokeOptions);
2557}

2559template <class S>
2560RecordedStrokeRect::RecordedStrokeRect(S& aStream)
  : RecordedEventDerived(STROKERECT) {
ReadElement(aStream, mRect);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
ReadStrokeOptions(aStream, mStrokeOptions);
2566}

2568inline void RecordedStrokeRect::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "StrokeRect (" << mRect.X() << ", " << mRect.Y() << " - "
              << mRect.Width() << " x " << mRect.Height()
              << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
OutputSimplePatternInfo(mPattern, aStringStream);
2574}

2576inline bool RecordedStrokeLine::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->StrokeLine(mBegin, mEnd, *GenericPattern(mPattern, aTranslator),
               mStrokeOptions, mOptions);
return true;
2585}

2587template <class S>
2588void RecordedStrokeLine::Record(S& aStream) const {
WriteElement(aStream, mBegin);
WriteElement(aStream, mEnd);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
RecordStrokeOptions(aStream, mStrokeOptions);
2594}

2596template <class S>
2597RecordedStrokeLine::RecordedStrokeLine(S& aStream)
  : RecordedEventDerived(STROKELINE) {
ReadElement(aStream, mBegin);
ReadElement(aStream, mEnd);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
ReadStrokeOptions(aStream, mStrokeOptions);
2604}

2606inline void RecordedStrokeLine::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "StrokeLine (" << mBegin.x << ", " << mBegin.y << " - "
              << mEnd.x << ", " << mEnd.y
              << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
OutputSimplePatternInfo(mPattern, aStringStream);
2612}

2614inline bool RecordedStrokeCircle::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->StrokeCircle(mCircle.origin, mCircle.radius,
                 *GenericPattern(mPattern, aTranslator), mStrokeOptions,
                 mOptions);
return true;
2624}

2626template <class S>
2627void RecordedStrokeCircle::Record(S& aStream) const {
WriteElement(aStream, mCircle);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
RecordStrokeOptions(aStream, mStrokeOptions);
2632}

2634template <class S>
2635RecordedStrokeCircle::RecordedStrokeCircle(S& aStream)
  : RecordedEventDerived(STROKECIRCLE) {
ReadElement(aStream, mCircle);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
ReadStrokeOptions(aStream, mStrokeOptions);
2641}

2643inline void RecordedStrokeCircle::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "StrokeCircle (" << mCircle.origin.x << ", "
              << mCircle.origin.y << " - " << mCircle.radius
              << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
OutputSimplePatternInfo(mPattern, aStringStream);
2649}

2651inline bool RecordedFill::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->Fill(aTranslator->LookupPath(mPath),
         *GenericPattern(mPattern, aTranslator), mOptions);
return true;
2660}

2662template <class S>
2663RecordedFill::RecordedFill(S& aStream) : RecordedEventDerived(FILL) {
ReadElement(aStream, mPath);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2667}

2669template <class S>
2670void RecordedFill::Record(S& aStream) const {
WriteElement(aStream, mPath);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2674}

2676inline void RecordedFill::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Fill (" << mPath << ") ";
OutputSimplePatternInfo(mPattern, aStringStream);
2680}

2682inline bool RecordedFillCircle::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->FillCircle(mCircle.origin, mCircle.radius,
               *GenericPattern(mPattern, aTranslator), mOptions);
return true;
2691}

2693template <class S>
2694void RecordedFillCircle::Record(S& aStream) const {
WriteElement(aStream, mCircle);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2698}

2700template <class S>
2701RecordedFillCircle::RecordedFillCircle(S& aStream)
  : RecordedEventDerived(FILLCIRCLE) {
ReadElement(aStream, mCircle);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2706}

2708inline void RecordedFillCircle::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "FillCircle (" << mCircle.origin.x << ", "
              << mCircle.origin.y << " - " << mCircle.radius << ")";
OutputSimplePatternInfo(mPattern, aStringStream);
2713}

2715template <class T>
2716inline RecordedDrawGlyphs<T>::~RecordedDrawGlyphs() {
delete[] mGlyphs;
26
←
Memory allocated by malloc() should be deallocated by free(), not 'delete[]'
2718}

2720template <class T>
2721inline bool RecordedDrawGlyphs<T>::PlayEvent(Translator* aTranslator) const {
if (mNumGlyphs > 0 && !mGlyphs) {
  // Glyph allocation failed
  return false;
}

DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

ScaledFont* scaledFont = aTranslator->LookupScaledFont(mScaledFont);
if (!scaledFont) {
  return false;
}

GlyphBuffer buffer;
buffer.mGlyphs = mGlyphs;
buffer.mNumGlyphs = mNumGlyphs;
DrawGlyphs(dt, scaledFont, buffer, *GenericPattern(mPattern, aTranslator));
return true;
2742}

2744template <class T>
2745template <class S>
2746RecordedDrawGlyphs<T>::RecordedDrawGlyphs(RecordedEvent::EventType aType,
                                        S& aStream)
  : RecordedEventDerived<T>(aType) {
ReadElement(aStream, mScaledFont);
ReadDrawOptions(aStream, mOptions);
this->ReadPatternData(aStream, mPattern);
ReadElement(aStream, mNumGlyphs);
if (!aStream.good() || mNumGlyphs <= 0) {
14
←
Assuming the condition is false→
15
←
Assuming field 'mNumGlyphs' is > 0→
16
←
Taking false branch→
  return;
}

mGlyphs = new (fallible) Glyph[mNumGlyphs];
17
←
Calling 'operator new[]'→
19
←
Returning from 'operator new[]'→
if (!mGlyphs) {
20
←
Assuming field 'mGlyphs' is non-null→
21
←
Taking false branch→
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false)) << "RecordedDrawGlyphs failed to allocate glyphs of size "
                  << mNumGlyphs;
  aStream.SetIsBad();
} else {
  aStream.read((char*)mGlyphs, sizeof(Glyph) * mNumGlyphs);
}
2765}

2767template <class T>
2768template <class S>
2769void RecordedDrawGlyphs<T>::Record(S& aStream) const {
WriteElement(aStream, mScaledFont);
WriteElement(aStream, mOptions);
this->RecordPatternData(aStream, mPattern);
WriteElement(aStream, mNumGlyphs);
aStream.write((char*)mGlyphs, sizeof(Glyph) * mNumGlyphs);
2775}

2777template <class T>
2778inline void RecordedDrawGlyphs<T>::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << this->GetName() << " (" << mScaledFont << ") ";
this->OutputSimplePatternInfo(mPattern, aStringStream);
2782}

2784inline bool RecordedMask::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->Mask(*GenericPattern(mSource, aTranslator),
         *GenericPattern(mMask, aTranslator), mOptions);
return true;
2793}

2795template <class S>
2796RecordedMask::RecordedMask(S& aStream) : RecordedEventDerived(MASK) {
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mSource);
ReadPatternData(aStream, mMask);
2800}

2802template <class S>
2803void RecordedMask::Record(S& aStream) const {
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mSource);
RecordPatternData(aStream, mMask);
2807}

2809inline void RecordedMask::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Mask (Source: ";
OutputSimplePatternInfo(mSource, aStringStream);
aStringStream << " Mask: ";
OutputSimplePatternInfo(mMask, aStringStream);
2815}

2817inline bool RecordedStroke::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

Path* path = aTranslator->LookupPath(mPath);
if (!path) {
  return false;
}

dt->Stroke(path, *GenericPattern(mPattern, aTranslator), mStrokeOptions,
           mOptions);
return true;
2831}

2833template <class S>
2834void RecordedStroke::Record(S& aStream) const {
WriteElement(aStream, mPath);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
RecordStrokeOptions(aStream, mStrokeOptions);
2839}

2841template <class S>
2842RecordedStroke::RecordedStroke(S& aStream) : RecordedEventDerived(STROKE) {
ReadElement(aStream, mPath);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
ReadStrokeOptions(aStream, mStrokeOptions);
2847}

2849inline void RecordedStroke::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Stroke (" << mPath
              << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
OutputSimplePatternInfo(mPattern, aStringStream);
2854}

2856inline bool RecordedClearRect::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->ClearRect(mRect);
return true;
2864}

2866template <class S>
2867void RecordedClearRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
2869}

2871template <class S>
2872RecordedClearRect::RecordedClearRect(S& aStream)
  : RecordedEventDerived(CLEARRECT) {
ReadElement(aStream, mRect);
2875}

2877inline void RecordedClearRect::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "ClearRect (" << mRect.X() << ", " << mRect.Y() << " - "
              << mRect.Width() << " x " << mRect.Height() << ") ";
2881}

2883inline bool RecordedCopySurface::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* surface = aTranslator->LookupSourceSurface(mSourceSurface);
if (!surface) {
  return false;
}

dt->CopySurface(surface, mSourceRect, mDest);
return true;
2896}

2898template <class S>
2899void RecordedCopySurface::Record(S& aStream) const {
WriteElement(aStream, mSourceSurface);
WriteElement(aStream, mSourceRect);
WriteElement(aStream, mDest);
2903}

2905template <class S>
2906RecordedCopySurface::RecordedCopySurface(S& aStream)
  : RecordedEventDerived(COPYSURFACE) {
ReadElement(aStream, mSourceSurface);
ReadElement(aStream, mSourceRect);
ReadElement(aStream, mDest);
2911}

2913inline void RecordedCopySurface::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "CopySurface (" << mSourceSurface << ")";
2916}

2918inline bool RecordedPushClip::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

Path* path = aTranslator->LookupPath(mPath);
if (!path) {
  return false;
}

dt->PushClip(path);
return true;
2931}

2933template <class S>
2934void RecordedPushClip::Record(S& aStream) const {
WriteElement(aStream, mPath);
2936}

2938template <class S>
2939RecordedPushClip::RecordedPushClip(S& aStream)
  : RecordedEventDerived(PUSHCLIP) {
ReadElement(aStream, mPath);
2942}

2944inline void RecordedPushClip::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PushClip (" << mPath << ") ";
2947}

2949inline bool RecordedPushClipRect::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->PushClipRect(mRect);
return true;
2957}

2959template <class S>
2960void RecordedPushClipRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
2962}

2964template <class S>
2965RecordedPushClipRect::RecordedPushClipRect(S& aStream)
  : RecordedEventDerived(PUSHCLIPRECT) {
ReadElement(aStream, mRect);
2968}

2970inline void RecordedPushClipRect::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PushClipRect (" << mRect.X() << ", " << mRect.Y() << " - "
              << mRect.Width() << " x " << mRect.Height() << ") ";
2974}

2976inline bool RecordedPopClip::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->PopClip();
return true;
2984}

2986template <class S>
2987void RecordedPopClip::Record(S& aStream) const {}

2989template <class S>
2990RecordedPopClip::RecordedPopClip(S& aStream) : RecordedEventDerived(POPCLIP) {}

2992inline void RecordedPopClip::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PopClip";
2995}

2997inline bool RecordedRemoveAllClips::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->RemoveAllClips();
return true;
3005}

3007template <class S>
3008void RecordedRemoveAllClips::Record(S& aStream) const {}

3010template <class S>
3011RecordedRemoveAllClips::RecordedRemoveAllClips(S& aStream)
  : RecordedEventDerived(REMOVEALLCLIPS) {}

3014inline void RecordedRemoveAllClips::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "RemoveAllClips";
3017}

3019inline bool RecordedPushLayer::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* mask =
    mMask ? aTranslator->LookupSourceSurface(mMask) : nullptr;
dt->PushLayer(mOpaque, mOpacity, mask, mMaskTransform, mBounds,
              mCopyBackground);
return true;
3030}

3032template <class S>
3033void RecordedPushLayer::Record(S& aStream) const {
WriteElement(aStream, mOpaque);
WriteElement(aStream, mOpacity);
WriteElement(aStream, mMask);
WriteElement(aStream, mMaskTransform);
WriteElement(aStream, mBounds);
WriteElement(aStream, mCopyBackground);
3040}

3042template <class S>
3043RecordedPushLayer::RecordedPushLayer(S& aStream)
  : RecordedEventDerived(PUSHLAYER) {
ReadElement(aStream, mOpaque);
ReadElement(aStream, mOpacity);
ReadElement(aStream, mMask);
ReadElement(aStream, mMaskTransform);
ReadElement(aStream, mBounds);
ReadElement(aStream, mCopyBackground);
3051}

3053inline void RecordedPushLayer::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PushPLayer (Opaque=" << mOpaque << ", Opacity=" << mOpacity
              << ", Mask Ref=" << mMask << ") ";
3057}

3059inline bool RecordedPushLayerWithBlend::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* mask =
    mMask ? aTranslator->LookupSourceSurface(mMask) : nullptr;
dt->PushLayerWithBlend(mOpaque, mOpacity, mask, mMaskTransform, mBounds,
                       mCopyBackground, mCompositionOp);
return true;
3071}

3073template <class S>
3074void RecordedPushLayerWithBlend::Record(S& aStream) const {
WriteElement(aStream, mOpaque);
WriteElement(aStream, mOpacity);
WriteElement(aStream, mMask);
WriteElement(aStream, mMaskTransform);
WriteElement(aStream, mBounds);
WriteElement(aStream, mCopyBackground);
WriteElement(aStream, mCompositionOp);
3082}

3084template <class S>
3085RecordedPushLayerWithBlend::RecordedPushLayerWithBlend(S& aStream)
  : RecordedEventDerived(PUSHLAYERWITHBLEND) {
ReadElement(aStream, mOpaque);
ReadElement(aStream, mOpacity);
ReadElement(aStream, mMask);
ReadElement(aStream, mMaskTransform);
ReadElement(aStream, mBounds);
ReadElement(aStream, mCopyBackground);
ReadElementConstrained(aStream, mCompositionOp, CompositionOp::OP_OVER,
                       CompositionOp::OP_COUNT);
3095}

3097inline void RecordedPushLayerWithBlend::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PushLayerWithBlend (Opaque=" << mOpaque
              << ", Opacity=" << mOpacity << ", Mask Ref=" << mMask << ") ";
3101}

3103inline bool RecordedPopLayer::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->PopLayer();
return true;
3111}

3113template <class S>
3114void RecordedPopLayer::Record(S& aStream) const {}

3116template <class S>
3117RecordedPopLayer::RecordedPopLayer(S& aStream)
  : RecordedEventDerived(POPLAYER) {}

3120inline void RecordedPopLayer::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "PopLayer";
3123}

3125inline bool RecordedSetPermitSubpixelAA::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->SetPermitSubpixelAA(mPermitSubpixelAA);
return true;
3134}

3136template <class S>
3137void RecordedSetPermitSubpixelAA::Record(S& aStream) const {
WriteElement(aStream, mPermitSubpixelAA);
3139}

3141template <class S>
3142RecordedSetPermitSubpixelAA::RecordedSetPermitSubpixelAA(S& aStream)
  : RecordedEventDerived(SETPERMITSUBPIXELAA) {
ReadElement(aStream, mPermitSubpixelAA);
3145}

3147inline void RecordedSetPermitSubpixelAA::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "SetPermitSubpixelAA (" << mPermitSubpixelAA << ")";
3150}

3152inline bool RecordedSetTransform::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

// If we're drawing to the reference DT, then we need to manually apply
// its initial transform, otherwise we'll just clobber it with only the
// the transform that was visible to the code doing the recording.
if (dt == aTranslator->GetReferenceDrawTarget()) {
  dt->SetTransform(mTransform *
                   aTranslator->GetReferenceDrawTargetTransform());
} else {
  dt->SetTransform(mTransform);
}

return true;
3169}

3171template <class S>
3172void RecordedSetTransform::Record(S& aStream) const {
WriteElement(aStream, mTransform);
3174}

3176template <class S>
3177RecordedSetTransform::RecordedSetTransform(S& aStream)
  : RecordedEventDerived(SETTRANSFORM) {
ReadElement(aStream, mTransform);
3180}

3182inline void RecordedSetTransform::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "SetTransform [ " << mTransform._11 << " " << mTransform._12
              << " ; " << mTransform._21 << " " << mTransform._22 << " ; "
              << mTransform._31 << " " << mTransform._32 << " ]";
3187}

3189inline bool RecordedDrawSurface::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* surface = aTranslator->LookupSourceSurface(mRefSource);
if (!surface) {
  return false;
}

dt->DrawSurface(surface, mDest, mSource, mDSOptions, mOptions);
return true;
3202}

3204template <class S>
3205void RecordedDrawSurface::Record(S& aStream) const {
WriteElement(aStream, mRefSource);
WriteElement(aStream, mDest);
WriteElement(aStream, mSource);
WriteElement(aStream, mDSOptions);
WriteElement(aStream, mOptions);
3211}

3213template <class S>
3214RecordedDrawSurface::RecordedDrawSurface(S& aStream)
  : RecordedEventDerived(DRAWSURFACE) {
ReadElement(aStream, mRefSource);
ReadElement(aStream, mDest);
ReadElement(aStream, mSource);
ReadDrawSurfaceOptions(aStream, mDSOptions);
ReadDrawOptions(aStream, mOptions);
3221}

3223inline void RecordedDrawSurface::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawSurface (" << mRefSource << ")";
3226}

3228inline bool RecordedDrawSurfaceDescriptor::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

RefPtr<SourceSurface> surface =
    aTranslator->LookupSourceSurfaceFromSurfaceDescriptor(mDesc);
if (!surface) {
  return false;
}

RefPtr<SourceSurface> opt = dt->OptimizeSourceSurface(surface);
if (opt) {
  surface = opt;
}

dt->DrawSurface(surface, mDest, mSource, mDSOptions, mOptions);
return true;
3248}

3250template <class S>
3251void RecordedDrawSurfaceDescriptor::Record(S& aStream) const {
WriteElement(aStream, mDesc);
WriteElement(aStream, mDest);
WriteElement(aStream, mSource);
WriteElement(aStream, mDSOptions);
WriteElement(aStream, mOptions);
3257}

3259template <class S>
3260RecordedDrawSurfaceDescriptor::RecordedDrawSurfaceDescriptor(S& aStream)
  : RecordedEventDerived(DRAWSURFACEDESCRIPTOR) {
ReadElement(aStream, mDesc);
ReadElement(aStream, mDest);
ReadElement(aStream, mSource);
ReadDrawSurfaceOptions(aStream, mDSOptions);
ReadDrawOptions(aStream, mOptions);
3267}

3269inline void RecordedDrawSurfaceDescriptor::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawSurfaceDescriptor (" << mDesc.type() << ")";
3272}

3274inline bool RecordedDrawDependentSurface::PlayEvent(
  Translator* aTranslator) const {
aTranslator->DrawDependentSurface(mId, mDest);
return true;
3278}

3280template <class S>
3281void RecordedDrawDependentSurface::Record(S& aStream) const {
WriteElement(aStream, mId);
WriteElement(aStream, mDest);
3284}

3286template <class S>
3287RecordedDrawDependentSurface::RecordedDrawDependentSurface(S& aStream)
  : RecordedEventDerived(DRAWDEPENDENTSURFACE) {
ReadElement(aStream, mId);
ReadElement(aStream, mDest);
3291}

3293inline void RecordedDrawDependentSurface::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawDependentSurface (" << mId << ")";
3296}

3298inline bool RecordedDrawFilter::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

FilterNode* filter = aTranslator->LookupFilterNode(mNode);
if (!filter) {
  return false;
}

dt->DrawFilter(filter, mSourceRect, mDestPoint, mOptions);
return true;
3311}

3313template <class S>
3314void RecordedDrawFilter::Record(S& aStream) const {
WriteElement(aStream, mNode);
WriteElement(aStream, mSourceRect);
WriteElement(aStream, mDestPoint);
WriteElement(aStream, mOptions);
3319}

3321template <class S>
3322RecordedDrawFilter::RecordedDrawFilter(S& aStream)
  : RecordedEventDerived(DRAWFILTER) {
ReadElement(aStream, mNode);
ReadElement(aStream, mSourceRect);
ReadElement(aStream, mDestPoint);
ReadDrawOptions(aStream, mOptions);
3328}

3330inline void RecordedDrawFilter::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawFilter (" << mNode << ")";
3333}

3335inline bool RecordedDrawSurfaceWithShadow::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* surface = aTranslator->LookupSourceSurface(mRefSource);
if (!surface) {
  return false;
}

dt->DrawSurfaceWithShadow(surface, mDest, mShadow, mOp);
return true;
3349}

3351template <class S>
3352void RecordedDrawSurfaceWithShadow::Record(S& aStream) const {
WriteElement(aStream, mRefSource);
WriteElement(aStream, mDest);
WriteElement(aStream, mShadow);
WriteElement(aStream, mOp);
3357}

3359template <class S>
3360RecordedDrawSurfaceWithShadow::RecordedDrawSurfaceWithShadow(S& aStream)
  : RecordedEventDerived(DRAWSURFACEWITHSHADOW) {
ReadElement(aStream, mRefSource);
ReadElement(aStream, mDest);
ReadElement(aStream, mShadow);
ReadElementConstrained(aStream, mOp, CompositionOp::OP_OVER,
                       CompositionOp::OP_COUNT);
3367}

3369inline void RecordedDrawSurfaceWithShadow::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawSurfaceWithShadow (" << mRefSource << ") DeviceColor: ("
              << mShadow.mColor.r << ", " << mShadow.mColor.g << ", "
              << mShadow.mColor.b << ", " << mShadow.mColor.a << ")";
3374}

3376inline bool RecordedDrawShadow::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

Path* path = aTranslator->LookupPath(mPath);
if (!path) {
  return false;
}

dt->DrawShadow(path, *GenericPattern(mPattern, aTranslator), mShadow,
               mOptions, mHasStrokeOptions ? &mStrokeOptions : nullptr);
return true;
3390}

3392template <class S>
3393void RecordedDrawShadow::Record(S& aStream) const {
WriteElement(aStream, mPath);
RecordPatternData(aStream, mPattern);
WriteElement(aStream, mShadow);
WriteElement(aStream, mOptions);
WriteElement(aStream, mHasStrokeOptions);
if (mHasStrokeOptions) {
  RecordStrokeOptions(aStream, mStrokeOptions);
}
3402}

3404template <class S>
3405RecordedDrawShadow::RecordedDrawShadow(S& aStream)
  : RecordedEventDerived(DRAWSHADOW) {
ReadElement(aStream, mPath);
ReadPatternData(aStream, mPattern);
ReadElement(aStream, mShadow);
ReadDrawOptions(aStream, mOptions);
ReadElement(aStream, mHasStrokeOptions);
if (mHasStrokeOptions) {
  ReadStrokeOptions(aStream, mStrokeOptions);
}
3415}

3417inline void RecordedDrawShadow::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DrawShadow (" << mPath << ") DeviceColor: ("
              << mShadow.mColor.r << ", " << mShadow.mColor.g << ", "
              << mShadow.mColor.b << ", " << mShadow.mColor.a << ")";
3422}

3424inline RecordedPathCreation::RecordedPathCreation(PathRecording* aPath)
  : RecordedEventDerived(PATHCREATION),
    mRefPtr(aPath),
    mFillRule(aPath->mFillRule),
    mPath(aPath) {}

3430inline bool RecordedPathCreation::PlayEvent(Translator* aTranslator) const {
DrawTarget* drawTarget = aTranslator->GetCurrentDrawTarget();
if (!drawTarget) {
  return false;
}

RefPtr<PathBuilder> builder = drawTarget->CreatePathBuilder(mFillRule);
if (!mPathOps->CheckedStreamToSink(*builder)) {
  return false;
}

RefPtr<Path> path = builder->Finish();
aTranslator->AddPath(mRefPtr, path);
return true;
3444}

3446template <class S>
3447void RecordedPathCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mFillRule);
mPath->mPathOps.Record(aStream);
3451}

3453template <class S>
3454RecordedPathCreation::RecordedPathCreation(S& aStream)
  : RecordedEventDerived(PATHCREATION) {
ReadElement(aStream, mRefPtr);
ReadElementConstrained(aStream, mFillRule, FillRule::FILL_WINDING,
                       FillRule::FILL_EVEN_ODD);
mPathOps = MakeUnique<PathOps>(aStream);
3460}

3462inline void RecordedPathCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
size_t numberOfOps =
    mPath ? mPath->mPathOps.NumberOfOps() : mPathOps->NumberOfOps();
aStringStream << "[" << mRefPtr << "] Path created (OpCount: " << numberOfOps
              << ")";
3468}
3469inline bool RecordedPathDestruction::PlayEvent(Translator* aTranslator) const {
aTranslator->RemovePath(mRefPtr);
return true;
3472}

3474template <class S>
3475void RecordedPathDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3477}

3479template <class S>
3480RecordedPathDestruction::RecordedPathDestruction(S& aStream)
  : RecordedEventDerived(PATHDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3483}

3485inline void RecordedPathDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] Path Destroyed";
3488}

3490inline RecordedSourceSurfaceCreation::~RecordedSourceSurfaceCreation() {
if (mDataOwned) {
  delete[] mData;
}
3494}

3496inline bool RecordedSourceSurfaceCreation::PlayEvent(
  Translator* aTranslator) const {
if (!mData) {
  return false;
}

RefPtr<SourceSurface> src = Factory::CreateWrappingDataSourceSurface(
    mData, mSize.width * BytesPerPixel(mFormat), mSize, mFormat,
    [](void* aClosure) { delete[] static_cast<uint8_t*>(aClosure); }, mData);
if (src) {
  mDataOwned = false;
}

aTranslator->AddSourceSurface(mRefPtr, src);
return true;
3511}

3513template <class S>
3514void RecordedSourceSurfaceCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mSize);
WriteElement(aStream, mFormat);
MOZ_ASSERT(mData)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mData)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(mData))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("mData", "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h"
, 3518); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mData" ")")
; do { *((volatile int*)__null) = 3518; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
size_t dataFormatWidth = BytesPerPixel(mFormat) * mSize.width;
const char* endSrc = (const char*)(mData + (mSize.height * mStride));
for (const char* src = (const char*)mData; src < endSrc; src += mStride) {
  aStream.write(src, dataFormatWidth);
}
3524}

3526template <class S>
3527RecordedSourceSurfaceCreation::RecordedSourceSurfaceCreation(S& aStream)
  : RecordedEventDerived(SOURCESURFACECREATION), mDataOwned(true) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mSize);
ReadElementConstrained(aStream, mFormat, SurfaceFormat::A8R8G8B8_UINT32,
                       SurfaceFormat::UNKNOWN);

if (!Factory::AllowedSurfaceSize(mSize)) {
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false)) << "RecordedSourceSurfaceCreation read invalid size "
                  << mSize;
  aStream.SetIsBad();
}

if (!aStream.good()) {
  return;
}

size_t size = 0;
if (mSize.width >= 0 && mSize.height >= 0) {
  size = size_t(mSize.width) * size_t(mSize.height) * BytesPerPixel(mFormat);
  mData = new (fallible) uint8_t[size];
}
if (!mData) {
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false))
      << "RecordedSourceSurfaceCreation failed to allocate data of size "
      << size;
  aStream.SetIsBad();
} else {
  aStream.read((char*)mData, size);
}
3557}

3559inline void RecordedSourceSurfaceCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr
              << "] SourceSurface created (Size: " << mSize.width << "x"
              << mSize.height << ")";
3564}

3566inline bool RecordedSourceSurfaceDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveSourceSurface(mRefPtr);
return true;
3570}

3572template <class S>
3573void RecordedSourceSurfaceDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3575}

3577template <class S>
3578RecordedSourceSurfaceDestruction::RecordedSourceSurfaceDestruction(S& aStream)
  : RecordedEventDerived(SOURCESURFACEDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3581}

3583inline void RecordedSourceSurfaceDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] SourceSurface Destroyed";
3586}

3588inline bool RecordedOptimizeSourceSurface::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* surface = aTranslator->LookupSourceSurface(mSurface);
if (!surface) {
  return false;
}

RefPtr<SourceSurface> optimizedSurface = dt->OptimizeSourceSurface(surface);
aTranslator->AddSourceSurface(mOptimizedSurface, optimizedSurface);
return true;
3603}

3605template <class S>
3606void RecordedOptimizeSourceSurface::Record(S& aStream) const {
WriteElement(aStream, mSurface);
WriteElement(aStream, mOptimizedSurface);
3609}

3611template <class S>
3612RecordedOptimizeSourceSurface::RecordedOptimizeSourceSurface(S& aStream)
  : RecordedEventDerived(OPTIMIZESOURCESURFACE) {
ReadElement(aStream, mSurface);
ReadElement(aStream, mOptimizedSurface);
3616}

3618inline void RecordedOptimizeSourceSurface::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mSurface << "] Surface Optimized";
3621}

3623inline bool RecordedExternalSurfaceCreation::PlayEvent(
  Translator* aTranslator) const {
RefPtr<SourceSurface> surface = aTranslator->LookupExternalSurface(mKey);
if (!surface) {
  return false;
}

aTranslator->AddSourceSurface(mRefPtr, surface);
return true;
3632}

3634template <class S>
3635void RecordedExternalSurfaceCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mKey);
3638}

3640template <class S>
3641RecordedExternalSurfaceCreation::RecordedExternalSurfaceCreation(S& aStream)
  : RecordedEventDerived(EXTERNALSURFACECREATION) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mKey);
3645}

3647inline void RecordedExternalSurfaceCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr
              << "] SourceSurfaceSharedData created (Key: " << mKey << ")";
3651}

3653inline RecordedFilterNodeCreation::~RecordedFilterNodeCreation() = default;

3655inline bool RecordedFilterNodeCreation::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* drawTarget = aTranslator->GetCurrentDrawTarget();
if (!drawTarget) {
  return false;
}

RefPtr<FilterNode> node = drawTarget->CreateFilter(mType);
aTranslator->AddFilterNode(mRefPtr, node);
return true;
3665}

3667template <class S>
3668void RecordedFilterNodeCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mType);
3671}

3673template <class S>
3674RecordedFilterNodeCreation::RecordedFilterNodeCreation(S& aStream)
  : RecordedEventDerived(FILTERNODECREATION) {
ReadElement(aStream, mRefPtr);
ReadElementConstrained(aStream, mType, FilterType::BLEND,
                       FilterType::OPACITY);
3679}

3681inline void RecordedFilterNodeCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "CreateFilter [" << mRefPtr
              << "] FilterNode created (Type: " << int(mType) << ")";
3685}

3687inline bool RecordedFilterNodeDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveFilterNode(mRefPtr);
return true;
3691}

3693template <class S>
3694void RecordedFilterNodeDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3696}

3698template <class S>
3699RecordedFilterNodeDestruction::RecordedFilterNodeDestruction(S& aStream)
  : RecordedEventDerived(FILTERNODEDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3702}

3704inline void RecordedFilterNodeDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] FilterNode Destroyed";
3707}

3709inline RecordedGradientStopsCreation::~RecordedGradientStopsCreation() {
if (mDataOwned) {
  delete[] mStops;
}
3713}

3715inline bool RecordedGradientStopsCreation::PlayEvent(
  Translator* aTranslator) const {
if (mNumStops > 0 && !mStops) {
  // Stops allocation failed
  return false;
}

DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

RefPtr<GradientStops> src =
    aTranslator->GetOrCreateGradientStops(dt, mStops, mNumStops, mExtendMode);
aTranslator->AddGradientStops(mRefPtr, src);
return true;
3731}

3733template <class S>
3734void RecordedGradientStopsCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mExtendMode);
WriteElement(aStream, mNumStops);
aStream.write((const char*)mStops, mNumStops * sizeof(GradientStop));
3739}

3741template <class S>
3742RecordedGradientStopsCreation::RecordedGradientStopsCreation(S& aStream)
  : RecordedEventDerived(GRADIENTSTOPSCREATION), mDataOwned(true) {
ReadElement(aStream, mRefPtr);
ReadElementConstrained(aStream, mExtendMode, ExtendMode::CLAMP,
                       ExtendMode::REFLECT);
ReadElement(aStream, mNumStops);
if (!aStream.good() || mNumStops <= 0) {
  return;
}

mStops = new (fallible) GradientStop[mNumStops];
if (!mStops) {
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false))
      << "RecordedGradientStopsCreation failed to allocate stops of size "
      << mNumStops;
  aStream.SetIsBad();
} else {
  aStream.read((char*)mStops, mNumStops * sizeof(GradientStop));
}
3761}

3763inline void RecordedGradientStopsCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr
              << "] GradientStops created (Stops: " << mNumStops << ")";
3767}

3769inline bool RecordedGradientStopsDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveGradientStops(mRefPtr);
return true;
3773}

3775template <class S>
3776void RecordedGradientStopsDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3778}

3780template <class S>
3781RecordedGradientStopsDestruction::RecordedGradientStopsDestruction(S& aStream)
  : RecordedEventDerived(GRADIENTSTOPSDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3784}

3786inline void RecordedGradientStopsDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] GradientStops Destroyed";
3789}

3791inline bool RecordedIntoLuminanceSource::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

RefPtr<SourceSurface> src = dt->IntoLuminanceSource(mLuminanceType, mOpacity);
aTranslator->AddSourceSurface(mRefPtr, src);
return true;
3801}

3803template <class S>
3804void RecordedIntoLuminanceSource::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mLuminanceType);
WriteElement(aStream, mOpacity);
3808}

3810template <class S>
3811RecordedIntoLuminanceSource::RecordedIntoLuminanceSource(S& aStream)
  : RecordedEventDerived(INTOLUMINANCE) {
ReadElement(aStream, mRefPtr);
ReadElementConstrained(aStream, mLuminanceType, LuminanceType::LUMINANCE,
                       LuminanceType::LINEARRGB);
ReadElement(aStream, mOpacity);
3817}

3819inline void RecordedIntoLuminanceSource::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] Into Luminance Source";
3822}

3824inline bool RecordedExtractSubrect::PlayEvent(Translator* aTranslator) const {
SourceSurface* sourceSurf = aTranslator->LookupSourceSurface(mSourceSurface);
if (!sourceSurf) {
  return false;
}

RefPtr<SourceSurface> subSurf = sourceSurf->ExtractSubrect(mSubrect);
if (!subSurf) {
  RefPtr<DrawTarget> dt =
      aTranslator->GetReferenceDrawTarget()->CreateSimilarDrawTarget(
          mSubrect.Size(), sourceSurf->GetFormat());
  if (dt) {
    dt->CopySurface(sourceSurf, mSubrect, IntPoint());
    subSurf = dt->Snapshot();
  }
}
if (!subSurf) {
  return false;
}

aTranslator->AddSourceSurface(mRefPtr, subSurf);
return true;
3846}

3848template <class S>
3849void RecordedExtractSubrect::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mSourceSurface);
WriteElement(aStream, mSubrect);
3853}

3855template <class S>
3856RecordedExtractSubrect::RecordedExtractSubrect(S& aStream)
  : RecordedEventDerived(EXTRACTSUBRECT) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mSourceSurface);
ReadElement(aStream, mSubrect);
3861}

3863inline void RecordedExtractSubrect::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] Exract Subrect";
3866}

3868inline bool RecordedFlush::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->Flush();
return true;
3876}

3878template <class S>
3879void RecordedFlush::Record(S& aStream) const {}

3881template <class S>
3882RecordedFlush::RecordedFlush(S& aStream) : RecordedEventDerived(FLUSH) {}

3884inline void RecordedFlush::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Flush";
3887}

3889inline bool RecordedDetachAllSnapshots::PlayEvent(
  Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

dt->DetachAllSnapshots();
return true;
3898}

3900template <class S>
3901void RecordedDetachAllSnapshots::Record(S& aStream) const {}

3903template <class S>
3904RecordedDetachAllSnapshots::RecordedDetachAllSnapshots(S& aStream)
  : RecordedEventDerived(DETACHALLSNAPSHOTS) {}

3907inline void RecordedDetachAllSnapshots::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "DetachAllSnapshots";
3910}

3912inline bool RecordedSnapshot::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

RefPtr<SourceSurface> src = dt->Snapshot();
aTranslator->AddSourceSurface(mRefPtr, src);
return true;
3921}

3923template <class S>
3924void RecordedSnapshot::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3926}

3928template <class S>
3929RecordedSnapshot::RecordedSnapshot(S& aStream)
  : RecordedEventDerived(SNAPSHOT) {
ReadElement(aStream, mRefPtr);
3932}

3934inline void RecordedSnapshot::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] Snapshot Created";
3937}

3939inline RecordedFontData::~RecordedFontData() { delete[] mData; }

3941inline bool RecordedFontData::PlayEvent(Translator* aTranslator) const {
if (!mData) {
  return false;
}

RefPtr<NativeFontResource> fontResource = Factory::CreateNativeFontResource(
    mData, mFontDetails.size, mType, aTranslator->GetFontContext());
if (!fontResource) {
  return false;
}

aTranslator->AddNativeFontResource(mFontDetails.fontDataKey, fontResource);
return true;
3954}

3956template <class S>
3957void RecordedFontData::Record(S& aStream) const {
MOZ_ASSERT(mGetFontFileDataSucceeded)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGetFontFileDataSucceeded)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mGetFontFileDataSucceeded)))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("mGetFontFileDataSucceeded"
, "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h"
, 3958); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGetFontFileDataSucceeded"
 ")"); do { *((volatile int*)__null) = 3958; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

WriteElement(aStream, mType);
WriteElement(aStream, mFontDetails.fontDataKey);
if (!mData) {
  WriteElement(aStream, 0);
} else {
  WriteElement(aStream, mFontDetails.size);
  aStream.write((const char*)mData, mFontDetails.size);
}
3968}

3970inline void RecordedFontData::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Font Data of size " << mFontDetails.size;
3973}

3975inline void RecordedFontData::SetFontData(const uint8_t* aData, uint32_t aSize,
                                        uint32_t aIndex) {
mData = new (fallible) uint8_t[aSize];
if (!mData) {
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false))
      << "RecordedFontData failed to allocate data for recording of size "
      << aSize;
} else {
  memcpy(mData, aData, aSize);
}
mFontDetails.fontDataKey = SFNTData::GetUniqueKey(aData, aSize, 0, nullptr);
mFontDetails.size = aSize;
mFontDetails.index = aIndex;
3988}

3990inline bool RecordedFontData::GetFontDetails(RecordedFontDetails& fontDetails) {
if (!mGetFontFileDataSucceeded) {
  return false;
}

fontDetails.fontDataKey = mFontDetails.fontDataKey;
fontDetails.size = mFontDetails.size;
fontDetails.index = mFontDetails.index;
return true;
3999}

4001template <class S>
4002RecordedFontData::RecordedFontData(S& aStream)
  : RecordedEventDerived(FONTDATA), mType(FontType::UNKNOWN) {
ReadElementConstrained(aStream, mType, FontType::DWRITE, FontType::UNKNOWN);
ReadElement(aStream, mFontDetails.fontDataKey);
ReadElement(aStream, mFontDetails.size);
if (!mFontDetails.size || !aStream.good()) {
  return;
}

mData = new (fallible) uint8_t[mFontDetails.size];
if (!mData) {
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false))
      << "RecordedFontData failed to allocate data for playback of size "
      << mFontDetails.size;
  aStream.SetIsBad();
} else {
  aStream.read((char*)mData, mFontDetails.size);
}
4020}

4022inline RecordedFontDescriptor::~RecordedFontDescriptor() = default;

4024inline bool RecordedFontDescriptor::PlayEvent(Translator* aTranslator) const {
RefPtr<UnscaledFont> font = Factory::CreateUnscaledFontFromFontDescriptor(
    mType, mData.data(), mData.size(), mIndex);
if (!font) {
  gfxDevCrash(LogReason::InvalidFont)mozilla::gfx::CriticalLog(int(gfx::LogOptions::AutoPrefix) | int
(gfx::LogOptions::AssertOnCall) | int(gfx::LogOptions::CrashAction
), (LogReason::InvalidFont))
      << "Failed creating UnscaledFont of type " << int(mType)
      << " from font descriptor";
  return false;
}

aTranslator->AddUnscaledFont(mRefPtr, font);
return true;
4036}

4038template <class S>
4039void RecordedFontDescriptor::Record(S& aStream) const {
MOZ_ASSERT(mHasDesc)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mHasDesc)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mHasDesc))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mHasDesc", "/var/lib/jenkins/workspace/firefox-scan-build/gfx/2d/RecordedEventImpl.h"
, 4040); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mHasDesc" ")"
); do { *((volatile int*)__null) = 4040; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
WriteElement(aStream, mType);
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mIndex);
WriteElement(aStream, (size_t)mData.size());
if (mData.size()) {
  aStream.write((char*)mData.data(), mData.size());
}
4048}

4050inline void RecordedFontDescriptor::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] Font Descriptor";
4053}

4055inline void RecordedFontDescriptor::SetFontDescriptor(const uint8_t* aData,
                                                    uint32_t aSize,
                                                    uint32_t aIndex) {
mData.assign(aData, aData + aSize);
mIndex = aIndex;
4060}

4062template <class S>
4063RecordedFontDescriptor::RecordedFontDescriptor(S& aStream)
  : RecordedEventDerived(FONTDESC) {
ReadElementConstrained(aStream, mType, FontType::DWRITE, FontType::UNKNOWN);
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mIndex);

size_t size;
ReadElement(aStream, size);
if (!aStream.good()) {
  return;
}
if (size) {
  mData.resize(size);
  aStream.read((char*)mData.data(), size);
}
4078}

4080inline bool RecordedUnscaledFontCreation::PlayEvent(
  Translator* aTranslator) const {
NativeFontResource* fontResource =
    aTranslator->LookupNativeFontResource(mFontDataKey);
if (!fontResource) {
  gfxDevCrash(LogReason::NativeFontResourceNotFound)mozilla::gfx::CriticalLog(int(gfx::LogOptions::AutoPrefix) | int
(gfx::LogOptions::AssertOnCall) | int(gfx::LogOptions::CrashAction
), (LogReason::NativeFontResourceNotFound))
      << "NativeFontResource lookup failed for key |" << hexa(mFontDataKey)
      << "|.";
  return false;
}

RefPtr<UnscaledFont> unscaledFont = fontResource->CreateUnscaledFont(
    mIndex, mInstanceData.data(), mInstanceData.size());
aTranslator->AddUnscaledFont(mRefPtr, unscaledFont);
return true;
4095}

4097template <class S>
4098void RecordedUnscaledFontCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mFontDataKey);
WriteElement(aStream, mIndex);
WriteElement(aStream, (size_t)mInstanceData.size());
if (mInstanceData.size()) {
  aStream.write((char*)mInstanceData.data(), mInstanceData.size());
}
4106}

4108inline void RecordedUnscaledFontCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] UnscaledFont Created";
4111}

4113inline void RecordedUnscaledFontCreation::SetFontInstanceData(
  const uint8_t* aData, uint32_t aSize) {
if (aSize) {
  mInstanceData.assign(aData, aData + aSize);
}
4118}

4120template <class S>
4121RecordedUnscaledFontCreation::RecordedUnscaledFontCreation(S& aStream)
  : RecordedEventDerived(UNSCALEDFONTCREATION) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mFontDataKey);
ReadElement(aStream, mIndex);

size_t size;
ReadElement(aStream, size);
if (!aStream.good()) {
  return;
}
if (size) {
  mInstanceData.resize(size);
  aStream.read((char*)mInstanceData.data(), size);
}
4136}

4138inline bool RecordedUnscaledFontDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveUnscaledFont(mRefPtr);
return true;
4142}

4144template <class S>
4145void RecordedUnscaledFontDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
4147}

4149template <class S>
4150RecordedUnscaledFontDestruction::RecordedUnscaledFontDestruction(S& aStream)
  : RecordedEventDerived(UNSCALEDFONTDESTRUCTION) {
ReadElement(aStream, mRefPtr);
4153}

4155inline void RecordedUnscaledFontDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] UnscaledFont Destroyed";
4158}

4160inline bool RecordedScaledFontCreation::PlayEvent(
  Translator* aTranslator) const {
UnscaledFont* unscaledFont = aTranslator->LookupUnscaledFont(mUnscaledFont);
if (!unscaledFont) {
  gfxDevCrash(LogReason::UnscaledFontNotFound)mozilla::gfx::CriticalLog(int(gfx::LogOptions::AutoPrefix) | int
(gfx::LogOptions::AssertOnCall) | int(gfx::LogOptions::CrashAction
), (LogReason::UnscaledFontNotFound))
      << "UnscaledFont lookup failed for key |" << hexa(mUnscaledFont)
      << "|.";
  return false;
}

RefPtr<ScaledFont> scaledFont = unscaledFont->CreateScaledFont(
    mGlyphSize, mInstanceData.data(), mInstanceData.size(),
    mVariations.data(), mVariations.size());

aTranslator->AddScaledFont(mRefPtr, scaledFont);
return true;
4176}

4178template <class S>
4179void RecordedScaledFontCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mUnscaledFont);
WriteElement(aStream, mGlyphSize);
WriteElement(aStream, (size_t)mInstanceData.size());
if (mInstanceData.size()) {
  aStream.write((char*)mInstanceData.data(), mInstanceData.size());
}
WriteElement(aStream, (size_t)mVariations.size());
if (mVariations.size()) {
  aStream.write((char*)mVariations.data(),
                sizeof(FontVariation) * mVariations.size());
}
4192}

4194inline void RecordedScaledFontCreation::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] ScaledFont Created";
4197}

4199inline void RecordedScaledFontCreation::SetFontInstanceData(
  const uint8_t* aData, uint32_t aSize, const FontVariation* aVariations,
  uint32_t aNumVariations) {
if (aSize) {
  mInstanceData.assign(aData, aData + aSize);
}
if (aNumVariations) {
  mVariations.assign(aVariations, aVariations + aNumVariations);
}
4208}

4210template <class S>
4211RecordedScaledFontCreation::RecordedScaledFontCreation(S& aStream)
  : RecordedEventDerived(SCALEDFONTCREATION) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mUnscaledFont);
ReadElement(aStream, mGlyphSize);

size_t size;
ReadElement(aStream, size);
if (!aStream.good()) {
  return;
}
if (size) {
  mInstanceData.resize(size);
  aStream.read((char*)mInstanceData.data(), size);
}

size_t numVariations;
ReadElement(aStream, numVariations);
if (!aStream.good()) {
  return;
}
if (numVariations) {
  mVariations.resize(numVariations);
  aStream.read((char*)mVariations.data(),
               sizeof(FontVariation) * numVariations);
}
4237}

4239inline bool RecordedScaledFontDestruction::PlayEvent(
  Translator* aTranslator) const {
aTranslator->RemoveScaledFont(mRefPtr);
return true;
4243}

4245template <class S>
4246void RecordedScaledFontDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
4248}

4250template <class S>
4251RecordedScaledFontDestruction::RecordedScaledFontDestruction(S& aStream)
  : RecordedEventDerived(SCALEDFONTDESTRUCTION) {
ReadElement(aStream, mRefPtr);
4254}

4256inline void RecordedScaledFontDestruction::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mRefPtr << "] ScaledFont Destroyed";
4259}

4261inline bool RecordedMaskSurface::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}

SourceSurface* surface = aTranslator->LookupSourceSurface(mRefMask);
if (!surface) {
  return false;
}

dt->MaskSurface(*GenericPattern(mPattern, aTranslator), surface, mOffset,
                mOptions);
return true;
4275}

4277template <class S>
4278void RecordedMaskSurface::Record(S& aStream) const {
RecordPatternData(aStream, mPattern);
WriteElement(aStream, mRefMask);
WriteElement(aStream, mOffset);
WriteElement(aStream, mOptions);
4283}

4285template <class S>
4286RecordedMaskSurface::RecordedMaskSurface(S& aStream)
  : RecordedEventDerived(MASKSURFACE) {
ReadPatternData(aStream, mPattern);
ReadElement(aStream, mRefMask);
ReadElement(aStream, mOffset);
ReadDrawOptions(aStream, mOptions);
4292}

4294inline void RecordedMaskSurface::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "MaskSurface (" << mRefMask << ")  Offset: (" << mOffset.x
              << "x" << mOffset.y << ") Pattern: ";
OutputSimplePatternInfo(mPattern, aStringStream);
4299}

4301template <typename T>
4302void ReplaySetAttribute(FilterNode* aNode, uint32_t aIndex, T aValue) {
aNode->SetAttribute(aIndex, aValue);
4304}

4306inline bool RecordedFilterNodeSetAttribute::PlayEvent(
  Translator* aTranslator) const {
FilterNode* node = aTranslator->LookupFilterNode(mNode);
if (!node) {
  return false;
}

4313#define REPLAY_SET_ATTRIBUTE(type, argtype)case ARGTYPE_argtype: ReplaySetAttribute(node, mIndex, *(type
*)&mPayload.front()); break                      \
case ARGTYPE_##argtype:                                        \
  ReplaySetAttribute(node, mIndex, *(type*)&mPayload.front()); \
  break

switch (mArgType) {
  REPLAY_SET_ATTRIBUTE(bool, BOOL)case ARGTYPE_BOOL: ReplaySetAttribute(node, mIndex, *(bool*)&
mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(uint32_t, UINT32)case ARGTYPE_UINT32: ReplaySetAttribute(node, mIndex, *(uint32_t
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Float, FLOAT)case ARGTYPE_FLOAT: ReplaySetAttribute(node, mIndex, *(Float*
)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Size, SIZE)case ARGTYPE_SIZE: ReplaySetAttribute(node, mIndex, *(Size*)&
mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(IntSize, INTSIZE)case ARGTYPE_INTSIZE: ReplaySetAttribute(node, mIndex, *(IntSize
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(IntPoint, INTPOINT)case ARGTYPE_INTPOINT: ReplaySetAttribute(node, mIndex, *(IntPoint
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Rect, RECT)case ARGTYPE_RECT: ReplaySetAttribute(node, mIndex, *(Rect*)&
mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(IntRect, INTRECT)case ARGTYPE_INTRECT: ReplaySetAttribute(node, mIndex, *(IntRect
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Point, POINT)case ARGTYPE_POINT: ReplaySetAttribute(node, mIndex, *(Point*
)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Matrix, MATRIX)case ARGTYPE_MATRIX: ReplaySetAttribute(node, mIndex, *(Matrix
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Matrix5x4, MATRIX5X4)case ARGTYPE_MATRIX5X4: ReplaySetAttribute(node, mIndex, *(Matrix5x4
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(Point3D, POINT3D)case ARGTYPE_POINT3D: ReplaySetAttribute(node, mIndex, *(Point3D
*)&mPayload.front()); break;
  REPLAY_SET_ATTRIBUTE(DeviceColor, COLOR)case ARGTYPE_COLOR: ReplaySetAttribute(node, mIndex, *(DeviceColor
*)&mPayload.front()); break;
  case ARGTYPE_FLOAT_ARRAY:
    node->SetAttribute(mIndex,
                       reinterpret_cast<const Float*>(&mPayload.front()),
                       mPayload.size() / sizeof(Float));
    break;
}

return true;
4340}

4342template <class S>
4343void RecordedFilterNodeSetAttribute::Record(S& aStream) const {
WriteElement(aStream, mNode);
WriteElement(aStream, mIndex);
WriteElement(aStream, mArgType);
WriteElement(aStream, uint64_t(mPayload.size()));
aStream.write((const char*)&mPayload.front(), mPayload.size());
4349}

4351template <class S>
4352RecordedFilterNodeSetAttribute::RecordedFilterNodeSetAttribute(S& aStream)
  : RecordedEventDerived(FILTERNODESETATTRIBUTE) {
ReadElement(aStream, mNode);
ReadElement(aStream, mIndex);
ReadElementConstrained(aStream, mArgType, ArgType::ARGTYPE_UINT32,
                       ArgType::ARGTYPE_FLOAT_ARRAY);
uint64_t size;
ReadElement(aStream, size);
if (!aStream.good()) {
  return;
}

mPayload.resize(size_t(size));
aStream.read((char*)&mPayload.front(), size);
4366}

4368inline void RecordedFilterNodeSetAttribute::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mNode << "] SetAttribute (" << mIndex << ")";
4371}

4373inline bool RecordedFilterNodeSetInput::PlayEvent(
  Translator* aTranslator) const {
FilterNode* node = aTranslator->LookupFilterNode(mNode);
if (!node) {
  return false;
}

if (mInputFilter) {
  node->SetInput(mIndex, aTranslator->LookupFilterNode(mInputFilter));
} else {
  node->SetInput(mIndex, aTranslator->LookupSourceSurface(mInputSurface));
}

return true;
4387}

4389template <class S>
4390void RecordedFilterNodeSetInput::Record(S& aStream) const {
WriteElement(aStream, mNode);
WriteElement(aStream, mIndex);
WriteElement(aStream, mInputFilter);
WriteElement(aStream, mInputSurface);
4395}

4397template <class S>
4398RecordedFilterNodeSetInput::RecordedFilterNodeSetInput(S& aStream)
  : RecordedEventDerived(FILTERNODESETINPUT) {
ReadElement(aStream, mNode);
ReadElement(aStream, mIndex);
ReadElement(aStream, mInputFilter);
ReadElement(aStream, mInputSurface);
4404}

4406inline void RecordedFilterNodeSetInput::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "[" << mNode << "] SetAttribute (" << mIndex << ", ";

if (mInputFilter) {
  aStringStream << "Filter: " << mInputFilter;
} else {
  aStringStream << "Surface: " << mInputSurface;
}

aStringStream << ")";
4417}

4419inline bool RecordedLink::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}
dt->Link(mLocalDest.c_str(), mURI.c_str(), mRect);
return true;
4426}

4428template <class S>
4429void RecordedLink::Record(S& aStream) const {
WriteElement(aStream, mRect);
uint32_t len = mLocalDest.length();
WriteElement(aStream, len);
if (len) {
  aStream.write(mLocalDest.data(), len);
}
len = mURI.length();
WriteElement(aStream, len);
if (len) {
  aStream.write(mURI.data(), len);
}
4441}

4443template <class S>
4444RecordedLink::RecordedLink(S& aStream) : RecordedEventDerived(LINK) {
ReadElement(aStream, mRect);
uint32_t len;
ReadElement(aStream, len);
mLocalDest.resize(size_t(len));
if (len && aStream.good()) {
  aStream.read(&mLocalDest.front(), len);
}
ReadElement(aStream, len);
mURI.resize(size_t(len));
if (len && aStream.good()) {
  aStream.read(&mURI.front(), len);
}
4457}

4459inline void RecordedLink::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
if (mLocalDest.empty()) {
  aStringStream << "Link [" << mURI << " @ " << mRect << "]";
} else {
  aStringStream << "Link [" << mLocalDest << " / " << mURI << " @ " << mRect
                << "]";
}
4467}

4469inline bool RecordedDestination::PlayEvent(Translator* aTranslator) const {
DrawTarget* dt = aTranslator->GetCurrentDrawTarget();
if (!dt) {
  return false;
}
dt->Destination(mDestination.c_str(), mPoint);
return true;
4476}

4478template <class S>
4479void RecordedDestination::Record(S& aStream) const {
WriteElement(aStream, mPoint);
uint32_t len = mDestination.length();
WriteElement(aStream, len);
if (len) {
  aStream.write(mDestination.data(), len);
}
4486}

4488template <class S>
4489RecordedDestination::RecordedDestination(S& aStream)
  : RecordedEventDerived(DESTINATION) {
ReadElement(aStream, mPoint);
uint32_t len;
ReadElement(aStream, len);
mDestination.resize(size_t(len));
if (len && aStream.good()) {
  aStream.read(&mDestination.front(), len);
}
4498}

4500inline void RecordedDestination::OutputSimpleEventInfo(
  std::stringstream& aStringStream) const {
aStringStream << "Destination [" << mDestination << " @ " << mPoint << "]";
4503}

4505#define FOR_EACH_EVENT(f)f(DRAWTARGETCREATION, RecordedDrawTargetCreation); f(DRAWTARGETDESTRUCTION
, RecordedDrawTargetDestruction); f(SETCURRENTDRAWTARGET, RecordedSetCurrentDrawTarget
); f(FILLRECT, RecordedFillRect); f(STROKERECT, RecordedStrokeRect
); f(STROKELINE, RecordedStrokeLine); f(STROKECIRCLE, RecordedStrokeCircle
); f(CLEARRECT, RecordedClearRect); f(COPYSURFACE, RecordedCopySurface
); f(SETPERMITSUBPIXELAA, RecordedSetPermitSubpixelAA); f(SETTRANSFORM
, RecordedSetTransform); f(PUSHCLIPRECT, RecordedPushClipRect
); f(PUSHCLIP, RecordedPushClip); f(POPCLIP, RecordedPopClip)
; f(REMOVEALLCLIPS, RecordedRemoveAllClips); f(FILL, RecordedFill
); f(FILLCIRCLE, RecordedFillCircle); f(FILLGLYPHS, RecordedFillGlyphs
); f(STROKEGLYPHS, RecordedStrokeGlyphs); f(MASK, RecordedMask
); f(STROKE, RecordedStroke); f(DRAWSURFACE, RecordedDrawSurface
); f(DRAWSURFACEDESCRIPTOR, RecordedDrawSurfaceDescriptor); f
(DRAWDEPENDENTSURFACE, RecordedDrawDependentSurface); f(DRAWSURFACEWITHSHADOW
, RecordedDrawSurfaceWithShadow); f(DRAWSHADOW, RecordedDrawShadow
); f(DRAWFILTER, RecordedDrawFilter); f(PATHCREATION, RecordedPathCreation
); f(PATHDESTRUCTION, RecordedPathDestruction); f(SOURCESURFACECREATION
, RecordedSourceSurfaceCreation); f(SOURCESURFACEDESTRUCTION,
 RecordedSourceSurfaceDestruction); f(FILTERNODECREATION, RecordedFilterNodeCreation
); f(FILTERNODEDESTRUCTION, RecordedFilterNodeDestruction); f
(GRADIENTSTOPSCREATION, RecordedGradientStopsCreation); f(GRADIENTSTOPSDESTRUCTION
, RecordedGradientStopsDestruction); f(SNAPSHOT, RecordedSnapshot
); f(SCALEDFONTCREATION, RecordedScaledFontCreation); f(SCALEDFONTDESTRUCTION
, RecordedScaledFontDestruction); f(MASKSURFACE, RecordedMaskSurface
); f(FILTERNODESETATTRIBUTE, RecordedFilterNodeSetAttribute);
 f(FILTERNODESETINPUT, RecordedFilterNodeSetInput); f(CREATESIMILARDRAWTARGET
, RecordedCreateSimilarDrawTarget); f(CREATECLIPPEDDRAWTARGET
, RecordedCreateClippedDrawTarget); f(CREATEDRAWTARGETFORFILTER
, RecordedCreateDrawTargetForFilter); f(FONTDATA, RecordedFontData
); f(FONTDESC, RecordedFontDescriptor); f(PUSHLAYER, RecordedPushLayer
); f(PUSHLAYERWITHBLEND, RecordedPushLayerWithBlend); f(POPLAYER
, RecordedPopLayer); f(UNSCALEDFONTCREATION, RecordedUnscaledFontCreation
); f(UNSCALEDFONTDESTRUCTION, RecordedUnscaledFontDestruction
); f(INTOLUMINANCE, RecordedIntoLuminanceSource); f(EXTRACTSUBRECT
, RecordedExtractSubrect); f(EXTERNALSURFACECREATION, RecordedExternalSurfaceCreation
); f(FLUSH, RecordedFlush); f(DETACHALLSNAPSHOTS, RecordedDetachAllSnapshots
); f(OPTIMIZESOURCESURFACE, RecordedOptimizeSourceSurface); f
(LINK, RecordedLink); f(DESTINATION, RecordedDestination);                                          \
f(DRAWTARGETCREATION, RecordedDrawTargetCreation);               \
f(DRAWTARGETDESTRUCTION, RecordedDrawTargetDestruction);         \
f(SETCURRENTDRAWTARGET, RecordedSetCurrentDrawTarget);           \
f(FILLRECT, RecordedFillRect);                                   \
f(STROKERECT, RecordedStrokeRect);                               \
f(STROKELINE, RecordedStrokeLine);                               \
f(STROKECIRCLE, RecordedStrokeCircle);                           \
f(CLEARRECT, RecordedClearRect);                                 \
f(COPYSURFACE, RecordedCopySurface);                             \
f(SETPERMITSUBPIXELAA, RecordedSetPermitSubpixelAA);             \
f(SETTRANSFORM, RecordedSetTransform);                           \
f(PUSHCLIPRECT, RecordedPushClipRect);                           \
f(PUSHCLIP, RecordedPushClip);                                   \
f(POPCLIP, RecordedPopClip);                                     \
f(REMOVEALLCLIPS, RecordedRemoveAllClips);                       \
f(FILL, RecordedFill);                                           \
f(FILLCIRCLE, RecordedFillCircle);                               \
f(FILLGLYPHS, RecordedFillGlyphs);                               \
f(STROKEGLYPHS, RecordedStrokeGlyphs);                           \
f(MASK, RecordedMask);                                           \
f(STROKE, RecordedStroke);                                       \
f(DRAWSURFACE, RecordedDrawSurface);                             \
f(DRAWSURFACEDESCRIPTOR, RecordedDrawSurfaceDescriptor);         \
f(DRAWDEPENDENTSURFACE, RecordedDrawDependentSurface);           \
f(DRAWSURFACEWITHSHADOW, RecordedDrawSurfaceWithShadow);         \
f(DRAWSHADOW, RecordedDrawShadow);                               \
f(DRAWFILTER, RecordedDrawFilter);                               \
f(PATHCREATION, RecordedPathCreation);                           \
f(PATHDESTRUCTION, RecordedPathDestruction);                     \
f(SOURCESURFACECREATION, RecordedSourceSurfaceCreation);         \
f(SOURCESURFACEDESTRUCTION, RecordedSourceSurfaceDestruction);   \
f(FILTERNODECREATION, RecordedFilterNodeCreation);               \
f(FILTERNODEDESTRUCTION, RecordedFilterNodeDestruction);         \
f(GRADIENTSTOPSCREATION, RecordedGradientStopsCreation);         \
f(GRADIENTSTOPSDESTRUCTION, RecordedGradientStopsDestruction);   \
f(SNAPSHOT, RecordedSnapshot);                                   \
f(SCALEDFONTCREATION, RecordedScaledFontCreation);               \
f(SCALEDFONTDESTRUCTION, RecordedScaledFontDestruction);         \
f(MASKSURFACE, RecordedMaskSurface);                             \
f(FILTERNODESETATTRIBUTE, RecordedFilterNodeSetAttribute);       \
f(FILTERNODESETINPUT, RecordedFilterNodeSetInput);               \
f(CREATESIMILARDRAWTARGET, RecordedCreateSimilarDrawTarget);     \
f(CREATECLIPPEDDRAWTARGET, RecordedCreateClippedDrawTarget);     \
f(CREATEDRAWTARGETFORFILTER, RecordedCreateDrawTargetForFilter); \
f(FONTDATA, RecordedFontData);                                   \
f(FONTDESC, RecordedFontDescriptor);                             \
f(PUSHLAYER, RecordedPushLayer);                                 \
f(PUSHLAYERWITHBLEND, RecordedPushLayerWithBlend);               \
f(POPLAYER, RecordedPopLayer);                                   \
f(UNSCALEDFONTCREATION, RecordedUnscaledFontCreation);           \
f(UNSCALEDFONTDESTRUCTION, RecordedUnscaledFontDestruction);     \
f(INTOLUMINANCE, RecordedIntoLuminanceSource);                   \
f(EXTRACTSUBRECT, RecordedExtractSubrect);                       \
f(EXTERNALSURFACECREATION, RecordedExternalSurfaceCreation);     \
f(FLUSH, RecordedFlush);                                         \
f(DETACHALLSNAPSHOTS, RecordedDetachAllSnapshots);               \
f(OPTIMIZESOURCESURFACE, RecordedOptimizeSourceSurface);         \
f(LINK, RecordedLink);                                           \
f(DESTINATION, RecordedDestination);

4566#define DO_WITH_EVENT_TYPE(_typeenum, _class)case _typeenum: { auto e = _class(aStream); return aAction(&
e); } \
case _typeenum: {                           \
  auto e = _class(aStream);                 \
  return aAction(&e);                       \
}

4572template <class S>
4573bool RecordedEvent::DoWithEvent(
  S& aStream, EventType aType,
  const std::function<bool(RecordedEvent*)>& aAction) {
switch (aType) {
11
←
Control jumps to 'case FILLGLYPHS:'  at line 4577→
  FOR_EACH_EVENT(DO_WITH_EVENT_TYPE)case DRAWTARGETCREATION: { auto e = RecordedDrawTargetCreation
(aStream); return aAction(&e); }; case DRAWTARGETDESTRUCTION
: { auto e = RecordedDrawTargetDestruction(aStream); return aAction
(&e); }; case SETCURRENTDRAWTARGET: { auto e = RecordedSetCurrentDrawTarget
(aStream); return aAction(&e); }; case FILLRECT: { auto e
 = RecordedFillRect(aStream); return aAction(&e); }; case
 STROKERECT: { auto e = RecordedStrokeRect(aStream); return aAction
(&e); }; case STROKELINE: { auto e = RecordedStrokeLine(aStream
); return aAction(&e); }; case STROKECIRCLE: { auto e = RecordedStrokeCircle
(aStream); return aAction(&e); }; case CLEARRECT: { auto e
 = RecordedClearRect(aStream); return aAction(&e); }; case
 COPYSURFACE: { auto e = RecordedCopySurface(aStream); return
 aAction(&e); }; case SETPERMITSUBPIXELAA: { auto e = RecordedSetPermitSubpixelAA
(aStream); return aAction(&e); }; case SETTRANSFORM: { auto
 e = RecordedSetTransform(aStream); return aAction(&e); }
; case PUSHCLIPRECT: { auto e = RecordedPushClipRect(aStream)
; return aAction(&e); }; case PUSHCLIP: { auto e = RecordedPushClip
(aStream); return aAction(&e); }; case POPCLIP: { auto e =
 RecordedPopClip(aStream); return aAction(&e); }; case REMOVEALLCLIPS
: { auto e = RecordedRemoveAllClips(aStream); return aAction(
&e); }; case FILL: { auto e = RecordedFill(aStream); return
 aAction(&e); }; case FILLCIRCLE: { auto e = RecordedFillCircle
(aStream); return aAction(&e); }; case FILLGLYPHS: { auto
 e = RecordedFillGlyphs(aStream); return aAction(&e); }; case
 STROKEGLYPHS: { auto e = RecordedStrokeGlyphs(aStream); return
 aAction(&e); }; case MASK: { auto e = RecordedMask(aStream
); return aAction(&e); }; case STROKE: { auto e = RecordedStroke
(aStream); return aAction(&e); }; case DRAWSURFACE: { auto
 e = RecordedDrawSurface(aStream); return aAction(&e); };
 case DRAWSURFACEDESCRIPTOR: { auto e = RecordedDrawSurfaceDescriptor
(aStream); return aAction(&e); }; case DRAWDEPENDENTSURFACE
: { auto e = RecordedDrawDependentSurface(aStream); return aAction
(&e); }; case DRAWSURFACEWITHSHADOW: { auto e = RecordedDrawSurfaceWithShadow
(aStream); return aAction(&e); }; case DRAWSHADOW: { auto
 e = RecordedDrawShadow(aStream); return aAction(&e); }; case
 DRAWFILTER: { auto e = RecordedDrawFilter(aStream); return aAction
(&e); }; case PATHCREATION: { auto e = RecordedPathCreation
(aStream); return aAction(&e); }; case PATHDESTRUCTION: {
 auto e = RecordedPathDestruction(aStream); return aAction(&
e); }; case SOURCESURFACECREATION: { auto e = RecordedSourceSurfaceCreation
(aStream); return aAction(&e); }; case SOURCESURFACEDESTRUCTION
: { auto e = RecordedSourceSurfaceDestruction(aStream); return
 aAction(&e); }; case FILTERNODECREATION: { auto e = RecordedFilterNodeCreation
(aStream); return aAction(&e); }; case FILTERNODEDESTRUCTION
: { auto e = RecordedFilterNodeDestruction(aStream); return aAction
(&e); }; case GRADIENTSTOPSCREATION: { auto e = RecordedGradientStopsCreation
(aStream); return aAction(&e); }; case GRADIENTSTOPSDESTRUCTION
: { auto e = RecordedGradientStopsDestruction(aStream); return
 aAction(&e); }; case SNAPSHOT: { auto e = RecordedSnapshot
(aStream); return aAction(&e); }; case SCALEDFONTCREATION
: { auto e = RecordedScaledFontCreation(aStream); return aAction
(&e); }; case SCALEDFONTDESTRUCTION: { auto e = RecordedScaledFontDestruction
(aStream); return aAction(&e); }; case MASKSURFACE: { auto
 e = RecordedMaskSurface(aStream); return aAction(&e); };
 case FILTERNODESETATTRIBUTE: { auto e = RecordedFilterNodeSetAttribute
(aStream); return aAction(&e); }; case FILTERNODESETINPUT
: { auto e = RecordedFilterNodeSetInput(aStream); return aAction
(&e); }; case CREATESIMILARDRAWTARGET: { auto e = RecordedCreateSimilarDrawTarget
(aStream); return aAction(&e); }; case CREATECLIPPEDDRAWTARGET
: { auto e = RecordedCreateClippedDrawTarget(aStream); return
 aAction(&e); }; case CREATEDRAWTARGETFORFILTER: { auto e
 = RecordedCreateDrawTargetForFilter(aStream); return aAction
(&e); }; case FONTDATA: { auto e = RecordedFontData(aStream
); return aAction(&e); }; case FONTDESC: { auto e = RecordedFontDescriptor
(aStream); return aAction(&e); }; case PUSHLAYER: { auto e
 = RecordedPushLayer(aStream); return aAction(&e); }; case
 PUSHLAYERWITHBLEND: { auto e = RecordedPushLayerWithBlend(aStream
); return aAction(&e); }; case POPLAYER: { auto e = RecordedPopLayer
(aStream); return aAction(&e); }; case UNSCALEDFONTCREATION
: { auto e = RecordedUnscaledFontCreation(aStream); return aAction
(&e); }; case UNSCALEDFONTDESTRUCTION: { auto e = RecordedUnscaledFontDestruction
(aStream); return aAction(&e); }; case INTOLUMINANCE: { auto
 e = RecordedIntoLuminanceSource(aStream); return aAction(&
e); }; case EXTRACTSUBRECT: { auto e = RecordedExtractSubrect
(aStream); return aAction(&e); }; case EXTERNALSURFACECREATION
: { auto e = RecordedExternalSurfaceCreation(aStream); return
 aAction(&e); }; case FLUSH: { auto e = RecordedFlush(aStream
); return aAction(&e); }; case DETACHALLSNAPSHOTS: { auto
 e = RecordedDetachAllSnapshots(aStream); return aAction(&
e); }; case OPTIMIZESOURCESURFACE: { auto e = RecordedOptimizeSourceSurface
(aStream); return aAction(&e); }; case LINK: { auto e = RecordedLink
(aStream); return aAction(&e); }; case DESTINATION: { auto
 e = RecordedDestination(aStream); return aAction(&e); };
12
←
Calling constructor for 'RecordedFillGlyphs'→
23
←
Returning from constructor for 'RecordedFillGlyphs'→
24
←
Calling implicit destructor for 'RecordedFillGlyphs'→
25
←
Calling '~RecordedDrawGlyphs'→
  default:
    return false;
}
4581}

4583}  // namespace gfx
4584}  // namespace mozilla

4586#endif

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/cxxalloc.h

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4 
5#ifndef mozilla_cxxalloc_h
6#define mozilla_cxxalloc_h
7 
8/*
9 * We implement the default operators new/delete as part of
10 * libmozalloc, replacing their definitions in libstdc++.  The
11 * operator new* definitions in libmozalloc will never return a NULL
12 * pointer.
13 *
14 * Each operator new immediately below returns a pointer to memory
15 * that can be delete'd by any of
16 *
17 *   (1) the matching infallible operator delete immediately below
18 *   (2) the matching system |operator delete(void*, std::nothrow)|
19 *   (3) the matching system |operator delete(void*) noexcept(false)|
20 *
21 * NB: these are declared |noexcept(false)|, though they will never
22 * throw that exception.  This declaration is consistent with the rule
23 * that |::operator new() noexcept(false)| will never return NULL.
24 *
25 * NB: mozilla::fallible can be used instead of std::nothrow.
26 */
27 
28#ifndef MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline
29#  define MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline MFBT_API__attribute__((weak)) __attribute__((visibility("default")))
30#endif
31 
32MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void* operator new(size_t size) noexcept(false) {
33  return moz_xmalloc(size);
34}
35 
36MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void* operator new(size_t size,
37                                       const std::nothrow_t&) noexcept(true) {
38  return malloc_implmalloc(size);
39}
40 
41MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void* operator new[](size_t size) noexcept(false) {
42  return moz_xmalloc(size);
43}
44 
45MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void* operator new[](size_t size,
46                                         const std::nothrow_t&) noexcept(true) {
47  return malloc_implmalloc(size);
18
←
Memory is allocated→
48}
49 
50MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr) noexcept(true) {
51  return free_implfree(ptr);
52}
53 
54MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr,
55                                         const std::nothrow_t&) noexcept(true) {
56  return free_implfree(ptr);
57}
58 
59MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](void* ptr) noexcept(true) {
60  return free_implfree(ptr);
61}
62 
63MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](
64    void* ptr, const std::nothrow_t&) noexcept(true) {
65  return free_implfree(ptr);
66}
67 
68#if defined(XP_WIN)
69// We provide the global sized delete overloads unconditionally because the
70// MSVC runtime headers do, despite compiling with /Zc:sizedDealloc-
71MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr,
72                                         size_t /*size*/) noexcept(true) {
73  return free_implfree(ptr);
74}
75 
76MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](void* ptr,
77                                           size_t /*size*/) noexcept(true) {
78  return free_implfree(ptr);
79}
80#endif
81 
82#endif /* mozilla_cxxalloc_h */