/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h

Bug Summary

File:	root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h
Warning:	line 80, column 7 Use of memory after it is freed

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 DrawTargetWebgl.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=/root/firefox-clang/obj-x86_64-pc-linux-gnu/dom/canvas -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/dom/canvas -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /root/firefox-clang/dom/canvas -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dom/canvas -I /root/firefox-clang/js/xpconnect/wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /root/firefox-clang/ipc/chromium/src -I /root/firefox-clang/dom/base -I /root/firefox-clang/dom/html -I /root/firefox-clang/dom/svg -I /root/firefox-clang/dom/workers -I /root/firefox-clang/dom/xul -I /root/firefox-clang/gfx/angle/checkout/include -I /root/firefox-clang/gfx/cairo/cairo/src -I /root/firefox-clang/gfx/gl -I /root/firefox-clang/image -I /root/firefox-clang/js/xpconnect/src -I /root/firefox-clang/layout/generic -I /root/firefox-clang/layout/style -I /root/firefox-clang/layout/xul -I /root/firefox-clang/media/libyuv/libyuv/include -I /root/firefox-clang/gfx/skia -I /root/firefox-clang/gfx/skia/skia -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -I /usr/include/gtk-3.0 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/cloudproviders -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/gtk-3.0/unix-print -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-21/lib/clang/21/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=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -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 -Wno-shorten-64-to-32 -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ /root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp

/root/firefox-clang/dom/canvas/DrawTargetWebgl.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
* 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#include "DrawTargetWebglInternal.h"
8#include "SourceSurfaceWebgl.h"

10#include "mozilla/ClearOnShutdown.h"
11#include "mozilla/StaticPrefs_gfx.h"
12#include "mozilla/gfx/AAStroke.h"
13#include "mozilla/gfx/Blur.h"
14#include "mozilla/gfx/DrawTargetSkia.h"
15#include "mozilla/gfx/gfxVars.h"
16#include "mozilla/gfx/Helpers.h"
17#include "mozilla/gfx/HelpersSkia.h"
18#include "mozilla/gfx/Logging.h"
19#include "mozilla/gfx/PathHelpers.h"
20#include "mozilla/gfx/PathSkia.h"
21#include "mozilla/gfx/Swizzle.h"
22#include "mozilla/layers/ImageDataSerializer.h"
23#include "mozilla/layers/RemoteTextureMap.h"
24#include "mozilla/widget/ScreenManager.h"
25#include "skia/include/core/SkPixmap.h"
26#include "nsContentUtils.h"
27#include "nsIMemoryReporter.h"

29#include "GLContext.h"
30#include "WebGLContext.h"
31#include "WebGLChild.h"
32#include "WebGLBuffer.h"
33#include "WebGLFramebuffer.h"
34#include "WebGLProgram.h"
35#include "WebGLShader.h"
36#include "WebGLTexture.h"
37#include "WebGLVertexArray.h"

39#include "gfxPlatform.h"

41#ifdef XP_MACOSX
42#  include "mozilla/gfx/ScaledFontMac.h"
43#endif

45namespace mozilla::gfx {

47static Atomic<size_t> gReportedTextureMemory;
48static Atomic<size_t> gReportedHeapData;
49static Atomic<size_t> gReportedContextCount;
50static Atomic<size_t> gReportedTargetCount;

52class AcceleratedCanvas2DMemoryReporter final : public nsIMemoryReporter {
~AcceleratedCanvas2DMemoryReporter() = default;

public:
NS_DECL_THREADSAFE_ISUPPORTSpublic: virtual nsresult QueryInterface(const nsIID& aIID
, void** aInstancePtr) override; virtual MozExternalRefCountType
 AddRef(void) override; virtual MozExternalRefCountType Release
(void) override; using HasThreadSafeRefCnt = std::true_type; protected
: ::mozilla::ThreadSafeAutoRefCnt mRefCnt; nsAutoOwningThread
 _mOwningThread; public:

MOZ_DEFINE_MALLOC_SIZE_OF_ON_ALLOC(MallocSizeOfOnAlloc)static size_t MallocSizeOfOnAlloc(const void* aPtr) { mozilla
::dmd::ReportOnAlloc(aPtr); return moz_malloc_size_of(aPtr); }
MOZ_DEFINE_MALLOC_SIZE_OF_ON_FREE(MallocSizeOfOnFree)static size_t MallocSizeOfOnFree(const void* aPtr) { return moz_malloc_size_of
(aPtr); }

NS_IMETHODvirtual nsresult CollectReports(nsIHandleReportCallback* aHandleReport,
                          nsISupports* aData, bool aAnonymize) override {
  MOZ_COLLECT_REPORT("ac2d-texture-memory", KIND_OTHER, UNITS_BYTES,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-texture-memory"
), KIND_OTHER, UNITS_BYTES, gReportedTextureMemory, nsLiteralCString
("GPU memory used by Accelerated Canvas2D textures."), aData)
                     gReportedTextureMemory,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-texture-memory"
), KIND_OTHER, UNITS_BYTES, gReportedTextureMemory, nsLiteralCString
("GPU memory used by Accelerated Canvas2D textures."), aData)
                     "GPU memory used by Accelerated Canvas2D textures.")(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-texture-memory"
), KIND_OTHER, UNITS_BYTES, gReportedTextureMemory, nsLiteralCString
("GPU memory used by Accelerated Canvas2D textures."), aData);
  MOZ_COLLECT_REPORT("explicit/ac2d/heap-resources", KIND_HEAP, UNITS_BYTES,(void)aHandleReport->Callback(""_ns, nsLiteralCString("explicit/ac2d/heap-resources"
), KIND_HEAP, UNITS_BYTES, gReportedHeapData, nsLiteralCString
("Heap overhead for Accelerated Canvas2D resources."), aData)
                     gReportedHeapData,(void)aHandleReport->Callback(""_ns, nsLiteralCString("explicit/ac2d/heap-resources"
), KIND_HEAP, UNITS_BYTES, gReportedHeapData, nsLiteralCString
("Heap overhead for Accelerated Canvas2D resources."), aData)
                     "Heap overhead for Accelerated Canvas2D resources.")(void)aHandleReport->Callback(""_ns, nsLiteralCString("explicit/ac2d/heap-resources"
), KIND_HEAP, UNITS_BYTES, gReportedHeapData, nsLiteralCString
("Heap overhead for Accelerated Canvas2D resources."), aData);
  MOZ_COLLECT_REPORT("ac2d-context-count", KIND_OTHER, UNITS_COUNT,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-context-count"
), KIND_OTHER, UNITS_COUNT, gReportedContextCount, nsLiteralCString
("Number of Accelerated Canvas2D contexts."), aData)
                     gReportedContextCount,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-context-count"
), KIND_OTHER, UNITS_COUNT, gReportedContextCount, nsLiteralCString
("Number of Accelerated Canvas2D contexts."), aData)
                     "Number of Accelerated Canvas2D contexts.")(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-context-count"
), KIND_OTHER, UNITS_COUNT, gReportedContextCount, nsLiteralCString
("Number of Accelerated Canvas2D contexts."), aData);
  MOZ_COLLECT_REPORT("ac2d-target-count", KIND_OTHER, UNITS_COUNT,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-target-count"
), KIND_OTHER, UNITS_COUNT, gReportedTargetCount, nsLiteralCString
("Number of Accelerated Canvas2D targets."), aData)
                     gReportedTargetCount,(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-target-count"
), KIND_OTHER, UNITS_COUNT, gReportedTargetCount, nsLiteralCString
("Number of Accelerated Canvas2D targets."), aData)
                     "Number of Accelerated Canvas2D targets.")(void)aHandleReport->Callback(""_ns, nsLiteralCString("ac2d-target-count"
), KIND_OTHER, UNITS_COUNT, gReportedTargetCount, nsLiteralCString
("Number of Accelerated Canvas2D targets."), aData);
  return NS_OK;
}

static void Register() {
  static bool registered = false;
  if (!registered) {
    registered = true;
    RegisterStrongMemoryReporter(new AcceleratedCanvas2DMemoryReporter);
  }
}
85};

87NS_IMPL_ISUPPORTS(AcceleratedCanvas2DMemoryReporter, nsIMemoryReporter)MozExternalRefCountType AcceleratedCanvas2DMemoryReporter::AddRef
(void) { static_assert(!std::is_destructible_v<AcceleratedCanvas2DMemoryReporter
>, "Reference-counted class " "AcceleratedCanvas2DMemoryReporter"
 " should not have a public destructor. " "Make this class's destructor non-public"
); do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
 " (" "illegal refcnt" ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 87); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
 ") (" "illegal refcnt" ")"); do { MOZ_CrashSequence(__null, 87
); __attribute__((nomerge)) ::abort(); } while (false); } } while
 (false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("AcceleratedCanvas2DMemoryReporter" != nullptr)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!("AcceleratedCanvas2DMemoryReporter" != nullptr))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("\"AcceleratedCanvas2DMemoryReporter\" != nullptr"
 " (" "Must specify a name" ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 87); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"AcceleratedCanvas2DMemoryReporter\" != nullptr"
 ") (" "Must specify a name" ")"); do { MOZ_CrashSequence(__null
, 87); __attribute__((nomerge)) ::abort(); } while (false); }
 } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread.AssertOwnership
("AcceleratedCanvas2DMemoryReporter" " not thread-safe"); nsrefcnt
 count = ++mRefCnt; NS_LogAddRef((this), (count), ("AcceleratedCanvas2DMemoryReporter"
), (uint32_t)(sizeof(*this))); return count; } MozExternalRefCountType
 AcceleratedCanvas2DMemoryReporter::Release(void) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(int32_t
(mRefCnt) > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0"
 " (" "dup release" ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 87); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
 ") (" "dup release" ")"); do { MOZ_CrashSequence(__null, 87)
; __attribute__((nomerge)) ::abort(); } while (false); } } while
 (false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("AcceleratedCanvas2DMemoryReporter" != nullptr)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!("AcceleratedCanvas2DMemoryReporter" != nullptr))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("\"AcceleratedCanvas2DMemoryReporter\" != nullptr"
 " (" "Must specify a name" ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 87); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"AcceleratedCanvas2DMemoryReporter\" != nullptr"
 ") (" "Must specify a name" ")"); do { MOZ_CrashSequence(__null
, 87); __attribute__((nomerge)) ::abort(); } while (false); }
 } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread.AssertOwnership
("AcceleratedCanvas2DMemoryReporter" " not thread-safe"); const
 char* const nametmp = "AcceleratedCanvas2DMemoryReporter"; nsrefcnt
 count = --mRefCnt; NS_LogRelease((this), (count), (nametmp))
; if (count == 0) { mRefCnt = 1; delete (this); return 0; } return
 count; } nsresult AcceleratedCanvas2DMemoryReporter::QueryInterface
(const nsIID& aIID, void** aInstancePtr) { do { if (!(aInstancePtr
)) { NS_DebugBreak(NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 87); MOZ_PretendNoReturn(); } } while (0); nsresult rv = NS_ERROR_FAILURE
; static_assert(1 > 0, "Need more arguments to NS_INTERFACE_TABLE"
); static const QITableEntry table[] = { {&mozilla::detail
::kImplementedIID<AcceleratedCanvas2DMemoryReporter, nsIMemoryReporter
>, int32_t( reinterpret_cast<char*>(static_cast<nsIMemoryReporter
*>((AcceleratedCanvas2DMemoryReporter*)0x1000)) - reinterpret_cast
<char*>((AcceleratedCanvas2DMemoryReporter*)0x1000))}, {
&mozilla::detail::kImplementedIID<AcceleratedCanvas2DMemoryReporter
, nsISupports>, int32_t(reinterpret_cast<char*>(static_cast
<nsISupports*>( static_cast<nsIMemoryReporter*>((
AcceleratedCanvas2DMemoryReporter*)0x1000))) - reinterpret_cast
<char*>((AcceleratedCanvas2DMemoryReporter*)0x1000))}, {
 nullptr, 0 } } ; static_assert(std::size(table) > 1, "need at least 1 interface"
); rv = NS_TableDrivenQI(static_cast<void*>(this), aIID
, aInstancePtr, table); return rv; }

89BackingTexture::BackingTexture(const IntSize& aSize, SurfaceFormat aFormat,
                             const RefPtr<WebGLTexture>& aTexture)
  : mSize(aSize), mFormat(aFormat), mTexture(aTexture) {}

93#ifdef XP_WIN
94// Work around buggy ANGLE/D3D drivers that may copy blocks of pixels outside
95// the row length. Extra space is reserved at the end of each row up to stride
96// alignment. This does not affect standalone textures.
97static const Etagere::AllocatorOptions kR8AllocatorOptions = {16, 1, 1, 0};
98#endif

100SharedTexture::SharedTexture(const IntSize& aSize, SurfaceFormat aFormat,
                           const RefPtr<WebGLTexture>& aTexture)
  : BackingTexture(aSize, aFormat, aTexture),
    mAtlasAllocator(
104#ifdef XP_WIN
        aFormat == SurfaceFormat::A8
            ? Etagere::etagere_atlas_allocator_with_options(
                  aSize.width, aSize.height, &kR8AllocatorOptions)
            :
109#endif
            Etagere::etagere_atlas_allocator_new(aSize.width, aSize.height)) {
111}

113SharedTexture::~SharedTexture() {
if (mAtlasAllocator) {
  Etagere::etagere_atlas_allocator_delete(mAtlasAllocator);
  mAtlasAllocator = nullptr;
}
118}

120SharedTextureHandle::SharedTextureHandle(Etagere::AllocationId aId,
                                       const IntRect& aBounds,
                                       SharedTexture* aTexture)
  : mAllocationId(aId), mBounds(aBounds), mTexture(aTexture) {}

125already_AddRefed<SharedTextureHandle> SharedTexture::Allocate(
  const IntSize& aSize) {
Etagere::Allocation alloc = {{0, 0, 0, 0}, Etagere::INVALID_ALLOCATION_ID};
if (!mAtlasAllocator ||
    !Etagere::etagere_atlas_allocator_allocate(mAtlasAllocator, aSize.width,
                                               aSize.height, &alloc) ||
    alloc.id == Etagere::INVALID_ALLOCATION_ID) {
  return nullptr;
}
RefPtr<SharedTextureHandle> handle = new SharedTextureHandle(
    alloc.id,
    IntRect(IntPoint(alloc.rectangle.min_x, alloc.rectangle.min_y), aSize),
    this);
return handle.forget();
139}

141bool SharedTexture::Free(SharedTextureHandle& aHandle) {
if (aHandle.mTexture != this) {
  return false;
}
if (aHandle.mAllocationId != Etagere::INVALID_ALLOCATION_ID) {
  if (mAtlasAllocator) {
    Etagere::etagere_atlas_allocator_deallocate(mAtlasAllocator,
                                                aHandle.mAllocationId);
  }
  aHandle.mAllocationId = Etagere::INVALID_ALLOCATION_ID;
}
return true;
153}

155StandaloneTexture::StandaloneTexture(const IntSize& aSize,
                                   SurfaceFormat aFormat,
                                   const RefPtr<WebGLTexture>& aTexture)
  : BackingTexture(aSize, aFormat, aTexture) {}

160DrawTargetWebgl::DrawTargetWebgl() = default;

162inline void SharedContextWebgl::ClearLastTexture(bool aFullClear) {
mLastTexture = nullptr;
if (aFullClear) {
  mLastClipMask = nullptr;
}
167}

169// Attempts to clear the snapshot state. If the snapshot is only referenced by
170// this target, then it should simply be destroyed. If it is a WebGL surface in
171// use by something else, then special cleanup such as reusing the texture or
172// copy-on-write may be possible.
173void DrawTargetWebgl::ClearSnapshot(bool aCopyOnWrite, bool aNeedHandle) {
if (!mSnapshot) {
  return;
}
mSharedContext->ClearLastTexture();
RefPtr<SourceSurfaceWebgl> snapshot = mSnapshot.forget();
if (snapshot->hasOneRef()) {
  return;
}
if (aCopyOnWrite) {
  // WebGL snapshots must be notified that the framebuffer contents will be
  // changing so that it can copy the data.
  snapshot->DrawTargetWillChange(aNeedHandle);
} else {
  // If not copying, then give the backing texture to the surface for reuse.
  snapshot->GiveTexture(
      mSharedContext->WrapSnapshot(GetSize(), GetFormat(), mTex.forget()));
}
191}

193DrawTargetWebgl::~DrawTargetWebgl() {
ClearSnapshot(false);
if (mSharedContext) {
  // Force any Skia snapshots to copy the shmem before it deallocs.
  if (mSkia) {
    mSkia->DetachAllSnapshots();
  }
  mSharedContext->ClearLastTexture(true);
  if (mClipMask) {
    mSharedContext->RemoveUntrackedTextureMemory(mClipMask);
    mClipMask = nullptr;
  }
  mFramebuffer = nullptr;
  if (mTex) {
    mSharedContext->RemoveUntrackedTextureMemory(mTex);
    mTex = nullptr;
  }
  mSharedContext->mDrawTargetCount--;
  gReportedTargetCount--;
}
213}

215SharedContextWebgl::SharedContextWebgl() = default;

217SharedContextWebgl::~SharedContextWebgl() {
// Detect context loss before deletion.
if (mWebgl) {
  ExitTlsScope();
  mWebgl->ActiveTexture(0);
  gReportedContextCount--;
}
if (mWGRPathBuilder) {
  WGR::wgr_builder_release(mWGRPathBuilder);
  mWGRPathBuilder = nullptr;
}
if (mWGROutputBuffer) {
  RemoveHeapData(mWGROutputBuffer.get());
  mWGROutputBuffer = nullptr;
}
if (mPathVertexBuffer) {
  RemoveUntrackedTextureMemory(mPathVertexBuffer);
  mPathVertexBuffer = nullptr;
}
ClearZeroBuffer();
ClearAllTextures();
UnlinkSurfaceTextures();
UnlinkGlyphCaches();
240}

242gl::GLContext* SharedContextWebgl::GetGLContext() {
return mWebgl ? mWebgl->GL() : nullptr;
244}

246void SharedContextWebgl::EnterTlsScope() {
if (mTlsScope.isSome()) {
  return;
}
if (gl::GLContext* gl = GetGLContext()) {
  mTlsScope = Some(gl->mUseTLSIsCurrent);
  gl::GLContext::InvalidateCurrentContext();
  gl->mUseTLSIsCurrent = true;
}
255}

257void SharedContextWebgl::ExitTlsScope() {
if (mTlsScope.isNothing()) {
  return;
}
if (gl::GLContext* gl = GetGLContext()) {
  gl->mUseTLSIsCurrent = mTlsScope.value();
}
mTlsScope = Nothing();
265}

267// Remove any SourceSurface user data associated with this TextureHandle.
268inline void SharedContextWebgl::UnlinkSurfaceTexture(
  const RefPtr<TextureHandle>& aHandle) {
if (RefPtr<SourceSurface> surface = aHandle->GetSurface()) {
  // Ensure any WebGL snapshot textures get unlinked.
  if (surface->GetType() == SurfaceType::WEBGL) {
    static_cast<SourceSurfaceWebgl*>(surface.get())->OnUnlinkTexture(this);
  }
  surface->RemoveUserData(aHandle->IsShadow() ? &mShadowTextureKey
                                              : &mTextureHandleKey);
}
278}

280// Unlinks TextureHandles from any SourceSurface user data.
281void SharedContextWebgl::UnlinkSurfaceTextures() {
for (RefPtr<TextureHandle> handle = mTextureHandles.getFirst(); handle;
     handle = handle->getNext()) {
  UnlinkSurfaceTexture(handle);
}
286}

288// Unlinks GlyphCaches from any ScaledFont user data.
289void SharedContextWebgl::UnlinkGlyphCaches() {
GlyphCache* cache = mGlyphCaches.getFirst();
while (cache) {
  ScaledFont* font = cache->GetFont();
  // Access the next cache before removing the user data, as it might destroy
  // the cache.
  cache = cache->getNext();
  font->RemoveUserData(&mGlyphCacheKey);
}
298}

300void SharedContextWebgl::OnMemoryPressure() { mShouldClearCaches = true; }

302void SharedContextWebgl::ClearCaches() {
OnMemoryPressure();
ClearCachesIfNecessary();
305}

307// Clear out the entire list of texture handles from any source.
308void SharedContextWebgl::ClearAllTextures() {
while (!mTextureHandles.isEmpty()) {
  PruneTextureHandle(mTextureHandles.popLast());
  --mNumTextureHandles;
}
313}

315static inline size_t TextureMemoryUsage(WebGLTexture* aTexture) {
return aTexture->MemoryUsage();
317}

319static inline size_t TextureMemoryUsage(WebGLBuffer* aBuffer) {
return aBuffer->ByteLength();
321}

323inline void SharedContextWebgl::AddHeapData(const void* aBuf) {
if (aBuf) {
  gReportedHeapData +=
      AcceleratedCanvas2DMemoryReporter::MallocSizeOfOnAlloc(aBuf);
}
328}

330inline void SharedContextWebgl::RemoveHeapData(const void* aBuf) {
if (aBuf) {
  gReportedHeapData -=
      AcceleratedCanvas2DMemoryReporter::MallocSizeOfOnFree(aBuf);
}
335}

337inline void SharedContextWebgl::AddUntrackedTextureMemory(size_t aBytes) {
gReportedTextureMemory += aBytes;
339}

341inline void SharedContextWebgl::RemoveUntrackedTextureMemory(size_t aBytes) {
gReportedTextureMemory -= aBytes;
343}

345template <typename T>
346inline void SharedContextWebgl::AddUntrackedTextureMemory(
  const RefPtr<T>& aObject, size_t aBytes) {
size_t usedBytes = aBytes > 0 ? aBytes : TextureMemoryUsage(aObject);
AddUntrackedTextureMemory(usedBytes);
gReportedHeapData += aObject->SizeOfIncludingThis(
    AcceleratedCanvas2DMemoryReporter::MallocSizeOfOnAlloc);
352}

354template <typename T>
355inline void SharedContextWebgl::RemoveUntrackedTextureMemory(
  const RefPtr<T>& aObject, size_t aBytes) {
size_t usedBytes = aBytes > 0 ? aBytes : TextureMemoryUsage(aObject);
RemoveUntrackedTextureMemory(usedBytes);
gReportedHeapData -= aObject->SizeOfIncludingThis(
    AcceleratedCanvas2DMemoryReporter::MallocSizeOfOnFree);
361}

363inline void SharedContextWebgl::AddTextureMemory(BackingTexture* aTexture) {
size_t usedBytes = aTexture->UsedBytes();
mTotalTextureMemory += usedBytes;
AddUntrackedTextureMemory(aTexture->GetWebGLTexture(), usedBytes);
367}

369inline void SharedContextWebgl::RemoveTextureMemory(BackingTexture* aTexture) {
size_t usedBytes = aTexture->UsedBytes();
mTotalTextureMemory -= usedBytes;
RemoveUntrackedTextureMemory(aTexture->GetWebGLTexture(), usedBytes);
373}

375// Scan through the shared texture pages looking for any that are empty and
376// delete them.
377void SharedContextWebgl::ClearEmptyTextureMemory() {
for (auto pos = mSharedTextures.begin(); pos != mSharedTextures.end();) {
  if (!(*pos)->HasAllocatedHandles()) {
    RefPtr<SharedTexture> shared = *pos;
    mEmptyTextureMemory -= shared->UsedBytes();
    RemoveTextureMemory(shared);
    pos = mSharedTextures.erase(pos);
  } else {
    ++pos;
  }
}
388}

390void SharedContextWebgl::ClearZeroBuffer() {
if (mZeroBuffer) {
  RemoveUntrackedTextureMemory(mZeroBuffer);
  mZeroBuffer = nullptr;
}
395}

397// If there is a request to clear out the caches because of memory pressure,
398// then first clear out all the texture handles in the texture cache. If there
399// are still empty texture pages being kept around, then clear those too.
400void SharedContextWebgl::ClearCachesIfNecessary() {
if (!mShouldClearCaches.exchange(false)) {
  return;
}
ClearZeroBuffer();
ClearAllTextures();
if (mEmptyTextureMemory) {
  ClearEmptyTextureMemory();
}
ClearLastTexture();
410}

412// Try to initialize a new WebGL context. Verifies that the requested size does
413// not exceed the available texture limits and that shader creation succeeded.
414bool DrawTargetWebgl::Init(const IntSize& size, const SurfaceFormat format,
                         const RefPtr<SharedContextWebgl>& aSharedContext) {
MOZ_ASSERT(format == SurfaceFormat::B8G8R8A8 ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat
::B8G8R8X8)>::isValid, "invalid assertion condition"); if (
(__builtin_expect(!!(!(!!(format == SurfaceFormat::B8G8R8A8 ||
 format == SurfaceFormat::B8G8R8X8))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat::B8G8R8X8"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 417);
 AnnotateMozCrashReason("MOZ_ASSERT" "(" "format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat::B8G8R8X8"
 ")"); do { MOZ_CrashSequence(__null, 417); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
           format == SurfaceFormat::B8G8R8X8)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat
::B8G8R8X8)>::isValid, "invalid assertion condition"); if (
(__builtin_expect(!!(!(!!(format == SurfaceFormat::B8G8R8A8 ||
 format == SurfaceFormat::B8G8R8X8))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat::B8G8R8X8"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 417);
 AnnotateMozCrashReason("MOZ_ASSERT" "(" "format == SurfaceFormat::B8G8R8A8 || format == SurfaceFormat::B8G8R8X8"
 ")"); do { MOZ_CrashSequence(__null, 417); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

mSize = size;
mFormat = format;

if (!aSharedContext || aSharedContext->IsContextLost() ||
    aSharedContext->mDrawTargetCount >=
        StaticPrefs::gfx_canvas_accelerated_max_draw_target_count()) {
  return false;
}
mSharedContext = aSharedContext;
mSharedContext->mDrawTargetCount++;
gReportedTargetCount++;

if (size_t(std::max(size.width, size.height)) >
    mSharedContext->mMaxTextureSize) {
  return false;
}

if (!CreateFramebuffer()) {
  return false;
}

size_t byteSize = layers::ImageDataSerializer::ComputeRGBBufferSize(
    mSize, SurfaceFormat::B8G8R8A8);
if (byteSize == 0) {
  return false;
}

size_t shmemSize = mozilla::ipc::shared_memory::PageAlignedSize(byteSize);
if (NS_WARN_IF(shmemSize > UINT32_MAX)NS_warn_if_impl(shmemSize > (4294967295U), "shmemSize > UINT32_MAX"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 447)) {
  MOZ_ASSERT_UNREACHABLE("Buffer too big?")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: "
 "Buffer too big?" ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 448); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
 "MOZ_ASSERT_UNREACHABLE: " "Buffer too big?" ")"); do { MOZ_CrashSequence
(__null, 448); __attribute__((nomerge)) ::abort(); } while (false
); } } while (false);
  return false;
}

auto handle = mozilla::ipc::shared_memory::Create(shmemSize);
if (NS_WARN_IF(!handle)NS_warn_if_impl(!handle, "!handle", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 453)) {
  return false;
}
auto mapping = handle.Map();
if (NS_WARN_IF(!mapping)NS_warn_if_impl(!mapping, "!mapping", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 457)) {
  return false;
}

mShmemHandle = std::move(handle).ToReadOnly();
mShmem = std::move(mapping);

mSkia = new DrawTargetSkia;
auto stride = layers::ImageDataSerializer::ComputeRGBStride(
    SurfaceFormat::B8G8R8A8, size.width);
if (!mSkia->Init(mShmem.DataAs<uint8_t>(), size, stride,
                 SurfaceFormat::B8G8R8A8, true)) {
  return false;
}

// Allocate an unclipped copy of the DT pointing to its data.
uint8_t* dtData = nullptr;
IntSize dtSize;
int32_t dtStride = 0;
SurfaceFormat dtFormat = SurfaceFormat::UNKNOWN;
if (!mSkia->LockBits(&dtData, &dtSize, &dtStride, &dtFormat)) {
  return false;
}
mSkiaNoClip = new DrawTargetSkia;
if (!mSkiaNoClip->Init(dtData, dtSize, dtStride, dtFormat, true)) {
  mSkia->ReleaseBits(dtData);
  return false;
}
mSkia->ReleaseBits(dtData);

SetPermitSubpixelAA(IsOpaque(format));
return true;
489}

491// If a non-recoverable error occurred that would stop the canvas from initing.
492static Atomic<bool> sContextInitError(false);

494already_AddRefed<SharedContextWebgl> SharedContextWebgl::Create() {
// If context initialization would fail, don't even try to create a context.
if (sContextInitError) {
  return nullptr;
}
RefPtr<SharedContextWebgl> sharedContext = new SharedContextWebgl;
if (!sharedContext->Initialize()) {
  return nullptr;
}
return sharedContext.forget();
504}

506bool SharedContextWebgl::Initialize() {
AcceleratedCanvas2DMemoryReporter::Register();

WebGLContextOptions options = {};
options.alpha = true;
options.depth = false;
options.stencil = false;
options.antialias = false;
options.preserveDrawingBuffer = true;
options.failIfMajorPerformanceCaveat = false;

const bool resistFingerprinting = nsContentUtils::ShouldResistFingerprinting(
    "Fallback", RFPTarget::WebGLRenderCapability);
const auto initDesc = webgl::InitContextDesc{
    .isWebgl2 = true,
    .resistFingerprinting = resistFingerprinting,
    .principalKey = 0,
    .size = {1, 1},
    .options = options,
};

webgl::InitContextResult initResult;
mWebgl = WebGLContext::Create(nullptr, initDesc, &initResult);
if (!mWebgl) {
  // There was a non-recoverable error when trying to create a host context.
  sContextInitError = true;
  mWebgl = nullptr;
  return false;
}
if (mWebgl->IsContextLost()) {
  mWebgl = nullptr;
  return false;
}

mMaxTextureSize = initResult.limits.maxTex2dSize;

if (kIsMacOS) {
  mRasterizationTruncates = initResult.vendor == gl::GLVendor::ATI;
}

CachePrefs();

if (!CreateShaders()) {
  // There was a non-recoverable error when trying to init shaders.
  sContextInitError = true;
  mWebgl = nullptr;
  return false;
}

mWGRPathBuilder = WGR::wgr_new_builder();

gReportedContextCount++;

return true;
560}

562inline void SharedContextWebgl::BlendFunc(GLenum aSrcFactor,
                                        GLenum aDstFactor) {
mWebgl->BlendFuncSeparate({}, aSrcFactor, aDstFactor, aSrcFactor, aDstFactor);
565}

567void SharedContextWebgl::SetBlendState(CompositionOp aOp,
                                     const Maybe<DeviceColor>& aColor) {
if (aOp == mLastCompositionOp && mLastBlendColor == aColor) {
  return;
}
mLastCompositionOp = aOp;
mLastBlendColor = aColor;
// AA is not supported for all composition ops, so switching blend modes may
// cause a toggle in AA state. Certain ops such as OP_SOURCE require output
// alpha that is blended separately from AA coverage. This would require two
// stage blending which can incur a substantial performance penalty, so to
// work around this currently we just disable AA for those ops.

// Map the composition op to a WebGL blend mode, if possible.
bool enabled = true;
switch (aOp) {
  case CompositionOp::OP_OVER:
    if (aColor) {
      // If a color is supplied, then we blend subpixel text.
      mWebgl->BlendColor(aColor->b, aColor->g, aColor->r, 1.0f);
      BlendFunc(LOCAL_GL_CONSTANT_COLOR0x8001, LOCAL_GL_ONE_MINUS_SRC_COLOR0x0301);
    } else {
      BlendFunc(LOCAL_GL_ONE1, LOCAL_GL_ONE_MINUS_SRC_ALPHA0x0303);
    }
    break;
  case CompositionOp::OP_ADD:
    BlendFunc(LOCAL_GL_ONE1, LOCAL_GL_ONE1);
    break;
  case CompositionOp::OP_ATOP:
    BlendFunc(LOCAL_GL_DST_ALPHA0x0304, LOCAL_GL_ONE_MINUS_SRC_ALPHA0x0303);
    break;
  case CompositionOp::OP_SOURCE:
    if (aColor) {
      // If a color is supplied, then we assume there is clipping or AA. This
      // requires that we still use an over blend func with the clip/AA alpha,
      // while filling the interior with the unaltered color. Normally this
      // would require dual source blending, but we can emulate it with only
      // a blend color.
      mWebgl->BlendColor(aColor->b, aColor->g, aColor->r, aColor->a);
      BlendFunc(LOCAL_GL_CONSTANT_COLOR0x8001, LOCAL_GL_ONE_MINUS_SRC_COLOR0x0301);
    } else {
      enabled = false;
    }
    break;
  case CompositionOp::OP_CLEAR:
    // Assume the source is an alpha mask for clearing. Be careful to blend in
    // the correct alpha if the target is opaque.
    mWebgl->BlendFuncSeparate(
        {}, LOCAL_GL_ZERO0, LOCAL_GL_ONE_MINUS_SRC_ALPHA0x0303,
        IsOpaque(mCurrentTarget->GetFormat()) ? LOCAL_GL_ONE1 : LOCAL_GL_ZERO0,
        LOCAL_GL_ONE_MINUS_SRC_ALPHA0x0303);
    break;
  default:
    enabled = false;
    break;
}

mWebgl->SetEnabled(LOCAL_GL_BLEND0x0BE2, {}, enabled);
625}

627// Ensure the WebGL framebuffer is set to the current target.
628bool SharedContextWebgl::SetTarget(DrawTargetWebgl* aDT) {
if (!mWebgl || mWebgl->IsContextLost()) {
  return false;
}
if (aDT != mCurrentTarget) {
  mCurrentTarget = aDT;
  if (aDT) {
    mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, aDT->mFramebuffer);
    mViewportSize = aDT->GetSize();
    mWebgl->Viewport(0, 0, mViewportSize.width, mViewportSize.height);
  }
}
return true;
641}

643// Replace the current clip rect with a new potentially-AA'd clip rect.
644void SharedContextWebgl::SetClipRect(const Rect& aClipRect) {
// Only invalidate the clip rect if it actually changes.
if (!mClipAARect.IsEqualEdges(aClipRect)) {
  mClipAARect = aClipRect;
  // Store the integer-aligned bounds.
  mClipRect = RoundedOut(aClipRect);
}
651}

653bool SharedContextWebgl::SetClipMask(const RefPtr<WebGLTexture>& aTex) {
if (mLastClipMask != aTex) {
  if (!mWebgl) {
    return false;
  }
  mWebgl->ActiveTexture(1);
  mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, aTex);
  mWebgl->ActiveTexture(0);
  mLastClipMask = aTex;
}
return true;
664}

666bool SharedContextWebgl::SetNoClipMask() {
if (mNoClipMask) {
  return SetClipMask(mNoClipMask);
}
if (!mWebgl) {
  return false;
}
mNoClipMask = mWebgl->CreateTexture();
if (!mNoClipMask) {
  return false;
}
mWebgl->ActiveTexture(1);
mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, mNoClipMask);
static const auto solidMask =
    std::array<const uint8_t, 4>{0xFF, 0xFF, 0xFF, 0xFF};
mWebgl->TexImage(0, LOCAL_GL_RGBA80x8058, {0, 0, 0},
                 {LOCAL_GL_RGBA0x1908, LOCAL_GL_UNSIGNED_BYTE0x1401},
                 {LOCAL_GL_TEXTURE_2D0x0DE1,
                  {1, 1, 1},
                  gfxAlphaType::NonPremult,
                  Some(Span{solidMask})});
InitTexParameters(mNoClipMask, false);
mWebgl->ActiveTexture(0);
mLastClipMask = mNoClipMask;
return true;
691}

693inline bool DrawTargetWebgl::ClipStack::operator==(
  const DrawTargetWebgl::ClipStack& aOther) const {
// Verify the transform and bounds match.
if (!mTransform.FuzzyEquals(aOther.mTransform) ||
    !mRect.IsEqualInterior(aOther.mRect)) {
  return false;
}
// Verify the paths match.
if (!mPath) {
  return !aOther.mPath;
}
if (!aOther.mPath ||
    mPath->GetBackendType() != aOther.mPath->GetBackendType()) {
  return false;
}
if (mPath->GetBackendType() != BackendType::SKIA) {
  return mPath == aOther.mPath;
}
return static_cast<const PathSkia*>(mPath.get())->GetPath() ==
       static_cast<const PathSkia*>(aOther.mPath.get())->GetPath();
713}

715// If the clip region can't be approximated by a simple clip rect, then we need
716// to generate a clip mask that can represent the clip region per-pixel. We
717// render to the Skia target temporarily, transparent outside the clip region,
718// opaque inside, and upload this to a texture that can be used by the shaders.
719bool DrawTargetWebgl::GenerateComplexClipMask() {
if (!mClipChanged || (mClipMask && mCachedClipStack == mClipStack)) {
  mClipChanged = false;
  // If the clip mask was already generated, use the cached mask and bounds.
  mSharedContext->SetClipMask(mClipMask);
  mSharedContext->SetClipRect(mClipBounds);
  return true;
}
if (!mWebglValid) {
  // If the Skia target is currently being used, then we can't render the mask
  // in it.
  return false;
}
RefPtr<WebGLContext> webgl = mSharedContext->mWebgl;
if (!webgl) {
  return false;
}
bool init = false;
if (!mClipMask) {
  mClipMask = webgl->CreateTexture();
  if (!mClipMask) {
    return false;
  }
  init = true;
}
// Try to get the bounds of the clip to limit the size of the mask.
if (Maybe<IntRect> clip = mSkia->GetDeviceClipRect(true)) {
  mClipBounds = *clip;
} else {
  // If we can't get bounds, then just use the entire viewport.
  mClipBounds = GetRect();
}
mClipAARect = Rect(mClipBounds);
// If initializing the clip mask, then allocate the entire texture to ensure
// all pixels get filled with an empty mask regardless. Otherwise, restrict
// uploading to only the clip region.
RefPtr<DrawTargetSkia> dt = new DrawTargetSkia;
if (!dt->Init(mClipBounds.Size(), SurfaceFormat::A8)) {
  if (init) {
    // Ensure that the clip mask is reinitialized on the next attempt.
    mClipMask = nullptr;
  }
  return false;
}
// Set the clip region and fill the entire inside of it
// with opaque white.
mCachedClipStack.clear();
for (auto& clipStack : mClipStack) {
  // Record the current state of the clip stack for this mask.
  mCachedClipStack.push_back(clipStack);
  dt->SetTransform(
      Matrix(clipStack.mTransform).PostTranslate(-mClipBounds.TopLeft()));
  if (clipStack.mPath) {
    dt->PushClip(clipStack.mPath);
  } else {
    dt->PushClipRect(clipStack.mRect);
  }
}
dt->SetTransform(Matrix::Translation(-mClipBounds.TopLeft()));
dt->FillRect(Rect(mClipBounds), ColorPattern(DeviceColor(1, 1, 1, 1)));
// Bind the clip mask for uploading. This is done on texture unit 0 so that
// we can work around an Windows Intel driver bug. If done on texture unit 1,
// the driver doesn't notice that the texture contents was modified. Force a
// re-latch by binding the texture on texture unit 1 only after modification.
webgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, mClipMask);
if (init) {
  mSharedContext->InitTexParameters(mClipMask, false);
}
RefPtr<DataSourceSurface> data;
if (RefPtr<SourceSurface> snapshot = dt->Snapshot()) {
  data = snapshot->GetDataSurface();
}
// Finally, upload the texture data and initialize texture storage if
// necessary.
if (init && mClipBounds.Size() != mSize) {
  mSharedContext->UploadSurface(nullptr, SurfaceFormat::A8, GetRect(),
                                IntPoint(), true, true);
  init = false;
}
mSharedContext->UploadSurface(data, SurfaceFormat::A8,
                              IntRect(IntPoint(), mClipBounds.Size()),
                              mClipBounds.TopLeft(), init);
mSharedContext->ClearLastTexture();
// Bind the new clip mask to the clip sampler on texture unit 1.
mSharedContext->SetClipMask(mClipMask);
mSharedContext->SetClipRect(mClipBounds);
// We uploaded a surface, just as if we missed the texture cache, so account
// for that here.
if (init) {
  mSharedContext->AddUntrackedTextureMemory(mClipMask);
}
mProfile.OnCacheMiss();
return !!data;
812}

814bool DrawTargetWebgl::SetSimpleClipRect() {
// Determine whether the clipping rectangle is simple enough to accelerate.
// Check if there is a device space clip rectangle available from the Skia
// target.
if (Maybe<IntRect> clip = mSkia->GetDeviceClipRect(false)) {
  // If the clip is empty, leave the final integer clip rectangle empty to
  // trivially discard the draw request.
  // If the clip rect is larger than the viewport, just set it to the
  // viewport.
  if (!clip->IsEmpty() && clip->Contains(GetRect())) {
    clip = Some(GetRect());
  }
  mSharedContext->SetClipRect(*clip);
  mSharedContext->SetNoClipMask();
  return true;
}

// There was no pixel-aligned clip rect available, so check the clip stack to
// see if there is an AA'd axis-aligned rectangle clip.
Rect rect(GetRect());
for (auto& clipStack : mClipStack) {
  // If clip is a path or it has a non-axis-aligned transform, then it is
  // complex.
  if (clipStack.mPath ||
      !clipStack.mTransform.PreservesAxisAlignedRectangles()) {
    return false;
  }
  // Transform the rect and intersect it with the current clip.
  rect =
      clipStack.mTransform.TransformBounds(clipStack.mRect).Intersect(rect);
}
mSharedContext->SetClipRect(rect);
mSharedContext->SetNoClipMask();
return true;
848}

850// Installs the Skia clip rectangle, if applicable, onto the shared WebGL
851// context as well as sets the WebGL framebuffer to the current target.
852bool DrawTargetWebgl::PrepareContext(bool aClipped) {
if (!aClipped) {
  // If no clipping requested, just set the clip rect to the viewport.
  mSharedContext->SetClipRect(GetRect());
  mSharedContext->SetNoClipMask();
  // Ensure the clip gets reset if clipping is later requested for the target.
  mRefreshClipState = true;
} else if (mRefreshClipState || !mSharedContext->IsCurrentTarget(this)) {
  // Try to use a simple clip rect if possible. Otherwise, fall back to
  // generating a clip mask texture that can represent complex clip regions.
  if (!SetSimpleClipRect() && !GenerateComplexClipMask()) {
    return false;
  }
  mClipChanged = false;
  mRefreshClipState = false;
}
return mSharedContext->SetTarget(this);
869}

871bool SharedContextWebgl::IsContextLost() const {
return !mWebgl || mWebgl->IsContextLost();
873}

875// Signal to CanvasRenderingContext2D when the WebGL context is lost.
876bool DrawTargetWebgl::IsValid() const {
return mSharedContext && !mSharedContext->IsContextLost();
878}

880bool DrawTargetWebgl::CanCreate(const IntSize& aSize, SurfaceFormat aFormat) {
if (!gfxVars::UseAcceleratedCanvas2D()) {
  return false;
}

if (!Factory::AllowedSurfaceSize(aSize)) {
  return false;
}

// The interpretation of the min-size and max-size follows from the old
// SkiaGL prefs. First just ensure that the context is not unreasonably
// small.
static const int32_t kMinDimension = 16;
if (std::min(aSize.width, aSize.height) < kMinDimension) {
  return false;
}

int32_t minSize = StaticPrefs::gfx_canvas_accelerated_min_size();
if (aSize.width * aSize.height < minSize * minSize) {
  return false;
}

// Maximum pref allows 3 different options:
//  0 means unlimited size,
//  > 0 means use value as an absolute threshold,
//  < 0 means use the number of screen pixels as a threshold.
int32_t maxSize = StaticPrefs::gfx_canvas_accelerated_max_size();
if (maxSize > 0) {
  if (std::max(aSize.width, aSize.height) > maxSize) {
    return false;
  }
} else if (maxSize < 0) {
  // Default to historical mobile screen size of 980x480, like FishIEtank.
  // In addition, allow acceleration up to this size even if the screen is
  // smaller. A lot content expects this size to work well. See Bug 999841
  static const int32_t kScreenPixels = 980 * 480;

  if (RefPtr<widget::Screen> screen =
          widget::ScreenManager::GetSingleton().GetPrimaryScreen()) {
    LayoutDeviceIntSize screenSize = screen->GetRect().Size();
    if (aSize.width * aSize.height >
        std::max(screenSize.width * screenSize.height, kScreenPixels)) {
      return false;
    }
  }
}

return true;
928}

930already_AddRefed<DrawTargetWebgl> DrawTargetWebgl::Create(
  const IntSize& aSize, SurfaceFormat aFormat,
  const RefPtr<SharedContextWebgl>& aSharedContext) {
// Validate the size and format.
if (!CanCreate(aSize, aFormat)) {
  return nullptr;
}

RefPtr<DrawTargetWebgl> dt = new DrawTargetWebgl;
if (!dt->Init(aSize, aFormat, aSharedContext) || !dt->IsValid()) {
  return nullptr;
}

return dt.forget();
944}

946void* DrawTargetWebgl::GetNativeSurface(NativeSurfaceType aType) {
switch (aType) {
  case NativeSurfaceType::WEBGL_CONTEXT:
    // If the context is lost, then don't attempt to access it.
    if (mSharedContext->IsContextLost()) {
      return nullptr;
    }
    if (!mWebglValid) {
      FlushFromSkia();
    }
    return mSharedContext->mWebgl.get();
  default:
    return nullptr;
}
960}

962// Wrap a WebGL texture holding a snapshot with a texture handle. Note that
963// while the texture is still in use as the backing texture of a framebuffer,
964// it's texture memory is not currently tracked with other texture handles.
965// Once it is finally orphaned and used as a texture handle, it must be added
966// to the resource usage totals.
967already_AddRefed<TextureHandle> SharedContextWebgl::WrapSnapshot(
  const IntSize& aSize, SurfaceFormat aFormat, RefPtr<WebGLTexture> aTex) {
// Ensure there is enough space for the texture.
size_t usedBytes = BackingTexture::UsedBytes(aFormat, aSize);
PruneTextureMemory(usedBytes, false);
// Allocate a handle for the texture
RefPtr<StandaloneTexture> handle =
    new StandaloneTexture(aSize, aFormat, aTex.forget());
mStandaloneTextures.push_back(handle);
mTextureHandles.insertFront(handle);
AddTextureMemory(handle);
mUsedTextureMemory += usedBytes;
++mNumTextureHandles;
return handle.forget();
981}

983void SharedContextWebgl::SetTexFilter(WebGLTexture* aTex, bool aFilter) {
mWebgl->TexParameter_base(
    LOCAL_GL_TEXTURE_2D0x0DE1, LOCAL_GL_TEXTURE_MAG_FILTER0x2800,
    FloatOrInt(aFilter ? LOCAL_GL_LINEAR0x2601 : LOCAL_GL_NEAREST0x2600));
mWebgl->TexParameter_base(
    LOCAL_GL_TEXTURE_2D0x0DE1, LOCAL_GL_TEXTURE_MIN_FILTER0x2801,
    FloatOrInt(aFilter ? LOCAL_GL_LINEAR0x2601 : LOCAL_GL_NEAREST0x2600));
990}

992void SharedContextWebgl::InitTexParameters(WebGLTexture* aTex, bool aFilter) {
mWebgl->TexParameter_base(LOCAL_GL_TEXTURE_2D0x0DE1, LOCAL_GL_TEXTURE_WRAP_S0x2802,
                          FloatOrInt(LOCAL_GL_REPEAT0x2901));
mWebgl->TexParameter_base(LOCAL_GL_TEXTURE_2D0x0DE1, LOCAL_GL_TEXTURE_WRAP_T0x2803,
                          FloatOrInt(LOCAL_GL_REPEAT0x2901));
SetTexFilter(aTex, aFilter);
998}

1000// Copy the contents of the WebGL framebuffer into a WebGL texture.
1001already_AddRefed<TextureHandle> SharedContextWebgl::CopySnapshot(
  const IntRect& aRect, TextureHandle* aHandle) {
if (!mWebgl || mWebgl->IsContextLost()) {
  return nullptr;
}

// If the target is going away, then we can just directly reuse the
// framebuffer texture since it will never change.
RefPtr<WebGLTexture> tex = mWebgl->CreateTexture();
if (!tex) {
  return nullptr;
}

// If copying from a non-DT source, we have to bind a scratch framebuffer for
// reading.
if (aHandle) {
  if (!mScratchFramebuffer) {
    mScratchFramebuffer = mWebgl->CreateFramebuffer();
  }
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mScratchFramebuffer);

  webgl::FbAttachInfo attachInfo;
  attachInfo.tex = aHandle->GetBackingTexture()->GetWebGLTexture();
  mWebgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER0x8D40, LOCAL_GL_COLOR_ATTACHMENT00x8CE0,
                            LOCAL_GL_TEXTURE_2D0x0DE1, attachInfo);
}

// Create a texture to hold the copy
mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, tex);
mWebgl->TexStorage(LOCAL_GL_TEXTURE_2D0x0DE1, 1, LOCAL_GL_RGBA80x8058,
                   {uint32_t(aRect.width), uint32_t(aRect.height), 1});
InitTexParameters(tex);
// Copy the framebuffer into the texture
mWebgl->CopyTexImage(LOCAL_GL_TEXTURE_2D0x0DE1, 0, 0, {0, 0, 0}, {aRect.x, aRect.y},
                     {uint32_t(aRect.width), uint32_t(aRect.height)});
ClearLastTexture();

SurfaceFormat format =
    aHandle ? aHandle->GetFormat() : mCurrentTarget->GetFormat();
already_AddRefed<TextureHandle> result =
    WrapSnapshot(aRect.Size(), format, tex.forget());

// Restore the actual framebuffer after reading is done.
if (aHandle && mCurrentTarget) {
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mCurrentTarget->mFramebuffer);
}

return result;
1049}

1051inline DrawTargetWebgl::AutoRestoreContext::AutoRestoreContext(
  DrawTargetWebgl* aTarget)
  : mTarget(aTarget),
    mClipAARect(aTarget->mSharedContext->mClipAARect),
    mLastClipMask(aTarget->mSharedContext->mLastClipMask) {}

1057inline DrawTargetWebgl::AutoRestoreContext::~AutoRestoreContext() {
mTarget->mSharedContext->SetClipRect(mClipAARect);
if (mLastClipMask) {
  mTarget->mSharedContext->SetClipMask(mLastClipMask);
}
mTarget->mRefreshClipState = true;
1063}

1065// Utility method to install the target before copying a snapshot.
1066already_AddRefed<TextureHandle> DrawTargetWebgl::CopySnapshot(
  const IntRect& aRect) {
AutoRestoreContext restore(this);
if (!PrepareContext(false)) {
  return nullptr;
}
return mSharedContext->CopySnapshot(aRect);
1073}

1075bool DrawTargetWebgl::HasDataSnapshot() const {
return (mSkiaValid && !mSkiaLayer) || (mSnapshot && mSnapshot->HasReadData());
1077}

1079bool DrawTargetWebgl::PrepareSkia() {
if (!mSkiaValid) {
  ReadIntoSkia();
} else if (mSkiaLayer) {
  FlattenSkia();
}
return mSkiaValid;
1086}

1088bool DrawTargetWebgl::EnsureDataSnapshot() {
return HasDataSnapshot() || PrepareSkia();
1090}

1092void DrawTargetWebgl::PrepareShmem() { PrepareSkia(); }

1094// Borrow a snapshot that may be used by another thread for composition. Only
1095// Skia snapshots are safe to pass around.
1096already_AddRefed<SourceSurface> DrawTargetWebgl::GetDataSnapshot() {
PrepareSkia();
return mSkia->Snapshot(mFormat);
1099}

1101already_AddRefed<SourceSurface> DrawTargetWebgl::Snapshot() {
// If already using the Skia fallback, then just snapshot that.
if (mSkiaValid) {
  return GetDataSnapshot();
}

// There's no valid Skia snapshot, so we need to get one from the WebGL
// context.
if (!mSnapshot) {
  // Create a copy-on-write reference to this target.
  mSnapshot = new SourceSurfaceWebgl(this);
}
return do_AddRef(mSnapshot);
1114}

1116// If we need to provide a snapshot for another DrawTargetWebgl that shares the
1117// same WebGL context, then it is safe to directly return a snapshot. Otherwise,
1118// we may be exporting to another thread and require a data snapshot.
1119already_AddRefed<SourceSurface> DrawTargetWebgl::GetOptimizedSnapshot(
  DrawTarget* aTarget) {
if (aTarget && aTarget->GetBackendType() == BackendType::WEBGL &&
    static_cast<DrawTargetWebgl*>(aTarget)->mSharedContext ==
        mSharedContext) {
  return Snapshot();
}
return GetDataSnapshot();
1127}

1129// Read from the WebGL context into a buffer. This handles both swizzling BGRA
1130// to RGBA and flipping the image.
1131bool SharedContextWebgl::ReadInto(uint8_t* aDstData, int32_t aDstStride,
                                SurfaceFormat aFormat, const IntRect& aBounds,
                                TextureHandle* aHandle) {
MOZ_ASSERT(aFormat == SurfaceFormat::B8G8R8A8 ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat
::B8G8R8X8)>::isValid, "invalid assertion condition"); if (
(__builtin_expect(!!(!(!!(aFormat == SurfaceFormat::B8G8R8A8 ||
 aFormat == SurfaceFormat::B8G8R8X8))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat::B8G8R8X8"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 1135)
; AnnotateMozCrashReason("MOZ_ASSERT" "(" "aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat::B8G8R8X8"
 ")"); do { MOZ_CrashSequence(__null, 1135); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
           aFormat == SurfaceFormat::B8G8R8X8)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat
::B8G8R8X8)>::isValid, "invalid assertion condition"); if (
(__builtin_expect(!!(!(!!(aFormat == SurfaceFormat::B8G8R8A8 ||
 aFormat == SurfaceFormat::B8G8R8X8))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat::B8G8R8X8"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 1135)
; AnnotateMozCrashReason("MOZ_ASSERT" "(" "aFormat == SurfaceFormat::B8G8R8A8 || aFormat == SurfaceFormat::B8G8R8X8"
 ")"); do { MOZ_CrashSequence(__null, 1135); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

// If reading into a new texture, we have to bind it to a scratch framebuffer
// for reading.
if (aHandle) {
  if (!mScratchFramebuffer) {
    mScratchFramebuffer = mWebgl->CreateFramebuffer();
  }
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mScratchFramebuffer);
  webgl::FbAttachInfo attachInfo;
  attachInfo.tex = aHandle->GetBackingTexture()->GetWebGLTexture();
  mWebgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER0x8D40, LOCAL_GL_COLOR_ATTACHMENT00x8CE0,
                            LOCAL_GL_TEXTURE_2D0x0DE1, attachInfo);
} else if (mCurrentTarget && mCurrentTarget->mIsClear) {
  // If reading from a target that is still clear, then avoid the readback by
  // just clearing the data.
  SkPixmap(MakeSkiaImageInfo(aBounds.Size(), aFormat), aDstData, aDstStride)
      .erase(IsOpaque(aFormat) ? SK_ColorBLACK : SK_ColorTRANSPARENT);
  return true;
}

webgl::ReadPixelsDesc desc;
desc.srcOffset = *ivec2::From(aBounds);
desc.size = *uvec2::FromSize(aBounds);
desc.packState.rowLength = aDstStride / 4;
Range<uint8_t> range = {aDstData, size_t(aDstStride) * aBounds.height};
mWebgl->ReadPixelsInto(desc, range);

// Restore the actual framebuffer after reading is done.
if (aHandle && mCurrentTarget) {
  mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mCurrentTarget->mFramebuffer);
}

return true;
1169}

1171already_AddRefed<DataSourceSurface> SharedContextWebgl::ReadSnapshot(
  TextureHandle* aHandle) {
// Allocate a data surface, map it, and read from the WebGL context into the
// surface.
SurfaceFormat format = SurfaceFormat::UNKNOWN;
IntRect bounds;
if (aHandle) {
  format = aHandle->GetFormat();
  bounds = aHandle->GetBounds();
} else {
  format = mCurrentTarget->GetFormat();
  bounds = mCurrentTarget->GetRect();
}
RefPtr<DataSourceSurface> surface =
    Factory::CreateDataSourceSurface(bounds.Size(), format);
if (!surface) {
  return nullptr;
}
DataSourceSurface::ScopedMap dstMap(surface, DataSourceSurface::WRITE);
if (!dstMap.IsMapped() || !ReadInto(dstMap.GetData(), dstMap.GetStride(),
                                    format, bounds, aHandle)) {
  return nullptr;
}
return surface.forget();
1195}

1197// Utility method to install the target before reading a snapshot.
1198bool DrawTargetWebgl::ReadInto(uint8_t* aDstData, int32_t aDstStride) {
if (!PrepareContext(false)) {
  return false;
}

return mSharedContext->ReadInto(aDstData, aDstStride, GetFormat(), GetRect());
1204}

1206// Utility method to install the target before reading a snapshot.
1207already_AddRefed<DataSourceSurface> DrawTargetWebgl::ReadSnapshot() {
AutoRestoreContext restore(this);
if (!PrepareContext(false)) {
  return nullptr;
}
mProfile.OnReadback();
return mSharedContext->ReadSnapshot();
1214}

1216already_AddRefed<SourceSurface> DrawTargetWebgl::GetBackingSurface() {
return Snapshot();
1218}

1220void DrawTargetWebgl::DetachAllSnapshots() {
mSkia->DetachAllSnapshots();
ClearSnapshot();
1223}

1225// Prepare the framebuffer for accelerated drawing. Any cached snapshots will
1226// be invalidated if not detached and copied here. Ensure the WebGL
1227// framebuffer's contents are updated if still somehow stored in the Skia
1228// framebuffer.
1229bool DrawTargetWebgl::MarkChanged() {
if (mSnapshot) {
  // Try to copy the target into a new texture if possible.
  ClearSnapshot(true, true);
}
if (!mWebglValid && !FlushFromSkia()) {
  return false;
}
mSkiaValid = false;
mIsClear = false;
return true;
1240}

1242void DrawTargetWebgl::MarkSkiaChanged(bool aOverwrite) {
if (aOverwrite) {
  mSkiaValid = true;
  mSkiaLayer = false;
} else if (!mSkiaValid) {
  if (ReadIntoSkia()) {
    // Signal that we've hit a complete software fallback.
    mProfile.OnFallback();
  }
} else if (mSkiaLayer && !mLayerDepth) {
  FlattenSkia();
}
mWebglValid = false;
mIsClear = false;
1256}

1258// Whether a given composition operator is associative and thus allows drawing
1259// into a separate layer that can be later composited back into the WebGL
1260// context.
1261static inline bool SupportsLayering(const DrawOptions& aOptions) {
switch (aOptions.mCompositionOp) {
  case CompositionOp::OP_OVER:
    // Layering is only supported for the default source-over composition op.
    return true;
  default:
    return false;
}
1269}

1271void DrawTargetWebgl::MarkSkiaChanged(const DrawOptions& aOptions) {
if (SupportsLayering(aOptions)) {
  if (!mSkiaValid) {
    // If the Skia context needs initialization, clear it and enable layering.
    mSkiaValid = true;
    if (mWebglValid) {
      mProfile.OnLayer();
      mSkiaLayer = true;
      mSkiaLayerClear = mIsClear;
      mSkia->DetachAllSnapshots();
      if (mSkiaLayerClear) {
        // Avoid blending later by making sure the layer background is filled
        // with opaque alpha values if necessary.
        mSkiaNoClip->FillRect(Rect(mSkiaNoClip->GetRect()), GetClearPattern(),
                              DrawOptions(1.0f, CompositionOp::OP_SOURCE));
      } else {
        mSkiaNoClip->ClearRect(Rect(mSkiaNoClip->GetRect()));
      }
    }
  }
  // The WebGL context is no longer up-to-date.
  mWebglValid = false;
  mIsClear = false;
} else {
  // For other composition ops, just overwrite the Skia data.
  MarkSkiaChanged();
}
1298}

1300bool DrawTargetWebgl::LockBits(uint8_t** aData, IntSize* aSize,
                             int32_t* aStride, SurfaceFormat* aFormat,
                             IntPoint* aOrigin) {
// Can only access pixels if there is valid, flattened Skia data.
if (mSkiaValid && !mSkiaLayer) {
  MarkSkiaChanged();
  return mSkia->LockBits(aData, aSize, aStride, aFormat, aOrigin);
}
return false;
1309}

1311void DrawTargetWebgl::ReleaseBits(uint8_t* aData) {
// Can only access pixels if there is valid, flattened Skia data.
if (mSkiaValid && !mSkiaLayer) {
  mSkia->ReleaseBits(aData);
}
1316}

1318// Format is x, y, alpha
1319static const float kRectVertexData[12] = {0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
                                        1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f};

1322// Orphans the contents of the path vertex buffer. The beginning of the buffer
1323// always contains data for a simple rectangle draw to avoid needing to switch
1324// buffers.
1325void SharedContextWebgl::ResetPathVertexBuffer() {
if (!mPathVertexBuffer) {
  MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 1327); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { MOZ_CrashSequence(__null, 1327); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return;
}

size_t oldCapacity = mPathVertexBuffer->ByteLength();
RemoveUntrackedTextureMemory(oldCapacity);

mWebgl->BindBuffer(LOCAL_GL_ARRAY_BUFFER0x8892, mPathVertexBuffer.get());
mWebgl->UninitializedBufferData_SizeOnly(
    LOCAL_GL_ARRAY_BUFFER0x8892,
    std::max(size_t(mPathVertexCapacity), sizeof(kRectVertexData)),
    LOCAL_GL_DYNAMIC_DRAW0x88E8);
mWebgl->BufferSubData(LOCAL_GL_ARRAY_BUFFER0x8892, 0, sizeof(kRectVertexData),
                      (const uint8_t*)kRectVertexData);
mPathVertexOffset = sizeof(kRectVertexData);

size_t newCapacity = mPathVertexBuffer->ByteLength();
AddUntrackedTextureMemory(newCapacity);

if (mWGROutputBuffer &&
    (!mPathVertexCapacity || newCapacity != oldCapacity)) {
  RemoveHeapData(mWGROutputBuffer.get());
  mWGROutputBuffer = nullptr;
}

if (mPathVertexCapacity > 0 && !mWGROutputBuffer) {
  mWGROutputBuffer.reset(new (
      fallible) WGR::OutputVertex[newCapacity / sizeof(WGR::OutputVertex)]);
  AddHeapData(mWGROutputBuffer.get());
}
1357}

1359// Attempts to create all shaders and resources to be used for drawing commands.
1360// Returns whether or not this succeeded.
1361bool SharedContextWebgl::CreateShaders() {
if (!mPathVertexArray) {
  mPathVertexArray = mWebgl->CreateVertexArray();
}
if (!mPathVertexBuffer) {
  mPathVertexBuffer = mWebgl->CreateBuffer();
  AddUntrackedTextureMemory(mPathVertexBuffer);
  mWebgl->BindVertexArray(mPathVertexArray.get());
  ResetPathVertexBuffer();
  mWebgl->EnableVertexAttribArray(0);

  webgl::VertAttribPointerDesc attribDesc;
  attribDesc.channels = 3;
  attribDesc.type = LOCAL_GL_FLOAT0x1406;
  attribDesc.normalized = false;
  mWebgl->VertexAttribPointer(0, attribDesc);
}
if (!mSolidProgram) {
  // AA is computed by using the basis vectors of the transform to determine
  // both the scale and orientation. The scale is then used to extrude the
  // rectangle outward by 1 screen-space pixel to account for the AA region.
  // The distance to the rectangle edges is passed to the fragment shader in
  // an interpolant, biased by 0.5 so it represents the desired coverage. The
  // minimum coverage is then chosen by the fragment shader to use as an AA
  // coverage value to modulate the color.
  auto vsSource =
      "attribute vec3 a_vertex;\n"
      "uniform vec2 u_transform[3];\n"
      "uniform vec2 u_viewport;\n"
      "uniform vec4 u_clipbounds;\n"
      "uniform float u_aa;\n"
      "varying vec2 v_cliptc;\n"
      "varying vec4 v_clipdist;\n"
      "varying vec4 v_dist;\n"
      "varying float v_alpha;\n"
      "void main() {\n"
      "   vec2 scale = vec2(dot(u_transform[0], u_transform[0]),\n"
      "                     dot(u_transform[1], u_transform[1]));\n"
      "   vec2 invScale = u_aa * inversesqrt(scale + 1.0e-6);\n"
      "   scale *= invScale;\n"
      "   vec2 extrude = a_vertex.xy +\n"
      "                  invScale * (2.0 * a_vertex.xy - 1.0);\n"
      "   vec2 vertex = u_transform[0] * extrude.x +\n"
      "                 u_transform[1] * extrude.y +\n"
      "                 u_transform[2];\n"
      "   gl_Position = vec4(vertex * 2.0 / u_viewport - 1.0, 0.0, 1.0);\n"
      "   v_cliptc = vertex / u_viewport;\n"
      "   v_clipdist = vec4(vertex - u_clipbounds.xy,\n"
      "                     u_clipbounds.zw - vertex);\n"
      "   float noAA = 1.0 - u_aa;\n"
      "   v_dist = vec4(extrude, 1.0 - extrude) * scale.xyxy + 0.5 + noAA;\n"
      "   v_alpha = min(a_vertex.z,\n"
      "                 min(scale.x, 1.0) * min(scale.y, 1.0) + noAA);\n"
      "}\n";
  auto fsSource =
      "precision mediump float;\n"
      "uniform vec4 u_color;\n"
      "uniform sampler2D u_clipmask;\n"
      "varying highp vec2 v_cliptc;\n"
      "varying vec4 v_clipdist;\n"
      "varying vec4 v_dist;\n"
      "varying float v_alpha;\n"
      "void main() {\n"
      "   float clip = texture2D(u_clipmask, v_cliptc).r;\n"
      "   vec4 dist = min(v_dist, v_clipdist);\n"
      "   dist.xy = min(dist.xy, dist.zw);\n"
      "   float aa = clamp(min(dist.x, dist.y), 0.0, v_alpha);\n"
      "   gl_FragColor = clip * aa * u_color;\n"
      "}\n";
  RefPtr<WebGLShader> vsId = mWebgl->CreateShader(LOCAL_GL_VERTEX_SHADER0x8B31);
  mWebgl->ShaderSource(*vsId, vsSource);
  mWebgl->CompileShader(*vsId);
  if (!mWebgl->GetCompileResult(*vsId).success) {
    return false;
  }
  RefPtr<WebGLShader> fsId = mWebgl->CreateShader(LOCAL_GL_FRAGMENT_SHADER0x8B30);
  mWebgl->ShaderSource(*fsId, fsSource);
  mWebgl->CompileShader(*fsId);
  if (!mWebgl->GetCompileResult(*fsId).success) {
    return false;
  }
  mSolidProgram = mWebgl->CreateProgram();
  mWebgl->AttachShader(*mSolidProgram, *vsId);
  mWebgl->AttachShader(*mSolidProgram, *fsId);
  mWebgl->BindAttribLocation(*mSolidProgram, 0, "a_vertex");
  mWebgl->LinkProgram(*mSolidProgram);
  if (!mWebgl->GetLinkResult(*mSolidProgram).success) {
    return false;
  }
  mSolidProgramViewport = GetUniformLocation(mSolidProgram, "u_viewport");
  mSolidProgramAA = GetUniformLocation(mSolidProgram, "u_aa");
  mSolidProgramTransform = GetUniformLocation(mSolidProgram, "u_transform");
  mSolidProgramColor = GetUniformLocation(mSolidProgram, "u_color");
  mSolidProgramClipMask = GetUniformLocation(mSolidProgram, "u_clipmask");
  mSolidProgramClipBounds = GetUniformLocation(mSolidProgram, "u_clipbounds");
  if (!mSolidProgramViewport || !mSolidProgramAA || !mSolidProgramTransform ||
      !mSolidProgramColor || !mSolidProgramClipMask ||
      !mSolidProgramClipBounds) {
    return false;
  }
  mWebgl->UseProgram(mSolidProgram);
  UniformData(LOCAL_GL_INT0x1404, mSolidProgramClipMask, Array<int32_t, 1>{1});
}

if (!mImageProgram) {
  auto vsSource =
      "attribute vec3 a_vertex;\n"
      "uniform vec2 u_viewport;\n"
      "uniform vec4 u_clipbounds;\n"
      "uniform float u_aa;\n"
      "uniform vec2 u_transform[3];\n"
      "uniform vec2 u_texmatrix[3];\n"
      "varying vec2 v_cliptc;\n"
      "varying vec2 v_texcoord;\n"
      "varying vec4 v_clipdist;\n"
      "varying vec4 v_dist;\n"
      "varying float v_alpha;\n"
      "void main() {\n"
      "   vec2 scale = vec2(dot(u_transform[0], u_transform[0]),\n"
      "                     dot(u_transform[1], u_transform[1]));\n"
      "   vec2 invScale = u_aa * inversesqrt(scale + 1.0e-6);\n"
      "   scale *= invScale;\n"
      "   vec2 extrude = a_vertex.xy +\n"
      "                  invScale * (2.0 * a_vertex.xy - 1.0);\n"
      "   vec2 vertex = u_transform[0] * extrude.x +\n"
      "                 u_transform[1] * extrude.y +\n"
      "                 u_transform[2];\n"
      "   gl_Position = vec4(vertex * 2.0 / u_viewport - 1.0, 0.0, 1.0);\n"
      "   v_cliptc = vertex / u_viewport;\n"
      "   v_clipdist = vec4(vertex - u_clipbounds.xy,\n"
      "                     u_clipbounds.zw - vertex);\n"
      "   v_texcoord = u_texmatrix[0] * extrude.x +\n"
      "                u_texmatrix[1] * extrude.y +\n"
      "                u_texmatrix[2];\n"
      "   float noAA = 1.0 - u_aa;\n"
      "   v_dist = vec4(extrude, 1.0 - extrude) * scale.xyxy + 0.5 + noAA;\n"
      "   v_alpha = min(a_vertex.z,\n"
      "                 min(scale.x, 1.0) * min(scale.y, 1.0) + noAA);\n"
      "}\n";
  auto fsSource =
      "precision mediump float;\n"
      "uniform vec4 u_texbounds;\n"
      "uniform vec4 u_color;\n"
      "uniform float u_swizzle;\n"
      "uniform sampler2D u_sampler;\n"
      "uniform sampler2D u_clipmask;\n"
      "varying highp vec2 v_cliptc;\n"
      "varying highp vec2 v_texcoord;\n"
      "varying vec4 v_clipdist;\n"
      "varying vec4 v_dist;\n"
      "varying float v_alpha;\n"
      "void main() {\n"
      "   highp vec2 tc = clamp(v_texcoord, u_texbounds.xy,\n"
      "                         u_texbounds.zw);\n"
      "   vec4 image = texture2D(u_sampler, tc);\n"
      "   float clip = texture2D(u_clipmask, v_cliptc).r;\n"
      "   vec4 dist = min(v_dist, v_clipdist);\n"
      "   dist.xy = min(dist.xy, dist.zw);\n"
      "   float aa = clamp(min(dist.x, dist.y), 0.0, v_alpha);\n"
      "   gl_FragColor = clip * aa * u_color *\n"
      "                  mix(image, image.rrrr, u_swizzle);\n"
      "}\n";
  RefPtr<WebGLShader> vsId = mWebgl->CreateShader(LOCAL_GL_VERTEX_SHADER0x8B31);
  mWebgl->ShaderSource(*vsId, vsSource);
  mWebgl->CompileShader(*vsId);
  if (!mWebgl->GetCompileResult(*vsId).success) {
    return false;
  }
  RefPtr<WebGLShader> fsId = mWebgl->CreateShader(LOCAL_GL_FRAGMENT_SHADER0x8B30);
  mWebgl->ShaderSource(*fsId, fsSource);
  mWebgl->CompileShader(*fsId);
  if (!mWebgl->GetCompileResult(*fsId).success) {
    return false;
  }
  mImageProgram = mWebgl->CreateProgram();
  mWebgl->AttachShader(*mImageProgram, *vsId);
  mWebgl->AttachShader(*mImageProgram, *fsId);
  mWebgl->BindAttribLocation(*mImageProgram, 0, "a_vertex");
  mWebgl->LinkProgram(*mImageProgram);
  if (!mWebgl->GetLinkResult(*mImageProgram).success) {
    return false;
  }
  mImageProgramViewport = GetUniformLocation(mImageProgram, "u_viewport");
  mImageProgramAA = GetUniformLocation(mImageProgram, "u_aa");
  mImageProgramTransform = GetUniformLocation(mImageProgram, "u_transform");
  mImageProgramTexMatrix = GetUniformLocation(mImageProgram, "u_texmatrix");
  mImageProgramTexBounds = GetUniformLocation(mImageProgram, "u_texbounds");
  mImageProgramSwizzle = GetUniformLocation(mImageProgram, "u_swizzle");
  mImageProgramColor = GetUniformLocation(mImageProgram, "u_color");
  mImageProgramSampler = GetUniformLocation(mImageProgram, "u_sampler");
  mImageProgramClipMask = GetUniformLocation(mImageProgram, "u_clipmask");
  mImageProgramClipBounds = GetUniformLocation(mImageProgram, "u_clipbounds");
  if (!mImageProgramViewport || !mImageProgramAA || !mImageProgramTransform ||
      !mImageProgramTexMatrix || !mImageProgramTexBounds ||
      !mImageProgramSwizzle || !mImageProgramColor || !mImageProgramSampler ||
      !mImageProgramClipMask || !mImageProgramClipBounds) {
    return false;
  }
  mWebgl->UseProgram(mImageProgram);
  UniformData(LOCAL_GL_INT0x1404, mImageProgramSampler, Array<int32_t, 1>{0});
  UniformData(LOCAL_GL_INT0x1404, mImageProgramClipMask, Array<int32_t, 1>{1});
}
return true;
1564}

1566void SharedContextWebgl::EnableScissor(const IntRect& aRect) {
// Only update scissor state if it actually changes.
if (!mLastScissor.IsEqualEdges(aRect)) {
  mLastScissor = aRect;
  mWebgl->Scissor(aRect.x, aRect.y, aRect.width, aRect.height);
}
if (!mScissorEnabled) {
  mScissorEnabled = true;
  mWebgl->SetEnabled(LOCAL_GL_SCISSOR_TEST0x0C11, {}, true);
}
1576}

1578void SharedContextWebgl::DisableScissor() {
if (mScissorEnabled) {
  mScissorEnabled = false;
  mWebgl->SetEnabled(LOCAL_GL_SCISSOR_TEST0x0C11, {}, false);
}
1583}

1585inline ColorPattern DrawTargetWebgl::GetClearPattern() const {
return ColorPattern(
    DeviceColor(0.0f, 0.0f, 0.0f, IsOpaque(mFormat) ? 1.0f : 0.0f));
1588}

1590template <typename R>
1591inline RectDouble DrawTargetWebgl::TransformDouble(const R& aRect) const {
return MatrixDouble(mTransform).TransformBounds(WidenToDouble(aRect));
1593}

1595// Check if the transformed rect clips to the viewport.
1596inline Maybe<Rect> DrawTargetWebgl::RectClippedToViewport(
  const RectDouble& aRect) const {
if (!mTransform.PreservesAxisAlignedRectangles()) {
  return Nothing();
}

return Some(NarrowToFloat(aRect.SafeIntersect(RectDouble(GetRect()))));
1603}

1605// Ensure that the rect, after transform, is within reasonable precision limits
1606// such that when transformed and clipped in the shader it will not round bits
1607// from the mantissa in a way that will diverge in a noticeable way from path
1608// geometry calculated by the path fallback.
1609template <typename R>
1610static inline bool RectInsidePrecisionLimits(const R& aRect) {
return R(-(1 << 20), -(1 << 20), 2 << 20, 2 << 20).Contains(aRect);
1612}

1614void DrawTargetWebgl::ClearRect(const Rect& aRect) {
if (mIsClear) {
  // No need to clear anything if the entire framebuffer is already clear.
  return;
}

RectDouble xformRect = TransformDouble(aRect);
bool containsViewport = false;
if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
  // If the rect clips to viewport, just clear the clipped rect
  // to avoid transform issues.
  containsViewport = clipped->Size() == Size(GetSize());
  DrawRect(*clipped, GetClearPattern(),
           DrawOptions(1.0f, CompositionOp::OP_CLEAR), Nothing(), nullptr,
           false);
} else if (RectInsidePrecisionLimits(xformRect)) {
  // If the rect transform won't stress precision, then just use it.
  DrawRect(aRect, GetClearPattern(),
           DrawOptions(1.0f, CompositionOp::OP_CLEAR));
} else {
  // Otherwise, using the transform in the shader may lead to inaccuracies, so
  // just fall back.
  MarkSkiaChanged();
  mSkia->ClearRect(aRect);
}

// If the clear rectangle encompasses the entire viewport and is not clipped,
// then mark the target as entirely clear.
if (containsViewport && mSharedContext->IsCurrentTarget(this) &&
    !mSharedContext->HasClipMask() &&
    mSharedContext->mClipAARect.Contains(Rect(GetRect()))) {
  mIsClear = true;
}
1647}

1649static inline DeviceColor PremultiplyColor(const DeviceColor& aColor,
                                         float aAlpha = 1.0f) {
float a = aColor.a * aAlpha;
return DeviceColor(aColor.r * a, aColor.g * a, aColor.b * a, a);
1653}

1655// Attempts to create the framebuffer used for drawing and also any relevant
1656// non-shared resources. Returns whether or not this succeeded.
1657bool DrawTargetWebgl::CreateFramebuffer() {
RefPtr<WebGLContext> webgl = mSharedContext->mWebgl;
if (!mFramebuffer) {
  mFramebuffer = webgl->CreateFramebuffer();
}
if (!mTex) {
  mTex = webgl->CreateTexture();
  webgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, mTex);
  webgl->TexStorage(LOCAL_GL_TEXTURE_2D0x0DE1, 1, LOCAL_GL_RGBA80x8058,
                    {uint32_t(mSize.width), uint32_t(mSize.height), 1});
  mSharedContext->InitTexParameters(mTex);
  webgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mFramebuffer);
  webgl::FbAttachInfo attachInfo;
  attachInfo.tex = mTex;
  webgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER0x8D40, LOCAL_GL_COLOR_ATTACHMENT00x8CE0,
                           LOCAL_GL_TEXTURE_2D0x0DE1, attachInfo);
  webgl->Viewport(0, 0, mSize.width, mSize.height);
  mSharedContext->DisableScissor();
  DeviceColor color = PremultiplyColor(GetClearPattern().mColor);
  webgl->ClearColor(color.b, color.g, color.r, color.a);
  webgl->Clear(LOCAL_GL_COLOR_BUFFER_BIT0x00004000);
  mSharedContext->ClearTarget();
  mSharedContext->ClearLastTexture();
  mSharedContext->AddUntrackedTextureMemory(mTex);
}
return true;
1683}

1685void DrawTargetWebgl::CopySurface(SourceSurface* aSurface,
                                const IntRect& aSourceRect,
                                const IntPoint& aDestination) {
// Intersect the source and destination rectangles with the viewport bounds.
IntRect destRect =
    IntRect(aDestination, aSourceRect.Size()).SafeIntersect(GetRect());
IntRect srcRect = destRect - aDestination + aSourceRect.TopLeft();
if (srcRect.IsEmpty()) {
  return;
}

if (mSkiaValid) {
  if (mSkiaLayer) {
    if (destRect.Contains(GetRect())) {
      // If the the destination would override the entire layer, discard the
      // layer.
      mSkiaLayer = false;
    } else if (!IsOpaque(aSurface->GetFormat())) {
      // If the surface is not opaque, copying it into the layer results in
      // unintended blending rather than a copy to the destination.
      FlattenSkia();
    }
  } else {
    // If there is no layer, copying is safe.
    MarkSkiaChanged();
  }
  mSkia->CopySurface(aSurface, srcRect, destRect.TopLeft());
  return;
}

IntRect samplingRect;
if (!mSharedContext->IsCompatibleSurface(aSurface)) {
  // If this data surface completely overwrites the framebuffer, then just
  // copy it to the Skia target.
  if (destRect.Contains(GetRect())) {
    MarkSkiaChanged(true);
    mSkia->DetachAllSnapshots();
    mSkiaNoClip->CopySurface(aSurface, srcRect, destRect.TopLeft());
    return;
  }

  // CopySurface usually only samples a surface once, so don't cache the
  // entire surface as it is unlikely to be reused. Limit it to the used
  // source rectangle instead.
  IntRect surfaceRect = aSurface->GetRect();
  if (!srcRect.IsEqualEdges(surfaceRect)) {
    samplingRect = srcRect.SafeIntersect(surfaceRect) - surfaceRect.TopLeft();
  }
}

Matrix matrix = Matrix::Translation(destRect.TopLeft() - srcRect.TopLeft());
SurfacePattern pattern(aSurface, ExtendMode::CLAMP, matrix,
                       SamplingFilter::POINT, samplingRect);
DrawRect(Rect(destRect), pattern, DrawOptions(1.0f, CompositionOp::OP_SOURCE),
         Nothing(), nullptr, false, false);
1740}

1742void DrawTargetWebgl::PushClip(const Path* aPath) {
if (aPath && aPath->GetBackendType() == BackendType::SKIA) {
  // Detect if the path is really just a rect to simplify caching.
  if (Maybe<Rect> rect = aPath->AsRect()) {
    PushClipRect(*rect);
    return;
  }
}

mClipChanged = true;
mRefreshClipState = true;
mSkia->PushClip(aPath);

mClipStack.push_back({GetTransform(), Rect(), aPath});
1756}

1758void DrawTargetWebgl::PushClipRect(const Rect& aRect) {
mClipChanged = true;
mRefreshClipState = true;
mSkia->PushClipRect(aRect);

mClipStack.push_back({GetTransform(), aRect, nullptr});
1764}

1766void DrawTargetWebgl::PushDeviceSpaceClipRects(const IntRect* aRects,
                                             uint32_t aCount) {
mClipChanged = true;
mRefreshClipState = true;
mSkia->PushDeviceSpaceClipRects(aRects, aCount);

for (uint32_t i = 0; i < aCount; i++) {
  mClipStack.push_back({Matrix(), Rect(aRects[i]), nullptr});
}
1775}

1777void DrawTargetWebgl::PopClip() {
mClipChanged = true;
mRefreshClipState = true;
mSkia->PopClip();

mClipStack.pop_back();
1783}

1785bool DrawTargetWebgl::RemoveAllClips() {
if (mClipStack.empty()) {
  return true;
}
if (!mSkia->RemoveAllClips()) {
  return false;
}
mClipChanged = true;
mRefreshClipState = true;
mClipStack.clear();
return true;
1796}

1798bool DrawTargetWebgl::CopyToFallback(DrawTarget* aDT) {
aDT->RemoveAllClips();
for (auto& clipStack : mClipStack) {
  aDT->SetTransform(clipStack.mTransform);
  if (clipStack.mPath) {
    aDT->PushClip(clipStack.mPath);
  } else {
    aDT->PushClipRect(clipStack.mRect);
  }
}
aDT->SetTransform(GetTransform());

// An existing data snapshot is required for fallback, as we have to avoid
// trying to touch the WebGL context, which is assumed to be invalid and not
// suitable for readback.
if (HasDataSnapshot()) {
  if (RefPtr<SourceSurface> snapshot = Snapshot()) {
    aDT->CopySurface(snapshot, snapshot->GetRect(), gfx::IntPoint(0, 0));
    return true;
  }
}
return false;
1820}

1822// Whether a given composition operator can be mapped to a WebGL blend mode.
1823static inline bool SupportsDrawOptions(const DrawOptions& aOptions) {
switch (aOptions.mCompositionOp) {
  case CompositionOp::OP_OVER:
  case CompositionOp::OP_ADD:
  case CompositionOp::OP_ATOP:
  case CompositionOp::OP_SOURCE:
  case CompositionOp::OP_CLEAR:
    return true;
  default:
    return false;
}
1834}

1836static inline bool SupportsExtendMode(const SurfacePattern& aPattern) {
switch (aPattern.mExtendMode) {
  case ExtendMode::CLAMP:
    return true;
  case ExtendMode::REPEAT:
  case ExtendMode::REPEAT_X:
  case ExtendMode::REPEAT_Y:
    if ((!aPattern.mSurface ||
         aPattern.mSurface->GetUnderlyingType() == SurfaceType::WEBGL) &&
        !aPattern.mSamplingRect.IsEmpty()) {
      return false;
    }
    return true;
  default:
    return false;
}
1852}

1854// Whether a pattern can be mapped to an available WebGL shader.
1855bool SharedContextWebgl::SupportsPattern(const Pattern& aPattern) {
switch (aPattern.GetType()) {
  case PatternType::COLOR:
    return true;
  case PatternType::SURFACE: {
    auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
    if (!SupportsExtendMode(surfacePattern)) {
      return false;
    }
    if (surfacePattern.mSurface) {
      // If the surface is already uploaded to a texture, then just use it.
      if (IsCompatibleSurface(surfacePattern.mSurface)) {
        return true;
      }

      IntSize size = surfacePattern.mSurface->GetSize();
      // The maximum size a surface can be before triggering a fallback to
      // software. Bound the maximum surface size by the actual texture size
      // limit.
      int32_t maxSize = int32_t(
          std::min(StaticPrefs::gfx_canvas_accelerated_max_surface_size(),
                   mMaxTextureSize));
      // Check if either of the surface dimensions or the sampling rect,
      // if supplied, exceed the maximum.
      if (std::max(size.width, size.height) > maxSize &&
          (surfacePattern.mSamplingRect.IsEmpty() ||
           std::max(surfacePattern.mSamplingRect.width,
                    surfacePattern.mSamplingRect.height) > maxSize)) {
        return false;
      }
    }
    return true;
  }
  default:
    // Patterns other than colors and surfaces are currently not accelerated.
    return false;
}
1892}

1894bool DrawTargetWebgl::DrawRect(const Rect& aRect, const Pattern& aPattern,
                             const DrawOptions& aOptions,
                             Maybe<DeviceColor> aMaskColor,
                             RefPtr<TextureHandle>* aHandle,
                             bool aTransformed, bool aClipped,
                             bool aAccelOnly, bool aForceUpdate,
                             const StrokeOptions* aStrokeOptions) {
// If there is nothing to draw, then don't draw...
if (aRect.IsEmpty()) {
  return true;
}

// If we're already drawing directly to the WebGL context, then we want to
// continue to do so. However, if we're drawing into a Skia layer over the
// WebGL context, then we need to be careful to avoid repeatedly clearing
// and flushing the layer if we hit a drawing request that can be accelerated
// in between layered drawing requests, as clearing and flushing the layer
// can be significantly expensive when repeated. So when a Skia layer is
// active, if it is possible to continue drawing into the layer, then don't
// accelerate the drawing request.
if (mWebglValid || (mSkiaLayer && !mLayerDepth &&
                    (aAccelOnly || !SupportsLayering(aOptions)))) {
  // If we get here, either the WebGL context is being directly drawn to
  // or we are going to flush the Skia layer to it before doing so. The shared
  // context still needs to be claimed and prepared for drawing. If this
  // fails, we just fall back to drawing with Skia below.
  if (PrepareContext(aClipped)) {
    // The shared context is claimed and the framebuffer is now valid, so try
    // accelerated drawing.
    return mSharedContext->DrawRectAccel(
        aRect, aPattern, aOptions, aMaskColor, aHandle, aTransformed,
        aClipped, aAccelOnly, aForceUpdate, aStrokeOptions);
  }
}

// Either there is no valid WebGL target to draw into, or we failed to prepare
// it for drawing. The only thing we can do at this point is fall back to
// drawing with Skia. If the request explicitly requires accelerated drawing,
// then draw nothing before returning failure.
if (!aAccelOnly) {
  DrawRectFallback(aRect, aPattern, aOptions, aMaskColor, aTransformed,
                   aClipped, aStrokeOptions);
}
return false;
1938}

1940void DrawTargetWebgl::DrawRectFallback(const Rect& aRect,
                                     const Pattern& aPattern,
                                     const DrawOptions& aOptions,
                                     Maybe<DeviceColor> aMaskColor,
                                     bool aTransformed, bool aClipped,
                                     const StrokeOptions* aStrokeOptions) {
// Invalidate the WebGL target and prepare the Skia target for drawing.
MarkSkiaChanged(aOptions);

if (aTransformed) {
  // If transforms are requested, then just translate back to FillRect.
  if (aMaskColor) {
    mSkia->Mask(ColorPattern(*aMaskColor), aPattern, aOptions);
  } else if (aStrokeOptions) {
    mSkia->StrokeRect(aRect, aPattern, *aStrokeOptions, aOptions);
  } else {
    mSkia->FillRect(aRect, aPattern, aOptions);
  }
} else if (aClipped) {
  // If no transform was requested but clipping is still required, then
  // temporarily reset the transform before translating to FillRect.
  mSkia->SetTransform(Matrix());
  if (aMaskColor) {
    auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
    if (surfacePattern.mSamplingRect.IsEmpty()) {
      mSkia->MaskSurface(ColorPattern(*aMaskColor), surfacePattern.mSurface,
                         aRect.TopLeft(), aOptions);
    } else {
      mSkia->Mask(ColorPattern(*aMaskColor), aPattern, aOptions);
    }
  } else if (aStrokeOptions) {
    mSkia->StrokeRect(aRect, aPattern, *aStrokeOptions, aOptions);
  } else {
    mSkia->FillRect(aRect, aPattern, aOptions);
  }
  mSkia->SetTransform(mTransform);
} else if (aPattern.GetType() == PatternType::SURFACE) {
  // No transform nor clipping was requested, so it is essentially just a
  // copy.
  auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
  IntRect destRect = RoundedOut(aRect);
  IntRect srcRect =
      destRect - IntPoint::Round(surfacePattern.mMatrix.GetTranslation());
  mSkia->CopySurface(surfacePattern.mSurface, srcRect, destRect.TopLeft());
} else {
  MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 1985); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { MOZ_CrashSequence(__null, 1985); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
}
1987}

1989inline already_AddRefed<WebGLTexture> SharedContextWebgl::GetCompatibleSnapshot(
  SourceSurface* aSurface) const {
if (aSurface->GetUnderlyingType() == SurfaceType::WEBGL) {
  RefPtr<SourceSurfaceWebgl> webglSurf =
      aSurface->GetUnderlyingSurface().downcast<SourceSurfaceWebgl>();
  if (this == webglSurf->mSharedContext) {
    // If there is a snapshot copy in a texture handle, use that.
    if (webglSurf->mHandle) {
      return do_AddRef(
          webglSurf->mHandle->GetBackingTexture()->GetWebGLTexture());
    }
    if (RefPtr<DrawTargetWebgl> webglDT = webglSurf->GetTarget()) {
      // If there is a copy-on-write reference to a target, use its backing
      // texture directly. This is only safe if the targets don't match, but
      // MarkChanged should ensure that any snapshots were copied into a
      // texture handle before we ever get here.
      if (!IsCurrentTarget(webglDT)) {
        return do_AddRef(webglDT->mTex);
      }
    }
  }
}
return nullptr;
2012}

2014inline bool SharedContextWebgl::IsCompatibleSurface(
  SourceSurface* aSurface) const {
return bool(RefPtr<WebGLTexture>(GetCompatibleSnapshot(aSurface)));
2017}

2019bool SharedContextWebgl::UploadSurface(DataSourceSurface* aData,
                                     SurfaceFormat aFormat,
                                     const IntRect& aSrcRect,
                                     const IntPoint& aDstOffset, bool aInit,
                                     bool aZero,
                                     const RefPtr<WebGLTexture>& aTex) {
webgl::TexUnpackBlobDesc texDesc = {
    LOCAL_GL_TEXTURE_2D0x0DE1,
    {uint32_t(aSrcRect.width), uint32_t(aSrcRect.height), 1}};
if (aData) {
  // The surface needs to be uploaded to its backing texture either to
  // initialize or update the texture handle contents. Map the data
  // contents of the surface so it can be read.
  DataSourceSurface::ScopedMap map(aData, DataSourceSurface::READ);
  if (!map.IsMapped()) {
    return false;
  }
  int32_t stride = map.GetStride();
  int32_t bpp = BytesPerPixel(aFormat);
  // Get the data pointer range considering the sampling rect offset and
  // size.
  Span<const uint8_t> range(
      map.GetData() + aSrcRect.y * size_t(stride) + aSrcRect.x * bpp,
      std::max(aSrcRect.height - 1, 0) * size_t(stride) +
          aSrcRect.width * bpp);
  texDesc.cpuData = Some(range);
  // If the stride happens to be 4 byte aligned, assume that is the
  // desired alignment regardless of format (even A8). Otherwise, we
  // default to byte alignment.
  texDesc.unpacking.alignmentInTypeElems = stride % 4 ? 1 : 4;
  texDesc.unpacking.rowLength = stride / bpp;
} else if (aZero) {
  // Create a PBO filled with zero data to initialize the texture data and
  // avoid slow initialization inside WebGL.
  MOZ_ASSERT(aSrcRect.TopLeft() == IntPoint(0, 0))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aSrcRect.TopLeft() == IntPoint(0, 0))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aSrcRect.TopLeft() == IntPoint
(0, 0)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("aSrcRect.TopLeft() == IntPoint(0, 0)", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 2053); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aSrcRect.TopLeft() == IntPoint(0, 0)"
 ")"); do { MOZ_CrashSequence(__null, 2053); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  size_t size =
      size_t(GetAlignedStride<4>(aSrcRect.width, BytesPerPixel(aFormat))) *
      aSrcRect.height;
  if (!mZeroBuffer || size > mZeroSize) {
    ClearZeroBuffer();
    mZeroBuffer = mWebgl->CreateBuffer();
    mZeroSize = size;
    mWebgl->BindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER0x88EC, mZeroBuffer);
    // WebGL will zero initialize the empty buffer, so we don't send zero data
    // explicitly.
    mWebgl->BufferData(LOCAL_GL_PIXEL_UNPACK_BUFFER0x88EC, size, nullptr,
                       LOCAL_GL_STATIC_DRAW0x88E4);
    AddUntrackedTextureMemory(mZeroBuffer);
  } else {
    mWebgl->BindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER0x88EC, mZeroBuffer);
  }
  texDesc.pboOffset = Some(0);
}
// Upload as RGBA8 to avoid swizzling during upload. Surfaces provide
// data as BGRA, but we manually swizzle that in the shader. An A8
// surface will be stored as an R8 texture that will also be swizzled
// in the shader.
GLenum intFormat =
    aFormat == SurfaceFormat::A8 ? LOCAL_GL_R80x8229 : LOCAL_GL_RGBA80x8058;
GLenum extFormat =
    aFormat == SurfaceFormat::A8 ? LOCAL_GL_RED0x1903 : LOCAL_GL_RGBA0x1908;
webgl::PackingInfo texPI = {extFormat, LOCAL_GL_UNSIGNED_BYTE0x1401};
// Do the (partial) upload for the shared or standalone texture.
if (aTex) {
  mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, aTex);
}
mWebgl->TexImage(0, aInit ? intFormat : 0,
                 {uint32_t(aDstOffset.x), uint32_t(aDstOffset.y), 0}, texPI,
                 texDesc);
if (aTex) {
  mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, mLastTexture);
}
if (!aData && aZero) {
  mWebgl->BindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER0x88EC, 0);
}
return true;
2095}

2097// Allocate a new texture handle backed by either a standalone texture or as a
2098// sub-texture of a larger shared texture.
2099already_AddRefed<TextureHandle> SharedContextWebgl::AllocateTextureHandle(
  SurfaceFormat aFormat, const IntSize& aSize, bool aAllowShared,
  bool aRenderable) {
RefPtr<TextureHandle> handle;
// Calculate the bytes that would be used by this texture handle, and prune
// enough other textures to ensure we have that much usable texture space
// available to allocate.
size_t usedBytes = BackingTexture::UsedBytes(aFormat, aSize);
PruneTextureMemory(usedBytes, false);
// The requested page size for shared textures.
int32_t pageSize = int32_t(std::min(
    StaticPrefs::gfx_canvas_accelerated_shared_page_size(), mMaxTextureSize));
if (aAllowShared && std::max(aSize.width, aSize.height) <= pageSize / 2) {
  // Ensure that the surface is no bigger than a quadrant of a shared texture
  // page. If so, try to allocate it to a shared texture. Look for any
  // existing shared texture page with a matching format and allocate
  // from that if possible.
  for (auto& shared : mSharedTextures) {
    if (shared->GetFormat() == aFormat &&
        shared->IsRenderable() == aRenderable) {
      bool wasEmpty = !shared->HasAllocatedHandles();
      handle = shared->Allocate(aSize);
      if (handle) {
        if (wasEmpty) {
          // If the page was previously empty, then deduct it from the
          // empty memory reserves.
          mEmptyTextureMemory -= shared->UsedBytes();
        }
        break;
      }
    }
  }
  // If we couldn't find an existing shared texture page with matching
  // format, then allocate a new page to put the request in.
  if (!handle) {
    if (RefPtr<WebGLTexture> tex = mWebgl->CreateTexture()) {
      RefPtr<SharedTexture> shared =
          new SharedTexture(IntSize(pageSize, pageSize), aFormat, tex);
      if (aRenderable) {
        shared->MarkRenderable();
      }
      mSharedTextures.push_back(shared);
      AddTextureMemory(shared);
      handle = shared->Allocate(aSize);
    }
  }
} else {
  // The surface wouldn't fit in a shared texture page, so we need to
  // allocate a standalone texture for it instead.
  if (RefPtr<WebGLTexture> tex = mWebgl->CreateTexture()) {
    RefPtr<StandaloneTexture> standalone =
        new StandaloneTexture(aSize, aFormat, tex);
    if (aRenderable) {
      standalone->MarkRenderable();
    }
    mStandaloneTextures.push_back(standalone);
    AddTextureMemory(standalone);
    handle = standalone;
  }
}

if (!handle) {
  return nullptr;
}

// Insert the new texture handle into the front of the MRU list and
// update used space for it.
mTextureHandles.insertFront(handle);
++mNumTextureHandles;
mUsedTextureMemory += handle->UsedBytes();

return handle.forget();
2171}

2173static inline SamplingFilter GetSamplingFilter(const Pattern& aPattern) {
return aPattern.GetType() == PatternType::SURFACE
           ? static_cast<const SurfacePattern&>(aPattern).mSamplingFilter
           : SamplingFilter::GOOD;
2177}

2179static inline bool UseNearestFilter(const Pattern& aPattern) {
return GetSamplingFilter(aPattern) == SamplingFilter::POINT;
2181}

2183// Determine if the rectangle is still axis-aligned and pixel-aligned.
2184static inline Maybe<IntRect> IsAlignedRect(bool aTransformed,
                                         const Matrix& aCurrentTransform,
                                         const Rect& aRect) {
if (!aTransformed || aCurrentTransform.HasOnlyIntegerTranslation()) {
  auto intRect = RoundedToInt(aRect);
  if (aRect.WithinEpsilonOf(Rect(intRect), 1.0e-3f)) {
    if (aTransformed) {
      intRect += RoundedToInt(aCurrentTransform.GetTranslation());
    }
    return Some(intRect);
  }
}
return Nothing();
2197}

2199Maybe<uint32_t> SharedContextWebgl::GetUniformLocation(
  const RefPtr<WebGLProgram>& aProg, const std::string& aName) const {
if (!aProg || !aProg->LinkInfo()) {
  return Nothing();
}

for (const auto& activeUniform : aProg->LinkInfo()->active.activeUniforms) {
  if (activeUniform.block_index != -1) continue;

  auto locName = activeUniform.name;
  const auto indexed = webgl::ParseIndexed(locName);
  if (indexed) {
    locName = indexed->name;
  }

  const auto baseLength = locName.size();
  for (const auto& pair : activeUniform.locByIndex) {
    if (indexed) {
      locName.erase(baseLength);  // Erase previous "[N]".
      locName += '[';
      locName += std::to_string(pair.first);
      locName += ']';
    }
    if (locName == aName || locName == aName + "[0]") {
      return Some(pair.second);
    }
  }
}

return Nothing();
2229}

2231template <class T>
2232struct IsUniformDataValT : std::false_type {};
2233template <>
2234struct IsUniformDataValT<webgl::UniformDataVal> : std::true_type {};
2235template <>
2236struct IsUniformDataValT<float> : std::true_type {};
2237template <>
2238struct IsUniformDataValT<int32_t> : std::true_type {};
2239template <>
2240struct IsUniformDataValT<uint32_t> : std::true_type {};

2242template <typename T, typename = std::enable_if_t<IsUniformDataValT<T>::value>>
2243inline Range<const webgl::UniformDataVal> AsUniformDataVal(
  const Range<const T>& data) {
return {data.begin().template ReinterpretCast<const webgl::UniformDataVal>(),
        data.end().template ReinterpretCast<const webgl::UniformDataVal>()};
2247}

2249template <class T, size_t N>
2250inline void SharedContextWebgl::UniformData(GLenum aFuncElemType,
                                          const Maybe<uint32_t>& aLoc,
                                          const Array<T, N>& aData) {
// We currently always pass false for transpose. If in the future we need
// support for transpose then caching needs to take that in to account.
mWebgl->UniformData(*aLoc, false,
                    AsUniformDataVal(Range<const T>(Span<const T>(aData))));
2257}

2259template <class T, size_t N>
2260void SharedContextWebgl::MaybeUniformData(GLenum aFuncElemType,
                                        const Maybe<uint32_t>& aLoc,
                                        const Array<T, N>& aData,
                                        Maybe<Array<T, N>>& aCached) {
if (aCached.isNothing() || !(*aCached == aData)) {
  aCached = Some(aData);
  UniformData(aFuncElemType, aLoc, aData);
}
2268}

2270inline void SharedContextWebgl::DrawQuad() {
mWebgl->DrawArraysInstanced(LOCAL_GL_TRIANGLE_FAN0x0006, 0, 4, 1);
2272}

2274void SharedContextWebgl::DrawTriangles(const PathVertexRange& aRange) {
mWebgl->DrawArraysInstanced(LOCAL_GL_TRIANGLES0x0004, GLint(aRange.mOffset),
                            GLsizei(aRange.mLength), 1);
2277}

2279// Common rectangle and pattern drawing function shared by many DrawTarget
2280// commands. If aMaskColor is specified, the provided surface pattern will be
2281// treated as a mask. If aHandle is specified, then the surface pattern's
2282// texture will be cached in the supplied handle, as opposed to using the
2283// surface's user data. If aTransformed or aClipped are false, then transforms
2284// and/or clipping will be disabled. If aAccelOnly is specified, then this
2285// function will return before it would have otherwise drawn without
2286// acceleration. If aForceUpdate is specified, then the provided texture handle
2287// will be respecified with the provided surface.
2288bool SharedContextWebgl::DrawRectAccel(
  const Rect& aRect, const Pattern& aPattern, const DrawOptions& aOptions,
  Maybe<DeviceColor> aMaskColor, RefPtr<TextureHandle>* aHandle,
  bool aTransformed, bool aClipped, bool aAccelOnly, bool aForceUpdate,
  const StrokeOptions* aStrokeOptions, const PathVertexRange* aVertexRange,
  const Matrix* aRectXform) {
// If the rect or clip rect is empty, then there is nothing to draw.
if (aRect.IsEmpty() || mClipRect.IsEmpty()) {
  return true;
}

// Check if the drawing options and the pattern support acceleration. Also
// ensure the framebuffer is prepared for drawing. If not, fall back to using
// the Skia target. When we need to forcefully update a texture, we must be
// careful to override any pattern limits, as the caller ensures the pattern
// is otherwise a supported type.
if (!SupportsDrawOptions(aOptions) ||
    (!aForceUpdate && !SupportsPattern(aPattern)) || aStrokeOptions ||
    !mCurrentTarget->MarkChanged()) {
  // If only accelerated drawing was requested, bail out without software
  // drawing fallback.
  if (!aAccelOnly) {
    MOZ_ASSERT(!aVertexRange)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aVertexRange)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aVertexRange))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("!aVertexRange",
 "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 2310);
 AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aVertexRange" ")")
; do { MOZ_CrashSequence(__null, 2310); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    mCurrentTarget->DrawRectFallback(aRect, aPattern, aOptions, aMaskColor,
                                     aTransformed, aClipped, aStrokeOptions);
  }
  return false;
}

const Matrix& currentTransform = mCurrentTarget->GetTransform();
// rectXform only applies to the rect, but should not apply to the pattern,
// as it might inadvertently alter the pattern.
Matrix rectXform = currentTransform;
if (aRectXform) {
  rectXform.PreMultiply(*aRectXform);
}

if (aOptions.mCompositionOp == CompositionOp::OP_SOURCE && aTransformed &&
    aClipped &&
    (HasClipMask() || !rectXform.PreservesAxisAlignedRectangles() ||
     !rectXform.TransformBounds(aRect).Contains(Rect(mClipAARect)) ||
     (aPattern.GetType() == PatternType::SURFACE &&
      !IsAlignedRect(aTransformed, rectXform, aRect)))) {
  // Clear outside the mask region for masks that are not bounded by clip.
  return DrawRectAccel(Rect(mClipRect), ColorPattern(DeviceColor(0, 0, 0, 0)),
                       DrawOptions(1.0f, CompositionOp::OP_SOURCE,
                                   aOptions.mAntialiasMode),
                       Nothing(), nullptr, false, aClipped, aAccelOnly) &&
         DrawRectAccel(aRect, aPattern,
                       DrawOptions(aOptions.mAlpha, CompositionOp::OP_ADD,
                                   aOptions.mAntialiasMode),
                       aMaskColor, aHandle, aTransformed, aClipped,
                       aAccelOnly, aForceUpdate, aStrokeOptions, aVertexRange,
                       aRectXform);
}
if (aOptions.mCompositionOp == CompositionOp::OP_CLEAR &&
    aPattern.GetType() == PatternType::SURFACE && !aMaskColor) {
  // If the surface being drawn with clear is not a mask, then its contents
  // needs to be ignored. Just use a color pattern instead.
  return DrawRectAccel(aRect, ColorPattern(DeviceColor(1, 1, 1, 1)), aOptions,
                       Nothing(), aHandle, aTransformed, aClipped, aAccelOnly,
                       aForceUpdate, aStrokeOptions, aVertexRange,
                       aRectXform);
}

// Set up the scissor test to reflect the clipping rectangle, if supplied.
if (!mClipRect.Contains(IntRect(IntPoint(), mViewportSize))) {
  EnableScissor(mClipRect);
} else {
  DisableScissor();
}

bool success = false;

// Now try to actually draw the pattern...
switch (aPattern.GetType()) {
  case PatternType::COLOR: {
    if (!aVertexRange) {
      // Only an uncached draw if not using the vertex cache.
      mCurrentTarget->mProfile.OnUncachedDraw();
    }
    DeviceColor color = PremultiplyColor(
        static_cast<const ColorPattern&>(aPattern).mColor, aOptions.mAlpha);
    if (((color.a == 1.0f &&
          aOptions.mCompositionOp == CompositionOp::OP_OVER) ||
         aOptions.mCompositionOp == CompositionOp::OP_SOURCE ||
         aOptions.mCompositionOp == CompositionOp::OP_CLEAR) &&
        !aStrokeOptions && !aVertexRange && !HasClipMask() &&
        mClipAARect.IsEqualEdges(Rect(mClipRect))) {
      // Certain color patterns can be mapped to scissored clears. The
      // composition op must effectively overwrite the destination, and the
      // transform must map to an axis-aligned integer rectangle.
      if (Maybe<IntRect> intRect =
              IsAlignedRect(aTransformed, rectXform, aRect)) {
        // Only use a clear if the area is larger than a quarter or the
        // viewport.
        if (intRect->Area() >=
            (mViewportSize.width / 2) * (mViewportSize.height / 2)) {
          if (!intRect->Contains(mClipRect)) {
            EnableScissor(intRect->Intersect(mClipRect));
          }
          if (aOptions.mCompositionOp == CompositionOp::OP_CLEAR) {
            color =
                PremultiplyColor(mCurrentTarget->GetClearPattern().mColor);
          }
          mWebgl->ClearColor(color.b, color.g, color.r, color.a);
          mWebgl->Clear(LOCAL_GL_COLOR_BUFFER_BIT0x00004000);
          success = true;
          break;
        }
      }
    }
    // Map the composition op to a WebGL blend mode, if possible.
    Maybe<DeviceColor> blendColor;
    if (aOptions.mCompositionOp == CompositionOp::OP_SOURCE ||
        aOptions.mCompositionOp == CompositionOp::OP_CLEAR) {
      // The source operator can support clipping and AA by emulating it with
      // the over op. Supply the color with blend state, and set the shader
      // color to white, to avoid needing dual-source blending.
      blendColor = Some(color);
      // Both source and clear operators should output a mask from the shader.
      color = DeviceColor(1, 1, 1, 1);
    }
    SetBlendState(aOptions.mCompositionOp, blendColor);
    // Since it couldn't be mapped to a scissored clear, we need to use the
    // solid color shader with supplied transform.
    if (mLastProgram != mSolidProgram) {
      mWebgl->UseProgram(mSolidProgram);
      mLastProgram = mSolidProgram;
    }
    Array<float, 2> viewportData = {float(mViewportSize.width),
                                    float(mViewportSize.height)};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mSolidProgramViewport, viewportData,
                     mSolidProgramUniformState.mViewport);

    // Generated paths provide their own AA as vertex alpha.
    Array<float, 1> aaData = {aVertexRange ? 0.0f : 1.0f};
    MaybeUniformData(LOCAL_GL_FLOAT0x1406, mSolidProgramAA, aaData,
                     mSolidProgramUniformState.mAA);

    // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel
    // boundary.
    Array<float, 4> clipData = {mClipAARect.x - 0.5f, mClipAARect.y - 0.5f,
                                mClipAARect.XMost() + 0.5f,
                                mClipAARect.YMost() + 0.5f};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mSolidProgramClipBounds, clipData,
                     mSolidProgramUniformState.mClipBounds);

    Array<float, 4> colorData = {color.b, color.g, color.r, color.a};
    Matrix xform(aRect.width, 0.0f, 0.0f, aRect.height, aRect.x, aRect.y);
    if (aTransformed) {
      xform *= rectXform;
    }
    Array<float, 6> xformData = {xform._11, xform._12, xform._21,
                                 xform._22, xform._31, xform._32};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mSolidProgramTransform, xformData,
                     mSolidProgramUniformState.mTransform);

    MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mSolidProgramColor, colorData,
                     mSolidProgramUniformState.mColor);

    // Finally draw the colored rectangle.
    if (aVertexRange) {
      // If there's a vertex range, then we need to draw triangles within from
      // generated from a path stored in the path vertex buffer.
      DrawTriangles(*aVertexRange);
    } else {
      // Otherwise we're drawing a simple filled rectangle.
      DrawQuad();
    }
    success = true;
    break;
  }
  case PatternType::SURFACE: {
    auto surfacePattern = static_cast<const SurfacePattern&>(aPattern);
    // If a texture handle was supplied, or if the surface already has an
    // assigned texture handle stashed in its used data, try to use it.
    RefPtr<SourceSurface> underlyingSurface =
        surfacePattern.mSurface
            ? surfacePattern.mSurface->GetUnderlyingSurface()
            : nullptr;
    RefPtr<TextureHandle> handle =
        aHandle
            ? aHandle->get()
            : (underlyingSurface
                   ? static_cast<TextureHandle*>(
                         underlyingSurface->GetUserData(&mTextureHandleKey))
                   : nullptr);
    IntSize texSize;
    IntPoint offset;
    SurfaceFormat format;
    // Check if the found handle is still valid and if its sampling rect
    // matches the requested sampling rect.
    if (handle && handle->IsValid() &&
        (surfacePattern.mSamplingRect.IsEmpty() ||
         handle->GetSamplingRect().IsEqualEdges(
             surfacePattern.mSamplingRect)) &&
        (surfacePattern.mExtendMode == ExtendMode::CLAMP ||
         handle->GetType() == TextureHandle::STANDALONE)) {
      texSize = handle->GetSize();
      format = handle->GetFormat();
      offset = handle->GetSamplingOffset();
    } else {
      // Otherwise, there is no handle that can be used yet, so extract
      // information from the surface pattern.
      handle = nullptr;
      if (!underlyingSurface) {
        // If there was no actual surface supplied, then we tried to draw
        // using a texture handle, but the texture handle wasn't valid.
        break;
      }
      texSize = underlyingSurface->GetSize();
      format = underlyingSurface->GetFormat();
      if (!surfacePattern.mSamplingRect.IsEmpty()) {
        texSize = surfacePattern.mSamplingRect.Size();
        offset = surfacePattern.mSamplingRect.TopLeft();
      }
    }

    // We need to be able to transform from local space into texture space.
    Matrix invMatrix = surfacePattern.mMatrix;
    // Determine if the requested surface itself is offset from the underlying
    // surface.
    if (surfacePattern.mSurface) {
      invMatrix.PreTranslate(surfacePattern.mSurface->GetRect().TopLeft());
    }
    // If drawing a pre-transformed vertex range, then we need to ensure the
    // user-space pattern is still transformed to screen-space.
    if (aVertexRange && !aTransformed) {
      invMatrix *= currentTransform;
    }
    if (!invMatrix.Invert()) {
      break;
    }
    if (aRectXform) {
      // If there is aRectXform, it must be applied to the source rectangle to
      // generate the proper input coordinates for the inverse pattern matrix.
      invMatrix.PreMultiply(*aRectXform);
    }

    RefPtr<WebGLTexture> tex;
    IntRect bounds;
    IntSize backingSize;
    RefPtr<DataSourceSurface> data;
    if (handle) {
      if (aForceUpdate) {
        data = underlyingSurface->GetDataSurface();
        if (!data) {
          break;
        }
        // The size of the texture may change if we update contents.
        mUsedTextureMemory -= handle->UsedBytes();
        handle->UpdateSize(texSize);
        mUsedTextureMemory += handle->UsedBytes();
        handle->SetSamplingOffset(surfacePattern.mSamplingRect.TopLeft());
      }
      // If using an existing handle, move it to the front of the MRU list.
      handle->remove();
      mTextureHandles.insertFront(handle);
    } else if ((tex = GetCompatibleSnapshot(underlyingSurface))) {
      backingSize = underlyingSurface->GetSize();
      bounds = IntRect(offset, texSize);
      // Count reusing a snapshot texture (no readback) as a cache hit.
      mCurrentTarget->mProfile.OnCacheHit();
    } else {
      // If we get here, we need a data surface for a texture upload.
      data = underlyingSurface->GetDataSurface();
      if (!data) {
        break;
      }
      // There is no existing handle. Try to allocate a new one. If the
      // surface size may change via a forced update, then don't allocate
      // from a shared texture page.
      handle = AllocateTextureHandle(
          format, texSize,
          !aForceUpdate && surfacePattern.mExtendMode == ExtendMode::CLAMP);
      if (!handle) {
        MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 2565); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { MOZ_CrashSequence(__null, 2565); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
        break;
      }
      // Link the handle to the surface's user data.
      handle->SetSamplingOffset(surfacePattern.mSamplingRect.TopLeft());
      if (aHandle) {
        *aHandle = handle;
      } else {
        handle->SetSurface(underlyingSurface);
        underlyingSurface->AddUserData(&mTextureHandleKey, handle.get(),
                                       nullptr);
      }
    }

    // Map the composition op to a WebGL blend mode, if possible. If there is
    // a mask color and a texture with multiple channels, assume subpixel
    // blending. If we encounter the source op here, then assume the surface
    // is opaque (non-opaque is handled above) and emulate it with over.
    SetBlendState(aOptions.mCompositionOp,
                  format != SurfaceFormat::A8 ? aMaskColor : Nothing());
    // Switch to the image shader and set up relevant transforms.
    if (mLastProgram != mImageProgram) {
      mWebgl->UseProgram(mImageProgram);
      mLastProgram = mImageProgram;
    }

    Array<float, 2> viewportData = {float(mViewportSize.width),
                                    float(mViewportSize.height)};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mImageProgramViewport, viewportData,
                     mImageProgramUniformState.mViewport);

    // AA is not supported for OP_SOURCE. Generated paths provide their own
    // AA as vertex alpha.
    Array<float, 1> aaData = {
        mLastCompositionOp == CompositionOp::OP_SOURCE || aVertexRange
            ? 0.0f
            : 1.0f};
    MaybeUniformData(LOCAL_GL_FLOAT0x1406, mImageProgramAA, aaData,
                     mImageProgramUniformState.mAA);

    // Offset the clip AA bounds by 0.5 to ensure AA falls to 0 at pixel
    // boundary.
    Array<float, 4> clipData = {mClipAARect.x - 0.5f, mClipAARect.y - 0.5f,
                                mClipAARect.XMost() + 0.5f,
                                mClipAARect.YMost() + 0.5f};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mImageProgramClipBounds, clipData,
                     mImageProgramUniformState.mClipBounds);

    DeviceColor color =
        mLastCompositionOp == CompositionOp::OP_CLEAR
            ? DeviceColor(1, 1, 1, 1)
            : PremultiplyColor(
                  aMaskColor && format != SurfaceFormat::A8
                      ? DeviceColor::Mask(1.0f, aMaskColor->a)
                      : aMaskColor.valueOr(DeviceColor(1, 1, 1, 1)),
                  aOptions.mAlpha);
    Array<float, 4> colorData = {color.b, color.g, color.r, color.a};
    Array<float, 1> swizzleData = {format == SurfaceFormat::A8 ? 1.0f : 0.0f};
    Matrix xform(aRect.width, 0.0f, 0.0f, aRect.height, aRect.x, aRect.y);
    if (aTransformed) {
      xform *= rectXform;
    }
    Array<float, 6> xformData = {xform._11, xform._12, xform._21,
                                 xform._22, xform._31, xform._32};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mImageProgramTransform, xformData,
                     mImageProgramUniformState.mTransform);

    MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mImageProgramColor, colorData,
                     mImageProgramUniformState.mColor);

    MaybeUniformData(LOCAL_GL_FLOAT0x1406, mImageProgramSwizzle, swizzleData,
                     mImageProgramUniformState.mSwizzle);

    // Start binding the WebGL state for the texture.
    BackingTexture* backing = nullptr;
    if (handle) {
      backing = handle->GetBackingTexture();
      if (!tex) {
        tex = backing->GetWebGLTexture();
      }
      bounds = handle->GetBounds();
      backingSize = backing->GetSize();
    }
    if (mLastTexture != tex) {
      mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, tex);
      mLastTexture = tex;
    }

    if (backing && !backing->IsInitialized()) {
      // If this is the first time the texture is used, we need to initialize
      // the clamping and filtering state.
      backing->MarkInitialized();
      InitTexParameters(tex);
      if (texSize != backingSize) {
        // If this is a shared texture handle whose actual backing texture is
        // larger than it, then we need to allocate the texture page to the
        // full backing size before we can do a partial upload of the surface.
        UploadSurface(nullptr, format, IntRect(IntPoint(), backingSize),
                      IntPoint(), true, true);
      }
    }

    if (data) {
      UploadSurface(data, format, IntRect(offset, texSize), bounds.TopLeft(),
                    texSize == backingSize);
      // Signal that we had to upload new data to the texture cache.
      mCurrentTarget->mProfile.OnCacheMiss();
    } else {
      // Signal that we are reusing data from the texture cache.
      mCurrentTarget->mProfile.OnCacheHit();
    }

    // Set up the texture coordinate matrix to map from the input rectangle to
    // the backing texture subrect.
    Size backingSizeF(backingSize);
    Matrix uvMatrix(aRect.width, 0.0f, 0.0f, aRect.height, aRect.x, aRect.y);
    uvMatrix *= invMatrix;
    uvMatrix *= Matrix(1.0f / backingSizeF.width, 0.0f, 0.0f,
                       1.0f / backingSizeF.height,
                       float(bounds.x - offset.x) / backingSizeF.width,
                       float(bounds.y - offset.y) / backingSizeF.height);
    Array<float, 6> uvData = {uvMatrix._11, uvMatrix._12, uvMatrix._21,
                              uvMatrix._22, uvMatrix._31, uvMatrix._32};
    MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mImageProgramTexMatrix, uvData,
                     mImageProgramUniformState.mTexMatrix);

    // Clamp sampling to within the bounds of the backing texture subrect.
    Array<float, 4> texBounds = {
        (bounds.x + 0.5f) / backingSizeF.width,
        (bounds.y + 0.5f) / backingSizeF.height,
        (bounds.XMost() - 0.5f) / backingSizeF.width,
        (bounds.YMost() - 0.5f) / backingSizeF.height,
    };
    switch (surfacePattern.mExtendMode) {
      case ExtendMode::REPEAT:
        texBounds[0] = -1e16f;
        texBounds[1] = -1e16f;
        texBounds[2] = 1e16f;
        texBounds[3] = 1e16f;
        break;
      case ExtendMode::REPEAT_X:
        texBounds[0] = -1e16f;
        texBounds[2] = 1e16f;
        break;
      case ExtendMode::REPEAT_Y:
        texBounds[1] = -1e16f;
        texBounds[3] = 1e16f;
        break;
      default:
        break;
    }
    MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mImageProgramTexBounds, texBounds,
                     mImageProgramUniformState.mTexBounds);

    // Ensure we use nearest filtering when no antialiasing is requested.
    if (UseNearestFilter(surfacePattern)) {
      SetTexFilter(tex, false);
    }

    // Finally draw the image rectangle.
    if (aVertexRange) {
      // If there's a vertex range, then we need to draw triangles within from
      // generated from a path stored in the path vertex buffer.
      DrawTriangles(*aVertexRange);
    } else {
      // Otherwise we're drawing a simple filled rectangle.
      DrawQuad();
    }

    // Restore the default linear filter if overridden.
    if (UseNearestFilter(surfacePattern)) {
      SetTexFilter(tex, true);
    }

    success = true;
    break;
  }
  default:
    gfxWarningmozilla::gfx::WarningLog() << "Unknown DrawTargetWebgl::DrawRect pattern type: "
                 << (int)aPattern.GetType();
    break;
}

return success;
2749}

2751bool SharedContextWebgl::RemoveSharedTexture(
  const RefPtr<SharedTexture>& aTexture) {
auto pos =
    std::find(mSharedTextures.begin(), mSharedTextures.end(), aTexture);
if (pos == mSharedTextures.end()) {
  return false;
}
// Keep around a reserve of empty pages to avoid initialization costs from
// allocating shared pages. If still below the limit of reserved pages, then
// just add it to the reserve. Otherwise, erase the empty texture page.
size_t maxBytes = StaticPrefs::gfx_canvas_accelerated_reserve_empty_cache()
                  << 20;
size_t totalEmpty = mEmptyTextureMemory + aTexture->UsedBytes();
if (totalEmpty <= maxBytes) {
  mEmptyTextureMemory = totalEmpty;
} else {
  RemoveTextureMemory(aTexture);
  mSharedTextures.erase(pos);
  ClearLastTexture();
}
return true;
2772}

2774void SharedTextureHandle::Cleanup(SharedContextWebgl& aContext) {
mTexture->Free(*this);

// Check if the shared handle's owning page has no more allocated handles
// after we freed it. If so, remove the empty shared texture page also.
if (!mTexture->HasAllocatedHandles()) {
  aContext.RemoveSharedTexture(mTexture);
}
2782}

2784bool SharedContextWebgl::RemoveStandaloneTexture(
  const RefPtr<StandaloneTexture>& aTexture) {
auto pos = std::find(mStandaloneTextures.begin(), mStandaloneTextures.end(),
                     aTexture);
if (pos == mStandaloneTextures.end()) {
  return false;
}
RemoveTextureMemory(aTexture);
mStandaloneTextures.erase(pos);
ClearLastTexture();
return true;
2795}

2797void StandaloneTexture::Cleanup(SharedContextWebgl& aContext) {
aContext.RemoveStandaloneTexture(this);
2799}

2801// Prune a given texture handle and release its associated resources.
2802void SharedContextWebgl::PruneTextureHandle(
  const RefPtr<TextureHandle>& aHandle) {
// Invalidate the handle so nothing will subsequently use its contents.
aHandle->Invalidate();
// If the handle has an associated SourceSurface, unlink it.
UnlinkSurfaceTexture(aHandle);
// If the handle has an associated CacheEntry, unlink it.
if (RefPtr<CacheEntry> entry = aHandle->GetCacheEntry()) {
  entry->Unlink();
}
// Deduct the used space from the total.
mUsedTextureMemory -= aHandle->UsedBytes();
// Ensure any allocated shared or standalone texture regions get freed.
aHandle->Cleanup(*this);
2816}

2818// Prune any texture memory above the limit (or margin below the limit) or any
2819// least-recently-used handles that are no longer associated with any usable
2820// surface.
2821bool SharedContextWebgl::PruneTextureMemory(size_t aMargin, bool aPruneUnused) {
// The maximum amount of texture memory that may be used by textures.
size_t maxBytes = StaticPrefs::gfx_canvas_accelerated_cache_size() << 20;
maxBytes -= std::min(maxBytes, aMargin);
size_t maxItems = StaticPrefs::gfx_canvas_accelerated_cache_items();
size_t oldItems = mNumTextureHandles;
while (!mTextureHandles.isEmpty() &&
       (mUsedTextureMemory > maxBytes || mNumTextureHandles > maxItems ||
        (aPruneUnused && !mTextureHandles.getLast()->IsUsed()))) {
  PruneTextureHandle(mTextureHandles.popLast());
  --mNumTextureHandles;
}
return mNumTextureHandles < oldItems;
2834}

2836// Attempt to convert a linear gradient to a 1D ramp texture.
2837Maybe<SurfacePattern> DrawTargetWebgl::LinearGradientToSurface(
  const RectDouble& aBounds, const Pattern& aPattern) {
MOZ_ASSERT(aPattern.GetType() == PatternType::LINEAR_GRADIENT)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPattern.GetType() == PatternType::LINEAR_GRADIENT)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(aPattern.GetType() == PatternType::LINEAR_GRADIENT))
), 0))) { do { } while (false); MOZ_ReportAssertionFailure("aPattern.GetType() == PatternType::LINEAR_GRADIENT"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 2839)
; AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPattern.GetType() == PatternType::LINEAR_GRADIENT"
 ")"); do { MOZ_CrashSequence(__null, 2839); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
const auto& gradient = static_cast<const LinearGradientPattern&>(aPattern);
// The gradient points must be transformed by the gradient's matrix.
Point gradBegin = gradient.mMatrix.TransformPoint(gradient.mBegin);
Point gradEnd = gradient.mMatrix.TransformPoint(gradient.mEnd);
// Get the gradient points in user-space.
Point begin = mTransform.TransformPoint(gradBegin);
Point end = mTransform.TransformPoint(gradEnd);
// Find the normalized direction of the gradient and its length.
Point dir = end - begin;
float len = dir.Length();
dir = dir / len;
// Restrict the rendered bounds to fall within the canvas.
Rect visBounds = NarrowToFloat(aBounds.SafeIntersect(RectDouble(GetRect())));
// Calculate the distances along the gradient direction of the bounds.
float dist0 = (visBounds.TopLeft() - begin).DotProduct(dir);
float distX = visBounds.width * dir.x;
float distY = visBounds.height * dir.y;
float minDist = floorf(
    std::max(dist0 + std::min(distX, 0.0f) + std::min(distY, 0.0f), 0.0f));
float maxDist = ceilf(
    std::min(dist0 + std::max(distX, 0.0f) + std::max(distY, 0.0f), len));
// Calculate the approximate size of the ramp texture, and see if it would be
// sufficiently smaller than just rendering the primitive.
float subLen = maxDist - minDist;
if (subLen > 0 && subLen < 0.5f * visBounds.Area()) {
  // Create a 1D texture to contain the gradient ramp. Reserve two extra
  // texels at the beginning and end of the ramp to account for clamping.
  RefPtr<DrawTargetSkia> dt = new DrawTargetSkia;
  if (dt->Init(IntSize(int32_t(subLen + 2), 1), SurfaceFormat::B8G8R8A8)) {
    // Fill the section of the gradient ramp that is actually used.
    dt->FillRect(Rect(dt->GetRect()),
                 LinearGradientPattern(Point(1 - minDist, 0.0f),
                                       Point(len + 1 - minDist, 0.0f),
                                       gradient.mStops));
    if (RefPtr<SourceSurface> snapshot = dt->Snapshot()) {
      // Calculate a matrix that will map the gradient ramp texture onto the
      // actual direction of the gradient.
      Point gradDir = (gradEnd - gradBegin) / len;
      Point tangent = Point(-gradDir.y, gradDir.x) / gradDir.Length();
      SurfacePattern surfacePattern(
          snapshot, ExtendMode::CLAMP,
          Matrix(gradDir.x, gradDir.y, tangent.x, tangent.y, gradBegin.x,
                 gradBegin.y)
              .PreTranslate(minDist - 1, 0));
      if (SupportsPattern(surfacePattern)) {
        return Some(surfacePattern);
      }
    }
  }
}
return Nothing();
2891}

2893void DrawTargetWebgl::FillRect(const Rect& aRect, const Pattern& aPattern,
                             const DrawOptions& aOptions) {
RectDouble xformRect = TransformDouble(aRect);
if (aPattern.GetType() == PatternType::COLOR) {
  if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
    // If the pattern is transform-invariant and the rect clips to the
    // viewport, just clip drawing to the viewport to avoid transform
    // issues.
    DrawRect(*clipped, aPattern, aOptions, Nothing(), nullptr, false);
    return;
  }
}
if (RectInsidePrecisionLimits(xformRect)) {
  if (SupportsPattern(aPattern)) {
    DrawRect(aRect, aPattern, aOptions);
    return;
  }
  if (aPattern.GetType() == PatternType::LINEAR_GRADIENT) {
    if (Maybe<SurfacePattern> surface =
            LinearGradientToSurface(xformRect, aPattern)) {
      if (DrawRect(aRect, *surface, aOptions, Nothing(), nullptr, true, true,
                   true)) {
        return;
      }
    }
  }
}

if (!mWebglValid) {
  MarkSkiaChanged(aOptions);
  mSkia->FillRect(aRect, aPattern, aOptions);
} else {
  // If the pattern is unsupported, then transform the rect to a path so it
  // can be cached.
  SkPath skiaPath;
  skiaPath.addRect(RectToSkRect(aRect));
  RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
  DrawPath(path, aPattern, aOptions);
}
2932}

2934void CacheEntry::Link(const RefPtr<TextureHandle>& aHandle) {
mHandle = aHandle;
mHandle->SetCacheEntry(this);
2937}

2939// When the CacheEntry becomes unused, it marks the corresponding
2940// TextureHandle as unused and unlinks it from the CacheEntry. The
2941// entry is removed from its containing Cache, if applicable.
2942void CacheEntry::Unlink() {
// The entry may not have a valid handle if rasterization failed.
if (mHandle) {
8
←
Taking false branch→
  mHandle->SetCacheEntry(nullptr);
  mHandle = nullptr;
}

RemoveFromList();
9
←
Calling 'CacheEntryImpl::RemoveFromList'→
27
←
Returning; memory was released→
2950}

2952// Hashes a path and pattern to a single hash value that can be used for quick
2953// comparisons. This currently avoids to expensive hashing of internal path
2954// and pattern data for speed, relying instead on later exact comparisons for
2955// disambiguation.
2956HashNumber PathCacheEntry::HashPath(const QuantizedPath& aPath,
                                  const Pattern* aPattern,
                                  const Matrix& aTransform,
                                  const IntRect& aBounds,
                                  const Point& aOrigin) {
HashNumber hash = 0;
hash = AddToHash(hash, aPath.mPath.num_types);
hash = AddToHash(hash, aPath.mPath.num_points);
if (aPath.mPath.num_points > 0) {
  hash = AddToHash(hash, aPath.mPath.points[0].x);
  hash = AddToHash(hash, aPath.mPath.points[0].y);
  if (aPath.mPath.num_points > 1) {
    hash = AddToHash(hash, aPath.mPath.points[1].x);
    hash = AddToHash(hash, aPath.mPath.points[1].y);
  }
}
// Quantize the relative offset of the path to its bounds.
IntPoint offset = RoundedToInt((aOrigin - Point(aBounds.TopLeft())) * 16.0f);
hash = AddToHash(hash, offset.x);
hash = AddToHash(hash, offset.y);
hash = AddToHash(hash, aBounds.width);
hash = AddToHash(hash, aBounds.height);
if (aPattern) {
  hash = AddToHash(hash, (int)aPattern->GetType());
}
return hash;
2982}

2984// When caching rendered geometry, we need to ensure the scale and orientation
2985// is approximately the same. The offset will be considered separately.
2986static inline bool HasMatchingScale(const Matrix& aTransform1,
                                  const Matrix& aTransform2) {
return FuzzyEqual(aTransform1._11, aTransform2._11) &&
       FuzzyEqual(aTransform1._22, aTransform2._22) &&
       FuzzyEqual(aTransform1._12, aTransform2._12) &&
       FuzzyEqual(aTransform1._21, aTransform2._21);
2992}

2994// Determines if an existing path cache entry matches an incoming path and
2995// pattern.
2996inline bool PathCacheEntry::MatchesPath(
  const QuantizedPath& aPath, const Pattern* aPattern,
  const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
  const Matrix& aTransform, const IntRect& aBounds, const Point& aOrigin,
  HashNumber aHash, float aSigma) {
return aHash == mHash && HasMatchingScale(aTransform, mTransform) &&
       // Ensure the clipped relative bounds fit inside those of the entry
       aBounds.x - aOrigin.x >= mBounds.x - mOrigin.x &&
       (aBounds.x - aOrigin.x) + aBounds.width <=
           (mBounds.x - mOrigin.x) + mBounds.width &&
       aBounds.y - aOrigin.y >= mBounds.y - mOrigin.y &&
       (aBounds.y - aOrigin.y) + aBounds.height <=
           (mBounds.y - mOrigin.y) + mBounds.height &&
       aPath == mPath &&
       (!aPattern ? !mPattern : mPattern && *aPattern == *mPattern) &&
       (!aStrokeOptions
            ? !mStrokeOptions
            : mStrokeOptions && *aStrokeOptions == *mStrokeOptions &&
                  mAAStrokeMode == aStrokeMode) &&
       aSigma == mSigma;
3016}

3018PathCacheEntry::PathCacheEntry(QuantizedPath&& aPath, Pattern* aPattern,
                             StoredStrokeOptions* aStrokeOptions,
                             AAStrokeMode aStrokeMode,
                             const Matrix& aTransform, const IntRect& aBounds,
                             const Point& aOrigin, HashNumber aHash,
                             float aSigma)
  : CacheEntryImpl<PathCacheEntry>(aTransform, aBounds, aHash),
    mPath(std::move(aPath)),
    mOrigin(aOrigin),
    mPattern(aPattern),
    mStrokeOptions(aStrokeOptions),
    mAAStrokeMode(aStrokeMode),
    mSigma(aSigma) {}

3032// Attempt to find a matching entry in the path cache. If one isn't found,
3033// a new entry will be created. The caller should check whether the contained
3034// texture handle is valid to determine if it will need to render the text run
3035// or just reuse the cached texture.
3036already_AddRefed<PathCacheEntry> PathCache::FindOrInsertEntry(
  QuantizedPath aPath, const Pattern* aPattern,
  const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
  const Matrix& aTransform, const IntRect& aBounds, const Point& aOrigin,
  float aSigma) {
HashNumber hash =
    PathCacheEntry::HashPath(aPath, aPattern, aTransform, aBounds, aOrigin);
for (const RefPtr<PathCacheEntry>& entry : GetChain(hash)) {
  if (entry->MatchesPath(aPath, aPattern, aStrokeOptions, aStrokeMode,
                         aTransform, aBounds, aOrigin, hash, aSigma)) {
    return do_AddRef(entry);
  }
}
Pattern* pattern = nullptr;
if (aPattern) {
  pattern = aPattern->CloneWeak();
  if (!pattern) {
    return nullptr;
  }
}
StoredStrokeOptions* strokeOptions = nullptr;
if (aStrokeOptions) {
  strokeOptions = aStrokeOptions->Clone();
  if (!strokeOptions) {
    return nullptr;
  }
}
RefPtr<PathCacheEntry> entry =
    new PathCacheEntry(std::move(aPath), pattern, strokeOptions, aStrokeMode,
                       aTransform, aBounds, aOrigin, hash, aSigma);
Insert(entry);
return entry.forget();
3068}

3070void DrawTargetWebgl::Fill(const Path* aPath, const Pattern& aPattern,
                         const DrawOptions& aOptions) {
if (!aPath || aPath->GetBackendType() != BackendType::SKIA) {
  return;
}

const SkPath& skiaPath = static_cast<const PathSkia*>(aPath)->GetPath();
SkRect skiaRect = SkRect::MakeEmpty();
// Draw the path as a simple rectangle with a supported pattern when possible.
if (skiaPath.isRect(&skiaRect)) {
  RectDouble rect = SkRectToRectDouble(skiaRect);
  RectDouble xformRect = TransformDouble(rect);
  if (aPattern.GetType() == PatternType::COLOR) {
    if (Maybe<Rect> clipped = RectClippedToViewport(xformRect)) {
      // If the pattern is transform-invariant and the rect clips to the
      // viewport, just clip drawing to the viewport to avoid transform
      // issues.
      DrawRect(*clipped, aPattern, aOptions, Nothing(), nullptr, false);
      return;
    }
  }

  if (RectInsidePrecisionLimits(xformRect)) {
    if (SupportsPattern(aPattern)) {
      DrawRect(NarrowToFloat(rect), aPattern, aOptions);
      return;
    }
    if (aPattern.GetType() == PatternType::LINEAR_GRADIENT) {
      if (Maybe<SurfacePattern> surface =
              LinearGradientToSurface(xformRect, aPattern)) {
        if (DrawRect(NarrowToFloat(rect), *surface, aOptions, Nothing(),
                     nullptr, true, true, true)) {
          return;
        }
      }
    }
  }
}

DrawPath(aPath, aPattern, aOptions);
3110}

3112void DrawTargetWebgl::FillCircle(const Point& aOrigin, float aRadius,
                               const Pattern& aPattern,
                               const DrawOptions& aOptions) {
DrawCircle(aOrigin, aRadius, aPattern, aOptions);
3116}

3118QuantizedPath::QuantizedPath(const WGR::Path& aPath) : mPath(aPath) {}

3120QuantizedPath::QuantizedPath(QuantizedPath&& aPath) noexcept
  : mPath(aPath.mPath) {
aPath.mPath.points = nullptr;
aPath.mPath.num_points = 0;
aPath.mPath.types = nullptr;
aPath.mPath.num_types = 0;
3126}

3128QuantizedPath::~QuantizedPath() {
if (mPath.points || mPath.types) {
  WGR::wgr_path_release(mPath);
}
3132}

3134bool QuantizedPath::operator==(const QuantizedPath& aOther) const {
return mPath.num_types == aOther.mPath.num_types &&
       mPath.num_points == aOther.mPath.num_points &&
       mPath.fill_mode == aOther.mPath.fill_mode &&
       !memcmp(mPath.types, aOther.mPath.types,
               mPath.num_types * sizeof(uint8_t)) &&
       !memcmp(mPath.points, aOther.mPath.points,
               mPath.num_points * sizeof(WGR::Point));
3142}

3144// Generate a quantized path from the Skia path using WGR. The supplied
3145// transform will be applied to the path. The path is stored relative to its
3146// bounds origin to support translation later.
3147static Maybe<QuantizedPath> GenerateQuantizedPath(
  WGR::PathBuilder* aPathBuilder, const SkPath& aPath, const Rect& aBounds,
  const Matrix& aTransform) {
if (!aPathBuilder) {
  return Nothing();
}

WGR::wgr_builder_reset(aPathBuilder);
WGR::wgr_builder_set_fill_mode(aPathBuilder,
                               aPath.getFillType() == SkPathFillType::kWinding
                                   ? WGR::FillMode::Winding
                                   : WGR::FillMode::EvenOdd);

SkPath::RawIter iter(aPath);
SkPoint params[4];
SkPath::Verb currentVerb;

// printf_stderr("bounds: (%d, %d) %d x %d\n", aBounds.x, aBounds.y,
// aBounds.width, aBounds.height);
Matrix transform = aTransform;
transform.PostTranslate(-aBounds.TopLeft());
while ((currentVerb = iter.next(params)) != SkPath::kDone_Verb) {
  switch (currentVerb) {
    case SkPath::kMove_Verb: {
      Point p0 = transform.TransformPoint(SkPointToPoint(params[0]));
      WGR::wgr_builder_move_to(aPathBuilder, p0.x, p0.y);
      break;
    }
    case SkPath::kLine_Verb: {
      Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
      WGR::wgr_builder_line_to(aPathBuilder, p1.x, p1.y);
      break;
    }
    case SkPath::kCubic_Verb: {
      Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
      Point p2 = transform.TransformPoint(SkPointToPoint(params[2]));
      Point p3 = transform.TransformPoint(SkPointToPoint(params[3]));
      // printf_stderr("cubic (%f, %f), (%f, %f), (%f, %f)\n", p1.x, p1.y,
      // p2.x, p2.y, p3.x, p3.y);
      WGR::wgr_builder_curve_to(aPathBuilder, p1.x, p1.y, p2.x, p2.y, p3.x,
                                p3.y);
      break;
    }
    case SkPath::kQuad_Verb: {
      Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
      Point p2 = transform.TransformPoint(SkPointToPoint(params[2]));
      // printf_stderr("quad (%f, %f), (%f, %f)\n", p1.x, p1.y, p2.x, p2.y);
      WGR::wgr_builder_quad_to(aPathBuilder, p1.x, p1.y, p2.x, p2.y);
      break;
    }
    case SkPath::kConic_Verb: {
      Point p0 = transform.TransformPoint(SkPointToPoint(params[0]));
      Point p1 = transform.TransformPoint(SkPointToPoint(params[1]));
      Point p2 = transform.TransformPoint(SkPointToPoint(params[2]));
      float w = iter.conicWeight();
      std::vector<Point> quads;
      int numQuads = ConvertConicToQuads(p0, p1, p2, w, quads);
      for (int i = 0; i < numQuads; i++) {
        Point q1 = quads[2 * i + 1];
        Point q2 = quads[2 * i + 2];
        // printf_stderr("conic quad (%f, %f), (%f, %f)\n", q1.x, q1.y, q2.x,
        // q2.y);
        WGR::wgr_builder_quad_to(aPathBuilder, q1.x, q1.y, q2.x, q2.y);
      }
      break;
    }
    case SkPath::kClose_Verb:
      // printf_stderr("close\n");
      WGR::wgr_builder_close(aPathBuilder);
      break;
    default:
      MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 3218); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { MOZ_CrashSequence(__null, 3218); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
      // Unexpected verb found in path!
      return Nothing();
  }
}

WGR::Path p = WGR::wgr_builder_get_path(aPathBuilder);
if (!p.num_points || !p.num_types) {
  WGR::wgr_path_release(p);
  return Nothing();
}
return Some(QuantizedPath(p));
3230}

3232// Get the output vertex buffer using WGR from an input quantized path.
3233static Maybe<WGR::VertexBuffer> GeneratePathVertexBuffer(
  const QuantizedPath& aPath, const IntRect& aClipRect,
  bool aRasterizationTruncates, WGR::OutputVertex* aBuffer,
  size_t aBufferCapacity) {
WGR::VertexBuffer vb = WGR::wgr_path_rasterize_to_tri_list(
    &aPath.mPath, aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height,
    true, false, aRasterizationTruncates, aBuffer, aBufferCapacity);
if (!vb.len || (aBuffer && vb.len > aBufferCapacity)) {
  WGR::wgr_vertex_buffer_release(vb);
  return Nothing();
}
return Some(vb);
3245}

3247static inline AAStroke::LineJoin ToAAStrokeLineJoin(JoinStyle aJoin) {
switch (aJoin) {
  case JoinStyle::BEVEL:
    return AAStroke::LineJoin::Bevel;
  case JoinStyle::ROUND:
    return AAStroke::LineJoin::Round;
  case JoinStyle::MITER:
  case JoinStyle::MITER_OR_BEVEL:
    return AAStroke::LineJoin::Miter;
}
return AAStroke::LineJoin::Miter;
3258}

3260static inline AAStroke::LineCap ToAAStrokeLineCap(CapStyle aCap) {
switch (aCap) {
  case CapStyle::BUTT:
    return AAStroke::LineCap::Butt;
  case CapStyle::ROUND:
    return AAStroke::LineCap::Round;
  case CapStyle::SQUARE:
    return AAStroke::LineCap::Square;
}
return AAStroke::LineCap::Butt;
3270}

3272static inline Point WGRPointToPoint(const WGR::Point& aPoint) {
// WGR points are 28.4 fixed-point where (0.0, 0.0) is assumed to be a pixel
// center, as opposed to (0.5, 0.5) in canvas device space. WGR thus shifts
// each point by (-0.5, -0.5). To undo this, transform from fixed-point back
// to floating-point, and reverse the pixel shift by adding back (0.5, 0.5).
return Point(IntPoint(aPoint.x, aPoint.y)) * (1.0f / 16.0f) +
       Point(0.5f, 0.5f);
3279}

3281// Generates a vertex buffer for a stroked path using aa-stroke.
3282static Maybe<AAStroke::VertexBuffer> GenerateStrokeVertexBuffer(
  const QuantizedPath& aPath, const StrokeOptions* aStrokeOptions,
  float aScale, WGR::OutputVertex* aBuffer, size_t aBufferCapacity) {
AAStroke::StrokeStyle style = {aStrokeOptions->mLineWidth * aScale,
                               ToAAStrokeLineCap(aStrokeOptions->mLineCap),
                               ToAAStrokeLineJoin(aStrokeOptions->mLineJoin),
                               aStrokeOptions->mMiterLimit};
if (style.width <= 0.0f || !std::isfinite(style.width) ||
    style.miter_limit <= 0.0f || !std::isfinite(style.miter_limit)) {
  return Nothing();
}
AAStroke::Stroker* s = AAStroke::aa_stroke_new(
    &style, (AAStroke::OutputVertex*)aBuffer, aBufferCapacity);
bool valid = true;
size_t curPoint = 0;
for (size_t curType = 0; valid && curType < aPath.mPath.num_types;) {
  // Verify that we are at the start of a sub-path.
  if ((aPath.mPath.types[curType] & WGR::PathPointTypePathTypeMask) !=
      WGR::PathPointTypeStart) {
    valid = false;
    break;
  }
  // Find where the next sub-path starts so we can locate the end.
  size_t endType = curType + 1;
  for (; endType < aPath.mPath.num_types; endType++) {
    if ((aPath.mPath.types[endType] & WGR::PathPointTypePathTypeMask) ==
        WGR::PathPointTypeStart) {
      break;
    }
  }
  // Check if the path is closed. This is a flag modifying the last type.
  bool closed =
      (aPath.mPath.types[endType - 1] & WGR::PathPointTypeCloseSubpath) != 0;
  for (; curType < endType; curType++) {
    // If this is the last type and the sub-path is not closed, determine if
    // this segment should be capped.
    bool end = curType + 1 == endType && !closed;
    switch (aPath.mPath.types[curType] & WGR::PathPointTypePathTypeMask) {
      case WGR::PathPointTypeStart: {
        if (curPoint + 1 > aPath.mPath.num_points) {
          valid = false;
          break;
        }
        Point p1 = WGRPointToPoint(aPath.mPath.points[curPoint]);
        AAStroke::aa_stroke_move_to(s, p1.x, p1.y, closed);
        if (end) {
          AAStroke::aa_stroke_line_to(s, p1.x, p1.y, true);
        }
        curPoint++;
        break;
      }
      case WGR::PathPointTypeLine: {
        if (curPoint + 1 > aPath.mPath.num_points) {
          valid = false;
          break;
        }
        Point p1 = WGRPointToPoint(aPath.mPath.points[curPoint]);
        AAStroke::aa_stroke_line_to(s, p1.x, p1.y, end);
        curPoint++;
        break;
      }
      case WGR::PathPointTypeBezier: {
        if (curPoint + 3 > aPath.mPath.num_points) {
          valid = false;
          break;
        }
        Point p1 = WGRPointToPoint(aPath.mPath.points[curPoint]);
        Point p2 = WGRPointToPoint(aPath.mPath.points[curPoint + 1]);
        Point p3 = WGRPointToPoint(aPath.mPath.points[curPoint + 2]);
        AAStroke::aa_stroke_curve_to(s, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y,
                                     end);
        curPoint += 3;
        break;
      }
      default:
        MOZ_ASSERT(false, "Unknown WGR path point type")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "Unknown WGR path point type"
 ")", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 3357
); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unknown WGR path point type"
 ")"); do { MOZ_CrashSequence(__null, 3357); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
        valid = false;
        break;
    }
  }
  // Close the sub-path if necessary.
  if (valid && closed) {
    AAStroke::aa_stroke_close(s);
  }
}
Maybe<AAStroke::VertexBuffer> result;
if (valid) {
  AAStroke::VertexBuffer vb = AAStroke::aa_stroke_finish(s);
  if (!vb.len || (aBuffer && vb.len > aBufferCapacity)) {
    AAStroke::aa_stroke_vertex_buffer_release(vb);
  } else {
    result = Some(vb);
  }
}
AAStroke::aa_stroke_release(s);
return result;
3378}

3380// Search the path cache for any entries stored in the path vertex buffer and
3381// remove them.
3382void PathCache::ClearVertexRanges() {
for (auto& chain : mChains) {
  PathCacheEntry* entry = chain.getFirst();
  while (entry) {
    PathCacheEntry* next = entry->getNext();
    if (entry->GetVertexRange().IsValid()) {
      entry->Unlink();
    }
    entry = next;
  }
}
3393}

3395inline bool DrawTargetWebgl::ShouldAccelPath(
  const DrawOptions& aOptions, const StrokeOptions* aStrokeOptions) {
return mWebglValid && SupportsDrawOptions(aOptions) && PrepareContext();
3398}

3400// For now, we only directly support stroking solid color patterns to limit
3401// artifacts from blending of overlapping geometry generated by AAStroke. Other
3402// types of patterns may be partially supported by rendering to a temporary
3403// mask.
3404static inline AAStrokeMode SupportsAAStroke(const Pattern& aPattern,
                                          const DrawOptions& aOptions,
                                          const StrokeOptions& aStrokeOptions,
                                          bool aAllowStrokeAlpha) {
if (aStrokeOptions.mDashPattern) {
  return AAStrokeMode::Unsupported;
}
switch (aOptions.mCompositionOp) {
  case CompositionOp::OP_SOURCE:
    return AAStrokeMode::Geometry;
  case CompositionOp::OP_OVER:
    if (aPattern.GetType() == PatternType::COLOR) {
      return static_cast<const ColorPattern&>(aPattern).mColor.a *
                             aOptions.mAlpha <
                         1.0f &&
                     !aAllowStrokeAlpha
                 ? AAStrokeMode::Mask
                 : AAStrokeMode::Geometry;
    }
    return AAStrokeMode::Unsupported;
  default:
    return AAStrokeMode::Unsupported;
}
3427}

3429// Render an AA-Stroke'd vertex range into an R8 mask texture for subsequent
3430// drawing.
3431already_AddRefed<TextureHandle> SharedContextWebgl::DrawStrokeMask(
  const PathVertexRange& aVertexRange, const IntSize& aSize) {
// Allocate a new texture handle to store the rendered mask.
RefPtr<TextureHandle> handle =
    AllocateTextureHandle(SurfaceFormat::A8, aSize, true, true);
if (!handle) {
  return nullptr;
}

IntRect texBounds = handle->GetBounds();
BackingTexture* backing = handle->GetBackingTexture();
if (!backing->IsInitialized()) {
  // If the backing texture is uninitialized, it needs its sampling parameters
  // set for later use.
  mWebgl->BindTexture(LOCAL_GL_TEXTURE_2D0x0DE1, backing->GetWebGLTexture());
  mWebgl->TexStorage(LOCAL_GL_TEXTURE_2D0x0DE1, 1, LOCAL_GL_R80x8229,
                     {uint32_t(backing->GetSize().width),
                      uint32_t(backing->GetSize().height), 1});
  InitTexParameters(backing->GetWebGLTexture());
  ClearLastTexture();
}

// Set up a scratch framebuffer to render to the appropriate sub-texture of
// the backing texture.
if (!mScratchFramebuffer) {
  mScratchFramebuffer = mWebgl->CreateFramebuffer();
}
mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mScratchFramebuffer);
webgl::FbAttachInfo attachInfo;
attachInfo.tex = backing->GetWebGLTexture();
mWebgl->FramebufferAttach(LOCAL_GL_FRAMEBUFFER0x8D40, LOCAL_GL_COLOR_ATTACHMENT00x8CE0,
                          LOCAL_GL_TEXTURE_2D0x0DE1, attachInfo);
mWebgl->Viewport(texBounds.x, texBounds.y, texBounds.width, texBounds.height);
EnableScissor(texBounds);
if (!backing->IsInitialized()) {
  backing->MarkInitialized();
  // WebGL implicitly clears the backing texture the first time it is used.
} else {
  // Ensure the mask background is clear.
  mWebgl->ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  mWebgl->Clear(LOCAL_GL_COLOR_BUFFER_BIT0x00004000);
}

// Reset any blending when drawing the mask.
SetBlendState(CompositionOp::OP_OVER);

// Set up the solid color shader to draw a simple opaque mask.
if (mLastProgram != mSolidProgram) {
  mWebgl->UseProgram(mSolidProgram);
  mLastProgram = mSolidProgram;
}
Array<float, 2> viewportData = {float(texBounds.width),
                                float(texBounds.height)};
MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mSolidProgramViewport, viewportData,
                 mSolidProgramUniformState.mViewport);
Array<float, 1> aaData = {0.0f};
MaybeUniformData(LOCAL_GL_FLOAT0x1406, mSolidProgramAA, aaData,
                 mSolidProgramUniformState.mAA);
Array<float, 4> clipData = {-0.5f, -0.5f, float(texBounds.width) + 0.5f,
                            float(texBounds.height) + 0.5f};
MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mSolidProgramClipBounds, clipData,
                 mSolidProgramUniformState.mClipBounds);
Array<float, 4> colorData = {1.0f, 1.0f, 1.0f, 1.0f};
MaybeUniformData(LOCAL_GL_FLOAT_VEC40x8B52, mSolidProgramColor, colorData,
                 mSolidProgramUniformState.mColor);
Array<float, 6> xformData = {1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f};
MaybeUniformData(LOCAL_GL_FLOAT_VEC20x8B50, mSolidProgramTransform, xformData,
                 mSolidProgramUniformState.mTransform);

// Ensure the current clip mask is ignored.
RefPtr<WebGLTexture> prevClipMask = mLastClipMask;
SetNoClipMask();

// Draw the mask using the supplied path vertex range.
DrawTriangles(aVertexRange);

// Restore the previous framebuffer state.
mWebgl->BindFramebuffer(LOCAL_GL_FRAMEBUFFER0x8D40, mCurrentTarget->mFramebuffer);
mWebgl->Viewport(0, 0, mViewportSize.width, mViewportSize.height);
if (prevClipMask) {
  SetClipMask(prevClipMask);
}

return handle.forget();
3515}

3517bool SharedContextWebgl::DrawPathAccel(
  const Path* aPath, const Pattern& aPattern, const DrawOptions& aOptions,
  const StrokeOptions* aStrokeOptions, bool aAllowStrokeAlpha,
  const ShadowOptions* aShadow, bool aCacheable, const Matrix* aPathXform) {
// Get the transformed bounds for the path and conservatively check if the
// bounds overlap the canvas.
const PathSkia* pathSkia = static_cast<const PathSkia*>(aPath);
const Matrix& currentTransform = mCurrentTarget->GetTransform();
Matrix pathXform = currentTransform;
// If there is a path-specific transform that shouldn't be applied to the
// pattern, then generate a matrix that should only be used with the Skia
// path.
if (aPathXform) {
  pathXform.PreMultiply(*aPathXform);
}
Rect bounds = pathSkia->GetFastBounds(pathXform, aStrokeOptions);
// If the path is empty, then there is nothing to draw.
if (bounds.IsEmpty()) {
  return true;
}
// Avoid integer conversion errors with abnormally large paths.
if (!RectInsidePrecisionLimits(bounds)) {
  return false;
}
IntRect viewport(IntPoint(), mViewportSize);
if (aShadow) {
  // Inflate the bounds to account for the blur radius.
  bounds += aShadow->mOffset;
  int32_t blurRadius = aShadow->BlurRadius();
  bounds.Inflate(blurRadius);
  viewport.Inflate(blurRadius);
}
Point realOrigin = bounds.TopLeft();
if (aCacheable) {
  // Quantize the path origin to increase the reuse of cache entries.
  bounds.Scale(4.0f);
  bounds.Round();
  bounds.Scale(0.25f);
}
Point quantizedOrigin = bounds.TopLeft();
// If the path doesn't intersect the viewport, then there is nothing to draw.
IntRect intBounds = RoundedOut(bounds).Intersect(viewport);
if (intBounds.IsEmpty()) {
  return true;
}
// Nudge the bounds to account for the quantization rounding.
Rect quantBounds = Rect(intBounds) + (realOrigin - quantizedOrigin);
// If the pattern is a solid color, then this will be used along with a path
// mask to render the path, as opposed to baking the pattern into the cached
// path texture.
Maybe<DeviceColor> color =
    aOptions.mCompositionOp == CompositionOp::OP_CLEAR
        ? Some(DeviceColor(1, 1, 1, 1))
        : (aPattern.GetType() == PatternType::COLOR
               ? Some(static_cast<const ColorPattern&>(aPattern).mColor)
               : Nothing());
AAStrokeMode aaStrokeMode =
    aStrokeOptions && mPathAAStroke
        ? SupportsAAStroke(aPattern, aOptions, *aStrokeOptions,
                           aAllowStrokeAlpha)
        : AAStrokeMode::Unsupported;
// Look for an existing path cache entry, if possible, or otherwise create
// one. If the draw request is not cacheable, then don't create an entry.
RefPtr<PathCacheEntry> entry;
RefPtr<TextureHandle> handle;
if (aCacheable) {
  if (!mPathCache) {
    mPathCache = MakeUnique<PathCache>();
  }
  // Use a quantized, relative (to its bounds origin) version of the path as
  // a cache key to help limit cache bloat.
  Maybe<QuantizedPath> qp = GenerateQuantizedPath(
      mWGRPathBuilder, pathSkia->GetPath(), quantBounds, pathXform);
  if (!qp) {
    return false;
  }
  entry = mPathCache->FindOrInsertEntry(
      std::move(*qp), color ? nullptr : &aPattern, aStrokeOptions,
      aaStrokeMode, currentTransform, intBounds, quantizedOrigin,
      aShadow ? aShadow->mSigma : -1.0f);
  if (!entry) {
    return false;
  }
  handle = entry->GetHandle();
}

// If there is a shadow, it needs to draw with the shadow color rather than
// the path color.
Maybe<DeviceColor> shadowColor = color;
if (aShadow && aOptions.mCompositionOp != CompositionOp::OP_CLEAR) {
  shadowColor = Some(aShadow->mColor);
  if (color) {
    shadowColor->a *= color->a;
  }
}
SamplingFilter filter =
    aShadow ? SamplingFilter::GOOD : GetSamplingFilter(aPattern);
if (handle && handle->IsValid()) {
  // If the entry has a valid texture handle still, use it. However, the
  // entry texture is assumed to be located relative to its previous bounds.
  // We need to offset the pattern by the difference between its new unclipped
  // origin and its previous previous unclipped origin. Then when we finally
  // draw a rectangle at the expected new bounds, it will overlap the portion
  // of the old entry texture we actually need to sample from.
  Point offset =
      (realOrigin - entry->GetOrigin()) + entry->GetBounds().TopLeft();
  SurfacePattern pathPattern(nullptr, ExtendMode::CLAMP,
                             Matrix::Translation(offset), filter);
  return DrawRectAccel(quantBounds, pathPattern, aOptions, shadowColor,
                       &handle, false, true, true);
}

if (mPathVertexCapacity > 0 && !handle && entry && !aShadow &&
    aOptions.mAntialiasMode != AntialiasMode::NONE &&
    SupportsPattern(aPattern) &&
    entry->GetPath().mPath.num_types <= mPathMaxComplexity) {
  if (entry->GetVertexRange().IsValid()) {
    // If there is a valid cached vertex data in the path vertex buffer, then
    // just draw that. We must draw at integer pixel boundaries (using
    // intBounds instead of quantBounds) due to WGR's reliance on pixel center
    // location.
    mCurrentTarget->mProfile.OnCacheHit();
    return DrawRectAccel(Rect(intBounds.TopLeft(), Size(1, 1)), aPattern,
                         aOptions, Nothing(), nullptr, false, true, true,
                         false, nullptr, &entry->GetVertexRange());
  }

  // printf_stderr("Generating... verbs %d, points %d\n",
  //     int(pathSkia->GetPath().countVerbs()),
  //     int(pathSkia->GetPath().countPoints()));
  WGR::OutputVertex* outputBuffer = nullptr;
  size_t outputBufferCapacity = 0;
  if (mWGROutputBuffer) {
    outputBuffer = mWGROutputBuffer.get();
    outputBufferCapacity = mPathVertexCapacity / sizeof(WGR::OutputVertex);
  }
  Maybe<WGR::VertexBuffer> wgrVB;
  Maybe<AAStroke::VertexBuffer> strokeVB;
  if (!aStrokeOptions) {
    if (aPath == mUnitCirclePath) {
      auto scaleFactors = pathXform.ScaleFactors();
      if (scaleFactors.AreScalesSame()) {
        Point center = pathXform.GetTranslation() - quantBounds.TopLeft();
        float radius = scaleFactors.xScale;
        AAStroke::VertexBuffer vb = AAStroke::aa_stroke_filled_circle(
            center.x, center.y, radius, (AAStroke::OutputVertex*)outputBuffer,
            outputBufferCapacity);
        if (!vb.len || (outputBuffer && vb.len > outputBufferCapacity)) {
          AAStroke::aa_stroke_vertex_buffer_release(vb);
        } else {
          strokeVB = Some(vb);
        }
      }
    }
    if (!strokeVB) {
      wgrVB = GeneratePathVertexBuffer(
          entry->GetPath(), IntRect(-intBounds.TopLeft(), mViewportSize),
          mRasterizationTruncates, outputBuffer, outputBufferCapacity);
    }
  } else {
    if (aaStrokeMode != AAStrokeMode::Unsupported) {
      auto scaleFactors = currentTransform.ScaleFactors();
      if (scaleFactors.AreScalesSame()) {
        strokeVB = GenerateStrokeVertexBuffer(
            entry->GetPath(), aStrokeOptions, scaleFactors.xScale,
            outputBuffer, outputBufferCapacity);
      }
    }
    if (!strokeVB && mPathWGRStroke) {
      //  If stroking, then generate a path to fill the stroked region. This
      //  path will need to be quantized again because it differs from the
      //  path used for the cache entry, but this allows us to avoid
      //  generating a fill path on a cache hit.
      Maybe<Rect> cullRect;
      Matrix invTransform = currentTransform;
      if (invTransform.Invert()) {
        // Transform the stroking clip rect from device space to local
        // space.
        Rect invRect = invTransform.TransformBounds(Rect(mClipRect));
        invRect.RoundOut();
        cullRect = Some(invRect);
      }
      SkPath fillPath;
      if (pathSkia->GetFillPath(*aStrokeOptions, pathXform, fillPath,
                                cullRect)) {
        // printf_stderr("    stroke fill... verbs %d, points %d\n",
        //     int(fillPath.countVerbs()),
        //     int(fillPath.countPoints()));
        if (Maybe<QuantizedPath> qp = GenerateQuantizedPath(
                mWGRPathBuilder, fillPath, quantBounds, pathXform)) {
          wgrVB = GeneratePathVertexBuffer(
              *qp, IntRect(-intBounds.TopLeft(), mViewportSize),
              mRasterizationTruncates, outputBuffer, outputBufferCapacity);
        }
      }
    }
  }
  if (wgrVB || strokeVB) {
    const uint8_t* vbData =
        wgrVB ? (const uint8_t*)wgrVB->data : (const uint8_t*)strokeVB->data;
    if (outputBuffer && !vbData) {
      vbData = (const uint8_t*)outputBuffer;
    }
    size_t vbLen = wgrVB ? wgrVB->len : strokeVB->len;
    uint32_t vertexBytes = uint32_t(
        std::min(vbLen * sizeof(WGR::OutputVertex), size_t(UINT32_MAX(4294967295U))));
    // printf_stderr("  ... %d verts, %d bytes\n", int(vbLen),
    //     int(vertexBytes));
    if (vertexBytes > mPathVertexCapacity - mPathVertexOffset &&
        vertexBytes <= mPathVertexCapacity - sizeof(kRectVertexData)) {
      // If the vertex data is too large to fit in the remaining path vertex
      // buffer, then orphan the contents of the vertex buffer to make room
      // for it.
      if (mPathCache) {
        mPathCache->ClearVertexRanges();
      }
      ResetPathVertexBuffer();
    }
    if (vertexBytes <= mPathVertexCapacity - mPathVertexOffset) {
      // If there is actually room to fit the vertex data in the vertex buffer
      // after orphaning as necessary, then upload the data to the next
      // available offset in the buffer.
      PathVertexRange vertexRange(
          uint32_t(mPathVertexOffset / sizeof(WGR::OutputVertex)),
          uint32_t(vbLen));
      // printf_stderr("      ... offset %d\n", mPathVertexOffset);
      // Normal glBufferSubData interleaved with draw calls causes performance
      // issues on Mali, so use our special unsynchronized version. This is
      // safe as we never update regions referenced by pending draw calls.
      mWebgl->BufferSubData(LOCAL_GL_ARRAY_BUFFER0x8892, mPathVertexOffset,
                            vertexBytes, vbData,
                            /* unsynchronized */ true);
      mPathVertexOffset += vertexBytes;
      if (wgrVB) {
        WGR::wgr_vertex_buffer_release(wgrVB.ref());
      } else {
        AAStroke::aa_stroke_vertex_buffer_release(strokeVB.ref());
      }
      if (strokeVB && aaStrokeMode == AAStrokeMode::Mask) {
        // Attempt to generate a stroke mask for path.
        if (RefPtr<TextureHandle> handle =
                DrawStrokeMask(vertexRange, intBounds.Size())) {
          // Finally, draw the rendered stroke mask.
          if (entry) {
            entry->Link(handle);
          }
          mCurrentTarget->mProfile.OnCacheMiss();
          SurfacePattern maskPattern(
              nullptr, ExtendMode::CLAMP,
              Matrix::Translation(quantBounds.TopLeft()),
              SamplingFilter::GOOD);
          return DrawRectAccel(quantBounds, maskPattern, aOptions, color,
                               &handle, false, true, true);
        }
      } else {
        // Remember the vertex range in the cache entry so that it can be
        // reused later.
        if (entry) {
          entry->SetVertexRange(vertexRange);
        }

        // Finally, draw the uploaded vertex data.
        mCurrentTarget->mProfile.OnCacheMiss();
        return DrawRectAccel(Rect(intBounds.TopLeft(), Size(1, 1)), aPattern,
                             aOptions, Nothing(), nullptr, false, true, true,
                             false, nullptr, &vertexRange);
      }
    } else {
      if (wgrVB) {
        WGR::wgr_vertex_buffer_release(wgrVB.ref());
      } else {
        AAStroke::aa_stroke_vertex_buffer_release(strokeVB.ref());
      }
    }
    // If we failed to draw the vertex data for some reason, then fall through
    // to the texture rasterization path.
  }
}

// If a stroke path covers too much screen area, it is likely that most is
// empty space in the interior. This usually imposes too high a cost versus
// just rasterizing without acceleration. Note that AA-Stroke generally
// produces more acceptable amounts of geometry for larger paths, so we do
// this heuristic after we attempt AA-Stroke.
if (aStrokeOptions &&
    intBounds.width * intBounds.height >
        (mViewportSize.width / 2) * (mViewportSize.height / 2)) {
  // Avoid filling cache with empty entries.
  if (entry) {
    entry->Unlink();
  }
  return false;
}

// If there isn't a valid texture handle, then we need to rasterize the
// path in a software canvas and upload this to a texture. Solid color
// patterns will be rendered as a path mask that can then be modulated
// with any color. Other pattern types have to rasterize the pattern
// directly into the cached texture.
handle = nullptr;
RefPtr<DrawTargetSkia> pathDT = new DrawTargetSkia;
if (pathDT->Init(intBounds.Size(), color || aShadow
                                       ? SurfaceFormat::A8
                                       : SurfaceFormat::B8G8R8A8)) {
  Point offset = -quantBounds.TopLeft();
  if (aShadow) {
    // Ensure the the shadow is drawn at the requested offset
    offset += aShadow->mOffset;
  }
  DrawOptions drawOptions(1.0f, CompositionOp::OP_OVER,
                          aOptions.mAntialiasMode);
  static const ColorPattern maskPattern(DeviceColor(1.0f, 1.0f, 1.0f, 1.0f));
  const Pattern& cachePattern = color ? maskPattern : aPattern;
  // If the source pattern is a DrawTargetWebgl snapshot, we may shift
  // targets when drawing the path, so back up the old target.
  DrawTargetWebgl* oldTarget = mCurrentTarget;
  {
    RefPtr<const Path> path;
    if (!aPathXform || (color && !aStrokeOptions)) {
      // If the pattern is transform invariant or there is no pathXform, then
      // it is safe to use the path directly. Solid colors are transform
      // invariant, except when there are stroke options such as line width or
      // dashes that should not be scaled by pathXform.
      path = aPath;
      pathDT->SetTransform(pathXform * Matrix::Translation(offset));
    } else {
      // If there is a pathXform, then pre-apply that to the path to avoid
      // altering the pattern.
      RefPtr<PathBuilder> builder =
          aPath->TransformedCopyToBuilder(*aPathXform);
      path = builder->Finish();
      pathDT->SetTransform(currentTransform * Matrix::Translation(offset));
    }
    if (aStrokeOptions) {
      pathDT->Stroke(path, cachePattern, *aStrokeOptions, drawOptions);
    } else {
      pathDT->Fill(path, cachePattern, drawOptions);
    }
  }
  if (aShadow && aShadow->mSigma > 0.0f) {
    // Blur the shadow if required.
    uint8_t* data = nullptr;
    IntSize size;
    int32_t stride = 0;
    SurfaceFormat format = SurfaceFormat::UNKNOWN;
    if (pathDT->LockBits(&data, &size, &stride, &format)) {
      AlphaBoxBlur blur(Rect(pathDT->GetRect()), stride, aShadow->mSigma,
                        aShadow->mSigma);
      blur.Blur(data);
      pathDT->ReleaseBits(data);
    }
  }
  RefPtr<SourceSurface> pathSurface = pathDT->Snapshot();
  // If the target changed, try to restore it.
  if (pathSurface &&
      (mCurrentTarget == oldTarget || oldTarget->PrepareContext())) {
    SurfacePattern pathPattern(pathSurface, ExtendMode::CLAMP,
                               Matrix::Translation(quantBounds.TopLeft()),
                               filter);
    // Try and upload the rasterized path to a texture. If there is a
    // valid texture handle after this, then link it to the entry.
    // Otherwise, we might have to fall back to software drawing the
    // path, so unlink it from the entry.
    if (DrawRectAccel(quantBounds, pathPattern, aOptions, shadowColor,
                      &handle, false, true) &&
        handle) {
      if (entry) {
        entry->Link(handle);
      }
    } else if (entry) {
      entry->Unlink();
    }
    return true;
  }
}

// Avoid filling cache with empty entries.
if (entry) {
  entry->Unlink();
}
return false;
3898}

3900void DrawTargetWebgl::DrawPath(const Path* aPath, const Pattern& aPattern,
                             const DrawOptions& aOptions,
                             const StrokeOptions* aStrokeOptions,
                             bool aAllowStrokeAlpha) {
// If there is a WebGL context, then try to cache the path to avoid slow
// fallbacks.
if (ShouldAccelPath(aOptions, aStrokeOptions) &&
    mSharedContext->DrawPathAccel(aPath, aPattern, aOptions, aStrokeOptions,
                                  aAllowStrokeAlpha)) {
  return;
}

// There was no path cache entry available to use, so fall back to drawing the
// path with Skia.
MarkSkiaChanged(aOptions);
if (aStrokeOptions) {
  mSkia->Stroke(aPath, aPattern, *aStrokeOptions, aOptions);
} else {
  mSkia->Fill(aPath, aPattern, aOptions);
}
3920}

3922// DrawCircleAccel is a more specialized version of DrawPathAccel that attempts
3923// to cache a unit circle.
3924bool SharedContextWebgl::DrawCircleAccel(const Point& aCenter, float aRadius,
                                       const Pattern& aPattern,
                                       const DrawOptions& aOptions,
                                       const StrokeOptions* aStrokeOptions) {
// Cache a unit circle and transform it to avoid creating a path repeatedly.
if (!mUnitCirclePath) {
  mUnitCirclePath = MakePathForCircle(*mCurrentTarget, Point(0, 0), 1);
}
// Scale and translate the circle to the desired shape.
Matrix circleXform(aRadius, 0, 0, aRadius, aCenter.x, aCenter.y);
return DrawPathAccel(mUnitCirclePath, aPattern, aOptions, aStrokeOptions,
                     true, nullptr, true, &circleXform);
3936}

3938void DrawTargetWebgl::DrawCircle(const Point& aOrigin, float aRadius,
                               const Pattern& aPattern,
                               const DrawOptions& aOptions,
                               const StrokeOptions* aStrokeOptions) {
if (ShouldAccelPath(aOptions, aStrokeOptions) &&
    mSharedContext->DrawCircleAccel(aOrigin, aRadius, aPattern, aOptions,
                                    aStrokeOptions)) {
  return;
}

MarkSkiaChanged(aOptions);
if (aStrokeOptions) {
  mSkia->StrokeCircle(aOrigin, aRadius, aPattern, *aStrokeOptions, aOptions);
} else {
  mSkia->FillCircle(aOrigin, aRadius, aPattern, aOptions);
}
3954}

3956void DrawTargetWebgl::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
                                const Rect& aSource,
                                const DrawSurfaceOptions& aSurfOptions,
                                const DrawOptions& aOptions) {
Matrix matrix = Matrix::Scaling(aDest.width / aSource.width,
                                aDest.height / aSource.height);
matrix.PreTranslate(-aSource.TopLeft());
matrix.PostTranslate(aDest.TopLeft());

// Ensure the source rect is clipped to the surface bounds.
Rect src = aSource.Intersect(Rect(aSurface->GetRect()));
// Ensure the destination rect does not sample outside the surface bounds.
Rect dest = matrix.TransformBounds(src).Intersect(aDest);
SurfacePattern pattern(aSurface, ExtendMode::CLAMP, matrix,
                       aSurfOptions.mSamplingFilter);
DrawRect(dest, pattern, aOptions);
3972}

3974void DrawTargetWebgl::Mask(const Pattern& aSource, const Pattern& aMask,
                         const DrawOptions& aOptions) {
if (!SupportsDrawOptions(aOptions) ||
    aMask.GetType() != PatternType::SURFACE ||
    aSource.GetType() != PatternType::COLOR) {
  MarkSkiaChanged(aOptions);
  mSkia->Mask(aSource, aMask, aOptions);
  return;
}
auto sourceColor = static_cast<const ColorPattern&>(aSource).mColor;
auto maskPattern = static_cast<const SurfacePattern&>(aMask);
DrawRect(Rect(IntRect(IntPoint(), maskPattern.mSurface->GetSize())),
         maskPattern, aOptions, Some(sourceColor));
3987}

3989void DrawTargetWebgl::MaskSurface(const Pattern& aSource, SourceSurface* aMask,
                                Point aOffset, const DrawOptions& aOptions) {
if (!SupportsDrawOptions(aOptions) ||
    aSource.GetType() != PatternType::COLOR) {
  MarkSkiaChanged(aOptions);
  mSkia->MaskSurface(aSource, aMask, aOffset, aOptions);
} else {
  auto sourceColor = static_cast<const ColorPattern&>(aSource).mColor;
  SurfacePattern pattern(
      aMask, ExtendMode::CLAMP,
      Matrix::Translation(aOffset + aMask->GetRect().TopLeft()));
  DrawRect(Rect(aOffset, Size(aMask->GetSize())), pattern, aOptions,
           Some(sourceColor));
}
4003}

4005// Extract the surface's alpha values into an A8 surface.
4006static already_AddRefed<DataSourceSurface> ExtractAlpha(SourceSurface* aSurface,
                                                      bool aAllowSubpixelAA) {
RefPtr<DataSourceSurface> surfaceData = aSurface->GetDataSurface();
if (!surfaceData) {
  return nullptr;
}
DataSourceSurface::ScopedMap srcMap(surfaceData, DataSourceSurface::READ);
if (!srcMap.IsMapped()) {
  return nullptr;
}
IntSize size = surfaceData->GetSize();
RefPtr<DataSourceSurface> alpha =
    Factory::CreateDataSourceSurface(size, SurfaceFormat::A8, false);
if (!alpha) {
  return nullptr;
}
DataSourceSurface::ScopedMap dstMap(alpha, DataSourceSurface::WRITE);
if (!dstMap.IsMapped()) {
  return nullptr;
}
// For subpixel masks, ignore the alpha and instead sample one of the color
// channels as if they were alpha.
SwizzleData(
    srcMap.GetData(), srcMap.GetStride(),
    aAllowSubpixelAA ? SurfaceFormat::A8R8G8B8 : surfaceData->GetFormat(),
    dstMap.GetData(), dstMap.GetStride(), SurfaceFormat::A8, size);
return alpha.forget();
4033}

4035void DrawTargetWebgl::DrawShadow(const Path* aPath, const Pattern& aPattern,
                               const ShadowOptions& aShadow,
                               const DrawOptions& aOptions,
                               const StrokeOptions* aStrokeOptions) {
if (!aPath || aPath->GetBackendType() != BackendType::SKIA) {
  return;
}

// If there is a WebGL context, then try to cache the path to avoid slow
// fallbacks.
if (ShouldAccelPath(aOptions, aStrokeOptions) &&
    mSharedContext->DrawPathAccel(aPath, aPattern, aOptions, aStrokeOptions,
                                  false, &aShadow)) {
  return;
}

// There was no path cache entry available to use, so fall back to drawing the
// path with Skia.
MarkSkiaChanged(aOptions);
mSkia->DrawShadow(aPath, aPattern, aShadow, aOptions, aStrokeOptions);
4055}

4057void DrawTargetWebgl::DrawSurfaceWithShadow(SourceSurface* aSurface,
                                          const Point& aDest,
                                          const ShadowOptions& aShadow,
                                          CompositionOp aOperator) {
DrawOptions options(1.0f, aOperator);
if (ShouldAccelPath(options, nullptr)) {
  SurfacePattern pattern(aSurface, ExtendMode::CLAMP,
                         Matrix::Translation(aDest));
  SkPath skiaPath;
  skiaPath.addRect(RectToSkRect(Rect(aSurface->GetRect()) + aDest));
  RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
  AutoRestoreTransform restore(this);
  SetTransform(Matrix());
  if (mSharedContext->DrawPathAccel(path, pattern, options, nullptr, false,
                                    &aShadow, false)) {
    DrawRect(Rect(aSurface->GetRect()) + aDest, pattern, options);
    return;
  }
}

MarkSkiaChanged(options);
mSkia->DrawSurfaceWithShadow(aSurface, aDest, aShadow, aOperator);
4079}

4081already_AddRefed<PathBuilder> DrawTargetWebgl::CreatePathBuilder(
  FillRule aFillRule) const {
return mSkia->CreatePathBuilder(aFillRule);
4084}

4086void DrawTargetWebgl::SetTransform(const Matrix& aTransform) {
DrawTarget::SetTransform(aTransform);
mSkia->SetTransform(aTransform);
4089}

4091void DrawTargetWebgl::StrokeRect(const Rect& aRect, const Pattern& aPattern,
                               const StrokeOptions& aStrokeOptions,
                               const DrawOptions& aOptions) {
if (!mWebglValid) {
  MarkSkiaChanged(aOptions);
  mSkia->StrokeRect(aRect, aPattern, aStrokeOptions, aOptions);
} else {
  // If the stroke options are unsupported, then transform the rect to a path
  // so it can be cached.
  SkPath skiaPath;
  skiaPath.addRect(RectToSkRect(aRect));
  RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
  DrawPath(path, aPattern, aOptions, &aStrokeOptions, true);
}
4105}

4107static inline bool IsThinLine(const Matrix& aTransform,
                            const StrokeOptions& aStrokeOptions) {
auto scale = aTransform.ScaleFactors();
return std::max(scale.xScale, scale.yScale) * aStrokeOptions.mLineWidth <= 1;
4111}

4113bool DrawTargetWebgl::StrokeLineAccel(const Point& aStart, const Point& aEnd,
                                    const Pattern& aPattern,
                                    const StrokeOptions& aStrokeOptions,
                                    const DrawOptions& aOptions,
                                    bool aClosed) {
// Approximating a wide line as a rectangle works only with certain cap styles
// in the general case (butt or square). However, if the line width is
// sufficiently thin, we can either ignore the round cap (or treat it like
// square for zero-length lines) without causing objectionable artifacts.
// Lines may sometimes be used in closed paths that immediately reverse back,
// in which case we need to use mLineJoin instead of mLineCap to determine the
// actual cap used.
CapStyle capStyle =
    aClosed ? (aStrokeOptions.mLineJoin == JoinStyle::ROUND ? CapStyle::ROUND
                                                            : CapStyle::BUTT)
            : aStrokeOptions.mLineCap;
if (mWebglValid && SupportsPattern(aPattern) &&
    (capStyle != CapStyle::ROUND ||
     IsThinLine(GetTransform(), aStrokeOptions)) &&
    aStrokeOptions.mDashPattern == nullptr && aStrokeOptions.mLineWidth > 0) {
  // Treat the line as a rectangle whose center-line is the supplied line and
  // for which the height is the supplied line width. Generate a matrix that
  // maps the X axis to the orientation of the line and the Y axis to the
  // normal vector to the line. This only works if the line caps are squared,
  // as rounded rectangles are currently not supported for round line caps.
  Point start = aStart;
  Point dirX = aEnd - aStart;
  Point dirY;
  float dirLen = dirX.Length();
  float scale = aStrokeOptions.mLineWidth;
  if (dirLen == 0.0f) {
    // If the line is zero-length, then only a cap is rendered.
    switch (capStyle) {
      case CapStyle::BUTT:
        // The cap doesn't extend beyond the line so nothing is drawn.
        return true;
      case CapStyle::ROUND:
      case CapStyle::SQUARE:
        // Draw a unit square centered at the single point.
        dirX = Point(scale, 0.0f);
        dirY = Point(0.0f, scale);
        // Offset the start by half a unit.
        start.x -= 0.5f * scale;
        break;
    }
  } else {
    // Make the scale map to a single unit length.
    scale /= dirLen;
    dirY = Point(-dirX.y, dirX.x) * scale;
    if (capStyle == CapStyle::SQUARE) {
      // Offset the start by half a unit.
      start -= (dirX * scale) * 0.5f;
      // Ensure the extent also accounts for the start and end cap.
      dirX += dirX * scale;
    }
  }
  Matrix lineXform(dirX.x, dirX.y, dirY.x, dirY.y, start.x - 0.5f * dirY.x,
                   start.y - 0.5f * dirY.y);
  if (PrepareContext() &&
      mSharedContext->DrawRectAccel(Rect(0, 0, 1, 1), aPattern, aOptions,
                                    Nothing(), nullptr, true, true, true,
                                    false, nullptr, nullptr, &lineXform)) {
    return true;
  }
}
return false;
4179}

4181void DrawTargetWebgl::StrokeLine(const Point& aStart, const Point& aEnd,
                               const Pattern& aPattern,
                               const StrokeOptions& aStrokeOptions,
                               const DrawOptions& aOptions) {
if (!mWebglValid) {
  MarkSkiaChanged(aOptions);
  mSkia->StrokeLine(aStart, aEnd, aPattern, aStrokeOptions, aOptions);
} else if (!StrokeLineAccel(aStart, aEnd, aPattern, aStrokeOptions,
                            aOptions)) {
  // If the stroke options are unsupported, then transform the line to a path
  // so it can be cached.
  SkPath skiaPath;
  skiaPath.moveTo(PointToSkPoint(aStart));
  skiaPath.lineTo(PointToSkPoint(aEnd));
  RefPtr<PathSkia> path = new PathSkia(skiaPath, FillRule::FILL_WINDING);
  DrawPath(path, aPattern, aOptions, &aStrokeOptions, true);
}
4198}

4200void DrawTargetWebgl::Stroke(const Path* aPath, const Pattern& aPattern,
                           const StrokeOptions& aStrokeOptions,
                           const DrawOptions& aOptions) {
if (!aPath || aPath->GetBackendType() != BackendType::SKIA) {
  return;
}
const auto& skiaPath = static_cast<const PathSkia*>(aPath)->GetPath();
if (!mWebglValid) {
  MarkSkiaChanged(aOptions);
  mSkia->Stroke(aPath, aPattern, aStrokeOptions, aOptions);
  return;
}

// Avoid using Skia's isLine here because some paths erroneously include a
// closePath at the end, causing isLine to not detect the line. In that case
// we just draw a line in reverse right over the original line.
int numVerbs = skiaPath.countVerbs();
bool allowStrokeAlpha = false;
if (numVerbs >= 2 && numVerbs <= 3) {
  uint8_t verbs[3];
  skiaPath.getVerbs(verbs, numVerbs);
  if (verbs[0] == SkPath::kMove_Verb && verbs[1] == SkPath::kLine_Verb &&
      (numVerbs < 3 || verbs[2] == SkPath::kClose_Verb)) {
    bool closed = numVerbs >= 3;
    Point start = SkPointToPoint(skiaPath.getPoint(0));
    Point end = SkPointToPoint(skiaPath.getPoint(1));
    if (StrokeLineAccel(start, end, aPattern, aStrokeOptions, aOptions,
                        closed)) {
      if (closed) {
        StrokeLineAccel(end, start, aPattern, aStrokeOptions, aOptions, true);
      }
      return;
    }
    // If accelerated line drawing failed, just treat it as a path.
    allowStrokeAlpha = true;
  }
}

DrawPath(aPath, aPattern, aOptions, &aStrokeOptions, allowStrokeAlpha);
4239}

4241void DrawTargetWebgl::StrokeCircle(const Point& aOrigin, float aRadius,
                                 const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                 const DrawOptions& aOptions) {
DrawCircle(aOrigin, aRadius, aPattern, aOptions, &aStrokeOptions);
4246}

4248bool DrawTargetWebgl::ShouldUseSubpixelAA(ScaledFont* aFont,
                                        const DrawOptions& aOptions) {
AntialiasMode aaMode = aFont->GetDefaultAAMode();
if (aOptions.mAntialiasMode != AntialiasMode::DEFAULT) {
  aaMode = aOptions.mAntialiasMode;
}
return GetPermitSubpixelAA() &&
       (aaMode == AntialiasMode::DEFAULT ||
        aaMode == AntialiasMode::SUBPIXEL) &&
       aOptions.mCompositionOp == CompositionOp::OP_OVER;
4258}

4260void DrawTargetWebgl::StrokeGlyphs(ScaledFont* aFont,
                                 const GlyphBuffer& aBuffer,
                                 const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                 const DrawOptions& aOptions) {
if (!aFont || !aBuffer.mNumGlyphs) {
  return;
}

bool useSubpixelAA = ShouldUseSubpixelAA(aFont, aOptions);

if (mWebglValid && SupportsDrawOptions(aOptions) &&
    aPattern.GetType() == PatternType::COLOR && PrepareContext() &&
    mSharedContext->DrawGlyphsAccel(aFont, aBuffer, aPattern, aOptions,
                                    &aStrokeOptions, useSubpixelAA)) {
  return;
}

if (useSubpixelAA) {
  // Subpixel AA does not support layering because the subpixel masks can't
  // blend with the over op.
  MarkSkiaChanged();
} else {
  MarkSkiaChanged(aOptions);
}
mSkia->StrokeGlyphs(aFont, aBuffer, aPattern, aStrokeOptions, aOptions);
4286}

4288// Depending on whether we enable subpixel position for a given font, Skia may
4289// round transformed coordinates differently on each axis. By default, text is
4290// subpixel quantized horizontally and snapped to a whole integer vertical
4291// baseline. Axis-flip transforms instead snap to horizontal boundaries while
4292// subpixel quantizing along the vertical. For other types of transforms, Skia
4293// just applies subpixel quantization to both axes.
4294// We must duplicate the amount of quantization Skia applies carefully as a
4295// boundary value such as 0.49 may round to 0.5 with subpixel quantization,
4296// but if Skia actually snapped it to a whole integer instead, it would round
4297// down to 0. If a subsequent glyph with offset 0.51 came in, we might
4298// mistakenly round it down to 0.5, whereas Skia would round it up to 1. Thus
4299// we would alias 0.49 and 0.51 to the same cache entry, while Skia would
4300// actually snap the offset to 0 or 1, depending, resulting in mismatched
4301// hinting.
4302static inline IntPoint QuantizeScale(ScaledFont* aFont,
                                   const Matrix& aTransform) {
if (!aFont->UseSubpixelPosition()) {
  return {1, 1};
}
if (aTransform._12 == 0) {
  // Glyphs are rendered subpixel horizontally, so snap vertically.
  return {4, 1};
}
if (aTransform._11 == 0) {
  // Glyphs are rendered subpixel vertically, so snap horizontally.
  return {1, 4};
}
// The transform isn't aligned, so don't snap.
return {4, 4};
4317}

4319// Skia only supports subpixel positioning to the nearest 1/4 fraction. It
4320// would be wasteful to attempt to cache text runs with positioning that is
4321// anymore precise than this. To prevent this cache bloat, we quantize the
4322// transformed glyph positions to the nearest 1/4. The scaling factor for
4323// the quantization is baked into the transform, so that if subpixel rounding
4324// is used on a given axis, then the axis will be multiplied by 4 before
4325// rounding. Since the quantized position is not used for rasterization, the
4326// transform is safe to modify as such.
4327static inline IntPoint QuantizePosition(const Matrix& aTransform,
                                      const IntPoint& aOffset,
                                      const Point& aPosition) {
return RoundedToInt(aTransform.TransformPoint(aPosition)) - aOffset;
4331}

4333// Get a quantized starting offset for the glyph buffer. We want this offset
4334// to encapsulate the transform and buffer offset while still preserving the
4335// relative subpixel positions of the glyphs this offset is subtracted from.
4336static inline IntPoint QuantizeOffset(const Matrix& aTransform,
                                    const IntPoint& aQuantizeScale,
                                    const GlyphBuffer& aBuffer) {
IntPoint offset =
    RoundedToInt(aTransform.TransformPoint(aBuffer.mGlyphs[0].mPosition));
offset.x.value &= ~(aQuantizeScale.x.value - 1);
offset.y.value &= ~(aQuantizeScale.y.value - 1);
return offset;
4344}

4346// Hashes a glyph buffer to a single hash value that can be used for quick
4347// comparisons. Each glyph position is transformed and quantized before
4348// hashing.
4349HashNumber GlyphCacheEntry::HashGlyphs(const GlyphBuffer& aBuffer,
                                     const Matrix& aTransform,
                                     const IntPoint& aQuantizeScale) {
HashNumber hash = 0;
IntPoint offset = QuantizeOffset(aTransform, aQuantizeScale, aBuffer);
for (size_t i = 0; i < aBuffer.mNumGlyphs; i++) {
  const Glyph& glyph = aBuffer.mGlyphs[i];
  hash = AddToHash(hash, glyph.mIndex);
  IntPoint pos = QuantizePosition(aTransform, offset, glyph.mPosition);
  hash = AddToHash(hash, pos.x);
  hash = AddToHash(hash, pos.y);
}
return hash;
4362}

4364// Determines if an existing glyph cache entry matches an incoming text run.
4365inline bool GlyphCacheEntry::MatchesGlyphs(
  const GlyphBuffer& aBuffer, const DeviceColor& aColor,
  const Matrix& aTransform, const IntPoint& aQuantizeOffset,
  const IntPoint& aBoundsOffset, const IntRect& aClipRect, HashNumber aHash,
  const StrokeOptions* aStrokeOptions) {
// First check if the hash matches to quickly reject the text run before any
// more expensive checking. If it matches, then check if the color and
// transform are the same.
if (aHash != mHash || aBuffer.mNumGlyphs != mBuffer.mNumGlyphs ||
    aColor != mColor || !HasMatchingScale(aTransform, mTransform)) {
  return false;
}
// Finally check if all glyphs and their quantized positions match.
for (size_t i = 0; i < aBuffer.mNumGlyphs; i++) {
  const Glyph& dst = mBuffer.mGlyphs[i];
  const Glyph& src = aBuffer.mGlyphs[i];
  if (dst.mIndex != src.mIndex ||
      dst.mPosition != Point(QuantizePosition(aTransform, aQuantizeOffset,
                                              src.mPosition))) {
    return false;
  }
}
// Check that stroke options actually match.
if (aStrokeOptions) {
  // If stroking, verify that the entry is also stroked with the same options.
  if (!(mStrokeOptions && *aStrokeOptions == *mStrokeOptions)) {
    return false;
  }
} else if (mStrokeOptions) {
  // If not stroking, check if the entry is stroked. If so, don't match.
  return false;
}
// Verify that the full bounds, once translated and clipped, are equal to the
// clipped bounds.
return (mFullBounds + aBoundsOffset)
    .Intersect(aClipRect)
    .IsEqualEdges(GetBounds() + aBoundsOffset);
4402}

4404GlyphCacheEntry::GlyphCacheEntry(const GlyphBuffer& aBuffer,
                               const DeviceColor& aColor,
                               const Matrix& aTransform,
                               const IntPoint& aQuantizeScale,
                               const IntRect& aBounds,
                               const IntRect& aFullBounds, HashNumber aHash,
                               StoredStrokeOptions* aStrokeOptions)
  : CacheEntryImpl<GlyphCacheEntry>(aTransform, aBounds, aHash),
    mColor(aColor),
    mFullBounds(aFullBounds),
    mStrokeOptions(aStrokeOptions) {
// Store a copy of the glyph buffer with positions already quantized for fast
// comparison later.
Glyph* glyphs = new Glyph[aBuffer.mNumGlyphs];
IntPoint offset = QuantizeOffset(aTransform, aQuantizeScale, aBuffer);
// Make the bounds relative to the offset so we can add a new offset later.
IntPoint boundsOffset(offset.x / aQuantizeScale.x,
                      offset.y / aQuantizeScale.y);
mBounds -= boundsOffset;
mFullBounds -= boundsOffset;
for (size_t i = 0; i < aBuffer.mNumGlyphs; i++) {
  Glyph& dst = glyphs[i];
  const Glyph& src = aBuffer.mGlyphs[i];
  dst.mIndex = src.mIndex;
  dst.mPosition = Point(QuantizePosition(aTransform, offset, src.mPosition));
}
mBuffer.mGlyphs = glyphs;
mBuffer.mNumGlyphs = aBuffer.mNumGlyphs;
4432}

4434GlyphCacheEntry::~GlyphCacheEntry() { delete[] mBuffer.mGlyphs; }

4436// Attempt to find a matching entry in the glyph cache. The caller should check
4437// whether the contained texture handle is valid to determine if it will need to
4438// render the text run or just reuse the cached texture.
4439already_AddRefed<GlyphCacheEntry> GlyphCache::FindEntry(
  const GlyphBuffer& aBuffer, const DeviceColor& aColor,
  const Matrix& aTransform, const IntPoint& aQuantizeScale,
  const IntRect& aClipRect, HashNumber aHash,
  const StrokeOptions* aStrokeOptions) {
IntPoint offset = QuantizeOffset(aTransform, aQuantizeScale, aBuffer);
IntPoint boundsOffset(offset.x / aQuantizeScale.x,
                      offset.y / aQuantizeScale.y);
for (const RefPtr<GlyphCacheEntry>& entry : GetChain(aHash)) {
  if (entry->MatchesGlyphs(aBuffer, aColor, aTransform, offset, boundsOffset,
                           aClipRect, aHash, aStrokeOptions)) {
    return do_AddRef(entry);
  }
}
return nullptr;
4454}

4456// Insert a new entry in the glyph cache.
4457already_AddRefed<GlyphCacheEntry> GlyphCache::InsertEntry(
  const GlyphBuffer& aBuffer, const DeviceColor& aColor,
  const Matrix& aTransform, const IntPoint& aQuantizeScale,
  const IntRect& aBounds, const IntRect& aFullBounds, HashNumber aHash,
  const StrokeOptions* aStrokeOptions) {
StoredStrokeOptions* strokeOptions = nullptr;
if (aStrokeOptions) {
  strokeOptions = aStrokeOptions->Clone();
  if (!strokeOptions) {
    return nullptr;
  }
}
RefPtr<GlyphCacheEntry> entry =
    new GlyphCacheEntry(aBuffer, aColor, aTransform, aQuantizeScale, aBounds,
                        aFullBounds, aHash, strokeOptions);
Insert(entry);
return entry.forget();
4474}

4476GlyphCache::GlyphCache(ScaledFont* aFont) : mFont(aFont) {}

4478static void ReleaseGlyphCache(void* aPtr) {
delete static_cast<GlyphCache*>(aPtr);
1
Calling implicit destructor for 'GlyphCache'→
2
←
Calling '~CacheImpl'→
4480}

4482// Whether all glyphs in the buffer match the last whitespace glyph queried.
4483bool GlyphCache::IsWhitespace(const GlyphBuffer& aBuffer) const {
if (!mLastWhitespace) {
  return false;
}
uint32_t whitespace = *mLastWhitespace;
for (size_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
  if (aBuffer.mGlyphs[i].mIndex != whitespace) {
    return false;
  }
}
return true;
4494}

4496// Remember the last whitespace glyph seen.
4497void GlyphCache::SetLastWhitespace(const GlyphBuffer& aBuffer) {
mLastWhitespace = Some(aBuffer.mGlyphs[0].mIndex);
4499}

4501void DrawTargetWebgl::SetPermitSubpixelAA(bool aPermitSubpixelAA) {
DrawTarget::SetPermitSubpixelAA(aPermitSubpixelAA);
mSkia->SetPermitSubpixelAA(aPermitSubpixelAA);
4504}

4506// Check for any color glyphs contained within a rasterized BGRA8 text result.
4507static bool CheckForColorGlyphs(const RefPtr<SourceSurface>& aSurface) {
if (aSurface->GetFormat() != SurfaceFormat::B8G8R8A8) {
  return false;
}
RefPtr<DataSourceSurface> dataSurf = aSurface->GetDataSurface();
if (!dataSurf) {
  return true;
}
DataSourceSurface::ScopedMap map(dataSurf, DataSourceSurface::READ);
if (!map.IsMapped()) {
  return true;
}
IntSize size = dataSurf->GetSize();
const uint8_t* data = map.GetData();
int32_t stride = map.GetStride();
for (int y = 0; y < size.height; y++) {
  const uint32_t* x = (const uint32_t*)data;
  const uint32_t* end = x + size.width;
  for (; x < end; x++) {
    // Verify if all components are the same as for premultiplied grayscale.
    uint32_t color = *x;
    uint32_t gray = color & 0xFF;
    gray |= gray << 8;
    gray |= gray << 16;
    if (color != gray) return true;
  }
  data += stride;
}
return false;
4536}

4538// Quantize the preblend color used to key the cache, as only the high bits are
4539// used to determine the amount of preblending. This avoids excessive cache use.
4540// This roughly matches the quantization used in WebRender and Skia.
4541static DeviceColor QuantizePreblendColor(const DeviceColor& aColor,
                                       bool aUseSubpixelAA) {
int32_t r = int32_t(aColor.r * 255.0f + 0.5f);
int32_t g = int32_t(aColor.g * 255.0f + 0.5f);
int32_t b = int32_t(aColor.b * 255.0f + 0.5f);
// Skia only uses the high 3 bits of each color component to cache preblend
// ramp tables.
constexpr int32_t lumBits = 3;
constexpr int32_t floorMask = ((1 << lumBits) - 1) << (8 - lumBits);
if (!aUseSubpixelAA) {
  // If not using subpixel AA, then quantize only the luminance, stored in the
  // G channel.
  g = (r * 54 + g * 183 + b * 19) >> 8;
  g &= floorMask;
  r = g;
  b = g;
} else {
  r &= floorMask;
  g &= floorMask;
  b &= floorMask;
}
return DeviceColor{r / 255.0f, g / 255.0f, b / 255.0f, 1.0f};
4563}

4565// Draws glyphs to the WebGL target by trying to generate a cached texture for
4566// the text run that can be subsequently reused to quickly render the text run
4567// without using any software surfaces.
4568bool SharedContextWebgl::DrawGlyphsAccel(ScaledFont* aFont,
                                       const GlyphBuffer& aBuffer,
                                       const Pattern& aPattern,
                                       const DrawOptions& aOptions,
                                       const StrokeOptions* aStrokeOptions,
                                       bool aUseSubpixelAA) {
// Look for an existing glyph cache on the font. If not there, create it.
GlyphCache* cache =
    static_cast<GlyphCache*>(aFont->GetUserData(&mGlyphCacheKey));
if (!cache) {
  cache = new GlyphCache(aFont);
  aFont->AddUserData(&mGlyphCacheKey, cache, ReleaseGlyphCache);
  mGlyphCaches.insertFront(cache);
}

// Check if the buffer contains non-renderable whitespace characters before
// any other expensive checks.
if (cache->IsWhitespace(aBuffer)) {
  return true;
}

// Whether the font may use bitmaps. If so, we need to render the glyphs with
// color as grayscale bitmaps will use the color while color emoji will not,
// with no easy way to know ahead of time. We currently have to check the
// rasterized result to see if there are any color glyphs. To render subpixel
// masks, we need to know that the rasterized result actually represents a
// subpixel mask rather than try to interpret it as a normal RGBA result such
// as for color emoji.
bool useBitmaps = !aStrokeOptions && aFont->MayUseBitmaps() &&
                  aOptions.mCompositionOp != CompositionOp::OP_CLEAR;
// Hash the incoming text run and looking for a matching entry.
DeviceColor color = aOptions.mCompositionOp == CompositionOp::OP_CLEAR
                        ? DeviceColor(1, 1, 1, 1)
                        : static_cast<const ColorPattern&>(aPattern).mColor;
4602#if defined(XP_MACOSX)
// macOS uses gamma-aware blending with font smooth from subpixel AA.
// If font smoothing is requested, even if there is no subpixel AA, gamma-
// aware blending might be used and differing amounts of dilation might be
// applied.
bool usePreblend = aUseSubpixelAA ||
                   (aFont->GetType() == FontType::MAC &&
                    static_cast<ScaledFontMac*>(aFont)->UseFontSmoothing());
4610#elif defined(XP_WIN)
// Windows uses gamma-aware blending via ClearType with grayscale and subpixel
// AA.
bool usePreblend =
    aUseSubpixelAA || aOptions.mAntialiasMode != AntialiasMode::NONE;
4615#else
// FreeType backends currently don't use any preblending.
bool usePreblend = false;
4618#endif

// If the font has bitmaps, use the color directly. Otherwise, the texture
// holds a grayscale mask, so encode the key's subpixel state in the color.
const Matrix& currentTransform = mCurrentTarget->GetTransform();
IntPoint quantizeScale = QuantizeScale(aFont, currentTransform);
Matrix quantizeTransform = currentTransform;
quantizeTransform.PostScale(quantizeScale.x, quantizeScale.y);
HashNumber hash =
    GlyphCacheEntry::HashGlyphs(aBuffer, quantizeTransform, quantizeScale);
DeviceColor colorOrMask =
    useBitmaps ? color
               : (usePreblend ? QuantizePreblendColor(color, aUseSubpixelAA)
                              : DeviceColor::Mask(aUseSubpixelAA ? 1 : 0, 1));
IntRect clipRect(IntPoint(), mViewportSize);
RefPtr<GlyphCacheEntry> entry =
    cache->FindEntry(aBuffer, colorOrMask, quantizeTransform, quantizeScale,
                     clipRect, hash, aStrokeOptions);
if (!entry) {
  // For small text runs, bounds computations can be expensive relative to the
  // cost of looking up a cache result. Avoid doing local bounds computations
  // until actually inserting the entry into the cache.
  Maybe<Rect> bounds = mCurrentTarget->mSkia->GetGlyphLocalBounds(
      aFont, aBuffer, aPattern, aStrokeOptions, aOptions);
  if (!bounds) {
    // Assume the buffer is full of whitespace characters that should be
    // remembered for subsequent lookups.
    cache->SetLastWhitespace(aBuffer);
    return true;
  }
  // Transform the local bounds into device space so that we know how big
  // the cached texture will be.
  Rect xformBounds = currentTransform.TransformBounds(*bounds);
  // Check if the transform flattens out the bounds before rounding.
  if (xformBounds.IsEmpty()) {
    return true;
  }
  IntRect fullBounds = RoundedOut(xformBounds);
  IntRect clipBounds = fullBounds.Intersect(clipRect);
  // Check if the bounds are completely clipped out.
  if (clipBounds.IsEmpty()) {
    return true;
  }
  entry = cache->InsertEntry(aBuffer, colorOrMask, quantizeTransform,
                             quantizeScale, clipBounds, fullBounds, hash,
                             aStrokeOptions);
  if (!entry) {
    return false;
  }
}

// The bounds of the entry may have a different transform offset from the
// bounds of the currently drawn text run. The entry bounds are relative to
// the entry's quantized offset already, so just move the bounds to the new
// offset.
IntRect intBounds = entry->GetBounds();
IntPoint newOffset =
    QuantizeOffset(quantizeTransform, quantizeScale, aBuffer);
intBounds +=
    IntPoint(newOffset.x / quantizeScale.x, newOffset.y / quantizeScale.y);
// Ensure there is a clear border around the text. This must be applied only
// after clipping so that we always have some border texels for filtering.
intBounds.Inflate(2);

RefPtr<TextureHandle> handle = entry->GetHandle();
if (handle && handle->IsValid()) {
  // If there is an entry with a valid cached texture handle, then try
  // to draw with that. If that for some reason failed, then fall back
  // to using the Skia target as that means we were preventing from
  // drawing to the WebGL context based on something other than the
  // texture.
  SurfacePattern pattern(nullptr, ExtendMode::CLAMP,
                         Matrix::Translation(intBounds.TopLeft()));
  if (DrawRectAccel(Rect(intBounds), pattern, aOptions,
                    useBitmaps ? Nothing() : Some(color), &handle, false,
                    true, true)) {
    return true;
  }
} else {
  handle = nullptr;

  // If we get here, either there wasn't a cached texture handle or it
  // wasn't valid. Render the text run into a temporary target.
  RefPtr<DrawTargetSkia> textDT = new DrawTargetSkia;
  if (textDT->Init(intBounds.Size(),
                   useBitmaps || usePreblend || aUseSubpixelAA
                       ? SurfaceFormat::B8G8R8A8
                       : SurfaceFormat::A8)) {
    textDT->SetTransform(currentTransform *
                         Matrix::Translation(-intBounds.TopLeft()));
    textDT->SetPermitSubpixelAA(aUseSubpixelAA);
    DrawOptions drawOptions(1.0f, CompositionOp::OP_OVER,
                            aOptions.mAntialiasMode);
    // If bitmaps might be used, then we have to supply the color, as color
    // emoji may ignore it while grayscale bitmaps may use it, with no way to
    // know ahead of time. If we are using preblending in some form, then the
    // output also will depend on the supplied color. Otherwise, assume the
    // output will be a mask and just render it white to determine intensity.
    if (!useBitmaps && usePreblend) {
      textDT->DrawGlyphMask(aFont, aBuffer, color, aStrokeOptions,
                            drawOptions);
    } else {
      ColorPattern colorPattern(useBitmaps ? color : DeviceColor(1, 1, 1, 1));
      if (aStrokeOptions) {
        textDT->StrokeGlyphs(aFont, aBuffer, colorPattern, *aStrokeOptions,
                             drawOptions);
      } else {
        textDT->FillGlyphs(aFont, aBuffer, colorPattern, drawOptions);
      }
    }
    RefPtr<SourceSurface> textSurface = textDT->Snapshot();
    if (textSurface) {
      // If we don't expect the text surface to contain color glyphs
      // such as from subpixel AA, then do one final check to see if
      // any ended up in the result. If not, extract the alpha values
      // from the surface so we can render it as a mask.
      if (textSurface->GetFormat() != SurfaceFormat::A8 &&
          !CheckForColorGlyphs(textSurface)) {
        textSurface = ExtractAlpha(textSurface, !useBitmaps);
        if (!textSurface) {
          // Failed extracting alpha for the text surface...
          return false;
        }
      }
      // Attempt to upload the rendered text surface into a texture
      // handle and draw it.
      SurfacePattern pattern(textSurface, ExtendMode::CLAMP,
                             Matrix::Translation(intBounds.TopLeft()));
      if (DrawRectAccel(Rect(intBounds), pattern, aOptions,
                        useBitmaps ? Nothing() : Some(color), &handle, false,
                        true) &&
          handle) {
        // If drawing succeeded, then the text surface was uploaded to
        // a texture handle. Assign it to the glyph cache entry.
        entry->Link(handle);
      } else {
        // If drawing failed, remove the entry from the cache.
        entry->Unlink();
      }
      return true;
    }
  }
}

// Avoid filling cache with empty entries.
entry->Unlink();
return false;
4765}

4767void DrawTargetWebgl::FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,
                               const Pattern& aPattern,
                               const DrawOptions& aOptions) {
if (!aFont || !aBuffer.mNumGlyphs) {
  return;
}

bool useSubpixelAA = ShouldUseSubpixelAA(aFont, aOptions);

if (mWebglValid && SupportsDrawOptions(aOptions) &&
    aPattern.GetType() == PatternType::COLOR && PrepareContext() &&
    mSharedContext->DrawGlyphsAccel(aFont, aBuffer, aPattern, aOptions,
                                    nullptr, useSubpixelAA)) {
  return;
}

// If not able to cache the text run to a texture, then just fall back to
// drawing with the Skia target.
if (useSubpixelAA) {
  // Subpixel AA does not support layering because the subpixel masks can't
  // blend with the over op.
  MarkSkiaChanged();
} else {
  MarkSkiaChanged(aOptions);
}
mSkia->FillGlyphs(aFont, aBuffer, aPattern, aOptions);
4793}

4795// Attempts to read the contents of the WebGL context into the Skia target.
4796bool DrawTargetWebgl::ReadIntoSkia() {
if (mSkiaValid) {
  return false;
}
bool didReadback = false;
if (mWebglValid) {
  uint8_t* data = nullptr;
  IntSize size;
  int32_t stride;
  SurfaceFormat format;
  if (mIsClear) {
    // If the WebGL target is still clear, then just clear the Skia target.
    mSkia->DetachAllSnapshots();
    mSkiaNoClip->FillRect(Rect(mSkiaNoClip->GetRect()), GetClearPattern(),
                          DrawOptions(1.0f, CompositionOp::OP_SOURCE));
  } else {
    // If there's no existing snapshot and we can successfully map the Skia
    // target for reading, then try to read into that.
    if (!mSnapshot && mSkia->LockBits(&data, &size, &stride, &format)) {
      (void)ReadInto(data, stride);
      mSkia->ReleaseBits(data);
    } else if (RefPtr<SourceSurface> snapshot = Snapshot()) {
      // Otherwise, fall back to getting a snapshot from WebGL if available
      // and then copying that to Skia.
      mSkia->CopySurface(snapshot, GetRect(), IntPoint(0, 0));
    }
    didReadback = true;
  }
}
mSkiaValid = true;
// The Skia data is flat after reading, so disable any layering.
mSkiaLayer = false;
return didReadback;
4829}

4831// Reads data from the WebGL context and blends it with the current Skia layer.
4832void DrawTargetWebgl::FlattenSkia() {
if (!mSkiaValid || !mSkiaLayer) {
  return;
}
mSkiaLayer = false;
if (mSkiaLayerClear) {
  // If the WebGL target is clear, then there is nothing to blend.
  return;
}
if (RefPtr<DataSourceSurface> base = ReadSnapshot()) {
  mSkia->DetachAllSnapshots();
  mSkiaNoClip->DrawSurface(base, Rect(GetRect()), Rect(GetRect()),
                           DrawSurfaceOptions(SamplingFilter::POINT),
                           DrawOptions(1.f, CompositionOp::OP_DEST_OVER));
}
4847}

4849// Attempts to draw the contents of the Skia target into the WebGL context.
4850bool DrawTargetWebgl::FlushFromSkia() {
// If the WebGL context has been lost, then mark it as invalid and fail.
if (mSharedContext->IsContextLost()) {
  mWebglValid = false;
  return false;
}
// The WebGL target is already valid, so there is nothing to do.
if (mWebglValid) {
  return true;
}
// Ensure that DrawRect doesn't recursively call into FlushFromSkia. If
// the Skia target isn't valid, then it doesn't matter what is in the the
// WebGL target either, so only try to blend if there is a valid Skia target.
mWebglValid = true;
if (mSkiaValid) {
  AutoRestoreContext restore(this);

  // If the Skia target is clear, then there is no need to use a snapshot.
  // Directly clear the WebGL target instead.
  if (mIsClear) {
    if (!DrawRect(Rect(GetRect()), GetClearPattern(),
                  DrawOptions(1.0f, CompositionOp::OP_SOURCE), Nothing(),
                  nullptr, false, false, true)) {
      mWebglValid = false;
      return false;
    }
    return true;
  }

  RefPtr<SourceSurface> skiaSnapshot = mSkia->Snapshot();
  if (!skiaSnapshot) {
    // There's a valid Skia target to draw to, but for some reason there is
    // no available snapshot, so just keep using the Skia target.
    mWebglValid = false;
    return false;
  }

  // If there is no layer, then just upload it directly.
  if (!mSkiaLayer) {
    if (PrepareContext(false) && MarkChanged()) {
      if (RefPtr<DataSourceSurface> data = skiaSnapshot->GetDataSurface()) {
        mSharedContext->UploadSurface(data, mFormat, GetRect(), IntPoint(),
                                      false, false, mTex);
        return true;
      }
    }
    // Failed to upload the Skia snapshot.
    mWebglValid = false;
    return false;
  }

  SurfacePattern pattern(skiaSnapshot, ExtendMode::CLAMP);
  // If there is a layer, blend the snapshot with the WebGL context.
  if (!DrawRect(Rect(GetRect()), pattern,
                DrawOptions(1.0f, CompositionOp::OP_OVER), Nothing(),
                &mSnapshotTexture, false, false, true, true)) {
    // If accelerated drawing failed for some reason, then leave the Skia
    // target unchanged.
    mWebglValid = false;
    return false;
  }
}
return true;
4913}

4915void DrawTargetWebgl::UsageProfile::BeginFrame() {
// Reset the usage profile counters for the new frame.
mFallbacks = 0;
mLayers = 0;
mCacheMisses = 0;
mCacheHits = 0;
mUncachedDraws = 0;
mReadbacks = 0;
4923}

4925void DrawTargetWebgl::UsageProfile::EndFrame() {
bool failed = false;
// If we hit a complete fallback to software rendering, or if cache misses
// were more than cutoff ratio of all requests, then we consider the frame as
// having failed performance profiling.
float cacheRatio =
    StaticPrefs::gfx_canvas_accelerated_profile_cache_miss_ratio();
if (mFallbacks > 0 ||
    float(mCacheMisses + mReadbacks + mLayers) >
        cacheRatio * float(mCacheMisses + mCacheHits + mUncachedDraws +
                           mReadbacks + mLayers)) {
  failed = true;
}
if (failed) {
  ++mFailedFrames;
}
++mFrameCount;
4942}

4944bool DrawTargetWebgl::UsageProfile::RequiresRefresh() const {
// If we've rendered at least the required number of frames for a profile and
// more than the cutoff ratio of frames did not meet performance criteria,
// then we should stop using an accelerated canvas.
uint32_t profileFrames = StaticPrefs::gfx_canvas_accelerated_profile_frames();
if (!profileFrames || mFrameCount < profileFrames) {
  return false;
}
float failRatio =
    StaticPrefs::gfx_canvas_accelerated_profile_fallback_ratio();
return mFailedFrames > failRatio * mFrameCount;
4955}

4957void SharedContextWebgl::CachePrefs() {
uint32_t capacity = StaticPrefs::gfx_canvas_accelerated_gpu_path_size() << 20;
if (capacity != mPathVertexCapacity) {
  mPathVertexCapacity = capacity;
  if (mPathCache) {
    mPathCache->ClearVertexRanges();
  }
  if (mPathVertexBuffer) {
    ResetPathVertexBuffer();
  }
}

mPathMaxComplexity =
    StaticPrefs::gfx_canvas_accelerated_gpu_path_complexity();

mPathAAStroke = StaticPrefs::gfx_canvas_accelerated_aa_stroke_enabled();
mPathWGRStroke = StaticPrefs::gfx_canvas_accelerated_stroke_to_fill_path();
4974}

4976// For use within CanvasRenderingContext2D, called on BorrowDrawTarget.
4977void DrawTargetWebgl::BeginFrame(bool aInvalidContents) {
// If still rendering into the Skia target, switch back to the WebGL
// context.
if (!mWebglValid) {
  if (aInvalidContents) {
    // If nothing needs to persist, just mark the WebGL context valid.
    mWebglValid = true;
    // Even if the Skia framebuffer is marked clear, since the WebGL
    // context is not valid, its contents may be out-of-date and not
    // necessarily clear.
    mIsClear = false;
  } else {
    FlushFromSkia();
  }
}
// Check if we need to clear out any cached because of memory pressure.
mSharedContext->ClearCachesIfNecessary();
// Cache any prefs for the frame.
mSharedContext->CachePrefs();
mProfile.BeginFrame();
4997}

4999// For use within CanvasRenderingContext2D, called on ReturnDrawTarget.
5000void DrawTargetWebgl::EndFrame() {
if (StaticPrefs::gfx_canvas_accelerated_debug()) {
  // Draw a green rectangle in the upper right corner to indicate
  // acceleration.
  IntRect corner = IntRect(mSize.width - 16, 0, 16, 16).Intersect(GetRect());
  DrawRect(Rect(corner), ColorPattern(DeviceColor(0.0f, 1.0f, 0.0f, 1.0f)),
           DrawOptions(), Nothing(), nullptr, false, false);
}
mProfile.EndFrame();
// Ensure we're not somehow using more than the allowed texture memory.
mSharedContext->PruneTextureMemory();
// Signal that we're done rendering the frame in case no present occurs.
mSharedContext->mWebgl->EndOfFrame();
// Check if we need to clear out any cached because of memory pressure.
mSharedContext->ClearCachesIfNecessary();
5015}

5017bool DrawTargetWebgl::CopyToSwapChain(
  layers::TextureType aTextureType, layers::RemoteTextureId aId,
  layers::RemoteTextureOwnerId aOwnerId,
  layers::RemoteTextureOwnerClient* aOwnerClient) {
if (!mWebglValid && !FlushFromSkia()) {
  return false;
}

// Copy and swizzle the WebGL framebuffer to the swap chain front buffer.
webgl::SwapChainOptions options;
options.bgra = true;
// Allow async present to be toggled on for accelerated Canvas2D
// independent of WebGL via pref.
options.forceAsyncPresent =
    StaticPrefs::gfx_canvas_accelerated_async_present();
options.remoteTextureId = aId;
options.remoteTextureOwnerId = aOwnerId;
return mSharedContext->mWebgl->CopyToSwapChain(mFramebuffer, aTextureType,
                                               options, aOwnerClient);
5036}

5038already_AddRefed<DrawTarget> DrawTargetWebgl::CreateSimilarDrawTarget(
  const IntSize& aSize, SurfaceFormat aFormat) const {
return mSkia->CreateSimilarDrawTarget(aSize, aFormat);
5041}

5043bool DrawTargetWebgl::CanCreateSimilarDrawTarget(const IntSize& aSize,
                                               SurfaceFormat aFormat) const {
return mSkia->CanCreateSimilarDrawTarget(aSize, aFormat);
5046}

5048RefPtr<DrawTarget> DrawTargetWebgl::CreateClippedDrawTarget(
  const Rect& aBounds, SurfaceFormat aFormat) {
return mSkia->CreateClippedDrawTarget(aBounds, aFormat);
5051}

5053already_AddRefed<SourceSurface> DrawTargetWebgl::CreateSourceSurfaceFromData(
  unsigned char* aData, const IntSize& aSize, int32_t aStride,
  SurfaceFormat aFormat) const {
return mSkia->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat);
5057}

5059already_AddRefed<SourceSurface>
5060DrawTargetWebgl::CreateSourceSurfaceFromNativeSurface(
  const NativeSurface& aSurface) const {
return mSkia->CreateSourceSurfaceFromNativeSurface(aSurface);
5063}

5065already_AddRefed<SourceSurface> DrawTargetWebgl::OptimizeSourceSurface(
  SourceSurface* aSurface) const {
if (aSurface->GetUnderlyingType() == SurfaceType::WEBGL) {
  return do_AddRef(aSurface);
}
return mSkia->OptimizeSourceSurface(aSurface);
5071}

5073already_AddRefed<SourceSurface>
5074DrawTargetWebgl::OptimizeSourceSurfaceForUnknownAlpha(
  SourceSurface* aSurface) const {
return mSkia->OptimizeSourceSurfaceForUnknownAlpha(aSurface);
5077}

5079already_AddRefed<GradientStops> DrawTargetWebgl::CreateGradientStops(
  GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode) const {
return mSkia->CreateGradientStops(aStops, aNumStops, aExtendMode);
5082}

5084already_AddRefed<FilterNode> DrawTargetWebgl::CreateFilter(FilterType aType) {
return mSkia->CreateFilter(aType);
5086}

5088void DrawTargetWebgl::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
                               const Point& aDestPoint,
                               const DrawOptions& aOptions) {
MarkSkiaChanged(aOptions);
mSkia->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
5093}

5095bool DrawTargetWebgl::Draw3DTransformedSurface(SourceSurface* aSurface,
                                             const Matrix4x4& aMatrix) {
MarkSkiaChanged();
return mSkia->Draw3DTransformedSurface(aSurface, aMatrix);
5099}

5101void DrawTargetWebgl::PushLayer(bool aOpaque, Float aOpacity,
                              SourceSurface* aMask,
                              const Matrix& aMaskTransform,
                              const IntRect& aBounds, bool aCopyBackground) {
PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, aBounds,
                   aCopyBackground, CompositionOp::OP_OVER);
5107}

5109void DrawTargetWebgl::PushLayerWithBlend(bool aOpaque, Float aOpacity,
                                       SourceSurface* aMask,
                                       const Matrix& aMaskTransform,
                                       const IntRect& aBounds,
                                       bool aCopyBackground,
                                       CompositionOp aCompositionOp) {
MarkSkiaChanged(DrawOptions(aOpacity, aCompositionOp));
mSkia->PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, aBounds,
                          aCopyBackground, aCompositionOp);
++mLayerDepth;
SetPermitSubpixelAA(mSkia->GetPermitSubpixelAA());
5120}

5122void DrawTargetWebgl::PopLayer() {
MOZ_ASSERT(mSkiaValid)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mSkiaValid)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mSkiaValid))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("mSkiaValid", "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp"
, 5123); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mSkiaValid"
 ")"); do { MOZ_CrashSequence(__null, 5123); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
MOZ_ASSERT(mLayerDepth > 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mLayerDepth > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mLayerDepth > 0))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mLayerDepth > 0"
, "/root/firefox-clang/dom/canvas/DrawTargetWebgl.cpp", 5124)
; AnnotateMozCrashReason("MOZ_ASSERT" "(" "mLayerDepth > 0"
 ")"); do { MOZ_CrashSequence(__null, 5124); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
--mLayerDepth;
mSkia->PopLayer();
SetPermitSubpixelAA(mSkia->GetPermitSubpixelAA());
5128}

5130}  // namespace mozilla::gfx

←

/root/firefox-clang/dom/canvas/DrawTargetWebglInternal.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_DRAWTARGETWEBGL_INTERNAL_H
8#define _MOZILLA_GFX_DRAWTARGETWEBGL_INTERNAL_H

10#include "DrawTargetWebgl.h"

12#include "mozilla/HashFunctions.h"
13#include "mozilla/gfx/Etagere.h"
14#include "mozilla/gfx/PathSkia.h"
15#include "mozilla/gfx/WPFGpuRaster.h"

17namespace mozilla::gfx {

19// CacheEnty is a generic interface for various items that need to be cached to
20// a texture.
21class CacheEntry : public RefCounted<CacheEntry> {
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(CacheEntry)virtual const char* typeName() const { return "CacheEntry"; }
 virtual size_t typeSize() const { return sizeof(*this); }

CacheEntry(const Matrix& aTransform, const IntRect& aBounds, HashNumber aHash)
    : mTransform(aTransform), mBounds(aBounds), mHash(aHash) {}
virtual ~CacheEntry() = default;

void Link(const RefPtr<TextureHandle>& aHandle);
void Unlink();

const RefPtr<TextureHandle>& GetHandle() const { return mHandle; }

const Matrix& GetTransform() const { return mTransform; }
const IntRect& GetBounds() const { return mBounds; }
HashNumber GetHash() const { return mHash; }

virtual bool IsValid() const { return true; }

protected:
virtual void RemoveFromList() = 0;

// The handle of the rendered cache item.
RefPtr<TextureHandle> mHandle;
// The transform that was used to render the entry. This is necessary as
// the geometry might only be correctly rendered in device space after
// the transform is applied, so in general we can't cache untransformed
// geometry.
Matrix mTransform;
// The device space bounds of the rendered geometry.
IntRect mBounds;
// A hash of the geometry that may be used for quickly rejecting entries.
HashNumber mHash;
54};

56// CacheEntryImpl provides type-dependent boilerplate code for implementations
57// of CacheEntry.
58template <typename T>
59class CacheEntryImpl : public CacheEntry, public LinkedListElement<RefPtr<T>> {
typedef LinkedListElement<RefPtr<T>> ListType;

public:
CacheEntryImpl(const Matrix& aTransform, const IntRect& aBounds,
               HashNumber aHash)
    : CacheEntry(aTransform, aBounds, aHash) {}

void RemoveFromList() override {
  if (ListType::isInList()) {
10
←
Taking true branch→
    ListType::remove();
11
←
Calling 'LinkedListElement::remove'→
26
←
Returning; memory was released→
  }
}
72};

74// CacheImpl manages a list of CacheEntry.
75template <typename T, bool BIG>
76class CacheImpl {
protected:
typedef LinkedList<RefPtr<T>> ListType;

// Whether the cache should be small and space-efficient or prioritize speed.
static constexpr size_t kNumChains = BIG ? 499 : 71;

public:
~CacheImpl() {
  for (auto& chain : mChains) {
    while (RefPtr<T> entry = chain.popLast()) {
3
←
Calling 'RefPtr::operator bool'→
5
←
Returning from 'RefPtr::operator bool'→
6
←
Loop condition is true.  Entering loop body→
      entry->Unlink();
7
←
Calling 'CacheEntry::Unlink'→
28
←
Returning; memory was released→
    }
29
←
Calling '~RefPtr'→
  }
}

protected:
ListType& GetChain(HashNumber aHash) { return mChains[aHash % kNumChains]; }

void Insert(T* aEntry) { GetChain(aEntry->GetHash()).insertFront(aEntry); }

ListType mChains[kNumChains];
98};

100// BackingTexture provides information about the shared or standalone texture
101// that is backing a texture handle.
102class BackingTexture {
public:
BackingTexture(const IntSize& aSize, SurfaceFormat aFormat,
               const RefPtr<WebGLTexture>& aTexture);

SurfaceFormat GetFormat() const { return mFormat; }
IntSize GetSize() const { return mSize; }

static inline size_t UsedBytes(SurfaceFormat aFormat, const IntSize& aSize) {
  return size_t(BytesPerPixel(aFormat)) * size_t(aSize.width) *
         size_t(aSize.height);
}

size_t UsedBytes() const { return UsedBytes(GetFormat(), GetSize()); }

const RefPtr<WebGLTexture>& GetWebGLTexture() const { return mTexture; }

bool IsInitialized() const { return mFlags & INITIALIZED; }
void MarkInitialized() { mFlags |= INITIALIZED; }

bool IsRenderable() const { return mFlags & RENDERABLE; }
void MarkRenderable() { mFlags |= RENDERABLE; }

protected:
IntSize mSize;
SurfaceFormat mFormat;
RefPtr<WebGLTexture> mTexture;

private:
enum Flags : uint8_t {
  INITIALIZED = 1 << 0,
  RENDERABLE = 1 << 1,
};

uint8_t mFlags = 0;
137};

139// TextureHandle is an abstract base class for supplying textures to drawing
140// commands that may be backed by different resource types (such as a shared
141// or standalone texture). It may be further linked to use-specific metadata
142// such as for shadow drawing or for cached entries in the glyph cache.
143class TextureHandle : public RefCounted<TextureHandle>,
                    public LinkedListElement<RefPtr<TextureHandle>> {
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(TextureHandle)virtual const char* typeName() const { return "TextureHandle"
; } virtual size_t typeSize() const { return sizeof(*this); }

enum Type { SHARED, STANDALONE };

virtual Type GetType() const = 0;
virtual IntRect GetBounds() const = 0;
IntSize GetSize() const { return GetBounds().Size(); }
virtual SurfaceFormat GetFormat() const = 0;

virtual BackingTexture* GetBackingTexture() = 0;

size_t UsedBytes() const {
  return BackingTexture::UsedBytes(GetFormat(), GetSize());
}

virtual void UpdateSize(const IntSize& aSize) {}

virtual void Cleanup(SharedContextWebgl& aContext) {}

virtual ~TextureHandle() {}

bool IsValid() const { return mValid; }
void Invalidate() { mValid = false; }

void ClearSurface() { mSurface = nullptr; }
void SetSurface(const RefPtr<SourceSurface>& aSurface) {
  mSurface = aSurface;
}
already_AddRefed<SourceSurface> GetSurface() const {
  RefPtr<SourceSurface> surface(mSurface);
  return surface.forget();
}

float GetSigma() const { return mSigma; }
void SetSigma(float aSigma) { mSigma = aSigma; }
bool IsShadow() const { return mSigma >= 0.0f; }

void SetSamplingOffset(const IntPoint& aSamplingOffset) {
  mSamplingOffset = aSamplingOffset;
}
const IntPoint& GetSamplingOffset() const { return mSamplingOffset; }
IntRect GetSamplingRect() const {
  return IntRect(GetSamplingOffset(), GetSize());
}

const RefPtr<CacheEntry>& GetCacheEntry() const { return mCacheEntry; }
void SetCacheEntry(const RefPtr<CacheEntry>& aEntry) { mCacheEntry = aEntry; }

// Note as used if there is corresponding surface or cache entry.
bool IsUsed() const {
  return !mSurface.IsDead() || (mCacheEntry && mCacheEntry->IsValid());
}

private:
bool mValid = true;
// If applicable, weak pointer to the SourceSurface that is linked to this
// TextureHandle.
ThreadSafeWeakPtr<SourceSurface> mSurface;
// If this TextureHandle stores a cached shadow, then we need to remember the
// blur sigma used to produce the shadow.
float mSigma = -1.0f;
// If the originating surface requested a sampling rect, then we need to know
// the offset of the subrect within the surface for texture coordinates.
IntPoint mSamplingOffset;
// If applicable, the CacheEntry that is linked to this TextureHandle.
RefPtr<CacheEntry> mCacheEntry;
212};

214class SharedTextureHandle;

216// SharedTexture is a large slab texture that is subdivided (by using a
217// TexturePacker) to hold many small SharedTextureHandles. This avoids needing
218// to allocate many WebGL textures for every single small Canvas 2D texture.
219class SharedTexture : public RefCounted<SharedTexture>, public BackingTexture {
public:
MOZ_DECLARE_REFCOUNTED_TYPENAME(SharedTexture)const char* typeName() const { return "SharedTexture"; } size_t
 typeSize() const { return sizeof(*this); }

SharedTexture(const IntSize& aSize, SurfaceFormat aFormat,
              const RefPtr<WebGLTexture>& aTexture);
~SharedTexture();

already_AddRefed<SharedTextureHandle> Allocate(const IntSize& aSize);
bool Free(SharedTextureHandle& aHandle);

bool HasAllocatedHandles() const {
  return mAtlasAllocator && Etagere::etagere_atlas_allocator_allocated_space(
                                mAtlasAllocator) > 0;
}

private:
Etagere::AtlasAllocator* mAtlasAllocator = nullptr;
237};

239// SharedTextureHandle is an allocated region within a large SharedTexture page
240// that owns it.
241class SharedTextureHandle : public TextureHandle {
friend class SharedTexture;

public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(SharedTextureHandle, override)virtual const char* typeName() const override { return "SharedTextureHandle"
; } virtual size_t typeSize() const override { return sizeof(
*this); }

SharedTextureHandle(Etagere::AllocationId aId, const IntRect& aBounds,
                    SharedTexture* aTexture);

Type GetType() const override { return Type::SHARED; }

IntRect GetBounds() const override { return mBounds; }

SurfaceFormat GetFormat() const override { return mTexture->GetFormat(); }

BackingTexture* GetBackingTexture() override { return mTexture.get(); }

void Cleanup(SharedContextWebgl& aContext) override;

const RefPtr<SharedTexture>& GetOwner() const { return mTexture; }

private:
Etagere::AllocationId mAllocationId = Etagere::INVALID_ALLOCATION_ID;
IntRect mBounds;
RefPtr<SharedTexture> mTexture;
266};

268// StandaloneTexture is a texture that can not be effectively shared within
269// a SharedTexture page, such that it is better to assign it its own WebGL
270// texture.
271class StandaloneTexture : public TextureHandle, public BackingTexture {
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(StandaloneTexture, override)virtual const char* typeName() const override { return "StandaloneTexture"
; } virtual size_t typeSize() const override { return sizeof(
*this); }

StandaloneTexture(const IntSize& aSize, SurfaceFormat aFormat,
                  const RefPtr<WebGLTexture>& aTexture);

Type GetType() const override { return Type::STANDALONE; }

IntRect GetBounds() const override {
  return IntRect(IntPoint(0, 0), BackingTexture::GetSize());
}

SurfaceFormat GetFormat() const override {
  return BackingTexture::GetFormat();
}

using BackingTexture::UsedBytes;

BackingTexture* GetBackingTexture() override { return this; }

void UpdateSize(const IntSize& aSize) override { mSize = aSize; }

void Cleanup(SharedContextWebgl& aContext) override;
295};

297// GlyphCacheEntry stores rendering metadata for a rendered text run, as well
298// the handle to the texture it was rendered into, so that it can be located
299// for reuse under similar rendering circumstances.
300class GlyphCacheEntry : public CacheEntryImpl<GlyphCacheEntry> {
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GlyphCacheEntry, override)virtual const char* typeName() const override { return "GlyphCacheEntry"
; } virtual size_t typeSize() const override { return sizeof(
*this); }

GlyphCacheEntry(const GlyphBuffer& aBuffer, const DeviceColor& aColor,
                const Matrix& aTransform, const IntPoint& aQuantizeScale,
                const IntRect& aBounds, const IntRect& aFullBounds,
                HashNumber aHash,
                StoredStrokeOptions* aStrokeOptions = nullptr);
~GlyphCacheEntry();

const GlyphBuffer& GetGlyphBuffer() const { return mBuffer; }

bool MatchesGlyphs(const GlyphBuffer& aBuffer, const DeviceColor& aColor,
                   const Matrix& aTransform, const IntPoint& aQuantizeOffset,
                   const IntPoint& aBoundsOffset, const IntRect& aClipRect,
                   HashNumber aHash, const StrokeOptions* aStrokeOptions);

static HashNumber HashGlyphs(const GlyphBuffer& aBuffer,
                             const Matrix& aTransform,
                             const IntPoint& aQuantizeScale);

private:
// The glyph keys used to render the text run.
GlyphBuffer mBuffer = {nullptr, 0};
// The color of the text run.
DeviceColor mColor;
// The full bounds of the text run without any clipping applied.
IntRect mFullBounds;
// Stroke options for the text run.
UniquePtr<StoredStrokeOptions> mStrokeOptions;
331};

333// GlyphCache maintains a list of GlyphCacheEntry's representing previously
334// rendered text runs. The cache is searched to see if a given incoming text
335// run has already been rendered to a texture, and if so, just reuses it.
336// Otherwise, the text run will be rendered to a new texture handle and
337// inserted into a new GlyphCacheEntry to represent it.
338class GlyphCache : public LinkedListElement<GlyphCache>,
                 public CacheImpl<GlyphCacheEntry, false> {
public:
explicit GlyphCache(ScaledFont* aFont);

ScaledFont* GetFont() const { return mFont; }

already_AddRefed<GlyphCacheEntry> FindEntry(const GlyphBuffer& aBuffer,
                                            const DeviceColor& aColor,
                                            const Matrix& aTransform,
                                            const IntPoint& aQuantizeScale,
                                            const IntRect& aClipRect,
                                            HashNumber aHash,
                                            const StrokeOptions* aOptions);

already_AddRefed<GlyphCacheEntry> InsertEntry(
    const GlyphBuffer& aBuffer, const DeviceColor& aColor,
    const Matrix& aTransform, const IntPoint& aQuantizeScale,
    const IntRect& aBounds, const IntRect& aFullBounds, HashNumber aHash,
    const StrokeOptions* aOptions);

bool IsWhitespace(const GlyphBuffer& aBuffer) const;
void SetLastWhitespace(const GlyphBuffer& aBuffer);

private:
// Weak pointer to the owning font
ScaledFont* mFont;
// The last whitespace queried from this cache
Maybe<uint32_t> mLastWhitespace;
367};

369struct QuantizedPath {
explicit QuantizedPath(const WGR::Path& aPath);
// Ensure the path can only be moved, but not copied.
QuantizedPath(QuantizedPath&&) noexcept;
QuantizedPath(const QuantizedPath&) = delete;
~QuantizedPath();

bool operator==(const QuantizedPath&) const;

WGR::Path mPath;
379};

381struct PathVertexRange {
uint32_t mOffset;
uint32_t mLength;

PathVertexRange() : mOffset(0), mLength(0) {}
PathVertexRange(uint32_t aOffset, uint32_t aLength)
    : mOffset(aOffset), mLength(aLength) {}

bool IsValid() const { return mLength > 0; }
390};

392enum class AAStrokeMode {
Unsupported,
Geometry,
Mask,
396};

398// PathCacheEntry stores a rasterized version of a supplied path with a given
399// pattern.
400class PathCacheEntry : public CacheEntryImpl<PathCacheEntry> {
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathCacheEntry, override)virtual const char* typeName() const override { return "PathCacheEntry"
; } virtual size_t typeSize() const override { return sizeof(
*this); }

PathCacheEntry(QuantizedPath&& aPath, Pattern* aPattern,
               StoredStrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
               const Matrix& aTransform, const IntRect& aBounds,
               const Point& aOrigin, HashNumber aHash, float aSigma = -1.0f);

bool MatchesPath(const QuantizedPath& aPath, const Pattern* aPattern,
                 const StrokeOptions* aStrokeOptions,
                 AAStrokeMode aStrokeMode, const Matrix& aTransform,
                 const IntRect& aBounds, const Point& aOrigin,
                 HashNumber aHash, float aSigma);

static HashNumber HashPath(const QuantizedPath& aPath,
                           const Pattern* aPattern, const Matrix& aTransform,
                           const IntRect& aBounds, const Point& aOrigin);

const QuantizedPath& GetPath() const { return mPath; }

const Point& GetOrigin() const { return mOrigin; }

// Valid if either a mask (no pattern) or there is valid pattern.
bool IsValid() const override { return !mPattern || mPattern->IsValid(); }

const PathVertexRange& GetVertexRange() const { return mVertexRange; }
void SetVertexRange(const PathVertexRange& aRange) { mVertexRange = aRange; }

private:
// The actual path geometry supplied
QuantizedPath mPath;
// The transformed origin of the path
Point mOrigin;
// The pattern used to rasterize the path, if not a mask
UniquePtr<Pattern> mPattern;
// The StrokeOptions used for stroked paths, if applicable
UniquePtr<StoredStrokeOptions> mStrokeOptions;
// The AAStroke mode used for rendering a stroked path.
AAStrokeMode mAAStrokeMode = AAStrokeMode::Unsupported;
// The shadow blur sigma
float mSigma;
// If the path has cached geometry in the vertex buffer.
PathVertexRange mVertexRange;
444};

446class PathCache : public CacheImpl<PathCacheEntry, true> {
public:
PathCache() = default;

already_AddRefed<PathCacheEntry> FindOrInsertEntry(
    QuantizedPath aPath, const Pattern* aPattern,
    const StrokeOptions* aStrokeOptions, AAStrokeMode aStrokeMode,
    const Matrix& aTransform, const IntRect& aBounds, const Point& aOrigin,
    float aSigma = -1.0f);

void ClearVertexRanges();
457};

459}  // namespace mozilla::gfx

461#endif  // _MOZILLA_GFX_DRAWTARGETWEBGL_INTERNAL_H

←

/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.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
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#ifndef mozilla_RefPtr_h
8#define mozilla_RefPtr_h
9 
10#include "mozilla/AlreadyAddRefed.h"
11#include "mozilla/Assertions.h"
12#include "mozilla/Attributes.h"
13#include "mozilla/DbgMacro.h"
14 
15#include <type_traits>
16 
17/*****************************************************************************/
18 
19// template <class T> class RefPtrGetterAddRefs;
20 
21class nsQueryReferent;
22class nsCOMPtr_helper;
23class nsISupports;
24 
25namespace mozilla {
26template <class T>
27class MovingNotNull;
28template <class T>
29class NotNull;
30template <class T>
31class OwningNonNull;
32template <class T>
33class StaticLocalRefPtr;
34template <class T>
35class StaticRefPtr;
36 
37// Traditionally, RefPtr supports automatic refcounting of any pointer type
38// with AddRef() and Release() methods that follow the traditional semantics.
39//
40// This traits class can be specialized to operate on other pointer types. For
41// example, we specialize this trait for opaque FFI types that represent
42// refcounted objects in Rust.
43//
44// Given the use of ConstRemovingRefPtrTraits below, U should not be a const-
45// qualified type.
46template <class U>
47struct RefPtrTraits {
48  static void AddRef(U* aPtr) { aPtr->AddRef(); }
49  static void Release(U* aPtr) { aPtr->Release(); }
50};
51 
52}  // namespace mozilla
53 
54template <class T>
55class MOZ_IS_REFPTR RefPtr {
56 private:
57  void assign_with_AddRef(T* aRawPtr) {
58    if (aRawPtr) {
59      ConstRemovingRefPtrTraits<T>::AddRef(aRawPtr);
60    }
61    assign_assuming_AddRef(aRawPtr);
62  }
63 
64  void assign_assuming_AddRef(T* aNewPtr) {
65    T* oldPtr = mRawPtr;
66    mRawPtr = aNewPtr;
67    if (oldPtr) {
68      ConstRemovingRefPtrTraits<T>::Release(oldPtr);
69    }
70  }
71 
72 private:
73  T* MOZ_OWNING_REF mRawPtr;
74 
75 public:
76  typedef T element_type;
77 
78  ~RefPtr() {
79    if (mRawPtr29.1
Field 'mRawPtr' is non-null
29.1
Field 'mRawPtr' is non-null
29.1
Field 'mRawPtr' is non-null
29.1
Field 'mRawPtr' is non-null
29.1
Field 'mRawPtr' is non-null
29.1
Field 'mRawPtr' is non-null
) {
30
←
Taking true branch→
80      ConstRemovingRefPtrTraits<T>::Release(mRawPtr);
31
←
Use of memory after it is freed
81    }
82  }
83 
84  // Constructors
85 
86  constexpr RefPtr()
87      : mRawPtr(nullptr)
88  // default constructor
89  {}
90 
91  RefPtr(const RefPtr<T>& aSmartPtr)
92      : mRawPtr(aSmartPtr.mRawPtr)
93  // copy-constructor
94  {
95    if (mRawPtr) {
96      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
97    }
98  }
99 
100  RefPtr(RefPtr<T>&& aRefPtr) noexcept : mRawPtr(aRefPtr.mRawPtr) {
101    aRefPtr.mRawPtr = nullptr;
102  }
103 
104  // construct from a raw pointer (of the right type)
105 
106  MOZ_IMPLICIT RefPtr(T* aRawPtr) : mRawPtr(aRawPtr) {
107    if (mRawPtr) {
108      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
109    }
110  }
111 
112  MOZ_IMPLICIT RefPtr(decltype(nullptr)) : mRawPtr(nullptr) {}
113 
114  template <typename I,
115            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
116  MOZ_IMPLICIT RefPtr(already_AddRefed<I>& aSmartPtr)
117      : mRawPtr(aSmartPtr.take())
118  // construct from |already_AddRefed|
119  {}
120 
121  template <typename I,
122            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
123  MOZ_IMPLICIT RefPtr(already_AddRefed<I>&& aSmartPtr)
124      : mRawPtr(aSmartPtr.take())
125  // construct from |otherRefPtr.forget()|
126  {}
127 
128  template <typename I,
129            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
130  MOZ_IMPLICIT RefPtr(const RefPtr<I>& aSmartPtr)
131      : mRawPtr(aSmartPtr.get())
132  // copy-construct from a smart pointer with a related pointer type
133  {
134    if (mRawPtr) {
135      ConstRemovingRefPtrTraits<T>::AddRef(mRawPtr);
136    }
137  }
138 
139  template <typename I,
140            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
141  MOZ_IMPLICIT RefPtr(RefPtr<I>&& aSmartPtr)
142      : mRawPtr(aSmartPtr.forget().take())
143  // construct from |Move(RefPtr<SomeSubclassOfT>)|.
144  {}
145 
146  template <typename I,
147            typename = std::enable_if_t<!std::is_same_v<I, RefPtr<T>> &&
148                                        std::is_convertible_v<I, RefPtr<T>>>>
149  MOZ_IMPLICIT RefPtr(const mozilla::NotNull<I>& aSmartPtr)
150      : mRawPtr(RefPtr<T>(aSmartPtr.get()).forget().take())
151  // construct from |mozilla::NotNull|.
152  {}
153 
154  template <typename I,
155            typename = std::enable_if_t<!std::is_same_v<I, RefPtr<T>> &&
156                                        std::is_convertible_v<I, RefPtr<T>>>>
157  MOZ_IMPLICIT RefPtr(mozilla::MovingNotNull<I>&& aSmartPtr)
158      : mRawPtr(RefPtr<T>(std::move(aSmartPtr).unwrapBasePtr()).forget().take())
159  // construct from |mozilla::MovingNotNull|.
160  {}
161 
162  MOZ_IMPLICIT RefPtr(const nsQueryReferent& aHelper);
163  MOZ_IMPLICIT RefPtr(const nsCOMPtr_helper& aHelper);
164 
165  // Defined in OwningNonNull.h
166  template <class U>
167  MOZ_IMPLICIT RefPtr(const mozilla::OwningNonNull<U>& aOther);
168 
169  // Defined in StaticLocalPtr.h
170  template <class U>
171  MOZ_IMPLICIT RefPtr(const mozilla::StaticLocalRefPtr<U>& aOther);
172 
173  // Defined in StaticPtr.h
174  template <class U>
175  MOZ_IMPLICIT RefPtr(const mozilla::StaticRefPtr<U>& aOther);
176 
177  // Assignment operators
178 
179  RefPtr<T>& operator=(decltype(nullptr)) {
180    assign_assuming_AddRef(nullptr);
181    return *this;
182  }
183 
184  RefPtr<T>& operator=(const RefPtr<T>& aRhs)
185  // copy assignment operator
186  {
187    assign_with_AddRef(aRhs.mRawPtr);
188    return *this;
189  }
190 
191  template <typename I>
192  RefPtr<T>& operator=(const RefPtr<I>& aRhs)
193  // assign from an RefPtr of a related pointer type
194  {
195    assign_with_AddRef(aRhs.get());
196    return *this;
197  }
198 
199  RefPtr<T>& operator=(T* aRhs)
200  // assign from a raw pointer (of the right type)
201  {
202    assign_with_AddRef(aRhs);
203    return *this;
204  }
205 
206  template <typename I>
207  RefPtr<T>& operator=(already_AddRefed<I>& aRhs)
208  // assign from |already_AddRefed|
209  {
210    assign_assuming_AddRef(aRhs.take());
211    return *this;
212  }
213 
214  template <typename I>
215  RefPtr<T>& operator=(already_AddRefed<I>&& aRhs)
216  // assign from |otherRefPtr.forget()|
217  {
218    assign_assuming_AddRef(aRhs.take());
219    return *this;
220  }
221 
222  RefPtr<T>& operator=(const nsQueryReferent& aQueryReferent);
223  RefPtr<T>& operator=(const nsCOMPtr_helper& aHelper);
224 
225  template <typename I,
226            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
227  RefPtr<T>& operator=(RefPtr<I>&& aRefPtr) noexcept {
228    assign_assuming_AddRef(aRefPtr.forget().take());
229    return *this;
230  }
231 
232  template <typename I,
233            typename = std::enable_if_t<std::is_convertible_v<I, RefPtr<T>>>>
234  RefPtr<T>& operator=(const mozilla::NotNull<I>& aSmartPtr)
235  // assign from |mozilla::NotNull|.
236  {
237    assign_assuming_AddRef(RefPtr<T>(aSmartPtr.get()).forget().take());
238    return *this;
239  }
240 
241  template <typename I,
242            typename = std::enable_if_t<std::is_convertible_v<I, RefPtr<T>>>>
243  RefPtr<T>& operator=(mozilla::MovingNotNull<I>&& aSmartPtr)
244  // assign from |mozilla::MovingNotNull|.
245  {
246    assign_assuming_AddRef(
247        RefPtr<T>(std::move(aSmartPtr).unwrapBasePtr()).forget().take());
248    return *this;
249  }
250 
251  // Defined in OwningNonNull.h
252  template <class U>
253  RefPtr<T>& operator=(const mozilla::OwningNonNull<U>& aOther);
254 
255  // Defined in StaticLocalPtr.h
256  template <class U>
257  RefPtr<T>& operator=(const mozilla::StaticLocalRefPtr<U>& aOther);
258 
259  // Defined in StaticPtr.h
260  template <class U>
261  RefPtr<T>& operator=(const mozilla::StaticRefPtr<U>& aOther);
262 
263  // Other pointer operators
264 
265  void swap(RefPtr<T>& aRhs)
266  // ...exchange ownership with |aRhs|; can save a pair of refcount operations
267  {
268    T* temp = aRhs.mRawPtr;
269    aRhs.mRawPtr = mRawPtr;
270    mRawPtr = temp;
271  }
272 
273  void swap(T*& aRhs)
274  // ...exchange ownership with |aRhs|; can save a pair of refcount operations
275  {
276    T* temp = aRhs;
277    aRhs = mRawPtr;
278    mRawPtr = temp;
279  }
280 
281  already_AddRefed<T> MOZ_MAY_CALL_AFTER_MUST_RETURN forget()
282  // return the value of mRawPtr and null out mRawPtr. Useful for
283  // already_AddRefed return values.
284  {
285    T* temp = nullptr;
286    swap(temp);
287    return already_AddRefed<T>(temp);
288  }
289 
290  template <typename I>
291  void forget(I** aRhs)
292  // Set the target of aRhs to the value of mRawPtr and null out mRawPtr.
293  // Useful to avoid unnecessary AddRef/Release pairs with "out"
294  // parameters where aRhs bay be a T** or an I** where I is a base class
295  // of T.
296  {
297    MOZ_ASSERT(aRhs, "Null pointer passed to forget!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRhs)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(aRhs))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("aRhs" " (" "Null pointer passed to forget!"
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 297); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRhs" ") (" "Null pointer passed to forget!"
 ")"); do { MOZ_CrashSequence(__null, 297); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
298    *aRhs = mRawPtr;
299    mRawPtr = nullptr;
300  }
301 
302  void forget(nsISupports** aRhs) {
303    MOZ_ASSERT(aRhs, "Null pointer passed to forget!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRhs)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(aRhs))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("aRhs" " (" "Null pointer passed to forget!"
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 303); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRhs" ") (" "Null pointer passed to forget!"
 ")"); do { MOZ_CrashSequence(__null, 303); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
304    *aRhs = ToSupports(mRawPtr);
305    mRawPtr = nullptr;
306  }
307 
308  T* get() const
309  /*
310    Prefer the implicit conversion provided automatically by |operator T*()
311    const|. Use |get()| to resolve ambiguity or to get a castable pointer.
312  */
313  {
314    return const_cast<T*>(mRawPtr);
315  }
316 
317  operator T*() const&
318  /*
319    ...makes an |RefPtr| act like its underlying raw pointer type whenever it
320    is used in a context where a raw pointer is expected.  It is this operator
321    that makes an |RefPtr| substitutable for a raw pointer.
322 
323    Prefer the implicit use of this operator to calling |get()|, except where
324    necessary to resolve ambiguity.
325  */
326  {
327    return get();
328  }
329 
330  // Don't allow implicit conversion of temporary RefPtr to raw pointer,
331  // because the refcount might be one and the pointer will immediately become
332  // invalid.
333  operator T*() const&& = delete;
334 
335  // These are needed to avoid the deleted operator above.  XXX Why is operator!
336  // needed separately?  Shouldn't the compiler prefer using the non-deleted
337  // operator bool instead of the deleted operator T*?
338  explicit operator bool() const { return !!mRawPtr; }
4
←
Assuming field 'mRawPtr' is non-null→
339  bool operator!() const { return !mRawPtr; }
340 
341  T* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN {
342    MOZ_ASSERT(mRawPtr != nullptr,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator->()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 343); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator->()."
 ")"); do { MOZ_CrashSequence(__null, 343); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
343               "You can't dereference a NULL RefPtr with operator->().")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator->()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 343); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator->()."
 ")"); do { MOZ_CrashSequence(__null, 343); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
344    return get();
345  }
346 
347  template <typename R, typename... Args>
348  class Proxy {
349    typedef R (T::*member_function)(Args...);
350    T* mRawPtr;
351    member_function mFunction;
352 
353   public:
354    Proxy(T* aRawPtr, member_function aFunction)
355        : mRawPtr(aRawPtr), mFunction(aFunction) {}
356    template <typename... ActualArgs>
357    R operator()(ActualArgs&&... aArgs) {
358      return ((*mRawPtr).*mFunction)(std::forward<ActualArgs>(aArgs)...);
359    }
360  };
361 
362  template <typename R, typename... Args>
363  Proxy<R, Args...> operator->*(R (T::*aFptr)(Args...)) const {
364    MOZ_ASSERT(mRawPtr != nullptr,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator->*()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 365); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator->*()."
 ")"); do { MOZ_CrashSequence(__null, 365); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
365               "You can't dereference a NULL RefPtr with operator->*().")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator->*()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 365); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator->*()."
 ")"); do { MOZ_CrashSequence(__null, 365); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
366    return Proxy<R, Args...>(get(), aFptr);
367  }
368 
369  RefPtr<T>* get_address()
370  // This is not intended to be used by clients.  See |address_of|
371  // below.
372  {
373    return this;
374  }
375 
376  const RefPtr<T>* get_address() const
377  // This is not intended to be used by clients.  See |address_of|
378  // below.
379  {
380    return this;
381  }
382 
383 public:
384  T& operator*() const {
385    MOZ_ASSERT(mRawPtr != nullptr,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator*()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 386); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator*()."
 ")"); do { MOZ_CrashSequence(__null, 386); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
386               "You can't dereference a NULL RefPtr with operator*().")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRawPtr != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRawPtr != nullptr))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("mRawPtr != nullptr"
 " (" "You can't dereference a NULL RefPtr with operator*()."
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefPtr.h"
, 386); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRawPtr != nullptr"
 ") (" "You can't dereference a NULL RefPtr with operator*()."
 ")"); do { MOZ_CrashSequence(__null, 386); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
387    return *get();
388  }
389 
390  T** StartAssignment() {
391    assign_assuming_AddRef(nullptr);
392    return reinterpret_cast<T**>(&mRawPtr);
393  }
394 
395 private:
396  // This helper class makes |RefPtr<const T>| possible by casting away
397  // the constness from the pointer when calling AddRef() and Release().
398  //
399  // This is necessary because AddRef() and Release() implementations can't
400  // generally expected to be const themselves (without heavy use of |mutable|
401  // and |const_cast| in their own implementations).
402  //
403  // This should be sound because while |RefPtr<const T>| provides a
404  // const view of an object, the object itself should not be const (it
405  // would have to be allocated as |new const T| or similar to be const).
406  template <class U>
407  struct ConstRemovingRefPtrTraits {
408    static void AddRef(U* aPtr) { mozilla::RefPtrTraits<U>::AddRef(aPtr); }
409    static void Release(U* aPtr) { mozilla::RefPtrTraits<U>::Release(aPtr); }
410  };
411  template <class U>
412  struct ConstRemovingRefPtrTraits<const U> {
413    static void AddRef(const U* aPtr) {
414      mozilla::RefPtrTraits<U>::AddRef(const_cast<U*>(aPtr));
415    }
416    static void Release(const U* aPtr) {
417      mozilla::RefPtrTraits<U>::Release(const_cast<U*>(aPtr));
418    }
419  };
420};
421 
422class nsCycleCollectionTraversalCallback;
423template <typename T>
424void CycleCollectionNoteChild(nsCycleCollectionTraversalCallback& aCallback,
425                              T* aChild, const char* aName, uint32_t aFlags);
426 
427template <typename T>
428inline void ImplCycleCollectionUnlink(RefPtr<T>& aField) {
429  aField = nullptr;
430}
431 
432template <typename T>
433inline void ImplCycleCollectionTraverse(
434    nsCycleCollectionTraversalCallback& aCallback, const RefPtr<T>& aField,
435    const char* aName, uint32_t aFlags = 0) {
436  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
437}
438 
439template <class T>
440inline RefPtr<T>* address_of(RefPtr<T>& aPtr) {
441  return aPtr.get_address();
442}
443 
444template <class T>
445inline const RefPtr<T>* address_of(const RefPtr<T>& aPtr) {
446  return aPtr.get_address();
447}
448 
449template <class T>
450class RefPtrGetterAddRefs
451/*
452  ...
453 
454  This class is designed to be used for anonymous temporary objects in the
455  argument list of calls that return COM interface pointers, e.g.,
456 
457    RefPtr<IFoo> fooP;
458    ...->GetAddRefedPointer(getter_AddRefs(fooP))
459 
460  DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
461 
462  When initialized with a |RefPtr|, as in the example above, it returns
463  a |void**|, a |T**|, or an |nsISupports**| as needed, that the
464  outer call (|GetAddRefedPointer| in this case) can fill in.
465 
466  This type should be a nested class inside |RefPtr<T>|.
467*/
468{
469 public:
470  explicit RefPtrGetterAddRefs(RefPtr<T>& aSmartPtr)
471      : mTargetSmartPtr(aSmartPtr) {
472    // nothing else to do
473  }
474 
475  operator void**() {
476    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
477  }
478 
479  operator T**() { return mTargetSmartPtr.StartAssignment(); }
480 
481  T*& operator*() { return *(mTargetSmartPtr.StartAssignment()); }
482 
483 private:
484  RefPtr<T>& mTargetSmartPtr;
485};
486 
487template <class T>
488inline RefPtrGetterAddRefs<T> getter_AddRefs(RefPtr<T>& aSmartPtr)
489/*
490  Used around a |RefPtr| when
491  ...makes the class |RefPtrGetterAddRefs<T>| invisible.
492*/
493{
494  return RefPtrGetterAddRefs<T>(aSmartPtr);
495}
496 
497// Comparing two |RefPtr|s
498 
499template <class T, class U>
500inline bool operator==(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs) {
501  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs.get());
502}
503 
504template <class T, class U>
505inline bool operator!=(const RefPtr<T>& aLhs, const RefPtr<U>& aRhs) {
506  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs.get());
507}
508 
509// Comparing an |RefPtr| to a raw pointer
510 
511template <class T, class U>
512inline bool operator==(const RefPtr<T>& aLhs, const U* aRhs) {
513  return static_cast<const T*>(aLhs.get()) == static_cast<const U*>(aRhs);
514}
515 
516template <class T, class U>
517inline bool operator==(const U* aLhs, const RefPtr<T>& aRhs) {
518  return static_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
519}
520 
521template <class T, class U>
522inline bool operator!=(const RefPtr<T>& aLhs, const U* aRhs) {
523  return static_cast<const T*>(aLhs.get()) != static_cast<const U*>(aRhs);
524}
525 
526template <class T, class U>
527inline bool operator!=(const U* aLhs, const RefPtr<T>& aRhs) {
528  return static_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
529}
530 
531template <class T, class U>
532inline bool operator==(const RefPtr<T>& aLhs, U* aRhs) {
533  return static_cast<const T*>(aLhs.get()) == const_cast<const U*>(aRhs);
534}
535 
536template <class T, class U>
537inline bool operator==(U* aLhs, const RefPtr<T>& aRhs) {
538  return const_cast<const U*>(aLhs) == static_cast<const T*>(aRhs.get());
539}
540 
541template <class T, class U>
542inline bool operator!=(const RefPtr<T>& aLhs, U* aRhs) {
543  return static_cast<const T*>(aLhs.get()) != const_cast<const U*>(aRhs);
544}
545 
546template <class T, class U>
547inline bool operator!=(U* aLhs, const RefPtr<T>& aRhs) {
548  return const_cast<const U*>(aLhs) != static_cast<const T*>(aRhs.get());
549}
550 
551// Comparing an |RefPtr| to |nullptr|
552 
553template <class T>
554inline bool operator==(const RefPtr<T>& aLhs, decltype(nullptr)) {
555  return aLhs.get() == nullptr;
556}
557 
558template <class T>
559inline bool operator==(decltype(nullptr), const RefPtr<T>& aRhs) {
560  return nullptr == aRhs.get();
561}
562 
563template <class T>
564inline bool operator!=(const RefPtr<T>& aLhs, decltype(nullptr)) {
565  return aLhs.get() != nullptr;
566}
567 
568template <class T>
569inline bool operator!=(decltype(nullptr), const RefPtr<T>& aRhs) {
570  return nullptr != aRhs.get();
571}
572 
573// MOZ_DBG support
574 
575template <class T>
576std::ostream& operator<<(std::ostream& aOut, const RefPtr<T>& aObj) {
577  return mozilla::DebugValue(aOut, aObj.get());
578}
579 
580/*****************************************************************************/
581 
582template <class T>
583inline already_AddRefed<T> do_AddRef(T* aObj) {
584  RefPtr<T> ref(aObj);
585  return ref.forget();
586}
587 
588template <class T>
589inline already_AddRefed<T> do_AddRef(const RefPtr<T>& aObj) {
590  RefPtr<T> ref(aObj);
591  return ref.forget();
592}
593 
594namespace mozilla {
595 
596template <typename T>
597class AlignmentFinder;
598 
599// Provide a specialization of AlignmentFinder to allow MOZ_ALIGNOF(RefPtr<T>)
600// with an incomplete T.
601template <typename T>
602class AlignmentFinder<RefPtr<T>> {
603 public:
604  static const size_t alignment = alignof(T*);
605};
606 
607/**
608 * Helper function to be able to conveniently write things like:
609 *
610 *   already_AddRefed<T>
611 *   f(...)
612 *   {
613 *     return MakeAndAddRef<T>(...);
614 *   }
615 */
616template <typename T, typename... Args>
617already_AddRefed<T> MakeAndAddRef(Args&&... aArgs) {
618  RefPtr<T> p(new T(std::forward<Args>(aArgs)...));
619  return p.forget();
620}
621 
622/**
623 * Helper function to be able to conveniently write things like:
624 *
625 *   auto runnable =
626 * MakeRefPtr<ErrorCallbackRunnable<nsIDOMGetUserMediaSuccessCallback>>(
627 *       mOnSuccess, mOnFailure, *error, mWindowID);
628 */
629template <typename T, typename... Args>
630RefPtr<T> MakeRefPtr(Args&&... aArgs) {
631  RefPtr<T> p(new T(std::forward<Args>(aArgs)...));
632  return p;
633}
634 
635}  // namespace mozilla
636 
637/**
638 * Deduction guide to allow simple `RefPtr` definitions from an
639 * already_AddRefed<T> without repeating the type, e.g.:
640 *
641 *   RefPtr ptr = MakeAndAddRef<SomeType>(...);
642 */
643template <typename T>
644RefPtr(already_AddRefed<T>) -> RefPtr<T>;
645 
646#endif /* mozilla_RefPtr_h */

←

/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.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/* A type-safe doubly-linked list class. */

9/*
* The classes LinkedList<T> and LinkedListElement<T> together form a
* convenient, type-safe doubly-linked list implementation.
*
* The class T which will be inserted into the linked list must inherit from
* LinkedListElement<T>.  A given object may be in only one linked list at a
* time.
*
* A LinkedListElement automatically removes itself from the list upon
* destruction, and a LinkedList will fatally assert in debug builds if it's
* non-empty when it's destructed.
*
* For example, you might use LinkedList in a simple observer list class as
* follows.
*
*   class Observer : public LinkedListElement<Observer>
*   {
*   public:
*     void observe(char* aTopic) { ... }
*   };
*
*   class ObserverContainer
*   {
*   private:
*     LinkedList<Observer> list;
*
*   public:
*     void addObserver(Observer* aObserver)
*     {
*       // Will assert if |aObserver| is part of another list.
*       list.insertBack(aObserver);
*     }
*
*     void removeObserver(Observer* aObserver)
*     {
*       // Will assert if |aObserver| is not part of some list.
*       aObserver.remove();
*       // Or, will assert if |aObserver| is not part of |list| specifically.
*       // aObserver.removeFrom(list);
*     }
*
*     void notifyObservers(char* aTopic)
*     {
*       for (Observer* o = list.getFirst(); o != nullptr; o = o->getNext()) {
*         o->observe(aTopic);
*       }
*     }
*   };
*
* Additionally, the class AutoCleanLinkedList<T> is a LinkedList<T> that will
* remove and delete each element still within itself upon destruction. Note
* that because each element is deleted, elements must have been allocated
* using |new|.
*/

64#ifndef mozilla_LinkedList_h
65#define mozilla_LinkedList_h

67#include <algorithm>
68#include <utility>

70#include "mozilla/Assertions.h"
71#include "mozilla/Attributes.h"
72#include "mozilla/MemoryReporting.h"
73#include "mozilla/RefPtr.h"

75#ifdef __cplusplus201703L

77namespace mozilla {

79template <typename T>
80class LinkedListElement;

82namespace detail {

84/**
* LinkedList supports refcounted elements using this adapter class. Clients
* using LinkedList<RefPtr<T>> will get a data structure that holds a strong
* reference to T as long as T is in the list.
*/
89template <typename T>
90struct LinkedListElementTraits {
typedef T* RawType;
typedef const T* ConstRawType;
typedef T* ClientType;
typedef const T* ConstClientType;

// These static methods are called when an element is added to or removed from
// a linked list. It can be used to keep track ownership in lists that are
// supposed to own their elements. If elements are transferred from one list
// to another, no enter or exit calls happen since the elements still belong
// to a list.
static void enterList(LinkedListElement<T>* elt) {}
static void exitList(LinkedListElement<T>* elt) {}

// This method is called when AutoCleanLinkedList cleans itself
// during destruction. It can be used to call delete on elements if
// the list is the sole owner.
static void cleanElement(LinkedListElement<T>* elt) { delete elt->asT(); }
108};

110template <typename T>
111struct LinkedListElementTraits<RefPtr<T>> {
typedef T* RawType;
typedef const T* ConstRawType;
typedef RefPtr<T> ClientType;
typedef RefPtr<const T> ConstClientType;

static void enterList(LinkedListElement<RefPtr<T>>* elt) {
  elt->asT()->AddRef();
}
static void exitList(LinkedListElement<RefPtr<T>>* elt) {
  elt->asT()->Release();
15
←
Calling 'RefCounted::Release'→
24
←
Returning; memory was released→
}
static void cleanElement(LinkedListElement<RefPtr<T>>* elt) {}
124};

126} /* namespace detail */

128template <typename T>
129class LinkedList;

131template <typename T>
132class LinkedListElement {
typedef typename detail::LinkedListElementTraits<T> Traits;
typedef typename Traits::RawType RawType;
typedef typename Traits::ConstRawType ConstRawType;
typedef typename Traits::ClientType ClientType;
typedef typename Traits::ConstClientType ConstClientType;

/*
 * It's convenient that we return nullptr when getNext() or getPrevious()
 * hits the end of the list, but doing so costs an extra word of storage in
 * each linked list node (to keep track of whether |this| is the sentinel
 * node) and a branch on this value in getNext/getPrevious.
 *
 * We could get rid of the extra word of storage by shoving the "is
 * sentinel" bit into one of the pointers, although this would, of course,
 * have performance implications of its own.
 *
 * But the goal here isn't to win an award for the fastest or slimmest
 * linked list; rather, we want a *convenient* linked list.  So we won't
 * waste time guessing which micro-optimization strategy is best.
 *
 *
 * Speaking of unnecessary work, it's worth addressing here why we wrote
 * mozilla::LinkedList in the first place, instead of using stl::list.
 *
 * The key difference between mozilla::LinkedList and stl::list is that
 * mozilla::LinkedList stores the mPrev/mNext pointers in the object itself,
 * while stl::list stores the mPrev/mNext pointers in a list element which
 * itself points to the object being stored.
 *
 * mozilla::LinkedList's approach makes it harder to store an object in more
 * than one list.  But the upside is that you can call next() / prev() /
 * remove() directly on the object.  With stl::list, you'd need to store a
 * pointer to its iterator in the object in order to accomplish this.  Not
 * only would this waste space, but you'd have to remember to update that
 * pointer every time you added or removed the object from a list.
 *
 * In-place, constant-time removal is a killer feature of doubly-linked
 * lists, and supporting this painlessly was a key design criterion.
 */

private:
LinkedListElement* mNext;
LinkedListElement* mPrev;
const bool mIsSentinel;

public:
LinkedListElement() : mNext(this), mPrev(this), mIsSentinel(false) {}

/*
 * Moves |aOther| into |*this|. If |aOther| is already in a list, then
 * |aOther| is removed from the list and replaced by |*this|.
 */
LinkedListElement(LinkedListElement<T>&& aOther)
    : mIsSentinel(aOther.mIsSentinel) {
  adjustLinkForMove(std::move(aOther));
}

LinkedListElement& operator=(LinkedListElement<T>&& aOther) {
  MOZ_ASSERT(mIsSentinel == aOther.mIsSentinel, "Mismatch NodeKind!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mIsSentinel == aOther.mIsSentinel)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mIsSentinel == aOther.mIsSentinel
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mIsSentinel == aOther.mIsSentinel" " (" "Mismatch NodeKind!"
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 191); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIsSentinel == aOther.mIsSentinel"
 ") (" "Mismatch NodeKind!" ")"); do { MOZ_CrashSequence(__null
, 191); __attribute__((nomerge)) ::abort(); } while (false); }
 } while (false);
  MOZ_ASSERT(!isInList(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isInList()))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("!isInList()" " ("
 "Assigning to an element in a list messes up that list!" ")"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 193); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!isInList()"
 ") (" "Assigning to an element in a list messes up that list!"
 ")"); do { MOZ_CrashSequence(__null, 193); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
             "Assigning to an element in a list messes up that list!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isInList()))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("!isInList()" " ("
 "Assigning to an element in a list messes up that list!" ")"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 193); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!isInList()"
 ") (" "Assigning to an element in a list messes up that list!"
 ")"); do { MOZ_CrashSequence(__null, 193); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  adjustLinkForMove(std::move(aOther));
  return *this;
}

~LinkedListElement() {
  if (!mIsSentinel && isInList()) {
    remove();
  }
}

/*
 * Get the next element in the list, or nullptr if this is the last element
 * in the list.
 */
RawType getNext() { return mNext->asT(); }
ConstRawType getNext() const { return mNext->asT(); }

/*
 * Get the previous element in the list, or nullptr if this is the first
 * element in the list.
 */
RawType getPrevious() { return mPrev->asT(); }
ConstRawType getPrevious() const { return mPrev->asT(); }

/*
 * Insert aElem after this element in the list.  |this| must be part of a
 * linked list when you call setNext(); otherwise, this method will assert.
 */
void setNext(RawType aElem) {
  MOZ_ASSERT(isInList())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isInList()))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("isInList()", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 223); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isInList()" ")"
); do { MOZ_CrashSequence(__null, 223); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  setNextUnsafe(aElem);
}

/*
 * Insert aElem before this element in the list.  |this| must be part of a
 * linked list when you call setPrevious(); otherwise, this method will
 * assert.
 */
void setPrevious(RawType aElem) {
  MOZ_ASSERT(isInList())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isInList()))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("isInList()", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 233); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isInList()" ")"
); do { MOZ_CrashSequence(__null, 233); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  setPreviousUnsafe(aElem);
}

/*
 * Remove this element from the list which contains it.  If this element is
 * not currently part of a linked list, this method asserts.
 */
void remove() {
  MOZ_ASSERT(isInList())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isInList()))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("isInList()", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 242); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isInList()" ")"
); do { MOZ_CrashSequence(__null, 242); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
12
←
Taking false branch→
13
←
Loop condition is false.  Exiting loop→

  mPrev->mNext = mNext;
  mNext->mPrev = mPrev;
  mNext = this;
  mPrev = this;

  Traits::exitList(this);
14
←
Calling 'LinkedListElementTraits::exitList'→
25
←
Returning; memory was released via 1st parameter→
}

/*
 * Remove this element from the list containing it.  Returns a pointer to the
 * element that follows this element (before it was removed).  This method
 * asserts if the element does not belong to a list. Note: In a refcounted
 * list, |this| may be destroyed.
 */
RawType removeAndGetNext() {
  RawType r = getNext();
  remove();
  return r;
}

/*
 * Remove this element from the list containing it.  Returns a pointer to the
 * previous element in the containing list (before the removal).  This method
 * asserts if the element does not belong to a list. Note: In a refcounted
 * list, |this| may be destroyed.
 */
RawType removeAndGetPrevious() {
  RawType r = getPrevious();
  remove();
  return r;
}

/*
 * Identical to remove(), but also asserts in debug builds that this element
 * is in aList.
 */
void removeFrom(const LinkedList<T>& aList) {
  aList.assertContains(asT());
  remove();
}

/*
 * Return true if |this| part is of a linked list, and false otherwise.
 */
bool isInList() const {
  MOZ_ASSERT((mNext == this) == (mPrev == this))do { static_assert( mozilla::detail::AssertionConditionType<
decltype((mNext == this) == (mPrev == this))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((mNext == this) == (mPrev ==
 this)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("(mNext == this) == (mPrev == this)", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 289); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(mNext == this) == (mPrev == this)"
 ")"); do { MOZ_CrashSequence(__null, 289); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return mNext != this;
}

private:
friend class LinkedList<T>;
friend struct detail::LinkedListElementTraits<T>;

enum class NodeKind { Normal, Sentinel };

explicit LinkedListElement(NodeKind nodeKind)
    : mNext(this), mPrev(this), mIsSentinel(nodeKind == NodeKind::Sentinel) {}

/*
 * Return |this| cast to T* if we're a normal node, or return nullptr if
 * we're a sentinel node.
 */
RawType asT() { return mIsSentinel ? nullptr : static_cast<RawType>(this); }
ConstRawType asT() const {
  return mIsSentinel ? nullptr : static_cast<ConstRawType>(this);
}

/*
 * Insert aElem after this element, but don't check that this element is in
 * the list.  This is called by LinkedList::insertFront().
 */
void setNextUnsafe(RawType aElem) {
  LinkedListElement* listElem = static_cast<LinkedListElement*>(aElem);
  MOZ_RELEASE_ASSERT(!listElem->isInList())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!listElem->isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!listElem->isInList()))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("!listElem->isInList()"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 317); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "!listElem->isInList()"
 ")"); do { MOZ_CrashSequence(__null, 317); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  listElem->mNext = this->mNext;
  listElem->mPrev = this;
  this->mNext->mPrev = listElem;
  this->mNext = listElem;

  Traits::enterList(aElem);
}

/*
 * Insert aElem before this element, but don't check that this element is in
 * the list.  This is called by LinkedList::insertBack().
 */
void setPreviousUnsafe(RawType aElem) {
  LinkedListElement<T>* listElem = static_cast<LinkedListElement<T>*>(aElem);
  MOZ_RELEASE_ASSERT(!listElem->isInList())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!listElem->isInList())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!listElem->isInList()))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("!listElem->isInList()"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 333); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "!listElem->isInList()"
 ")"); do { MOZ_CrashSequence(__null, 333); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  listElem->mNext = this;
  listElem->mPrev = this->mPrev;
  this->mPrev->mNext = listElem;
  this->mPrev = listElem;

  Traits::enterList(aElem);
}

/*
 * Transfers the elements [aBegin, aEnd) before the "this" list element.
 */
void transferBeforeUnsafe(LinkedListElement<T>& aBegin,
                          LinkedListElement<T>& aEnd) {
  MOZ_RELEASE_ASSERT(!aBegin.mIsSentinel)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aBegin.mIsSentinel)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aBegin.mIsSentinel))), 0)))
 { do { } while (false); MOZ_ReportAssertionFailure("!aBegin.mIsSentinel"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 348); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "!aBegin.mIsSentinel"
 ")"); do { MOZ_CrashSequence(__null, 348); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  if (!aBegin.isInList() || !aEnd.isInList()) {
    return;
  }

  auto otherPrev = aBegin.mPrev;

  aBegin.mPrev = this->mPrev;
  this->mPrev->mNext = &aBegin;
  this->mPrev = aEnd.mPrev;
  aEnd.mPrev->mNext = this;

  // Patch the gap in the source list
  otherPrev->mNext = &aEnd;
  aEnd.mPrev = otherPrev;
}

/*
 * Adjust mNext and mPrev for implementing move constructor and move
 * assignment.
 */
void adjustLinkForMove(LinkedListElement<T>&& aOther) {
  if (!aOther.isInList()) {
    mNext = this;
    mPrev = this;
    return;
  }

  if (!mIsSentinel) {
    Traits::enterList(this);
  }

  MOZ_ASSERT(aOther.mNext->mPrev == &aOther)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aOther.mNext->mPrev == &aOther)>::isValid,
 "invalid assertion condition"); if ((__builtin_expect(!!(!(!
!(aOther.mNext->mPrev == &aOther))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("aOther.mNext->mPrev == &aOther"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 380); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aOther.mNext->mPrev == &aOther"
 ")"); do { MOZ_CrashSequence(__null, 380); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(aOther.mPrev->mNext == &aOther)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aOther.mPrev->mNext == &aOther)>::isValid,
 "invalid assertion condition"); if ((__builtin_expect(!!(!(!
!(aOther.mPrev->mNext == &aOther))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("aOther.mPrev->mNext == &aOther"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 381); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aOther.mPrev->mNext == &aOther"
 ")"); do { MOZ_CrashSequence(__null, 381); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  /*
   * Initialize |this| with |aOther|'s mPrev/mNext pointers, and adjust those
   * element to point to this one.
   */
  mNext = aOther.mNext;
  mPrev = aOther.mPrev;

  mNext->mPrev = this;
  mPrev->mNext = this;

  /*
   * Adjust |aOther| so it doesn't think it's in a list.  This makes it
   * safely destructable.
   */
  aOther.mNext = &aOther;
  aOther.mPrev = &aOther;

  if (!mIsSentinel) {
    Traits::exitList(&aOther);
  }
}

LinkedListElement& operator=(const LinkedListElement<T>& aOther) = delete;
LinkedListElement(const LinkedListElement<T>& aOther) = delete;
407};

409template <typename T>
410class LinkedList {
private:
using Traits = typename detail::LinkedListElementTraits<T>;
using RawType = typename Traits::RawType;
using ConstRawType = typename Traits::ConstRawType;
using ClientType = typename Traits::ClientType;
using ConstClientType = typename Traits::ConstClientType;
using ElementType = LinkedListElement<T>*;
using ConstElementType = const LinkedListElement<T>*;

LinkedListElement<T> sentinel;

public:
template <typename Type, typename Element>
class Iterator {
  Type mCurrent;

 public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = T*;
  using reference = T&;

  explicit Iterator(Type aCurrent) : mCurrent(aCurrent) {}

  Type operator*() const { return mCurrent; }

  const Iterator& operator++() {
    mCurrent = static_cast<Element>(mCurrent)->getNext();
    return *this;
  }

  bool operator!=(const Iterator& aOther) const {
    return mCurrent != aOther.mCurrent;
  }
};

using const_iterator = Iterator<ConstRawType, ConstElementType>;
using iterator = Iterator<RawType, ElementType>;

LinkedList() : sentinel(LinkedListElement<T>::NodeKind::Sentinel) {}

LinkedList(LinkedList<T>&& aOther) : sentinel(std::move(aOther.sentinel)) {}

LinkedList& operator=(LinkedList<T>&& aOther) {
  MOZ_ASSERT(isEmpty(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isEmpty())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isEmpty()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isEmpty()" " (" "Assigning to a non-empty list leaks elements in that list!"
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 457); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isEmpty()" ") ("
 "Assigning to a non-empty list leaks elements in that list!"
 ")"); do { MOZ_CrashSequence(__null, 457); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
             "Assigning to a non-empty list leaks elements in that list!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isEmpty())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isEmpty()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isEmpty()" " (" "Assigning to a non-empty list leaks elements in that list!"
 ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 457); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isEmpty()" ") ("
 "Assigning to a non-empty list leaks elements in that list!"
 ")"); do { MOZ_CrashSequence(__null, 457); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  sentinel = std::move(aOther.sentinel);
  return *this;
}

~LinkedList() {
463#  ifdef DEBUG1
  if (!isEmpty()) {
    MOZ_CRASH_UNSAFE_PRINTF(do { static_assert(1 > 0, "Did you forget arguments to MOZ_CRASH_UNSAFE_PRINTF? "
 "Or maybe you want MOZ_CRASH instead?"); static_assert(1 <=
 sPrintfMaxArgs, "Only up to 4 additional arguments are allowed!"
); static_assert(sizeof("%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction") <= sPrintfCrashReasonSize, "The supplied format string is too long!"
); MOZ_Crash("/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 469, MOZ_CrashPrintf("" "%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction", __PRETTY_FUNCTION__)); } while (false
)
        "%s has a buggy user: "do { static_assert(1 > 0, "Did you forget arguments to MOZ_CRASH_UNSAFE_PRINTF? "
 "Or maybe you want MOZ_CRASH instead?"); static_assert(1 <=
 sPrintfMaxArgs, "Only up to 4 additional arguments are allowed!"
); static_assert(sizeof("%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction") <= sPrintfCrashReasonSize, "The supplied format string is too long!"
); MOZ_Crash("/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 469, MOZ_CrashPrintf("" "%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction", __PRETTY_FUNCTION__)); } while (false
)
        "it should have removed all this list's elements before "do { static_assert(1 > 0, "Did you forget arguments to MOZ_CRASH_UNSAFE_PRINTF? "
 "Or maybe you want MOZ_CRASH instead?"); static_assert(1 <=
 sPrintfMaxArgs, "Only up to 4 additional arguments are allowed!"
); static_assert(sizeof("%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction") <= sPrintfCrashReasonSize, "The supplied format string is too long!"
); MOZ_Crash("/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 469, MOZ_CrashPrintf("" "%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction", __PRETTY_FUNCTION__)); } while (false
)
        "the list's destruction",do { static_assert(1 > 0, "Did you forget arguments to MOZ_CRASH_UNSAFE_PRINTF? "
 "Or maybe you want MOZ_CRASH instead?"); static_assert(1 <=
 sPrintfMaxArgs, "Only up to 4 additional arguments are allowed!"
); static_assert(sizeof("%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction") <= sPrintfCrashReasonSize, "The supplied format string is too long!"
); MOZ_Crash("/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 469, MOZ_CrashPrintf("" "%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction", __PRETTY_FUNCTION__)); } while (false
)
        __PRETTY_FUNCTION__)do { static_assert(1 > 0, "Did you forget arguments to MOZ_CRASH_UNSAFE_PRINTF? "
 "Or maybe you want MOZ_CRASH instead?"); static_assert(1 <=
 sPrintfMaxArgs, "Only up to 4 additional arguments are allowed!"
); static_assert(sizeof("%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction") <= sPrintfCrashReasonSize, "The supplied format string is too long!"
); MOZ_Crash("/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 469, MOZ_CrashPrintf("" "%s has a buggy user: " "it should have removed all this list's elements before "
 "the list's destruction", __PRETTY_FUNCTION__)); } while (false
);
  }
471#  endif
}

/*
 * Add aElem to the front of the list.
 */
void insertFront(RawType aElem) {
  /* Bypass setNext()'s this->isInList() assertion. */
  sentinel.setNextUnsafe(aElem);
}

/*
 * Add aElem to the back of the list.
 */
void insertBack(RawType aElem) { sentinel.setPreviousUnsafe(aElem); }

/*
 * Move all elements from another list to the back
 */
void extendBack(LinkedList<T>&& aOther) {
  MOZ_RELEASE_ASSERT(this != &aOther)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this != &aOther)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(this != &aOther))), 0)))
 { do { } while (false); MOZ_ReportAssertionFailure("this != &aOther"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 491); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "this != &aOther"
 ")"); do { MOZ_CrashSequence(__null, 491); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  if (aOther.isEmpty()) {
    return;
  }
  sentinel.transferBeforeUnsafe(**aOther.begin(), aOther.sentinel);
}

/*
 * Move elements from another list to the specified position
 */
void splice(size_t aDestinationPos, LinkedList<T>& aListFrom,
            size_t aSourceStart, size_t aSourceLen) {
  MOZ_RELEASE_ASSERT(this != &aListFrom)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this != &aListFrom)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(this != &aListFrom))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("this != &aListFrom"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 503); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "this != &aListFrom"
 ")"); do { MOZ_CrashSequence(__null, 503); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  if (aListFrom.isEmpty() || !aSourceLen) {
    return;
  }

  const auto safeForward = [](LinkedList<T>& aList,
                              LinkedListElement<T>& aBegin,
                              size_t aPos) -> LinkedListElement<T>& {
    auto* iter = &aBegin;
    for (size_t i = 0; i < aPos; ++i, (iter = iter->mNext)) {
      if (iter->mIsSentinel) {
        break;
      }
    }
    return *iter;
  };

  auto& sourceBegin =
      safeForward(aListFrom, *aListFrom.sentinel.mNext, aSourceStart);
  if (sourceBegin.mIsSentinel) {
    return;
  }
  auto& sourceEnd = safeForward(aListFrom, sourceBegin, aSourceLen);
  auto& destination = safeForward(*this, *sentinel.mNext, aDestinationPos);

  destination.transferBeforeUnsafe(sourceBegin, sourceEnd);
}

/*
 * Get the first element of the list, or nullptr if the list is empty.
 */
RawType getFirst() { return sentinel.getNext(); }
ConstRawType getFirst() const { return sentinel.getNext(); }

/*
 * Get the last element of the list, or nullptr if the list is empty.
 */
RawType getLast() { return sentinel.getPrevious(); }
ConstRawType getLast() const { return sentinel.getPrevious(); }

/*
 * Get and remove the first element of the list.  If the list is empty,
 * return nullptr.
 */
ClientType popFirst() {
  ClientType ret = sentinel.getNext();
  if (ret) {
    static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
  }
  return ret;
}

/*
 * Get and remove the last element of the list.  If the list is empty,
 * return nullptr.
 */
ClientType popLast() {
  ClientType ret = sentinel.getPrevious();
  if (ret) {
    static_cast<LinkedListElement<T>*>(RawType(ret))->remove();
  }
  return ret;
}

/*
 * Return true if the list is empty, or false otherwise.
 */
bool isEmpty() const { return !sentinel.isInList(); }

/**
 * Returns whether the given element is in the list.
 */
bool contains(ConstRawType aElm) const {
  return std::find(begin(), end(), aElm) != end();
}

/*
 * Remove all the elements from the list.
 *
 * This runs in time linear to the list's length, because we have to mark
 * each element as not in the list.
 */
void clear() {
  while (popFirst()) {
  }
}

/**
 * Return the length of elements in the list.
 */
size_t length() const { return std::distance(begin(), end()); }

/*
 * Allow range-based iteration:
 *
 *     for (MyElementType* elt : myList) { ... }
 */
Iterator<RawType, ElementType> begin() {
  return Iterator<RawType, ElementType>(getFirst());
}
Iterator<ConstRawType, ConstElementType> begin() const {
  return Iterator<ConstRawType, ConstElementType>(getFirst());
}
Iterator<RawType, ElementType> end() {
  return Iterator<RawType, ElementType>(nullptr);
}
Iterator<ConstRawType, ConstElementType> end() const {
  return Iterator<ConstRawType, ConstElementType>(nullptr);
}

/*
 * Measures the memory consumption of the list excluding |this|.  Note that
 * it only measures the list elements themselves.  If the list elements
 * contain pointers to other memory blocks, those blocks must be measured
 * separately during a subsequent iteration over the list.
 */
size_t sizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
  size_t n = 0;
  ConstRawType t = getFirst();
  while (t) {
    n += aMallocSizeOf(t);
    t = static_cast<const LinkedListElement<T>*>(t)->getNext();
  }
  return n;
}

/*
 * Like sizeOfExcludingThis(), but measures |this| as well.
 */
size_t sizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(this) + sizeOfExcludingThis(aMallocSizeOf);
}

/*
 * In a debug build, make sure that the list is sane (no cycles, consistent
 * mNext/mPrev pointers, only one sentinel).  Has no effect in release builds.
 */
void debugAssertIsSane() const {
641#  ifdef DEBUG1
  const LinkedListElement<T>* slow;
  const LinkedListElement<T>* fast1;
  const LinkedListElement<T>* fast2;

  /*
   * Check for cycles in the forward singly-linked list using the
   * tortoise/hare algorithm.
   */
  for (slow = sentinel.mNext, fast1 = sentinel.mNext->mNext,
      fast2 = sentinel.mNext->mNext->mNext;
       slow != &sentinel && fast1 != &sentinel && fast2 != &sentinel;
       slow = slow->mNext, fast1 = fast2->mNext, fast2 = fast1->mNext) {
    MOZ_ASSERT(slow != fast1)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(slow != fast1)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(slow != fast1))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("slow != fast1",
 "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 654); AnnotateMozCrashReason("MOZ_ASSERT" "(" "slow != fast1"
 ")"); do { MOZ_CrashSequence(__null, 654); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(slow != fast2)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(slow != fast2)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(slow != fast2))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("slow != fast2",
 "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 655); AnnotateMozCrashReason("MOZ_ASSERT" "(" "slow != fast2"
 ")"); do { MOZ_CrashSequence(__null, 655); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  }

  /* Check for cycles in the backward singly-linked list. */
  for (slow = sentinel.mPrev, fast1 = sentinel.mPrev->mPrev,
      fast2 = sentinel.mPrev->mPrev->mPrev;
       slow != &sentinel && fast1 != &sentinel && fast2 != &sentinel;
       slow = slow->mPrev, fast1 = fast2->mPrev, fast2 = fast1->mPrev) {
    MOZ_ASSERT(slow != fast1)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(slow != fast1)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(slow != fast1))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("slow != fast1",
 "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 663); AnnotateMozCrashReason("MOZ_ASSERT" "(" "slow != fast1"
 ")"); do { MOZ_CrashSequence(__null, 663); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(slow != fast2)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(slow != fast2)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(slow != fast2))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("slow != fast2",
 "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 664); AnnotateMozCrashReason("MOZ_ASSERT" "(" "slow != fast2"
 ")"); do { MOZ_CrashSequence(__null, 664); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  }

  /*
   * Check that |sentinel| is the only node in the list with
   * mIsSentinel == true.
   */
  for (const LinkedListElement<T>* elem = sentinel.mNext; elem != &sentinel;
       elem = elem->mNext) {
    MOZ_ASSERT(!elem->mIsSentinel)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!elem->mIsSentinel)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!elem->mIsSentinel))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("!elem->mIsSentinel"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 673); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!elem->mIsSentinel"
 ")"); do { MOZ_CrashSequence(__null, 673); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  }

  /* Check that the mNext/mPrev pointers match up. */
  const LinkedListElement<T>* prev = &sentinel;
  const LinkedListElement<T>* cur = sentinel.mNext;
  do {
    MOZ_ASSERT(cur->mPrev == prev)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(cur->mPrev == prev)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(cur->mPrev == prev))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("cur->mPrev == prev"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 680); AnnotateMozCrashReason("MOZ_ASSERT" "(" "cur->mPrev == prev"
 ")"); do { MOZ_CrashSequence(__null, 680); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(prev->mNext == cur)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(prev->mNext == cur)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(prev->mNext == cur))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("prev->mNext == cur"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 681); AnnotateMozCrashReason("MOZ_ASSERT" "(" "prev->mNext == cur"
 ")"); do { MOZ_CrashSequence(__null, 681); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

    prev = cur;
    cur = cur->mNext;
  } while (cur != &sentinel);
686#  endif /* ifdef DEBUG */
}

private:
friend class LinkedListElement<T>;

void assertContains(const RawType aValue) const {
693#  ifdef DEBUG1
  for (ConstRawType elem = getFirst(); elem; elem = elem->getNext()) {
    if (elem == aValue) {
      return;
    }
  }
  MOZ_CRASH("element wasn't found in this list!")do { do { } while (false); MOZ_ReportCrash("" "element wasn't found in this list!"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/LinkedList.h"
, 699); AnnotateMozCrashReason("MOZ_CRASH(" "element wasn't found in this list!"
 ")"); do { MOZ_CrashSequence(__null, 699); __attribute__((nomerge
)) ::abort(); } while (false); } while (false);
700#  endif
}

LinkedList& operator=(const LinkedList<T>& aOther) = delete;
LinkedList(const LinkedList<T>& aOther) = delete;
705};

707template <typename T>
708size_t RangeSizeEstimate(const LinkedList<T>&) {
return 0;
710}

712template <typename T>
713inline void ImplCycleCollectionUnlink(LinkedList<RefPtr<T>>& aField) {
aField.clear();
715}

717template <typename T>
718inline void ImplCycleCollectionTraverse(
  nsCycleCollectionTraversalCallback& aCallback,
  LinkedList<RefPtr<T>>& aField, const char* aName, uint32_t aFlags = 0) {
typedef typename detail::LinkedListElementTraits<T> Traits;
typedef typename Traits::RawType RawType;
for (RawType element : aField) {
  // RefPtr is stored as a raw pointer in LinkedList.
  // So instead of creating a new RefPtr from the raw
  // pointer (which is not allowed), we simply call
  // CycleCollectionNoteChild against the raw pointer
  CycleCollectionNoteChild(aCallback, element, aName, aFlags);
}
730}

732template <typename T>
733class AutoCleanLinkedList : public LinkedList<T> {
private:
using Traits = detail::LinkedListElementTraits<T>;
using ClientType = typename detail::LinkedListElementTraits<T>::ClientType;

public:
AutoCleanLinkedList() = default;
AutoCleanLinkedList(AutoCleanLinkedList&&) = default;
~AutoCleanLinkedList() { clear(); }

AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther) = default;

void clear() {
  while (ClientType element = this->popFirst()) {
    Traits::cleanElement(element);
  }
}
750};

752} /* namespace mozilla */

754#endif /* __cplusplus */

756#endif /* mozilla_LinkedList_h */

←

/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.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
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/* CRTP refcounting templates.  Do not use unless you are an Expert. */
8 
9#ifndef mozilla_RefCounted_h
10#define mozilla_RefCounted_h
11 
12#include <utility>
13#include <type_traits>
14 
15#include "mozilla/AlreadyAddRefed.h"
16#include "mozilla/Assertions.h"
17#include "mozilla/Atomics.h"
18#include "mozilla/Attributes.h"
19#include "mozilla/RefCountType.h"
20 
21#ifdef __wasi__
22#  include "mozilla/WasiAtomic.h"
23#else
24#  include <atomic>
25#endif  // __wasi__
26 
27#if defined(MOZ_SUPPORT_LEAKCHECKING1) && defined(NS_BUILD_REFCNT_LOGGING1)
28#  define MOZ_REFCOUNTED_LEAK_CHECKING
29#endif
30 
31namespace mozilla {
32 
33/**
34 * RefCounted<T> is a sort of a "mixin" for a class T.  RefCounted
35 * manages, well, refcounting for T, and because RefCounted is
36 * parameterized on T, RefCounted<T> can call T's destructor directly.
37 * This means T doesn't need to have a virtual dtor and so doesn't
38 * need a vtable.
39 *
40 * RefCounted<T> is created with refcount == 0.  Newly-allocated
41 * RefCounted<T> must immediately be assigned to a RefPtr to make the
42 * refcount > 0.  It's an error to allocate and free a bare
43 * RefCounted<T>, i.e. outside of the RefPtr machinery.  Attempts to
44 * do so will abort DEBUG builds.
45 *
46 * Live RefCounted<T> have refcount > 0.  The lifetime (refcounts) of
47 * live RefCounted<T> are controlled by RefPtr<T> and
48 * RefPtr<super/subclass of T>.  Upon a transition from refcounted==1
49 * to 0, the RefCounted<T> "dies" and is destroyed.  The "destroyed"
50 * state is represented in DEBUG builds by refcount==0xffffdead.  This
51 * state distinguishes use-before-ref (refcount==0) from
52 * use-after-destroy (refcount==0xffffdead).
53 *
54 * Note that when deriving from RefCounted or AtomicRefCounted, you
55 * should add MOZ_DECLARE_REFCOUNTED_TYPENAME(ClassName) to the public
56 * section of your class, where ClassName is the name of your class.
57 */
58namespace detail {
59const MozRefCountType DEAD = 0xffffdead;
60 
61#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
62// When this header is included in SpiderMonkey code, NS_LogAddRef and
63// NS_LogRelease are not available. To work around this, we call these
64// functions through a function pointer set by SetLeakCheckingFunctions.
65// Note: these are globals because GCC on Linux reports undefined-reference
66// errors when they're static members of the RefCountLogger class.
67using LogAddRefFunc = void (*)(void* aPtr, MozRefCountType aNewRefCnt,
68                               const char* aTypeName, uint32_t aClassSize);
69using LogReleaseFunc = void (*)(void* aPtr, MozRefCountType aNewRefCnt,
70                                const char* aTypeName);
71extern MFBT_DATA__attribute__((weak)) __attribute__((visibility("default"))) LogAddRefFunc gLogAddRefFunc;
72extern MFBT_DATA__attribute__((weak)) __attribute__((visibility("default"))) LogReleaseFunc gLogReleaseFunc;
73extern MFBT_DATA__attribute__((weak)) __attribute__((visibility("default"))) size_t gNumStaticCtors;
74extern MFBT_DATA__attribute__((weak)) __attribute__((visibility("default"))) const char* gLastStaticCtorTypeName;
75#endif
76 
77// When building code that gets compiled into Gecko, try to use the
78// trace-refcount leak logging facilities.
79class RefCountLogger {
80 public:
81  // Called by `RefCounted`-like classes to log a successful AddRef call in the
82  // Gecko leak-logging system. This call is a no-op outside of Gecko. Should be
83  // called afer incrementing the reference count.
84  template <class T>
85  static void logAddRef(const T* aPointer, MozRefCountType aRefCount) {
86#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
87    const void* pointer = aPointer;
88    const char* typeName = aPointer->typeName();
89    uint32_t typeSize = aPointer->typeSize();
90    if (gLogAddRefFunc) {
91      gLogAddRefFunc(const_cast<void*>(pointer), aRefCount, typeName, typeSize);
92    } else {
93      gNumStaticCtors++;
94      gLastStaticCtorTypeName = typeName;
95    }
96#endif
97  }
98 
99#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
100  static MFBT_API__attribute__((weak)) __attribute__((visibility("default"))) void SetLeakCheckingFunctions(LogAddRefFunc aLogAddRefFunc,
101                                                LogReleaseFunc aLogReleaseFunc);
102#endif
103 
104  // Created by `RefCounted`-like classes to log a successful Release call in
105  // the Gecko leak-logging system. The constructor should be invoked before the
106  // refcount is decremented to avoid invoking `typeName()` with a zero
107  // reference count. This call is a no-op outside of Gecko.
108  class MOZ_STACK_CLASS ReleaseLogger final {
109   public:
110    template <class T>
111    explicit ReleaseLogger(const T* aPointer)
112#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
113        : mPointer(aPointer),
114          mTypeName(aPointer->typeName())
115#endif
116    {
117    }
118 
119    void logRelease(MozRefCountType aRefCount) {
120#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
121      MOZ_ASSERT(aRefCount != DEAD)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRefCount != DEAD)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aRefCount != DEAD))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("aRefCount != DEAD"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 121); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRefCount != DEAD"
 ")"); do { MOZ_CrashSequence(__null, 121); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
122      if (gLogReleaseFunc) {
123        gLogReleaseFunc(const_cast<void*>(mPointer), aRefCount, mTypeName);
124      } else {
125        gNumStaticCtors++;
126        gLastStaticCtorTypeName = mTypeName;
127      }
128#endif
129    }
130 
131#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
132    const void* mPointer;
133    const char* mTypeName;
134#endif
135  };
136};
137 
138// This is used WeakPtr.h as well as this file.
139enum RefCountAtomicity { AtomicRefCount, NonAtomicRefCount };
140 
141template <typename T, RefCountAtomicity Atomicity>
142class RC {
143 public:
144  explicit RC(T aCount) : mValue(aCount) {}
145 
146  RC(const RC&) = delete;
147  RC& operator=(const RC&) = delete;
148  RC(RC&&) = delete;
149  RC& operator=(RC&&) = delete;
150 
151  T operator++() { return ++mValue; }
152  T operator--() { return --mValue; }
153 
154#ifdef DEBUG1
155  void operator=(const T& aValue) { mValue = aValue; }
156#endif
157 
158  operator T() const { return mValue; }
159 
160 private:
161  T mValue;
162};
163 
164template <typename T>
165class RC<T, AtomicRefCount> {
166 public:
167  explicit RC(T aCount) : mValue(aCount) {}
168 
169  RC(const RC&) = delete;
170  RC& operator=(const RC&) = delete;
171  RC(RC&&) = delete;
172  RC& operator=(RC&&) = delete;
173 
174  T operator++() {
175    // Memory synchronization is not required when incrementing a
176    // reference count.  The first increment of a reference count on a
177    // thread is not important, since the first use of the object on a
178    // thread can happen before it.  What is important is the transfer
179    // of the pointer to that thread, which may happen prior to the
180    // first increment on that thread.  The necessary memory
181    // synchronization is done by the mechanism that transfers the
182    // pointer between threads.
183    return mValue.fetch_add(1, std::memory_order_relaxed) + 1;
184  }
185 
186  T operator--() {
187    // Since this may be the last release on this thread, we need
188    // release semantics so that prior writes on this thread are visible
189    // to the thread that destroys the object when it reads mValue with
190    // acquire semantics.
191    T result = mValue.fetch_sub(1, std::memory_order_release) - 1;
192    if (result == 0) {
193      // We're going to destroy the object on this thread, so we need
194      // acquire semantics to synchronize with the memory released by
195      // the last release on other threads, that is, to ensure that
196      // writes prior to that release are now visible on this thread.
197#if defined(MOZ_TSAN) || defined(__wasi__)
198      // TSan doesn't understand std::atomic_thread_fence, so in order
199      // to avoid a false positive for every time a refcounted object
200      // is deleted, we replace the fence with an atomic operation.
201      mValue.load(std::memory_order_acquire);
202#else
203      std::atomic_thread_fence(std::memory_order_acquire);
204#endif
205    }
206    return result;
207  }
208 
209#ifdef DEBUG1
210  // This method is only called in debug builds, so we're not too concerned
211  // about its performance.
212  void operator=(const T& aValue) {
213    mValue.store(aValue, std::memory_order_seq_cst);
214  }
215#endif
216 
217  operator T() const {
218    // Use acquire semantics since we're not sure what the caller is
219    // doing.
220    return mValue.load(std::memory_order_acquire);
221  }
222 
223  T IncrementIfNonzero() {
224    // This can be a relaxed load as any write of 0 that we observe will leave
225    // the field in a permanently zero (or `DEAD`) state (so a "stale" read of 0
226    // is fine), and any other value is confirmed by the CAS below.
227    //
228    // This roughly matches rust's Arc::upgrade implementation as of rust 1.49.0
229    T prev = mValue.load(std::memory_order_relaxed);
230    while (prev != 0) {
231      MOZ_ASSERT(prev != detail::DEAD,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(prev != detail::DEAD)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(prev != detail::DEAD))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("prev != detail::DEAD"
 " (" "Cannot IncrementIfNonzero if marked as dead!" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 232); AnnotateMozCrashReason("MOZ_ASSERT" "(" "prev != detail::DEAD"
 ") (" "Cannot IncrementIfNonzero if marked as dead!" ")"); do
 { MOZ_CrashSequence(__null, 232); __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
232                 "Cannot IncrementIfNonzero if marked as dead!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(prev != detail::DEAD)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(prev != detail::DEAD))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("prev != detail::DEAD"
 " (" "Cannot IncrementIfNonzero if marked as dead!" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 232); AnnotateMozCrashReason("MOZ_ASSERT" "(" "prev != detail::DEAD"
 ") (" "Cannot IncrementIfNonzero if marked as dead!" ")"); do
 { MOZ_CrashSequence(__null, 232); __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
233      // TODO: It may be possible to use relaxed success ordering here?
234      if (mValue.compare_exchange_weak(prev, prev + 1,
235                                       std::memory_order_acquire,
236                                       std::memory_order_relaxed)) {
237        return prev + 1;
238      }
239    }
240    return 0;
241  }
242 
243 private:
244  std::atomic<T> mValue;
245};
246 
247template <typename T, RefCountAtomicity Atomicity>
248class RefCounted {
249 protected:
250  RefCounted() : mRefCnt(0) {}
251#ifdef DEBUG1
252  ~RefCounted() { MOZ_ASSERT(mRefCnt == detail::DEAD)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRefCnt == detail::DEAD)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRefCnt == detail::DEAD))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("mRefCnt == detail::DEAD"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 252); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRefCnt == detail::DEAD"
 ")"); do { MOZ_CrashSequence(__null, 252); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); }
253#endif
254 
255 public:
256  // Compatibility with RefPtr.
257  void AddRef() const {
258    // Note: this method must be thread safe for AtomicRefCounted.
259    MOZ_ASSERT(int32_t(mRefCnt) >= 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 259); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
 ")"); do { MOZ_CrashSequence(__null, 259); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
260    MozRefCountType cnt = ++mRefCnt;
261    detail::RefCountLogger::logAddRef(static_cast<const T*>(this), cnt);
262  }
263 
264  void Release() const {
265    // Note: this method must be thread safe for AtomicRefCounted.
266    MOZ_ASSERT(int32_t(mRefCnt) > 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(int32_t(mRefCnt) > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 266); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
 ")"); do { MOZ_CrashSequence(__null, 266); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
16
←
Assuming the condition is true→
17
←
Taking false branch→
18
←
Loop condition is false.  Exiting loop→
267    detail::RefCountLogger::ReleaseLogger logger(static_cast<const T*>(this));
268    MozRefCountType cnt = --mRefCnt;
269    // Note: it's not safe to touch |this| after decrementing the refcount,
270    // except for below.
271    logger.logRelease(cnt);
272    if (0 == cnt) {
19
←
Assuming 'cnt' is equal to 0→
20
←
Taking true branch→
273      // Because we have atomically decremented the refcount above, only
274      // one thread can get a 0 count here, so as long as we can assume that
275      // everything else in the system is accessing this object through
276      // RefPtrs, it's safe to access |this| here.
277#ifdef DEBUG1
278      mRefCnt = detail::DEAD;
279#endif
280      delete static_cast<const T*>(this);
21
←
Calling 'operator delete'→
23
←
Returning from 'operator delete'→
281    }
282  }
283 
284  using HasThreadSafeRefCnt =
285      std::integral_constant<bool, Atomicity == AtomicRefCount>;
286 
287  // Compatibility with wtf::RefPtr.
288  void ref() { AddRef(); }
289  void deref() { Release(); }
290  MozRefCountType refCount() const { return mRefCnt; }
291  bool hasOneRef() const {
292    MOZ_ASSERT(mRefCnt > 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mRefCnt > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mRefCnt > 0))), 0))) { do
 { } while (false); MOZ_ReportAssertionFailure("mRefCnt > 0"
, "/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/mozilla/RefCounted.h"
, 292); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRefCnt > 0"
 ")"); do { MOZ_CrashSequence(__null, 292); __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
293    return mRefCnt == 1;
294  }
295 
296 private:
297  mutable RC<MozRefCountType, Atomicity> mRefCnt;
298};
299 
300#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
301// Passing override for the optional argument marks the typeName and
302// typeSize functions defined by this macro as overrides.
303#  define MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(T, ...)virtual const char* typeName() const ... { return "T"; } virtual
 size_t typeSize() const ... { return sizeof(*this); }           \
304    virtual const char* typeName() const __VA_ARGS__ { return #T; } \
305    virtual size_t typeSize() const __VA_ARGS__ { return sizeof(*this); }
306#else
307#  define MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(T, ...)virtual const char* typeName() const ... { return "T"; } virtual
 size_t typeSize() const ... { return sizeof(*this); }
308#endif
309 
310// Note that this macro is expanded unconditionally because it declares only
311// two small inline functions which will hopefully get eliminated by the linker
312// in non-leak-checking builds.
313#define MOZ_DECLARE_REFCOUNTED_TYPENAME(T)const char* typeName() const { return "T"; } size_t typeSize(
) const { return sizeof(*this); }    \
314  const char* typeName() const { return #T; } \
315  size_t typeSize() const { return sizeof(*this); }
316 
317}  // namespace detail
318 
319template <typename T>
320class RefCounted : public detail::RefCounted<T, detail::NonAtomicRefCount> {
321 public:
322  ~RefCounted() {
323    static_assert(std::is_base_of<RefCounted, T>::value,
324                  "T must derive from RefCounted<T>");
325  }
326};
327 
328namespace external {
329 
330/**
331 * AtomicRefCounted<T> is like RefCounted<T>, with an atomically updated
332 * reference counter.
333 *
334 * NOTE: Please do not use this class, use NS_INLINE_DECL_THREADSAFE_REFCOUNTING
335 * instead.
336 */
337template <typename T>
338class AtomicRefCounted
339    : public mozilla::detail::RefCounted<T, mozilla::detail::AtomicRefCount> {
340 public:
341  ~AtomicRefCounted() {
342    static_assert(std::is_base_of<AtomicRefCounted, T>::value,
343                  "T must derive from AtomicRefCounted<T>");
344  }
345};
346 
347}  // namespace external
348 
349}  // namespace mozilla
350 
351#endif  // mozilla_RefCounted_h

←

/root/firefox-clang/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 
45// Inlining `new` like this is technically against C++ spec, but we crave perf.
46MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void* operator new[](size_t size,
47                                         const std::nothrow_t&) noexcept(true) {
48#ifdef __GNUC__4
49// GCC-14 codegen at -O2 causes false positive due to converting
50// `new A[n]` to `malloc(-1)` when `n > PTRDIFF_MAX/sizeof(A)`.
51// (See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85783, WONTFIX'd)
52#  pragma GCC diagnostic push
53#  pragma GCC diagnostic ignored "-Walloc-size-larger-than="
54#endif
55 
56  return malloc_implmalloc(size);
57 
58#ifdef __GNUC__4
59#  pragma GCC diagnostic pop
60#endif
61}
62 
63MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr) noexcept(true) {
64  return free_implfree(ptr);
22
←
Memory is released→
65}
66 
67MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr,
68                                         const std::nothrow_t&) noexcept(true) {
69  return free_implfree(ptr);
70}
71 
72MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](void* ptr) noexcept(true) {
73  return free_implfree(ptr);
74}
75 
76MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](
77    void* ptr, const std::nothrow_t&) noexcept(true) {
78  return free_implfree(ptr);
79}
80 
81#if defined(XP_WIN)
82// We provide the global sized delete overloads unconditionally because the
83// MSVC runtime headers do, despite compiling with /Zc:sizedDealloc-
84MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete(void* ptr,
85                                         size_t /*size*/) noexcept(true) {
86  return free_implfree(ptr);
87}
88 
89MOZALLOC_EXPORT_NEW__attribute__((always_inline)) inline void operator delete[](void* ptr,
90                                           size_t /*size*/) noexcept(true) {
91  return free_implfree(ptr);
92}
93#endif
94 
95#endif /* mozilla_cxxalloc_h */