Bug 1640839 - Add some helpers for enums to calculate the size and us…

…e it in EnumeratedArray. r=glandium,jgilbert,media-playback-reviewers,padenot Differential Revision: https://phabricator.services.mozilla.com/D201334
dothq · Mar 2, 2024 · 2b747df · 2b747df
1 parent 9c8d00b
commit 2b747df
Show file tree

Hide file tree

Showing 53 changed files with 189 additions and 126 deletions.
diff --git a/dom/animation/EffectCompositor.h b/dom/animation/EffectCompositor.h
@@ -245,7 +245,7 @@ class EffectCompositor {
   // indicate that the style rule on the element is out of date but without
   // posting a restyle to update it.
   EnumeratedArray<CascadeLevel, nsTHashMap<PseudoElementHashEntry, bool>,
-                  CascadeLevel(kCascadeLevelCount)>
+                  kCascadeLevelCount>
       mElementsToRestyle;
 
   bool mIsInPreTraverse = false;

diff --git a/dom/base/FlushType.h b/dom/base/FlushType.h
@@ -40,7 +40,7 @@ enum class FlushType : uint8_t {
 
 // Flush type strings that will be displayed in the profiler
 // clang-format off
-const EnumeratedArray<FlushType, const char*, FlushType::Count>
+const EnumeratedArray<FlushType, const char*, size_t(FlushType::Count)>
     kFlushTypeNames = {
   "",
   "Event",

diff --git a/dom/canvas/CanvasRenderingContext2D.h b/dom/canvas/CanvasRenderingContext2D.h
@@ -1008,9 +1008,11 @@ class CanvasRenderingContext2D : public nsICanvasRenderingContextInternal,
     RefPtr<nsAtom> fontLanguage;
     nsFont fontFont;
 
-    EnumeratedArray<Style, RefPtr<CanvasGradient>, Style::MAX> gradientStyles;
-    EnumeratedArray<Style, RefPtr<CanvasPattern>, Style::MAX> patternStyles;
-    EnumeratedArray<Style, nscolor, Style::MAX> colorStyles;
+    EnumeratedArray<Style, RefPtr<CanvasGradient>, size_t(Style::MAX)>
+        gradientStyles;
+    EnumeratedArray<Style, RefPtr<CanvasPattern>, size_t(Style::MAX)>
+        patternStyles;
+    EnumeratedArray<Style, nscolor, size_t(Style::MAX)> colorStyles;
 
     nsCString font;
     CanvasTextAlign textAlign = CanvasTextAlign::Start;

diff --git a/dom/canvas/WebGLContext.h b/dom/canvas/WebGLContext.h
@@ -969,7 +969,7 @@ class WebGLContext : public VRefCounted, public SupportsWeakPtr {
   // WebGL extensions (implemented in WebGLContextExtensions.cpp)
 
   EnumeratedArray<WebGLExtensionID, std::unique_ptr<WebGLExtensionBase>,
-                  WebGLExtensionID::Max>
+                  size_t(WebGLExtensionID::Max)>
       mExtensions;
 
  public:

diff --git a/dom/media/ipc/RemoteDecoderManagerChild.cpp b/dom/media/ipc/RemoteDecoderManagerChild.cpp
@@ -51,7 +51,7 @@ using namespace gfx;
 // should be launched serially. Protects sLaunchPromise
 StaticMutex sLaunchMutex;
 static EnumeratedArray<RemoteDecodeIn, StaticRefPtr<GenericNonExclusivePromise>,
-                       RemoteDecodeIn::SENTINEL>
+                       size_t(RemoteDecodeIn::SENTINEL)>
     sLaunchPromises MOZ_GUARDED_BY(sLaunchMutex);
 
 // Only modified on the main-thread, read on any thread. While it could be read
@@ -62,7 +62,7 @@ static StaticDataMutex<StaticRefPtr<nsIThread>>
 
 // Only accessed from sRemoteDecoderManagerChildThread
 static EnumeratedArray<RemoteDecodeIn, StaticRefPtr<RemoteDecoderManagerChild>,
-                       RemoteDecodeIn::SENTINEL>
+                       size_t(RemoteDecodeIn::SENTINEL)>
     sRemoteDecoderManagerChildForProcesses;
 
 static StaticAutoPtr<nsTArray<RefPtr<Runnable>>> sRecreateTasks;
@@ -71,7 +71,7 @@ static StaticAutoPtr<nsTArray<RefPtr<Runnable>>> sRecreateTasks;
 // processes.
 StaticMutex sProcessSupportedMutex;
 static EnumeratedArray<RemoteDecodeIn, Maybe<media::MediaCodecsSupported>,
-                       RemoteDecodeIn::SENTINEL>
+                       size_t(RemoteDecodeIn::SENTINEL)>
     sProcessSupported MOZ_GUARDED_BY(sProcessSupportedMutex);
 
 class ShutdownObserver final : public nsIObserver {

diff --git a/dom/media/mediasession/MediaSession.h b/dom/media/mediasession/MediaSession.h
@@ -121,7 +121,7 @@ class MediaSession final : public nsIDocumentActivity, public nsWrapperCache {
   RefPtr<MediaMetadata> mMediaMetadata;
 
   EnumeratedArray<MediaSessionAction, RefPtr<MediaSessionActionHandler>,
-                  MediaSessionAction::EndGuard_>
+                  size_t(MediaSessionAction::EndGuard_)>
       mActionHandlers;
 
   // This is used as is a hint for the user agent to determine whether the

diff --git a/dom/quota/QuotaManager.h b/dom/quota/QuotaManager.h
@@ -727,7 +727,8 @@ class QuotaManager final : public BackgroundThreadObject {
 
   nsCOMPtr<mozIStorageConnection> mStorageConnection;
 
-  EnumeratedArray<Client::Type, nsCString, Client::TYPE_MAX> mShutdownSteps;
+  EnumeratedArray<Client::Type, nsCString, size_t(Client::TYPE_MAX)>
+      mShutdownSteps;
   LazyInitializedOnce<const TimeStamp> mShutdownStartedAt;
 
   // Accesses to mQuotaManagerShutdownSteps must be protected by mQuotaMutex.

diff --git a/dom/system/IOUtils.h b/dom/system/IOUtils.h
@@ -69,8 +69,8 @@ class IOUtils final {
   };
 
   template <typename T>
-  using PhaseArray =
-      EnumeratedArray<IOUtils::ShutdownPhase, T, IOUtils::ShutdownPhase::Count>;
+  using PhaseArray = EnumeratedArray<IOUtils::ShutdownPhase, T,
+                                     size_t(IOUtils::ShutdownPhase::Count)>;
 
   static already_AddRefed<Promise> Read(GlobalObject& aGlobal,
                                         const nsAString& aPath,

diff --git a/dom/system/PathUtils.h b/dom/system/PathUtils.h
@@ -241,7 +241,8 @@ class PathUtils::DirectoryCache final {
   void ResolveWithDirectory(Promise* aPromise, const Directory aRequestedDir);
 
   template <typename T>
-  using DirectoryArray = EnumeratedArray<Directory, T, Directory::Count>;
+  using DirectoryArray =
+      EnumeratedArray<Directory, T, size_t(Directory::Count)>;
 
   DirectoryArray<nsString> mDirectories;
   DirectoryArray<MozPromiseHolder<PopulateDirectoriesPromise>> mPromises;

diff --git a/dom/xslt/xslt/txEXSLTFunctions.cpp b/dom/xslt/xslt/txEXSLTFunctions.cpp
@@ -190,7 +190,7 @@ struct txEXSLTFunctionDescriptor {
 };
 
 static EnumeratedArray<txEXSLTType, txEXSLTFunctionDescriptor,
-                       txEXSLTType::_LIMIT>
+                       size_t(txEXSLTType::_LIMIT)>
     descriptTable;
 
 class txEXSLTFunctionCall : public FunctionCall {

diff --git a/gfx/layers/ImageContainer.h b/gfx/layers/ImageContainer.h
@@ -192,7 +192,7 @@ class Image {
 
   mozilla::EnumeratedArray<mozilla::layers::LayersBackend,
                            UniquePtr<ImageBackendData>,
-                           mozilla::layers::LayersBackend::LAYERS_LAST>
+                           size_t(mozilla::layers::LayersBackend::LAYERS_LAST)>
       mBackendData;
 
   void* mImplData;

diff --git a/gfx/layers/ipc/VideoBridgeParent.cpp b/gfx/layers/ipc/VideoBridgeParent.cpp
@@ -18,7 +18,7 @@ using namespace mozilla::ipc;
 using namespace mozilla::gfx;
 
 using VideoBridgeTable = EnumeratedArray<VideoBridgeSource, VideoBridgeParent*,
-                                         VideoBridgeSource::_Count>;
+                                         size_t(VideoBridgeSource::_Count)>;
 
 static StaticDataMutex<VideoBridgeTable> sVideoBridgeFromProcess(
     "VideoBridges");

diff --git a/gfx/thebes/gfxPlatformFontList.h b/gfx/thebes/gfxPlatformFontList.h
@@ -1011,12 +1011,13 @@ class gfxPlatformFontList : public gfxFontInfoLoader {
   // When system-wide font lookup fails for a character, cache it to skip future
   // searches. This is an array of bitsets, one for each FontVisibility level.
   mozilla::EnumeratedArray<FontVisibility, gfxSparseBitSet,
-                           FontVisibility::Count>
+                           size_t(FontVisibility::Count)>
       mCodepointsWithNoFonts MOZ_GUARDED_BY(mLock);
 
   // the family to use for U+FFFD fallback, to avoid expensive search every time
   // on pages with lots of problems
-  mozilla::EnumeratedArray<FontVisibility, FontFamily, FontVisibility::Count>
+  mozilla::EnumeratedArray<FontVisibility, FontFamily,
+                           size_t(FontVisibility::Count)>
       mReplacementCharFallbackFamily MOZ_GUARDED_BY(mLock);
 
   // Sorted array of lowercased family names; use ContainsSorted to test

diff --git a/ipc/glue/UtilityAudioDecoderChild.cpp b/ipc/glue/UtilityAudioDecoderChild.cpp
@@ -43,7 +43,7 @@ NS_IMETHODIMP UtilityAudioDecoderChildShutdownObserver::Observe(
 NS_IMPL_ISUPPORTS(UtilityAudioDecoderChildShutdownObserver, nsIObserver);
 
 static EnumeratedArray<SandboxingKind, StaticRefPtr<UtilityAudioDecoderChild>,
-                       SandboxingKind::COUNT>
+                       size_t(SandboxingKind::COUNT)>
     sAudioDecoderChilds;
 
 UtilityAudioDecoderChild::UtilityAudioDecoderChild(SandboxingKind aKind)

diff --git a/ipc/glue/UtilityProcessManager.h b/ipc/glue/UtilityProcessManager.h
@@ -228,7 +228,8 @@ class UtilityProcessManager final : public UtilityProcessHost::Listener {
     ~ProcessFields() = default;
   };
 
-  EnumeratedArray<SandboxingKind, RefPtr<ProcessFields>, SandboxingKind::COUNT>
+  EnumeratedArray<SandboxingKind, RefPtr<ProcessFields>,
+                  size_t(SandboxingKind::COUNT)>
       mProcesses;
 
   RefPtr<ProcessFields> GetProcess(SandboxingKind);

diff --git a/js/public/RootingAPI.h b/js/public/RootingAPI.h
@@ -981,12 +981,12 @@ enum class AutoGCRooterKind : uint8_t {
   Limit
 };
 
-using RootedListHeads =
-    mozilla::EnumeratedArray<RootKind, js::StackRootedBase*, RootKind::Limit>;
+using RootedListHeads = mozilla::EnumeratedArray<RootKind, js::StackRootedBase*,
+                                                 size_t(RootKind::Limit)>;
 
 using AutoRooterListHeads =
     mozilla::EnumeratedArray<AutoGCRooterKind, AutoGCRooter*,
-                             AutoGCRooterKind::Limit>;
+                             size_t(AutoGCRooterKind::Limit)>;
 
 // Superclass of JSContext which can be used for rooting data in use by the
 // current thread but that does not provide all the functions of a JSContext.

diff --git a/js/src/gc/AllocKind.h b/js/src/gc/AllocKind.h
@@ -197,13 +197,14 @@ constexpr auto SomeAllocKinds(AllocKind first = AllocKind::FIRST,
 // with each index corresponding to a particular alloc kind.
 template <typename ValueType>
 using AllAllocKindArray =
-    mozilla::EnumeratedArray<AllocKind, ValueType, AllocKind::LIMIT>;
+    mozilla::EnumeratedArray<AllocKind, ValueType, size_t(AllocKind::LIMIT)>;
 
 // ObjectAllocKindArray<ValueType> gives an enumerated array of ValueTypes,
 // with each index corresponding to a particular object alloc kind.
 template <typename ValueType>
 using ObjectAllocKindArray =
-    mozilla::EnumeratedArray<AllocKind, ValueType, AllocKind::OBJECT_LIMIT>;
+    mozilla::EnumeratedArray<AllocKind, ValueType,
+                             size_t(AllocKind::OBJECT_LIMIT)>;
 
 /*
  * Map from C++ type to alloc kind for non-object types. JSObject does not have

diff --git a/js/src/gc/Nursery.h b/js/src/gc/Nursery.h
@@ -382,10 +382,10 @@ class Nursery {
   };
 
   using ProfileTimes = mozilla::EnumeratedArray<ProfileKey, mozilla::TimeStamp,
-                                                ProfileKey::KeyCount>;
+                                                size_t(ProfileKey::KeyCount)>;
   using ProfileDurations =
       mozilla::EnumeratedArray<ProfileKey, mozilla::TimeDuration,
-                               ProfileKey::KeyCount>;
+                               size_t(ProfileKey::KeyCount)>;
 
   // Calculate the promotion rate of the most recent minor GC.
   // The valid_for_tenuring parameter is used to return whether this

diff --git a/js/src/gc/Statistics.cpp b/js/src/gc/Statistics.cpp
@@ -154,11 +154,11 @@ struct PhaseInfo {
 };
 
 // A table of PhaseInfo indexed by Phase.
-using PhaseTable = EnumeratedArray<Phase, PhaseInfo, Phase::LIMIT>;
+using PhaseTable = EnumeratedArray<Phase, PhaseInfo, size_t(Phase::LIMIT)>;
 
 // A table of PhaseKindInfo indexed by PhaseKind.
 using PhaseKindTable =
-    EnumeratedArray<PhaseKind, PhaseKindInfo, PhaseKind::LIMIT>;
+    EnumeratedArray<PhaseKind, PhaseKindInfo, size_t(PhaseKind::LIMIT)>;
 
 #include "gc/StatsPhasesGenerated.inc"
 

diff --git a/js/src/gc/Statistics.h b/js/src/gc/Statistics.h
@@ -138,7 +138,7 @@ struct Statistics {
 
   template <typename IndexType, typename ValueType, IndexType SizeAsEnumValue>
   using EnumeratedArray =
-      mozilla::EnumeratedArray<IndexType, ValueType, SizeAsEnumValue>;
+      mozilla::EnumeratedArray<IndexType, ValueType, size_t(SizeAsEnumValue)>;
 
   using TimeDuration = mozilla::TimeDuration;
   using TimeStamp = mozilla::TimeStamp;

diff --git a/js/src/jit/CodeGenerator.cpp b/js/src/jit/CodeGenerator.cpp
@@ -2167,8 +2167,8 @@ class CreateDependentString {
     NotInlineString,
     Count
   };
-  mozilla::EnumeratedArray<FallbackKind, Label, FallbackKind::Count> fallbacks_,
-      joins_;
+  mozilla::EnumeratedArray<FallbackKind, Label, size_t(FallbackKind::Count)>
+      fallbacks_, joins_;
 
  public:
   CreateDependentString(CharEncoding encoding, Register string, Register temp1,

diff --git a/js/src/jit/ExecutableAllocator.h b/js/src/jit/ExecutableAllocator.h
@@ -72,7 +72,8 @@ class ExecutablePool {
   bool m_mark : 1;
 
   // Number of bytes currently allocated for each CodeKind.
-  mozilla::EnumeratedArray<CodeKind, size_t, CodeKind::Count> m_codeBytes;
+  mozilla::EnumeratedArray<CodeKind, size_t, size_t(CodeKind::Count)>
+      m_codeBytes;
 
  public:
   void release(bool willDestroy = false);

diff --git a/js/src/jit/IonOptimizationLevels.h b/js/src/jit/IonOptimizationLevels.h
@@ -182,7 +182,7 @@ class OptimizationInfo {
 class OptimizationLevelInfo {
  private:
   mozilla::EnumeratedArray<OptimizationLevel, OptimizationInfo,
-                           OptimizationLevel::Count>
+                           size_t(OptimizationLevel::Count)>
       infos_;
 
  public:

diff --git a/js/src/jit/JitRuntime.h b/js/src/jit/JitRuntime.h
@@ -74,15 +74,16 @@ enum class BailoutReturnKind {
 // is stored in JitRuntime and generated when creating the JitRuntime.
 class BaselineICFallbackCode {
   JitCode* code_ = nullptr;
-  using OffsetArray = mozilla::EnumeratedArray<BaselineICFallbackKind, uint32_t,
-                                               BaselineICFallbackKind::Count>;
+  using OffsetArray =
+      mozilla::EnumeratedArray<BaselineICFallbackKind, uint32_t,
+                               size_t(BaselineICFallbackKind::Count)>;
   OffsetArray offsets_ = {};
 
   // Keep track of offset into various baseline stubs' code at return
   // point from called script.
   using BailoutReturnArray =
       mozilla::EnumeratedArray<BailoutReturnKind, uint32_t,
-                               BailoutReturnKind::Count>;
+                               size_t(BailoutReturnKind::Count)>;
   BailoutReturnArray bailoutReturnOffsets_ = {};
 
  public:
@@ -175,12 +176,12 @@ class JitRuntime {
 
   // Thunk to do a generic call from Ion.
   mozilla::EnumeratedArray<IonGenericCallKind, WriteOnceData<uint32_t>,
-                           IonGenericCallKind::Count>
+                           size_t(IonGenericCallKind::Count)>
       ionGenericCallStubOffset_;
 
   // Thunk used by the debugger for breakpoint and step mode.
   mozilla::EnumeratedArray<DebugTrapHandlerKind, WriteOnceData<JitCode*>,
-                           DebugTrapHandlerKind::Count>
+                           size_t(DebugTrapHandlerKind::Count)>
       debugTrapHandlers_;
 
   // BaselineInterpreter state.

diff --git a/js/src/jit/JitZone.h b/js/src/jit/JitZone.h
@@ -141,7 +141,8 @@ class JitZone {
     Count
   };
 
-  mozilla::EnumeratedArray<StubIndex, WeakHeapPtr<JitCode*>, StubIndex::Count>
+  mozilla::EnumeratedArray<StubIndex, WeakHeapPtr<JitCode*>,
+                           size_t(StubIndex::Count)>
       stubs_;
 
   mozilla::Maybe<IonCompilationId> currentCompilationId_;

diff --git a/js/src/jit/WarpCacheIRTranspiler.cpp b/js/src/jit/WarpCacheIRTranspiler.cpp
@@ -49,7 +49,8 @@ class MOZ_RAII WarpCacheIRTranspiler : public WarpBuilderShared {
 
   // Array mapping call arguments to OperandId.
   using ArgumentKindArray =
-      mozilla::EnumeratedArray<ArgumentKind, OperandId, ArgumentKind::NumKinds>;
+      mozilla::EnumeratedArray<ArgumentKind, OperandId,
+                               size_t(ArgumentKind::NumKinds)>;
   ArgumentKindArray argumentOperandIds_;
 
   void setArgumentId(ArgumentKind kind, OperandId id) {

diff --git a/js/src/util/StructuredSpewer.h b/js/src/util/StructuredSpewer.h
@@ -187,8 +187,8 @@ class StructuredSpewer {
   // Globally selected channel.
   StructuredSpewFilter selectedChannel_;
 
-  using NameArray =
-      mozilla::EnumeratedArray<SpewChannel, const char*, SpewChannel::Count>;
+  using NameArray = mozilla::EnumeratedArray<SpewChannel, const char*,
+                                             size_t(SpewChannel::Count)>;
   // Channel Names
   static NameArray const names_;
 

diff --git a/js/src/vm/GlobalObject.h b/js/src/vm/GlobalObject.h
@@ -129,8 +129,8 @@ class GlobalObjectData {
     HeapPtr<JSObject*> constructor;
     HeapPtr<JSObject*> prototype;
   };
-  using CtorArray =
-      mozilla::EnumeratedArray<JSProtoKey, ConstructorWithProto, JSProto_LIMIT>;
+  using CtorArray = mozilla::EnumeratedArray<JSProtoKey, ConstructorWithProto,
+                                             size_t(JSProto_LIMIT)>;
   CtorArray builtinConstructors;
 
   // Built-in prototypes for this global. Note that this is different from the
@@ -154,8 +154,8 @@ class GlobalObjectData {
 
     Limit
   };
-  using ProtoArray =
-      mozilla::EnumeratedArray<ProtoKind, HeapPtr<JSObject*>, ProtoKind::Limit>;
+  using ProtoArray = mozilla::EnumeratedArray<ProtoKind, HeapPtr<JSObject*>,
+                                              size_t(ProtoKind::Limit)>;
   ProtoArray builtinProtos;
 
   HeapPtr<GlobalScope*> emptyGlobalScope;
@@ -197,7 +197,7 @@ class GlobalObjectData {
   // AllocKind.
   using PlainObjectShapeArray =
       mozilla::EnumeratedArray<PlainObjectSlotsKind, HeapPtr<SharedShape*>,
-                               PlainObjectSlotsKind::Limit>;
+                               size_t(PlainObjectSlotsKind::Limit)>;
   PlainObjectShapeArray plainObjectShapesWithDefaultProto;
 
   // Shape for JSFunction with %Function.prototype% as proto, for both

diff --git a/js/src/vm/HelperThreadState.h b/js/src/vm/HelperThreadState.h
@@ -115,7 +115,8 @@ class GlobalHelperThreadState {
       PromiseHelperTaskVector;
 
   // Count of running task by each threadType.
-  mozilla::EnumeratedArray<ThreadType, size_t, ThreadType::THREAD_TYPE_MAX>
+  mozilla::EnumeratedArray<ThreadType, size_t,
+                           size_t(ThreadType::THREAD_TYPE_MAX)>
       runningTaskCount;
   size_t totalCountRunningTasks;
 

diff --git a/js/src/vm/Runtime.h b/js/src/vm/Runtime.h
@@ -528,7 +528,7 @@ struct JSRuntime {
   // Heap GC roots for PersistentRooted pointers.
   js::MainThreadData<mozilla::EnumeratedArray<
       JS::RootKind, mozilla::LinkedList<js::PersistentRootedBase>,
-      JS::RootKind::Limit>>
+      size_t(JS::RootKind::Limit)>>
       heapRoots;
 
   void tracePersistentRoots(JSTracer* trc);

diff --git a/js/src/wasm/WasmBuiltinModule.h b/js/src/wasm/WasmBuiltinModule.h
@@ -102,7 +102,7 @@ class BuiltinModuleFunc {
 class BuiltinModuleFuncs {
   using Storage =
       mozilla::EnumeratedArray<BuiltinModuleFuncId, BuiltinModuleFunc,
-                               BuiltinModuleFuncId::Limit>;
+                               size_t(BuiltinModuleFuncId::Limit)>;
   Storage funcs_;
 
   static BuiltinModuleFuncs* singleton_;