/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 3449, column 5 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-18/lib/clang/18 -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-18/lib/clang/18/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 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -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-07-30-004816-4182763-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→
48    bool success = RecordedEvent::DoWithEvent(
8
←
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 (!success) {
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) {}

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 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;
717};

719class 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;
757};

759class 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);
776};

778class 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;
800};

802class 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);
822};

824class 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;
855};

857class 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;
890};

892class 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;
914};

916class 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;
945};

947class 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;
982};

984class 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;
1012};

1014class 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);
1037};

1039class 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);
1060};

1062class 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);
1098};

1100class 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);
1121};

1123class 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);
1148};

1150class 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);
1178};

1180class 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);
1206};

1208class 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);
1229};

1231class 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);
1264};

1266class 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);
1287};

1289class 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);
1307};

1309class 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);
1329};

1331class 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);
1351};

1353class 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);
1380};

1382class 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);
1409};

1411class 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);
1454};

1456class 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);
1499};

1501class 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);
1540};

1542class 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);
1562};

1564class 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);
1608};

1610class 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);
1631};

1633class 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;
1663};

1665class 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);
1724};

1726class 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);
1762};

1764class 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);
1788};

1790class 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);
1812};

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

1825template <class S>
1826void 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;
}
1862}

1864template <class S>
1865void 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;
}
1910}

1912inline 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;
  }
}
1974}

1976template <class S>
1977void 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);
1995}

1997template <class S>
1998void 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);
2026}

2028template <class S>
2029static 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();
}
2041}

2043template <class S>
2044static 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();
}
2057}

2059inline 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;
  }
}
2104}

2106inline 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;
2124}

2126template <class S>
2127void 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"
, 2135); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mExistingData"
 ")"); do { *((volatile int*)__null) = 2135; __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"
, 2136); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mExistingData->GetSize() == mRect.Size()"
 ")"); do { *((volatile int*)__null) = 2136; __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);
  }
}
2145}

2147template <class S>
2148RecordedDrawTargetCreation::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;
}
2175}

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

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

2190template <class S>
2191void RecordedDrawTargetDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
2193}

2195template <class S>
2196RecordedDrawTargetDestruction::RecordedDrawTargetDestruction(S& aStream)
  : RecordedEventDerived(DRAWTARGETDESTRUCTION) {
ReadElement(aStream, mRefPtr);
2199}

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

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

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

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

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

2227inline 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;
2245}

2247template <class S>
2248void RecordedCreateSimilarDrawTarget::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mSize);
WriteElement(aStream, mFormat);
2252}

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

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

2270inline 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;
2335}

2337inline 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;
2354}

2356template <class S>
2357void RecordedCreateClippedDrawTarget::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mBounds);
WriteElement(aStream, mFormat);
2361}

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

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

2377template <class S>
2378void 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);
2386}

2388template <class S>
2389RecordedCreateDrawTargetForFilter::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);
2399}

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

2406struct 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;
2485};

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

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

2497template <class S>
2498void RecordedFillRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2502}

2504template <class S>
2505RecordedFillRect::RecordedFillRect(S& aStream)
  : RecordedEventDerived(FILLRECT) {
ReadElement(aStream, mRect);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2510}

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

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

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

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

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

2547inline 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);
2553}

2555inline 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;
2564}

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

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

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

2593inline 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;
2603}

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

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

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

2630inline 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;
2639}

2641template <class S>
2642RecordedFill::RecordedFill(S& aStream) : RecordedEventDerived(FILL) {
ReadElement(aStream, mPath);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2646}

2648template <class S>
2649void RecordedFill::Record(S& aStream) const {
WriteElement(aStream, mPath);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2653}

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

2661inline 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;
2670}

2672template <class S>
2673void RecordedFillCircle::Record(S& aStream) const {
WriteElement(aStream, mCircle);
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mPattern);
2677}

2679template <class S>
2680RecordedFillCircle::RecordedFillCircle(S& aStream)
  : RecordedEventDerived(FILLCIRCLE) {
ReadElement(aStream, mCircle);
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mPattern);
2685}

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

2694template <class T>
2695inline RecordedDrawGlyphs<T>::~RecordedDrawGlyphs() {
delete[] mGlyphs;
2697}

2699template <class T>
2700inline 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;
2721}

2723template <class T>
2724template <class S>
2725RecordedDrawGlyphs<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) {
  return;
}

mGlyphs = new (fallible) Glyph[mNumGlyphs];
if (!mGlyphs) {
  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);
}
2744}

2746template <class T>
2747template <class S>
2748void 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);
2754}

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

2763inline 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;
2772}

2774template <class S>
2775RecordedMask::RecordedMask(S& aStream) : RecordedEventDerived(MASK) {
ReadDrawOptions(aStream, mOptions);
ReadPatternData(aStream, mSource);
ReadPatternData(aStream, mMask);
2779}

2781template <class S>
2782void RecordedMask::Record(S& aStream) const {
WriteElement(aStream, mOptions);
RecordPatternData(aStream, mSource);
RecordPatternData(aStream, mMask);
2786}

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

2796inline 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;
2810}

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

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

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

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

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

2845template <class S>
2846void RecordedClearRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
2848}

2850template <class S>
2851RecordedClearRect::RecordedClearRect(S& aStream)
  : RecordedEventDerived(CLEARRECT) {
ReadElement(aStream, mRect);
2854}

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

2862inline 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;
2875}

2877template <class S>
2878void RecordedCopySurface::Record(S& aStream) const {
WriteElement(aStream, mSourceSurface);
WriteElement(aStream, mSourceRect);
WriteElement(aStream, mDest);
2882}

2884template <class S>
2885RecordedCopySurface::RecordedCopySurface(S& aStream)
  : RecordedEventDerived(COPYSURFACE) {
ReadElement(aStream, mSourceSurface);
ReadElement(aStream, mSourceRect);
ReadElement(aStream, mDest);
2890}

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

2897inline 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;
2910}

2912template <class S>
2913void RecordedPushClip::Record(S& aStream) const {
WriteElement(aStream, mPath);
2915}

2917template <class S>
2918RecordedPushClip::RecordedPushClip(S& aStream)
  : RecordedEventDerived(PUSHCLIP) {
ReadElement(aStream, mPath);
2921}

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

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

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

2938template <class S>
2939void RecordedPushClipRect::Record(S& aStream) const {
WriteElement(aStream, mRect);
2941}

2943template <class S>
2944RecordedPushClipRect::RecordedPushClipRect(S& aStream)
  : RecordedEventDerived(PUSHCLIPRECT) {
ReadElement(aStream, mRect);
2947}

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

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

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

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

2968template <class S>
2969RecordedPopClip::RecordedPopClip(S& aStream) : RecordedEventDerived(POPCLIP) {}

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

2976inline 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;
2987}

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

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

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

3016inline 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;
3028}

3030template <class S>
3031void 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);
3039}

3041template <class S>
3042RecordedPushLayerWithBlend::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);
3052}

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

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

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

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

3073template <class S>
3074RecordedPopLayer::RecordedPopLayer(S& aStream)
  : RecordedEventDerived(POPLAYER) {}

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

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

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

3093template <class S>
3094void RecordedSetPermitSubpixelAA::Record(S& aStream) const {
WriteElement(aStream, mPermitSubpixelAA);
3096}

3098template <class S>
3099RecordedSetPermitSubpixelAA::RecordedSetPermitSubpixelAA(S& aStream)
  : RecordedEventDerived(SETPERMITSUBPIXELAA) {
ReadElement(aStream, mPermitSubpixelAA);
3102}

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

3109inline 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;
3126}

3128template <class S>
3129void RecordedSetTransform::Record(S& aStream) const {
WriteElement(aStream, mTransform);
3131}

3133template <class S>
3134RecordedSetTransform::RecordedSetTransform(S& aStream)
  : RecordedEventDerived(SETTRANSFORM) {
ReadElement(aStream, mTransform);
3137}

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

3146inline 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;
3159}

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

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

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

3185inline 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;
3205}

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

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

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

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

3237template <class S>
3238void RecordedDrawDependentSurface::Record(S& aStream) const {
WriteElement(aStream, mId);
WriteElement(aStream, mDest);
3241}

3243template <class S>
3244RecordedDrawDependentSurface::RecordedDrawDependentSurface(S& aStream)
  : RecordedEventDerived(DRAWDEPENDENTSURFACE) {
ReadElement(aStream, mId);
ReadElement(aStream, mDest);
3248}

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

3255inline 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;
3268}

3270template <class S>
3271void RecordedDrawFilter::Record(S& aStream) const {
WriteElement(aStream, mNode);
WriteElement(aStream, mSourceRect);
WriteElement(aStream, mDestPoint);
WriteElement(aStream, mOptions);
3276}

3278template <class S>
3279RecordedDrawFilter::RecordedDrawFilter(S& aStream)
  : RecordedEventDerived(DRAWFILTER) {
ReadElement(aStream, mNode);
ReadElement(aStream, mSourceRect);
ReadElement(aStream, mDestPoint);
ReadDrawOptions(aStream, mOptions);
3285}

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

3292inline 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;
3306}

3308template <class S>
3309void RecordedDrawSurfaceWithShadow::Record(S& aStream) const {
WriteElement(aStream, mRefSource);
WriteElement(aStream, mDest);
WriteElement(aStream, mShadow);
WriteElement(aStream, mOp);
3314}

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

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

3333inline 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;
3347}

3349template <class S>
3350void 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);
}
3359}

3361template <class S>
3362RecordedDrawShadow::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);
}
3372}

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

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

3387inline 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;
3401}

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

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

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

3431template <class S>
3432void RecordedPathDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3434}

3436template <class S>
3437RecordedPathDestruction::RecordedPathDestruction(S& aStream)
  : RecordedEventDerived(PATHDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3440}

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

3447inline RecordedSourceSurfaceCreation::~RecordedSourceSurfaceCreation() {
if (mDataOwned21.1
Field 'mDataOwned' is true
1
Field 'mDataOwned' is true
1
Field 'mDataOwned' is true
) {
22
←
Taking true branch→
  delete[] mData;
23
←
Memory allocated by malloc() should be deallocated by free(), not 'delete[]'
}
3451}

3453inline 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;
3468}

3470template <class S>
3471void 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"
, 3475); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mData" ")")
; do { *((volatile int*)__null) = 3475; __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);
}
3481}

3483template <class S>
3484RecordedSourceSurfaceCreation::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)) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false)) << "RecordedSourceSurfaceCreation read invalid size "
                  << mSize;
  aStream.SetIsBad();
}

if (!aStream.good()) {
13
←
Taking false branch→
  return;
}

size_t size = 0;
if (mSize.width13.1
Field 'width' is >= 0
1
Field 'width' is >= 0
1
Field 'width' is >= 0
 >= 0 && mSize.height13.2
Field 'height' is >= 0
2
Field 'height' is >= 0
2
Field 'height' is >= 0
 >= 0) {
14
←
Taking true branch→
  size = size_t(mSize.width) * size_t(mSize.height) * BytesPerPixel(mFormat);
  mData = new (fallible) uint8_t[size];
15
←
Calling 'operator new[]'→
17
←
Returning from 'operator new[]'→
}
if (!mData) {
18
←
Assuming field 'mData' is non-null→
19
←
Taking false branch→
  gfxCriticalNotemozilla::gfx::CriticalLog(mozilla::gfx::CriticalLog::DefaultOptions
(false))
      << "RecordedSourceSurfaceCreation failed to allocate data of size "
      << size;
  aStream.SetIsBad();
} else {
  aStream.read((char*)mData, size);
}
3514}

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

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

3529template <class S>
3530void RecordedSourceSurfaceDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3532}

3534template <class S>
3535RecordedSourceSurfaceDestruction::RecordedSourceSurfaceDestruction(S& aStream)
  : RecordedEventDerived(SOURCESURFACEDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3538}

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

3545inline 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;
3560}

3562template <class S>
3563void RecordedOptimizeSourceSurface::Record(S& aStream) const {
WriteElement(aStream, mSurface);
WriteElement(aStream, mOptimizedSurface);
3566}

3568template <class S>
3569RecordedOptimizeSourceSurface::RecordedOptimizeSourceSurface(S& aStream)
  : RecordedEventDerived(OPTIMIZESOURCESURFACE) {
ReadElement(aStream, mSurface);
ReadElement(aStream, mOptimizedSurface);
3573}

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

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

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

3591template <class S>
3592void RecordedExternalSurfaceCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mKey);
3595}

3597template <class S>
3598RecordedExternalSurfaceCreation::RecordedExternalSurfaceCreation(S& aStream)
  : RecordedEventDerived(EXTERNALSURFACECREATION) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mKey);
3602}

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

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

3612inline 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;
3622}

3624template <class S>
3625void RecordedFilterNodeCreation::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mType);
3628}

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

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

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

3650template <class S>
3651void RecordedFilterNodeDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3653}

3655template <class S>
3656RecordedFilterNodeDestruction::RecordedFilterNodeDestruction(S& aStream)
  : RecordedEventDerived(FILTERNODEDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3659}

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

3666inline RecordedGradientStopsCreation::~RecordedGradientStopsCreation() {
if (mDataOwned) {
  delete[] mStops;
}
3670}

3672inline 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;
3688}

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

3698template <class S>
3699RecordedGradientStopsCreation::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));
}
3718}

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

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

3732template <class S>
3733void RecordedGradientStopsDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3735}

3737template <class S>
3738RecordedGradientStopsDestruction::RecordedGradientStopsDestruction(S& aStream)
  : RecordedEventDerived(GRADIENTSTOPSDESTRUCTION) {
ReadElement(aStream, mRefPtr);
3741}

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

3748inline 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;
3758}

3760template <class S>
3761void RecordedIntoLuminanceSource::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mLuminanceType);
WriteElement(aStream, mOpacity);
3765}

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

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

3781inline 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;
3803}

3805template <class S>
3806void RecordedExtractSubrect::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
WriteElement(aStream, mSourceSurface);
WriteElement(aStream, mSubrect);
3810}

3812template <class S>
3813RecordedExtractSubrect::RecordedExtractSubrect(S& aStream)
  : RecordedEventDerived(EXTRACTSUBRECT) {
ReadElement(aStream, mRefPtr);
ReadElement(aStream, mSourceSurface);
ReadElement(aStream, mSubrect);
3818}

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

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

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

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

3838template <class S>
3839RecordedFlush::RecordedFlush(S& aStream) : RecordedEventDerived(FLUSH) {}

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

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

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

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

3860template <class S>
3861RecordedDetachAllSnapshots::RecordedDetachAllSnapshots(S& aStream)
  : RecordedEventDerived(DETACHALLSNAPSHOTS) {}

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

3869inline 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;
3878}

3880template <class S>
3881void RecordedSnapshot::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
3883}

3885template <class S>
3886RecordedSnapshot::RecordedSnapshot(S& aStream)
  : RecordedEventDerived(SNAPSHOT) {
ReadElement(aStream, mRefPtr);
3889}

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

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

3898inline 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;
3911}

3913template <class S>
3914void 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"
, 3915); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGetFontFileDataSucceeded"
 ")"); do { *((volatile int*)__null) = 3915; __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);
}
3925}

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

3932inline 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;
3945}

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

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

3958template <class S>
3959RecordedFontData::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);
}
3977}

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

3981inline 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;
3993}

3995template <class S>
3996void 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"
, 3997); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mHasDesc" ")"
); do { *((volatile int*)__null) = 3997; __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());
}
4005}

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

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

4019template <class S>
4020RecordedFontDescriptor::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);
}
4035}

4037inline 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;
4052}

4054template <class S>
4055void 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());
}
4063}

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

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

4077template <class S>
4078RecordedUnscaledFontCreation::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);
}
4093}

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

4101template <class S>
4102void RecordedUnscaledFontDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
4104}

4106template <class S>
4107RecordedUnscaledFontDestruction::RecordedUnscaledFontDestruction(S& aStream)
  : RecordedEventDerived(UNSCALEDFONTDESTRUCTION) {
ReadElement(aStream, mRefPtr);
4110}

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

4117inline 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;
4133}

4135template <class S>
4136void 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());
}
4149}

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

4156inline 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);
}
4165}

4167template <class S>
4168RecordedScaledFontCreation::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);
}
4194}

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

4202template <class S>
4203void RecordedScaledFontDestruction::Record(S& aStream) const {
WriteElement(aStream, mRefPtr);
4205}

4207template <class S>
4208RecordedScaledFontDestruction::RecordedScaledFontDestruction(S& aStream)
  : RecordedEventDerived(SCALEDFONTDESTRUCTION) {
ReadElement(aStream, mRefPtr);
4211}

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

4218inline 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;
4232}

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

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

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

4258template <typename T>
4259void ReplaySetAttribute(FilterNode* aNode, uint32_t aIndex, T aValue) {
aNode->SetAttribute(aIndex, aValue);
4261}

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

4270#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;
4297}

4299template <class S>
4300void 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());
4306}

4308template <class S>
4309RecordedFilterNodeSetAttribute::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);
4323}

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

4330inline 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;
4344}

4346template <class S>
4347void RecordedFilterNodeSetInput::Record(S& aStream) const {
WriteElement(aStream, mNode);
WriteElement(aStream, mIndex);
WriteElement(aStream, mInputFilter);
WriteElement(aStream, mInputSurface);
4352}

4354template <class S>
4355RecordedFilterNodeSetInput::RecordedFilterNodeSetInput(S& aStream)
  : RecordedEventDerived(FILTERNODESETINPUT) {
ReadElement(aStream, mNode);
ReadElement(aStream, mIndex);
ReadElement(aStream, mInputFilter);
ReadElement(aStream, mInputSurface);
4361}

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

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

aStringStream << ")";
4374}

4376inline 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;
4383}

4385template <class S>
4386void 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);
}
4398}

4400template <class S>
4401RecordedLink::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);
}
4414}

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

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

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

4445template <class S>
4446RecordedDestination::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);
}
4455}

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

4462#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(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(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);

4522#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);                       \
}

4528template <class S>
4529bool RecordedEvent::DoWithEvent(
  S& aStream, EventType aType,
  const std::function<bool(RecordedEvent*)>& aAction) {
switch (aType) {
9
←
Control jumps to 'case SOURCESURFACECREATION:'  at line 4533→
  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 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); };
10
←
Calling constructor for 'RecordedSourceSurfaceCreation'→
20
←
Returning from constructor for 'RecordedSourceSurfaceCreation'→
21
←
Calling '~RecordedSourceSurfaceCreation'→
  default:
    return false;
}
4537}

4539}  // namespace gfx
4540}  // namespace mozilla

4542#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);
16
←
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 */