summaryrefslogtreecommitdiffstats
path: root/xpcom/ds
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--xpcom/ds/ArenaAllocator.h214
-rw-r--r--xpcom/ds/ArenaAllocatorExtensions.h76
-rw-r--r--xpcom/ds/ArrayAlgorithm.h109
-rw-r--r--xpcom/ds/ArrayIterator.h165
-rw-r--r--xpcom/ds/Atom.py64
-rw-r--r--xpcom/ds/AtomArray.h19
-rw-r--r--xpcom/ds/Dafsa.cpp153
-rw-r--r--xpcom/ds/Dafsa.h54
-rw-r--r--xpcom/ds/HTMLAtoms.py257
-rw-r--r--xpcom/ds/IncrementalTokenizer.cpp190
-rw-r--r--xpcom/ds/IncrementalTokenizer.h125
-rw-r--r--xpcom/ds/Observer.h76
-rw-r--r--xpcom/ds/PLDHashTable.cpp870
-rw-r--r--xpcom/ds/PLDHashTable.h807
-rw-r--r--xpcom/ds/PerfectHash.h50
-rw-r--r--xpcom/ds/SimpleEnumerator.h73
-rw-r--r--xpcom/ds/StaticAtoms.py2636
-rw-r--r--xpcom/ds/StickyTimeDuration.h239
-rw-r--r--xpcom/ds/Tokenizer.cpp805
-rw-r--r--xpcom/ds/Tokenizer.h524
-rw-r--r--xpcom/ds/components.conf24
-rw-r--r--xpcom/ds/moz.build156
-rw-r--r--xpcom/ds/nsArray.cpp146
-rw-r--r--xpcom/ds/nsArray.h78
-rw-r--r--xpcom/ds/nsArrayEnumerator.cpp213
-rw-r--r--xpcom/ds/nsArrayEnumerator.h31
-rw-r--r--xpcom/ds/nsArrayUtils.cpp22
-rw-r--r--xpcom/ds/nsArrayUtils.h34
-rw-r--r--xpcom/ds/nsAtom.h309
-rw-r--r--xpcom/ds/nsAtomTable.cpp670
-rw-r--r--xpcom/ds/nsAtomTable.h30
-rw-r--r--xpcom/ds/nsBaseHashtable.h1029
-rw-r--r--xpcom/ds/nsCOMArray.cpp252
-rw-r--r--xpcom/ds/nsCOMArray.h398
-rw-r--r--xpcom/ds/nsCRT.cpp123
-rw-r--r--xpcom/ds/nsCRT.h119
-rw-r--r--xpcom/ds/nsCharSeparatedTokenizer.cpp10
-rw-r--r--xpcom/ds/nsCharSeparatedTokenizer.h274
-rw-r--r--xpcom/ds/nsCheapSets.h155
-rw-r--r--xpcom/ds/nsClassHashtable.h115
-rw-r--r--xpcom/ds/nsDeque.cpp265
-rw-r--r--xpcom/ds/nsDeque.h538
-rw-r--r--xpcom/ds/nsEnumeratorUtils.cpp248
-rw-r--r--xpcom/ds/nsEnumeratorUtils.h24
-rw-r--r--xpcom/ds/nsExpirationTracker.h618
-rw-r--r--xpcom/ds/nsGkAtoms.cpp70
-rw-r--r--xpcom/ds/nsGkAtoms.h192
-rw-r--r--xpcom/ds/nsHashKeys.h636
-rw-r--r--xpcom/ds/nsHashPropertyBag.cpp366
-rw-r--r--xpcom/ds/nsHashPropertyBag.h80
-rw-r--r--xpcom/ds/nsHashtablesFwd.h94
-rw-r--r--xpcom/ds/nsIArray.idl103
-rw-r--r--xpcom/ds/nsIArrayExtensions.idl51
-rw-r--r--xpcom/ds/nsIINIParser.idl61
-rw-r--r--xpcom/ds/nsIMutableArray.idl92
-rw-r--r--xpcom/ds/nsINIParserImpl.cpp143
-rw-r--r--xpcom/ds/nsINIParserImpl.h23
-rw-r--r--xpcom/ds/nsIObserver.idl37
-rw-r--r--xpcom/ds/nsIObserverService.idl109
-rw-r--r--xpcom/ds/nsIPersistentProperties.h13
-rw-r--r--xpcom/ds/nsIPersistentProperties2.idl59
-rw-r--r--xpcom/ds/nsIProperties.idl46
-rw-r--r--xpcom/ds/nsIProperty.idl25
-rw-r--r--xpcom/ds/nsIPropertyBag.idl28
-rw-r--r--xpcom/ds/nsIPropertyBag2.idl80
-rw-r--r--xpcom/ds/nsISerializable.idl32
-rw-r--r--xpcom/ds/nsISimpleEnumerator.idl77
-rw-r--r--xpcom/ds/nsIStringEnumerator.idl37
-rw-r--r--xpcom/ds/nsISupportsIterators.idl292
-rw-r--r--xpcom/ds/nsISupportsPrimitives.idl222
-rw-r--r--xpcom/ds/nsIVariant.idl162
-rw-r--r--xpcom/ds/nsIWindowsRegKey.idl336
-rw-r--r--xpcom/ds/nsIWritablePropertyBag.idl27
-rw-r--r--xpcom/ds/nsIWritablePropertyBag2.idl22
-rw-r--r--xpcom/ds/nsInterfaceHashtable.h14
-rw-r--r--xpcom/ds/nsMathUtils.h109
-rw-r--r--xpcom/ds/nsObserverList.cpp92
-rw-r--r--xpcom/ds/nsObserverList.h67
-rw-r--r--xpcom/ds/nsObserverService.cpp357
-rw-r--r--xpcom/ds/nsObserverService.h56
-rw-r--r--xpcom/ds/nsPersistentProperties.cpp584
-rw-r--r--xpcom/ds/nsPersistentProperties.h57
-rw-r--r--xpcom/ds/nsPointerHashKeys.h50
-rw-r--r--xpcom/ds/nsProperties.cpp61
-rw-r--r--xpcom/ds/nsProperties.h29
-rw-r--r--xpcom/ds/nsQuickSort.cpp175
-rw-r--r--xpcom/ds/nsQuickSort.h39
-rw-r--r--xpcom/ds/nsRefCountedHashtable.h245
-rw-r--r--xpcom/ds/nsRefPtrHashtable.h12
-rw-r--r--xpcom/ds/nsSimpleEnumerator.cpp78
-rw-r--r--xpcom/ds/nsSimpleEnumerator.h22
-rw-r--r--xpcom/ds/nsStaticAtomUtils.h36
-rw-r--r--xpcom/ds/nsStaticNameTable.cpp180
-rw-r--r--xpcom/ds/nsStaticNameTable.h48
-rw-r--r--xpcom/ds/nsStringEnumerator.cpp311
-rw-r--r--xpcom/ds/nsStringEnumerator.h102
-rw-r--r--xpcom/ds/nsSupportsPrimitives.cpp603
-rw-r--r--xpcom/ds/nsSupportsPrimitives.h279
-rw-r--r--xpcom/ds/nsTArray-inl.h691
-rw-r--r--xpcom/ds/nsTArray.cpp28
-rw-r--r--xpcom/ds/nsTArray.h3345
-rw-r--r--xpcom/ds/nsTArrayForwardDeclare.h39
-rw-r--r--xpcom/ds/nsTHashMap.h70
-rw-r--r--xpcom/ds/nsTHashSet.h193
-rw-r--r--xpcom/ds/nsTHashtable.h966
-rw-r--r--xpcom/ds/nsTObserverArray.cpp27
-rw-r--r--xpcom/ds/nsTObserverArray.h583
-rw-r--r--xpcom/ds/nsTPriorityQueue.h147
-rw-r--r--xpcom/ds/nsVariant.cpp1876
-rw-r--r--xpcom/ds/nsVariant.h223
-rw-r--r--xpcom/ds/nsWhitespaceTokenizer.h96
-rw-r--r--xpcom/ds/nsWindowsRegKey.cpp523
-rw-r--r--xpcom/ds/nsWindowsRegKey.h45
-rw-r--r--xpcom/ds/test/python.ini4
-rw-r--r--xpcom/ds/test/test_dafsa.py546
-rw-r--r--xpcom/ds/tools/incremental_dafsa.py509
-rw-r--r--xpcom/ds/tools/make_dafsa.py372
-rw-r--r--xpcom/ds/tools/perfecthash.py371
118 files changed, 31162 insertions, 0 deletions
diff --git a/xpcom/ds/ArenaAllocator.h b/xpcom/ds/ArenaAllocator.h
new file mode 100644
index 0000000000..76498986ce
--- /dev/null
+++ b/xpcom/ds/ArenaAllocator.h
@@ -0,0 +1,214 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_ArenaAllocator_h
+#define mozilla_ArenaAllocator_h
+
+#include <algorithm>
+#include <cstdint>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/fallible.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryChecking.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/OperatorNewExtensions.h"
+#include "mozilla/Poison.h"
+#include "mozilla/TemplateLib.h"
+#include "nsDebug.h"
+
+namespace mozilla {
+
+/**
+ * A very simple arena allocator based on NSPR's PLArena.
+ *
+ * The arena allocator only provides for allocation, all memory is retained
+ * until the allocator is destroyed. It's useful for situations where a large
+ * amount of small transient allocations are expected.
+ *
+ * Example usage:
+ *
+ * // Define an allocator that is page sized and returns allocations that are
+ * // 8-byte aligned.
+ * ArenaAllocator<4096, 8> a;
+ * for (int i = 0; i < 1000; i++) {
+ * DoSomething(a.Allocate(i));
+ * }
+ */
+template <size_t ArenaSize, size_t Alignment = 1>
+class ArenaAllocator {
+ public:
+ constexpr ArenaAllocator() : mHead(), mCurrent(nullptr) {
+ static_assert(mozilla::tl::FloorLog2<Alignment>::value ==
+ mozilla::tl::CeilingLog2<Alignment>::value,
+ "ArenaAllocator alignment must be a power of two");
+ }
+
+ ArenaAllocator(const ArenaAllocator&) = delete;
+ ArenaAllocator& operator=(const ArenaAllocator&) = delete;
+
+ /**
+ * Frees all internal arenas but does not call destructors for objects
+ * allocated out of the arena.
+ */
+ ~ArenaAllocator() { Clear(); }
+
+ /**
+ * Fallibly allocates a chunk of memory with the given size from the internal
+ * arenas. If the allocation size is larger than the chosen arena a size an
+ * entire arena is allocated and used.
+ */
+ MOZ_ALWAYS_INLINE void* Allocate(size_t aSize, const fallible_t&) {
+ MOZ_RELEASE_ASSERT(aSize, "Allocation size must be non-zero");
+ return InternalAllocate(AlignedSize(aSize));
+ }
+
+ void* Allocate(size_t aSize) {
+ void* p = Allocate(aSize, fallible);
+ if (MOZ_UNLIKELY(!p)) {
+ NS_ABORT_OOM(std::max(aSize, ArenaSize));
+ }
+
+ return p;
+ }
+
+ /**
+ * Frees all entries. The allocator can be reused after this is called.
+ *
+ * NB: This will not run destructors of any objects that were allocated from
+ * the arena.
+ */
+ void Clear() {
+ // Free all chunks.
+ auto a = mHead.next;
+ while (a) {
+ auto tmp = a;
+ a = a->next;
+ free(tmp);
+ }
+
+ // Reset the list head.
+ mHead.next = nullptr;
+ mCurrent = nullptr;
+ }
+
+ /**
+ * Adjusts the given size to the required alignment.
+ */
+ static constexpr size_t AlignedSize(size_t aSize) {
+ return (aSize + (Alignment - 1)) & ~(Alignment - 1);
+ }
+
+ size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+ size_t s = 0;
+ for (auto arena = mHead.next; arena; arena = arena->next) {
+ s += aMallocSizeOf(arena);
+ }
+
+ return s;
+ }
+
+ void Check() {
+ if (mCurrent) {
+ mCurrent->canary.Check();
+ }
+ }
+
+ private:
+ struct ArenaHeader {
+ /**
+ * The location in memory of the data portion of the arena.
+ */
+ uintptr_t offset;
+ /**
+ * The location in memory of the end of the data portion of the arena.
+ */
+ uintptr_t tail;
+ };
+
+ struct ArenaChunk {
+ constexpr ArenaChunk() : header{0, 0}, next(nullptr) {}
+
+ explicit ArenaChunk(size_t aSize)
+ : header{AlignedSize(uintptr_t(this + 1)), uintptr_t(this) + aSize},
+ next(nullptr) {}
+
+ CorruptionCanary canary;
+ ArenaHeader header;
+ ArenaChunk* next;
+
+ /**
+ * Allocates a chunk of memory out of the arena and advances the offset.
+ */
+ void* Allocate(size_t aSize) {
+ MOZ_ASSERT(aSize <= Available());
+ char* p = reinterpret_cast<char*>(header.offset);
+ MOZ_RELEASE_ASSERT(p);
+ header.offset += aSize;
+ canary.Check();
+ MOZ_MAKE_MEM_UNDEFINED(p, aSize);
+ return p;
+ }
+
+ /**
+ * Calculates the amount of space available for allocation in this chunk.
+ */
+ size_t Available() const { return header.tail - header.offset; }
+ };
+
+ /**
+ * Allocates an arena chunk of the given size and initializes its header.
+ */
+ ArenaChunk* AllocateChunk(size_t aSize) {
+ static const size_t kOffset = AlignedSize(sizeof(ArenaChunk));
+ MOZ_ASSERT(kOffset < aSize);
+
+ const size_t chunkSize = aSize + kOffset;
+ void* p = malloc(chunkSize);
+ if (!p) {
+ return nullptr;
+ }
+
+ ArenaChunk* arena = new (KnownNotNull, p) ArenaChunk(chunkSize);
+ MOZ_MAKE_MEM_NOACCESS((void*)arena->header.offset,
+ arena->header.tail - arena->header.offset);
+
+ // Insert into the head of the list.
+ arena->next = mHead.next;
+ mHead.next = arena;
+
+ // Only update |mCurrent| if this is a standard allocation, large
+ // allocations will always end up full so there's no point in updating
+ // |mCurrent| in that case.
+ if (aSize == ArenaSize - kOffset) {
+ mCurrent = arena;
+ }
+
+ return arena;
+ }
+
+ MOZ_ALWAYS_INLINE void* InternalAllocate(size_t aSize) {
+ static_assert(ArenaSize > AlignedSize(sizeof(ArenaChunk)),
+ "Arena size must be greater than the header size");
+
+ static const size_t kMaxArenaCapacity =
+ ArenaSize - AlignedSize(sizeof(ArenaChunk));
+
+ if (mCurrent && aSize <= mCurrent->Available()) {
+ return mCurrent->Allocate(aSize);
+ }
+
+ ArenaChunk* arena = AllocateChunk(std::max(kMaxArenaCapacity, aSize));
+ return arena ? arena->Allocate(aSize) : nullptr;
+ }
+
+ ArenaChunk mHead;
+ ArenaChunk* mCurrent;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_ArenaAllocator_h
diff --git a/xpcom/ds/ArenaAllocatorExtensions.h b/xpcom/ds/ArenaAllocatorExtensions.h
new file mode 100644
index 0000000000..60819381d5
--- /dev/null
+++ b/xpcom/ds/ArenaAllocatorExtensions.h
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_ArenaAllocatorExtensions_h
+#define mozilla_ArenaAllocatorExtensions_h
+
+#include "mozilla/ArenaAllocator.h"
+#include "mozilla/CheckedInt.h"
+#include "nsAString.h"
+
+/**
+ * Extensions to the ArenaAllocator class.
+ */
+namespace mozilla {
+
+namespace detail {
+
+template <typename T, size_t ArenaSize, size_t Alignment>
+T* DuplicateString(const T* aSrc, const CheckedInt<size_t>& aLen,
+ ArenaAllocator<ArenaSize, Alignment>& aArena);
+
+} // namespace detail
+
+/**
+ * Makes an arena allocated null-terminated copy of the source string. The
+ * source string must be null-terminated.
+ *
+ * @param aSrc String to copy.
+ * @param aArena The arena to allocate the string copy out of.
+ * @return An arena allocated null-terminated string.
+ */
+template <typename T, size_t ArenaSize, size_t Alignment>
+T* ArenaStrdup(const T* aStr, ArenaAllocator<ArenaSize, Alignment>& aArena) {
+ return detail::DuplicateString(aStr, nsCharTraits<T>::length(aStr), aArena);
+}
+
+/**
+ * Makes an arena allocated null-terminated copy of the source string.
+ *
+ * @param aSrc String to copy.
+ * @param aArena The arena to allocate the string copy out of.
+ * @return An arena allocated null-terminated string.
+ */
+template <typename T, size_t ArenaSize, size_t Alignment>
+T* ArenaStrdup(const detail::nsTStringRepr<T>& aStr,
+ ArenaAllocator<ArenaSize, Alignment>& aArena) {
+ return detail::DuplicateString(aStr.BeginReading(), aStr.Length(), aArena);
+}
+
+/**
+ * Copies the source string and adds a null terminator. Source string does not
+ * have to be null terminated.
+ */
+template <typename T, size_t ArenaSize, size_t Alignment>
+T* detail::DuplicateString(const T* aSrc, const CheckedInt<size_t>& aLen,
+ ArenaAllocator<ArenaSize, Alignment>& aArena) {
+ const auto byteLen = (aLen + 1) * sizeof(T);
+ if (!byteLen.isValid()) {
+ return nullptr;
+ }
+
+ T* p = static_cast<T*>(aArena.Allocate(byteLen.value(), mozilla::fallible));
+ if (p) {
+ memcpy(p, aSrc, byteLen.value() - sizeof(T));
+ p[aLen.value()] = T(0);
+ }
+
+ return p;
+}
+
+} // namespace mozilla
+
+#endif // mozilla_ArenaAllocatorExtensions_h
diff --git a/xpcom/ds/ArrayAlgorithm.h b/xpcom/ds/ArrayAlgorithm.h
new file mode 100644
index 0000000000..2556eef465
--- /dev/null
+++ b/xpcom/ds/ArrayAlgorithm.h
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ArrayAlgorithm_h___
+#define ArrayAlgorithm_h___
+
+#include "nsTArray.h"
+
+#include "mozilla/Algorithm.h"
+#include "mozilla/ResultExtensions.h"
+
+namespace mozilla {
+
+// An algorithm similar to TransformAbortOnErr, which creates a new nsTArray
+// rather than inserting into an output iterator. The capacity of the result
+// array is set to the number of elements that will be inserted if all
+// transformations are successful. This variant is fallible, i.e. if setting the
+// capacity fails, NS_ERROR_OUT_OF_MEMORY is returned as an error value. This
+// variant only works with nsresult errors.
+template <
+ typename SrcIter, typename Transform,
+ typename = std::enable_if_t<std::is_same_v<
+ typename detail::TransformTraits<Transform, SrcIter>::result_err_type,
+ nsresult>>>
+Result<nsTArray<typename detail::TransformTraits<Transform,
+ SrcIter>::result_ok_type>,
+ nsresult>
+TransformIntoNewArrayAbortOnErr(SrcIter aIter, SrcIter aEnd,
+ Transform aTransform, fallible_t) {
+ nsTArray<typename detail::TransformTraits<Transform, SrcIter>::result_ok_type>
+ res;
+ if (!res.SetCapacity(std::distance(aIter, aEnd), fallible)) {
+ return Err(NS_ERROR_OUT_OF_MEMORY);
+ }
+
+ auto transformRes = TransformAbortOnErr(aIter, aEnd, MakeBackInserter(res),
+ std::move(aTransform));
+ if (NS_WARN_IF(transformRes.isErr())) {
+ return Err(transformRes.unwrapErr());
+ }
+
+ return res;
+}
+
+template <typename SrcRange, typename Transform>
+auto TransformIntoNewArrayAbortOnErr(SrcRange& aRange, Transform aTransform,
+ fallible_t) {
+ using std::begin;
+ using std::end;
+ return TransformIntoNewArrayAbortOnErr(begin(aRange), end(aRange), aTransform,
+ fallible);
+}
+
+// An algorithm similar to std::transform, which creates a new nsTArray
+// rather than inserting into an output iterator. The capacity of the result
+// array is set to the number of elements that will be inserted. This variant is
+// fallible, i.e. if setting the capacity fails, NS_ERROR_OUT_OF_MEMORY is
+// returned as an error value. This variant only works with nsresult errors.
+template <typename SrcIter, typename Transform>
+Result<nsTArray<detail::ArrayElementTransformType<Transform, SrcIter>>,
+ nsresult>
+TransformIntoNewArray(SrcIter aIter, SrcIter aEnd, Transform aTransform,
+ fallible_t) {
+ nsTArray<detail::ArrayElementTransformType<Transform, SrcIter>> res;
+ if (!res.SetCapacity(std::distance(aIter, aEnd), fallible)) {
+ return Err(NS_ERROR_OUT_OF_MEMORY);
+ }
+
+ std::transform(aIter, aEnd, MakeBackInserter(res), std::move(aTransform));
+
+ return res;
+}
+
+template <typename SrcRange, typename Transform>
+auto TransformIntoNewArray(SrcRange& aRange, Transform aTransform, fallible_t) {
+ using std::begin;
+ using std::end;
+ return TransformIntoNewArray(begin(aRange), end(aRange), aTransform,
+ fallible);
+}
+
+// An algorithm similar to std::transform, which creates a new nsTArray
+// rather than inserting into an output iterator. The capacity of the result
+// array is set to the number of elements that will be inserted. This variant is
+// infallible, i.e. if setting the capacity fails, the process is aborted.
+template <typename SrcIter, typename Transform>
+nsTArray<detail::ArrayElementTransformType<Transform, SrcIter>>
+TransformIntoNewArray(SrcIter aIter, SrcIter aEnd, Transform aTransform) {
+ nsTArray<detail::ArrayElementTransformType<Transform, SrcIter>> res;
+ res.SetCapacity(std::distance(aIter, aEnd));
+
+ std::transform(aIter, aEnd, MakeBackInserter(res), std::move(aTransform));
+
+ return res;
+}
+
+template <typename SrcRange, typename Transform>
+auto TransformIntoNewArray(SrcRange& aRange, Transform aTransform) {
+ using std::begin;
+ using std::end;
+ return TransformIntoNewArray(begin(aRange), end(aRange), aTransform);
+}
+
+} // namespace mozilla
+
+#endif // !defined(ArrayAlgorithm_h___)
diff --git a/xpcom/ds/ArrayIterator.h b/xpcom/ds/ArrayIterator.h
new file mode 100644
index 0000000000..cc6c8d1cb4
--- /dev/null
+++ b/xpcom/ds/ArrayIterator.h
@@ -0,0 +1,165 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Common iterator implementation for array classes e.g. nsTArray.
+
+#ifndef mozilla_ArrayIterator_h
+#define mozilla_ArrayIterator_h
+
+#include <iterator>
+#include <type_traits>
+
+namespace mozilla {
+
+namespace detail {
+template <typename T>
+struct AddInnerConst;
+
+template <typename T>
+struct AddInnerConst<T&> {
+ using Type = const T&;
+};
+
+template <typename T>
+struct AddInnerConst<T*> {
+ using Type = const T*;
+};
+
+template <typename T>
+using AddInnerConstT = typename AddInnerConst<T>::Type;
+} // namespace detail
+
+// We have implemented a custom iterator class for array rather than using
+// raw pointers into the backing storage to improve the safety of C++11-style
+// range based iteration in the presence of array mutation, or script execution
+// (bug 1299489).
+//
+// Mutating an array which is being iterated is still wrong, and will either
+// cause elements to be missed or firefox to crash, but will not trigger memory
+// safety problems due to the release-mode bounds checking found in ElementAt.
+//
+// Dereferencing this iterator returns type Element. When Element is a reference
+// type, this iterator implements the full standard random access iterator spec,
+// and can be treated in many ways as though it is a pointer. Otherwise, it is
+// just enough to be used in range-based for loop.
+template <class Element, class ArrayType>
+class ArrayIterator {
+ public:
+ typedef ArrayType array_type;
+ typedef ArrayIterator<Element, ArrayType> iterator_type;
+ typedef typename array_type::index_type index_type;
+ typedef std::remove_reference_t<Element> value_type;
+ typedef ptrdiff_t difference_type;
+ typedef value_type* pointer;
+ typedef value_type& reference;
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef ArrayIterator<detail::AddInnerConstT<Element>, ArrayType>
+ const_iterator_type;
+
+ private:
+ const array_type* mArray;
+ index_type mIndex;
+
+ public:
+ ArrayIterator() : mArray(nullptr), mIndex(0) {}
+ ArrayIterator(const iterator_type& aOther)
+ : mArray(aOther.mArray), mIndex(aOther.mIndex) {}
+ ArrayIterator(const array_type& aArray, index_type aIndex)
+ : mArray(&aArray), mIndex(aIndex) {}
+
+ iterator_type& operator=(const iterator_type& aOther) {
+ mArray = aOther.mArray;
+ mIndex = aOther.mIndex;
+ return *this;
+ }
+
+ constexpr operator const_iterator_type() const {
+ return mArray ? const_iterator_type{*mArray, mIndex}
+ : const_iterator_type{};
+ }
+
+ bool operator==(const iterator_type& aRhs) const {
+ return mIndex == aRhs.mIndex;
+ }
+ bool operator!=(const iterator_type& aRhs) const { return !(*this == aRhs); }
+ bool operator<(const iterator_type& aRhs) const {
+ return mIndex < aRhs.mIndex;
+ }
+ bool operator>(const iterator_type& aRhs) const {
+ return mIndex > aRhs.mIndex;
+ }
+ bool operator<=(const iterator_type& aRhs) const {
+ return mIndex <= aRhs.mIndex;
+ }
+ bool operator>=(const iterator_type& aRhs) const {
+ return mIndex >= aRhs.mIndex;
+ }
+
+ // These operators depend on the release mode bounds checks in
+ // ArrayIterator::ElementAt for safety.
+ value_type* operator->() const {
+ return const_cast<value_type*>(&mArray->ElementAt(mIndex));
+ }
+ Element operator*() const {
+ return const_cast<Element>(mArray->ElementAt(mIndex));
+ }
+
+ iterator_type& operator++() {
+ ++mIndex;
+ return *this;
+ }
+ iterator_type operator++(int) {
+ iterator_type it = *this;
+ ++*this;
+ return it;
+ }
+ iterator_type& operator--() {
+ --mIndex;
+ return *this;
+ }
+ iterator_type operator--(int) {
+ iterator_type it = *this;
+ --*this;
+ return it;
+ }
+
+ iterator_type& operator+=(difference_type aDiff) {
+ mIndex += aDiff;
+ return *this;
+ }
+ iterator_type& operator-=(difference_type aDiff) {
+ mIndex -= aDiff;
+ return *this;
+ }
+
+ iterator_type operator+(difference_type aDiff) const {
+ iterator_type it = *this;
+ it += aDiff;
+ return it;
+ }
+ iterator_type operator-(difference_type aDiff) const {
+ iterator_type it = *this;
+ it -= aDiff;
+ return it;
+ }
+
+ difference_type operator-(const iterator_type& aOther) const {
+ return static_cast<difference_type>(mIndex) -
+ static_cast<difference_type>(aOther.mIndex);
+ }
+
+ Element operator[](difference_type aIndex) const {
+ return *this->operator+(aIndex);
+ }
+
+ constexpr const array_type* GetArray() const { return mArray; }
+
+ constexpr index_type GetIndex() const { return mIndex; }
+};
+
+} // namespace mozilla
+
+#endif // mozilla_ArrayIterator_h
diff --git a/xpcom/ds/Atom.py b/xpcom/ds/Atom.py
new file mode 100644
index 0000000000..1399ba840a
--- /dev/null
+++ b/xpcom/ds/Atom.py
@@ -0,0 +1,64 @@
+# 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/.
+
+
+class Atom:
+ def __init__(self, ident, string, ty="nsStaticAtom"):
+ self.ident = ident
+ self.string = string
+ self.ty = ty
+ self.atom_type = self.__class__.__name__
+ self.hash = hash_string(string)
+ self.is_ascii_lowercase = is_ascii_lowercase(string)
+
+
+class PseudoElementAtom(Atom):
+ def __init__(self, ident, string):
+ Atom.__init__(self, ident, string, ty="nsCSSPseudoElementStaticAtom")
+
+
+class AnonBoxAtom(Atom):
+ def __init__(self, ident, string):
+ Atom.__init__(self, ident, string, ty="nsCSSAnonBoxPseudoStaticAtom")
+
+
+class NonInheritingAnonBoxAtom(AnonBoxAtom):
+ def __init__(self, ident, string):
+ AnonBoxAtom.__init__(self, ident, string)
+
+
+class InheritingAnonBoxAtom(AnonBoxAtom):
+ def __init__(self, ident, string):
+ AnonBoxAtom.__init__(self, ident, string)
+
+
+GOLDEN_RATIO_U32 = 0x9E3779B9
+
+
+def rotate_left_5(value):
+ return ((value << 5) | (value >> 27)) & 0xFFFFFFFF
+
+
+def wrapping_multiply(x, y):
+ return (x * y) & 0xFFFFFFFF
+
+
+# Calculate the precomputed hash of the static atom. This is a port of
+# mozilla::HashString(const char16_t*), which is what we use for atomizing
+# strings. An assertion in nsAtomTable::RegisterStaticAtoms ensures that
+# the value we compute here matches what HashString() would produce.
+def hash_string(s):
+ h = 0
+ for c in s:
+ h = wrapping_multiply(GOLDEN_RATIO_U32, rotate_left_5(h) ^ ord(c))
+ return h
+
+
+# Returns true if lowercasing this string in an ascii-case-insensitive way
+# would leave the string unchanged.
+def is_ascii_lowercase(s):
+ for c in s:
+ if c >= "A" and c <= "Z":
+ return False
+ return True
diff --git a/xpcom/ds/AtomArray.h b/xpcom/ds/AtomArray.h
new file mode 100644
index 0000000000..5b1e0a0eae
--- /dev/null
+++ b/xpcom/ds/AtomArray.h
@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_AtomArray_h
+#define mozilla_AtomArray_h
+
+#include "mozilla/RefPtr.h"
+#include "nsTArray.h"
+
+class nsAtom;
+
+namespace mozilla {
+typedef AutoTArray<RefPtr<nsAtom>, 4> AtomArray;
+}
+
+#endif // mozilla_AtomArray_h
diff --git a/xpcom/ds/Dafsa.cpp b/xpcom/ds/Dafsa.cpp
new file mode 100644
index 0000000000..8854e0ff1d
--- /dev/null
+++ b/xpcom/ds/Dafsa.cpp
@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "Dafsa.h"
+
+#include "mozilla/Assertions.h"
+#include "nsAString.h"
+
+const int mozilla::Dafsa::kKeyNotFound = -1;
+
+// Note the DAFSA implementation was lifted from eTLD code in Chromium that was
+// originally lifted from Firefox.
+
+// Read next offset from pos.
+// Returns true if an offset could be read, false otherwise.
+static bool GetNextOffset(const unsigned char** pos, const unsigned char* end,
+ const unsigned char** offset) {
+ if (*pos == end) return false;
+
+ // When reading an offset the byte array must always contain at least
+ // three more bytes to consume. First the offset to read, then a node
+ // to skip over and finally a destination node. No object can be smaller
+ // than one byte.
+ MOZ_ASSERT(*pos + 2 < end);
+ size_t bytes_consumed;
+ switch (**pos & 0x60) {
+ case 0x60: // Read three byte offset
+ *offset += (((*pos)[0] & 0x1F) << 16) | ((*pos)[1] << 8) | (*pos)[2];
+ bytes_consumed = 3;
+ break;
+ case 0x40: // Read two byte offset
+ *offset += (((*pos)[0] & 0x1F) << 8) | (*pos)[1];
+ bytes_consumed = 2;
+ break;
+ default:
+ *offset += (*pos)[0] & 0x3F;
+ bytes_consumed = 1;
+ }
+ if ((**pos & 0x80) != 0) {
+ *pos = end;
+ } else {
+ *pos += bytes_consumed;
+ }
+ return true;
+}
+
+// Check if byte at offset is last in label.
+static bool IsEOL(const unsigned char* offset, const unsigned char* end) {
+ MOZ_ASSERT(offset < end);
+ return (*offset & 0x80) != 0;
+}
+
+// Check if byte at offset matches first character in key.
+// This version matches characters not last in label.
+static bool IsMatch(const unsigned char* offset, const unsigned char* end,
+ const char* key) {
+ MOZ_ASSERT(offset < end);
+ return *offset == *key;
+}
+
+// Check if byte at offset matches first character in key.
+// This version matches characters last in label.
+static bool IsEndCharMatch(const unsigned char* offset,
+ const unsigned char* end, const char* key) {
+ MOZ_ASSERT(offset < end);
+ return *offset == (*key | 0x80);
+}
+
+// Read return value at offset.
+// Returns true if a return value could be read, false otherwise.
+static bool GetReturnValue(const unsigned char* offset,
+ const unsigned char* end, int* return_value) {
+ MOZ_ASSERT(offset < end);
+ if ((*offset & 0xE0) == 0x80) {
+ *return_value = *offset & 0x0F;
+ return true;
+ }
+ return false;
+}
+
+// Lookup a domain key in a byte array generated by make_dafsa.py.
+// The rule type is returned if key is found, otherwise kKeyNotFound is
+// returned.
+static int LookupString(const unsigned char* graph, size_t length,
+ const char* key, size_t key_length) {
+ const unsigned char* pos = graph;
+ const unsigned char* end = graph + length;
+ const unsigned char* offset = pos;
+ const char* key_end = key + key_length;
+ while (GetNextOffset(&pos, end, &offset)) {
+ // char <char>+ end_char offsets
+ // char <char>+ return value
+ // char end_char offsets
+ // char return value
+ // end_char offsets
+ // return_value
+ bool did_consume = false;
+ if (key != key_end && !IsEOL(offset, end)) {
+ // Leading <char> is not a match. Don't dive into this child
+ if (!IsMatch(offset, end, key)) continue;
+ did_consume = true;
+ ++offset;
+ ++key;
+ // Possible matches at this point:
+ // <char>+ end_char offsets
+ // <char>+ return value
+ // end_char offsets
+ // return value
+ // Remove all remaining <char> nodes possible
+ while (!IsEOL(offset, end) && key != key_end) {
+ if (!IsMatch(offset, end, key)) return mozilla::Dafsa::kKeyNotFound;
+ ++key;
+ ++offset;
+ }
+ }
+ // Possible matches at this point:
+ // end_char offsets
+ // return_value
+ // If one or more <char> elements were consumed, a failure
+ // to match is terminal. Otherwise, try the next node.
+ if (key == key_end) {
+ int return_value;
+ if (GetReturnValue(offset, end, &return_value)) return return_value;
+ // The DAFSA guarantees that if the first char is a match, all
+ // remaining char elements MUST match if the key is truly present.
+ if (did_consume) return mozilla::Dafsa::kKeyNotFound;
+ continue;
+ }
+ if (!IsEndCharMatch(offset, end, key)) {
+ if (did_consume) return mozilla::Dafsa::kKeyNotFound; // Unexpected
+ continue;
+ }
+ ++key;
+ pos = ++offset; // Dive into child
+ }
+ return mozilla::Dafsa::kKeyNotFound; // No match
+}
+
+namespace mozilla {
+
+int Dafsa::Lookup(const nsACString& aKey) const {
+ return LookupString(mData.Elements(), mData.Length(), aKey.BeginReading(),
+ aKey.Length());
+}
+
+} // namespace mozilla
diff --git a/xpcom/ds/Dafsa.h b/xpcom/ds/Dafsa.h
new file mode 100644
index 0000000000..1a5584f632
--- /dev/null
+++ b/xpcom/ds/Dafsa.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_Dafsa_h
+#define mozilla_Dafsa_h
+
+#include "stdint.h"
+
+#include "mozilla/Span.h"
+#include "nsStringFwd.h"
+
+namespace mozilla {
+
+/**
+ * A deterministic acyclic finite state automaton suitable for storing static
+ * dictionaries of tagged ascii strings. Consider using this if you have a very
+ * large set of strings that need an associated enum value.
+ *
+ * Currently the string tag is limited by `make_dafsa.py` to a value of [0-4].
+ * In theory [0-15] can easily be supported.
+ *
+ * See `make_dafsa.py` for more details.
+ */
+class Dafsa {
+ public:
+ using Graph = Span<const uint8_t>;
+
+ /**
+ * Initializes the DAFSA with a binary encoding generated by `make_dafsa.py`.
+ */
+ explicit Dafsa(const Graph& aData) : mData(aData) {}
+
+ ~Dafsa() = default;
+
+ /**
+ * Searches for the given string in the DAFSA.
+ *
+ * @param aKey The string to search for.
+ * @returns kKeyNotFound if not found, otherwise the associated tag.
+ */
+ int Lookup(const nsACString& aKey) const;
+
+ static const int kKeyNotFound;
+
+ private:
+ const Graph mData;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_Dafsa_h
diff --git a/xpcom/ds/HTMLAtoms.py b/xpcom/ds/HTMLAtoms.py
new file mode 100644
index 0000000000..ae4df76cc3
--- /dev/null
+++ b/xpcom/ds/HTMLAtoms.py
@@ -0,0 +1,257 @@
+# THIS FILE IS GENERATED BY THE HTML PARSER TRANSLATOR AND WILL BE OVERWRITTEN!
+from Atom import Atom
+
+HTML_PARSER_ATOMS = [
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink", "xlink"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xml_space", "xml:space"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xml_lang", "xml:lang"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("aria_grab", "aria-grab"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("aria_channel", "aria-channel"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("aria_secret", "aria-secret"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("aria_templateid", "aria-templateid"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("aria_datatype", "aria-datatype"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("local", "local"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xchannelselector", "xchannelselector"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("ychannelselector", "ychannelselector"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("enable_background", "enable-background"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("calcmode", "calcmode"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("specularexponent", "specularexponent"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("specularconstant", "specularconstant"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("gradienttransform", "gradienttransform"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("gradientunits", "gradientunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("rendering_intent", "rendering-intent"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("stddeviation", "stddeviation"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("basefrequency", "basefrequency"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("baseprofile", "baseprofile"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("baseProfile", "baseProfile"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("edgemode", "edgemode"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("repeatcount", "repeatcount"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("repeatdur", "repeatdur"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("spreadmethod", "spreadmethod"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("diffuseconstant", "diffuseconstant"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("surfacescale", "surfacescale"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("lengthadjust", "lengthadjust"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("origin", "origin"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("targetx", "targetx"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("targety", "targety"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("pathlength", "pathlength"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("definitionurl", "definitionurl"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("limitingconeangle", "limitingconeangle"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("markerheight", "markerheight"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("markerwidth", "markerwidth"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("maskunits", "maskunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("markerunits", "markerunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("maskcontentunits", "maskcontentunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("tablevalues", "tablevalues"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("primitiveunits", "primitiveunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("zoomandpan", "zoomandpan"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("kernelmatrix", "kernelmatrix"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("kerning", "kerning"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("kernelunitlength", "kernelunitlength"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("pointsatx", "pointsatx"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("pointsaty", "pointsaty"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("pointsatz", "pointsatz"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_href", "xlink:href"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_title", "xlink:title"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_role", "xlink:role"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_arcrole", "xlink:arcrole"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("arcrole", "arcrole"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xmlns_xlink", "xmlns:xlink"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_type", "xlink:type"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_show", "xlink:show"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("xlink_actuate", "xlink:actuate"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("color_rendering", "color-rendering"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("numoctaves", "numoctaves"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("onmousewheel", "onmousewheel"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("clippathunits", "clippathunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("glyph_orientation_vertical", "glyph-orientation-vertical"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("glyph_orientation_horizontal", "glyph-orientation-horizontal"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("glyphref", "glyphref"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("keypoints", "keypoints"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("attributename", "attributename"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("attributetype", "attributetype"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("startoffset", "startoffset"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("keysplines", "keysplines"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("preservealpha", "preservealpha"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("preserveaspectratio", "preserveaspectratio"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("alttext", "alttext"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("filterunits", "filterunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("keytimes", "keytimes"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("patterntransform", "patterntransform"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("patternunits", "patternunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("patterncontentunits", "patterncontentunits"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("stitchtiles", "stitchtiles"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("systemlanguage", "systemlanguage"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("textlength", "textlength"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("requiredfeatures", "requiredfeatures"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("requiredextensions", "requiredextensions"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("viewtarget", "viewtarget"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("viewbox", "viewbox"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("refx", "refx"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("refy", "refy"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fefunca", "fefunca"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fefuncb", "fefuncb"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feblend", "feblend"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feflood", "feflood"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feturbulence", "feturbulence"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("femergenode", "femergenode"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feimage", "feimage"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("femerge", "femerge"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fetile", "fetile"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fecomposite", "fecomposite"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altglyphdef", "altglyphdef"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altGlyphDef", "altGlyphDef"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fefuncg", "fefuncg"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fediffuselighting", "fediffuselighting"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fespecularlighting", "fespecularlighting"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altglyph", "altglyph"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altGlyph", "altGlyph"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("clippath", "clippath"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("textpath", "textpath"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altglyphitem", "altglyphitem"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("altGlyphItem", "altGlyphItem"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("animatetransform", "animatetransform"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("animatemotion", "animatemotion"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fedisplacementmap", "fedisplacementmap"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("animatecolor", "animatecolor"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fefuncr", "fefuncr"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fecomponenttransfer", "fecomponenttransfer"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fegaussianblur", "fegaussianblur"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("foreignobject", "foreignobject"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feoffset", "feoffset"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fespotlight", "fespotlight"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fepointlight", "fepointlight"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fedistantlight", "fedistantlight"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("lineargradient", "lineargradient"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("radialgradient", "radialgradient"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fedropshadow", "fedropshadow"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("fecolormatrix", "fecolormatrix"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("feconvolvematrix", "feconvolvematrix"),
+ # ATOM GENERATED BY HTML PARSER TRANSLATOR (WILL BE AUTOMATICALLY OVERWRITTEN):
+ Atom("femorphology", "femorphology"),
+]
diff --git a/xpcom/ds/IncrementalTokenizer.cpp b/xpcom/ds/IncrementalTokenizer.cpp
new file mode 100644
index 0000000000..db6fddb82b
--- /dev/null
+++ b/xpcom/ds/IncrementalTokenizer.cpp
@@ -0,0 +1,190 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/IncrementalTokenizer.h"
+
+#include "mozilla/AutoRestore.h"
+
+#include "nsIInputStream.h"
+#include "IncrementalTokenizer.h"
+#include <algorithm>
+
+namespace mozilla {
+
+IncrementalTokenizer::IncrementalTokenizer(Consumer&& aConsumer,
+ const char* aWhitespaces,
+ const char* aAdditionalWordChars,
+ uint32_t aRawMinBuffered)
+ : TokenizerBase(aWhitespaces, aAdditionalWordChars)
+#ifdef DEBUG
+ ,
+ mConsuming(false)
+#endif
+ ,
+ mNeedMoreInput(false),
+ mRollback(false),
+ mInputCursor(0),
+ mConsumer(std::move(aConsumer)) {
+ mInputFinished = false;
+ mMinRawDelivery = aRawMinBuffered;
+}
+
+nsresult IncrementalTokenizer::FeedInput(const nsACString& aInput) {
+ NS_ENSURE_TRUE(mConsumer, NS_ERROR_NOT_INITIALIZED);
+ MOZ_ASSERT(!mInputFinished);
+
+ mInput.Cut(0, mInputCursor);
+ mInputCursor = 0;
+
+ mInput.Append(aInput);
+
+ return Process();
+}
+
+nsresult IncrementalTokenizer::FeedInput(nsIInputStream* aInput,
+ uint32_t aCount) {
+ NS_ENSURE_TRUE(mConsumer, NS_ERROR_NOT_INITIALIZED);
+ MOZ_ASSERT(!mInputFinished);
+ MOZ_ASSERT(!mConsuming);
+
+ mInput.Cut(0, mInputCursor);
+ mInputCursor = 0;
+
+ nsresult rv = NS_OK;
+ while (NS_SUCCEEDED(rv) && aCount) {
+ nsCString::index_type remainder = mInput.Length();
+ nsCString::index_type load =
+ std::min<nsCString::index_type>(aCount, PR_UINT32_MAX - remainder);
+
+ if (!load) {
+ // To keep the API simple, we fail if the input data buffer if filled.
+ // It's highly unlikely there will ever be such amout of data cumulated
+ // unless a logic fault in the consumer code.
+ NS_ERROR("IncrementalTokenizer consumer not reading data?");
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (!mInput.SetLength(remainder + load, fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ auto buffer = mInput.BeginWriting() + remainder;
+
+ uint32_t read;
+ rv = aInput->Read(buffer, load, &read);
+ if (NS_SUCCEEDED(rv)) {
+ // remainder + load fits the uint32_t size, so must remainder + read.
+ mInput.SetLength(remainder + read);
+ aCount -= read;
+
+ rv = Process();
+ }
+ }
+
+ return rv;
+}
+
+nsresult IncrementalTokenizer::FinishInput() {
+ NS_ENSURE_TRUE(mConsumer, NS_ERROR_NOT_INITIALIZED);
+ MOZ_ASSERT(!mInputFinished);
+ MOZ_ASSERT(!mConsuming);
+
+ mInput.Cut(0, mInputCursor);
+ mInputCursor = 0;
+
+ mInputFinished = true;
+ nsresult rv = Process();
+ mConsumer = nullptr;
+ return rv;
+}
+
+bool IncrementalTokenizer::Next(Token& aToken) {
+ // Assert we are called only from the consumer callback
+ MOZ_ASSERT(mConsuming);
+
+ if (mPastEof) {
+ return false;
+ }
+
+ nsACString::const_char_iterator next = Parse(aToken);
+ mPastEof = aToken.Type() == TOKEN_EOF;
+ if (next == mCursor && !mPastEof) {
+ // Not enough input to make a deterministic decision.
+ return false;
+ }
+
+ AssignFragment(aToken, mCursor, next);
+ mCursor = next;
+ return true;
+}
+
+void IncrementalTokenizer::NeedMoreInput() {
+ // Assert we are called only from the consumer callback
+ MOZ_ASSERT(mConsuming);
+
+ // When the input has been finished, we can't set the flag to prevent
+ // indefinite wait for more input (that will never come)
+ mNeedMoreInput = !mInputFinished;
+}
+
+void IncrementalTokenizer::Rollback() {
+ // Assert we are called only from the consumer callback
+ MOZ_ASSERT(mConsuming);
+
+ mRollback = true;
+}
+
+nsresult IncrementalTokenizer::Process() {
+#ifdef DEBUG
+ // Assert we are not re-entered
+ MOZ_ASSERT(!mConsuming);
+
+ AutoRestore<bool> consuming(mConsuming);
+ mConsuming = true;
+#endif
+
+ MOZ_ASSERT(!mPastEof);
+
+ nsresult rv = NS_OK;
+
+ mInput.BeginReading(mCursor);
+ mCursor += mInputCursor;
+ mInput.EndReading(mEnd);
+
+ while (NS_SUCCEEDED(rv) && !mPastEof) {
+ Token token;
+ nsACString::const_char_iterator next = Parse(token);
+ mPastEof = token.Type() == TOKEN_EOF;
+ if (next == mCursor && !mPastEof) {
+ // Not enough input to make a deterministic decision.
+ break;
+ }
+
+ AssignFragment(token, mCursor, next);
+
+ nsACString::const_char_iterator rollback = mCursor;
+ mCursor = next;
+
+ mNeedMoreInput = mRollback = false;
+
+ rv = mConsumer(token, *this);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+ if (mNeedMoreInput || mRollback) {
+ mCursor = rollback;
+ mPastEof = false;
+ if (mNeedMoreInput) {
+ break;
+ }
+ }
+ }
+
+ mInputCursor = mCursor - mInput.BeginReading();
+ return rv;
+}
+
+} // namespace mozilla
diff --git a/xpcom/ds/IncrementalTokenizer.h b/xpcom/ds/IncrementalTokenizer.h
new file mode 100644
index 0000000000..c2647052c9
--- /dev/null
+++ b/xpcom/ds/IncrementalTokenizer.h
@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef INCREMENTAL_TOKENIZER_H__
+#define INCREMENTAL_TOKENIZER_H__
+
+#include "mozilla/Tokenizer.h"
+
+#include "nsError.h"
+#include <functional>
+
+class nsIInputStream;
+
+namespace mozilla {
+
+class IncrementalTokenizer : public TokenizerBase<char> {
+ public:
+ /**
+ * The consumer callback. The function is called for every single token
+ * as found in the input. Failure result returned by this callback stops
+ * the tokenization immediately and bubbles to result of Feed/FinishInput.
+ *
+ * Fragment()s of consumed tokens are ensured to remain valid until next call
+ * to Feed/FinishInput and are pointing to a single linear buffer. Hence,
+ * those can be safely used to accumulate the data for processing after
+ * Feed/FinishInput returned.
+ */
+ typedef std::function<nsresult(Token const&, IncrementalTokenizer& i)>
+ Consumer;
+
+ /**
+ * For aWhitespaces and aAdditionalWordChars arguments see TokenizerBase.
+ *
+ * @param aConsumer
+ * A mandatory non-null argument, a function that consumes the tokens as
+ * they come when the tokenizer is fed.
+ * @param aRawMinBuffered
+ * When we have buffered at least aRawMinBuffered data, but there was no
+ * custom token found so far because of too small incremental feed chunks,
+ * deliver the raw data to preserve streaming and to save memory. This only
+ * has effect in OnlyCustomTokenizing mode.
+ */
+ explicit IncrementalTokenizer(Consumer&& aConsumer,
+ const char* aWhitespaces = nullptr,
+ const char* aAdditionalWordChars = nullptr,
+ uint32_t aRawMinBuffered = 1024);
+
+ /**
+ * Pushes the input to be tokenized. These directly call the Consumer
+ * callback on every found token. Result of the Consumer callback is returned
+ * here.
+ *
+ * The tokenizer must be initialized with a valid consumer prior call to these
+ * methods. It's not allowed to call Feed/FinishInput from inside the
+ * Consumer callback.
+ */
+ nsresult FeedInput(const nsACString& aInput);
+ nsresult FeedInput(nsIInputStream* aInput, uint32_t aCount);
+ nsresult FinishInput();
+
+ /**
+ * Can only be called from inside the consumer callback.
+ *
+ * When there is still anything to read from the input, tokenize it, store
+ * the token type and value to aToken result and shift the cursor past this
+ * just parsed token. Each call to Next() reads another token from
+ * the input and shifts the cursor.
+ *
+ * Returns false if there is not enough data to deterministically recognize
+ * tokens or when the last returned token was EOF.
+ */
+ [[nodiscard]] bool Next(Token& aToken);
+
+ /**
+ * Can only be called from inside the consumer callback.
+ *
+ * Tells the tokenizer to revert the cursor and stop the async parsing until
+ * next feed of the input. This is useful when more than one token is needed
+ * to decide on the syntax but there is not enough input to get a next token
+ * (Next() returned false.)
+ */
+ void NeedMoreInput();
+
+ /**
+ * Can only be called from inside the consumer callback.
+ *
+ * This makes the consumer callback be called again while parsing
+ * the input at the previous cursor position again. This is useful when
+ * the tokenizer state (custom tokens, tokenization mode) has changed and
+ * we want to re-parse the input again.
+ */
+ void Rollback();
+
+ private:
+ // Loops over the input with TokenizerBase::Parse and calls the Consumer
+ // callback.
+ nsresult Process();
+
+#ifdef DEBUG
+ // True when inside the consumer callback, used only for assertions.
+ bool mConsuming;
+#endif // DEBUG
+ // Modifyable only from the Consumer callback, tells the parser to break,
+ // rollback and wait for more input.
+ bool mNeedMoreInput;
+ // Modifyable only from the Consumer callback, tells the parser to rollback
+ // and parse the input again, with (if modified) new settings of the
+ // tokenizer.
+ bool mRollback;
+ // The input buffer. Updated with each call to Feed/FinishInput.
+ nsCString mInput;
+ // Numerical index pointing at the current cursor position. We don't keep
+ // direct reference to the string buffer since the buffer gets often
+ // reallocated.
+ nsCString::index_type mInputCursor;
+ // Refernce to the consumer function.
+ Consumer mConsumer;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/xpcom/ds/Observer.h b/xpcom/ds/Observer.h
new file mode 100644
index 0000000000..3d189603eb
--- /dev/null
+++ b/xpcom/ds/Observer.h
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_Observer_h
+#define mozilla_Observer_h
+
+#include "nsTObserverArray.h"
+
+namespace mozilla {
+
+/**
+ * Observer<T> provides a way for a class to observe something.
+ * When an event has to be broadcasted to all Observer<T>, Notify() method
+ * is called.
+ * T represents the type of the object passed in argument to Notify().
+ *
+ * @see ObserverList.
+ */
+template <class T>
+class Observer {
+ public:
+ virtual ~Observer() = default;
+ virtual void Notify(const T& aParam) = 0;
+};
+
+/**
+ * ObserverList<T> tracks Observer<T> and can notify them when Broadcast() is
+ * called.
+ * T represents the type of the object passed in argument to Broadcast() and
+ * sent to Observer<T> objects through Notify().
+ *
+ * @see Observer.
+ */
+template <class T>
+class ObserverList {
+ public:
+ /**
+ * Note: When calling AddObserver, it's up to the caller to make sure the
+ * object isn't going to be release as long as RemoveObserver hasn't been
+ * called.
+ *
+ * @see RemoveObserver()
+ */
+ void AddObserver(Observer<T>* aObserver) {
+ mObservers.AppendElementUnlessExists(aObserver);
+ }
+
+ /**
+ * Remove the observer from the observer list.
+ * @return Whether the observer has been found in the list.
+ */
+ bool RemoveObserver(Observer<T>* aObserver) {
+ return mObservers.RemoveElement(aObserver);
+ }
+
+ uint32_t Length() { return mObservers.Length(); }
+
+ /**
+ * Call Notify() on each item in the list.
+ */
+ void Broadcast(const T& aParam) {
+ for (Observer<T>* obs : mObservers.ForwardRange()) {
+ obs->Notify(aParam);
+ }
+ }
+
+ protected:
+ nsTObserverArray<Observer<T>*> mObservers;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_Observer_h
diff --git a/xpcom/ds/PLDHashTable.cpp b/xpcom/ds/PLDHashTable.cpp
new file mode 100644
index 0000000000..2814813f68
--- /dev/null
+++ b/xpcom/ds/PLDHashTable.cpp
@@ -0,0 +1,870 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <new>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "PLDHashTable.h"
+#include "nsDebug.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/OperatorNewExtensions.h"
+#include "mozilla/ScopeExit.h"
+#include "nsAlgorithm.h"
+#include "nsPointerHashKeys.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ChaosMode.h"
+
+using namespace mozilla;
+
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+
+class AutoReadOp {
+ Checker& mChk;
+
+ public:
+ explicit AutoReadOp(Checker& aChk) : mChk(aChk) { mChk.StartReadOp(); }
+ ~AutoReadOp() { mChk.EndReadOp(); }
+};
+
+class AutoWriteOp {
+ Checker& mChk;
+
+ public:
+ explicit AutoWriteOp(Checker& aChk) : mChk(aChk) { mChk.StartWriteOp(); }
+ ~AutoWriteOp() { mChk.EndWriteOp(); }
+};
+
+class AutoIteratorRemovalOp {
+ Checker& mChk;
+
+ public:
+ explicit AutoIteratorRemovalOp(Checker& aChk) : mChk(aChk) {
+ mChk.StartIteratorRemovalOp();
+ }
+ ~AutoIteratorRemovalOp() { mChk.EndIteratorRemovalOp(); }
+};
+
+class AutoDestructorOp {
+ Checker& mChk;
+
+ public:
+ explicit AutoDestructorOp(Checker& aChk) : mChk(aChk) {
+ mChk.StartDestructorOp();
+ }
+ ~AutoDestructorOp() { mChk.EndDestructorOp(); }
+};
+
+#endif
+
+/* static */
+PLDHashNumber PLDHashTable::HashStringKey(const void* aKey) {
+ return HashString(static_cast<const char*>(aKey));
+}
+
+/* static */
+PLDHashNumber PLDHashTable::HashVoidPtrKeyStub(const void* aKey) {
+ return nsPtrHashKey<void>::HashKey(aKey);
+}
+
+/* static */
+bool PLDHashTable::MatchEntryStub(const PLDHashEntryHdr* aEntry,
+ const void* aKey) {
+ const PLDHashEntryStub* stub = (const PLDHashEntryStub*)aEntry;
+
+ return stub->key == aKey;
+}
+
+/* static */
+bool PLDHashTable::MatchStringKey(const PLDHashEntryHdr* aEntry,
+ const void* aKey) {
+ const PLDHashEntryStub* stub = (const PLDHashEntryStub*)aEntry;
+
+ // XXX tolerate null keys on account of sloppy Mozilla callers.
+ return stub->key == aKey ||
+ (stub->key && aKey &&
+ strcmp((const char*)stub->key, (const char*)aKey) == 0);
+}
+
+/* static */
+void PLDHashTable::MoveEntryStub(PLDHashTable* aTable,
+ const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo) {
+ memcpy(aTo, aFrom, aTable->mEntrySize);
+}
+
+/* static */
+void PLDHashTable::ClearEntryStub(PLDHashTable* aTable,
+ PLDHashEntryHdr* aEntry) {
+ memset(aEntry, 0, aTable->mEntrySize);
+}
+
+static const PLDHashTableOps gStubOps = {
+ PLDHashTable::HashVoidPtrKeyStub, PLDHashTable::MatchEntryStub,
+ PLDHashTable::MoveEntryStub, PLDHashTable::ClearEntryStub, nullptr};
+
+/* static */ const PLDHashTableOps* PLDHashTable::StubOps() {
+ return &gStubOps;
+}
+
+static bool SizeOfEntryStore(uint32_t aCapacity, uint32_t aEntrySize,
+ uint32_t* aNbytes) {
+ uint32_t slotSize = aEntrySize + sizeof(PLDHashNumber);
+ uint64_t nbytes64 = uint64_t(aCapacity) * uint64_t(slotSize);
+ *aNbytes = aCapacity * slotSize;
+ return uint64_t(*aNbytes) == nbytes64; // returns false on overflow
+}
+
+// Compute max and min load numbers (entry counts). We have a secondary max
+// that allows us to overload a table reasonably if it cannot be grown further
+// (i.e. if ChangeTable() fails). The table slows down drastically if the
+// secondary max is too close to 1, but 0.96875 gives only a slight slowdown
+// while allowing 1.3x more elements.
+static inline uint32_t MaxLoad(uint32_t aCapacity) {
+ return aCapacity - (aCapacity >> 2); // == aCapacity * 0.75
+}
+static inline uint32_t MaxLoadOnGrowthFailure(uint32_t aCapacity) {
+ return aCapacity - (aCapacity >> 5); // == aCapacity * 0.96875
+}
+static inline uint32_t MinLoad(uint32_t aCapacity) {
+ return aCapacity >> 2; // == aCapacity * 0.25
+}
+
+// Compute the minimum capacity (and the Log2 of that capacity) for a table
+// containing |aLength| elements while respecting the following contraints:
+// - table must be at most 75% full;
+// - capacity must be a power of two;
+// - capacity cannot be too small.
+static inline void BestCapacity(uint32_t aLength, uint32_t* aCapacityOut,
+ uint32_t* aLog2CapacityOut) {
+ // Callers should ensure this is true.
+ MOZ_ASSERT(aLength <= PLDHashTable::kMaxInitialLength);
+
+ // Compute the smallest capacity allowing |aLength| elements to be inserted
+ // without rehashing.
+ uint32_t capacity = (aLength * 4 + (3 - 1)) / 3; // == ceil(aLength * 4 / 3)
+ if (capacity < PLDHashTable::kMinCapacity) {
+ capacity = PLDHashTable::kMinCapacity;
+ }
+
+ // Round up capacity to next power-of-two.
+ uint32_t log2 = CeilingLog2(capacity);
+ capacity = 1u << log2;
+ MOZ_ASSERT(capacity <= PLDHashTable::kMaxCapacity);
+
+ *aCapacityOut = capacity;
+ *aLog2CapacityOut = log2;
+}
+
+/* static */ MOZ_ALWAYS_INLINE uint32_t
+PLDHashTable::HashShift(uint32_t aEntrySize, uint32_t aLength) {
+ if (aLength > kMaxInitialLength) {
+ MOZ_CRASH("Initial length is too large");
+ }
+
+ uint32_t capacity, log2;
+ BestCapacity(aLength, &capacity, &log2);
+
+ uint32_t nbytes;
+ if (!SizeOfEntryStore(capacity, aEntrySize, &nbytes)) {
+ MOZ_CRASH("Initial entry store size is too large");
+ }
+
+ // Compute the hashShift value.
+ return kPLDHashNumberBits - log2;
+}
+
+PLDHashTable::PLDHashTable(const PLDHashTableOps* aOps, uint32_t aEntrySize,
+ uint32_t aLength)
+ : mOps(aOps),
+ mEntryStore(),
+ mGeneration(0),
+ mHashShift(HashShift(aEntrySize, aLength)),
+ mEntrySize(aEntrySize),
+ mEntryCount(0),
+ mRemovedCount(0) {
+ // An entry size greater than 0xff is unlikely, but let's check anyway. If
+ // you hit this, your hashtable would waste lots of space for unused entries
+ // and you should change your hash table's entries to pointers.
+ if (aEntrySize != uint32_t(mEntrySize)) {
+ MOZ_CRASH("Entry size is too large");
+ }
+}
+
+PLDHashTable& PLDHashTable::operator=(PLDHashTable&& aOther) {
+ if (this == &aOther) {
+ return *this;
+ }
+
+ // |mOps| and |mEntrySize| are required to stay the same, they're
+ // conceptually part of the type -- indeed, if PLDHashTable was a templated
+ // type like nsTHashtable, they *would* be part of the type -- so it only
+ // makes sense to assign in cases where they match.
+ MOZ_RELEASE_ASSERT(mOps == aOther.mOps || !mOps);
+ MOZ_RELEASE_ASSERT(mEntrySize == aOther.mEntrySize || !mEntrySize);
+
+ // Reconstruct |this|.
+ const PLDHashTableOps* ops = aOther.mOps;
+ this->~PLDHashTable();
+ new (KnownNotNull, this) PLDHashTable(ops, aOther.mEntrySize, 0);
+
+ // Move non-const pieces over.
+ mHashShift = std::move(aOther.mHashShift);
+ mEntryCount = std::move(aOther.mEntryCount);
+ mRemovedCount = std::move(aOther.mRemovedCount);
+ mEntryStore.Set(aOther.mEntryStore.Get(), &mGeneration);
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mChecker = std::move(aOther.mChecker);
+#endif
+
+ // Clear up |aOther| so its destruction will be a no-op and it reports being
+ // empty.
+ {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoDestructorOp op(mChecker);
+#endif
+ aOther.mEntryCount = 0;
+ aOther.mEntryStore.Set(nullptr, &aOther.mGeneration);
+ }
+
+ return *this;
+}
+
+PLDHashNumber PLDHashTable::Hash1(PLDHashNumber aHash0) const {
+ return aHash0 >> mHashShift;
+}
+
+void PLDHashTable::Hash2(PLDHashNumber aHash0, uint32_t& aHash2Out,
+ uint32_t& aSizeMaskOut) const {
+ uint32_t sizeLog2 = kPLDHashNumberBits - mHashShift;
+ uint32_t sizeMask = (PLDHashNumber(1) << sizeLog2) - 1;
+ aSizeMaskOut = sizeMask;
+
+ // The incoming aHash0 always has the low bit unset (since we leave it
+ // free for the collision flag), and should have reasonably random
+ // data in the other 31 bits. We used the high bits of aHash0 for
+ // Hash1, so we use the low bits here. If the table size is large,
+ // the bits we use may overlap, but that's still more random than
+ // filling with 0s.
+ //
+ // Double hashing needs the second hash code to be relatively prime to table
+ // size, so we simply make hash2 odd.
+ //
+ // This also conveniently covers up the fact that we have the low bit
+ // unset since aHash0 has the low bit unset.
+ aHash2Out = (aHash0 & sizeMask) | 1;
+}
+
+// Reserve mKeyHash 0 for free entries and 1 for removed-entry sentinels. Note
+// that a removed-entry sentinel need be stored only if the removed entry had
+// a colliding entry added after it. Therefore we can use 1 as the collision
+// flag in addition to the removed-entry sentinel value. Multiplicative hash
+// uses the high order bits of mKeyHash, so this least-significant reservation
+// should not hurt the hash function's effectiveness much.
+
+// Match an entry's mKeyHash against an unstored one computed from a key.
+/* static */
+bool PLDHashTable::MatchSlotKeyhash(Slot& aSlot, const PLDHashNumber aKeyHash) {
+ return (aSlot.KeyHash() & ~kCollisionFlag) == aKeyHash;
+}
+
+// Compute the address of the indexed entry in table.
+auto PLDHashTable::SlotForIndex(uint32_t aIndex) const -> Slot {
+ return mEntryStore.SlotForIndex(aIndex, mEntrySize, CapacityFromHashShift());
+}
+
+PLDHashTable::~PLDHashTable() {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoDestructorOp op(mChecker);
+#endif
+
+ if (!mEntryStore.IsAllocated()) {
+ return;
+ }
+
+ // Clear any remaining live entries (if not trivially destructible).
+ if (mOps->clearEntry) {
+ mEntryStore.ForEachSlot(Capacity(), mEntrySize, [&](const Slot& aSlot) {
+ if (aSlot.IsLive()) {
+ mOps->clearEntry(this, aSlot.ToEntry());
+ }
+ });
+ }
+
+ // Entry storage is freed last, by ~EntryStore().
+}
+
+void PLDHashTable::ClearAndPrepareForLength(uint32_t aLength) {
+ // Get these values before the destructor clobbers them.
+ const PLDHashTableOps* ops = mOps;
+ uint32_t entrySize = mEntrySize;
+
+ this->~PLDHashTable();
+ new (KnownNotNull, this) PLDHashTable(ops, entrySize, aLength);
+}
+
+void PLDHashTable::Clear() { ClearAndPrepareForLength(kDefaultInitialLength); }
+
+// If |Reason| is |ForAdd|, the return value is always non-null and it may be
+// a previously-removed entry. If |Reason| is |ForSearchOrRemove|, the return
+// value is null on a miss, and will never be a previously-removed entry on a
+// hit. This distinction is a bit grotty but this function is hot enough that
+// these differences are worthwhile. (It's also hot enough that
+// MOZ_ALWAYS_INLINE makes a significant difference.)
+template <PLDHashTable::SearchReason Reason, typename Success, typename Failure>
+MOZ_ALWAYS_INLINE auto PLDHashTable::SearchTable(const void* aKey,
+ PLDHashNumber aKeyHash,
+ Success&& aSuccess,
+ Failure&& aFailure) const {
+ MOZ_ASSERT(mEntryStore.IsAllocated());
+ NS_ASSERTION(!(aKeyHash & kCollisionFlag), "!(aKeyHash & kCollisionFlag)");
+
+ // Compute the primary hash address.
+ PLDHashNumber hash1 = Hash1(aKeyHash);
+ Slot slot = SlotForIndex(hash1);
+
+ // Miss: return space for a new entry.
+ if (slot.IsFree()) {
+ return (Reason == ForAdd) ? aSuccess(slot) : aFailure();
+ }
+
+ // Hit: return entry.
+ PLDHashMatchEntry matchEntry = mOps->matchEntry;
+ if (MatchSlotKeyhash(slot, aKeyHash)) {
+ PLDHashEntryHdr* e = slot.ToEntry();
+ if (matchEntry(e, aKey)) {
+ return aSuccess(slot);
+ }
+ }
+
+ // Collision: double hash.
+ PLDHashNumber hash2;
+ uint32_t sizeMask;
+ Hash2(aKeyHash, hash2, sizeMask);
+
+ // Save the first removed entry slot so Add() can recycle it. (Only used
+ // if Reason==ForAdd.)
+ Maybe<Slot> firstRemoved;
+
+ for (;;) {
+ if (Reason == ForAdd && !firstRemoved) {
+ if (MOZ_UNLIKELY(slot.IsRemoved())) {
+ firstRemoved.emplace(slot);
+ } else {
+ slot.MarkColliding();
+ }
+ }
+
+ hash1 -= hash2;
+ hash1 &= sizeMask;
+
+ slot = SlotForIndex(hash1);
+ if (slot.IsFree()) {
+ if (Reason != ForAdd) {
+ return aFailure();
+ }
+ return aSuccess(firstRemoved.refOr(slot));
+ }
+
+ if (MatchSlotKeyhash(slot, aKeyHash)) {
+ PLDHashEntryHdr* e = slot.ToEntry();
+ if (matchEntry(e, aKey)) {
+ return aSuccess(slot);
+ }
+ }
+ }
+
+ // NOTREACHED
+ return aFailure();
+}
+
+// This is a copy of SearchTable(), used by ChangeTable(), hardcoded to
+// 1. assume |Reason| is |ForAdd|,
+// 2. assume that |aKey| will never match an existing entry, and
+// 3. assume that no entries have been removed from the current table
+// structure.
+// Avoiding the need for |aKey| means we can avoid needing a way to map entries
+// to keys, which means callers can use complex key types more easily.
+MOZ_ALWAYS_INLINE auto PLDHashTable::FindFreeSlot(PLDHashNumber aKeyHash) const
+ -> Slot {
+ MOZ_ASSERT(mEntryStore.IsAllocated());
+ NS_ASSERTION(!(aKeyHash & kCollisionFlag), "!(aKeyHash & kCollisionFlag)");
+
+ // Compute the primary hash address.
+ PLDHashNumber hash1 = Hash1(aKeyHash);
+ Slot slot = SlotForIndex(hash1);
+
+ // Miss: return space for a new entry.
+ if (slot.IsFree()) {
+ return slot;
+ }
+
+ // Collision: double hash.
+ PLDHashNumber hash2;
+ uint32_t sizeMask;
+ Hash2(aKeyHash, hash2, sizeMask);
+
+ for (;;) {
+ MOZ_ASSERT(!slot.IsRemoved());
+ slot.MarkColliding();
+
+ hash1 -= hash2;
+ hash1 &= sizeMask;
+
+ slot = SlotForIndex(hash1);
+ if (slot.IsFree()) {
+ return slot;
+ }
+ }
+
+ // NOTREACHED
+}
+
+bool PLDHashTable::ChangeTable(int32_t aDeltaLog2) {
+ MOZ_ASSERT(mEntryStore.IsAllocated());
+
+ // Look, but don't touch, until we succeed in getting new entry store.
+ int32_t oldLog2 = kPLDHashNumberBits - mHashShift;
+ int32_t newLog2 = oldLog2 + aDeltaLog2;
+ uint32_t newCapacity = 1u << newLog2;
+ if (newCapacity > kMaxCapacity) {
+ return false;
+ }
+
+ uint32_t nbytes;
+ if (!SizeOfEntryStore(newCapacity, mEntrySize, &nbytes)) {
+ return false; // overflowed
+ }
+
+ char* newEntryStore = (char*)calloc(1, nbytes);
+ if (!newEntryStore) {
+ return false;
+ }
+
+ // We can't fail from here on, so update table parameters.
+ mHashShift = kPLDHashNumberBits - newLog2;
+ mRemovedCount = 0;
+
+ // Assign the new entry store to table.
+ char* oldEntryStore = mEntryStore.Get();
+ mEntryStore.Set(newEntryStore, &mGeneration);
+ PLDHashMoveEntry moveEntry = mOps->moveEntry;
+
+ // Copy only live entries, leaving removed ones behind.
+ uint32_t oldCapacity = 1u << oldLog2;
+ EntryStore::ForEachSlot(
+ oldEntryStore, oldCapacity, mEntrySize, [&](const Slot& slot) {
+ if (slot.IsLive()) {
+ const PLDHashNumber key = slot.KeyHash() & ~kCollisionFlag;
+ Slot newSlot = FindFreeSlot(key);
+ MOZ_ASSERT(newSlot.IsFree());
+ moveEntry(this, slot.ToEntry(), newSlot.ToEntry());
+ newSlot.SetKeyHash(key);
+ }
+ });
+
+ free(oldEntryStore);
+ return true;
+}
+
+MOZ_ALWAYS_INLINE PLDHashNumber
+PLDHashTable::ComputeKeyHash(const void* aKey) const {
+ MOZ_ASSERT(mEntryStore.IsAllocated());
+
+ PLDHashNumber keyHash = mozilla::ScrambleHashCode(mOps->hashKey(aKey));
+
+ // Avoid 0 and 1 hash codes, they indicate free and removed entries.
+ if (keyHash < 2) {
+ keyHash -= 2;
+ }
+ keyHash &= ~kCollisionFlag;
+
+ return keyHash;
+}
+
+PLDHashEntryHdr* PLDHashTable::Search(const void* aKey) const {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoReadOp op(mChecker);
+#endif
+
+ if (!mEntryStore.IsAllocated()) {
+ return nullptr;
+ }
+
+ return SearchTable<ForSearchOrRemove>(
+ aKey, ComputeKeyHash(aKey),
+ [&](Slot& slot) -> PLDHashEntryHdr* { return slot.ToEntry(); },
+ [&]() -> PLDHashEntryHdr* { return nullptr; });
+}
+
+PLDHashEntryHdr* PLDHashTable::Add(const void* aKey,
+ const mozilla::fallible_t& aFallible) {
+ auto maybeEntryHandle = MakeEntryHandle(aKey, aFallible);
+ if (!maybeEntryHandle) {
+ return nullptr;
+ }
+ return maybeEntryHandle->OrInsert([&aKey, this](PLDHashEntryHdr* entry) {
+ if (mOps->initEntry) {
+ mOps->initEntry(entry, aKey);
+ }
+ });
+}
+
+PLDHashEntryHdr* PLDHashTable::Add(const void* aKey) {
+ return MakeEntryHandle(aKey).OrInsert([&aKey, this](PLDHashEntryHdr* entry) {
+ if (mOps->initEntry) {
+ mOps->initEntry(entry, aKey);
+ }
+ });
+}
+
+void PLDHashTable::Remove(const void* aKey) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoWriteOp op(mChecker);
+#endif
+
+ if (!mEntryStore.IsAllocated()) {
+ return;
+ }
+
+ PLDHashNumber keyHash = ComputeKeyHash(aKey);
+ SearchTable<ForSearchOrRemove>(
+ aKey, keyHash,
+ [&](Slot& slot) {
+ RawRemove(slot);
+ ShrinkIfAppropriate();
+ },
+ [&]() {
+ // Do nothing.
+ });
+}
+
+void PLDHashTable::RemoveEntry(PLDHashEntryHdr* aEntry) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoWriteOp op(mChecker);
+#endif
+
+ RawRemove(aEntry);
+ ShrinkIfAppropriate();
+}
+
+void PLDHashTable::RawRemove(PLDHashEntryHdr* aEntry) {
+ Slot slot(mEntryStore.SlotForPLDHashEntry(aEntry, Capacity(), mEntrySize));
+ RawRemove(slot);
+}
+
+void PLDHashTable::RawRemove(Slot& aSlot) {
+ // Unfortunately, we can only do weak checking here. That's because
+ // RawRemove() can be called legitimately while an Enumerate() call is
+ // active, which doesn't fit well into how Checker's mState variable works.
+ MOZ_ASSERT(mChecker.IsWritable());
+
+ MOZ_ASSERT(mEntryStore.IsAllocated());
+
+ MOZ_ASSERT(aSlot.IsLive());
+
+ // Load keyHash first in case clearEntry() goofs it.
+ PLDHashNumber keyHash = aSlot.KeyHash();
+ if (mOps->clearEntry) {
+ PLDHashEntryHdr* entry = aSlot.ToEntry();
+ mOps->clearEntry(this, entry);
+ }
+ if (keyHash & kCollisionFlag) {
+ aSlot.MarkRemoved();
+ mRemovedCount++;
+ } else {
+ aSlot.MarkFree();
+ }
+ mEntryCount--;
+}
+
+// Shrink or compress if a quarter or more of all entries are removed, or if the
+// table is underloaded according to the minimum alpha, and is not minimal-size
+// already.
+void PLDHashTable::ShrinkIfAppropriate() {
+ uint32_t capacity = Capacity();
+ if (mRemovedCount >= capacity >> 2 ||
+ (capacity > kMinCapacity && mEntryCount <= MinLoad(capacity))) {
+ uint32_t log2;
+ BestCapacity(mEntryCount, &capacity, &log2);
+
+ int32_t deltaLog2 = log2 - (kPLDHashNumberBits - mHashShift);
+ MOZ_ASSERT(deltaLog2 <= 0);
+
+ (void)ChangeTable(deltaLog2);
+ }
+}
+
+size_t PLDHashTable::ShallowSizeOfExcludingThis(
+ MallocSizeOf aMallocSizeOf) const {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ AutoReadOp op(mChecker);
+#endif
+
+ return aMallocSizeOf(mEntryStore.Get());
+}
+
+size_t PLDHashTable::ShallowSizeOfIncludingThis(
+ MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+}
+
+mozilla::Maybe<PLDHashTable::EntryHandle> PLDHashTable::MakeEntryHandle(
+ const void* aKey, const mozilla::fallible_t&) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mChecker.StartWriteOp();
+ auto endWriteOp = MakeScopeExit([&] { mChecker.EndWriteOp(); });
+#endif
+
+ // Allocate the entry storage if it hasn't already been allocated.
+ if (!mEntryStore.IsAllocated()) {
+ uint32_t nbytes;
+ // We already checked this in the constructor, so it must still be true.
+ MOZ_RELEASE_ASSERT(
+ SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes));
+ mEntryStore.Set((char*)calloc(1, nbytes), &mGeneration);
+ if (!mEntryStore.IsAllocated()) {
+ return Nothing();
+ }
+ }
+
+ // If alpha is >= .75, grow or compress the table. If aKey is already in the
+ // table, we may grow once more than necessary, but only if we are on the
+ // edge of being overloaded.
+ uint32_t capacity = Capacity();
+ if (mEntryCount + mRemovedCount >= MaxLoad(capacity)) {
+ // Compress if a quarter or more of all entries are removed.
+ int deltaLog2 = 1;
+ if (mRemovedCount >= capacity >> 2) {
+ deltaLog2 = 0;
+ }
+
+ // Grow or compress the table. If ChangeTable() fails, allow overloading up
+ // to the secondary max. Once we hit the secondary max, return null.
+ if (!ChangeTable(deltaLog2) &&
+ mEntryCount + mRemovedCount >= MaxLoadOnGrowthFailure(capacity)) {
+ return Nothing();
+ }
+ }
+
+ // Look for entry after possibly growing, so we don't have to add it,
+ // then skip it while growing the table and re-add it after.
+ PLDHashNumber keyHash = ComputeKeyHash(aKey);
+ Slot slot = SearchTable<ForAdd>(
+ aKey, keyHash, [](Slot& found) -> Slot { return found; },
+ []() -> Slot {
+ MOZ_CRASH("Nope");
+ return Slot(nullptr, nullptr);
+ });
+
+ // The `EntryHandle` will handle ending the write op when it is destroyed.
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ endWriteOp.release();
+#endif
+
+ return Some(EntryHandle{this, keyHash, slot});
+}
+
+PLDHashTable::EntryHandle PLDHashTable::MakeEntryHandle(const void* aKey) {
+ auto res = MakeEntryHandle(aKey, fallible);
+ if (!res) {
+ if (!mEntryStore.IsAllocated()) {
+ // We OOM'd while allocating the initial entry storage.
+ uint32_t nbytes;
+ (void)SizeOfEntryStore(CapacityFromHashShift(), mEntrySize, &nbytes);
+ NS_ABORT_OOM(nbytes);
+ } else {
+ // We failed to resize the existing entry storage, either due to OOM or
+ // because we exceeded the maximum table capacity or size; report it as
+ // an OOM. The multiplication by 2 gets us the size we tried to allocate,
+ // which is double the current size.
+ NS_ABORT_OOM(2 * EntrySize() * EntryCount());
+ }
+ }
+ return res.extract();
+}
+
+PLDHashTable::EntryHandle::EntryHandle(PLDHashTable* aTable,
+ PLDHashNumber aKeyHash, Slot aSlot)
+ : mTable(aTable), mKeyHash(aKeyHash), mSlot(aSlot) {}
+
+PLDHashTable::EntryHandle::EntryHandle(EntryHandle&& aOther) noexcept
+ : mTable(std::exchange(aOther.mTable, nullptr)),
+ mKeyHash(aOther.mKeyHash),
+ mSlot(aOther.mSlot) {}
+
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+PLDHashTable::EntryHandle::~EntryHandle() {
+ if (!mTable) {
+ return;
+ }
+
+ mTable->mChecker.EndWriteOp();
+}
+#endif
+
+void PLDHashTable::EntryHandle::Remove() {
+ MOZ_ASSERT(HasEntry());
+
+ mTable->RawRemove(mSlot);
+}
+
+void PLDHashTable::EntryHandle::OrRemove() {
+ if (HasEntry()) {
+ Remove();
+ }
+}
+
+void PLDHashTable::EntryHandle::OccupySlot() {
+ MOZ_ASSERT(!HasEntry());
+
+ PLDHashNumber keyHash = mKeyHash;
+ if (mSlot.IsRemoved()) {
+ mTable->mRemovedCount--;
+ keyHash |= kCollisionFlag;
+ }
+ mSlot.SetKeyHash(keyHash);
+ mTable->mEntryCount++;
+}
+
+PLDHashTable::Iterator::Iterator(Iterator&& aOther)
+ : mTable(aOther.mTable),
+ mCurrent(aOther.mCurrent),
+ mNexts(aOther.mNexts),
+ mNextsLimit(aOther.mNextsLimit),
+ mHaveRemoved(aOther.mHaveRemoved),
+ mEntrySize(aOther.mEntrySize) {
+ // No need to change |mChecker| here.
+ aOther.mTable = nullptr;
+ // We don't really have the concept of a null slot, so leave mCurrent.
+ aOther.mNexts = 0;
+ aOther.mNextsLimit = 0;
+ aOther.mHaveRemoved = false;
+ aOther.mEntrySize = 0;
+}
+
+PLDHashTable::Iterator::Iterator(PLDHashTable* aTable)
+ : mTable(aTable),
+ mCurrent(mTable->mEntryStore.SlotForIndex(0, mTable->mEntrySize,
+ mTable->Capacity())),
+ mNexts(0),
+ mNextsLimit(mTable->EntryCount()),
+ mHaveRemoved(false),
+ mEntrySize(aTable->mEntrySize) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mTable->mChecker.StartReadOp();
+#endif
+
+ if (ChaosMode::isActive(ChaosFeature::HashTableIteration) &&
+ mTable->Capacity() > 0) {
+ // Start iterating at a random entry. It would be even more chaotic to
+ // iterate in fully random order, but that's harder.
+ uint32_t capacity = mTable->CapacityFromHashShift();
+ uint32_t i = ChaosMode::randomUint32LessThan(capacity);
+ mCurrent =
+ mTable->mEntryStore.SlotForIndex(i, mTable->mEntrySize, capacity);
+ }
+
+ // Advance to the first live entry, if there is one.
+ if (!Done() && IsOnNonLiveEntry()) {
+ MoveToNextLiveEntry();
+ }
+}
+
+PLDHashTable::Iterator::Iterator(PLDHashTable* aTable, EndIteratorTag aTag)
+ : mTable(aTable),
+ mCurrent(mTable->mEntryStore.SlotForIndex(0, mTable->mEntrySize,
+ mTable->Capacity())),
+ mNexts(mTable->EntryCount()),
+ mNextsLimit(mTable->EntryCount()),
+ mHaveRemoved(false),
+ mEntrySize(aTable->mEntrySize) {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mTable->mChecker.StartReadOp();
+#endif
+
+ MOZ_ASSERT(Done());
+}
+
+PLDHashTable::Iterator::Iterator(const Iterator& aOther)
+ : mTable(aOther.mTable),
+ mCurrent(aOther.mCurrent),
+ mNexts(aOther.mNexts),
+ mNextsLimit(aOther.mNextsLimit),
+ mHaveRemoved(aOther.mHaveRemoved),
+ mEntrySize(aOther.mEntrySize) {
+ // TODO: Is this necessary?
+ MOZ_ASSERT(!mHaveRemoved);
+
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mTable->mChecker.StartReadOp();
+#endif
+}
+
+PLDHashTable::Iterator::~Iterator() {
+ if (mTable) {
+ if (mHaveRemoved) {
+ mTable->ShrinkIfAppropriate();
+ }
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mTable->mChecker.EndReadOp();
+#endif
+ }
+}
+
+MOZ_ALWAYS_INLINE bool PLDHashTable::Iterator::IsOnNonLiveEntry() const {
+ MOZ_ASSERT(!Done());
+ return !mCurrent.IsLive();
+}
+
+void PLDHashTable::Iterator::Next() {
+ MOZ_ASSERT(!Done());
+
+ mNexts++;
+
+ // Advance to the next live entry, if there is one.
+ if (!Done()) {
+ MoveToNextLiveEntry();
+ }
+}
+
+MOZ_ALWAYS_INLINE void PLDHashTable::Iterator::MoveToNextLiveEntry() {
+ // Chaos mode requires wraparound to cover all possible entries, so we can't
+ // simply move to the next live entry and stop when we hit the end of the
+ // entry store. But we don't want to introduce extra branches into our inner
+ // loop. So we are going to exploit the structure of the entry store in this
+ // method to implement an efficient inner loop.
+ //
+ // The idea is that since we are really only iterating through the stored
+ // hashes and because we know that there are a power-of-two number of
+ // hashes, we can use masking to implement the wraparound for us. This
+ // method does have the downside of needing to recalculate where the
+ // associated entry is once we've found it, but that seems OK.
+
+ // Our current slot and its associated hash.
+ Slot slot = mCurrent;
+ PLDHashNumber* p = slot.HashPtr();
+ const uint32_t capacity = mTable->CapacityFromHashShift();
+ const uint32_t mask = capacity - 1;
+ auto hashes = reinterpret_cast<PLDHashNumber*>(mTable->mEntryStore.Get());
+ uint32_t slotIndex = p - hashes;
+
+ do {
+ slotIndex = (slotIndex + 1) & mask;
+ } while (!Slot::IsLiveHash(hashes[slotIndex]));
+
+ // slotIndex now indicates where a live slot is. Rematerialize the entry
+ // and the slot.
+ mCurrent = mTable->mEntryStore.SlotForIndex(slotIndex, mEntrySize, capacity);
+}
+
+void PLDHashTable::Iterator::Remove() {
+ mTable->RawRemove(mCurrent);
+ mHaveRemoved = true;
+}
diff --git a/xpcom/ds/PLDHashTable.h b/xpcom/ds/PLDHashTable.h
new file mode 100644
index 0000000000..67e4d7fdcf
--- /dev/null
+++ b/xpcom/ds/PLDHashTable.h
@@ -0,0 +1,807 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// See the comment at the top of mfbt/HashTable.h for a comparison between
+// PLDHashTable and mozilla::HashTable.
+
+#ifndef PLDHashTable_h
+#define PLDHashTable_h
+
+#include <utility>
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/fallible.h"
+#include "nscore.h"
+
+using PLDHashNumber = mozilla::HashNumber;
+static const uint32_t kPLDHashNumberBits = mozilla::kHashNumberBits;
+
+#if defined(DEBUG) || defined(FUZZING)
+# define MOZ_HASH_TABLE_CHECKS_ENABLED 1
+#endif
+
+class PLDHashTable;
+struct PLDHashTableOps;
+
+// Table entry header structure.
+//
+// In order to allow in-line allocation of key and value, we do not declare
+// either here. Instead, the API uses const void *key as a formal parameter.
+// The key need not be stored in the entry; it may be part of the value, but
+// need not be stored at all.
+//
+// Callback types are defined below and grouped into the PLDHashTableOps
+// structure, for single static initialization per hash table sub-type.
+//
+// Each hash table sub-type should make its entry type a subclass of
+// PLDHashEntryHdr. PLDHashEntryHdr is merely a common superclass to present a
+// uniform interface to PLDHashTable clients. The zero-sized base class
+// optimization, employed by all of our supported C++ compilers, will ensure
+// that this abstraction does not make objects needlessly larger.
+struct PLDHashEntryHdr {
+ PLDHashEntryHdr() = default;
+ PLDHashEntryHdr(const PLDHashEntryHdr&) = delete;
+ PLDHashEntryHdr& operator=(const PLDHashEntryHdr&) = delete;
+ PLDHashEntryHdr(PLDHashEntryHdr&&) = default;
+ PLDHashEntryHdr& operator=(PLDHashEntryHdr&&) = default;
+
+ private:
+ friend class PLDHashTable;
+};
+
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+
+// This class does three kinds of checking:
+//
+// - that calls to one of |mOps| or to an enumerator do not cause re-entry into
+// the table in an unsafe way;
+//
+// - that multiple threads do not access the table in an unsafe way;
+//
+// - that a table marked as immutable is not modified.
+//
+// "Safe" here means that multiple concurrent read operations are ok, but a
+// write operation (i.e. one that can cause the entry storage to be reallocated
+// or destroyed) cannot safely run concurrently with another read or write
+// operation. This meaning of "safe" is only partial; for example, it does not
+// cover whether a single entry in the table is modified by two separate
+// threads. (Doing such checking would be much harder.)
+//
+// It does this with two variables:
+//
+// - mState, which embodies a tri-stage tagged union with the following
+// variants:
+// - Idle
+// - Read(n), where 'n' is the number of concurrent read operations
+// - Write
+//
+// - mIsWritable, which indicates if the table is mutable.
+//
+class Checker {
+ public:
+ constexpr Checker() : mState(kIdle), mIsWritable(true) {}
+
+ Checker& operator=(Checker&& aOther) {
+ // Atomic<> doesn't have an |operator=(Atomic<>&&)|.
+ mState = uint32_t(aOther.mState);
+ mIsWritable = bool(aOther.mIsWritable);
+
+ aOther.mState = kIdle;
+ // XXX Shouldn't we set mIsWritable to true here for consistency?
+
+ return *this;
+ }
+
+ static bool IsIdle(uint32_t aState) { return aState == kIdle; }
+ static bool IsRead(uint32_t aState) {
+ return kRead1 <= aState && aState <= kReadMax;
+ }
+ static bool IsRead1(uint32_t aState) { return aState == kRead1; }
+ static bool IsWrite(uint32_t aState) { return aState == kWrite; }
+
+ bool IsIdle() const { return mState == kIdle; }
+
+ bool IsWritable() const { return mIsWritable; }
+
+ void SetNonWritable() { mIsWritable = false; }
+
+ // NOTE: the obvious way to implement these functions is to (a) check
+ // |mState| is reasonable, and then (b) update |mState|. But the lack of
+ // atomicity in such an implementation can cause problems if we get unlucky
+ // thread interleaving between (a) and (b).
+ //
+ // So instead for |mState| we are careful to (a) first get |mState|'s old
+ // value and assign it a new value in single atomic operation, and only then
+ // (b) check the old value was reasonable. This ensures we don't have
+ // interleaving problems.
+ //
+ // For |mIsWritable| we don't need to be as careful because it can only in
+ // transition in one direction (from writable to non-writable).
+
+ void StartReadOp() {
+ uint32_t oldState = mState++; // this is an atomic increment
+ MOZ_RELEASE_ASSERT(IsIdle(oldState) || IsRead(oldState));
+ MOZ_RELEASE_ASSERT(oldState < kReadMax); // check for overflow
+ }
+
+ void EndReadOp() {
+ uint32_t oldState = mState--; // this is an atomic decrement
+ MOZ_RELEASE_ASSERT(IsRead(oldState));
+ }
+
+ void StartWriteOp() {
+ MOZ_RELEASE_ASSERT(IsWritable());
+ uint32_t oldState = mState.exchange(kWrite);
+ MOZ_RELEASE_ASSERT(IsIdle(oldState));
+ }
+
+ void EndWriteOp() {
+ // Check again that the table is writable, in case it was marked as
+ // non-writable just after the IsWritable() assertion in StartWriteOp()
+ // occurred.
+ MOZ_RELEASE_ASSERT(IsWritable());
+ uint32_t oldState = mState.exchange(kIdle);
+ MOZ_RELEASE_ASSERT(IsWrite(oldState));
+ }
+
+ void StartIteratorRemovalOp() {
+ // When doing removals at the end of iteration, we go from Read1 state to
+ // Write and then back.
+ MOZ_RELEASE_ASSERT(IsWritable());
+ uint32_t oldState = mState.exchange(kWrite);
+ MOZ_RELEASE_ASSERT(IsRead1(oldState));
+ }
+
+ void EndIteratorRemovalOp() {
+ // Check again that the table is writable, in case it was marked as
+ // non-writable just after the IsWritable() assertion in
+ // StartIteratorRemovalOp() occurred.
+ MOZ_RELEASE_ASSERT(IsWritable());
+ uint32_t oldState = mState.exchange(kRead1);
+ MOZ_RELEASE_ASSERT(IsWrite(oldState));
+ }
+
+ void StartDestructorOp() {
+ // A destructor op is like a write, but the table doesn't need to be
+ // writable.
+ uint32_t oldState = mState.exchange(kWrite);
+ MOZ_RELEASE_ASSERT(IsIdle(oldState));
+ }
+
+ void EndDestructorOp() {
+ uint32_t oldState = mState.exchange(kIdle);
+ MOZ_RELEASE_ASSERT(IsWrite(oldState));
+ }
+
+ private:
+ // Things of note about the representation of |mState|.
+ // - The values between kRead1..kReadMax represent valid Read(n) values.
+ // - kIdle and kRead1 are deliberately chosen so that incrementing the -
+ // former gives the latter.
+ // - 9999 concurrent readers should be enough for anybody.
+ static const uint32_t kIdle = 0;
+ static const uint32_t kRead1 = 1;
+ static const uint32_t kReadMax = 9999;
+ static const uint32_t kWrite = 10000;
+
+ mozilla::Atomic<uint32_t, mozilla::SequentiallyConsistent> mState;
+ mozilla::Atomic<bool, mozilla::SequentiallyConsistent> mIsWritable;
+};
+#endif
+
+// A PLDHashTable may be allocated on the stack or within another structure or
+// class. No entry storage is allocated until the first element is added. This
+// means that empty hash tables are cheap, which is good because they are
+// common.
+//
+// There used to be a long, math-heavy comment here about the merits of
+// double hashing vs. chaining; it was removed in bug 1058335. In short, double
+// hashing is more space-efficient unless the element size gets large (in which
+// case you should keep using double hashing but switch to using pointer
+// elements). Also, with double hashing, you can't safely hold an entry pointer
+// and use it after an add or remove operation, unless you sample Generation()
+// before adding or removing, and compare the sample after, dereferencing the
+// entry pointer only if Generation() has not changed.
+class PLDHashTable {
+ private:
+ // A slot represents a cached hash value and its associated entry stored in
+ // the hash table. The hash value and the entry are not stored contiguously.
+ struct Slot {
+ Slot(PLDHashEntryHdr* aEntry, PLDHashNumber* aKeyHash)
+ : mEntry(aEntry), mKeyHash(aKeyHash) {}
+
+ Slot(const Slot&) = default;
+ Slot(Slot&& aOther) = default;
+
+ Slot& operator=(Slot&& aOther) = default;
+
+ bool operator==(const Slot& aOther) const {
+ return mEntry == aOther.mEntry;
+ }
+
+ PLDHashNumber KeyHash() const { return *HashPtr(); }
+ void SetKeyHash(PLDHashNumber aHash) { *HashPtr() = aHash; }
+
+ PLDHashEntryHdr* ToEntry() const { return mEntry; }
+
+ bool IsFree() const { return KeyHash() == 0; }
+ bool IsRemoved() const { return KeyHash() == 1; }
+ bool IsLive() const { return IsLiveHash(KeyHash()); }
+ static bool IsLiveHash(uint32_t aHash) { return aHash >= 2; }
+
+ void MarkFree() { *HashPtr() = 0; }
+ void MarkRemoved() { *HashPtr() = 1; }
+ void MarkColliding() { *HashPtr() |= kCollisionFlag; }
+
+ void Next(uint32_t aEntrySize) {
+ char* p = reinterpret_cast<char*>(mEntry);
+ p += aEntrySize;
+ mEntry = reinterpret_cast<PLDHashEntryHdr*>(p);
+ mKeyHash++;
+ }
+ PLDHashNumber* HashPtr() const { return mKeyHash; }
+
+ private:
+ PLDHashEntryHdr* mEntry;
+ PLDHashNumber* mKeyHash;
+ };
+
+ // This class maintains the invariant that every time the entry store is
+ // changed, the generation is updated.
+ //
+ // The data layout separates the cached hashes of entries and the entries
+ // themselves to save space. We could store the entries thusly:
+ //
+ // +--------+--------+---------+
+ // | entry0 | entry1 | ... |
+ // +--------+--------+---------+
+ //
+ // where the entries themselves contain the cached hash stored as their
+ // first member. PLDHashTable did this for a long time, with entries looking
+ // like:
+ //
+ // class PLDHashEntryHdr
+ // {
+ // PLDHashNumber mKeyHash;
+ // };
+ //
+ // class MyEntry : public PLDHashEntryHdr
+ // {
+ // ...
+ // };
+ //
+ // The problem with this setup is that, depending on the layout of
+ // `MyEntry`, there may be platform ABI-mandated padding between `mKeyHash`
+ // and the first member of `MyEntry`. This ABI-mandated padding is wasted
+ // space, and was surprisingly common, e.g. when MyEntry contained a single
+ // pointer on 64-bit platforms.
+ //
+ // As previously alluded to, the current setup stores things thusly:
+ //
+ // +-------+-------+-------+-------+--------+--------+---------+
+ // | hash0 | hash1 | ..... | hashN | entry0 | entry1 | ... |
+ // +-------+-------+-------+-------+--------+--------+---------+
+ //
+ // which contains no wasted space between the hashes themselves, and no
+ // wasted space between the entries themselves. malloc is guaranteed to
+ // return blocks of memory with at least word alignment on all of our major
+ // platforms. PLDHashTable mandates that the size of the hash table is
+ // always a power of two, so the alignment of the memory containing the
+ // first entry is always at least the alignment of the entire entry store.
+ // That means the alignment of `entry0` should be its natural alignment.
+ // Entries may have problems if they contain over-aligned members such as
+ // SIMD vector types, but this has not been a problem in practice.
+ //
+ // Note: It would be natural to store the generation within this class, but
+ // we can't do that without bloating sizeof(PLDHashTable) on 64-bit machines.
+ // So instead we store it outside this class, and Set() takes a pointer to it
+ // and ensures it is updated as necessary.
+ class EntryStore {
+ private:
+ char* mEntryStore;
+
+ static char* Entries(char* aStore, uint32_t aCapacity) {
+ return aStore + aCapacity * sizeof(PLDHashNumber);
+ }
+
+ char* Entries(uint32_t aCapacity) const {
+ return Entries(Get(), aCapacity);
+ }
+
+ public:
+ EntryStore() : mEntryStore(nullptr) {}
+
+ ~EntryStore() {
+ free(mEntryStore);
+ mEntryStore = nullptr;
+ }
+
+ char* Get() const { return mEntryStore; }
+ bool IsAllocated() const { return !!mEntryStore; }
+
+ Slot SlotForIndex(uint32_t aIndex, uint32_t aEntrySize,
+ uint32_t aCapacity) const {
+ char* entries = Entries(aCapacity);
+ auto entry =
+ reinterpret_cast<PLDHashEntryHdr*>(entries + aIndex * aEntrySize);
+ auto hashes = reinterpret_cast<PLDHashNumber*>(Get());
+ return Slot(entry, &hashes[aIndex]);
+ }
+
+ Slot SlotForPLDHashEntry(PLDHashEntryHdr* aEntry, uint32_t aCapacity,
+ uint32_t aEntrySize) {
+ char* entries = Entries(aCapacity);
+ char* entry = reinterpret_cast<char*>(aEntry);
+ uint32_t entryOffset = entry - entries;
+ uint32_t slotIndex = entryOffset / aEntrySize;
+ return SlotForIndex(slotIndex, aEntrySize, aCapacity);
+ }
+
+ template <typename F>
+ void ForEachSlot(uint32_t aCapacity, uint32_t aEntrySize, F&& aFunc) {
+ ForEachSlot(Get(), aCapacity, aEntrySize, std::move(aFunc));
+ }
+
+ template <typename F>
+ static void ForEachSlot(char* aStore, uint32_t aCapacity,
+ uint32_t aEntrySize, F&& aFunc) {
+ char* entries = Entries(aStore, aCapacity);
+ Slot slot(reinterpret_cast<PLDHashEntryHdr*>(entries),
+ reinterpret_cast<PLDHashNumber*>(aStore));
+ for (size_t i = 0; i < aCapacity; ++i) {
+ aFunc(slot);
+ slot.Next(aEntrySize);
+ }
+ }
+
+ void Set(char* aEntryStore, uint16_t* aGeneration) {
+ mEntryStore = aEntryStore;
+ *aGeneration += 1;
+ }
+ };
+
+ // These fields are packed carefully. On 32-bit platforms,
+ // sizeof(PLDHashTable) is 20. On 64-bit platforms, sizeof(PLDHashTable) is
+ // 32; 28 bytes of data followed by 4 bytes of padding for alignment.
+ const PLDHashTableOps* const mOps; // Virtual operations; see below.
+ EntryStore mEntryStore; // (Lazy) entry storage and generation.
+ uint16_t mGeneration; // The storage generation.
+ uint8_t mHashShift; // Multiplicative hash shift.
+ const uint8_t mEntrySize; // Number of bytes in an entry.
+ uint32_t mEntryCount; // Number of entries in table.
+ uint32_t mRemovedCount; // Removed entry sentinels in table.
+
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mutable Checker mChecker;
+#endif
+
+ public:
+ // Table capacity limit; do not exceed. The max capacity used to be 1<<23 but
+ // that occasionally that wasn't enough. Making it much bigger than 1<<26
+ // probably isn't worthwhile -- tables that big are kind of ridiculous.
+ // Also, the growth operation will (deliberately) fail if |capacity *
+ // mEntrySize| overflows a uint32_t, and mEntrySize is always at least 8
+ // bytes.
+ static const uint32_t kMaxCapacity = ((uint32_t)1 << 26);
+
+ static const uint32_t kMinCapacity = 8;
+
+ // Making this half of kMaxCapacity ensures it'll fit. Nobody should need an
+ // initial length anywhere nearly this large, anyway.
+ static const uint32_t kMaxInitialLength = kMaxCapacity / 2;
+
+ // This gives a default initial capacity of 8.
+ static const uint32_t kDefaultInitialLength = 4;
+
+ // Initialize the table with |aOps| and |aEntrySize|. The table's initial
+ // capacity is chosen such that |aLength| elements can be inserted without
+ // rehashing; if |aLength| is a power-of-two, this capacity will be
+ // |2*length|. However, because entry storage is allocated lazily, this
+ // initial capacity won't be relevant until the first element is added; prior
+ // to that the capacity will be zero.
+ //
+ // This will crash if |aEntrySize| and/or |aLength| are too large.
+ PLDHashTable(const PLDHashTableOps* aOps, uint32_t aEntrySize,
+ uint32_t aLength = kDefaultInitialLength);
+
+ PLDHashTable(PLDHashTable&& aOther)
+ // Initialize fields which are checked by the move assignment operator
+ // and the destructor (which the move assignment operator calls).
+ : mOps(nullptr), mEntryStore(), mGeneration(0), mEntrySize(0) {
+ *this = std::move(aOther);
+ }
+
+ PLDHashTable& operator=(PLDHashTable&& aOther);
+
+ ~PLDHashTable();
+
+ // This should be used rarely.
+ const PLDHashTableOps* Ops() const { return mOps; }
+
+ // Size in entries (gross, not net of free and removed sentinels) for table.
+ // This can be zero if no elements have been added yet, in which case the
+ // entry storage will not have yet been allocated.
+ uint32_t Capacity() const {
+ return mEntryStore.IsAllocated() ? CapacityFromHashShift() : 0;
+ }
+
+ uint32_t EntrySize() const { return mEntrySize; }
+ uint32_t EntryCount() const { return mEntryCount; }
+ uint32_t Generation() const { return mGeneration; }
+
+ // To search for a |key| in |table|, call:
+ //
+ // entry = table.Search(key);
+ //
+ // If |entry| is non-null, |key| was found. If |entry| is null, key was not
+ // found.
+ PLDHashEntryHdr* Search(const void* aKey) const;
+
+ // To add an entry identified by |key| to table, call:
+ //
+ // entry = table.Add(key, mozilla::fallible);
+ //
+ // If |entry| is null upon return, then the table is severely overloaded and
+ // memory can't be allocated for entry storage.
+ //
+ // Otherwise, if the initEntry hook was provided, |entry| will be
+ // initialized. If the initEntry hook was not provided, the caller
+ // should initialize |entry| as appropriate.
+ PLDHashEntryHdr* Add(const void* aKey, const mozilla::fallible_t&);
+
+ // This is like the other Add() function, but infallible, and so never
+ // returns null.
+ PLDHashEntryHdr* Add(const void* aKey);
+
+ // To remove an entry identified by |key| from table, call:
+ //
+ // table.Remove(key);
+ //
+ // If |key|'s entry is found, it is cleared (via table->mOps->clearEntry).
+ // The table's capacity may be reduced afterwards.
+ void Remove(const void* aKey);
+
+ // To remove an entry found by a prior search, call:
+ //
+ // table.RemoveEntry(entry);
+ //
+ // The entry, which must be present and in use, is cleared (via
+ // table->mOps->clearEntry). The table's capacity may be reduced afterwards.
+ void RemoveEntry(PLDHashEntryHdr* aEntry);
+
+ // Remove an entry already accessed via Search() or Add().
+ //
+ // NB: this is a "raw" or low-level method. It does not shrink the table if
+ // it is underloaded. Don't use it unless necessary and you know what you are
+ // doing, and if so, please explain in a comment why it is necessary instead
+ // of RemoveEntry().
+ void RawRemove(PLDHashEntryHdr* aEntry);
+
+ // This function is equivalent to
+ // ClearAndPrepareForLength(kDefaultInitialLength).
+ void Clear();
+
+ // This function clears the table's contents and frees its entry storage,
+ // leaving it in a empty state ready to be used again. Afterwards, when the
+ // first element is added the entry storage that gets allocated will have a
+ // capacity large enough to fit |aLength| elements without rehashing.
+ //
+ // It's conceptually the same as calling the destructor and then re-calling
+ // the constructor with the original |aOps| and |aEntrySize| arguments, and
+ // a new |aLength| argument.
+ void ClearAndPrepareForLength(uint32_t aLength);
+
+ // Measure the size of the table's entry storage. If the entries contain
+ // pointers to other heap blocks, you have to iterate over the table and
+ // measure those separately; hence the "Shallow" prefix.
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ // Like ShallowSizeOfExcludingThis(), but includes sizeof(*this).
+ size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ // Mark a table as immutable for the remainder of its lifetime. This
+ // changes the implementation from asserting one set of invariants to
+ // asserting a different set.
+ void MarkImmutable() {
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ mChecker.SetNonWritable();
+#endif
+ }
+
+ // If you use PLDHashEntryStub or a subclass of it as your entry struct, and
+ // if your entries move via memcpy and clear via memset(0), you can use these
+ // stub operations.
+ static const PLDHashTableOps* StubOps();
+
+ // The individual stub operations in StubOps().
+ static PLDHashNumber HashVoidPtrKeyStub(const void* aKey);
+ static bool MatchEntryStub(const PLDHashEntryHdr* aEntry, const void* aKey);
+ static void MoveEntryStub(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo);
+ static void ClearEntryStub(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
+
+ // Hash/match operations for tables holding C strings.
+ static PLDHashNumber HashStringKey(const void* aKey);
+ static bool MatchStringKey(const PLDHashEntryHdr* aEntry, const void* aKey);
+
+ class EntryHandle {
+ public:
+ EntryHandle(EntryHandle&& aOther) noexcept;
+#ifdef MOZ_HASH_TABLE_CHECKS_ENABLED
+ ~EntryHandle();
+#endif
+
+ EntryHandle(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&) = delete;
+ EntryHandle& operator=(EntryHandle&& aOther) = delete;
+
+ // Is this slot currently occupied?
+ bool HasEntry() const { return mSlot.IsLive(); }
+
+ explicit operator bool() const { return HasEntry(); }
+
+ // Get the entry stored in this slot. May not be called unless the slot is
+ // currently occupied.
+ PLDHashEntryHdr* Entry() {
+ MOZ_ASSERT(HasEntry());
+ return mSlot.ToEntry();
+ }
+
+ template <class F>
+ void Insert(F&& aInitEntry) {
+ MOZ_ASSERT(!HasEntry());
+ OccupySlot();
+ std::forward<F>(aInitEntry)(Entry());
+ }
+
+ // If the slot is currently vacant, the slot is occupied and `initEntry` is
+ // invoked to initialize the entry. Returns the entry stored in now-occupied
+ // slot.
+ template <class F>
+ PLDHashEntryHdr* OrInsert(F&& aInitEntry) {
+ if (!HasEntry()) {
+ Insert(std::forward<F>(aInitEntry));
+ }
+ return Entry();
+ }
+
+ /** Removes the entry. Note that the table won't shrink on destruction of
+ * the EntryHandle.
+ *
+ * \pre HasEntry()
+ * \post !HasEntry()
+ */
+ void Remove();
+
+ /** Removes the entry, if it exists. Note that the table won't shrink on
+ * destruction of the EntryHandle.
+ *
+ * \post !HasEntry()
+ */
+ void OrRemove();
+
+ private:
+ friend class PLDHashTable;
+
+ EntryHandle(PLDHashTable* aTable, PLDHashNumber aKeyHash, Slot aSlot);
+
+ void OccupySlot();
+
+ PLDHashTable* mTable;
+ PLDHashNumber mKeyHash;
+ Slot mSlot;
+ };
+
+ template <class F>
+ auto WithEntryHandle(const void* aKey, F&& aFunc)
+ -> std::invoke_result_t<F, EntryHandle&&> {
+ return std::forward<F>(aFunc)(MakeEntryHandle(aKey));
+ }
+
+ template <class F>
+ auto WithEntryHandle(const void* aKey, const mozilla::fallible_t& aFallible,
+ F&& aFunc)
+ -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
+ return std::forward<F>(aFunc)(MakeEntryHandle(aKey, aFallible));
+ }
+
+ // This is an iterator for PLDHashtable. Assertions will detect some, but not
+ // all, mid-iteration table modifications that might invalidate (e.g.
+ // reallocate) the entry storage.
+ //
+ // Any element can be removed during iteration using Remove(). If any
+ // elements are removed, the table may be resized once iteration ends.
+ //
+ // Example usage:
+ //
+ // for (auto iter = table.Iter(); !iter.Done(); iter.Next()) {
+ // auto entry = static_cast<FooEntry*>(iter.Get());
+ // // ... do stuff with |entry| ...
+ // // ... possibly call iter.Remove() once ...
+ // }
+ //
+ // or:
+ //
+ // for (PLDHashTable::Iterator iter(&table); !iter.Done(); iter.Next()) {
+ // auto entry = static_cast<FooEntry*>(iter.Get());
+ // // ... do stuff with |entry| ...
+ // // ... possibly call iter.Remove() once ...
+ // }
+ //
+ // The latter form is more verbose but is easier to work with when
+ // making subclasses of Iterator.
+ //
+ class Iterator {
+ public:
+ explicit Iterator(PLDHashTable* aTable);
+ struct EndIteratorTag {};
+ Iterator(PLDHashTable* aTable, EndIteratorTag aTag);
+ Iterator(Iterator&& aOther);
+ ~Iterator();
+
+ // Have we finished?
+ bool Done() const { return mNexts == mNextsLimit; }
+
+ // Get the current entry.
+ PLDHashEntryHdr* Get() const {
+ MOZ_ASSERT(!Done());
+ MOZ_ASSERT(mCurrent.IsLive());
+ return mCurrent.ToEntry();
+ }
+
+ // Advance to the next entry.
+ void Next();
+
+ // Remove the current entry. Must only be called once per entry, and Get()
+ // must not be called on that entry afterwards.
+ void Remove();
+
+ bool operator==(const Iterator& aOther) const {
+ MOZ_ASSERT(mTable == aOther.mTable);
+ return mNexts == aOther.mNexts;
+ }
+
+ Iterator Clone() const { return {*this}; }
+
+ protected:
+ PLDHashTable* mTable; // Main table pointer.
+
+ private:
+ Slot mCurrent; // Pointer to the current entry.
+ uint32_t mNexts; // Number of Next() calls.
+ uint32_t mNextsLimit; // Next() call limit.
+
+ bool mHaveRemoved; // Have any elements been removed?
+ uint8_t mEntrySize; // Size of entries.
+
+ bool IsOnNonLiveEntry() const;
+
+ void MoveToNextLiveEntry();
+
+ Iterator() = delete;
+ Iterator(const Iterator&);
+ Iterator& operator=(const Iterator&) = delete;
+ Iterator& operator=(const Iterator&&) = delete;
+ };
+
+ Iterator Iter() { return Iterator(this); }
+
+ // Use this if you need to initialize an Iterator in a const method. If you
+ // use this case, you should not call Remove() on the iterator.
+ Iterator ConstIter() const {
+ return Iterator(const_cast<PLDHashTable*>(this));
+ }
+
+ private:
+ static uint32_t HashShift(uint32_t aEntrySize, uint32_t aLength);
+
+ static const PLDHashNumber kCollisionFlag = 1;
+
+ PLDHashNumber Hash1(PLDHashNumber aHash0) const;
+ void Hash2(PLDHashNumber aHash, uint32_t& aHash2Out,
+ uint32_t& aSizeMaskOut) const;
+
+ static bool MatchSlotKeyhash(Slot& aSlot, const PLDHashNumber aHash);
+ Slot SlotForIndex(uint32_t aIndex) const;
+
+ // We store mHashShift rather than sizeLog2 to optimize the collision-free
+ // case in SearchTable.
+ uint32_t CapacityFromHashShift() const {
+ return ((uint32_t)1 << (kPLDHashNumberBits - mHashShift));
+ }
+
+ PLDHashNumber ComputeKeyHash(const void* aKey) const;
+
+ enum SearchReason { ForSearchOrRemove, ForAdd };
+
+ // Avoid using bare `Success` and `Failure`, as those names are commonly
+ // defined as macros.
+ template <SearchReason Reason, typename PLDSuccess, typename PLDFailure>
+ auto SearchTable(const void* aKey, PLDHashNumber aKeyHash,
+ PLDSuccess&& aSucess, PLDFailure&& aFailure) const;
+
+ Slot FindFreeSlot(PLDHashNumber aKeyHash) const;
+
+ bool ChangeTable(int aDeltaLog2);
+
+ void RawRemove(Slot& aSlot);
+ void ShrinkIfAppropriate();
+
+ mozilla::Maybe<EntryHandle> MakeEntryHandle(const void* aKey,
+ const mozilla::fallible_t&);
+
+ EntryHandle MakeEntryHandle(const void* aKey);
+
+ PLDHashTable(const PLDHashTable& aOther) = delete;
+ PLDHashTable& operator=(const PLDHashTable& aOther) = delete;
+};
+
+// Compute the hash code for a given key to be looked up, added, or removed.
+// A hash code may have any PLDHashNumber value.
+typedef PLDHashNumber (*PLDHashHashKey)(const void* aKey);
+
+// Compare the key identifying aEntry with the provided key parameter. Return
+// true if keys match, false otherwise.
+typedef bool (*PLDHashMatchEntry)(const PLDHashEntryHdr* aEntry,
+ const void* aKey);
+
+// Copy the data starting at aFrom to the new entry storage at aTo. Do not add
+// reference counts for any strong references in the entry, however, as this
+// is a "move" operation: the old entry storage at from will be freed without
+// any reference-decrementing callback shortly.
+typedef void (*PLDHashMoveEntry)(PLDHashTable* aTable,
+ const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo);
+
+// Clear the entry and drop any strong references it holds. This callback is
+// invoked by Remove(), but only if the given key is found in the table.
+typedef void (*PLDHashClearEntry)(PLDHashTable* aTable,
+ PLDHashEntryHdr* aEntry);
+
+// Initialize a new entry. This function is called when
+// Add() finds no existing entry for the given key, and must add a new one.
+typedef void (*PLDHashInitEntry)(PLDHashEntryHdr* aEntry, const void* aKey);
+
+// Finally, the "vtable" structure for PLDHashTable. The first four hooks
+// must be provided by implementations; they're called unconditionally by the
+// generic PLDHashTable.cpp code. Hooks after these may be null.
+//
+// Summary of allocation-related hook usage with C++ placement new emphasis:
+// initEntry Call placement new using default key-based ctor.
+// moveEntry Call placement new using copy ctor, run dtor on old
+// entry storage.
+// clearEntry Run dtor on entry.
+//
+// Note the reason why initEntry is optional: the default hooks (stubs) clear
+// entry storage. On a successful Add(tbl, key), the returned entry pointer
+// addresses an entry struct whose entry members are still clear (null). Add()
+// callers can test such members to see whether the entry was newly created by
+// the Add() call that just succeeded. If placement new or similar
+// initialization is required, define an |initEntry| hook. Of course, the
+// |clearEntry| hook must zero or null appropriately.
+//
+// XXX assumes 0 is null for pointer types.
+struct PLDHashTableOps {
+ // Mandatory hooks. All implementations must provide these.
+ PLDHashHashKey hashKey;
+ PLDHashMatchEntry matchEntry;
+ PLDHashMoveEntry moveEntry;
+
+ // Optional hooks start here. If null, these are not called.
+ PLDHashClearEntry clearEntry;
+ PLDHashInitEntry initEntry;
+};
+
+// A minimal entry is a subclass of PLDHashEntryHdr and has a void* key pointer.
+struct PLDHashEntryStub : public PLDHashEntryHdr {
+ const void* key;
+};
+
+#endif /* PLDHashTable_h */
diff --git a/xpcom/ds/PerfectHash.h b/xpcom/ds/PerfectHash.h
new file mode 100644
index 0000000000..1e75855462
--- /dev/null
+++ b/xpcom/ds/PerfectHash.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Helper routines for perfecthash.py. Not to be used directly. */
+
+#ifndef mozilla_PerfectHash_h
+#define mozilla_PerfectHash_h
+
+#include <type_traits>
+
+namespace mozilla {
+namespace perfecthash {
+
+// 32-bit FNV offset basis and prime value.
+// NOTE: Must match values in |perfecthash.py|
+constexpr uint32_t FNV_OFFSET_BASIS = 0x811C9DC5;
+constexpr uint32_t FNV_PRIME = 16777619;
+
+/**
+ * Basic FNV hasher function used by perfecthash. Generic over the unit type.
+ */
+template <typename C>
+inline uint32_t Hash(uint32_t aBasis, const C* aKey, size_t aLen) {
+ for (size_t i = 0; i < aLen; ++i) {
+ aBasis =
+ (aBasis ^ static_cast<std::make_unsigned_t<C>>(aKey[i])) * FNV_PRIME;
+ }
+ return aBasis;
+}
+
+/**
+ * Helper method for getting the index from a perfect hash.
+ * Called by code generated from |perfecthash.py|.
+ */
+template <typename C, typename Base, size_t NBases, typename Entry,
+ size_t NEntries>
+inline const Entry& Lookup(const C* aKey, size_t aLen,
+ const Base (&aTable)[NBases],
+ const Entry (&aEntries)[NEntries]) {
+ uint32_t basis = aTable[Hash(FNV_OFFSET_BASIS, aKey, aLen) % NBases];
+ return aEntries[Hash(basis, aKey, aLen) % NEntries];
+}
+
+} // namespace perfecthash
+} // namespace mozilla
+
+#endif // !defined(mozilla_PerfectHash_h)
diff --git a/xpcom/ds/SimpleEnumerator.h b/xpcom/ds/SimpleEnumerator.h
new file mode 100644
index 0000000000..463b9ecaed
--- /dev/null
+++ b/xpcom/ds/SimpleEnumerator.h
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_SimpleEnumerator_h
+#define mozilla_SimpleEnumerator_h
+
+#include "nsCOMPtr.h"
+#include "nsISimpleEnumerator.h"
+
+namespace mozilla {
+
+/**
+ * A wrapper class around nsISimpleEnumerator to support ranged iteration. This
+ * requires every element in the enumeration to implement the same interface, T.
+ * If any element does not implement this interface, the enumeration ends at
+ * that element, and triggers an assertion in debug builds.
+ *
+ * Typical usage looks something like:
+ *
+ * for (auto& docShell : SimpleEnumerator<nsIDocShell>(docShellEnum)) {
+ * docShell.LoadURI(...);
+ * }
+ */
+
+template <typename T>
+class SimpleEnumerator final {
+ public:
+ explicit SimpleEnumerator(nsISimpleEnumerator* aEnum) : mEnum(aEnum) {}
+
+ class Entry {
+ public:
+ explicit Entry(T* aPtr) : mPtr(aPtr) {}
+
+ explicit Entry(nsISimpleEnumerator& aEnum) : mEnum(&aEnum) { ++*this; }
+
+ const nsCOMPtr<T>& operator*() {
+ MOZ_ASSERT(mPtr);
+ return mPtr;
+ }
+
+ Entry& operator++() {
+ MOZ_ASSERT(mEnum);
+ nsCOMPtr<nsISupports> next;
+ if (NS_SUCCEEDED(mEnum->GetNext(getter_AddRefs(next)))) {
+ mPtr = do_QueryInterface(next);
+ MOZ_ASSERT(mPtr);
+ } else {
+ mPtr = nullptr;
+ }
+ return *this;
+ }
+
+ bool operator!=(const Entry& aOther) const { return mPtr != aOther.mPtr; }
+
+ private:
+ nsCOMPtr<T> mPtr;
+ nsCOMPtr<nsISimpleEnumerator> mEnum;
+ };
+
+ Entry begin() { return Entry(*mEnum); }
+
+ Entry end() { return Entry(nullptr); }
+
+ private:
+ nsCOMPtr<nsISimpleEnumerator> mEnum;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_SimpleEnumerator_h
diff --git a/xpcom/ds/StaticAtoms.py b/xpcom/ds/StaticAtoms.py
new file mode 100644
index 0000000000..fb41a00bd1
--- /dev/null
+++ b/xpcom/ds/StaticAtoms.py
@@ -0,0 +1,2636 @@
+# 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/.
+
+# flake8: noqa
+
+import sys
+
+from Atom import (
+ Atom,
+ InheritingAnonBoxAtom,
+ NonInheritingAnonBoxAtom,
+ PseudoElementAtom,
+)
+from HTMLAtoms import HTML_PARSER_ATOMS
+
+# Static atom definitions, used to generate nsGkAtomList.h.
+#
+# Each atom is defined by a call to Atom, PseudoElementAtom,
+# NonInheritingAnonBoxAtom or InheritingAnonBoxAtom.
+#
+# The first argument is the atom's identifier.
+# The second argument is the atom's string value.
+#
+# Please keep the Atom() definitions on one line as this is parsed by the
+# htmlparser: parser/html/java/htmlparser
+# Please keep "START ATOMS" and "END ATOMS" comments as the parser uses them.
+#
+# It is not possible to conditionally define static atoms with #ifdef etc.
+# fmt: off
+STATIC_ATOMS = [
+ # START ATOMS
+ # --------------------------------------------------------------------------
+ # Generic atoms
+ # --------------------------------------------------------------------------
+ Atom("SystemPrincipal", "[System Principal]"),
+ Atom("_empty", ""),
+ Atom("_0", "0"),
+ Atom("_1", "1"),
+ Atom("mozframetype", "mozframetype"),
+ Atom("_moz_abspos", "_moz_abspos"),
+ Atom("_moz_activated", "_moz_activated"),
+ Atom("_moz_anonclass", "_moz_anonclass"),
+ Atom("_moz_resizing", "_moz_resizing"),
+ Atom("moztype", "_moz-type"),
+ Atom("mozdirty", "_moz_dirty"),
+ Atom("mozdisallowselectionprint", "mozdisallowselectionprint"),
+ Atom("mozdonotsend", "moz-do-not-send"),
+ Atom("mozfwcontainer", "moz-forward-container"), # Used by MailNews.
+ Atom("mozgeneratedcontentbefore", "_moz_generated_content_before"),
+ Atom("mozgeneratedcontentafter", "_moz_generated_content_after"),
+ Atom("mozgeneratedcontentmarker", "_moz_generated_content_marker"),
+ Atom("mozgeneratedcontentimage", "_moz_generated_content_image"),
+ Atom("mozquote", "_moz_quote"),
+ Atom("mozsignature", "moz-signature"), # Used by MailNews.
+ Atom("_moz_bullet_font", "-moz-bullet-font"),
+ Atom("_moz_is_glyph", "-moz-is-glyph"),
+ Atom("_moz_original_size", "_moz_original_size"),
+ Atom("_moz_print_preview", "-moz-print-preview"),
+ Atom("_moz_non_native_content_theme", "-moz-non-native-content-theme"),
+ Atom("menuactive", "_moz-menuactive"),
+ Atom("_poundDefault", "#default"),
+ Atom("_asterisk", "*"),
+ Atom("a", "a"),
+ Atom("abbr", "abbr"),
+ Atom("abort", "abort"),
+ Atom("above", "above"),
+ Atom("acceltext", "acceltext"),
+ Atom("accept", "accept"),
+ Atom("acceptcharset", "accept-charset"),
+ Atom("accessiblenode", "accessible-node"),
+ Atom("accesskey", "accesskey"),
+ Atom("acronym", "acronym"),
+ Atom("action", "action"),
+ Atom("active", "active"),
+ Atom("activateontab", "activateontab"),
+ Atom("actuate", "actuate"),
+ Atom("address", "address"),
+ Atom("adoptedsheetclones", "adoptedsheetclones"),
+ Atom("after", "after"),
+ Atom("align", "align"),
+ Atom("alink", "alink"),
+ Atom("all", "all"),
+ Atom("allow", "allow"),
+ Atom("allowdownloads", "allow-downloads"),
+ Atom("allowevents", "allowevents"),
+ Atom("allowforms", "allow-forms"),
+ Atom("allowfullscreen", "allowfullscreen"),
+ Atom("allowmodals", "allow-modals"),
+ Atom("alloworientationlock", "allow-orientation-lock"),
+ Atom("allowpointerlock", "allow-pointer-lock"),
+ Atom("allowpopupstoescapesandbox", "allow-popups-to-escape-sandbox"),
+ Atom("allowpopups", "allow-popups"),
+ Atom("allowpresentation", "allow-presentation"),
+ Atom("allowstorageaccessbyuseractivatetion", "allow-storage-access-by-user-activation"),
+ Atom("allowsameorigin", "allow-same-origin"),
+ Atom("allowscripts", "allow-scripts"),
+ Atom("allowscriptstoclose", "allowscriptstoclose"),
+ Atom("allowtopnavigation", "allow-top-navigation"),
+ Atom("allowtopnavigationbyuseractivation", "allow-top-navigation-by-user-activation"),
+ Atom("allowtopnavigationcustomprotocols", "allow-top-navigation-to-custom-protocols"),
+ Atom("allowuntrusted", "allowuntrusted"),
+ Atom("alt", "alt"),
+ Atom("alternate", "alternate"),
+ Atom("always", "always"),
+ Atom("ancestor", "ancestor"),
+ Atom("ancestorOrSelf", "ancestor-or-self"),
+ Atom("anchor", "anchor"),
+ Atom("_and", "and"),
+ Atom("animations", "animations"),
+ Atom("anonid", "anonid"),
+ Atom("anonlocation", "anonlocation"),
+ Atom("any", "any"),
+ Atom("any_hover", "any-hover"),
+ Atom("any_pointer", "any-pointer"),
+ Atom("applet", "applet"),
+ Atom("applyImports", "apply-imports"),
+ Atom("applyTemplates", "apply-templates"),
+ Atom("archive", "archive"),
+ Atom("area", "area"),
+ Atom("aria", "aria"),
+ Atom("aria_activedescendant", "aria-activedescendant"),
+ Atom("aria_atomic", "aria-atomic"),
+ Atom("aria_autocomplete", "aria-autocomplete"),
+ Atom("aria_busy", "aria-busy"),
+ Atom("aria_checked", "aria-checked"),
+ Atom("aria_controls", "aria-controls"),
+ Atom("aria_current", "aria-current"),
+ Atom("aria_describedby", "aria-describedby"),
+ Atom("aria_description", "aria-description"),
+ Atom("aria_disabled", "aria-disabled"),
+ Atom("aria_dropeffect", "aria-dropeffect"),
+ Atom("aria_expanded", "aria-expanded"),
+ Atom("aria_flowto", "aria-flowto"),
+ Atom("aria_haspopup", "aria-haspopup"),
+ Atom("aria_hidden", "aria-hidden"),
+ Atom("aria_invalid", "aria-invalid"),
+ Atom("aria_labelledby", "aria-labelledby"),
+ Atom("aria_level", "aria-level"),
+ Atom("aria_live", "aria-live"),
+ Atom("aria_multiline", "aria-multiline"),
+ Atom("aria_multiselectable", "aria-multiselectable"),
+ Atom("aria_owns", "aria-owns"),
+ Atom("aria_posinset", "aria-posinset"),
+ Atom("aria_pressed", "aria-pressed"),
+ Atom("aria_readonly", "aria-readonly"),
+ Atom("aria_relevant", "aria-relevant"),
+ Atom("aria_required", "aria-required"),
+ Atom("aria_selected", "aria-selected"),
+ Atom("aria_setsize", "aria-setsize"),
+ Atom("aria_sort", "aria-sort"),
+ Atom("aria_valuemax", "aria-valuemax"),
+ Atom("aria_valuemin", "aria-valuemin"),
+ Atom("aria_valuenow", "aria-valuenow"),
+ Atom("arrow", "arrow"),
+ Atom("article", "article"),
+ Atom("as", "as"),
+ Atom("ascending", "ascending"),
+ Atom("aside", "aside"),
+ Atom("aspectRatio", "aspect-ratio"),
+ Atom("async", "async"),
+ Atom("attribute", "attribute"),
+ Atom("attributes", "attributes"),
+ Atom("attributeSet", "attribute-set"),
+ Atom("_auto", "auto"),
+ Atom("autocapitalize", "autocapitalize"),
+ Atom("autocheck", "autocheck"),
+ Atom("autocomplete", "autocomplete"),
+ Atom("autocomplete_richlistbox", "autocomplete-richlistbox"),
+ Atom("autofocus", "autofocus"),
+ Atom("autoplay", "autoplay"),
+ Atom("axis", "axis"),
+ Atom("b", "b"),
+ Atom("background", "background"),
+ Atom("bar", "bar"),
+ Atom("base", "base"),
+ Atom("basefont", "basefont"),
+ Atom("baseline", "baseline"),
+ Atom("bdi", "bdi"),
+ Atom("bdo", "bdo"),
+ Atom("before", "before"),
+ Atom("behavior", "behavior"),
+ Atom("below", "below"),
+ Atom("bgcolor", "bgcolor"),
+ Atom("bgsound", "bgsound"),
+ Atom("big", "big"),
+ Atom("binding", "binding"),
+ Atom("bindings", "bindings"),
+ Atom("bindToUntrustedContent", "bindToUntrustedContent"),
+ Atom("black", "black"),
+ Atom("block", "block"),
+ Atom("block_size", "block-size"),
+ Atom("blockquote", "blockquote"),
+ Atom("blur", "blur"),
+ Atom("body", "body"),
+ Atom("boolean", "boolean"),
+ Atom("border", "border"),
+ Atom("bordercolor", "bordercolor"),
+ Atom("both", "both"),
+ Atom("bottom", "bottom"),
+ Atom("bottomend", "bottomend"),
+ Atom("bottomstart", "bottomstart"),
+ Atom("bottomleft", "bottomleft"),
+ Atom("bottommargin", "bottommargin"),
+ Atom("bottomright", "bottomright"),
+ Atom("box", "box"),
+ Atom("br", "br"),
+ Atom("browser", "browser"),
+ Atom("mozbrowser", "mozbrowser"),
+ Atom("button", "button"),
+ Atom("callTemplate", "call-template"),
+ Atom("canvas", "canvas"),
+ Atom("caption", "caption"),
+ Atom("captionBox", "caption-box"),
+ Atom("capture", "capture"),
+ Atom("caseOrder", "case-order"),
+ Atom("cdataSectionElements", "cdata-section-elements"),
+ Atom("ceiling", "ceiling"),
+ Atom("cell", "cell"),
+ Atom("cellpadding", "cellpadding"),
+ Atom("cellspacing", "cellspacing"),
+ Atom("center", "center"),
+ Atom("change", "change"),
+ Atom("_char", "char"),
+ Atom("characterData", "characterData"),
+ Atom("charcode", "charcode"),
+ Atom("charoff", "charoff"),
+ Atom("charset", "charset"),
+ Atom("checkbox", "checkbox"),
+ Atom("checkboxLabel", "checkbox-label"),
+ Atom("checked", "checked"),
+ Atom("child", "child"),
+ Atom("children", "children"),
+ Atom("childList", "childList"),
+ Atom("child_item_count", "child-item-count"),
+ Atom("choose", "choose"),
+ Atom("chromemargin", "chromemargin"),
+ Atom("exposeToUntrustedContent", "exposeToUntrustedContent"),
+ Atom("circ", "circ"),
+ Atom("circle", "circle"),
+ Atom("cite", "cite"),
+ Atom("_class", "class"),
+ Atom("classid", "classid"),
+ Atom("clear", "clear"),
+ Atom("click", "click"),
+ Atom("clickcount", "clickcount"),
+ Atom("movetoclick", "movetoclick"),
+ Atom("clip", "clip"),
+ Atom("close", "close"),
+ Atom("closed", "closed"),
+ Atom("closemenu", "closemenu"),
+ Atom("code", "code"),
+ Atom("codebase", "codebase"),
+ Atom("codetype", "codetype"),
+ Atom("col", "col"),
+ Atom("colgroup", "colgroup"),
+ Atom("collapse", "collapse"),
+ Atom("collapsed", "collapsed"),
+ Atom("color", "color"),
+ Atom("color_gamut", "color-gamut"),
+ Atom("color_index", "color-index"),
+ Atom("color_scheme", "color-scheme"),
+ Atom("cols", "cols"),
+ Atom("colspan", "colspan"),
+ Atom("combobox", "combobox"),
+ Atom("command", "command"),
+ Atom("commandupdater", "commandupdater"),
+ Atom("comment", "comment"),
+ Atom("compact", "compact"),
+ Atom("concat", "concat"),
+ Atom("constructor", "constructor"),
+ Atom("consumeoutsideclicks", "consumeoutsideclicks"),
+ Atom("container", "container"),
+ Atom("contains", "contains"),
+ Atom("content", "content"),
+ Atom("contenteditable", "contenteditable"),
+ Atom("headerContentDisposition", "content-disposition"),
+ Atom("headerContentLanguage", "content-language"),
+ Atom("contentLocation", "content-location"),
+ Atom("headerContentScriptType", "content-script-type"),
+ Atom("headerContentStyleType", "content-style-type"),
+ Atom("headerContentType", "content-type"),
+ Atom("consumeanchor", "consumeanchor"),
+ Atom("context", "context"),
+ Atom("contextmenu", "contextmenu"),
+ Atom("control", "control"),
+ Atom("controls", "controls"),
+ Atom("coords", "coords"),
+ Atom("copy", "copy"),
+ Atom("copyOf", "copy-of"),
+ Atom("count", "count"),
+ Atom("crop", "crop"),
+ Atom("crossorigin", "crossorigin"),
+ Atom("curpos", "curpos"),
+ Atom("current", "current"),
+ Atom("cutoutregion", "cutoutregion"),
+ Atom("cycler", "cycler"),
+ Atom("dashed", "dashed"),
+ Atom("data", "data"),
+ Atom("dataAtShortcutkeys", "data-at-shortcutkeys"),
+ Atom("datalist", "datalist"),
+ Atom("datal10nid", "data-l10n-id"),
+ Atom("datal10nargs", "data-l10n-args"),
+ Atom("datal10nattrs", "data-l10n-attrs"),
+ Atom("datal10nname", "data-l10n-name"),
+ Atom("datal10nsync", "data-l10n-sync"),
+ Atom("dataType", "data-type"),
+ Atom("dateTime", "date-time"),
+ Atom("date", "date"),
+ Atom("datetime", "datetime"),
+ Atom("datetime_local", "datetime-local"),
+ Atom("datetimeInputBoxWrapper", "datetime-input-box-wrapper"),
+ Atom("dd", "dd"),
+ Atom("decimal", "decimal"),
+ Atom("decimalFormat", "decimal-format"),
+ Atom("decimalSeparator", "decimal-separator"),
+ Atom("declare", "declare"),
+ Atom("decoderDoctor", "decoder-doctor"),
+ Atom("decoding", "decoding"),
+ Atom("decrement", "decrement"),
+ Atom("_default", "default"),
+ Atom("headerDefaultStyle", "default-style"),
+ Atom("defer", "defer"),
+ Atom("del", "del"),
+ Atom("delegatesanchor", "delegatesanchor"),
+ Atom("deletion", "deletion"),
+ Atom("deprecation", "deprecation"),
+ Atom("descendant", "descendant"),
+ Atom("descendantOrSelf", "descendant-or-self"),
+ Atom("descending", "descending"),
+ Atom("description", "description"),
+ Atom("destructor", "destructor"),
+ Atom("details", "details"),
+ Atom("deviceAspectRatio", "device-aspect-ratio"),
+ Atom("deviceHeight", "device-height"),
+ Atom("devicePixelRatio", "device-pixel-ratio"),
+ Atom("deviceWidth", "device-width"),
+ Atom("dfn", "dfn"),
+ Atom("dialog", "dialog"),
+ Atom("difference", "difference"),
+ Atom("digit", "digit"),
+ Atom("dir", "dir"),
+ Atom("dirAutoSetBy", "dirAutoSetBy"),
+ Atom("directory", "directory"),
+ Atom("disableOutputEscaping", "disable-output-escaping"),
+ Atom("disabled", "disabled"),
+ Atom("disableglobalhistory", "disableglobalhistory"),
+ Atom("disablehistory", "disablehistory"),
+ Atom("disablefullscreen", "disablefullscreen"),
+ Atom("disclosure_closed", "disclosure-closed"),
+ Atom("disclosure_open", "disclosure-open"),
+ Atom("display", "display"),
+ Atom("displayMode", "display-mode"),
+ Atom("distinct", "distinct"),
+ Atom("div", "div"),
+ Atom("dl", "dl"),
+ Atom("docAbstract", "doc-abstract"),
+ Atom("docAcknowledgments", "doc-acknowledgments"),
+ Atom("docAfterword", "doc-afterword"),
+ Atom("docAppendix", "doc-appendix"),
+ Atom("docBacklink", "doc-backlink"),
+ Atom("docBiblioentry", "doc-biblioentry"),
+ Atom("docBibliography", "doc-bibliography"),
+ Atom("docBiblioref", "doc-biblioref"),
+ Atom("docChapter", "doc-chapter"),
+ Atom("docColophon", "doc-colophon"),
+ Atom("docConclusion", "doc-conclusion"),
+ Atom("docCover", "doc-cover"),
+ Atom("docCredit", "doc-credit"),
+ Atom("docCredits", "doc-credits"),
+ Atom("docDedication", "doc-dedication"),
+ Atom("docEndnote", "doc-endnote"),
+ Atom("docEndnotes", "doc-endnotes"),
+ Atom("docEpigraph", "doc-epigraph"),
+ Atom("docEpilogue", "doc-epilogue"),
+ Atom("docErrata", "doc-errata"),
+ Atom("docExample", "doc-example"),
+ Atom("docFootnote", "doc-footnote"),
+ Atom("docForeword", "doc-foreword"),
+ Atom("docGlossary", "doc-glossary"),
+ Atom("docGlossref", "doc-glossref"),
+ Atom("docIndex", "doc-index"),
+ Atom("docIntroduction", "doc-introduction"),
+ Atom("docNoteref", "doc-noteref"),
+ Atom("docNotice", "doc-notice"),
+ Atom("docPagebreak", "doc-pagebreak"),
+ Atom("docPagelist", "doc-pagelist"),
+ Atom("docPart", "doc-part"),
+ Atom("docPreface", "doc-preface"),
+ Atom("docPrologue", "doc-prologue"),
+ Atom("docPullquote", "doc-pullquote"),
+ Atom("docQna", "doc-qna"),
+ Atom("docSubtitle", "doc-subtitle"),
+ Atom("docTip", "doc-tip"),
+ Atom("docToc", "doc-toc"),
+ Atom("doctypePublic", "doctype-public"),
+ Atom("doctypeSystem", "doctype-system"),
+ Atom("document", "document"),
+ Atom("down", "down"),
+ Atom("download", "download"),
+ Atom("drag", "drag"),
+ Atom("draggable", "draggable"),
+ Atom("dragging", "dragging"),
+ Atom("dragSession", "dragSession"),
+ Atom("drawintitlebar", "drawintitlebar"),
+ Atom("drawtitle", "drawtitle"),
+ Atom("dropAfter", "dropAfter"),
+ Atom("dropBefore", "dropBefore"),
+ Atom("dropOn", "dropOn"),
+ Atom("dropMarker", "dropmarker"),
+ Atom("dt", "dt"),
+ Atom("e", "e"),
+ Atom("editable", "editable"),
+ Atom("editing", "editing"),
+ Atom("editor", "editor"),
+ Atom("element", "element"),
+ Atom("elementAvailable", "element-available"),
+ Atom("elements", "elements"),
+ Atom("em", "em"),
+ Atom("embed", "embed"),
+ Atom("empty", "empty"),
+ Atom("encoding", "encoding"),
+ Atom("enctype", "enctype"),
+ Atom("end", "end"),
+ Atom("endEvent", "endEvent"),
+ Atom("enterkeyhint", "enterkeyhint"),
+ Atom("error", "error"),
+ Atom("ethiopic_numeric", "ethiopic-numeric"),
+ Atom("even", "even"),
+ Atom("event", "event"),
+ Atom("events", "events"),
+ Atom("excludeResultPrefixes", "exclude-result-prefixes"),
+ Atom("exportparts", "exportparts"),
+ Atom("explicit_name", "explicit-name"),
+ Atom("extends", "extends"),
+ Atom("extensionElementPrefixes", "extension-element-prefixes"),
+ Atom("face", "face"),
+ Atom("fallback", "fallback"),
+ Atom("_false", "false"),
+ Atom("farthest", "farthest"),
+ Atom("featurePolicyViolation", "feature-policy-violation"),
+ Atom("field", "field"),
+ Atom("fieldset", "fieldset"),
+ Atom("file", "file"),
+ Atom("figcaption", "figcaption"),
+ Atom("figure", "figure"),
+ Atom("findbar", "findbar"),
+ Atom("firstInput", "first-input"),
+ Atom("fixed", "fixed"),
+ Atom("flags", "flags"),
+ Atom("flex", "flex"),
+ Atom("flip", "flip"),
+ Atom("floating", "floating"),
+ Atom("floor", "floor"),
+ Atom("flowlength", "flowlength"),
+ Atom("focus", "focus"),
+ Atom("focused", "focused"),
+ Atom("followanchor", "followanchor"),
+ Atom("following", "following"),
+ Atom("followingSibling", "following-sibling"),
+ Atom("font", "font"),
+ Atom("fontWeight", "font-weight"),
+ Atom("footer", "footer"),
+ Atom("_for", "for"),
+ Atom("forEach", "for-each"),
+ Atom("forcedColors", "forced-colors"),
+ Atom("invertedColors", "inverted-colors"),
+ Atom("forceOwnRefreshDriver", "forceOwnRefreshDriver"),
+ Atom("form", "form"),
+ Atom("formaction", "formaction"),
+ Atom("format", "format"),
+ Atom("formatNumber", "format-number"),
+ Atom("formenctype", "formenctype"),
+ Atom("formmethod", "formmethod"),
+ Atom("formnovalidate", "formnovalidate"),
+ Atom("formtarget", "formtarget"),
+ Atom("frame", "frame"),
+ Atom("frameborder", "frameborder"),
+ Atom("frameset", "frameset"),
+ Atom("from", "from"),
+ Atom("fullscreenchange", "fullscreenchange"),
+ Atom("fullscreenerror", "fullscreenerror"),
+ Atom("functionAvailable", "function-available"),
+ Atom("generateId", "generate-id"),
+ Atom("generic", "generic"),
+ Atom("getter", "getter"),
+ Atom("graphicsDocument", "graphics-document"),
+ Atom("graphicsObject", "graphics-object"),
+ Atom("graphicsSymbol", "graphics-symbol"),
+ Atom("grid", "grid"),
+ Atom("group", "group"),
+ Atom("groups", "groups"),
+ Atom("groupbox", "groupbox"),
+ Atom("groupingSeparator", "grouping-separator"),
+ Atom("groupingSize", "grouping-size"),
+ Atom("grow", "grow"),
+ Atom("h1", "h1"),
+ Atom("h2", "h2"),
+ Atom("h3", "h3"),
+ Atom("h4", "h4"),
+ Atom("h5", "h5"),
+ Atom("h6", "h6"),
+ Atom("handheldFriendly", "HandheldFriendly"),
+ Atom("handler", "handler"),
+ Atom("handlers", "handlers"),
+ Atom("HARD", "HARD"),
+ Atom("hasSameNode", "has-same-node"),
+ Atom("hbox", "hbox"),
+ Atom("head", "head"),
+ Atom("header", "header"),
+ Atom("headers", "headers"),
+ Atom("hebrew", "hebrew"),
+ Atom("height", "height"),
+ Atom("hgroup", "hgroup"),
+ Atom("hidden", "hidden"),
+ Atom("hidechrome", "hidechrome"),
+ Atom("hidecolumnpicker", "hidecolumnpicker"),
+ Atom("high", "high"),
+ Atom("highest", "highest"),
+ Atom("horizontal", "horizontal"),
+ Atom("hover", "hover"),
+ Atom("hr", "hr"),
+ Atom("href", "href"),
+ Atom("hreflang", "hreflang"),
+ Atom("hsides", "hsides"),
+ Atom("hspace", "hspace"),
+ Atom("html", "html"),
+ Atom("httpEquiv", "http-equiv"),
+ Atom("i", "i"),
+ Atom("icon", "icon"),
+ Atom("id", "id"),
+ Atom("_if", "if"),
+ Atom("iframe", "iframe"),
+ Atom("ignorekeys", "ignorekeys"),
+ Atom("ignoreuserfocus", "ignoreuserfocus"),
+ Atom("image", "image"),
+ Atom("imageClickedPoint", "image-clicked-point"),
+ Atom("imagesizes", "imagesizes"),
+ Atom("imagesrcset", "imagesrcset"),
+ Atom("img", "img"),
+ Atom("implementation", "implementation"),
+ Atom("implements", "implements"),
+ Atom("import", "import"),
+ Atom("include", "include"),
+ Atom("includes", "includes"),
+ Atom("incontentshell", "incontentshell"),
+ Atom("increment", "increment"),
+ Atom("indent", "indent"),
+ Atom("indeterminate", "indeterminate"),
+ Atom("index", "index"),
+ Atom("inert", "inert"),
+ Atom("infinity", "infinity"),
+ Atom("inherits", "inherits"),
+ Atom("inheritOverflow", "inherit-overflow"),
+ Atom("inheritstyle", "inheritstyle"),
+ Atom("initial_scale", "initial-scale"),
+ Atom("input", "input"),
+ Atom("inputmode", "inputmode"),
+ Atom("ins", "ins"),
+ Atom("insertafter", "insertafter"),
+ Atom("insertbefore", "insertbefore"),
+ Atom("insertion", "insertion"),
+ Atom("integer", "integer"),
+ Atom("integrity", "integrity"),
+ Atom("internal", "internal"),
+ Atom("internals", "internals"),
+ Atom("intersection", "intersection"),
+ Atom("intersectionobserverlist", "intersectionobserverlist"),
+ Atom("is", "is"),
+ Atom("ismap", "ismap"),
+ Atom("itemid", "itemid"),
+ Atom("itemprop", "itemprop"),
+ Atom("itemref", "itemref"),
+ Atom("itemscope", "itemscope"),
+ Atom("itemtype", "itemtype"),
+ Atom("japanese_formal", "japanese-formal"),
+ Atom("japanese_informal", "japanese-informal"),
+ Atom("kbd", "kbd"),
+ Atom("keepcurrentinview", "keepcurrentinview"),
+ Atom("keepobjectsalive", "keepobjectsalive"),
+ Atom("key", "key"),
+ Atom("keycode", "keycode"),
+ Atom("keydown", "keydown"),
+ Atom("keygen", "keygen"),
+ Atom("keypress", "keypress"),
+ Atom("keyset", "keyset"),
+ Atom("keysystem", "keysystem"),
+ Atom("keyup", "keyup"),
+ Atom("kind", "kind"),
+ Atom("korean_hangul_formal", "korean-hangul-formal"),
+ Atom("korean_hanja_formal", "korean-hanja-formal"),
+ Atom("korean_hanja_informal", "korean-hanja-informal"),
+ Atom("label", "label"),
+ Atom("lang", "lang"),
+ Atom("language", "language"),
+ Atom("last", "last"),
+ Atom("layer", "layer"),
+ Atom("LayerActivity", "LayerActivity"),
+ Atom("layout_guess", "layout-guess"),
+ Atom("leading", "leading"),
+ Atom("leaf", "leaf"),
+ Atom("left", "left"),
+ Atom("leftmargin", "leftmargin"),
+ Atom("legend", "legend"),
+ Atom("length", "length"),
+ Atom("letterValue", "letter-value"),
+ Atom("level", "level"),
+ Atom("lhs", "lhs"),
+ Atom("li", "li"),
+ Atom("line", "line"),
+ Atom("link", "link"),
+ Atom("linkset", "linkset"),
+ # Atom("list", "list"), # "list" is present below
+ Atom("listbox", "listbox"),
+ Atom("listener", "listener"),
+ Atom("listheader", "listheader"),
+ Atom("listing", "listing"),
+ Atom("listitem", "listitem"),
+ Atom("load", "load"),
+ Atom("loading", "loading"),
+ Atom("triggeringprincipal", "triggeringprincipal"),
+ Atom("localedir", "localedir"),
+ Atom("localName", "local-name"),
+ Atom("localization", "localization"),
+ Atom("longdesc", "longdesc"),
+ Atom("loop", "loop"),
+ Atom("low", "low"),
+ Atom("lowerFirst", "lower-first"),
+ Atom("lowest", "lowest"),
+ Atom("lowsrc", "lowsrc"),
+ Atom("ltr", "ltr"),
+ Atom("lwtheme", "lwtheme"),
+ Atom("main", "main"),
+ Atom("map", "map"),
+ Atom("manifest", "manifest"),
+ Atom("marginBottom", "margin-bottom"),
+ Atom("marginLeft", "margin-left"),
+ Atom("marginRight", "margin-right"),
+ Atom("marginTop", "margin-top"),
+ Atom("marginheight", "marginheight"),
+ Atom("marginwidth", "marginwidth"),
+ Atom("mark", "mark"),
+ Atom("marquee", "marquee"),
+ Atom("match", "match"),
+ Atom("max", "max"),
+ Atom("maxheight", "maxheight"),
+ Atom("maximum_scale", "maximum-scale"),
+ Atom("maxlength", "maxlength"),
+ Atom("maxpos", "maxpos"),
+ Atom("maxwidth", "maxwidth"),
+ Atom("measure", "measure"),
+ Atom("media", "media"),
+ Atom("mediaType", "media-type"),
+ Atom("menu", "menu"),
+ Atom("menubar", "menubar"),
+ Atom("menucaption", "menucaption"),
+ Atom("menugroup", "menugroup"),
+ Atom("menuitem", "menuitem"),
+ Atom("menulist", "menulist"),
+ Atom("menupopup", "menupopup"),
+ Atom("menuseparator", "menuseparator"),
+ Atom("mesh", "mesh"),
+ Atom("message", "message"),
+ Atom("meta", "meta"),
+ Atom("referrer", "referrer"),
+ Atom("referrerpolicy", "referrerpolicy"),
+ Atom("renderroot", "renderroot"),
+ Atom("headerReferrerPolicy", "referrer-policy"),
+ Atom("meter", "meter"),
+ Atom("method", "method"),
+ Atom("middle", "middle"),
+ Atom("min", "min"),
+ Atom("minheight", "minheight"),
+ Atom("minimum_scale", "minimum-scale"),
+ Atom("minlength", "minlength"),
+ Atom("minpos", "minpos"),
+ Atom("minusSign", "minus-sign"),
+ Atom("minwidth", "minwidth"),
+ Atom("mixed", "mixed"),
+ Atom("messagemanagergroup", "messagemanagergroup"),
+ Atom("mod", "mod"),
+ Atom("_module", "module"),
+ Atom("mode", "mode"),
+ Atom("modifiers", "modifiers"),
+ Atom("monochrome", "monochrome"),
+ Atom("mouseover", "mouseover"),
+ Atom("mozAccessiblecaret", "moz-accessiblecaret"),
+ Atom("mozCustomContentContainer", "moz-custom-content-container"),
+ Atom("mozGrabber", "mozGrabber"),
+ Atom("mozNativeAnonymous", "-moz-native-anonymous"),
+ Atom("mozprivatebrowsing", "mozprivatebrowsing"),
+ Atom("mozResizer", "mozResizer"),
+ Atom("mozResizingInfo", "mozResizingInfo"),
+ Atom("mozResizingShadow", "mozResizingShadow"),
+ Atom("mozTableAddColumnAfter", "mozTableAddColumnAfter"),
+ Atom("mozTableAddColumnBefore", "mozTableAddColumnBefore"),
+ Atom("mozTableAddRowAfter", "mozTableAddRowAfter"),
+ Atom("mozTableAddRowBefore", "mozTableAddRowBefore"),
+ Atom("mozTableRemoveRow", "mozTableRemoveRow"),
+ Atom("mozTableRemoveColumn", "mozTableRemoveColumn"),
+ Atom("moz_opaque", "moz-opaque"),
+ Atom("moz_action_hint", "mozactionhint"),
+ Atom("multicol", "multicol"),
+ Atom("multiple", "multiple"),
+ Atom("muted", "muted"),
+ Atom("name", "name"),
+ Atom("_namespace", "namespace"),
+ Atom("namespaceAlias", "namespace-alias"),
+ Atom("namespaceUri", "namespace-uri"),
+ Atom("NaN", "NaN"),
+ Atom("n", "n"),
+ Atom("nav", "nav"),
+ Atom("ne", "ne"),
+ Atom("never", "never"),
+ Atom("_new", "new"),
+ Atom("newline", "newline"),
+ Atom("nextRemoteTabId", "nextRemoteTabId"),
+ Atom("no", "no"),
+ Atom("noautofocus", "noautofocus"),
+ Atom("noautohide", "noautohide"),
+ Atom("norolluponanchor", "norolluponanchor"),
+ Atom("noBar", "no-bar"),
+ Atom("nobr", "nobr"),
+ Atom("nodefaultsrc", "nodefaultsrc"),
+ Atom("nodeSet", "node-set"),
+ Atom("noembed", "noembed"),
+ Atom("noframes", "noframes"),
+ Atom("nohref", "nohref"),
+ Atom("nomodule", "nomodule"),
+ Atom("nonce", "nonce"),
+ Atom("none", "none"),
+ Atom("noresize", "noresize"),
+ Atom("normal", "normal"),
+ Atom("normalizeSpace", "normalize-space"),
+ Atom("noscript", "noscript"),
+ Atom("noshade", "noshade"),
+ Atom("notification", "notification"),
+ Atom("novalidate", "novalidate"),
+ Atom("_not", "not"),
+ Atom("nowrap", "nowrap"),
+ Atom("number", "number"),
+ Atom("nw", "nw"),
+ Atom("object", "object"),
+ Atom("objectType", "object-type"),
+ Atom("observes", "observes"),
+ Atom("odd", "odd"),
+ Atom("OFF", "OFF"),
+ Atom("ol", "ol"),
+ Atom("omitXmlDeclaration", "omit-xml-declaration"),
+ Atom("onabort", "onabort"),
+ Atom("onmozaccesskeynotfound", "onmozaccesskeynotfound"),
+ Atom("onactivate", "onactivate"),
+ Atom("onafterprint", "onafterprint"),
+ Atom("onafterscriptexecute", "onafterscriptexecute"),
+ Atom("onanimationcancel", "onanimationcancel"),
+ Atom("onanimationend", "onanimationend"),
+ Atom("onanimationiteration", "onanimationiteration"),
+ Atom("onanimationstart", "onanimationstart"),
+ Atom("onAppCommand", "onAppCommand"),
+ Atom("onaudioprocess", "onaudioprocess"),
+ Atom("onauxclick", "onauxclick"),
+ Atom("onbeforecopy", "onbeforecopy"),
+ Atom("onbeforecut", "onbeforecut"),
+ Atom("onbeforeinput", "onbeforeinput"),
+ Atom("onbeforepaste", "onbeforepaste"),
+ Atom("onbeforeprint", "onbeforeprint"),
+ Atom("onbeforescriptexecute", "onbeforescriptexecute"),
+ Atom("onbeforeunload", "onbeforeunload"),
+ Atom("onblocked", "onblocked"),
+ Atom("onblur", "onblur"),
+ Atom("onbounce", "onbounce"),
+ Atom("onboundschange", "onboundschange"),
+ Atom("onbroadcast", "onbroadcast"),
+ Atom("onbufferedamountlow", "onbufferedamountlow"),
+ Atom("oncached", "oncached"),
+ Atom("oncancel", "oncancel"),
+ Atom("onchange", "onchange"),
+ Atom("onchargingchange", "onchargingchange"),
+ Atom("onchargingtimechange", "onchargingtimechange"),
+ Atom("onchecking", "onchecking"),
+ Atom("onCheckboxStateChange", "onCheckboxStateChange"),
+ Atom("onCheckKeyPressEventModel", "onCheckKeyPressEventModel"),
+ Atom("onclick", "onclick"),
+ Atom("onclose", "onclose"),
+ Atom("oncommand", "oncommand"),
+ Atom("oncommandupdate", "oncommandupdate"),
+ Atom("oncomplete", "oncomplete"),
+ Atom("oncompositionend", "oncompositionend"),
+ Atom("oncompositionstart", "oncompositionstart"),
+ Atom("oncompositionupdate", "oncompositionupdate"),
+ Atom("onconnect", "onconnect"),
+ Atom("onconnectionavailable", "onconnectionavailable"),
+ Atom("oncontextmenu", "oncontextmenu"),
+ Atom("oncontextlost", "oncontextlost"),
+ Atom("oncontextrestored", "oncontextrestored"),
+ Atom("oncopy", "oncopy"),
+ Atom("oncut", "oncut"),
+ Atom("ondblclick", "ondblclick"),
+ Atom("ondischargingtimechange", "ondischargingtimechange"),
+ Atom("ondownloading", "ondownloading"),
+ Atom("onDOMActivate", "onDOMActivate"),
+ Atom("onDOMAttrModified", "onDOMAttrModified"),
+ Atom("onDOMCharacterDataModified", "onDOMCharacterDataModified"),
+ Atom("onDOMFocusIn", "onDOMFocusIn"),
+ Atom("onDOMFocusOut", "onDOMFocusOut"),
+ Atom("onDOMMouseScroll", "onDOMMouseScroll"),
+ Atom("onDOMNodeInserted", "onDOMNodeInserted"),
+ Atom("onDOMNodeInsertedIntoDocument", "onDOMNodeInsertedIntoDocument"),
+ Atom("onDOMNodeRemoved", "onDOMNodeRemoved"),
+ Atom("onDOMNodeRemovedFromDocument", "onDOMNodeRemovedFromDocument"),
+ Atom("onDOMSubtreeModified", "onDOMSubtreeModified"),
+ Atom("ondata", "ondata"),
+ Atom("ondrag", "ondrag"),
+ Atom("ondragdrop", "ondragdrop"),
+ Atom("ondragend", "ondragend"),
+ Atom("ondragenter", "ondragenter"),
+ Atom("ondragexit", "ondragexit"),
+ Atom("ondragleave", "ondragleave"),
+ Atom("ondragover", "ondragover"),
+ Atom("ondragstart", "ondragstart"),
+ Atom("ondrain", "ondrain"),
+ Atom("ondrop", "ondrop"),
+ Atom("onerror", "onerror"),
+ Atom("onfinish", "onfinish"),
+ Atom("onfocus", "onfocus"),
+ Atom("onfocusin", "onfocusin"),
+ Atom("onfocusout", "onfocusout"),
+ Atom("onfullscreenchange", "onfullscreenchange"),
+ Atom("onfullscreenerror", "onfullscreenerror"),
+ Atom("onget", "onget"),
+ Atom("onhashchange", "onhashchange"),
+ Atom("oninput", "oninput"),
+ Atom("oninputsourceschange", "oninputsourceschange"),
+ Atom("oninstall", "oninstall"),
+ Atom("oninvalid", "oninvalid"),
+ Atom("onkeydown", "onkeydown"),
+ Atom("onkeypress", "onkeypress"),
+ Atom("onkeyup", "onkeyup"),
+ Atom("onlanguagechange", "onlanguagechange"),
+ Atom("onlevelchange", "onlevelchange"),
+ Atom("onload", "onload"),
+ Atom("onloading", "onloading"),
+ Atom("onloadingdone", "onloadingdone"),
+ Atom("onloadingerror", "onloadingerror"),
+ Atom("onpopstate", "onpopstate"),
+ Atom("only", "only"), # this one is not an event
+ Atom("onmerchantvalidation", "onmerchantvalidation"),
+ Atom("onmessage", "onmessage"),
+ Atom("onmessageerror", "onmessageerror"),
+ Atom("onmidimessage", "onmidimessage"),
+ Atom("onmousedown", "onmousedown"),
+ Atom("onmouseenter", "onmouseenter"),
+ Atom("onmouseleave", "onmouseleave"),
+ Atom("onmouselongtap", "onmouselongtap"),
+ Atom("onmousemove", "onmousemove"),
+ Atom("onmouseout", "onmouseout"),
+ Atom("onmouseover", "onmouseover"),
+ Atom("onMozMouseHittest", "onMozMouseHittest"),
+ Atom("onMozMouseExploreByTouch", "onMozMouseExploreByTouch"),
+ Atom("onmouseup", "onmouseup"),
+ Atom("onMozAfterPaint", "onMozAfterPaint"),
+ Atom("onmozfullscreenchange", "onmozfullscreenchange"),
+ Atom("onmozfullscreenerror", "onmozfullscreenerror"),
+ Atom("onmozpointerlockchange", "onmozpointerlockchange"),
+ Atom("onmozpointerlockerror", "onmozpointerlockerror"),
+ Atom("onMozMousePixelScroll", "onMozMousePixelScroll"),
+ Atom("onMozScrolledAreaChanged", "onMozScrolledAreaChanged"),
+ Atom("onmute", "onmute"),
+ Atom("onnotificationclick", "onnotificationclick"),
+ Atom("onnotificationclose", "onnotificationclose"),
+ Atom("onnoupdate", "onnoupdate"),
+ Atom("onobsolete", "onobsolete"),
+ Atom("ononline", "ononline"),
+ Atom("onoffline", "onoffline"),
+ Atom("onopen", "onopen"),
+ Atom("onorientationchange", "onorientationchange"),
+ Atom("onoverflow", "onoverflow"),
+ Atom("onpagehide", "onpagehide"),
+ Atom("onpageshow", "onpageshow"),
+ Atom("onpaste", "onpaste"),
+ Atom("onpayerdetailchange", "onpayerdetailchange"),
+ Atom("onpaymentmethodchange", "onpaymentmethodchange"),
+ Atom("onpointerlockchange", "onpointerlockchange"),
+ Atom("onpointerlockerror", "onpointerlockerror"),
+ Atom("onpopuphidden", "onpopuphidden"),
+ Atom("onpopuphiding", "onpopuphiding"),
+ Atom("onpopuppositioned", "onpopuppositioned"),
+ Atom("onpopupshowing", "onpopupshowing"),
+ Atom("onpopupshown", "onpopupshown"),
+ Atom("onprocessorerror", "onprocessorerror"),
+ Atom("onprioritychange", "onprioritychange"),
+ Atom("onpush", "onpush"),
+ Atom("onpushsubscriptionchange", "onpushsubscriptionchange"),
+ Atom("onRadioStateChange", "onRadioStateChange"),
+ Atom("onreadystatechange", "onreadystatechange"),
+ Atom("onrejectionhandled", "onrejectionhandled"),
+ Atom("onremove", "onremove"),
+ Atom("onrequestprogress", "onrequestprogress"),
+ Atom("onresourcetimingbufferfull", "onresourcetimingbufferfull"),
+ Atom("onresponseprogress", "onresponseprogress"),
+ Atom("onRequest", "onRequest"),
+ Atom("onreset", "onreset"),
+ Atom("onresize", "onresize"),
+ Atom("onscroll", "onscroll"),
+ Atom("onsecuritypolicyviolation", "onsecuritypolicyviolation"),
+ Atom("onselect", "onselect"),
+ Atom("onselectionchange", "onselectionchange"),
+ Atom("onselectend", "onselectend"),
+ Atom("onselectstart", "onselectstart"),
+ Atom("onset", "onset"),
+ Atom("onshippingaddresschange", "onshippingaddresschange"),
+ Atom("onshippingoptionchange", "onshippingoptionchange"),
+ Atom("onshow", "onshow"),
+ Atom("onslotchange", "onslotchange"),
+ Atom("onsqueeze", "onsqueeze"),
+ Atom("onsqueezeend", "onsqueezeend"),
+ Atom("onsqueezestart", "onsqueezestart"),
+ Atom("onstatechange", "onstatechange"),
+ Atom("onstorage", "onstorage"),
+ Atom("onsubmit", "onsubmit"),
+ Atom("onsuccess", "onsuccess"),
+ Atom("onsystemstatusbarclick", "onsystemstatusbarclick"),
+ Atom("ontypechange", "ontypechange"),
+ Atom("onterminate", "onterminate"),
+ Atom("ontext", "ontext"),
+ Atom("ontoggle", "ontoggle"),
+ Atom("ontonechange", "ontonechange"),
+ Atom("ontouchstart", "ontouchstart"),
+ Atom("ontouchend", "ontouchend"),
+ Atom("ontouchmove", "ontouchmove"),
+ Atom("ontouchcancel", "ontouchcancel"),
+ Atom("ontransitioncancel", "ontransitioncancel"),
+ Atom("ontransitionend", "ontransitionend"),
+ Atom("ontransitionrun", "ontransitionrun"),
+ Atom("ontransitionstart", "ontransitionstart"),
+ Atom("onuncapturederror", "onuncapturederror"),
+ Atom("onunderflow", "onunderflow"),
+ Atom("onunhandledrejection", "onunhandledrejection"),
+ Atom("onunload", "onunload"),
+ Atom("onunmute", "onunmute"),
+ Atom("onupdatefound", "onupdatefound"),
+ Atom("onupdateready", "onupdateready"),
+ Atom("onupgradeneeded", "onupgradeneeded"),
+ Atom("onversionchange", "onversionchange"),
+ Atom("onvisibilitychange", "onvisibilitychange"),
+ Atom("onvoiceschanged", "onvoiceschanged"),
+ Atom("onvrdisplayactivate", "onvrdisplayactivate"),
+ Atom("onvrdisplayconnect", "onvrdisplayconnect"),
+ Atom("onvrdisplaydeactivate", "onvrdisplaydeactivate"),
+ Atom("onvrdisplaydisconnect", "onvrdisplaydisconnect"),
+ Atom("onvrdisplaypresentchange", "onvrdisplaypresentchange"),
+ Atom("onwebkitAnimationEnd", "onwebkitAnimationEnd"),
+ Atom("onwebkitAnimationIteration", "onwebkitAnimationIteration"),
+ Atom("onwebkitAnimationStart", "onwebkitAnimationStart"),
+ Atom("onwebkitTransitionEnd", "onwebkitTransitionEnd"),
+ Atom("onwebkitanimationend", "onwebkitanimationend"),
+ Atom("onwebkitanimationiteration", "onwebkitanimationiteration"),
+ Atom("onwebkitanimationstart", "onwebkitanimationstart"),
+ Atom("onwebkittransitionend", "onwebkittransitionend"),
+ Atom("onwheel", "onwheel"),
+ Atom("open", "open"),
+ Atom("optgroup", "optgroup"),
+ Atom("optimum", "optimum"),
+ Atom("option", "option"),
+ Atom("_or", "or"),
+ Atom("order", "order"),
+ Atom("orient", "orient"),
+ Atom("orientation", "orientation"),
+ Atom("origin_trial", "origin-trial"),
+ Atom("otherwise", "otherwise"),
+ Atom("output", "output"),
+ Atom("overflow", "overflow"),
+ Atom("overflowBlock", "overflow-block"),
+ Atom("overflowInline", "overflow-inline"),
+ Atom("overlay", "overlay"),
+ Atom("p", "p"),
+ Atom("pack", "pack"),
+ Atom("page", "page"),
+ Atom("pageincrement", "pageincrement"),
+ Atom("paint", "paint"),
+ Atom("paint_order", "paint-order"),
+ Atom("panel", "panel"),
+ Atom("paragraph", "paragraph"),
+ Atom("param", "param"),
+ Atom("parameter", "parameter"),
+ Atom("parent", "parent"),
+ Atom("parentfocused", "parentfocused"),
+ Atom("parsererror", "parsererror"),
+ Atom("part", "part"),
+ Atom("password", "password"),
+ Atom("pattern", "pattern"),
+ Atom("patternSeparator", "pattern-separator"),
+ Atom("perMille", "per-mille"),
+ Atom("percent", "percent"),
+ Atom("persist", "persist"),
+ Atom("phase", "phase"),
+ Atom("picture", "picture"),
+ Atom("ping", "ping"),
+ Atom("pinned", "pinned"),
+ Atom("placeholder", "placeholder"),
+ Atom("plaintext", "plaintext"),
+ Atom("playbackrate", "playbackrate"),
+ Atom("pointSize", "point-size"),
+ Atom("poly", "poly"),
+ Atom("polygon", "polygon"),
+ Atom("popover", "popover"),
+ Atom("popovertarget", "popovertarget"),
+ Atom("popovertargetaction", "popovertargetaction"),
+ Atom("popup", "popup"),
+ Atom("popupalign", "popupalign"),
+ Atom("popupanchor", "popupanchor"),
+ Atom("popupgroup", "popupgroup"),
+ Atom("popupset", "popupset"),
+ Atom("popupsinherittooltip", "popupsinherittooltip"),
+ Atom("portal", "portal"),
+ Atom("position", "position"),
+ Atom("poster", "poster"),
+ Atom("pre", "pre"),
+ Atom("preceding", "preceding"),
+ Atom("precedingSibling", "preceding-sibling"),
+ Atom("prefersReducedMotion", "prefers-reduced-motion"),
+ Atom("prefersReducedTransparency", "prefers-reduced-transparency"),
+ Atom("prefersColorScheme", "prefers-color-scheme"),
+ Atom("prefersContrast", "prefers-contrast"),
+ Atom("prefix", "prefix"),
+ Atom("prefwidth", "prefwidth"),
+ Atom("dynamicRange", "dynamic-range"),
+ Atom("videoDynamicRange", "video-dynamic-range"),
+ Atom("scripting", "scripting"),
+ Atom("preload", "preload"),
+ Atom("preserve", "preserve"),
+ Atom("preserveSpace", "preserve-space"),
+ Atom("preventdefault", "preventdefault"),
+ Atom("previewDiv", "preview-div"),
+ Atom("primary", "primary"),
+ Atom("print", "print"),
+ Atom("printisfocuseddoc", "printisfocuseddoc"),
+ Atom("printselectionranges", "printselectionranges"),
+ Atom("priority", "priority"),
+ Atom("processingInstruction", "processing-instruction"),
+ Atom("profile", "profile"),
+ Atom("progress", "progress"),
+ Atom("prompt", "prompt"),
+ Atom("properties", "properties"),
+ Atom("property", "property"),
+ Atom("pubdate", "pubdate"),
+ Atom("q", "q"),
+ Atom("radio", "radio"),
+ Atom("radioLabel", "radio-label"),
+ Atom("radiogroup", "radiogroup"),
+ Atom("range", "range"),
+ Atom("readonly", "readonly"),
+ Atom("rect", "rect"),
+ Atom("rectangle", "rectangle"),
+ Atom("refresh", "refresh"),
+ Atom("rel", "rel"),
+ Atom("relativeBounds", "relative-bounds"),
+ Atom("rem", "rem"),
+ Atom("remote", "remote"),
+ Atom("removeelement", "removeelement"),
+ Atom("renderingobserverset", "renderingobserverset"),
+ Atom("repeat", "repeat"),
+ Atom("replace", "replace"),
+ Atom("requestcontextid", "requestcontextid"),
+ Atom("required", "required"),
+ Atom("reserved", "reserved"),
+ Atom("reset", "reset"),
+ Atom("resizeafter", "resizeafter"),
+ Atom("resizebefore", "resizebefore"),
+ Atom("resizer", "resizer"),
+ Atom("resolution", "resolution"),
+ Atom("resources", "resources"),
+ Atom("result", "result"),
+ Atom("resultPrefix", "result-prefix"),
+ Atom("retargetdocumentfocus", "retargetdocumentfocus"),
+ Atom("rev", "rev"),
+ Atom("reverse", "reverse"),
+ Atom("reversed", "reversed"),
+ Atom("rhs", "rhs"),
+ Atom("richlistbox", "richlistbox"),
+ Atom("richlistitem", "richlistitem"),
+ Atom("right", "right"),
+ Atom("rightmargin", "rightmargin"),
+ Atom("role", "role"),
+ Atom("rolluponmousewheel", "rolluponmousewheel"),
+ Atom("round", "round"),
+ Atom("row", "row"),
+ Atom("rows", "rows"),
+ Atom("rowspan", "rowspan"),
+ Atom("rb", "rb"),
+ Atom("rp", "rp"),
+ Atom("rt", "rt"),
+ Atom("rtc", "rtc"),
+ Atom("rtl", "rtl"),
+ Atom("ruby", "ruby"),
+ Atom("rubyBase", "ruby-base"),
+ Atom("rubyBaseContainer", "ruby-base-container"),
+ Atom("rubyText", "ruby-text"),
+ Atom("rubyTextContainer", "ruby-text-container"),
+ Atom("rules", "rules"),
+ Atom("s", "s"),
+ Atom("safe_area_inset_top", "safe-area-inset-top"),
+ Atom("safe_area_inset_bottom", "safe-area-inset-bottom"),
+ Atom("safe_area_inset_left", "safe-area-inset-left"),
+ Atom("safe_area_inset_right", "safe-area-inset-right"),
+ Atom("samp", "samp"),
+ Atom("sandbox", "sandbox"),
+ Atom("sbattr", "sbattr"),
+ Atom("scale", "scale"),
+ Atom("scan", "scan"),
+ Atom("scheme", "scheme"),
+ Atom("scope", "scope"),
+ Atom("scoped", "scoped"),
+ Atom("screen", "screen"),
+ Atom("screenX", "screenX"),
+ Atom("screenx", "screenx"),
+ Atom("screenY", "screenY"),
+ Atom("screeny", "screeny"),
+ Atom("script", "script"),
+ Atom("scrollbar", "scrollbar"),
+ Atom("scrollbarThumb", "scrollbar-thumb"),
+ Atom("scrollamount", "scrollamount"),
+ Atom("scrollbarbutton", "scrollbarbutton"),
+ Atom("scrollbarDownBottom", "scrollbar-down-bottom"),
+ Atom("scrollbarDownTop", "scrollbar-down-top"),
+ Atom("scrollbarInlineSize", "scrollbar-inline-size"),
+ Atom("scrollbarUpBottom", "scrollbar-up-bottom"),
+ Atom("scrollbarUpTop", "scrollbar-up-top"),
+ Atom("scrollbox", "scrollbox"),
+ Atom("scrollcorner", "scrollcorner"),
+ Atom("scrolldelay", "scrolldelay"),
+ Atom("scrolling", "scrolling"),
+ Atom("scrollPosition", "scroll-position"),
+ Atom("se", "se"),
+ Atom("section", "section"),
+ Atom("select", "select"),
+ Atom("selected", "selected"),
+ Atom("selectedIndex", "selectedIndex"),
+ Atom("selectedindex", "selectedindex"),
+ Atom("selectmenu", "selectmenu"),
+ Atom("self", "self"),
+ Atom("seltype", "seltype"),
+ Atom("setcookie", "set-cookie"),
+ Atom("setter", "setter"),
+ Atom("shadow", "shadow"),
+ Atom("shape", "shape"),
+ Atom("show", "show"),
+ Atom("showcaret", "showcaret"),
+ Atom("sibling", "sibling"),
+ Atom("simple", "simple"),
+ Atom("simp_chinese_formal", "simp-chinese-formal"),
+ Atom("simp_chinese_informal", "simp-chinese-informal"),
+ Atom("single", "single"),
+ Atom("size", "size"),
+ Atom("sizes", "sizes"),
+ Atom("sizemode", "sizemode"),
+ Atom("sizetopopup", "sizetopopup"),
+ Atom("slider", "slider"),
+ Atom("small", "small"),
+ Atom("smooth", "smooth"),
+ Atom("snap", "snap"),
+ Atom("solid", "solid"),
+ Atom("sort", "sort"),
+ Atom("sortActive", "sortActive"),
+ Atom("sortDirection", "sortDirection"),
+ Atom("sorted", "sorted"),
+ Atom("sorthints", "sorthints"),
+ Atom("source", "source"),
+ Atom("sourcetext", "sourcetext"),
+ Atom("space", "space"),
+ Atom("spacer", "spacer"),
+ Atom("span", "span"),
+ Atom("spellcheck", "spellcheck"),
+ Atom("split", "split"),
+ Atom("splitter", "splitter"),
+ Atom("square", "square"),
+ Atom("src", "src"),
+ Atom("srcdoc", "srcdoc"),
+ Atom("srclang", "srclang"),
+ Atom("srcset", "srcset"),
+ Atom("standalone", "standalone"),
+ Atom("standby", "standby"),
+ Atom("start", "start"),
+ Atom("startsWith", "starts-with"),
+ Atom("state", "state"),
+ Atom("statusbar", "statusbar"),
+ Atom("step", "step"),
+ Atom("stop", "stop"),
+ Atom("stretch", "stretch"),
+ Atom("strike", "strike"),
+ Atom("string", "string"),
+ Atom("stringLength", "string-length"),
+ Atom("stripSpace", "strip-space"),
+ Atom("strong", "strong"),
+ Atom("style", "style"),
+ Atom("stylesheet", "stylesheet"),
+ Atom("stylesheetPrefix", "stylesheet-prefix"),
+ Atom("submit", "submit"),
+ Atom("substate", "substate"),
+ Atom("substring", "substring"),
+ Atom("substringAfter", "substring-after"),
+ Atom("substringBefore", "substring-before"),
+ Atom("sub", "sub"),
+ Atom("suggestion", "suggestion"),
+ Atom("sum", "sum"),
+ Atom("sup", "sup"),
+ Atom("summary", "summary"),
+ Atom("sw", "sw"),
+ # Atom("_switch", "switch"), # "switch" is present below
+ Atom("systemProperty", "system-property"),
+ Atom("tab", "tab"),
+ Atom("tabindex", "tabindex"),
+ Atom("table", "table"),
+ Atom("tabpanel", "tabpanel"),
+ Atom("tabpanels", "tabpanels"),
+ Atom("tag", "tag"),
+ Atom("target", "target"),
+ Atom("targets", "targets"),
+ Atom("tbody", "tbody"),
+ Atom("td", "td"),
+ Atom("tel", "tel"),
+ Atom("_template", "template"),
+ Atom("text_decoration", "text-decoration"),
+ Atom("terminate", "terminate"),
+ Atom("term", "term"),
+ Atom("test", "test"),
+ Atom("text", "text"),
+ Atom("textAlign", "text-align"),
+ Atom("textarea", "textarea"),
+ Atom("textbox", "textbox"),
+ Atom("textLink", "text-link"),
+ Atom("textNodeDirectionalityMap", "textNodeDirectionalityMap"),
+ Atom("textOverlay", "text-overlay"),
+ Atom("tfoot", "tfoot"),
+ Atom("th", "th"),
+ Atom("thead", "thead"),
+ Atom("thumb", "thumb"),
+ Atom("time", "time"),
+ Atom("title", "title"),
+ Atom("titlebar", "titlebar"),
+ Atom("titletip", "titletip"),
+ Atom("token", "token"),
+ Atom("tokenize", "tokenize"),
+ Atom("toolbar", "toolbar"),
+ Atom("toolbarbutton", "toolbarbutton"),
+ Atom("toolbaritem", "toolbaritem"),
+ Atom("toolbarpaletteitem", "toolbarpaletteitem"),
+ Atom("toolbox", "toolbox"),
+ Atom("tooltip", "tooltip"),
+ Atom("tooltiptext", "tooltiptext"),
+ Atom("top", "top"),
+ Atom("topleft", "topleft"),
+ Atom("topmargin", "topmargin"),
+ Atom("topright", "topright"),
+ Atom("tr", "tr"),
+ Atom("track", "track"),
+ Atom("trad_chinese_formal", "trad-chinese-formal"),
+ Atom("trad_chinese_informal", "trad-chinese-informal"),
+ Atom("trailing", "trailing"),
+ Atom("transform", "transform"),
+ Atom("transform_3d", "transform-3d"),
+ Atom("transformiix", "transformiix"),
+ Atom("translate", "translate"),
+ Atom("transparent", "transparent"),
+ Atom("tree", "tree"),
+ Atom("treecell", "treecell"),
+ Atom("treechildren", "treechildren"),
+ Atom("treecol", "treecol"),
+ Atom("treecolpicker", "treecolpicker"),
+ Atom("treecols", "treecols"),
+ Atom("treeitem", "treeitem"),
+ Atom("treerow", "treerow"),
+ Atom("treeseparator", "treeseparator"),
+ Atom("_true", "true"),
+ Atom("truespeed", "truespeed"),
+ Atom("tt", "tt"),
+ Atom("type", "type"),
+ Atom("u", "u"),
+ Atom("ul", "ul"),
+ Atom("unparsedEntityUri", "unparsed-entity-uri"),
+ Atom("up", "up"),
+ Atom("update", "update"),
+ Atom("upperFirst", "upper-first"),
+ Atom("use", "use"),
+ Atom("useAttributeSets", "use-attribute-sets"),
+ Atom("usemap", "usemap"),
+ Atom("user_scalable", "user-scalable"),
+ Atom("validate", "validate"),
+ Atom("valign", "valign"),
+ Atom("value", "value"),
+ Atom("values", "values"),
+ Atom("valueOf", "value-of"),
+ Atom("valuetype", "valuetype"),
+ Atom("var", "var"),
+ Atom("variable", "variable"),
+ Atom("vendor", "vendor"),
+ Atom("vendorUrl", "vendor-url"),
+ Atom("version", "version"),
+ Atom("vertical", "vertical"),
+ Atom("audio", "audio"),
+ Atom("video", "video"),
+ Atom("viewport", "viewport"),
+ Atom("viewport_fit", "viewport-fit"),
+ Atom("viewport_height", "viewport-height"),
+ Atom("viewport_initial_scale", "viewport-initial-scale"),
+ Atom("viewport_maximum_scale", "viewport-maximum-scale"),
+ Atom("viewport_minimum_scale", "viewport-minimum-scale"),
+ Atom("viewport_user_scalable", "viewport-user-scalable"),
+ Atom("viewport_width", "viewport-width"),
+ Atom("visibility", "visibility"),
+ Atom("visuallyselected", "visuallyselected"),
+ Atom("vlink", "vlink"),
+ Atom("_void", "void"),
+ Atom("vsides", "vsides"),
+ Atom("vspace", "vspace"),
+ Atom("w", "w"),
+ Atom("wbr", "wbr"),
+ Atom("webkitdirectory", "webkitdirectory"),
+ Atom("when", "when"),
+ Atom("white", "white"),
+ Atom("width", "width"),
+ Atom("willChange", "will-change"),
+ Atom("window", "window"),
+ Atom("headerWindowTarget", "window-target"),
+ Atom("windowtype", "windowtype"),
+ Atom("withParam", "with-param"),
+ Atom("wrap", "wrap"),
+ Atom("headerDNSPrefetchControl", "x-dns-prefetch-control"),
+ Atom("headerCSP", "content-security-policy"),
+ Atom("headerCSPReportOnly", "content-security-policy-report-only"),
+ Atom("headerXFO", "x-frame-options"),
+ Atom("x_western", "x-western"),
+ Atom("xml", "xml"),
+ Atom("xml_stylesheet", "xml-stylesheet"),
+ Atom("xmlns", "xmlns"),
+ Atom("xmp", "xmp"),
+ Atom("xul", "xul"),
+ Atom("yes", "yes"),
+ Atom("z_index", "z-index"),
+ Atom("zeroDigit", "zero-digit"),
+ Atom("zlevel", "zlevel"),
+ Atom("percentage", "%"),
+ Atom("A", "A"),
+ Atom("alignment_baseline", "alignment-baseline"),
+ Atom("amplitude", "amplitude"),
+ Atom("animate", "animate"),
+ Atom("animateColor", "animateColor"),
+ Atom("animateMotion", "animateMotion"),
+ Atom("animateTransform", "animateTransform"),
+ Atom("arithmetic", "arithmetic"),
+ Atom("atop", "atop"),
+ Atom("azimuth", "azimuth"),
+ Atom("B", "B"),
+ Atom("backgroundColor", "background-color"),
+ Atom("background_image", "background-image"),
+ Atom("baseFrequency", "baseFrequency"),
+ Atom("baseline_shift", "baseline-shift"),
+ Atom("bias", "bias"),
+ Atom("caption_side", "caption-side"),
+ Atom("clip_path", "clip-path"),
+ Atom("clip_rule", "clip-rule"),
+ Atom("clipPath", "clipPath"),
+ Atom("clipPathUnits", "clipPathUnits"),
+ Atom("cm", "cm"),
+ Atom("colorBurn", "color-burn"),
+ Atom("colorDodge", "color-dodge"),
+ Atom("colorInterpolation", "color-interpolation"),
+ Atom("colorInterpolationFilters", "color-interpolation-filters"),
+ Atom("colorProfile", "color-profile"),
+ Atom("cursor", "cursor"),
+ Atom("cx", "cx"),
+ Atom("cy", "cy"),
+ Atom("d", "d"),
+ Atom("darken", "darken"),
+ Atom("defs", "defs"),
+ Atom("deg", "deg"),
+ Atom("desc", "desc"),
+ Atom("diffuseConstant", "diffuseConstant"),
+ Atom("dilate", "dilate"),
+ Atom("direction", "direction"),
+ Atom("disable", "disable"),
+ Atom("disc", "disc"),
+ Atom("discrete", "discrete"),
+ Atom("divisor", "divisor"),
+ Atom("dominant_baseline", "dominant-baseline"),
+ Atom("duplicate", "duplicate"),
+ Atom("dx", "dx"),
+ Atom("dy", "dy"),
+ Atom("edgeMode", "edgeMode"),
+ Atom("ellipse", "ellipse"),
+ Atom("elevation", "elevation"),
+ Atom("erode", "erode"),
+ Atom("ex", "ex"),
+ Atom("exact", "exact"),
+ Atom("exclusion", "exclusion"),
+ Atom("exponent", "exponent"),
+ Atom("feBlend", "feBlend"),
+ Atom("feColorMatrix", "feColorMatrix"),
+ Atom("feComponentTransfer", "feComponentTransfer"),
+ Atom("feComposite", "feComposite"),
+ Atom("feConvolveMatrix", "feConvolveMatrix"),
+ Atom("feDiffuseLighting", "feDiffuseLighting"),
+ Atom("feDisplacementMap", "feDisplacementMap"),
+ Atom("feDistantLight", "feDistantLight"),
+ Atom("feDropShadow", "feDropShadow"),
+ Atom("feFlood", "feFlood"),
+ Atom("feFuncA", "feFuncA"),
+ Atom("feFuncB", "feFuncB"),
+ Atom("feFuncG", "feFuncG"),
+ Atom("feFuncR", "feFuncR"),
+ Atom("feGaussianBlur", "feGaussianBlur"),
+ Atom("feImage", "feImage"),
+ Atom("feMerge", "feMerge"),
+ Atom("feMergeNode", "feMergeNode"),
+ Atom("feMorphology", "feMorphology"),
+ Atom("feOffset", "feOffset"),
+ Atom("fePointLight", "fePointLight"),
+ Atom("feSpecularLighting", "feSpecularLighting"),
+ Atom("feSpotLight", "feSpotLight"),
+ Atom("feTile", "feTile"),
+ Atom("feTurbulence", "feTurbulence"),
+ Atom("fill", "fill"),
+ Atom("fill_opacity", "fill-opacity"),
+ Atom("fill_rule", "fill-rule"),
+ Atom("filter", "filter"),
+ Atom("filterUnits", "filterUnits"),
+ Atom("_float", "float"),
+ Atom("flood_color", "flood-color"),
+ Atom("flood_opacity", "flood-opacity"),
+ Atom("font_face", "font-face"),
+ Atom("font_face_format", "font-face-format"),
+ Atom("font_face_name", "font-face-name"),
+ Atom("font_face_src", "font-face-src"),
+ Atom("font_face_uri", "font-face-uri"),
+ Atom("font_family", "font-family"),
+ Atom("font_size", "font-size"),
+ Atom("font_size_adjust", "font-size-adjust"),
+ Atom("font_stretch", "font-stretch"),
+ Atom("font_style", "font-style"),
+ Atom("font_variant", "font-variant"),
+ Atom("formatting", "formatting"),
+ Atom("foreignObject", "foreignObject"),
+ Atom("fractalNoise", "fractalNoise"),
+ Atom("fr", "fr"),
+ Atom("fx", "fx"),
+ Atom("fy", "fy"),
+ Atom("G", "G"),
+ Atom("g", "g"),
+ Atom("gamma", "gamma"),
+ Atom("glyphRef", "glyphRef"),
+ Atom("grad", "grad"),
+ Atom("gradientTransform", "gradientTransform"),
+ Atom("gradientUnits", "gradientUnits"),
+ Atom("hardLight", "hard-light"),
+ Atom("hue", "hue"),
+ Atom("hueRotate", "hueRotate"),
+ Atom("identity", "identity"),
+ Atom("image_rendering", "image-rendering"),
+ Atom("in", "in"),
+ Atom("in2", "in2"),
+ Atom("intercept", "intercept"),
+ Atom("k1", "k1"),
+ Atom("k2", "k2"),
+ Atom("k3", "k3"),
+ Atom("k4", "k4"),
+ Atom("kernelMatrix", "kernelMatrix"),
+ Atom("kernelUnitLength", "kernelUnitLength"),
+ Atom("lengthAdjust", "lengthAdjust"),
+ Atom("letter_spacing", "letter-spacing"),
+ Atom("lighten", "lighten"),
+ Atom("lighter", "lighter"),
+ Atom("lighting_color", "lighting-color"),
+ Atom("limitingConeAngle", "limitingConeAngle"),
+ Atom("linear", "linear"),
+ Atom("linearGradient", "linearGradient"),
+ Atom("list_item", "list-item"),
+ Atom("list_style_type", "list-style-type"),
+ Atom("luminanceToAlpha", "luminanceToAlpha"),
+ Atom("luminosity", "luminosity"),
+ Atom("magnify", "magnify"),
+ Atom("marker", "marker"),
+ Atom("marker_end", "marker-end"),
+ Atom("marker_mid", "marker-mid"),
+ Atom("marker_start", "marker-start"),
+ Atom("markerHeight", "markerHeight"),
+ Atom("markerUnits", "markerUnits"),
+ Atom("markerWidth", "markerWidth"),
+ Atom("mask", "mask"),
+ Atom("maskContentUnits", "maskContentUnits"),
+ Atom("mask_type", "mask-type"),
+ Atom("maskUnits", "maskUnits"),
+ Atom("matrix", "matrix"),
+ Atom("metadata", "metadata"),
+ Atom("missingGlyph", "missing-glyph"),
+ Atom("mm", "mm"),
+ Atom("mpath", "mpath"),
+ Atom("noStitch", "noStitch"),
+ Atom("numOctaves", "numOctaves"),
+ Atom("multiply", "multiply"),
+ Atom("objectBoundingBox", "objectBoundingBox"),
+ Atom("offset", "offset"),
+ Atom("onSVGLoad", "onSVGLoad"),
+ Atom("onSVGScroll", "onSVGScroll"),
+ Atom("onzoom", "onzoom"),
+ Atom("opacity", "opacity"),
+ Atom("_operator", "operator"),
+ Atom("out", "out"),
+ Atom("over", "over"),
+ Atom("overridePreserveAspectRatio", "overridePreserveAspectRatio"),
+ Atom("pad", "pad"),
+ Atom("path", "path"),
+ Atom("pathLength", "pathLength"),
+ Atom("patternContentUnits", "patternContentUnits"),
+ Atom("patternTransform", "patternTransform"),
+ Atom("patternUnits", "patternUnits"),
+ Atom("pc", "pc"),
+ Atom("pointer", "pointer"),
+ Atom("pointer_events", "pointer-events"),
+ Atom("points", "points"),
+ Atom("pointsAtX", "pointsAtX"),
+ Atom("pointsAtY", "pointsAtY"),
+ Atom("pointsAtZ", "pointsAtZ"),
+ Atom("polyline", "polyline"),
+ Atom("preserveAlpha", "preserveAlpha"),
+ Atom("preserveAspectRatio", "preserveAspectRatio"),
+ Atom("primitiveUnits", "primitiveUnits"),
+ Atom("pt", "pt"),
+ Atom("px", "px"),
+ Atom("R", "R"),
+ Atom("r", "r"),
+ Atom("rad", "rad"),
+ Atom("radialGradient", "radialGradient"),
+ Atom("radius", "radius"),
+ Atom("reflect", "reflect"),
+ Atom("refX", "refX"),
+ Atom("refY", "refY"),
+ Atom("requiredExtensions", "requiredExtensions"),
+ Atom("requiredFeatures", "requiredFeatures"),
+ Atom("rotate", "rotate"),
+ Atom("rx", "rx"),
+ Atom("ry", "ry"),
+ Atom("saturate", "saturate"),
+ Atom("saturation", "saturation"),
+ Atom("set", "set"),
+ Atom("seed", "seed"),
+ Atom("shape_rendering", "shape-rendering"),
+ Atom("simpleScopeChain", "simpleScopeChain"),
+ Atom("skewX", "skewX"),
+ Atom("skewY", "skewY"),
+ Atom("slope", "slope"),
+ Atom("slot", "slot"),
+ Atom("softLight", "soft-light"),
+ Atom("spacing", "spacing"),
+ Atom("spacingAndGlyphs", "spacingAndGlyphs"),
+ Atom("specularConstant", "specularConstant"),
+ Atom("specularExponent", "specularExponent"),
+ Atom("spreadMethod", "spreadMethod"),
+ Atom("startOffset", "startOffset"),
+ Atom("stdDeviation", "stdDeviation"),
+ Atom("stitch", "stitch"),
+ Atom("stitchTiles", "stitchTiles"),
+ Atom("stop_color", "stop-color"),
+ Atom("stop_opacity", "stop-opacity"),
+ Atom("stroke", "stroke"),
+ Atom("stroke_dasharray", "stroke-dasharray"),
+ Atom("stroke_dashoffset", "stroke-dashoffset"),
+ Atom("stroke_linecap", "stroke-linecap"),
+ Atom("stroke_linejoin", "stroke-linejoin"),
+ Atom("stroke_miterlimit", "stroke-miterlimit"),
+ Atom("stroke_opacity", "stroke-opacity"),
+ Atom("stroke_width", "stroke-width"),
+ Atom("strokeWidth", "strokeWidth"),
+ Atom("surfaceScale", "surfaceScale"),
+ Atom("svg", "svg"),
+ Atom("svgSwitch", "switch"),
+ Atom("symbol", "symbol"),
+ Atom("systemLanguage", "systemLanguage"),
+ Atom("tableValues", "tableValues"),
+ Atom("targetX", "targetX"),
+ Atom("targetY", "targetY"),
+ Atom("text_anchor", "text-anchor"),
+ Atom("text_rendering", "text-rendering"),
+ Atom("textLength", "textLength"),
+ Atom("textPath", "textPath"),
+ Atom("transform_origin", "transform-origin"),
+ Atom("tref", "tref"),
+ Atom("tspan", "tspan"),
+ Atom("turbulence", "turbulence"),
+ Atom("unicode_bidi", "unicode-bidi"),
+ Atom("userSpaceOnUse", "userSpaceOnUse"),
+ Atom("view", "view"),
+ Atom("viewBox", "viewBox"),
+ Atom("viewTarget", "viewTarget"),
+ Atom("white_space", "white-space"),
+ Atom("word_spacing", "word-spacing"),
+ Atom("writing_mode", "writing-mode"),
+ Atom("x", "x"),
+ Atom("x1", "x1"),
+ Atom("x2", "x2"),
+ Atom("xChannelSelector", "xChannelSelector"),
+ Atom("xor_", "xor"),
+ Atom("y", "y"),
+ Atom("y1", "y1"),
+ Atom("y2", "y2"),
+ Atom("yChannelSelector", "yChannelSelector"),
+ Atom("z", "z"),
+ Atom("zoomAndPan", "zoomAndPan"),
+ Atom("vector_effect", "vector-effect"),
+ Atom("vertical_align", "vertical-align"),
+ Atom("accumulate", "accumulate"),
+ Atom("additive", "additive"),
+ Atom("attributeName", "attributeName"),
+ Atom("attributeType", "attributeType"),
+ Atom("auto_reverse", "auto-reverse"),
+ Atom("begin", "begin"),
+ Atom("beginEvent", "beginEvent"),
+ Atom("by", "by"),
+ Atom("calcMode", "calcMode"),
+ Atom("dur", "dur"),
+ Atom("keyPoints", "keyPoints"),
+ Atom("keySplines", "keySplines"),
+ Atom("keyTimes", "keyTimes"),
+ Atom("mozAnimateMotionDummyAttr", "_mozAnimateMotionDummyAttr"),
+ Atom("onbegin", "onbegin"),
+ Atom("onbeginEvent", "onbeginEvent"),
+ Atom("onend", "onend"),
+ Atom("onendEvent", "onendEvent"),
+ Atom("onrepeat", "onrepeat"),
+ Atom("onrepeatEvent", "onrepeatEvent"),
+ Atom("repeatCount", "repeatCount"),
+ Atom("repeatDur", "repeatDur"),
+ Atom("repeatEvent", "repeatEvent"),
+ Atom("restart", "restart"),
+ Atom("to", "to"),
+ Atom("abs_", "abs"),
+ Atom("accent_", "accent"),
+ Atom("accentunder_", "accentunder"),
+ Atom("actiontype_", "actiontype"),
+ Atom("alignmentscope_", "alignmentscope"),
+ Atom("altimg_", "altimg"),
+ Atom("altimg_height_", "altimg-height"),
+ Atom("altimg_valign_", "altimg-valign"),
+ Atom("altimg_width_", "altimg-width"),
+ Atom("annotation_", "annotation"),
+ Atom("annotation_xml_", "annotation-xml"),
+ Atom("apply_", "apply"),
+ Atom("approx_", "approx"),
+ Atom("arccos_", "arccos"),
+ Atom("arccosh_", "arccosh"),
+ Atom("arccot_", "arccot"),
+ Atom("arccoth_", "arccoth"),
+ Atom("arccsc_", "arccsc"),
+ Atom("arccsch_", "arccsch"),
+ Atom("arcsec_", "arcsec"),
+ Atom("arcsech_", "arcsech"),
+ Atom("arcsin_", "arcsin"),
+ Atom("arcsinh_", "arcsinh"),
+ Atom("arctan_", "arctan"),
+ Atom("arctanh_", "arctanh"),
+ Atom("arg_", "arg"),
+ Atom("bevelled_", "bevelled"),
+ Atom("bind_", "bind"),
+ Atom("bvar_", "bvar"),
+ Atom("card_", "card"),
+ Atom("cartesianproduct_", "cartesianproduct"),
+ Atom("cbytes_", "cbytes"),
+ Atom("cd_", "cd"),
+ Atom("cdgroup_", "cdgroup"),
+ Atom("cerror_", "cerror"),
+ Atom("charalign_", "charalign"),
+ Atom("ci_", "ci"),
+ Atom("closure_", "closure"),
+ Atom("cn_", "cn"),
+ Atom("codomain_", "codomain"),
+ Atom("columnalign_", "columnalign"),
+ Atom("columnalignment_", "columnalignment"),
+ Atom("columnlines_", "columnlines"),
+ Atom("columnspacing_", "columnspacing"),
+ Atom("columnspan_", "columnspan"),
+ Atom("columnwidth_", "columnwidth"),
+ Atom("complexes_", "complexes"),
+ Atom("compose_", "compose"),
+ Atom("condition_", "condition"),
+ Atom("conjugate_", "conjugate"),
+ Atom("cos_", "cos"),
+ Atom("cosh_", "cosh"),
+ Atom("cot_", "cot"),
+ Atom("coth_", "coth"),
+ Atom("crossout_", "crossout"),
+ Atom("csc_", "csc"),
+ Atom("csch_", "csch"),
+ Atom("cs_", "cs"),
+ Atom("csymbol_", "csymbol"),
+ Atom("csp", "csp"),
+ Atom("curl_", "curl"),
+ Atom("decimalpoint_", "decimalpoint"),
+ Atom("definitionURL_", "definitionURL"),
+ Atom("degree_", "degree"),
+ Atom("denomalign_", "denomalign"),
+ Atom("depth_", "depth"),
+ Atom("determinant_", "determinant"),
+ Atom("diff_", "diff"),
+ Atom("displaystyle_", "displaystyle"),
+ Atom("divergence_", "divergence"),
+ Atom("divide_", "divide"),
+ Atom("domain_", "domain"),
+ Atom("domainofapplication_", "domainofapplication"),
+ Atom("edge_", "edge"),
+ Atom("el", "el"),
+ Atom("emptyset_", "emptyset"),
+ Atom("eq_", "eq"),
+ Atom("equalcolumns_", "equalcolumns"),
+ Atom("equalrows_", "equalrows"),
+ Atom("equivalent_", "equivalent"),
+ Atom("eulergamma_", "eulergamma"),
+ Atom("exists_", "exists"),
+ Atom("exp_", "exp"),
+ Atom("exponentiale_", "exponentiale"),
+ Atom("factorial_", "factorial"),
+ Atom("factorof_", "factorof"),
+ Atom("fence_", "fence"),
+ Atom("fn_", "fn"),
+ Atom("fontfamily_", "fontfamily"),
+ Atom("fontsize_", "fontsize"),
+ Atom("fontstyle_", "fontstyle"),
+ Atom("fontweight_", "fontweight"),
+ Atom("forall_", "forall"),
+ Atom("framespacing_", "framespacing"),
+ Atom("gcd_", "gcd"),
+ Atom("geq_", "geq"),
+ Atom("groupalign_", "groupalign"),
+ Atom("gt_", "gt"),
+ Atom("ident_", "ident"),
+ Atom("imaginaryi_", "imaginaryi"),
+ Atom("imaginary_", "imaginary"),
+ Atom("implies_", "implies"),
+ Atom("indentalignfirst_", "indentalignfirst"),
+ Atom("indentalign_", "indentalign"),
+ Atom("indentalignlast_", "indentalignlast"),
+ Atom("indentshiftfirst_", "indentshiftfirst"),
+ Atom("indentshift_", "indentshift"),
+ Atom("indenttarget_", "indenttarget"),
+ Atom("integers_", "integers"),
+ Atom("intersect_", "intersect"),
+ Atom("interval_", "interval"),
+ Atom("int_", "int"),
+ Atom("inverse_", "inverse"),
+ Atom("lambda_", "lambda"),
+ Atom("laplacian_", "laplacian"),
+ Atom("largeop_", "largeop"),
+ Atom("lcm_", "lcm"),
+ Atom("leq_", "leq"),
+ Atom("limit_", "limit"),
+ Atom("linebreak_", "linebreak"),
+ Atom("linebreakmultchar_", "linebreakmultchar"),
+ Atom("linebreakstyle_", "linebreakstyle"),
+ Atom("linethickness_", "linethickness"),
+ Atom("list_", "list"),
+ Atom("ln_", "ln"),
+ Atom("location_", "location"),
+ Atom("logbase_", "logbase"),
+ Atom("log_", "log"),
+ Atom("longdivstyle_", "longdivstyle"),
+ Atom("lowlimit_", "lowlimit"),
+ Atom("lquote_", "lquote"),
+ Atom("lspace_", "lspace"),
+ Atom("lt_", "lt"),
+ Atom("maction_", "maction"),
+ Atom("maligngroup_", "maligngroup"),
+ Atom("malignmark_", "malignmark"),
+ Atom("mathbackground_", "mathbackground"),
+ Atom("mathcolor_", "mathcolor"),
+ Atom("mathsize_", "mathsize"),
+ Atom("mathvariant_", "mathvariant"),
+ Atom("matrixrow_", "matrixrow"),
+ Atom("maxsize_", "maxsize"),
+ Atom("mean_", "mean"),
+ Atom("median_", "median"),
+ Atom("menclose_", "menclose"),
+ Atom("merror_", "merror"),
+ Atom("mfenced_", "mfenced"),
+ Atom("mfrac_", "mfrac"),
+ Atom("mglyph_", "mglyph"),
+ Atom("mi_", "mi"),
+ Atom("minlabelspacing_", "minlabelspacing"),
+ Atom("minsize_", "minsize"),
+ Atom("minus_", "minus"),
+ Atom("mlabeledtr_", "mlabeledtr"),
+ Atom("mlongdiv_", "mlongdiv"),
+ Atom("mmultiscripts_", "mmultiscripts"),
+ Atom("mn_", "mn"),
+ Atom("momentabout_", "momentabout"),
+ Atom("moment_", "moment"),
+ Atom("mo_", "mo"),
+ Atom("movablelimits_", "movablelimits"),
+ Atom("mover_", "mover"),
+ Atom("mpadded_", "mpadded"),
+ Atom("mphantom_", "mphantom"),
+ Atom("mprescripts_", "mprescripts"),
+ Atom("mroot_", "mroot"),
+ Atom("mrow_", "mrow"),
+ Atom("mscarries_", "mscarries"),
+ Atom("mscarry_", "mscarry"),
+ Atom("msgroup_", "msgroup"),
+ Atom("msline_", "msline"),
+ Atom("ms_", "ms"),
+ Atom("mspace_", "mspace"),
+ Atom("msqrt_", "msqrt"),
+ Atom("msrow_", "msrow"),
+ Atom("mstack_", "mstack"),
+ Atom("mstyle_", "mstyle"),
+ Atom("msub_", "msub"),
+ Atom("msubsup_", "msubsup"),
+ Atom("msup_", "msup"),
+ Atom("mtable_", "mtable"),
+ Atom("mtd_", "mtd"),
+ Atom("mtext_", "mtext"),
+ Atom("mtr_", "mtr"),
+ Atom("munder_", "munder"),
+ Atom("munderover_", "munderover"),
+ Atom("naturalnumbers_", "naturalnumbers"),
+ Atom("neq_", "neq"),
+ Atom("notanumber_", "notanumber"),
+ Atom("notation_", "notation"),
+ Atom("note_", "note"),
+ Atom("notin_", "notin"),
+ Atom("notprsubset_", "notprsubset"),
+ Atom("notsubset_", "notsubset"),
+ Atom("numalign_", "numalign"),
+ Atom("other", "other"),
+ Atom("outerproduct_", "outerproduct"),
+ Atom("partialdiff_", "partialdiff"),
+ Atom("piece_", "piece"),
+ Atom("piecewise_", "piecewise"),
+ Atom("pi_", "pi"),
+ Atom("plus_", "plus"),
+ Atom("power_", "power"),
+ Atom("primes_", "primes"),
+ Atom("product_", "product"),
+ Atom("prsubset_", "prsubset"),
+ Atom("quotient_", "quotient"),
+ Atom("rationals_", "rationals"),
+ Atom("real_", "real"),
+ Atom("reals_", "reals"),
+ Atom("reln_", "reln"),
+ Atom("root_", "root"),
+ Atom("rowalign_", "rowalign"),
+ Atom("rowlines_", "rowlines"),
+ Atom("rowspacing_", "rowspacing"),
+ Atom("rquote_", "rquote"),
+ Atom("rspace_", "rspace"),
+ Atom("scalarproduct_", "scalarproduct"),
+ Atom("schemaLocation_", "schemaLocation"),
+ Atom("scriptlevel_", "scriptlevel"),
+ Atom("scriptminsize_", "scriptminsize"),
+ Atom("scriptsizemultiplier_", "scriptsizemultiplier"),
+ Atom("scriptsize_", "scriptsize"),
+ Atom("sdev_", "sdev"),
+ Atom("sech_", "sech"),
+ Atom("sec_", "sec"),
+ Atom("selection_", "selection"),
+ Atom("selector_", "selector"),
+ Atom("semantics_", "semantics"),
+ Atom("separator_", "separator"),
+ Atom("separators_", "separators"),
+ Atom("sep_", "sep"),
+ Atom("setdiff_", "setdiff"),
+ # Atom("set_", "set"), # "set" is present above
+ Atom("share_", "share"),
+ Atom("shift_", "shift"),
+ Atom("side_", "side"),
+ Atom("sinh_", "sinh"),
+ Atom("sin_", "sin"),
+ Atom("stackalign_", "stackalign"),
+ Atom("stretchy_", "stretchy"),
+ Atom("subscriptshift_", "subscriptshift"),
+ Atom("subset_", "subset"),
+ Atom("superscriptshift_", "superscriptshift"),
+ Atom("symmetric_", "symmetric"),
+ Atom("tanh_", "tanh"),
+ Atom("tan_", "tan"),
+ Atom("tendsto_", "tendsto"),
+ Atom("times_", "times"),
+ Atom("transpose_", "transpose"),
+ Atom("union_", "union"),
+ Atom("uplimit_", "uplimit"),
+ Atom("variance_", "variance"),
+ Atom("vectorproduct_", "vectorproduct"),
+ Atom("vector_", "vector"),
+ Atom("voffset_", "voffset"),
+ Atom("xref_", "xref"),
+ Atom("math", "math"), # the only one without an underscore
+ Atom("booleanFromString", "boolean-from-string"),
+ Atom("countNonEmpty", "count-non-empty"),
+ Atom("daysFromDate", "days-from-date"),
+ Atom("secondsFromDateTime", "seconds-from-dateTime"),
+ Atom("tabbrowser_arrowscrollbox", "tabbrowser-arrowscrollbox"),
+ # Simple gestures support
+ Atom("onMozSwipeGestureMayStart", "onMozSwipeGestureMayStart"),
+ Atom("onMozSwipeGestureStart", "onMozSwipeGestureStart"),
+ Atom("onMozSwipeGestureUpdate", "onMozSwipeGestureUpdate"),
+ Atom("onMozSwipeGestureEnd", "onMozSwipeGestureEnd"),
+ Atom("onMozSwipeGesture", "onMozSwipeGesture"),
+ Atom("onMozMagnifyGestureStart", "onMozMagnifyGestureStart"),
+ Atom("onMozMagnifyGestureUpdate", "onMozMagnifyGestureUpdate"),
+ Atom("onMozMagnifyGesture", "onMozMagnifyGesture"),
+ Atom("onMozRotateGestureStart", "onMozRotateGestureStart"),
+ Atom("onMozRotateGestureUpdate", "onMozRotateGestureUpdate"),
+ Atom("onMozRotateGesture", "onMozRotateGesture"),
+ Atom("onMozTapGesture", "onMozTapGesture"),
+ Atom("onMozPressTapGesture", "onMozPressTapGesture"),
+ Atom("onMozEdgeUIStarted", "onMozEdgeUIStarted"),
+ Atom("onMozEdgeUICanceled", "onMozEdgeUICanceled"),
+ Atom("onMozEdgeUICompleted", "onMozEdgeUICompleted"),
+ # Pointer events
+ Atom("onpointerdown", "onpointerdown"),
+ Atom("onpointermove", "onpointermove"),
+ Atom("onpointerup", "onpointerup"),
+ Atom("onpointercancel", "onpointercancel"),
+ Atom("onpointerover", "onpointerover"),
+ Atom("onpointerout", "onpointerout"),
+ Atom("onpointerenter", "onpointerenter"),
+ Atom("onpointerleave", "onpointerleave"),
+ Atom("ongotpointercapture", "ongotpointercapture"),
+ Atom("onlostpointercapture", "onlostpointercapture"),
+ # orientation support
+ Atom("ondevicemotion", "ondevicemotion"),
+ Atom("ondeviceorientation", "ondeviceorientation"),
+ Atom("ondeviceorientationabsolute", "ondeviceorientationabsolute"),
+ Atom("onmozorientationchange", "onmozorientationchange"),
+ Atom("onuserproximity", "onuserproximity"),
+ # light sensor support
+ Atom("ondevicelight", "ondevicelight"),
+ # MediaDevices device change event
+ Atom("ondevicechange", "ondevicechange"),
+ # Internal Visual Viewport events
+ Atom("onmozvisualresize", "onmozvisualresize"),
+ Atom("onmozvisualscroll", "onmozvisualscroll"),
+ # Miscellaneous events included for memory usage optimization (see bug 1542885)
+ Atom("onDOMAutoComplete", "onDOMAutoComplete"),
+ Atom("onDOMContentLoaded", "onDOMContentLoaded"),
+ Atom("onDOMDocElementInserted", "onDOMDocElementInserted"),
+ Atom("onDOMFormBeforeSubmit", "onDOMFormBeforeSubmit"),
+ Atom("onDOMFormHasPassword", "onDOMFormHasPassword"),
+ Atom("onDOMFrameContentLoaded", "onDOMFrameContentLoaded"),
+ Atom("onDOMHeadElementParsed", "onDOMHeadElementParsed"),
+ Atom("onDOMInputPasswordAdded", "onDOMInputPasswordAdded"),
+ Atom("onDOMLinkAdded", "onDOMLinkAdded"),
+ Atom("onDOMLinkChanged", "onDOMLinkChanged"),
+ Atom("onDOMMetaAdded", "onDOMMetaAdded"),
+ Atom("onDOMMetaChanged", "onDOMMetaChanged"),
+ Atom("onDOMMetaRemoved", "onDOMMetaRemoved"),
+ Atom("onDOMPopupBlocked", "onDOMPopupBlocked"),
+ Atom("onDOMTitleChanged", "onDOMTitleChanged"),
+ Atom("onDOMWindowClose", "onDOMWindowClose"),
+ Atom("onDOMWindowCreated", "onDOMWindowCreated"),
+ Atom("onDOMWindowFocus", "onDOMWindowFocus"),
+ Atom("onFullZoomChange", "onFullZoomChange"),
+ Atom("onGloballyAutoplayBlocked", "onGloballyAutoplayBlocked"),
+ Atom("onMozDOMFullscreen_Entered", "onMozDOMFullscreen:Entered"),
+ Atom("onMozDOMFullscreen_Exit", "onMozDOMFullscreen:Exit"),
+ Atom("onMozDOMFullscreen_Exited", "onMozDOMFullscreen:Exited"),
+ Atom("onMozDOMFullscreen_NewOrigin", "onMozDOMFullscreen:NewOrigin"),
+ Atom("onMozDOMFullscreen_Request", "onMozDOMFullscreen:Request"),
+ Atom("onMozDOMPointerLock_Entered", "onMozDOMPointerLock:Entered"),
+ Atom("onMozDOMPointerLock_Exited", "onMozDOMPointerLock:Exited"),
+ Atom("onMozInvalidForm", "onMozInvalidForm"),
+ Atom("onMozLocalStorageChanged", "onMozLocalStorageChanged"),
+ Atom("onMozOpenDateTimePicker", "onMozOpenDateTimePicker"),
+ Atom("onMozSessionStorageChanged", "onMozSessionStorageChanged"),
+ Atom("onMozTogglePictureInPicture", "onMozTogglePictureInPicture"),
+ Atom("onPluginCrashed", "onPluginCrashed"),
+ Atom("onPrintingError", "onPrintingError"),
+ Atom("onTextZoomChange", "onTextZoomChange"),
+ Atom("onUAWidgetSetupOrChange", "onUAWidgetSetupOrChange"),
+ Atom("onUAWidgetTeardown", "onUAWidgetTeardown"),
+ Atom("onUnselectedTabHover_Disable", "onUnselectedTabHover:Disable"),
+ Atom("onUnselectedTabHover_Enable", "onUnselectedTabHover:Enable"),
+ Atom("onmozshowdropdown", "onmozshowdropdown"),
+ Atom("onmozshowdropdown_sourcetouch", "onmozshowdropdown-sourcetouch"),
+ Atom("onprintPreviewUpdate", "onprintPreviewUpdate"),
+ Atom("onscrollend", "onscrollend"),
+ Atom("onbeforetoggle", "onbeforetoggle"),
+ # WebExtensions
+ Atom("moz_extension", "moz-extension"),
+ Atom("all_urlsPermission", "<all_urls>"),
+ Atom("clipboardRead", "clipboardRead"),
+ Atom("clipboardWrite", "clipboardWrite"),
+ Atom("debugger", "debugger"),
+ Atom("mozillaAddons", "mozillaAddons"),
+ Atom("tabs", "tabs"),
+ Atom("webRequestBlocking", "webRequestBlocking"),
+ Atom("webRequestFilterResponse_serviceWorkerScript", "webRequestFilterResponse.serviceWorkerScript"),
+ Atom("http", "http"),
+ Atom("https", "https"),
+ Atom("ws", "ws"),
+ Atom("wss", "wss"),
+ Atom("ftp", "ftp"),
+ Atom("chrome", "chrome"),
+ Atom("moz", "moz"),
+ Atom("moz_icon", "moz-icon"),
+ Atom("moz_gio", "moz-gio"),
+ Atom("proxy", "proxy"),
+ Atom("privateBrowsingAllowedPermission", "internal:privateBrowsingAllowed"),
+ Atom("svgContextPropertiesAllowedPermission", "internal:svgContextPropertiesAllowed"),
+ Atom("theme", "theme"),
+ # CSS Counter Styles
+ Atom("decimal_leading_zero", "decimal-leading-zero"),
+ Atom("arabic_indic", "arabic-indic"),
+ Atom("armenian", "armenian"),
+ Atom("upper_armenian", "upper-armenian"),
+ Atom("lower_armenian", "lower-armenian"),
+ Atom("bengali", "bengali"),
+ Atom("cambodian", "cambodian"),
+ Atom("khmer", "khmer"),
+ Atom("cjk_decimal", "cjk-decimal"),
+ Atom("devanagari", "devanagari"),
+ Atom("georgian", "georgian"),
+ Atom("gujarati", "gujarati"),
+ Atom("gurmukhi", "gurmukhi"),
+ Atom("kannada", "kannada"),
+ Atom("lao", "lao"),
+ Atom("malayalam", "malayalam"),
+ Atom("mongolian", "mongolian"),
+ Atom("myanmar", "myanmar"),
+ Atom("oriya", "oriya"),
+ Atom("persian", "persian"),
+ Atom("lower_roman", "lower-roman"),
+ Atom("upper_roman", "upper-roman"),
+ Atom("tamil", "tamil"),
+ Atom("telugu", "telugu"),
+ Atom("thai", "thai"),
+ Atom("tibetan", "tibetan"),
+ Atom("lower_alpha", "lower-alpha"),
+ Atom("lower_latin", "lower-latin"),
+ Atom("upper_alpha", "upper-alpha"),
+ Atom("upper_latin", "upper-latin"),
+ Atom("cjk_heavenly_stem", "cjk-heavenly-stem"),
+ Atom("cjk_earthly_branch", "cjk-earthly-branch"),
+ Atom("lower_greek", "lower-greek"),
+ Atom("hiragana", "hiragana"),
+ Atom("hiragana_iroha", "hiragana-iroha"),
+ Atom("katakana", "katakana"),
+ Atom("katakana_iroha", "katakana-iroha"),
+ Atom("cjk_ideographic", "cjk-ideographic"),
+ Atom("_moz_arabic_indic", "-moz-arabic-indic"),
+ Atom("_moz_persian", "-moz-persian"),
+ Atom("_moz_urdu", "-moz-urdu"),
+ Atom("_moz_devanagari", "-moz-devanagari"),
+ Atom("_moz_bengali", "-moz-bengali"),
+ Atom("_moz_gurmukhi", "-moz-gurmukhi"),
+ Atom("_moz_gujarati", "-moz-gujarati"),
+ Atom("_moz_oriya", "-moz-oriya"),
+ Atom("_moz_tamil", "-moz-tamil"),
+ Atom("_moz_telugu", "-moz-telugu"),
+ Atom("_moz_kannada", "-moz-kannada"),
+ Atom("_moz_malayalam", "-moz-malayalam"),
+ Atom("_moz_thai", "-moz-thai"),
+ Atom("_moz_lao", "-moz-lao"),
+ Atom("_moz_myanmar", "-moz-myanmar"),
+ Atom("_moz_khmer", "-moz-khmer"),
+ Atom("_moz_cjk_heavenly_stem", "-moz-cjk-heavenly-stem"),
+ Atom("_moz_cjk_earthly_branch", "-moz-cjk-earthly-branch"),
+ Atom("_moz_hangul", "-moz-hangul"),
+ Atom("_moz_hangul_consonant", "-moz-hangul-consonant"),
+ Atom("_moz_ethiopic_halehame", "-moz-ethiopic-halehame"),
+ Atom("_moz_ethiopic_halehame_am", "-moz-ethiopic-halehame-am"),
+ Atom("_moz_ethiopic_halehame_ti_er", "-moz-ethiopic-halehame-ti-er"),
+ Atom("_moz_ethiopic_halehame_ti_et", "-moz-ethiopic-halehame-ti-et"),
+ Atom("_moz_trad_chinese_informal", "-moz-trad-chinese-informal"),
+ Atom("_moz_trad_chinese_formal", "-moz-trad-chinese-formal"),
+ Atom("_moz_simp_chinese_informal", "-moz-simp-chinese-informal"),
+ Atom("_moz_simp_chinese_formal", "-moz-simp-chinese-formal"),
+ Atom("_moz_japanese_informal", "-moz-japanese-informal"),
+ Atom("_moz_japanese_formal", "-moz-japanese-formal"),
+ Atom("_moz_ethiopic_numeric", "-moz-ethiopic-numeric"),
+ # --------------------------------------------------------------------------
+ # Special atoms
+ # --------------------------------------------------------------------------
+ # Node types
+ Atom("cdataTagName", "#cdata-section"),
+ Atom("commentTagName", "#comment"),
+ Atom("documentNodeName", "#document"),
+ Atom("documentFragmentNodeName", "#document-fragment"),
+ Atom("documentTypeNodeName", "#document-type"),
+ Atom("processingInstructionTagName", "#processing-instruction"),
+ Atom("textTagName", "#text"),
+ # Frame types
+ #
+ # TODO(emilio): Rename this? This is only used now to mark the style context of
+ # the placeholder with a dummy pseudo.
+ Atom("placeholderFrame", "PlaceholderFrame"),
+ Atom("onloadend", "onloadend"),
+ Atom("onloadstart", "onloadstart"),
+ Atom("onprogress", "onprogress"),
+ Atom("onsuspend", "onsuspend"),
+ Atom("onemptied", "onemptied"),
+ Atom("onstalled", "onstalled"),
+ Atom("onplay", "onplay"),
+ Atom("onpause", "onpause"),
+ Atom("onloadedmetadata", "onloadedmetadata"),
+ Atom("onloadeddata", "onloadeddata"),
+ Atom("onwaiting", "onwaiting"),
+ Atom("onplaying", "onplaying"),
+ Atom("oncanplay", "oncanplay"),
+ Atom("oncanplaythrough", "oncanplaythrough"),
+ Atom("onseeking", "onseeking"),
+ Atom("onseeked", "onseeked"),
+ Atom("ontimeout", "ontimeout"),
+ Atom("ontimeupdate", "ontimeupdate"),
+ Atom("onended", "onended"),
+ Atom("onformdata", "onformdata"),
+ Atom("onratechange", "onratechange"),
+ Atom("ondurationchange", "ondurationchange"),
+ Atom("onvolumechange", "onvolumechange"),
+ Atom("onaddtrack", "onaddtrack"),
+ Atom("oncontrollerchange", "oncontrollerchange"),
+ Atom("oncuechange", "oncuechange"),
+ Atom("onenter", "onenter"),
+ Atom("onexit", "onexit"),
+ Atom("onencrypted", "onencrypted"),
+ Atom("onwaitingforkey", "onwaitingforkey"),
+ Atom("onkeystatuseschange", "onkeystatuseschange"),
+ Atom("onremovetrack", "onremovetrack"),
+ Atom("loadstart", "loadstart"),
+ Atom("suspend", "suspend"),
+ Atom("emptied", "emptied"),
+ Atom("play", "play"),
+ Atom("pause", "pause"),
+ Atom("loadedmetadata", "loadedmetadata"),
+ Atom("loadeddata", "loadeddata"),
+ Atom("waiting", "waiting"),
+ Atom("playing", "playing"),
+ Atom("timeupdate", "timeupdate"),
+ Atom("canplay", "canplay"),
+ Atom("canplaythrough", "canplaythrough"),
+ Atom("ondataavailable", "ondataavailable"),
+ Atom("onwarning", "onwarning"),
+ Atom("onstart", "onstart"),
+ Atom("onstop", "onstop"),
+ Atom("onphoto", "onphoto"),
+ Atom("ongamepadbuttondown", "ongamepadbuttondown"),
+ Atom("ongamepadbuttonup", "ongamepadbuttonup"),
+ Atom("ongamepadaxismove", "ongamepadaxismove"),
+ Atom("ongamepadconnected", "ongamepadconnected"),
+ Atom("ongamepaddisconnected", "ongamepaddisconnected"),
+ Atom("onfetch", "onfetch"),
+ # Content property names
+ Atom("afterPseudoProperty", "afterPseudoProperty"), # nsXMLElement*
+ Atom("beforePseudoProperty", "beforePseudoProperty"), # nsXMLElement*
+ Atom("cssPseudoElementBeforeProperty", "CSSPseudoElementBeforeProperty"), # CSSPseudoElement*
+ Atom("cssPseudoElementAfterProperty", "CSSPseudoElementAfterProperty"), # CSSPseudoElement*
+ Atom("cssPseudoElementMarkerProperty", "CSSPseudoElementMarkerProperty"), # CSSPseudoElement*
+ Atom("genConInitializerProperty", "QuoteNodeProperty"),
+ Atom("labelMouseDownPtProperty", "LabelMouseDownPtProperty"),
+ Atom("lockedStyleStates", "lockedStyleStates"),
+ Atom("apzCallbackTransform", "apzCallbackTransform"),
+ Atom("apzDisabled", "ApzDisabled"), # bool
+ Atom("restylableAnonymousNode", "restylableAnonymousNode"), # bool
+ Atom("docLevelNativeAnonymousContent", "docLevelNativeAnonymousContent"), # bool
+ Atom("paintRequestTime", "PaintRequestTime"),
+ Atom("pseudoProperty", "PseudoProperty"), # PseudoStyleType
+ Atom("manualNACProperty", "ManualNACProperty"), # ManualNAC*
+ Atom("markerPseudoProperty", "markerPseudoProperty"), # nsXMLElement*
+ # Languages for lang-specific transforms
+ Atom("Japanese", "ja"),
+ Atom("Chinese", "zh-CN"),
+ Atom("Taiwanese", "zh-TW"),
+ Atom("HongKongChinese", "zh-HK"),
+ Atom("Unicode", "x-unicode"),
+ # language codes specifically referenced in the gfx code
+ Atom("ko", "ko"),
+ Atom("zh_cn", "zh-cn"),
+ Atom("zh_tw", "zh-tw"),
+ # additional codes used in nsUnicodeRange.cpp
+ Atom("x_cyrillic", "x-cyrillic"),
+ Atom("he", "he"),
+ Atom("ar", "ar"),
+ Atom("x_devanagari", "x-devanagari"),
+ Atom("x_tamil", "x-tamil"),
+ Atom("x_armn", "x-armn"),
+ Atom("x_beng", "x-beng"),
+ Atom("x_cans", "x-cans"),
+ Atom("x_ethi", "x-ethi"),
+ Atom("x_geor", "x-geor"),
+ Atom("x_gujr", "x-gujr"),
+ Atom("x_guru", "x-guru"),
+ Atom("x_khmr", "x-khmr"),
+ Atom("x_knda", "x-knda"),
+ Atom("x_mlym", "x-mlym"),
+ Atom("x_orya", "x-orya"),
+ Atom("x_sinh", "x-sinh"),
+ Atom("x_telu", "x-telu"),
+ Atom("x_tibt", "x-tibt"),
+ # additional languages that have special case transformations
+ Atom("az", "az"),
+ Atom("ba", "ba"),
+ Atom("crh", "crh"),
+ # Atom("el", "el"), # "el" is present above
+ Atom("ga", "ga"),
+ # Atom("lt", "lt"), # "lt" is present above (atom name "lt_")
+ Atom("nl", "nl"),
+ # mathematical language, used for MathML
+ Atom("x_math", "x-math"),
+ # other languages mentioned in :lang() rules in UA style sheets
+ Atom("zh", "zh"),
+ # Names for editor transactions
+ Atom("TypingTxnName", "Typing"),
+ Atom("IMETxnName", "IME"),
+ Atom("DeleteTxnName", "Deleting"),
+ # Font families
+ Atom("serif", "serif"),
+ Atom("sans_serif", "sans-serif"),
+ Atom("cursive", "cursive"),
+ Atom("fantasy", "fantasy"),
+ Atom("monospace", "monospace"),
+ Atom("mozfixed", "-moz-fixed"),
+ Atom("moz_fixed_pos_containing_block", "-moz-fixed-pos-containing-block"),
+ # Standard font-palette identifiers
+ Atom("light", "light"),
+ Atom("dark", "dark"),
+ # IPC stuff
+ # Atom("Remote", "remote"), # "remote" is present above
+ Atom("RemoteId", "_remote_id"),
+ Atom("RemoteType", "remoteType"),
+ Atom("DisplayPort", "_displayport"),
+ Atom("DisplayPortMargins", "_displayportmargins"),
+ Atom("DisplayPortBase", "_displayportbase"),
+ Atom("MinimalDisplayPort", "_minimaldisplayport"),
+ Atom("forceMousewheelAutodir", "_force_mousewheel_autodir"),
+ Atom("forceMousewheelAutodirHonourRoot", "_force_mousewheel_autodir_honourroot"),
+ Atom("forcemessagemanager", "forcemessagemanager"),
+ Atom("initialBrowsingContextGroupId", "initialBrowsingContextGroupId"),
+ Atom("initiallyactive", "initiallyactive"),
+ # windows media query names
+ Atom("windows_win7", "windows-win7"),
+ Atom("windows_win8", "windows-win8"),
+ Atom("windows_win10", "windows-win10"),
+ # Names for system metrics.
+ Atom("_moz_scrollbar_start_backward", "-moz-scrollbar-start-backward"),
+ Atom("_moz_scrollbar_start_forward", "-moz-scrollbar-start-forward"),
+ Atom("_moz_scrollbar_end_backward", "-moz-scrollbar-end-backward"),
+ Atom("_moz_scrollbar_end_forward", "-moz-scrollbar-end-forward"),
+ Atom("_moz_overlay_scrollbars", "-moz-overlay-scrollbars"),
+ Atom("_moz_windows_accent_color_in_titlebar", "-moz-windows-accent-color-in-titlebar"),
+ Atom("_moz_windows_default_theme", "-moz-windows-default-theme"),
+ Atom("_moz_mac_graphite_theme", "-moz-mac-graphite-theme"),
+ Atom("_moz_mac_big_sur_theme", "-moz-mac-big-sur-theme"),
+ Atom("_moz_mac_rtl", "-moz-mac-rtl"),
+ Atom("_moz_platform", "-moz-platform"),
+ Atom("_moz_windows_compositor", "-moz-windows-compositor"),
+ Atom("_moz_windows_classic", "-moz-windows-classic"),
+ Atom("_moz_windows_glass", "-moz-windows-glass"),
+ Atom("_moz_windows_non_native_menus", "-moz-windows-non-native-menus"),
+ Atom("_moz_menubar_drag", "-moz-menubar-drag"),
+ Atom("_moz_device_pixel_ratio", "-moz-device-pixel-ratio"),
+ Atom("_moz_device_orientation", "-moz-device-orientation"),
+ Atom("_moz_is_resource_document", "-moz-is-resource-document"),
+ Atom("_moz_swipe_animation_enabled", "-moz-swipe-animation-enabled"),
+ Atom("_moz_gtk_csd_available", "-moz-gtk-csd-available"),
+ Atom("_moz_gtk_csd_titlebar_radius", "-moz-gtk-csd-titlebar-radius"),
+ Atom("_moz_gtk_csd_minimize_button", "-moz-gtk-csd-minimize-button"),
+ Atom("_moz_gtk_csd_minimize_button_position", "-moz-gtk-csd-minimize-button-position"),
+ Atom("_moz_gtk_csd_maximize_button", "-moz-gtk-csd-maximize-button"),
+ Atom("_moz_gtk_csd_maximize_button_position", "-moz-gtk-csd-maximize-button-position"),
+ Atom("_moz_gtk_csd_close_button", "-moz-gtk-csd-close-button"),
+ Atom("_moz_gtk_csd_close_button_position", "-moz-gtk-csd-close-button-position"),
+ Atom("_moz_gtk_csd_reversed_placement", "-moz-gtk-csd-reversed-placement"),
+ Atom("_moz_content_prefers_color_scheme", "-moz-content-prefers-color-scheme"),
+ Atom("_moz_content_preferred_color_scheme", "-moz-content-preferred-color-scheme"),
+ Atom("_moz_system_dark_theme", "-moz-system-dark-theme"),
+ Atom("_moz_panel_animations", "-moz-panel-animations"),
+ # application commands
+ Atom("Back", "Back"),
+ Atom("Forward", "Forward"),
+ Atom("Reload", "Reload"),
+ Atom("Stop", "Stop"),
+ Atom("Search", "Search"),
+ Atom("Bookmarks", "Bookmarks"),
+ Atom("Home", "Home"),
+ Atom("NextTrack", "NextTrack"),
+ Atom("PreviousTrack", "PreviousTrack"),
+ Atom("MediaStop", "MediaStop"),
+ Atom("PlayPause", "PlayPause"),
+ Atom("New", "New"),
+ Atom("Open", "Open"),
+ Atom("Close", "Close"),
+ Atom("Save", "Save"),
+ Atom("Find", "Find"),
+ Atom("Help", "Help"),
+ Atom("Print", "Print"),
+ Atom("SendMail", "SendMail"),
+ Atom("ForwardMail", "ForwardMail"),
+ Atom("ReplyToMail", "ReplyToMail"),
+ Atom("alert", "alert"),
+ Atom("alertdialog", "alertdialog"),
+ Atom("application", "application"),
+ Atom("aria_colcount", "aria-colcount"),
+ Atom("aria_colindex", "aria-colindex"),
+ Atom("aria_colindextext", "aria-colindextext"),
+ Atom("aria_colspan", "aria-colspan"),
+ Atom("aria_details", "aria-details"),
+ Atom("aria_errormessage", "aria-errormessage"),
+ Atom("aria_grabbed", "aria-grabbed"),
+ Atom("aria_keyshortcuts", "aria-keyshortcuts"),
+ Atom("aria_label", "aria-label"),
+ Atom("aria_modal", "aria-modal"),
+ Atom("aria_orientation", "aria-orientation"),
+ Atom("aria_placeholder", "aria-placeholder"),
+ Atom("aria_roledescription", "aria-roledescription"),
+ Atom("aria_rowcount", "aria-rowcount"),
+ Atom("aria_rowindex", "aria-rowindex"),
+ Atom("aria_rowindextext", "aria-rowindextext"),
+ Atom("aria_rowspan", "aria-rowspan"),
+ Atom("aria_valuetext", "aria-valuetext"),
+ Atom("assertive", "assertive"),
+ Atom("auto_generated", "auto-generated"),
+ Atom("banner", "banner"),
+ Atom("checkable", "checkable"),
+ Atom("columnheader", "columnheader"),
+ Atom("complementary", "complementary"),
+ Atom("containerAtomic", "container-atomic"),
+ Atom("containerBusy", "container-busy"),
+ Atom("containerLive", "container-live"),
+ Atom("containerLiveRole", "container-live-role"),
+ Atom("containerRelevant", "container-relevant"),
+ Atom("contentinfo", "contentinfo"),
+ Atom("cycles", "cycles"),
+ Atom("datatable", "datatable"),
+ Atom("eventFromInput", "event-from-input"),
+ Atom("feed", "feed"),
+ Atom("grammar", "grammar"),
+ Atom("gridcell", "gridcell"),
+ Atom("heading", "heading"),
+ Atom("inlinevalue", "inline"),
+ Atom("inline_size", "inline-size"),
+ Atom("invalid", "invalid"),
+ Atom("lineNumber", "line-number"),
+ Atom("menuitemcheckbox", "menuitemcheckbox"),
+ Atom("menuitemradio", "menuitemradio"),
+ # Atom("mixed", "mixed"), # "mixed" is present above
+ Atom("navigation", "navigation"),
+ Atom("polite", "polite"),
+ Atom("posinset", "posinset"),
+ Atom("presentation", "presentation"),
+ Atom("progressbar", "progressbar"),
+ Atom("region", "region"),
+ Atom("rowgroup", "rowgroup"),
+ Atom("rowheader", "rowheader"),
+ Atom("search", "search"),
+ Atom("searchbox", "searchbox"),
+ Atom("setsize", "setsize"),
+ Atom("spelling", "spelling"),
+ Atom("spinbutton", "spinbutton"),
+ Atom("status", "status"),
+ Atom("tableCellIndex", "table-cell-index"),
+ Atom("tablist", "tablist"),
+ Atom("textIndent", "text-indent"),
+ Atom("textInputType", "text-input-type"),
+ Atom("textLineThroughColor", "text-line-through-color"),
+ Atom("textLineThroughStyle", "text-line-through-style"),
+ Atom("textPosition", "text-position"),
+ Atom("textUnderlineColor", "text-underline-color"),
+ Atom("textUnderlineStyle", "text-underline-style"),
+ Atom("timer", "timer"),
+ Atom("toolbarname", "toolbarname"),
+ Atom("toolbarseparator", "toolbarseparator"),
+ Atom("toolbarspacer", "toolbarspacer"),
+ Atom("toolbarspring", "toolbarspring"),
+ Atom("treegrid", "treegrid"),
+ Atom("_undefined", "undefined"),
+ Atom("xmlroles", "xml-roles"),
+ # MathML xml roles
+ Atom("close_fence", "close-fence"),
+ Atom("denominator", "denominator"),
+ Atom("numerator", "numerator"),
+ Atom("open_fence", "open-fence"),
+ Atom("overscript", "overscript"),
+ Atom("presubscript", "presubscript"),
+ Atom("presuperscript", "presuperscript"),
+ Atom("root_index", "root-index"),
+ Atom("subscript", "subscript"),
+ Atom("superscript", "superscript"),
+ Atom("underscript", "underscript"),
+ Atom("onaudiostart", "onaudiostart"),
+ Atom("onaudioend", "onaudioend"),
+ Atom("onsoundstart", "onsoundstart"),
+ Atom("onsoundend", "onsoundend"),
+ Atom("onspeechstart", "onspeechstart"),
+ Atom("onspeechend", "onspeechend"),
+ Atom("onresult", "onresult"),
+ Atom("onnomatch", "onnomatch"),
+ Atom("onresume", "onresume"),
+ Atom("onmark", "onmark"),
+ Atom("onboundary", "onboundary"),
+ # Media Controller
+ Atom("onactivated", "onactivated"),
+ Atom("ondeactivated", "ondeactivated"),
+ Atom("onmetadatachange", "onmetadatachange"),
+ Atom("onplaybackstatechange", "onplaybackstatechange"),
+ Atom("onpositionstatechange", "onpositionstatechange"),
+ Atom("onsupportedkeyschange", "onsupportedkeyschange"),
+ # media query for MathML Core's implementation of maction/semantics
+ Atom("_moz_mathml_core_maction_and_semantics", "-moz-mathml-core-maction-and-semantics"),
+ # media query for MathML Core's implementation of ms
+ Atom("_moz_mathml_core_ms", "-moz-mathml-core-ms"),
+ Atom("_moz_popover_enabled", "-moz-popover-enabled"),
+ # Contextual Identity / Containers
+ Atom("usercontextid", "usercontextid"),
+ Atom("geckoViewSessionContextId", "geckoViewSessionContextId"),
+ # Namespaces
+ Atom("nsuri_xmlns", "http://www.w3.org/2000/xmlns/"),
+ Atom("nsuri_xml", "http://www.w3.org/XML/1998/namespace"),
+ Atom("nsuri_xhtml", "http://www.w3.org/1999/xhtml"),
+ Atom("nsuri_xlink", "http://www.w3.org/1999/xlink"),
+ Atom("nsuri_xslt", "http://www.w3.org/1999/XSL/Transform"),
+ Atom("nsuri_mathml", "http://www.w3.org/1998/Math/MathML"),
+ Atom("nsuri_rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"),
+ Atom("nsuri_xul", "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"),
+ Atom("nsuri_svg", "http://www.w3.org/2000/svg"),
+ Atom("nsuri_parsererror", "http://www.mozilla.org/newlayout/xml/parsererror.xml"),
+ # MSE
+ Atom("onsourceopen", "onsourceopen"),
+ Atom("onsourceended", "onsourceended"),
+ Atom("onsourceclose", "onsourceclose"),
+ Atom("onupdatestart", "onupdatestart"),
+ Atom("onupdate", "onupdate"),
+ Atom("onupdateend", "onupdateend"),
+ Atom("onaddsourcebuffer", "onaddsourcebuffer"),
+ Atom("onremovesourcebuffer", "onremovesourcebuffer"),
+ # RDF (not used by mozilla-central, but still used by comm-central)
+ Atom("about", "about"),
+ Atom("ID", "ID"),
+ Atom("nodeID", "nodeID"),
+ Atom("aboutEach", "aboutEach"),
+ Atom("resource", "resource"),
+ Atom("RDF", "RDF"),
+ Atom("Description", "Description"),
+ Atom("Bag", "Bag"),
+ Atom("Seq", "Seq"),
+ Atom("Alt", "Alt"),
+ # Atom("kLiAtom", "li"), # "li" is present above
+ # Atom("kXMLNSAtom", "xmlns"), # "xmlns" is present above
+ Atom("parseType", "parseType"),
+ # Directory service
+ Atom("DirectoryService_CurrentProcess", "XCurProcD"),
+ Atom("DirectoryService_GRE_Directory", "GreD"),
+ Atom("DirectoryService_GRE_BinDirectory", "GreBinD"),
+ Atom("DirectoryService_OS_TemporaryDirectory", "TmpD"),
+ Atom("DirectoryService_OS_CurrentProcessDirectory", "CurProcD"),
+ Atom("DirectoryService_OS_CurrentWorkingDirectory", "CurWorkD"),
+ Atom("DirectoryService_OS_SystemConfigDir", "SysConfD"),
+ # Atom("DirectoryService_OS_HomeDirectory", "Home"), # "Home" is present above
+ Atom("DirectoryService_OS_DesktopDirectory", "Desk"),
+ Atom("DirectoryService_InitCurrentProcess_dummy", "MozBinD"),
+ Atom("DirectoryService_SystemDirectory", "SysD"),
+ Atom("DirectoryService_UserLibDirectory", "ULibDir"),
+ Atom("DirectoryService_DefaultDownloadDirectory", "DfltDwnld"),
+ Atom("DirectoryService_LocalApplicationsDirectory", "LocApp"),
+ Atom("DirectoryService_UserPreferencesDirectory", "UsrPrfs"),
+ Atom("DirectoryService_PictureDocumentsDirectory", "Pct"),
+ Atom("DirectoryService_DefaultScreenshotDirectory", "Scrnshts"),
+ Atom("DirectoryService_WindowsDirectory", "WinD"),
+ Atom("DirectoryService_WindowsProgramFiles", "ProgF"),
+ Atom("DirectoryService_Programs", "Progs"),
+ Atom("DirectoryService_Favorites", "Favs"),
+ Atom("DirectoryService_Appdata", "AppData"),
+ Atom("DirectoryService_LocalAppdata", "LocalAppData"),
+ Atom("DirectoryService_WinCookiesDirectory", "CookD"),
+ # CSS pseudo-elements -- these must appear in the same order as
+ # in nsCSSPseudoElementList.h
+ PseudoElementAtom("PseudoElement_after", ":after"),
+ PseudoElementAtom("PseudoElement_before", ":before"),
+ PseudoElementAtom("PseudoElement_marker", ":marker"),
+ PseudoElementAtom("PseudoElement_backdrop", ":backdrop"),
+ PseudoElementAtom("PseudoElement_cue", ":cue"),
+ PseudoElementAtom("PseudoElement_firstLetter", ":first-letter"),
+ PseudoElementAtom("PseudoElement_firstLine", ":first-line"),
+ PseudoElementAtom("PseudoElement_highlight", ":highlight"),
+ PseudoElementAtom("PseudoElement_selection", ":selection"),
+ PseudoElementAtom("PseudoElement_mozFocusInner", ":-moz-focus-inner"),
+ PseudoElementAtom("PseudoElement_mozNumberSpinBox", ":-moz-number-spin-box"),
+ PseudoElementAtom("PseudoElement_mozNumberSpinUp", ":-moz-number-spin-up"),
+ PseudoElementAtom("PseudoElement_mozNumberSpinDown", ":-moz-number-spin-down"),
+ PseudoElementAtom("PseudoElement_mozSearchClearButton", ":-moz-search-clear-button"),
+ PseudoElementAtom("PseudoElement_mozProgressBar", ":-moz-progress-bar"),
+ PseudoElementAtom("PseudoElement_mozRangeTrack", ":-moz-range-track"),
+ PseudoElementAtom("PseudoElement_mozRangeProgress", ":-moz-range-progress"),
+ PseudoElementAtom("PseudoElement_mozRangeThumb", ":-moz-range-thumb"),
+ PseudoElementAtom("PseudoElement_mozMeterBar", ":-moz-meter-bar"),
+ PseudoElementAtom("PseudoElement_placeholder", ":placeholder"),
+ PseudoElementAtom("PseudoElement_mozColorSwatch", ":-moz-color-swatch"),
+ PseudoElementAtom("PseudoElement_mozTextControlEditingRoot", ":-moz-text-control-editing-root"),
+ PseudoElementAtom("PseudoElement_mozTextControlPreview", ":-moz-text-control-preview"),
+ PseudoElementAtom("PseudoElement_mozReveal", ":-moz-reveal"),
+ PseudoElementAtom("PseudoElement_fileSelectorButton", ":file-selector-button"),
+ # CSS anonymous boxes -- these must appear in the same order as
+ # in nsCSSAnonBoxList.h
+ NonInheritingAnonBoxAtom("AnonBox_oofPlaceholder", ":-moz-oof-placeholder"),
+ NonInheritingAnonBoxAtom("AnonBox_horizontalFramesetBorder", ":-moz-hframeset-border"),
+ NonInheritingAnonBoxAtom("AnonBox_verticalFramesetBorder", ":-moz-vframeset-border"),
+ NonInheritingAnonBoxAtom("AnonBox_framesetBlank", ":-moz-frameset-blank"),
+ NonInheritingAnonBoxAtom("AnonBox_tableColGroup", ":-moz-table-column-group"),
+ NonInheritingAnonBoxAtom("AnonBox_tableCol", ":-moz-table-column"),
+ NonInheritingAnonBoxAtom("AnonBox_page", ":-moz-page"),
+ NonInheritingAnonBoxAtom("AnonBox_pageBreak", ":-moz-page-break"),
+ NonInheritingAnonBoxAtom("AnonBox_pageContent", ":-moz-page-content"),
+ NonInheritingAnonBoxAtom("AnonBox_printedSheet", ":-moz-printed-sheet"),
+ NonInheritingAnonBoxAtom("AnonBox_columnSpanWrapper", ":-moz-column-span-wrapper"),
+ InheritingAnonBoxAtom("AnonBox_mozText", ":-moz-text"),
+ InheritingAnonBoxAtom("AnonBox_firstLetterContinuation", ":-moz-first-letter-continuation"),
+ InheritingAnonBoxAtom("AnonBox_mozBlockInsideInlineWrapper", ":-moz-block-inside-inline-wrapper"),
+ InheritingAnonBoxAtom("AnonBox_mozMathMLAnonymousBlock", ":-moz-mathml-anonymous-block"),
+ InheritingAnonBoxAtom("AnonBox_mozLineFrame", ":-moz-line-frame"),
+ InheritingAnonBoxAtom("AnonBox_buttonContent", ":-moz-button-content"),
+ InheritingAnonBoxAtom("AnonBox_cellContent", ":-moz-cell-content"),
+ InheritingAnonBoxAtom("AnonBox_dropDownList", ":-moz-dropdown-list"),
+ InheritingAnonBoxAtom("AnonBox_fieldsetContent", ":-moz-fieldset-content"),
+ InheritingAnonBoxAtom("AnonBox_mozDisplayComboboxControlFrame", ":-moz-display-comboboxcontrol-frame"),
+ InheritingAnonBoxAtom("AnonBox_htmlCanvasContent", ":-moz-html-canvas-content"),
+ InheritingAnonBoxAtom("AnonBox_inlineTable", ":-moz-inline-table"),
+ InheritingAnonBoxAtom("AnonBox_table", ":-moz-table"),
+ InheritingAnonBoxAtom("AnonBox_tableCell", ":-moz-table-cell"),
+ InheritingAnonBoxAtom("AnonBox_tableWrapper", ":-moz-table-wrapper"),
+ InheritingAnonBoxAtom("AnonBox_tableRowGroup", ":-moz-table-row-group"),
+ InheritingAnonBoxAtom("AnonBox_tableRow", ":-moz-table-row"),
+ InheritingAnonBoxAtom("AnonBox_canvas", ":-moz-canvas"),
+ InheritingAnonBoxAtom("AnonBox_pageSequence", ":-moz-page-sequence"),
+ InheritingAnonBoxAtom("AnonBox_scrolledContent", ":-moz-scrolled-content"),
+ InheritingAnonBoxAtom("AnonBox_scrolledCanvas", ":-moz-scrolled-canvas"),
+ InheritingAnonBoxAtom("AnonBox_columnSet", ":-moz-column-set"),
+ InheritingAnonBoxAtom("AnonBox_columnContent", ":-moz-column-content"),
+ InheritingAnonBoxAtom("AnonBox_viewport", ":-moz-viewport"),
+ InheritingAnonBoxAtom("AnonBox_viewportScroll", ":-moz-viewport-scroll"),
+ InheritingAnonBoxAtom("AnonBox_anonymousItem", ":-moz-anonymous-item"),
+ InheritingAnonBoxAtom("AnonBox_blockRubyContent", ":-moz-block-ruby-content"),
+ InheritingAnonBoxAtom("AnonBox_ruby", ":-moz-ruby"),
+ InheritingAnonBoxAtom("AnonBox_rubyBase", ":-moz-ruby-base"),
+ InheritingAnonBoxAtom("AnonBox_rubyBaseContainer", ":-moz-ruby-base-container"),
+ InheritingAnonBoxAtom("AnonBox_rubyText", ":-moz-ruby-text"),
+ InheritingAnonBoxAtom("AnonBox_rubyTextContainer", ":-moz-ruby-text-container"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeColumn", ":-moz-tree-column"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeRow", ":-moz-tree-row"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeSeparator", ":-moz-tree-separator"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeCell", ":-moz-tree-cell"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeIndentation", ":-moz-tree-indentation"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeLine", ":-moz-tree-line"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeTwisty", ":-moz-tree-twisty"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeImage", ":-moz-tree-image"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeCellText", ":-moz-tree-cell-text"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeCheckbox", ":-moz-tree-checkbox"),
+ InheritingAnonBoxAtom("AnonBox_mozTreeDropFeedback", ":-moz-tree-drop-feedback"),
+ InheritingAnonBoxAtom("AnonBox_mozSVGMarkerAnonChild", ":-moz-svg-marker-anon-child"),
+ InheritingAnonBoxAtom("AnonBox_mozSVGOuterSVGAnonChild", ":-moz-svg-outer-svg-anon-child"),
+ InheritingAnonBoxAtom("AnonBox_mozSVGForeignContent", ":-moz-svg-foreign-content"),
+ InheritingAnonBoxAtom("AnonBox_mozSVGText", ":-moz-svg-text"),
+ # END ATOMS
+] + HTML_PARSER_ATOMS
+# fmt: on
+
+
+def verify():
+ idents = set()
+ strings = set()
+ failed = False
+ for atom in STATIC_ATOMS:
+ if atom.ident in idents:
+ print("StaticAtoms.py: duplicate static atom ident: %s" % atom.ident)
+ failed = True
+ if atom.string in strings:
+ print('StaticAtoms.py: duplicate static atom string: "%s"' % atom.string)
+ failed = True
+ idents.add(atom.ident)
+ strings.add(atom.string)
+ if failed:
+ sys.exit(1)
+
+
+def generate_nsgkatomlist_h(output, *ignore):
+ verify()
+ output.write(
+ "/* THIS FILE IS AUTOGENERATED BY StaticAtoms.py. DO NOT EDIT */\n\n"
+ "#ifdef small\n"
+ "#undef small\n"
+ "#endif\n\n"
+ "// GK_ATOM(identifier, string, hash, is_ascii_lower, gecko_type, atom_type)\n"
+ + "".join(
+ [
+ 'GK_ATOM(%s, "%s", 0x%08x, %s, %s, %s)\n'
+ % (
+ a.ident,
+ a.string,
+ a.hash,
+ str(a.is_ascii_lowercase).lower(),
+ a.ty,
+ a.atom_type,
+ )
+ for a in STATIC_ATOMS
+ ]
+ )
+ )
+
+
+def generate_nsgkatomconsts_h(output, *ignore):
+ pseudo_index = None
+ anon_box_index = None
+ pseudo_count = 0
+ anon_box_count = 0
+ for i, atom in enumerate(STATIC_ATOMS):
+ if atom.atom_type == "PseudoElementAtom":
+ if pseudo_index is None:
+ pseudo_index = i
+ pseudo_count += 1
+ elif (
+ atom.atom_type == "NonInheritingAnonBoxAtom"
+ or atom.atom_type == "InheritingAnonBoxAtom"
+ ):
+ if anon_box_index is None:
+ anon_box_index = i
+ anon_box_count += 1
+ output.write(
+ "/* THIS IS AN AUTOGENERATED FILE. DO NOT EDIT */\n\n"
+ "#ifndef nsGkAtomConsts_h\n"
+ "#define nsGkAtomConsts_h\n\n"
+ "namespace mozilla {\n"
+ " constexpr uint32_t kAtomIndex_PseudoElements = %d;\n"
+ " constexpr uint32_t kAtomCount_PseudoElements = %d;\n"
+ " constexpr uint32_t kAtomIndex_AnonBoxes = %d;\n"
+ " constexpr uint32_t kAtomCount_AnonBoxes = %d;\n"
+ "}\n\n"
+ "#endif\n" % (pseudo_index, pseudo_count, anon_box_index, anon_box_count)
+ )
+
+
+if __name__ == "__main__":
+ generate_nsgkatomlist_h(sys.stdout)
diff --git a/xpcom/ds/StickyTimeDuration.h b/xpcom/ds/StickyTimeDuration.h
new file mode 100644
index 0000000000..ce4e8c1e69
--- /dev/null
+++ b/xpcom/ds/StickyTimeDuration.h
@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_StickyTimeDuration_h
+#define mozilla_StickyTimeDuration_h
+
+#include <cmath>
+#include "mozilla/TimeStamp.h"
+#include "mozilla/FloatingPoint.h"
+
+namespace mozilla {
+
+/**
+ * A ValueCalculator class that performs additional checks before performing
+ * arithmetic operations such that if either operand is Forever (or the
+ * negative equivalent) the result remains Forever (or the negative equivalent
+ * as appropriate).
+ *
+ * Currently this only checks if either argument to each operation is
+ * Forever/-Forever. However, it is possible that, for example,
+ * aA + aB > INT64_MAX (or < INT64_MIN).
+ *
+ * We currently don't check for that case since we don't expect that to
+ * happen often except under test conditions in which case the wrapping
+ * behavior is probably acceptable.
+ */
+class StickyTimeDurationValueCalculator {
+ public:
+ static int64_t Add(int64_t aA, int64_t aB) {
+ MOZ_ASSERT((aA != INT64_MAX || aB != INT64_MIN) &&
+ (aA != INT64_MIN || aB != INT64_MAX),
+ "'Infinity + -Infinity' and '-Infinity + Infinity'"
+ " are undefined");
+
+ // Forever + x = Forever
+ // x + Forever = Forever
+ if (aA == INT64_MAX || aB == INT64_MAX) {
+ return INT64_MAX;
+ }
+ // -Forever + x = -Forever
+ // x + -Forever = -Forever
+ if (aA == INT64_MIN || aB == INT64_MIN) {
+ return INT64_MIN;
+ }
+
+ return aA + aB;
+ }
+
+ // Note that we can't just define Add and have BaseTimeDuration call Add with
+ // negative arguments since INT64_MAX != -INT64_MIN so the saturating logic
+ // won't work.
+ static int64_t Subtract(int64_t aA, int64_t aB) {
+ MOZ_ASSERT((aA != INT64_MAX && aA != INT64_MIN) || aA != aB,
+ "'Infinity - Infinity' and '-Infinity - -Infinity'"
+ " are undefined");
+
+ // Forever - x = Forever
+ // x - -Forever = Forever
+ if (aA == INT64_MAX || aB == INT64_MIN) {
+ return INT64_MAX;
+ }
+ // -Forever - x = -Forever
+ // x - Forever = -Forever
+ if (aA == INT64_MIN || aB == INT64_MAX) {
+ return INT64_MIN;
+ }
+
+ return aA - aB;
+ }
+
+ template <typename T>
+ static int64_t Multiply(int64_t aA, T aB) {
+ // Specializations for double, float, and int64_t are provided following.
+ return Multiply(aA, static_cast<int64_t>(aB));
+ }
+
+ static int64_t Divide(int64_t aA, int64_t aB) {
+ MOZ_ASSERT(aB != 0, "Division by zero");
+ MOZ_ASSERT((aA != INT64_MAX && aA != INT64_MIN) ||
+ (aB != INT64_MAX && aB != INT64_MIN),
+ "Dividing +/-Infinity by +/-Infinity is undefined");
+
+ // Forever / +x = Forever
+ // Forever / -x = -Forever
+ // -Forever / +x = -Forever
+ // -Forever / -x = Forever
+ if (aA == INT64_MAX || aA == INT64_MIN) {
+ return (aA >= 0) ^ (aB >= 0) ? INT64_MIN : INT64_MAX;
+ }
+ // x / Forever = 0
+ // x / -Forever = 0
+ if (aB == INT64_MAX || aB == INT64_MIN) {
+ return 0;
+ }
+
+ return aA / aB;
+ }
+
+ static double DivideDouble(int64_t aA, int64_t aB) {
+ MOZ_ASSERT(aB != 0, "Division by zero");
+ MOZ_ASSERT((aA != INT64_MAX && aA != INT64_MIN) ||
+ (aB != INT64_MAX && aB != INT64_MIN),
+ "Dividing +/-Infinity by +/-Infinity is undefined");
+
+ // Forever / +x = Forever
+ // Forever / -x = -Forever
+ // -Forever / +x = -Forever
+ // -Forever / -x = Forever
+ if (aA == INT64_MAX || aA == INT64_MIN) {
+ return (aA >= 0) ^ (aB >= 0) ? NegativeInfinity<double>()
+ : PositiveInfinity<double>();
+ }
+ // x / Forever = 0
+ // x / -Forever = 0
+ if (aB == INT64_MAX || aB == INT64_MIN) {
+ return 0.0;
+ }
+
+ return static_cast<double>(aA) / aB;
+ }
+
+ static int64_t Modulo(int64_t aA, int64_t aB) {
+ MOZ_ASSERT(aA != INT64_MAX && aA != INT64_MIN,
+ "Infinity modulo x is undefined");
+
+ return aA % aB;
+ }
+};
+
+template <>
+inline int64_t StickyTimeDurationValueCalculator::Multiply<int64_t>(
+ int64_t aA, int64_t aB) {
+ MOZ_ASSERT((aA != 0 || (aB != INT64_MIN && aB != INT64_MAX)) &&
+ ((aA != INT64_MIN && aA != INT64_MAX) || aB != 0),
+ "Multiplication of infinity by zero");
+
+ // Forever * +x = Forever
+ // Forever * -x = -Forever
+ // -Forever * +x = -Forever
+ // -Forever * -x = Forever
+ //
+ // i.e. If one or more of the arguments is +/-Forever, then
+ // return -Forever if the signs differ, or +Forever otherwise.
+ if (aA == INT64_MAX || aA == INT64_MIN || aB == INT64_MAX ||
+ aB == INT64_MIN) {
+ return (aA >= 0) ^ (aB >= 0) ? INT64_MIN : INT64_MAX;
+ }
+
+ return aA * aB;
+}
+
+template <>
+inline int64_t StickyTimeDurationValueCalculator::Multiply<double>(int64_t aA,
+ double aB) {
+ MOZ_ASSERT((aA != 0 || (!std::isinf(aB))) &&
+ ((aA != INT64_MIN && aA != INT64_MAX) || aB != 0.0),
+ "Multiplication of infinity by zero");
+
+ // As with Multiply<int64_t>, if one or more of the arguments is
+ // +/-Forever or +/-Infinity, then return -Forever if the signs differ,
+ // or +Forever otherwise.
+ if (aA == INT64_MAX || aA == INT64_MIN || std::isinf(aB)) {
+ return (aA >= 0) ^ (aB >= 0.0) ? INT64_MIN : INT64_MAX;
+ }
+
+ return aA * aB;
+}
+
+template <>
+inline int64_t StickyTimeDurationValueCalculator::Multiply<float>(int64_t aA,
+ float aB) {
+ MOZ_ASSERT(std::isinf(aB) == std::isinf(static_cast<double>(aB)),
+ "Casting to float loses infinite-ness");
+
+ return Multiply(aA, static_cast<double>(aB));
+}
+
+/**
+ * Specialization of BaseTimeDuration that uses
+ * StickyTimeDurationValueCalculator for arithmetic on the mValue member.
+ *
+ * Use this class when you need a time duration that is expected to hold values
+ * of Forever (or the negative equivalent) *and* when you expect that
+ * time duration to be used in arithmetic operations (and not just value
+ * comparisons).
+ */
+typedef BaseTimeDuration<StickyTimeDurationValueCalculator> StickyTimeDuration;
+
+// Template specializations to allow arithmetic between StickyTimeDuration
+// and TimeDuration objects by falling back to the safe behavior.
+inline StickyTimeDuration operator+(const TimeDuration& aA,
+ const StickyTimeDuration& aB) {
+ return StickyTimeDuration(aA) + aB;
+}
+inline StickyTimeDuration operator+(const StickyTimeDuration& aA,
+ const TimeDuration& aB) {
+ return aA + StickyTimeDuration(aB);
+}
+
+inline StickyTimeDuration operator-(const TimeDuration& aA,
+ const StickyTimeDuration& aB) {
+ return StickyTimeDuration(aA) - aB;
+}
+inline StickyTimeDuration operator-(const StickyTimeDuration& aA,
+ const TimeDuration& aB) {
+ return aA - StickyTimeDuration(aB);
+}
+
+inline StickyTimeDuration& operator+=(StickyTimeDuration& aA,
+ const TimeDuration& aB) {
+ return aA += StickyTimeDuration(aB);
+}
+inline StickyTimeDuration& operator-=(StickyTimeDuration& aA,
+ const TimeDuration& aB) {
+ return aA -= StickyTimeDuration(aB);
+}
+
+inline double operator/(const TimeDuration& aA, const StickyTimeDuration& aB) {
+ return StickyTimeDuration(aA) / aB;
+}
+inline double operator/(const StickyTimeDuration& aA, const TimeDuration& aB) {
+ return aA / StickyTimeDuration(aB);
+}
+
+inline StickyTimeDuration operator%(const TimeDuration& aA,
+ const StickyTimeDuration& aB) {
+ return StickyTimeDuration(aA) % aB;
+}
+inline StickyTimeDuration operator%(const StickyTimeDuration& aA,
+ const TimeDuration& aB) {
+ return aA % StickyTimeDuration(aB);
+}
+
+} // namespace mozilla
+
+#endif /* mozilla_StickyTimeDuration_h */
diff --git a/xpcom/ds/Tokenizer.cpp b/xpcom/ds/Tokenizer.cpp
new file mode 100644
index 0000000000..3b0f6b02dd
--- /dev/null
+++ b/xpcom/ds/Tokenizer.cpp
@@ -0,0 +1,805 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "Tokenizer.h"
+
+#include "nsUnicharUtils.h"
+#include <algorithm>
+
+namespace mozilla {
+
+template <>
+char const TokenizerBase<char>::sWhitespaces[] = {' ', '\t', 0};
+template <>
+char16_t const TokenizerBase<char16_t>::sWhitespaces[3] = {' ', '\t', 0};
+
+template <typename TChar>
+static bool contains(TChar const* const list, TChar const needle) {
+ for (TChar const* c = list; *c; ++c) {
+ if (needle == *c) {
+ return true;
+ }
+ }
+ return false;
+}
+
+template <typename TChar>
+TTokenizer<TChar>::TTokenizer(const typename base::TAString& aSource,
+ const TChar* aWhitespaces,
+ const TChar* aAdditionalWordChars)
+ : TokenizerBase<TChar>(aWhitespaces, aAdditionalWordChars) {
+ base::mInputFinished = true;
+ aSource.BeginReading(base::mCursor);
+ mRecord = mRollback = base::mCursor;
+ aSource.EndReading(base::mEnd);
+}
+
+template <typename TChar>
+TTokenizer<TChar>::TTokenizer(const TChar* aSource, const TChar* aWhitespaces,
+ const TChar* aAdditionalWordChars)
+ : TTokenizer(typename base::TDependentString(aSource), aWhitespaces,
+ aAdditionalWordChars) {}
+
+template <typename TChar>
+bool TTokenizer<TChar>::Next(typename base::Token& aToken) {
+ if (!base::HasInput()) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ mRollback = base::mCursor;
+ base::mCursor = base::Parse(aToken);
+
+ base::AssignFragment(aToken, mRollback, base::mCursor);
+
+ base::mPastEof = aToken.Type() == base::TOKEN_EOF;
+ base::mHasFailed = false;
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::Check(const typename base::TokenType aTokenType,
+ typename base::Token& aResult) {
+ if (!base::HasInput()) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ typename base::TAString::const_char_iterator next = base::Parse(aResult);
+ if (aTokenType != aResult.Type()) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ mRollback = base::mCursor;
+ base::mCursor = next;
+
+ base::AssignFragment(aResult, mRollback, base::mCursor);
+
+ base::mPastEof = aResult.Type() == base::TOKEN_EOF;
+ base::mHasFailed = false;
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::Check(const typename base::Token& aToken) {
+#ifdef DEBUG
+ base::Validate(aToken);
+#endif
+
+ if (!base::HasInput()) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ typename base::Token parsed;
+ typename base::TAString::const_char_iterator next = base::Parse(parsed);
+ if (!aToken.Equals(parsed)) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ mRollback = base::mCursor;
+ base::mCursor = next;
+ base::mPastEof = parsed.Type() == base::TOKEN_EOF;
+ base::mHasFailed = false;
+ return true;
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::SkipWhites(WhiteSkipping aIncludeNewLines) {
+ if (!CheckWhite() &&
+ (aIncludeNewLines == DONT_INCLUDE_NEW_LINE || !CheckEOL())) {
+ return;
+ }
+
+ typename base::TAString::const_char_iterator rollback = mRollback;
+ while (CheckWhite() || (aIncludeNewLines == INCLUDE_NEW_LINE && CheckEOL())) {
+ }
+
+ base::mHasFailed = false;
+ mRollback = rollback;
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::SkipUntil(typename base::Token const& aToken) {
+ typename base::TAString::const_char_iterator rollback = base::mCursor;
+ const typename base::Token eof = base::Token::EndOfFile();
+
+ typename base::Token t;
+ while (Next(t)) {
+ if (aToken.Equals(t) || eof.Equals(t)) {
+ Rollback();
+ break;
+ }
+ }
+
+ mRollback = rollback;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::CheckChar(bool (*aClassifier)(const TChar aChar)) {
+ if (!aClassifier) {
+ MOZ_ASSERT(false);
+ return false;
+ }
+
+ if (!base::HasInput() || base::mCursor == base::mEnd) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ if (!aClassifier(*base::mCursor)) {
+ base::mHasFailed = true;
+ return false;
+ }
+
+ mRollback = base::mCursor;
+ ++base::mCursor;
+ base::mHasFailed = false;
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::CheckPhrase(const typename base::TAString& aPhrase) {
+ if (!base::HasInput()) {
+ return false;
+ }
+
+ typedef typename base::TAString::const_char_iterator Cursor;
+
+ TTokenizer<TChar> pattern(aPhrase);
+ MOZ_ASSERT(!pattern.CheckEOF(),
+ "This will return true but won't shift the Tokenizer's cursor");
+
+ return [&](Cursor cursor, Cursor rollback) mutable {
+ while (true) {
+ if (pattern.CheckEOF()) {
+ base::mHasFailed = false;
+ mRollback = cursor;
+ return true;
+ }
+
+ typename base::Token t1, t2;
+ Unused << Next(t1);
+ Unused << pattern.Next(t2);
+ if (t1.Type() == t2.Type() && t1.Fragment().Equals(t2.Fragment())) {
+ continue;
+ }
+
+ break;
+ }
+
+ base::mHasFailed = true;
+ base::mPastEof = false;
+ base::mCursor = cursor;
+ mRollback = rollback;
+ return false;
+ }(base::mCursor, mRollback);
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadChar(TChar* aValue) {
+ MOZ_RELEASE_ASSERT(aValue);
+
+ typename base::Token t;
+ if (!Check(base::TOKEN_CHAR, t)) {
+ return false;
+ }
+
+ *aValue = t.AsChar();
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadChar(bool (*aClassifier)(const TChar aChar),
+ TChar* aValue) {
+ MOZ_RELEASE_ASSERT(aValue);
+
+ if (!CheckChar(aClassifier)) {
+ return false;
+ }
+
+ *aValue = *mRollback;
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadWord(typename base::TAString& aValue) {
+ typename base::Token t;
+ if (!Check(base::TOKEN_WORD, t)) {
+ return false;
+ }
+
+ aValue.Assign(t.AsString());
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadWord(typename base::TDependentSubstring& aValue) {
+ typename base::Token t;
+ if (!Check(base::TOKEN_WORD, t)) {
+ return false;
+ }
+
+ aValue.Rebind(t.AsString().BeginReading(), t.AsString().Length());
+ return true;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadUntil(typename base::Token const& aToken,
+ typename base::TAString& aResult,
+ ClaimInclusion aInclude) {
+ typename base::TDependentSubstring substring;
+ bool rv = ReadUntil(aToken, substring, aInclude);
+ aResult.Assign(substring);
+ return rv;
+}
+
+template <typename TChar>
+bool TTokenizer<TChar>::ReadUntil(typename base::Token const& aToken,
+ typename base::TDependentSubstring& aResult,
+ ClaimInclusion aInclude) {
+ typename base::TAString::const_char_iterator record = mRecord;
+ Record();
+ typename base::TAString::const_char_iterator rollback = mRollback =
+ base::mCursor;
+
+ bool found = false;
+ typename base::Token t;
+ while (Next(t)) {
+ if (aToken.Equals(t)) {
+ found = true;
+ break;
+ }
+ if (t.Equals(base::Token::EndOfFile())) {
+ // We don't want to eat it.
+ Rollback();
+ break;
+ }
+ }
+
+ Claim(aResult, aInclude);
+ mRollback = rollback;
+ mRecord = record;
+ return found;
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::Rollback() {
+ MOZ_ASSERT(base::mCursor > mRollback || base::mPastEof, "TODO!!!");
+
+ base::mPastEof = false;
+ base::mHasFailed = false;
+ base::mCursor = mRollback;
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::Record(ClaimInclusion aInclude) {
+ mRecord = aInclude == INCLUDE_LAST ? mRollback : base::mCursor;
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::Claim(typename base::TAString& aResult,
+ ClaimInclusion aInclusion) {
+ typename base::TAString::const_char_iterator close =
+ aInclusion == EXCLUDE_LAST ? mRollback : base::mCursor;
+ aResult.Assign(Substring(mRecord, close));
+}
+
+template <typename TChar>
+void TTokenizer<TChar>::Claim(typename base::TDependentSubstring& aResult,
+ ClaimInclusion aInclusion) {
+ typename base::TAString::const_char_iterator close =
+ aInclusion == EXCLUDE_LAST ? mRollback : base::mCursor;
+
+ MOZ_RELEASE_ASSERT(close >= mRecord, "Overflow!");
+ aResult.Rebind(mRecord, close - mRecord);
+}
+
+// TokenizerBase
+
+template <typename TChar>
+TokenizerBase<TChar>::TokenizerBase(const TChar* aWhitespaces,
+ const TChar* aAdditionalWordChars)
+ : mPastEof(false),
+ mHasFailed(false),
+ mInputFinished(true),
+ mMode(Mode::FULL),
+ mMinRawDelivery(1024),
+ mWhitespaces(aWhitespaces ? aWhitespaces : sWhitespaces),
+ mAdditionalWordChars(aAdditionalWordChars),
+ mCursor(nullptr),
+ mEnd(nullptr),
+ mNextCustomTokenID(TOKEN_CUSTOM0) {}
+
+template <typename TChar>
+auto TokenizerBase<TChar>::AddCustomToken(const TAString& aValue,
+ ECaseSensitivity aCaseInsensitivity,
+ bool aEnabled) -> Token {
+ MOZ_ASSERT(!aValue.IsEmpty());
+
+ UniquePtr<Token>& t = *mCustomTokens.AppendElement();
+ t = MakeUnique<Token>();
+
+ t->mType = static_cast<TokenType>(++mNextCustomTokenID);
+ t->mCustomCaseInsensitivity = aCaseInsensitivity;
+ t->mCustomEnabled = aEnabled;
+ t->mCustom.Assign(aValue);
+ return *t;
+}
+
+template <typename TChar>
+void TokenizerBase<TChar>::RemoveCustomToken(Token& aToken) {
+ if (aToken.mType == TOKEN_UNKNOWN) {
+ // Already removed
+ return;
+ }
+
+ for (UniquePtr<Token> const& custom : mCustomTokens) {
+ if (custom->mType == aToken.mType) {
+ mCustomTokens.RemoveElement(custom);
+ aToken.mType = TOKEN_UNKNOWN;
+ return;
+ }
+ }
+
+ MOZ_ASSERT(false, "Token to remove not found");
+}
+
+template <typename TChar>
+void TokenizerBase<TChar>::EnableCustomToken(Token const& aToken,
+ bool aEnabled) {
+ if (aToken.mType == TOKEN_UNKNOWN) {
+ // Already removed
+ return;
+ }
+
+ for (UniquePtr<Token> const& custom : mCustomTokens) {
+ if (custom->Type() == aToken.Type()) {
+ // This effectively destroys the token instance.
+ custom->mCustomEnabled = aEnabled;
+ return;
+ }
+ }
+
+ MOZ_ASSERT(false, "Token to change not found");
+}
+
+template <typename TChar>
+void TokenizerBase<TChar>::SetTokenizingMode(Mode aMode) {
+ mMode = aMode;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::HasFailed() const {
+ return mHasFailed;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::HasInput() const {
+ return !mPastEof;
+}
+
+template <typename TChar>
+auto TokenizerBase<TChar>::Parse(Token& aToken) const ->
+ typename TAString::const_char_iterator {
+ if (mCursor == mEnd) {
+ if (!mInputFinished) {
+ return mCursor;
+ }
+
+ aToken = Token::EndOfFile();
+ return mEnd;
+ }
+
+ MOZ_RELEASE_ASSERT(mEnd >= mCursor, "Overflow!");
+ typename TAString::size_type available = mEnd - mCursor;
+
+ uint32_t longestCustom = 0;
+ for (UniquePtr<Token> const& custom : mCustomTokens) {
+ if (IsCustom(mCursor, *custom, &longestCustom)) {
+ aToken = *custom;
+ return mCursor + custom->mCustom.Length();
+ }
+ }
+
+ if (!mInputFinished && available < longestCustom) {
+ // Not enough data to deterministically decide.
+ return mCursor;
+ }
+
+ typename TAString::const_char_iterator next = mCursor;
+
+ if (mMode == Mode::CUSTOM_ONLY) {
+ // We have to do a brute-force search for all of the enabled custom
+ // tokens.
+ while (next < mEnd) {
+ ++next;
+ for (UniquePtr<Token> const& custom : mCustomTokens) {
+ if (IsCustom(next, *custom)) {
+ aToken = Token::Raw();
+ return next;
+ }
+ }
+ }
+
+ if (mInputFinished) {
+ // End of the data reached.
+ aToken = Token::Raw();
+ return next;
+ }
+
+ if (longestCustom < available && available > mMinRawDelivery) {
+ // We can return some data w/o waiting for either a custom token
+ // or call to FinishData() when we leave the tail where all the
+ // custom tokens potentially fit, so we can't lose only partially
+ // delivered tokens. This preserves reasonable granularity.
+ aToken = Token::Raw();
+ return mEnd - longestCustom + 1;
+ }
+
+ // Not enough data to deterministically decide.
+ return mCursor;
+ }
+
+ enum State {
+ PARSE_INTEGER,
+ PARSE_WORD,
+ PARSE_CRLF,
+ PARSE_LF,
+ PARSE_WS,
+ PARSE_CHAR,
+ } state;
+
+ if (IsWordFirst(*next)) {
+ state = PARSE_WORD;
+ } else if (IsNumber(*next)) {
+ state = PARSE_INTEGER;
+ } else if (contains(mWhitespaces, *next)) { // not UTF-8 friendly?
+ state = PARSE_WS;
+ } else if (*next == '\r') {
+ state = PARSE_CRLF;
+ } else if (*next == '\n') {
+ state = PARSE_LF;
+ } else {
+ state = PARSE_CHAR;
+ }
+
+ mozilla::CheckedUint64 resultingNumber = 0;
+
+ while (next < mEnd) {
+ switch (state) {
+ case PARSE_INTEGER:
+ // Keep it simple for now
+ resultingNumber *= 10;
+ resultingNumber += static_cast<uint64_t>(*next - '0');
+
+ ++next;
+ if (IsPending(next)) {
+ break;
+ }
+ if (IsEnd(next) || !IsNumber(*next)) {
+ if (!resultingNumber.isValid()) {
+ aToken = Token::Error();
+ } else {
+ aToken = Token::Number(resultingNumber.value());
+ }
+ return next;
+ }
+ break;
+
+ case PARSE_WORD:
+ ++next;
+ if (IsPending(next)) {
+ break;
+ }
+ if (IsEnd(next) || !IsWord(*next)) {
+ aToken = Token::Word(Substring(mCursor, next));
+ return next;
+ }
+ break;
+
+ case PARSE_CRLF:
+ ++next;
+ if (IsPending(next)) {
+ break;
+ }
+ if (!IsEnd(next) && *next == '\n') { // LF is optional
+ ++next;
+ }
+ aToken = Token::NewLine();
+ return next;
+
+ case PARSE_LF:
+ ++next;
+ aToken = Token::NewLine();
+ return next;
+
+ case PARSE_WS:
+ ++next;
+ aToken = Token::Whitespace();
+ return next;
+
+ case PARSE_CHAR:
+ ++next;
+ aToken = Token::Char(*mCursor);
+ return next;
+ } // switch (state)
+ } // while (next < end)
+
+ MOZ_ASSERT(!mInputFinished);
+ return mCursor;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsEnd(
+ const typename TAString::const_char_iterator& caret) const {
+ return caret == mEnd;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsPending(
+ const typename TAString::const_char_iterator& caret) const {
+ return IsEnd(caret) && !mInputFinished;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsWordFirst(const TChar aInput) const {
+ // TODO: make this fully work with unicode
+ return (ToLowerCase(static_cast<uint32_t>(aInput)) !=
+ ToUpperCase(static_cast<uint32_t>(aInput))) ||
+ '_' == aInput ||
+ (mAdditionalWordChars ? contains(mAdditionalWordChars, aInput)
+ : false);
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsWord(const TChar aInput) const {
+ return IsWordFirst(aInput) || IsNumber(aInput);
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsNumber(const TChar aInput) const {
+ // TODO: are there unicode numbers?
+ return aInput >= '0' && aInput <= '9';
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::IsCustom(
+ const typename TAString::const_char_iterator& caret,
+ const Token& aCustomToken, uint32_t* aLongest) const {
+ MOZ_ASSERT(aCustomToken.mType > TOKEN_CUSTOM0);
+ if (!aCustomToken.mCustomEnabled) {
+ return false;
+ }
+
+ if (aLongest) {
+ *aLongest = std::max<uint32_t>(*aLongest, aCustomToken.mCustom.Length());
+ }
+
+ // This is not very likely to happen according to how we call this method
+ // and since it's on a hot path, it's just a diagnostic assert,
+ // not a release assert.
+ MOZ_DIAGNOSTIC_ASSERT(mEnd >= caret, "Overflow?");
+ uint32_t inputLength = mEnd - caret;
+ if (aCustomToken.mCustom.Length() > inputLength) {
+ return false;
+ }
+
+ TDependentSubstring inputFragment(caret, aCustomToken.mCustom.Length());
+ if (aCustomToken.mCustomCaseInsensitivity == CASE_INSENSITIVE) {
+ if constexpr (std::is_same_v<TChar, char>) {
+ return inputFragment.Equals(aCustomToken.mCustom,
+ nsCaseInsensitiveUTF8StringComparator);
+ } else {
+ return inputFragment.Equals(aCustomToken.mCustom,
+ nsCaseInsensitiveStringComparator);
+ }
+ }
+ return inputFragment.Equals(aCustomToken.mCustom);
+}
+
+template <typename TChar>
+void TokenizerBase<TChar>::AssignFragment(
+ Token& aToken, typename TAString::const_char_iterator begin,
+ typename TAString::const_char_iterator end) {
+ aToken.AssignFragment(begin, end);
+}
+
+#ifdef DEBUG
+
+template <typename TChar>
+void TokenizerBase<TChar>::Validate(Token const& aToken) {
+ if (aToken.Type() == TOKEN_WORD) {
+ typename TAString::const_char_iterator c = aToken.AsString().BeginReading();
+ typename TAString::const_char_iterator e = aToken.AsString().EndReading();
+
+ if (c < e) {
+ MOZ_ASSERT(IsWordFirst(*c));
+ while (++c < e) {
+ MOZ_ASSERT(IsWord(*c));
+ }
+ }
+ }
+}
+
+#endif
+
+// TokenizerBase::Token
+
+template <typename TChar>
+TokenizerBase<TChar>::Token::Token()
+ : mType(TOKEN_UNKNOWN),
+ mChar(0),
+ mInteger(0),
+ mCustomCaseInsensitivity(CASE_SENSITIVE),
+ mCustomEnabled(false) {}
+
+template <typename TChar>
+TokenizerBase<TChar>::Token::Token(const Token& aOther)
+ : mType(aOther.mType),
+ mCustom(aOther.mCustom),
+ mChar(aOther.mChar),
+ mInteger(aOther.mInteger),
+ mCustomCaseInsensitivity(aOther.mCustomCaseInsensitivity),
+ mCustomEnabled(aOther.mCustomEnabled) {
+ if (mType == TOKEN_WORD || mType > TOKEN_CUSTOM0) {
+ mWord.Rebind(aOther.mWord.BeginReading(), aOther.mWord.Length());
+ }
+}
+
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::operator=(const Token& aOther) -> Token& {
+ mType = aOther.mType;
+ mCustom = aOther.mCustom;
+ mChar = aOther.mChar;
+ mWord.Rebind(aOther.mWord.BeginReading(), aOther.mWord.Length());
+ mInteger = aOther.mInteger;
+ mCustomCaseInsensitivity = aOther.mCustomCaseInsensitivity;
+ mCustomEnabled = aOther.mCustomEnabled;
+ return *this;
+}
+
+template <typename TChar>
+void TokenizerBase<TChar>::Token::AssignFragment(
+ typename TAString::const_char_iterator begin,
+ typename TAString::const_char_iterator end) {
+ MOZ_RELEASE_ASSERT(end >= begin, "Overflow!");
+ mFragment.Rebind(begin, end - begin);
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Raw() -> Token {
+ Token t;
+ t.mType = TOKEN_RAW;
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Word(TAString const& aValue) -> Token {
+ Token t;
+ t.mType = TOKEN_WORD;
+ t.mWord.Rebind(aValue.BeginReading(), aValue.Length());
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Char(TChar const aValue) -> Token {
+ Token t;
+ t.mType = TOKEN_CHAR;
+ t.mChar = aValue;
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Number(uint64_t const aValue) -> Token {
+ Token t;
+ t.mType = TOKEN_INTEGER;
+ t.mInteger = aValue;
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Whitespace() -> Token {
+ Token t;
+ t.mType = TOKEN_WS;
+ t.mChar = '\0';
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::NewLine() -> Token {
+ Token t;
+ t.mType = TOKEN_EOL;
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::EndOfFile() -> Token {
+ Token t;
+ t.mType = TOKEN_EOF;
+ return t;
+}
+
+// static
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::Error() -> Token {
+ Token t;
+ t.mType = TOKEN_ERROR;
+ return t;
+}
+
+template <typename TChar>
+bool TokenizerBase<TChar>::Token::Equals(const Token& aOther) const {
+ if (mType != aOther.mType) {
+ return false;
+ }
+
+ switch (mType) {
+ case TOKEN_INTEGER:
+ return AsInteger() == aOther.AsInteger();
+ case TOKEN_WORD:
+ return AsString() == aOther.AsString();
+ case TOKEN_CHAR:
+ return AsChar() == aOther.AsChar();
+ default:
+ return true;
+ }
+}
+
+template <typename TChar>
+TChar TokenizerBase<TChar>::Token::AsChar() const {
+ MOZ_ASSERT(mType == TOKEN_CHAR || mType == TOKEN_WS);
+ return mChar;
+}
+
+template <typename TChar>
+auto TokenizerBase<TChar>::Token::AsString() const -> TDependentSubstring {
+ MOZ_ASSERT(mType == TOKEN_WORD);
+ return mWord;
+}
+
+template <typename TChar>
+uint64_t TokenizerBase<TChar>::Token::AsInteger() const {
+ MOZ_ASSERT(mType == TOKEN_INTEGER);
+ return mInteger;
+}
+
+template class TokenizerBase<char>;
+template class TokenizerBase<char16_t>;
+
+template class TTokenizer<char>;
+template class TTokenizer<char16_t>;
+
+} // namespace mozilla
diff --git a/xpcom/ds/Tokenizer.h b/xpcom/ds/Tokenizer.h
new file mode 100644
index 0000000000..713b63f269
--- /dev/null
+++ b/xpcom/ds/Tokenizer.h
@@ -0,0 +1,524 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef Tokenizer_h__
+#define Tokenizer_h__
+
+#include <type_traits>
+
+#include "nsString.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/UniquePtr.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+
+template <typename TChar>
+class TokenizerBase {
+ public:
+ typedef nsTSubstring<TChar> TAString;
+ typedef nsTString<TChar> TString;
+ typedef nsTDependentString<TChar> TDependentString;
+ typedef nsTDependentSubstring<TChar> TDependentSubstring;
+
+ static TChar const sWhitespaces[];
+
+ /**
+ * The analyzer works with elements in the input cut to a sequence of token
+ * where each token has an elementary type
+ */
+ enum TokenType : uint32_t {
+ TOKEN_UNKNOWN,
+ TOKEN_RAW,
+ TOKEN_ERROR,
+ TOKEN_INTEGER,
+ TOKEN_WORD,
+ TOKEN_CHAR,
+ TOKEN_WS,
+ TOKEN_EOL,
+ TOKEN_EOF,
+ TOKEN_CUSTOM0 = 1000
+ };
+
+ enum ECaseSensitivity { CASE_SENSITIVE, CASE_INSENSITIVE };
+
+ /**
+ * Class holding the type and the value of a token. It can be manually
+ * created to allow checks against it via methods of TTokenizer or are results
+ * of some of the TTokenizer's methods.
+ */
+ class Token {
+ TokenType mType;
+ TDependentSubstring mWord;
+ TString mCustom;
+ TChar mChar;
+ uint64_t mInteger;
+ ECaseSensitivity mCustomCaseInsensitivity;
+ bool mCustomEnabled;
+
+ // If this token is a result of the parsing process, this member is
+ // referencing a sub-string in the input buffer. If this is externally
+ // created Token this member is left an empty string.
+ TDependentSubstring mFragment;
+
+ friend class TokenizerBase<TChar>;
+ void AssignFragment(typename TAString::const_char_iterator begin,
+ typename TAString::const_char_iterator end);
+
+ static Token Raw();
+
+ public:
+ Token();
+ Token(const Token& aOther);
+ Token& operator=(const Token& aOther);
+
+ // Static constructors of tokens by type and value
+ static Token Word(TAString const& aWord);
+ static Token Char(TChar const aChar);
+ static Token Number(uint64_t const aNumber);
+ static Token Whitespace();
+ static Token NewLine();
+ static Token EndOfFile();
+ static Token Error();
+
+ // Compares the two tokens, type must be identical and value
+ // of one of the tokens must be 'any' or equal.
+ bool Equals(const Token& aOther) const;
+
+ TokenType Type() const { return mType; }
+ TChar AsChar() const;
+ TDependentSubstring AsString() const;
+ uint64_t AsInteger() const;
+
+ TDependentSubstring Fragment() const { return mFragment; }
+ };
+
+ /**
+ * Consumers may register a custom string that, when found in the input, is
+ * considered a token and returned by Next*() and accepted by Check*()
+ * methods. AddCustomToken() returns a reference to a token that can then be
+ * comapred using Token::Equals() againts the output from Next*() or be passed
+ * to Check*().
+ */
+ Token AddCustomToken(const TAString& aValue,
+ ECaseSensitivity aCaseInsensitivity,
+ bool aEnabled = true);
+ template <uint32_t N>
+ Token AddCustomToken(const TChar (&aValue)[N],
+ ECaseSensitivity aCaseInsensitivity,
+ bool aEnabled = true) {
+ return AddCustomToken(TDependentSubstring(aValue, N - 1),
+ aCaseInsensitivity, aEnabled);
+ }
+ void RemoveCustomToken(Token& aToken);
+ /**
+ * Only applies to a custom type of a Token (see AddCustomToken above.)
+ * This turns on and off token recognition. When a custom token is disabled,
+ * it's ignored as never added as a custom token.
+ */
+ void EnableCustomToken(Token const& aToken, bool aEnable);
+
+ /**
+ * Mode of tokenization.
+ * FULL tokenization, the default, recognizes built-in tokens and any custom
+ * tokens, if added. CUSTOM_ONLY will only recognize custom tokens, the rest
+ * is seen as 'raw'. This mode can be understood as a 'binary' mode.
+ */
+ enum class Mode { FULL, CUSTOM_ONLY };
+ void SetTokenizingMode(Mode aMode);
+
+ /**
+ * Return false iff the last Check*() call has returned false or when we've
+ * read past the end of the input string.
+ */
+ [[nodiscard]] bool HasFailed() const;
+
+ protected:
+ explicit TokenizerBase(const TChar* aWhitespaces = nullptr,
+ const TChar* aAdditionalWordChars = nullptr);
+
+ // false if we have already read the EOF token.
+ bool HasInput() const;
+ // Main parsing function, it doesn't shift the read cursor, just returns the
+ // next token position.
+ typename TAString::const_char_iterator Parse(Token& aToken) const;
+ // Is read cursor at the end?
+ bool IsEnd(const typename TAString::const_char_iterator& caret) const;
+ // True, when we are at the end of the input data, but it has not been marked
+ // as complete yet. In that case we cannot proceed with providing a
+ // multi-TChar token.
+ bool IsPending(const typename TAString::const_char_iterator& caret) const;
+ // Is read cursor on a character that is a word start?
+ bool IsWordFirst(const TChar aInput) const;
+ // Is read cursor on a character that is an in-word letter?
+ bool IsWord(const TChar aInput) const;
+ // Is read cursor on a character that is a valid number?
+ // TODO - support multiple radix
+ bool IsNumber(const TChar aInput) const;
+ // Is equal to the given custom token?
+ bool IsCustom(const typename TAString::const_char_iterator& caret,
+ const Token& aCustomToken, uint32_t* aLongest = nullptr) const;
+
+ // Friendly helper to assign a fragment on a Token
+ static void AssignFragment(Token& aToken,
+ typename TAString::const_char_iterator begin,
+ typename TAString::const_char_iterator end);
+
+#ifdef DEBUG
+ // This is called from inside Tokenizer methods to make sure the token is
+ // valid.
+ void Validate(Token const& aToken);
+#endif
+
+ // true iff we have already read the EOF token
+ bool mPastEof;
+ // true iff the last Check*() call has returned false, reverts to true on
+ // Rollback() call
+ bool mHasFailed;
+ // true if the input string is final (finished), false when we expect more
+ // data yet to be fed to the tokenizer (see IncrementalTokenizer derived
+ // class).
+ bool mInputFinished;
+ // custom only vs full tokenizing mode, see the Parse() method
+ Mode mMode;
+ // minimal raw data chunked delivery during incremental feed
+ uint32_t mMinRawDelivery;
+
+ // Customizable list of whitespaces
+ const TChar* mWhitespaces;
+ // Additinal custom word characters
+ const TChar* mAdditionalWordChars;
+
+ // All these point to the original buffer passed to the constructor or to the
+ // incremental buffer after FeedInput.
+ typename TAString::const_char_iterator
+ mCursor; // Position of the current (actually next to read) token start
+ typename TAString::const_char_iterator mEnd; // End of the input position
+
+ // This is the list of tokens user has registered with AddCustomToken()
+ nsTArray<UniquePtr<Token>> mCustomTokens;
+ uint32_t mNextCustomTokenID;
+
+ private:
+ TokenizerBase() = delete;
+ TokenizerBase(const TokenizerBase&) = delete;
+ TokenizerBase(TokenizerBase&&) = delete;
+ TokenizerBase(const TokenizerBase&&) = delete;
+ TokenizerBase& operator=(const TokenizerBase&) = delete;
+};
+
+/**
+ * This is a simple implementation of a lexical analyzer or maybe better
+ * called a tokenizer.
+ *
+ * Please use Tokenizer or Tokenizer16 classes, that are specializations
+ * of this template class. Tokenizer is for ASCII input, Tokenizer16 may
+ * handle char16_t input, but doesn't recognize whitespaces or numbers
+ * other than standard `char` specialized Tokenizer class.
+ */
+template <typename TChar>
+class TTokenizer : public TokenizerBase<TChar> {
+ public:
+ typedef TokenizerBase<TChar> base;
+
+ /**
+ * @param aSource
+ * The string to parse.
+ * IMPORTANT NOTE: TTokenizer doesn't ensure the input string buffer
+ * lifetime. It's up to the consumer to make sure the string's buffer outlives
+ * the TTokenizer!
+ * @param aWhitespaces
+ * If non-null TTokenizer will use this custom set of whitespaces for
+ * CheckWhite() and SkipWhites() calls. By default the list consists of space
+ * and tab.
+ * @param aAdditionalWordChars
+ * If non-null it will be added to the list of characters that consist a
+ * word. This is useful when you want to accept e.g. '-' in HTTP headers. By
+ * default a word character is consider any character for which upper case
+ * is different from lower case.
+ *
+ * If there is an overlap between aWhitespaces and aAdditionalWordChars, the
+ * check for word characters is made first.
+ */
+ explicit TTokenizer(const typename base::TAString& aSource,
+ const TChar* aWhitespaces = nullptr,
+ const TChar* aAdditionalWordChars = nullptr);
+ explicit TTokenizer(const TChar* aSource, const TChar* aWhitespaces = nullptr,
+ const TChar* aAdditionalWordChars = nullptr);
+
+ /**
+ * When there is still anything to read from the input, tokenize it, store the
+ * token type and value to aToken result and shift the cursor past this just
+ * parsed token. Each call to Next() reads another token from the input and
+ * shifts the cursor. Returns false if we have passed the end of the input.
+ */
+ [[nodiscard]] bool Next(typename base::Token& aToken);
+
+ /**
+ * Parse the token on the input read cursor position, check its type is equal
+ * to aTokenType and if so, put it into aResult, shift the cursor and return
+ * true. Otherwise, leave the input read cursor position intact and return
+ * false.
+ */
+ [[nodiscard]] bool Check(const typename base::TokenType aTokenType,
+ typename base::Token& aResult);
+ /**
+ * Same as above method, just compares both token type and token value passed
+ * in aToken. When both the type and the value equals, shift the cursor and
+ * return true. Otherwise return false.
+ */
+ [[nodiscard]] bool Check(const typename base::Token& aToken);
+
+ /**
+ * SkipWhites method (below) may also skip new line characters automatically.
+ */
+ enum WhiteSkipping {
+ /**
+ * SkipWhites will only skip what is defined as a white space (default).
+ */
+ DONT_INCLUDE_NEW_LINE = 0,
+ /**
+ * SkipWhites will skip definited white spaces as well as new lines
+ * automatically.
+ */
+ INCLUDE_NEW_LINE = 1
+ };
+
+ /**
+ * Skips any occurence of whitespaces specified in mWhitespaces member,
+ * optionally skip also new lines.
+ */
+ void SkipWhites(WhiteSkipping aIncludeNewLines = DONT_INCLUDE_NEW_LINE);
+
+ /**
+ * Skips all tokens until the given one is found or EOF is hit. The token
+ * or EOF are next to read.
+ */
+ void SkipUntil(typename base::Token const& aToken);
+
+ // These are mostly shortcuts for the Check() methods above.
+
+ /**
+ * Check whitespace character is present.
+ */
+ [[nodiscard]] bool CheckWhite() { return Check(base::Token::Whitespace()); }
+ /**
+ * Check there is a single character on the read cursor position. If so,
+ * shift the read cursor position and return true. Otherwise false.
+ */
+ [[nodiscard]] bool CheckChar(const TChar aChar) {
+ return Check(base::Token::Char(aChar));
+ }
+ /**
+ * This is a customizable version of CheckChar. aClassifier is a function
+ * called with value of the character on the current input read position. If
+ * this user function returns true, read cursor is shifted and true returned.
+ * Otherwise false. The user classifiction function is not called when we are
+ * at or past the end and false is immediately returned.
+ */
+ [[nodiscard]] bool CheckChar(bool (*aClassifier)(const TChar aChar));
+ /**
+ * Check for a whole expected word.
+ */
+ [[nodiscard]] bool CheckWord(const typename base::TAString& aWord) {
+ return Check(base::Token::Word(aWord));
+ }
+ /**
+ * Shortcut for literal const word check with compile time length calculation.
+ */
+ template <uint32_t N>
+ [[nodiscard]] bool CheckWord(const TChar (&aWord)[N]) {
+ return Check(
+ base::Token::Word(typename base::TDependentString(aWord, N - 1)));
+ }
+ /**
+ * Helper to check for a string compound of multiple tokens like "foo bar".
+ * The match is binary-exact, a white space or a delimiter character in the
+ * phrase must match exactly the characters in the input.
+ */
+ [[nodiscard]] bool CheckPhrase(const typename base::TAString& aPhrase);
+ template <uint32_t N>
+ [[nodiscard]] bool CheckPhrase(const TChar (&aPhrase)[N]) {
+ return CheckPhrase(typename base::TDependentString(aPhrase, N - 1));
+ }
+ /**
+ * Checks \r, \n or \r\n.
+ */
+ [[nodiscard]] bool CheckEOL() { return Check(base::Token::NewLine()); }
+ /**
+ * Checks we are at the end of the input string reading. If so, shift past
+ * the end and returns true. Otherwise does nothing and returns false.
+ */
+ [[nodiscard]] bool CheckEOF() { return Check(base::Token::EndOfFile()); }
+
+ /**
+ * These are shortcuts to obtain the value immediately when the token type
+ * matches.
+ */
+ [[nodiscard]] bool ReadChar(TChar* aValue);
+ [[nodiscard]] bool ReadChar(bool (*aClassifier)(const TChar aChar),
+ TChar* aValue);
+ [[nodiscard]] bool ReadWord(typename base::TAString& aValue);
+ [[nodiscard]] bool ReadWord(typename base::TDependentSubstring& aValue);
+
+ /**
+ * This is an integer read helper. It returns false and doesn't move the read
+ * cursor when any of the following happens:
+ * - the token at the read cursor is not an integer
+ * - the final number doesn't fit the T type
+ * Otherwise true is returned, aValue is filled with the integral number
+ * and the cursor is moved forward.
+ */
+ template <typename T>
+ [[nodiscard]] bool ReadInteger(T* aValue) {
+ MOZ_RELEASE_ASSERT(aValue);
+
+ typename base::TAString::const_char_iterator rollback = mRollback;
+ typename base::TAString::const_char_iterator cursor = base::mCursor;
+ typename base::Token t;
+ if (!Check(base::TOKEN_INTEGER, t)) {
+ return false;
+ }
+
+ mozilla::CheckedInt<T> checked(t.AsInteger());
+ if (!checked.isValid()) {
+ // Move to a state as if Check() call has failed
+ mRollback = rollback;
+ base::mCursor = cursor;
+ base::mHasFailed = true;
+ return false;
+ }
+
+ *aValue = checked.value();
+ return true;
+ }
+
+ /**
+ * Same as above, but accepts an integer with an optional minus sign.
+ */
+ template <typename T, typename V = std::enable_if_t<
+ std::is_signed_v<std::remove_pointer_t<T>>,
+ std::remove_pointer_t<T>>>
+ [[nodiscard]] bool ReadSignedInteger(T* aValue) {
+ MOZ_RELEASE_ASSERT(aValue);
+
+ typename base::TAString::const_char_iterator rollback = mRollback;
+ typename base::TAString::const_char_iterator cursor = base::mCursor;
+ auto revert = MakeScopeExit([&] {
+ // Move to a state as if Check() call has failed
+ mRollback = rollback;
+ base::mCursor = cursor;
+ base::mHasFailed = true;
+ });
+
+ // Using functional raw access because '-' could be part of the word set
+ // making CheckChar('-') not work.
+ bool minus = CheckChar([](const TChar aChar) { return aChar == '-'; });
+
+ typename base::Token t;
+ if (!Check(base::TOKEN_INTEGER, t)) {
+ return false;
+ }
+
+ mozilla::CheckedInt<T> checked(t.AsInteger());
+ if (minus) {
+ checked *= -1;
+ }
+
+ if (!checked.isValid()) {
+ return false;
+ }
+
+ *aValue = checked.value();
+ revert.release();
+ return true;
+ }
+
+ /**
+ * Returns the read cursor position back as it was before the last call of any
+ * parsing method of TTokenizer (Next, Check*, Skip*, Read*) so that the last
+ * operation can be repeated. Rollback cannot be used multiple times, it only
+ * reverts the last successfull parse operation. It also cannot be used
+ * before any parsing operation has been called on the TTokenizer.
+ */
+ void Rollback();
+
+ /**
+ * Record() and Claim() are collecting the input as it is being parsed to
+ * obtain a substring between particular syntax bounderies defined by any
+ * recursive descent parser or simple parser the TTokenizer is used to read
+ * the input for. Inlucsion of a token that has just been parsed can be
+ * controlled using an arguemnt.
+ */
+ enum ClaimInclusion {
+ /**
+ * Include resulting (or passed) token of the last lexical analyzer
+ * operation in the result.
+ */
+ INCLUDE_LAST,
+ /**
+ * Do not include it.
+ */
+ EXCLUDE_LAST
+ };
+
+ /**
+ * Start the process of recording. Based on aInclude value the begining of
+ * the recorded sub-string is at the current position (EXCLUDE_LAST) or at the
+ * position before the last parsed token (INCLUDE_LAST).
+ */
+ void Record(ClaimInclusion aInclude = EXCLUDE_LAST);
+ /**
+ * Claim result of the record started with Record() call before. Depending on
+ * aInclude the ending of the sub-string result includes or excludes the last
+ * parsed or checked token.
+ */
+ void Claim(typename base::TAString& aResult,
+ ClaimInclusion aInclude = EXCLUDE_LAST);
+ void Claim(typename base::TDependentSubstring& aResult,
+ ClaimInclusion aInclude = EXCLUDE_LAST);
+
+ /**
+ * If aToken is found, aResult is set to the substring between the current
+ * position and the position of aToken, potentially including aToken depending
+ * on aInclude.
+ * If aToken isn't found aResult is set to the substring between the current
+ * position and the end of the string.
+ * If aToken is found, the method returns true. Otherwise it returns false.
+ *
+ * Calling Rollback() after ReadUntil() will return the read cursor to the
+ * position it had before ReadUntil was called.
+ */
+ [[nodiscard]] bool ReadUntil(typename base::Token const& aToken,
+ typename base::TDependentSubstring& aResult,
+ ClaimInclusion aInclude = EXCLUDE_LAST);
+ [[nodiscard]] bool ReadUntil(typename base::Token const& aToken,
+ typename base::TAString& aResult,
+ ClaimInclusion aInclude = EXCLUDE_LAST);
+
+ protected:
+ // All these point to the original buffer passed to the TTokenizer's
+ // constructor
+ typename base::TAString::const_char_iterator
+ mRecord; // Position where the recorded sub-string for Claim() is
+ typename base::TAString::const_char_iterator
+ mRollback; // Position of the previous token start
+
+ private:
+ TTokenizer() = delete;
+ TTokenizer(const TTokenizer&) = delete;
+ TTokenizer(TTokenizer&&) = delete;
+ TTokenizer(const TTokenizer&&) = delete;
+ TTokenizer& operator=(const TTokenizer&) = delete;
+};
+
+typedef TTokenizer<char> Tokenizer;
+typedef TTokenizer<char16_t> Tokenizer16;
+
+} // namespace mozilla
+
+#endif // Tokenizer_h__
diff --git a/xpcom/ds/components.conf b/xpcom/ds/components.conf
new file mode 100644
index 0000000000..1b600352b3
--- /dev/null
+++ b/xpcom/ds/components.conf
@@ -0,0 +1,24 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+ {
+ 'cid': '{35c66fd1-95e9-4e0a-80c5-c3bd2b375481}',
+ 'contract_ids': ['@mozilla.org/array;1'],
+ 'legacy_constructor': 'nsArrayBase::XPCOMConstructor',
+ 'headers': ['nsArray.h'],
+ },
+ {
+ 'name': 'Observer',
+ 'js_name': 'obs',
+ 'cid': '{d07f5195-e3d1-11d2-8acd-00105a1b8860}',
+ 'contract_ids': ['@mozilla.org/observer-service;1'],
+ 'interfaces': ['nsIObserverService'],
+ 'legacy_constructor': 'nsObserverService::Create',
+ 'headers': ['/xpcom/ds/nsObserverService.h'],
+ 'processes': ProcessSelector.ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS,
+ },
+]
diff --git a/xpcom/ds/moz.build b/xpcom/ds/moz.build
new file mode 100644
index 0000000000..e861f7bd8d
--- /dev/null
+++ b/xpcom/ds/moz.build
@@ -0,0 +1,156 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPIDL_SOURCES += [
+ "nsIArray.idl",
+ "nsIArrayExtensions.idl",
+ "nsIINIParser.idl",
+ "nsIMutableArray.idl",
+ "nsIObserver.idl",
+ "nsIObserverService.idl",
+ "nsIPersistentProperties2.idl",
+ "nsIProperties.idl",
+ "nsIProperty.idl",
+ "nsIPropertyBag.idl",
+ "nsIPropertyBag2.idl",
+ "nsISerializable.idl",
+ "nsISimpleEnumerator.idl",
+ "nsIStringEnumerator.idl",
+ "nsISupportsIterators.idl",
+ "nsISupportsPrimitives.idl",
+ "nsIVariant.idl",
+ "nsIWritablePropertyBag.idl",
+ "nsIWritablePropertyBag2.idl",
+]
+
+if CONFIG["OS_ARCH"] == "WINNT":
+ XPIDL_SOURCES += [
+ "nsIWindowsRegKey.idl",
+ ]
+ EXPORTS += ["nsWindowsRegKey.h"]
+ SOURCES += ["nsWindowsRegKey.cpp"]
+
+XPIDL_MODULE = "xpcom_ds"
+
+XPCOM_MANIFESTS += [
+ "components.conf",
+]
+
+EXPORTS += [
+ "!nsGkAtomConsts.h",
+ "!nsGkAtomList.h",
+ "nsArray.h",
+ "nsArrayEnumerator.h",
+ "nsArrayUtils.h",
+ "nsAtom.h",
+ "nsBaseHashtable.h",
+ "nsCharSeparatedTokenizer.h",
+ "nsCheapSets.h",
+ "nsClassHashtable.h",
+ "nsCOMArray.h",
+ "nsCRT.h",
+ "nsDeque.h",
+ "nsEnumeratorUtils.h",
+ "nsExpirationTracker.h",
+ "nsGkAtoms.h",
+ "nsHashKeys.h",
+ "nsHashPropertyBag.h",
+ "nsHashtablesFwd.h",
+ "nsInterfaceHashtable.h",
+ "nsMathUtils.h",
+ "nsPersistentProperties.h",
+ "nsPointerHashKeys.h",
+ "nsProperties.h",
+ "nsQuickSort.h",
+ "nsRefCountedHashtable.h",
+ "nsRefPtrHashtable.h",
+ "nsSimpleEnumerator.h",
+ "nsStaticAtomUtils.h",
+ "nsStaticNameTable.h",
+ "nsStringEnumerator.h",
+ "nsSupportsPrimitives.h",
+ "nsTArray-inl.h",
+ "nsTArray.h",
+ "nsTArrayForwardDeclare.h",
+ "nsTHashMap.h",
+ "nsTHashSet.h",
+ "nsTHashtable.h",
+ "nsTObserverArray.h",
+ "nsTPriorityQueue.h",
+ "nsVariant.h",
+ "nsWhitespaceTokenizer.h",
+ "PLDHashTable.h",
+]
+
+EXPORTS.mozilla += [
+ "ArenaAllocator.h",
+ "ArenaAllocatorExtensions.h",
+ "ArrayAlgorithm.h",
+ "ArrayIterator.h",
+ "AtomArray.h",
+ "Dafsa.h",
+ "IncrementalTokenizer.h",
+ "Observer.h",
+ "PerfectHash.h",
+ "SimpleEnumerator.h",
+ "StickyTimeDuration.h",
+ "Tokenizer.h",
+]
+
+UNIFIED_SOURCES += [
+ "Dafsa.cpp",
+ "IncrementalTokenizer.cpp",
+ "nsArray.cpp",
+ "nsArrayEnumerator.cpp",
+ "nsArrayUtils.cpp",
+ "nsAtomTable.cpp",
+ "nsCharSeparatedTokenizer.cpp",
+ "nsCOMArray.cpp",
+ "nsCRT.cpp",
+ "nsDeque.cpp",
+ "nsEnumeratorUtils.cpp",
+ "nsGkAtoms.cpp",
+ "nsHashPropertyBag.cpp",
+ "nsINIParserImpl.cpp",
+ "nsObserverList.cpp",
+ "nsObserverService.cpp",
+ "nsPersistentProperties.cpp",
+ "nsProperties.cpp",
+ "nsQuickSort.cpp",
+ "nsSimpleEnumerator.cpp",
+ "nsStaticNameTable.cpp",
+ "nsStringEnumerator.cpp",
+ "nsSupportsPrimitives.cpp",
+ "nsTArray.cpp",
+ "nsTObserverArray.cpp",
+ "nsVariant.cpp",
+ "PLDHashTable.cpp",
+ "Tokenizer.cpp",
+]
+
+LOCAL_INCLUDES += [
+ "../io",
+]
+
+GeneratedFile(
+ "nsGkAtomList.h",
+ script="StaticAtoms.py",
+ entry_point="generate_nsgkatomlist_h",
+ inputs=["Atom.py", "HTMLAtoms.py"],
+)
+
+GeneratedFile(
+ "nsGkAtomConsts.h",
+ script="StaticAtoms.py",
+ entry_point="generate_nsgkatomconsts_h",
+ inputs=["Atom.py", "HTMLAtoms.py"],
+)
+
+FINAL_LIBRARY = "xul"
+
+PYTHON_UNITTEST_MANIFESTS += [
+ "test/python.ini",
+]
diff --git a/xpcom/ds/nsArray.cpp b/xpcom/ds/nsArray.cpp
new file mode 100644
index 0000000000..60758133d9
--- /dev/null
+++ b/xpcom/ds/nsArray.cpp
@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsThreadUtils.h"
+
+NS_INTERFACE_MAP_BEGIN(nsArray)
+ NS_INTERFACE_MAP_ENTRY(nsIArray)
+ NS_INTERFACE_MAP_ENTRY(nsIArrayExtensions)
+ NS_INTERFACE_MAP_ENTRY(nsIMutableArray)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMutableArray)
+NS_INTERFACE_MAP_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsArrayCC)
+ NS_INTERFACE_MAP_ENTRY(nsIArray)
+ NS_INTERFACE_MAP_ENTRY(nsIArrayExtensions)
+ NS_INTERFACE_MAP_ENTRY(nsIMutableArray)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMutableArray)
+NS_INTERFACE_MAP_END
+
+nsArrayBase::~nsArrayBase() { Clear(); }
+
+NS_IMPL_ADDREF(nsArray)
+NS_IMPL_RELEASE(nsArray)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsArrayCC)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsArrayCC)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsArrayCC)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsArrayCC)
+ tmp->Clear();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsArrayCC)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArray)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMETHODIMP
+nsArrayBase::GetLength(uint32_t* aLength) {
+ *aLength = mArray.Count();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsArrayBase::QueryElementAt(uint32_t aIndex, const nsIID& aIID,
+ void** aResult) {
+ nsISupports* obj = mArray.SafeObjectAt(aIndex);
+ if (!obj) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ // no need to worry about a leak here, because SafeObjectAt()
+ // doesn't addref its result
+ return obj->QueryInterface(aIID, aResult);
+}
+
+NS_IMETHODIMP
+nsArrayBase::IndexOf(uint32_t aStartIndex, nsISupports* aElement,
+ uint32_t* aResult) {
+ int32_t idx = mArray.IndexOf(aElement, aStartIndex);
+ if (idx == -1) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aResult = static_cast<uint32_t>(idx);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsArrayBase::ScriptedEnumerate(const nsIID& aElemIID, uint8_t aArgc,
+ nsISimpleEnumerator** aResult) {
+ if (aArgc > 0) {
+ return NS_NewArrayEnumerator(aResult, static_cast<nsIArray*>(this),
+ aElemIID);
+ }
+ return NS_NewArrayEnumerator(aResult, static_cast<nsIArray*>(this));
+}
+
+NS_IMETHODIMP
+nsArrayBase::EnumerateImpl(const nsID& aElemIID,
+ nsISimpleEnumerator** aResult) {
+ return NS_NewArrayEnumerator(aResult, static_cast<nsIArray*>(this), aElemIID);
+}
+
+// nsIMutableArray implementation
+
+NS_IMETHODIMP
+nsArrayBase::AppendElement(nsISupports* aElement) {
+ bool result = mArray.AppendObject(aElement);
+ return result ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsArrayBase::RemoveElementAt(uint32_t aIndex) {
+ bool result = mArray.RemoveObjectAt(aIndex);
+ return result ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsArrayBase::InsertElementAt(nsISupports* aElement, uint32_t aIndex) {
+ bool result = mArray.InsertObjectAt(aElement, aIndex);
+ return result ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsArrayBase::ReplaceElementAt(nsISupports* aElement, uint32_t aIndex) {
+ mArray.ReplaceObjectAt(aElement, aIndex);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsArrayBase::Clear() {
+ mArray.Clear();
+ return NS_OK;
+}
+
+// nsIArrayExtensions implementation.
+
+NS_IMETHODIMP
+nsArrayBase::Count(uint32_t* aResult) { return GetLength(aResult); }
+
+NS_IMETHODIMP
+nsArrayBase::GetElementAt(uint32_t aIndex, nsISupports** aResult) {
+ nsCOMPtr<nsISupports> obj = mArray.SafeObjectAt(aIndex);
+ obj.forget(aResult);
+ return NS_OK;
+}
+
+nsresult nsArrayBase::XPCOMConstructor(const nsIID& aIID, void** aResult) {
+ nsCOMPtr<nsIMutableArray> inst = Create();
+ return inst->QueryInterface(aIID, aResult);
+}
+
+already_AddRefed<nsIMutableArray> nsArrayBase::Create() {
+ nsCOMPtr<nsIMutableArray> inst;
+ if (NS_IsMainThread()) {
+ inst = new nsArrayCC;
+ } else {
+ inst = new nsArray;
+ }
+ return inst.forget();
+}
diff --git a/xpcom/ds/nsArray.h b/xpcom/ds/nsArray.h
new file mode 100644
index 0000000000..49d701d466
--- /dev/null
+++ b/xpcom/ds/nsArray.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsArray_h__
+#define nsArray_h__
+
+#include "nsIMutableArray.h"
+#include "nsCOMArray.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "mozilla/Attributes.h"
+
+// {35C66FD1-95E9-4e0a-80C5-C3BD2B375481}
+#define NS_ARRAY_CID \
+ { \
+ 0x35c66fd1, 0x95e9, 0x4e0a, { \
+ 0x80, 0xc5, 0xc3, 0xbd, 0x2b, 0x37, 0x54, 0x81 \
+ } \
+ }
+
+// nsArray without any refcounting declarations
+class nsArrayBase : public nsIMutableArray {
+ public:
+ NS_DECL_NSIARRAY
+ NS_DECL_NSIARRAYEXTENSIONS
+ NS_DECL_NSIMUTABLEARRAY
+
+ /* Both of these factory functions create a cycle-collectable array
+ on the main thread and a non-cycle-collectable array on other
+ threads. */
+ static already_AddRefed<nsIMutableArray> Create();
+ /* Only for the benefit of the XPCOM module system, use Create()
+ instead. */
+ static nsresult XPCOMConstructor(const nsIID& aIID, void** aResult);
+
+ protected:
+ nsArrayBase() = default;
+ nsArrayBase(const nsArrayBase& aOther);
+ explicit nsArrayBase(const nsCOMArray_base& aBaseArray)
+ : mArray(aBaseArray) {}
+ virtual ~nsArrayBase();
+
+ nsCOMArray_base mArray;
+};
+
+class nsArray final : public nsArrayBase {
+ friend class nsArrayBase;
+
+ public:
+ NS_DECL_ISUPPORTS
+
+ private:
+ nsArray() : nsArrayBase() {}
+ nsArray(const nsArray& aOther);
+ explicit nsArray(const nsCOMArray_base& aBaseArray)
+ : nsArrayBase(aBaseArray) {}
+ ~nsArray() = default;
+};
+
+class nsArrayCC final : public nsArrayBase {
+ friend class nsArrayBase;
+
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsArrayCC, nsIMutableArray)
+
+ private:
+ nsArrayCC() : nsArrayBase() {}
+ nsArrayCC(const nsArrayCC& aOther);
+ explicit nsArrayCC(const nsCOMArray_base& aBaseArray)
+ : nsArrayBase(aBaseArray) {}
+ ~nsArrayCC() = default;
+};
+
+#endif
diff --git a/xpcom/ds/nsArrayEnumerator.cpp b/xpcom/ds/nsArrayEnumerator.cpp
new file mode 100644
index 0000000000..ec475f9e5b
--- /dev/null
+++ b/xpcom/ds/nsArrayEnumerator.cpp
@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Attributes.h"
+
+#include "nsArrayEnumerator.h"
+
+#include "nsIArray.h"
+#include "nsSimpleEnumerator.h"
+
+#include "nsCOMArray.h"
+#include "nsCOMPtr.h"
+#include "mozilla/OperatorNewExtensions.h"
+#include "mozilla/RefPtr.h"
+
+class nsSimpleArrayEnumerator final : public nsSimpleEnumerator {
+ public:
+ // nsISimpleEnumerator interface
+ NS_DECL_NSISIMPLEENUMERATOR
+
+ // nsSimpleArrayEnumerator methods
+ explicit nsSimpleArrayEnumerator(nsIArray* aValueArray, const nsID& aEntryIID)
+ : mValueArray(aValueArray), mEntryIID(aEntryIID), mIndex(0) {}
+
+ const nsID& DefaultInterface() override { return mEntryIID; }
+
+ private:
+ ~nsSimpleArrayEnumerator() override = default;
+
+ protected:
+ nsCOMPtr<nsIArray> mValueArray;
+ const nsID mEntryIID;
+ uint32_t mIndex;
+};
+
+NS_IMETHODIMP
+nsSimpleArrayEnumerator::HasMoreElements(bool* aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (!mValueArray) {
+ *aResult = false;
+ return NS_OK;
+ }
+
+ uint32_t cnt;
+ nsresult rv = mValueArray->GetLength(&cnt);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ *aResult = (mIndex < cnt);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimpleArrayEnumerator::GetNext(nsISupports** aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (!mValueArray) {
+ *aResult = nullptr;
+ return NS_OK;
+ }
+
+ uint32_t cnt;
+ nsresult rv = mValueArray->GetLength(&cnt);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ if (mIndex >= cnt) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ return mValueArray->QueryElementAt(mIndex++, NS_GET_IID(nsISupports),
+ (void**)aResult);
+}
+
+nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult, nsIArray* aArray,
+ const nsID& aEntryIID) {
+ RefPtr<nsSimpleArrayEnumerator> enumer =
+ new nsSimpleArrayEnumerator(aArray, aEntryIID);
+ enumer.forget(aResult);
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// enumerator implementation for nsCOMArray
+// creates a snapshot of the array in question
+// you MUST use NS_NewArrayEnumerator to create this, so that
+// allocation is done correctly
+class nsCOMArrayEnumerator final : public nsSimpleEnumerator {
+ public:
+ // nsISimpleEnumerator interface
+ NS_DECL_NSISIMPLEENUMERATOR
+
+ // Use this instead of `new`.
+ static nsCOMArrayEnumerator* Allocate(const nsCOMArray_base& aArray,
+ const nsID& aEntryIID);
+
+ // specialized operator to make sure we make room for mValues
+ void operator delete(void* aPtr) { free(aPtr); }
+
+ const nsID& DefaultInterface() override { return mEntryIID; }
+
+ private:
+ // nsSimpleArrayEnumerator methods
+ explicit nsCOMArrayEnumerator(const nsID& aEntryIID)
+ : mIndex(0), mArraySize(0), mEntryIID(aEntryIID) {
+ mValueArray[0] = nullptr;
+ }
+
+ ~nsCOMArrayEnumerator(void) override;
+
+ protected:
+ uint32_t mIndex; // current position
+ uint32_t mArraySize; // size of the array
+
+ const nsID& mEntryIID;
+
+ // this is actually bigger
+ nsISupports* mValueArray[1];
+};
+
+nsCOMArrayEnumerator::~nsCOMArrayEnumerator() {
+ // only release the entries that we haven't visited yet
+ for (; mIndex < mArraySize; ++mIndex) {
+ NS_IF_RELEASE(mValueArray[mIndex]);
+ }
+}
+
+NS_IMETHODIMP
+nsCOMArrayEnumerator::HasMoreElements(bool* aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ *aResult = (mIndex < mArraySize);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCOMArrayEnumerator::GetNext(nsISupports** aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (mIndex >= mArraySize) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // pass the ownership of the reference to the caller. Since
+ // we AddRef'ed during creation of |this|, there is no need
+ // to AddRef here
+ *aResult = mValueArray[mIndex++];
+
+ // this really isn't necessary. just pretend this happens, since
+ // we'll never visit this value again!
+ // mValueArray[(mIndex-1)] = nullptr;
+
+ return NS_OK;
+}
+
+nsCOMArrayEnumerator* nsCOMArrayEnumerator::Allocate(
+ const nsCOMArray_base& aArray, const nsID& aEntryIID) {
+ // create enough space such that mValueArray points to a large
+ // enough value. Note that the initial value of aSize gives us
+ // space for mValueArray[0], so we must subtract
+ size_t size = sizeof(nsCOMArrayEnumerator);
+ uint32_t count;
+ if (aArray.Count() > 0) {
+ count = static_cast<uint32_t>(aArray.Count());
+ size += (count - 1) * sizeof(aArray[0]);
+ } else {
+ count = 0;
+ }
+
+ // Allocate a buffer large enough to contain our object and its array.
+ void* mem = moz_xmalloc(size);
+ auto result =
+ new (mozilla::KnownNotNull, mem) nsCOMArrayEnumerator(aEntryIID);
+
+ result->mArraySize = count;
+
+ // now need to copy over the values, and addref each one
+ // now this might seem like a lot of work, but we're actually just
+ // doing all our AddRef's ahead of time since GetNext() doesn't
+ // need to AddRef() on the way out
+ for (uint32_t i = 0; i < count; ++i) {
+ result->mValueArray[i] = aArray[i];
+ NS_IF_ADDREF(result->mValueArray[i]);
+ }
+
+ return result;
+}
+
+nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult,
+ const nsCOMArray_base& aArray,
+ const nsID& aEntryIID) {
+ RefPtr<nsCOMArrayEnumerator> enumerator =
+ nsCOMArrayEnumerator::Allocate(aArray, aEntryIID);
+ enumerator.forget(aResult);
+ return NS_OK;
+}
diff --git a/xpcom/ds/nsArrayEnumerator.h b/xpcom/ds/nsArrayEnumerator.h
new file mode 100644
index 0000000000..a406a9ea66
--- /dev/null
+++ b/xpcom/ds/nsArrayEnumerator.h
@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsArrayEnumerator_h__
+#define nsArrayEnumerator_h__
+
+// enumerator implementation for nsIArray
+
+#include "nsISupports.h"
+
+class nsISimpleEnumerator;
+class nsIArray;
+class nsCOMArray_base;
+
+// Create an enumerator for an existing nsIArray implementation
+// The enumerator holds an owning reference to the array.
+nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult, nsIArray* aArray,
+ const nsID& aEntryIID = NS_GET_IID(nsISupports));
+
+// create an enumerator for an existing nsCOMArray<T> implementation
+// The enumerator will hold an owning reference to each ELEMENT in
+// the array. This means that the nsCOMArray<T> can safely go away
+// without its objects going away.
+nsresult NS_NewArrayEnumerator(nsISimpleEnumerator** aResult,
+ const nsCOMArray_base& aArray,
+ const nsID& aEntryIID = NS_GET_IID(nsISupports));
+
+#endif
diff --git a/xpcom/ds/nsArrayUtils.cpp b/xpcom/ds/nsArrayUtils.cpp
new file mode 100644
index 0000000000..e8ea8bd0f2
--- /dev/null
+++ b/xpcom/ds/nsArrayUtils.cpp
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsArrayUtils.h"
+
+//
+// do_QueryElementAt helper stuff
+//
+nsresult nsQueryArrayElementAt::operator()(const nsIID& aIID,
+ void** aResult) const {
+ nsresult status = mArray ? mArray->QueryElementAt(mIndex, aIID, aResult)
+ : NS_ERROR_NULL_POINTER;
+
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+
+ return status;
+}
diff --git a/xpcom/ds/nsArrayUtils.h b/xpcom/ds/nsArrayUtils.h
new file mode 100644
index 0000000000..6adad119c7
--- /dev/null
+++ b/xpcom/ds/nsArrayUtils.h
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsArrayUtils_h__
+#define nsArrayUtils_h__
+
+#include "nsCOMPtr.h"
+#include "nsIArray.h"
+
+// helper class for do_QueryElementAt
+class MOZ_STACK_CLASS nsQueryArrayElementAt final : public nsCOMPtr_helper {
+ public:
+ nsQueryArrayElementAt(nsIArray* aArray, uint32_t aIndex, nsresult* aErrorPtr)
+ : mArray(aArray), mIndex(aIndex), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID& aIID,
+ void**) const override;
+
+ private:
+ nsIArray* MOZ_NON_OWNING_REF mArray;
+ uint32_t mIndex;
+ nsresult* mErrorPtr;
+};
+
+inline const nsQueryArrayElementAt do_QueryElementAt(nsIArray* aArray,
+ uint32_t aIndex,
+ nsresult* aErrorPtr = 0) {
+ return nsQueryArrayElementAt(aArray, aIndex, aErrorPtr);
+}
+
+#endif // nsArrayUtils_h__
diff --git a/xpcom/ds/nsAtom.h b/xpcom/ds/nsAtom.h
new file mode 100644
index 0000000000..1b53b7be2e
--- /dev/null
+++ b/xpcom/ds/nsAtom.h
@@ -0,0 +1,309 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsAtom_h
+#define nsAtom_h
+
+#include <type_traits>
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Char16.h"
+#include "mozilla/MemoryReporting.h"
+#include "nsISupports.h"
+#include "nsString.h"
+
+namespace mozilla {
+struct AtomsSizes;
+} // namespace mozilla
+
+class nsStaticAtom;
+class nsDynamicAtom;
+
+// This class encompasses both static and dynamic atoms.
+//
+// - In places where static and dynamic atoms can be used, use RefPtr<nsAtom>.
+// This is by far the most common case.
+//
+// - In places where only static atoms can appear, use nsStaticAtom* to avoid
+// unnecessary refcounting. This is a moderately common case.
+//
+// - In places where only dynamic atoms can appear, it doesn't matter much
+// whether you use RefPtr<nsAtom> or RefPtr<nsDynamicAtom>. This is an
+// extremely rare case.
+//
+class nsAtom {
+ public:
+ void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+ mozilla::AtomsSizes& aSizes) const;
+
+ bool Equals(char16ptr_t aString, uint32_t aLength) const {
+ return mLength == aLength &&
+ memcmp(GetUTF16String(), aString, mLength * sizeof(char16_t)) == 0;
+ }
+
+ bool Equals(const nsAString& aString) const {
+ return Equals(aString.BeginReading(), aString.Length());
+ }
+
+ bool IsStatic() const { return mIsStatic; }
+ bool IsDynamic() const { return !IsStatic(); }
+
+ inline const nsStaticAtom* AsStatic() const;
+ inline const nsDynamicAtom* AsDynamic() const;
+ inline nsDynamicAtom* AsDynamic();
+
+ char16ptr_t GetUTF16String() const;
+
+ uint32_t GetLength() const { return mLength; }
+
+ operator mozilla::Span<const char16_t>() const {
+ // Explicitly specify template argument here to avoid instantiating
+ // Span<char16_t> first and then implicitly converting to Span<const
+ // char16_t>
+ return mozilla::Span<const char16_t>{GetUTF16String(), GetLength()};
+ }
+
+ void ToString(nsAString& aString) const;
+ void ToUTF8String(nsACString& aString) const;
+
+ // A hashcode that is better distributed than the actual atom pointer, for
+ // use in situations that need a well-distributed hashcode. It's called hash()
+ // rather than Hash() so we can use mozilla::BloomFilter<N, nsAtom>, because
+ // BloomFilter requires elements to implement a function called hash().
+ //
+ uint32_t hash() const { return mHash; }
+
+ // This function returns true if ToLowercaseASCII would return the string
+ // unchanged.
+ bool IsAsciiLowercase() const { return mIsAsciiLowercase; }
+
+ // This function returns true if this is the empty atom. This is exactly
+ // equivalent to `this == nsGkAtoms::_empty`, but it's a bit less foot-gunny,
+ // since we also have `nsGkAtoms::empty`.
+ //
+ // Defined in nsGkAtoms.h
+ inline bool IsEmpty() const;
+
+ // We can't use NS_INLINE_DECL_THREADSAFE_REFCOUNTING because the refcounting
+ // of this type is special.
+ inline MozExternalRefCountType AddRef();
+ inline MozExternalRefCountType Release();
+
+ using HasThreadSafeRefCnt = std::true_type;
+
+ protected:
+ // Used by nsStaticAtom.
+ constexpr nsAtom(uint32_t aLength, uint32_t aHash, bool aIsAsciiLowercase)
+ : mLength(aLength),
+ mIsStatic(true),
+ mIsAsciiLowercase(aIsAsciiLowercase),
+ mHash(aHash) {}
+
+ // Used by nsDynamicAtom.
+ nsAtom(const nsAString& aString, uint32_t aHash, bool aIsAsciiLowercase)
+ : mLength(aString.Length()),
+ mIsStatic(false),
+ mIsAsciiLowercase(aIsAsciiLowercase),
+ mHash(aHash) {}
+
+ ~nsAtom() = default;
+
+ const uint32_t mLength : 30;
+ const uint32_t mIsStatic : 1;
+ const uint32_t mIsAsciiLowercase : 1;
+ const uint32_t mHash;
+};
+
+// This class would be |final| if it wasn't for nsCSSAnonBoxPseudoStaticAtom
+// and nsCSSPseudoElementStaticAtom, which are trivial subclasses used to
+// ensure only certain static atoms are passed to certain functions.
+class nsStaticAtom : public nsAtom {
+ public:
+ // These are deleted so it's impossible to RefPtr<nsStaticAtom>. Raw
+ // nsStaticAtom pointers should be used instead.
+ MozExternalRefCountType AddRef() = delete;
+ MozExternalRefCountType Release() = delete;
+
+ // The static atom's precomputed hash value is an argument here, but it
+ // must be the same as would be computed by mozilla::HashString(aStr),
+ // which is what we use when atomizing strings. We compute this hash in
+ // Atom.py and assert in nsAtomTable::RegisterStaticAtoms that the two
+ // hashes match.
+ constexpr nsStaticAtom(uint32_t aLength, uint32_t aHash,
+ uint32_t aStringOffset, bool aIsAsciiLowercase)
+ : nsAtom(aLength, aHash, aIsAsciiLowercase),
+ mStringOffset(aStringOffset) {}
+
+ const char16_t* String() const {
+ return reinterpret_cast<const char16_t*>(uintptr_t(this) - mStringOffset);
+ }
+
+ already_AddRefed<nsAtom> ToAddRefed() {
+ return already_AddRefed<nsAtom>(static_cast<nsAtom*>(this));
+ }
+
+ private:
+ // This is an offset to the string chars, which must be at a lower address in
+ // memory.
+ uint32_t mStringOffset;
+};
+
+class nsDynamicAtom : public nsAtom {
+ public:
+ // We can't use NS_INLINE_DECL_THREADSAFE_REFCOUNTING because the refcounting
+ // of this type is special.
+ MozExternalRefCountType AddRef() {
+ MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
+ nsrefcnt count = ++mRefCnt;
+ if (count == 1) {
+ gUnusedAtomCount--;
+ }
+ return count;
+ }
+
+ MozExternalRefCountType Release() {
+#ifdef DEBUG
+ // We set a lower GC threshold for atoms in debug builds so that we exercise
+ // the GC machinery more often.
+ static const int32_t kAtomGCThreshold = 20;
+#else
+ static const int32_t kAtomGCThreshold = 10000;
+#endif
+
+ MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
+ nsrefcnt count = --mRefCnt;
+ if (count == 0) {
+ if (++gUnusedAtomCount >= kAtomGCThreshold) {
+ GCAtomTable();
+ }
+ }
+
+ return count;
+ }
+
+ const char16_t* String() const {
+ return reinterpret_cast<const char16_t*>(this + 1);
+ }
+
+ static nsDynamicAtom* FromChars(char16_t* chars) {
+ return reinterpret_cast<nsDynamicAtom*>(chars) - 1;
+ }
+
+ private:
+ friend class nsAtomTable;
+ friend class nsAtomSubTable;
+ friend int32_t NS_GetUnusedAtomCount();
+
+ static mozilla::Atomic<int32_t, mozilla::ReleaseAcquire> gUnusedAtomCount;
+ static void GCAtomTable();
+
+ // These shouldn't be used directly, even by friend classes. The
+ // Create()/Destroy() methods use them.
+ nsDynamicAtom(const nsAString& aString, uint32_t aHash,
+ bool aIsAsciiLowercase);
+ ~nsDynamicAtom() = default;
+
+ static nsDynamicAtom* Create(const nsAString& aString, uint32_t aHash);
+ static void Destroy(nsDynamicAtom* aAtom);
+
+ mozilla::ThreadSafeAutoRefCnt mRefCnt;
+
+ // The atom's chars are stored at the end of the struct.
+};
+
+const nsStaticAtom* nsAtom::AsStatic() const {
+ MOZ_ASSERT(IsStatic());
+ return static_cast<const nsStaticAtom*>(this);
+}
+
+const nsDynamicAtom* nsAtom::AsDynamic() const {
+ MOZ_ASSERT(IsDynamic());
+ return static_cast<const nsDynamicAtom*>(this);
+}
+
+nsDynamicAtom* nsAtom::AsDynamic() {
+ MOZ_ASSERT(IsDynamic());
+ return static_cast<nsDynamicAtom*>(this);
+}
+
+MozExternalRefCountType nsAtom::AddRef() {
+ return IsStatic() ? 2 : AsDynamic()->AddRef();
+}
+
+MozExternalRefCountType nsAtom::Release() {
+ return IsStatic() ? 1 : AsDynamic()->Release();
+}
+
+// The four forms of NS_Atomize (for use with |RefPtr<nsAtom>|) return the
+// atom for the string given. At any given time there will always be one atom
+// representing a given string. Atoms are intended to make string comparison
+// cheaper by simplifying it to pointer equality. A pointer to the atom that
+// does not own a reference is not guaranteed to be valid.
+
+// Find an atom that matches the given UTF-8 string. The string is assumed to
+// be zero terminated. Never returns null.
+already_AddRefed<nsAtom> NS_Atomize(const char* aUTF8String);
+
+// Find an atom that matches the given UTF-8 string. Never returns null.
+already_AddRefed<nsAtom> NS_Atomize(const nsACString& aUTF8String);
+
+// Find an atom that matches the given UTF-16 string. The string is assumed to
+// be zero terminated. Never returns null.
+already_AddRefed<nsAtom> NS_Atomize(const char16_t* aUTF16String);
+
+// Find an atom that matches the given UTF-16 string. Never returns null.
+already_AddRefed<nsAtom> NS_Atomize(const nsAString& aUTF16String);
+
+// An optimized version of the method above for the main thread.
+already_AddRefed<nsAtom> NS_AtomizeMainThread(const nsAString& aUTF16String);
+
+// Return a count of the total number of atoms currently alive in the system.
+//
+// Note that the result is imprecise and racy if other threads are currently
+// operating on atoms. It's also slow, since it triggers a GC before counting.
+// Currently this function is only used in tests, which should probably remain
+// the case.
+nsrefcnt NS_GetNumberOfAtoms();
+
+// Return a pointer for a static atom for the string or null if there's no
+// static atom for this string.
+nsStaticAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
+
+class nsAtomString : public nsString {
+ public:
+ explicit nsAtomString(const nsAtom* aAtom) { aAtom->ToString(*this); }
+};
+
+class nsAutoAtomString : public nsAutoString {
+ public:
+ explicit nsAutoAtomString(const nsAtom* aAtom) { aAtom->ToString(*this); }
+};
+
+class nsAtomCString : public nsCString {
+ public:
+ explicit nsAtomCString(const nsAtom* aAtom) { aAtom->ToUTF8String(*this); }
+};
+
+class nsAutoAtomCString : public nsAutoCString {
+ public:
+ explicit nsAutoAtomCString(const nsAtom* aAtom) {
+ aAtom->ToUTF8String(*this);
+ }
+};
+
+class nsDependentAtomString : public nsDependentString {
+ public:
+ explicit nsDependentAtomString(const nsAtom* aAtom)
+ : nsDependentString(aAtom->GetUTF16String(), aAtom->GetLength()) {}
+};
+
+// Checks if the ascii chars in a given atom are already lowercase.
+// If they are, no-op. Otherwise, converts all the ascii uppercase
+// chars to lowercase and atomizes, storing the result in the inout
+// param.
+void ToLowerCaseASCII(RefPtr<nsAtom>& aAtom);
+
+#endif // nsAtom_h
diff --git a/xpcom/ds/nsAtomTable.cpp b/xpcom/ds/nsAtomTable.cpp
new file mode 100644
index 0000000000..56618cd46c
--- /dev/null
+++ b/xpcom/ds/nsAtomTable.cpp
@@ -0,0 +1,670 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/MruCache.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/TextUtils.h"
+#include "mozilla/Unused.h"
+
+#include "nsAtom.h"
+#include "nsAtomTable.h"
+#include "nsCRT.h"
+#include "nsGkAtoms.h"
+#include "nsHashKeys.h"
+#include "nsPrintfCString.h"
+#include "nsString.h"
+#include "nsThreadUtils.h"
+#include "nsUnicharUtils.h"
+#include "PLDHashTable.h"
+#include "prenv.h"
+
+// There are two kinds of atoms handled by this module.
+//
+// - Dynamic: the atom itself is heap allocated, as is the char buffer it
+// points to. |gAtomTable| holds weak references to dynamic atoms. When the
+// refcount of a dynamic atom drops to zero, we increment a static counter.
+// When that counter reaches a certain threshold, we iterate over the atom
+// table, removing and deleting dynamic atoms with refcount zero. This allows
+// us to avoid acquiring the atom table lock during normal refcounting.
+//
+// - Static: both the atom and its chars are statically allocated and
+// immutable, so it ignores all AddRef/Release calls.
+//
+// Note that gAtomTable is used on multiple threads, and has internal
+// synchronization.
+
+using namespace mozilla;
+
+//----------------------------------------------------------------------
+
+enum class GCKind {
+ RegularOperation,
+ Shutdown,
+};
+
+//----------------------------------------------------------------------
+
+// gUnusedAtomCount is incremented when an atom loses its last reference
+// (and thus turned into unused state), and decremented when an unused
+// atom gets a reference again. The atom table relies on this value to
+// schedule GC. This value can temporarily go below zero when multiple
+// threads are operating the same atom, so it has to be signed so that
+// we wouldn't use overflow value for comparison.
+// See nsAtom::AddRef() and nsAtom::Release().
+// This atomic can be accessed during the GC and other places where recorded
+// events are not allowed, so its value is not preserved when recording or
+// replaying.
+Atomic<int32_t, ReleaseAcquire> nsDynamicAtom::gUnusedAtomCount;
+
+nsDynamicAtom::nsDynamicAtom(const nsAString& aString, uint32_t aHash,
+ bool aIsAsciiLowercase)
+ : nsAtom(aString, aHash, aIsAsciiLowercase), mRefCnt(1) {}
+
+// Returns true if ToLowercaseASCII would return the string unchanged.
+static bool IsAsciiLowercase(const char16_t* aString, const uint32_t aLength) {
+ for (uint32_t i = 0; i < aLength; ++i) {
+ if (IS_ASCII_UPPER(aString[i])) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+nsDynamicAtom* nsDynamicAtom::Create(const nsAString& aString, uint32_t aHash) {
+ // We tack the chars onto the end of the nsDynamicAtom object.
+ size_t numCharBytes = (aString.Length() + 1) * sizeof(char16_t);
+ size_t numTotalBytes = sizeof(nsDynamicAtom) + numCharBytes;
+
+ bool isAsciiLower = ::IsAsciiLowercase(aString.Data(), aString.Length());
+
+ nsDynamicAtom* atom = (nsDynamicAtom*)moz_xmalloc(numTotalBytes);
+ new (atom) nsDynamicAtom(aString, aHash, isAsciiLower);
+ memcpy(const_cast<char16_t*>(atom->String()),
+ PromiseFlatString(aString).get(), numCharBytes);
+
+ MOZ_ASSERT(atom->String()[atom->GetLength()] == char16_t(0));
+ MOZ_ASSERT(atom->Equals(aString));
+ MOZ_ASSERT(atom->mHash == HashString(atom->String(), atom->GetLength()));
+ MOZ_ASSERT(atom->mIsAsciiLowercase == isAsciiLower);
+
+ return atom;
+}
+
+void nsDynamicAtom::Destroy(nsDynamicAtom* aAtom) {
+ aAtom->~nsDynamicAtom();
+ free(aAtom);
+}
+
+void nsAtom::ToString(nsAString& aString) const {
+ // See the comment on |mString|'s declaration.
+ if (IsStatic()) {
+ // AssignLiteral() lets us assign without copying. This isn't a string
+ // literal, but it's a static atom and thus has an unbounded lifetime,
+ // which is what's important.
+ aString.AssignLiteral(AsStatic()->String(), mLength);
+ } else {
+ aString.Assign(AsDynamic()->String(), mLength);
+ }
+}
+
+void nsAtom::ToUTF8String(nsACString& aBuf) const {
+ CopyUTF16toUTF8(nsDependentString(GetUTF16String(), mLength), aBuf);
+}
+
+void nsAtom::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
+ AtomsSizes& aSizes) const {
+ // Static atoms are in static memory, and so are not measured here.
+ if (IsDynamic()) {
+ aSizes.mDynamicAtoms += aMallocSizeOf(this);
+ }
+}
+
+char16ptr_t nsAtom::GetUTF16String() const {
+ return IsStatic() ? AsStatic()->String() : AsDynamic()->String();
+}
+
+//----------------------------------------------------------------------
+
+struct AtomTableKey {
+ explicit AtomTableKey(const nsStaticAtom* aAtom)
+ : mUTF16String(aAtom->String()),
+ mUTF8String(nullptr),
+ mLength(aAtom->GetLength()),
+ mHash(aAtom->hash()) {
+ MOZ_ASSERT(HashString(mUTF16String, mLength) == mHash);
+ }
+
+ AtomTableKey(const char16_t* aUTF16String, uint32_t aLength)
+ : mUTF16String(aUTF16String), mUTF8String(nullptr), mLength(aLength) {
+ mHash = HashString(mUTF16String, mLength);
+ }
+
+ AtomTableKey(const char* aUTF8String, uint32_t aLength, bool* aErr)
+ : mUTF16String(nullptr), mUTF8String(aUTF8String), mLength(aLength) {
+ mHash = HashUTF8AsUTF16(mUTF8String, mLength, aErr);
+ }
+
+ const char16_t* mUTF16String;
+ const char* mUTF8String;
+ uint32_t mLength;
+ uint32_t mHash;
+};
+
+struct AtomTableEntry : public PLDHashEntryHdr {
+ // These references are either to dynamic atoms, in which case they are
+ // non-owning, or they are to static atoms, which aren't really refcounted.
+ // See the comment at the top of this file for more details.
+ nsAtom* MOZ_NON_OWNING_REF mAtom;
+};
+
+struct AtomCache : public MruCache<AtomTableKey, nsAtom*, AtomCache> {
+ static HashNumber Hash(const AtomTableKey& aKey) { return aKey.mHash; }
+ static bool Match(const AtomTableKey& aKey, const nsAtom* aVal) {
+ MOZ_ASSERT(aKey.mUTF16String);
+ return aVal->Equals(aKey.mUTF16String, aKey.mLength);
+ }
+};
+
+static AtomCache sRecentlyUsedMainThreadAtoms;
+
+// In order to reduce locking contention for concurrent atomization, we segment
+// the atom table into N subtables, each with a separate lock. If the hash
+// values we use to select the subtable are evenly distributed, this reduces the
+// probability of contention by a factor of N. See bug 1440824.
+//
+// NB: This is somewhat similar to the technique used by Java's
+// ConcurrentHashTable.
+class nsAtomSubTable {
+ friend class nsAtomTable;
+ Mutex mLock;
+ PLDHashTable mTable;
+ nsAtomSubTable();
+ void GCLocked(GCKind aKind) MOZ_REQUIRES(mLock);
+ void AddSizeOfExcludingThisLocked(MallocSizeOf aMallocSizeOf,
+ AtomsSizes& aSizes) MOZ_REQUIRES(mLock);
+
+ AtomTableEntry* Search(AtomTableKey& aKey) const MOZ_REQUIRES(mLock) {
+ mLock.AssertCurrentThreadOwns();
+ return static_cast<AtomTableEntry*>(mTable.Search(&aKey));
+ }
+
+ AtomTableEntry* Add(AtomTableKey& aKey) MOZ_REQUIRES(mLock) {
+ mLock.AssertCurrentThreadOwns();
+ return static_cast<AtomTableEntry*>(mTable.Add(&aKey)); // Infallible
+ }
+};
+
+// The outer atom table, which coordinates access to the inner array of
+// subtables.
+class nsAtomTable {
+ public:
+ nsAtomSubTable& SelectSubTable(AtomTableKey& aKey);
+ void AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf, AtomsSizes& aSizes);
+ void GC(GCKind aKind);
+ already_AddRefed<nsAtom> Atomize(const nsAString& aUTF16String);
+ already_AddRefed<nsAtom> Atomize(const nsACString& aUTF8String);
+ already_AddRefed<nsAtom> AtomizeMainThread(const nsAString& aUTF16String);
+ nsStaticAtom* GetStaticAtom(const nsAString& aUTF16String);
+ void RegisterStaticAtoms(const nsStaticAtom* aAtoms, size_t aAtomsLen);
+
+ // The result of this function may be imprecise if other threads are operating
+ // on atoms concurrently. It's also slow, since it triggers a GC before
+ // counting.
+ size_t RacySlowCount();
+
+ // This hash table op is a static member of this class so that it can take
+ // advantage of |friend| declarations.
+ static void AtomTableClearEntry(PLDHashTable* aTable,
+ PLDHashEntryHdr* aEntry);
+
+ // We achieve measurable reduction in locking contention in parallel CSS
+ // parsing by increasing the number of subtables up to 128. This has been
+ // measured to have neglible impact on the performance of initialization, GC,
+ // and shutdown.
+ //
+ // Another important consideration is memory, since we're adding fixed
+ // overhead per content process, which we try to avoid. Measuring a
+ // mostly-empty page [1] with various numbers of subtables, we get the
+ // following deep sizes for the atom table:
+ // 1 subtable: 278K
+ // 8 subtables: 279K
+ // 16 subtables: 282K
+ // 64 subtables: 286K
+ // 128 subtables: 290K
+ //
+ // So 128 subtables costs us 12K relative to a single table, and 4K relative
+ // to 64 subtables. Conversely, measuring parallel (6 thread) CSS parsing on
+ // tp6-facebook, a single table provides ~150ms of locking overhead per
+ // thread, 64 subtables provides ~2-3ms of overhead, and 128 subtables
+ // provides <1ms. And so while either 64 or 128 subtables would probably be
+ // acceptable, achieving a measurable reduction in contention for 4k of fixed
+ // memory overhead is probably worth it.
+ //
+ // [1] The numbers will look different for content processes with complex
+ // pages loaded, but in those cases the actual atoms will dominate memory
+ // usage and the overhead of extra tables will be negligible. We're mostly
+ // interested in the fixed cost for nearly-empty content processes.
+ const static size_t kNumSubTables = 128; // Must be power of two.
+
+ private:
+ nsAtomSubTable mSubTables[kNumSubTables];
+};
+
+// Static singleton instance for the atom table.
+static nsAtomTable* gAtomTable;
+
+static PLDHashNumber AtomTableGetHash(const void* aKey) {
+ const AtomTableKey* k = static_cast<const AtomTableKey*>(aKey);
+ return k->mHash;
+}
+
+static bool AtomTableMatchKey(const PLDHashEntryHdr* aEntry, const void* aKey) {
+ const AtomTableEntry* he = static_cast<const AtomTableEntry*>(aEntry);
+ const AtomTableKey* k = static_cast<const AtomTableKey*>(aKey);
+
+ if (k->mUTF8String) {
+ bool err = false;
+ return (CompareUTF8toUTF16(nsDependentCSubstring(
+ k->mUTF8String, k->mUTF8String + k->mLength),
+ nsDependentAtomString(he->mAtom), &err) == 0) &&
+ !err;
+ }
+
+ return he->mAtom->Equals(k->mUTF16String, k->mLength);
+}
+
+void nsAtomTable::AtomTableClearEntry(PLDHashTable* aTable,
+ PLDHashEntryHdr* aEntry) {
+ auto entry = static_cast<AtomTableEntry*>(aEntry);
+ entry->mAtom = nullptr;
+}
+
+static void AtomTableInitEntry(PLDHashEntryHdr* aEntry, const void* aKey) {
+ static_cast<AtomTableEntry*>(aEntry)->mAtom = nullptr;
+}
+
+static const PLDHashTableOps AtomTableOps = {
+ AtomTableGetHash, AtomTableMatchKey, PLDHashTable::MoveEntryStub,
+ nsAtomTable::AtomTableClearEntry, AtomTableInitEntry};
+
+// The atom table very quickly gets 10,000+ entries in it (or even 100,000+).
+// But choosing the best initial subtable length has some subtleties: we add
+// ~2700 static atoms at start-up, and then we start adding and removing
+// dynamic atoms. If we make the tables too big to start with, when the first
+// dynamic atom gets removed from a given table the load factor will be < 25%
+// and we will shrink it.
+//
+// So we first make the simplifying assumption that the atoms are more or less
+// evenly-distributed across the subtables (which is the case empirically).
+// Then, we take the total atom count when the first dynamic atom is removed
+// (~2700), divide that across the N subtables, and the largest capacity that
+// will allow each subtable to be > 25% full with that count.
+//
+// So want an initial subtable capacity less than (2700 / N) * 4 = 10800 / N.
+// Rounding down to the nearest power of two gives us 8192 / N. Since the
+// capacity is double the initial length, we end up with (4096 / N) per
+// subtable.
+#define INITIAL_SUBTABLE_LENGTH (4096 / nsAtomTable::kNumSubTables)
+
+nsAtomSubTable& nsAtomTable::SelectSubTable(AtomTableKey& aKey) {
+ // There are a few considerations around how we select subtables.
+ //
+ // First, we want entries to be evenly distributed across the subtables. This
+ // can be achieved by using any bits in the hash key, assuming the key itself
+ // is evenly-distributed. Empirical measurements indicate that this method
+ // produces a roughly-even distribution across subtables.
+ //
+ // Second, we want to use the hash bits that are least likely to influence an
+ // entry's position within the subtable. If we used the exact same bits used
+ // by the subtables, then each subtable would compute the same position for
+ // every entry it observes, leading to pessimal performance. In this case,
+ // we're using PLDHashTable, whose primary hash function uses the N leftmost
+ // bits of the hash value (where N is the log2 capacity of the table). This
+ // means we should prefer the rightmost bits here.
+ //
+ // Note that the below is equivalent to mHash % kNumSubTables, a replacement
+ // which an optimizing compiler should make, but let's avoid any doubt.
+ static_assert((kNumSubTables & (kNumSubTables - 1)) == 0,
+ "must be power of two");
+ return mSubTables[aKey.mHash & (kNumSubTables - 1)];
+}
+
+void nsAtomTable::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
+ AtomsSizes& aSizes) {
+ MOZ_ASSERT(NS_IsMainThread());
+ aSizes.mTable += aMallocSizeOf(this);
+ for (auto& table : mSubTables) {
+ MutexAutoLock lock(table.mLock);
+ table.AddSizeOfExcludingThisLocked(aMallocSizeOf, aSizes);
+ }
+}
+
+void nsAtomTable::GC(GCKind aKind) {
+ MOZ_ASSERT(NS_IsMainThread());
+ sRecentlyUsedMainThreadAtoms.Clear();
+
+ // Note that this is effectively an incremental GC, since only one subtable
+ // is locked at a time.
+ for (auto& table : mSubTables) {
+ MutexAutoLock lock(table.mLock);
+ table.GCLocked(aKind);
+ }
+
+ // We would like to assert that gUnusedAtomCount matches the number of atoms
+ // we found in the table which we removed. However, there are two problems
+ // with this:
+ // * We have multiple subtables, each with their own lock. For optimal
+ // performance we only want to hold one lock at a time, but this means
+ // that atoms can be added and removed between GC slices.
+ // * Even if we held all the locks and performed all GC slices atomically,
+ // the locks are not acquired for AddRef() and Release() calls. This means
+ // we might see a gUnusedAtomCount value in between, say, AddRef()
+ // incrementing mRefCnt and it decrementing gUnusedAtomCount.
+ //
+ // So, we don't bother asserting that there are no unused atoms at the end of
+ // a regular GC. But we can (and do) assert this just after the last GC at
+ // shutdown.
+ //
+ // Note that, barring refcounting bugs, an atom can only go from a zero
+ // refcount to a non-zero refcount while the atom table lock is held, so
+ // so we won't try to resurrect a zero refcount atom while trying to delete
+ // it.
+
+ MOZ_ASSERT_IF(aKind == GCKind::Shutdown,
+ nsDynamicAtom::gUnusedAtomCount == 0);
+}
+
+size_t nsAtomTable::RacySlowCount() {
+ // Trigger a GC so that the result is deterministic modulo other threads.
+ GC(GCKind::RegularOperation);
+ size_t count = 0;
+ for (auto& table : mSubTables) {
+ MutexAutoLock lock(table.mLock);
+ count += table.mTable.EntryCount();
+ }
+
+ return count;
+}
+
+nsAtomSubTable::nsAtomSubTable()
+ : mLock("Atom Sub-Table Lock"),
+ mTable(&AtomTableOps, sizeof(AtomTableEntry), INITIAL_SUBTABLE_LENGTH) {}
+
+void nsAtomSubTable::GCLocked(GCKind aKind) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mLock.AssertCurrentThreadOwns();
+
+ int32_t removedCount = 0; // A non-atomic temporary for cheaper increments.
+ nsAutoCString nonZeroRefcountAtoms;
+ uint32_t nonZeroRefcountAtomsCount = 0;
+ for (auto i = mTable.Iter(); !i.Done(); i.Next()) {
+ auto entry = static_cast<AtomTableEntry*>(i.Get());
+ if (entry->mAtom->IsStatic()) {
+ continue;
+ }
+
+ nsAtom* atom = entry->mAtom;
+ if (atom->IsDynamic() && atom->AsDynamic()->mRefCnt == 0) {
+ i.Remove();
+ nsDynamicAtom::Destroy(atom->AsDynamic());
+ ++removedCount;
+ }
+#ifdef NS_FREE_PERMANENT_DATA
+ else if (aKind == GCKind::Shutdown && PR_GetEnv("XPCOM_MEM_BLOAT_LOG")) {
+ // Only report leaking atoms in leak-checking builds in a run where we
+ // are checking for leaks, during shutdown. If something is anomalous,
+ // then we'll assert later in this function.
+ nsAutoCString name;
+ atom->ToUTF8String(name);
+ if (nonZeroRefcountAtomsCount == 0) {
+ nonZeroRefcountAtoms = name;
+ } else if (nonZeroRefcountAtomsCount < 20) {
+ nonZeroRefcountAtoms += ","_ns + name;
+ } else if (nonZeroRefcountAtomsCount == 20) {
+ nonZeroRefcountAtoms += ",..."_ns;
+ }
+ nonZeroRefcountAtomsCount++;
+ }
+#endif
+ }
+ if (nonZeroRefcountAtomsCount) {
+ nsPrintfCString msg("%d dynamic atom(s) with non-zero refcount: %s",
+ nonZeroRefcountAtomsCount, nonZeroRefcountAtoms.get());
+ NS_ASSERTION(nonZeroRefcountAtomsCount == 0, msg.get());
+ }
+
+ nsDynamicAtom::gUnusedAtomCount -= removedCount;
+}
+
+void nsDynamicAtom::GCAtomTable() {
+ MOZ_ASSERT(gAtomTable);
+ if (NS_IsMainThread()) {
+ gAtomTable->GC(GCKind::RegularOperation);
+ }
+}
+
+//----------------------------------------------------------------------
+
+// Have the static atoms been inserted into the table?
+static bool gStaticAtomsDone = false;
+
+void NS_InitAtomTable() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!gAtomTable);
+
+ // We register static atoms immediately so they're available for use as early
+ // as possible.
+ gAtomTable = new nsAtomTable();
+ gAtomTable->RegisterStaticAtoms(nsGkAtoms::sAtoms, nsGkAtoms::sAtomsLen);
+ gStaticAtomsDone = true;
+}
+
+void NS_ShutdownAtomTable() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(gAtomTable);
+
+#ifdef NS_FREE_PERMANENT_DATA
+ // Do a final GC to satisfy leak checking. We skip this step in release
+ // builds.
+ gAtomTable->GC(GCKind::Shutdown);
+#endif
+
+ delete gAtomTable;
+ gAtomTable = nullptr;
+}
+
+void NS_AddSizeOfAtoms(MallocSizeOf aMallocSizeOf, AtomsSizes& aSizes) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->AddSizeOfIncludingThis(aMallocSizeOf, aSizes);
+}
+
+void nsAtomSubTable::AddSizeOfExcludingThisLocked(MallocSizeOf aMallocSizeOf,
+ AtomsSizes& aSizes) {
+ mLock.AssertCurrentThreadOwns();
+ aSizes.mTable += mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (auto iter = mTable.Iter(); !iter.Done(); iter.Next()) {
+ auto entry = static_cast<AtomTableEntry*>(iter.Get());
+ entry->mAtom->AddSizeOfIncludingThis(aMallocSizeOf, aSizes);
+ }
+}
+
+void nsAtomTable::RegisterStaticAtoms(const nsStaticAtom* aAtoms,
+ size_t aAtomsLen) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_RELEASE_ASSERT(!gStaticAtomsDone, "Static atom insertion is finished!");
+
+ for (uint32_t i = 0; i < aAtomsLen; ++i) {
+ const nsStaticAtom* atom = &aAtoms[i];
+ MOZ_ASSERT(IsAsciiNullTerminated(atom->String()));
+ MOZ_ASSERT(NS_strlen(atom->String()) == atom->GetLength());
+ MOZ_ASSERT(atom->IsAsciiLowercase() ==
+ ::IsAsciiLowercase(atom->String(), atom->GetLength()));
+
+ // This assertion ensures the static atom's precomputed hash value matches
+ // what would be computed by mozilla::HashString(aStr), which is what we use
+ // when atomizing strings. We compute this hash in Atom.py.
+ MOZ_ASSERT(HashString(atom->String()) == atom->hash());
+
+ AtomTableKey key(atom);
+ nsAtomSubTable& table = SelectSubTable(key);
+ MutexAutoLock lock(table.mLock);
+ AtomTableEntry* he = table.Add(key);
+
+ if (he->mAtom) {
+ // There are two ways we could get here.
+ // - Register two static atoms with the same string.
+ // - Create a dynamic atom and then register a static atom with the same
+ // string while the dynamic atom is alive.
+ // Both cases can cause subtle bugs, and are disallowed. We're
+ // programming in C++ here, not Smalltalk.
+ nsAutoCString name;
+ he->mAtom->ToUTF8String(name);
+ MOZ_CRASH_UNSAFE_PRINTF("Atom for '%s' already exists", name.get());
+ }
+ he->mAtom = const_cast<nsStaticAtom*>(atom);
+ }
+}
+
+already_AddRefed<nsAtom> NS_Atomize(const char* aUTF8String) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->Atomize(nsDependentCString(aUTF8String));
+}
+
+already_AddRefed<nsAtom> nsAtomTable::Atomize(const nsACString& aUTF8String) {
+ bool err;
+ AtomTableKey key(aUTF8String.Data(), aUTF8String.Length(), &err);
+ if (MOZ_UNLIKELY(err)) {
+ MOZ_ASSERT_UNREACHABLE("Tried to atomize invalid UTF-8.");
+ // The input was invalid UTF-8. Let's replace the errors with U+FFFD
+ // and atomize the result.
+ nsString str;
+ CopyUTF8toUTF16(aUTF8String, str);
+ return Atomize(str);
+ }
+ nsAtomSubTable& table = SelectSubTable(key);
+ MutexAutoLock lock(table.mLock);
+ AtomTableEntry* he = table.Add(key);
+
+ if (he->mAtom) {
+ RefPtr<nsAtom> atom = he->mAtom;
+ return atom.forget();
+ }
+
+ nsString str;
+ CopyUTF8toUTF16(aUTF8String, str);
+ RefPtr<nsAtom> atom = dont_AddRef(nsDynamicAtom::Create(str, key.mHash));
+
+ he->mAtom = atom;
+
+ return atom.forget();
+}
+
+already_AddRefed<nsAtom> NS_Atomize(const nsACString& aUTF8String) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->Atomize(aUTF8String);
+}
+
+already_AddRefed<nsAtom> NS_Atomize(const char16_t* aUTF16String) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->Atomize(nsDependentString(aUTF16String));
+}
+
+already_AddRefed<nsAtom> nsAtomTable::Atomize(const nsAString& aUTF16String) {
+ AtomTableKey key(aUTF16String.Data(), aUTF16String.Length());
+ nsAtomSubTable& table = SelectSubTable(key);
+ MutexAutoLock lock(table.mLock);
+ AtomTableEntry* he = table.Add(key);
+
+ if (he->mAtom) {
+ RefPtr<nsAtom> atom = he->mAtom;
+ return atom.forget();
+ }
+
+ RefPtr<nsAtom> atom =
+ dont_AddRef(nsDynamicAtom::Create(aUTF16String, key.mHash));
+ he->mAtom = atom;
+
+ return atom.forget();
+}
+
+already_AddRefed<nsAtom> NS_Atomize(const nsAString& aUTF16String) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->Atomize(aUTF16String);
+}
+
+already_AddRefed<nsAtom> nsAtomTable::AtomizeMainThread(
+ const nsAString& aUTF16String) {
+ MOZ_ASSERT(NS_IsMainThread());
+ RefPtr<nsAtom> retVal;
+ AtomTableKey key(aUTF16String.Data(), aUTF16String.Length());
+ auto p = sRecentlyUsedMainThreadAtoms.Lookup(key);
+ if (p) {
+ retVal = p.Data();
+ return retVal.forget();
+ }
+
+ nsAtomSubTable& table = SelectSubTable(key);
+ MutexAutoLock lock(table.mLock);
+ AtomTableEntry* he = table.Add(key);
+
+ if (he->mAtom) {
+ retVal = he->mAtom;
+ } else {
+ RefPtr<nsAtom> newAtom =
+ dont_AddRef(nsDynamicAtom::Create(aUTF16String, key.mHash));
+ he->mAtom = newAtom;
+ retVal = std::move(newAtom);
+ }
+
+ p.Set(retVal);
+ return retVal.forget();
+}
+
+already_AddRefed<nsAtom> NS_AtomizeMainThread(const nsAString& aUTF16String) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->AtomizeMainThread(aUTF16String);
+}
+
+nsrefcnt NS_GetNumberOfAtoms(void) {
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->RacySlowCount();
+}
+
+int32_t NS_GetUnusedAtomCount(void) { return nsDynamicAtom::gUnusedAtomCount; }
+
+nsStaticAtom* NS_GetStaticAtom(const nsAString& aUTF16String) {
+ MOZ_ASSERT(gStaticAtomsDone, "Static atom setup not yet done.");
+ MOZ_ASSERT(gAtomTable);
+ return gAtomTable->GetStaticAtom(aUTF16String);
+}
+
+nsStaticAtom* nsAtomTable::GetStaticAtom(const nsAString& aUTF16String) {
+ AtomTableKey key(aUTF16String.Data(), aUTF16String.Length());
+ nsAtomSubTable& table = SelectSubTable(key);
+ MutexAutoLock lock(table.mLock);
+ AtomTableEntry* he = table.Search(key);
+ return he && he->mAtom->IsStatic() ? static_cast<nsStaticAtom*>(he->mAtom)
+ : nullptr;
+}
+
+void ToLowerCaseASCII(RefPtr<nsAtom>& aAtom) {
+ // Assume the common case is that the atom is already ASCII lowercase.
+ if (aAtom->IsAsciiLowercase()) {
+ return;
+ }
+
+ nsAutoString lowercased;
+ ToLowerCaseASCII(nsDependentAtomString(aAtom), lowercased);
+ aAtom = NS_Atomize(lowercased);
+}
diff --git a/xpcom/ds/nsAtomTable.h b/xpcom/ds/nsAtomTable.h
new file mode 100644
index 0000000000..ac69daea9f
--- /dev/null
+++ b/xpcom/ds/nsAtomTable.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsAtomTable_h__
+#define nsAtomTable_h__
+
+#include "mozilla/MemoryReporting.h"
+#include "nsAtom.h"
+
+#include <stddef.h>
+
+void NS_InitAtomTable();
+void NS_ShutdownAtomTable();
+
+namespace mozilla {
+struct AtomsSizes {
+ size_t mTable;
+ size_t mDynamicAtoms;
+
+ AtomsSizes() : mTable(0), mDynamicAtoms(0) {}
+};
+} // namespace mozilla
+
+void NS_AddSizeOfAtoms(mozilla::MallocSizeOf aMallocSizeOf,
+ mozilla::AtomsSizes& aSizes);
+
+#endif // nsAtomTable_h__
diff --git a/xpcom/ds/nsBaseHashtable.h b/xpcom/ds/nsBaseHashtable.h
new file mode 100644
index 0000000000..7b57ef4666
--- /dev/null
+++ b/xpcom/ds/nsBaseHashtable.h
@@ -0,0 +1,1029 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsBaseHashtable_h__
+#define nsBaseHashtable_h__
+
+#include <functional>
+#include <utility>
+
+#include "mozilla/dom/SafeRefPtr.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Result.h"
+#include "mozilla/UniquePtr.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsHashtablesFwd.h"
+#include "nsTHashtable.h"
+
+namespace mozilla::detail {
+
+template <typename SmartPtr>
+struct SmartPtrTraits {
+ static constexpr bool IsSmartPointer = false;
+ static constexpr bool IsRefCounted = false;
+};
+
+template <typename Pointee>
+struct SmartPtrTraits<UniquePtr<Pointee>> {
+ static constexpr bool IsSmartPointer = true;
+ static constexpr bool IsRefCounted = false;
+ using SmartPointerType = UniquePtr<Pointee>;
+ using PointeeType = Pointee;
+ using RawPointerType = Pointee*;
+ template <typename U>
+ using OtherSmartPtrType = UniquePtr<U>;
+
+ template <typename U, typename... Args>
+ static SmartPointerType NewObject(Args&&... aConstructionArgs) {
+ return mozilla::MakeUnique<U>(std::forward<Args>(aConstructionArgs)...);
+ }
+};
+
+template <typename Pointee>
+struct SmartPtrTraits<RefPtr<Pointee>> {
+ static constexpr bool IsSmartPointer = true;
+ static constexpr bool IsRefCounted = true;
+ using SmartPointerType = RefPtr<Pointee>;
+ using PointeeType = Pointee;
+ using RawPointerType = Pointee*;
+ template <typename U>
+ using OtherSmartPtrType = RefPtr<U>;
+
+ template <typename U, typename... Args>
+ static SmartPointerType NewObject(Args&&... aConstructionArgs) {
+ return MakeRefPtr<U>(std::forward<Args>(aConstructionArgs)...);
+ }
+};
+
+template <typename Pointee>
+struct SmartPtrTraits<SafeRefPtr<Pointee>> {
+ static constexpr bool IsSmartPointer = true;
+ static constexpr bool IsRefCounted = true;
+ using SmartPointerType = SafeRefPtr<Pointee>;
+ using PointeeType = Pointee;
+ using RawPointerType = Pointee*;
+ template <typename U>
+ using OtherSmartPtrType = SafeRefPtr<U>;
+
+ template <typename U, typename... Args>
+ static SmartPointerType NewObject(Args&&... aConstructionArgs) {
+ return MakeSafeRefPtr<U>(std::forward<Args>(aConstructionArgs)...);
+ }
+};
+
+template <typename Pointee>
+struct SmartPtrTraits<nsCOMPtr<Pointee>> {
+ static constexpr bool IsSmartPointer = true;
+ static constexpr bool IsRefCounted = true;
+ using SmartPointerType = nsCOMPtr<Pointee>;
+ using PointeeType = Pointee;
+ using RawPointerType = Pointee*;
+ template <typename U>
+ using OtherSmartPtrType = nsCOMPtr<U>;
+
+ template <typename U, typename... Args>
+ static SmartPointerType NewObject(Args&&... aConstructionArgs) {
+ return MakeRefPtr<U>(std::forward<Args>(aConstructionArgs)...);
+ }
+};
+
+template <class T>
+T* PtrGetWeak(T* aPtr) {
+ return aPtr;
+}
+
+template <class T>
+T* PtrGetWeak(const RefPtr<T>& aPtr) {
+ return aPtr.get();
+}
+
+template <class T>
+T* PtrGetWeak(const SafeRefPtr<T>& aPtr) {
+ return aPtr.unsafeGetRawPtr();
+}
+
+template <class T>
+T* PtrGetWeak(const nsCOMPtr<T>& aPtr) {
+ return aPtr.get();
+}
+
+template <class T>
+T* PtrGetWeak(const UniquePtr<T>& aPtr) {
+ return aPtr.get();
+}
+
+template <typename EntryType>
+class nsBaseHashtableValueIterator : public ::detail::nsTHashtableIteratorBase {
+ // friend class nsTHashtable<EntryType>;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = const std::decay_t<typename EntryType::DataType>;
+ using difference_type = int32_t;
+ using pointer = value_type*;
+ using reference = value_type&;
+
+ using iterator_type = nsBaseHashtableValueIterator;
+ using const_iterator_type = nsBaseHashtableValueIterator;
+
+ using nsTHashtableIteratorBase::nsTHashtableIteratorBase;
+
+ value_type* operator->() const {
+ return &static_cast<const EntryType*>(mIterator.Get())->GetData();
+ }
+ decltype(auto) operator*() const {
+ return static_cast<const EntryType*>(mIterator.Get())->GetData();
+ }
+
+ iterator_type& operator++() {
+ mIterator.Next();
+ return *this;
+ }
+ iterator_type operator++(int) {
+ iterator_type it = *this;
+ ++*this;
+ return it;
+ }
+};
+
+template <typename EntryType>
+class nsBaseHashtableValueRange {
+ public:
+ using IteratorType = nsBaseHashtableValueIterator<EntryType>;
+ using iterator = IteratorType;
+
+ explicit nsBaseHashtableValueRange(const PLDHashTable& aHashtable)
+ : mHashtable{aHashtable} {}
+
+ auto begin() const { return IteratorType{mHashtable}; }
+ auto end() const {
+ return IteratorType{mHashtable, typename IteratorType::EndIteratorTag{}};
+ }
+ auto cbegin() const { return begin(); }
+ auto cend() const { return end(); }
+
+ uint32_t Count() const { return mHashtable.EntryCount(); }
+
+ private:
+ const PLDHashTable& mHashtable;
+};
+
+template <typename EntryType>
+auto RangeSize(const detail::nsBaseHashtableValueRange<EntryType>& aRange) {
+ return aRange.Count();
+}
+
+} // namespace mozilla::detail
+
+/**
+ * Data type conversion helper that is used to wrap and unwrap the specified
+ * DataType.
+ */
+template <class DataType, class UserDataType>
+class nsDefaultConverter {
+ public:
+ /**
+ * Maps the storage DataType to the exposed UserDataType.
+ */
+ static UserDataType Unwrap(DataType& src) { return UserDataType(src); }
+
+ /**
+ * Const ref variant used for example with nsCOMPtr wrappers.
+ */
+ static DataType Wrap(const UserDataType& src) { return DataType(src); }
+
+ /**
+ * Generic conversion, this is useful for things like already_AddRefed.
+ */
+ template <typename U>
+ static DataType Wrap(U&& src) {
+ return std::forward<U>(src);
+ }
+
+ template <typename U>
+ static UserDataType Unwrap(U&& src) {
+ return std::forward<U>(src);
+ }
+};
+
+/**
+ * the private nsTHashtable::EntryType class used by nsBaseHashtable
+ * @see nsTHashtable for the specification of this class
+ * @see nsBaseHashtable for template parameters
+ */
+template <class KeyClass, class TDataType>
+class nsBaseHashtableET : public KeyClass {
+ public:
+ using DataType = TDataType;
+
+ const DataType& GetData() const { return mData; }
+ DataType* GetModifiableData() { return &mData; }
+ template <typename U>
+ void SetData(U&& aData) {
+ mData = std::forward<U>(aData);
+ }
+
+ decltype(auto) GetWeak() const {
+ return mozilla::detail::PtrGetWeak(GetData());
+ }
+
+ private:
+ DataType mData;
+ friend class nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
+ template <typename KeyClassX, typename DataTypeX, typename UserDataTypeX,
+ typename ConverterX>
+ friend class nsBaseHashtable;
+ friend class ::detail::nsTHashtableKeyIterator<
+ nsBaseHashtableET<KeyClass, DataType>>;
+
+ typedef typename KeyClass::KeyType KeyType;
+ typedef typename KeyClass::KeyTypePointer KeyTypePointer;
+
+ template <typename... Args>
+ explicit nsBaseHashtableET(KeyTypePointer aKey, Args&&... aArgs);
+ nsBaseHashtableET(nsBaseHashtableET<KeyClass, DataType>&& aToMove) = default;
+ ~nsBaseHashtableET() = default;
+};
+
+/**
+ * Templated hashtable. Usually, this isn't instantiated directly but through
+ * its sub-class templates nsInterfaceHashtable, nsClassHashtable,
+ * nsRefPtrHashtable and nsTHashMap.
+ *
+ * Originally, UserDataType used to be the only type exposed to the user in the
+ * public member function signatures (hence its name), but this has proven to
+ * inadequate over time. Now, UserDataType is only exposed in by-value
+ * getter member functions that are called *Get*. Member functions that provide
+ * access to the DataType are called Lookup rather than Get. Note that this rule
+ * does not apply to nsRefPtrHashtable and nsInterfaceHashtable, as they are
+ * provide a similar interface, but are no genuine sub-classes of
+ * nsBaseHashtable.
+ *
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ * @param DataType the datatype stored in the hashtable,
+ * for example, uint32_t or nsCOMPtr.
+ * @param UserDataType the datatype returned from the by-value getter member
+ * functions (named *Get*), for example uint32_t or nsISupports*
+ * @param Converter that is used to map from DataType to UserDataType. A
+ * default converter is provided that assumes implicit conversion is an
+ * option.
+ */
+template <class KeyClass, class DataType, class UserDataType, class Converter>
+class nsBaseHashtable
+ : protected nsTHashtable<nsBaseHashtableET<KeyClass, DataType>> {
+ using Base = nsTHashtable<nsBaseHashtableET<KeyClass, DataType>>;
+ typedef mozilla::fallible_t fallible_t;
+
+ public:
+ typedef typename KeyClass::KeyType KeyType;
+ typedef nsBaseHashtableET<KeyClass, DataType> EntryType;
+
+ using nsTHashtable<EntryType>::Contains;
+ using nsTHashtable<EntryType>::GetGeneration;
+ using nsTHashtable<EntryType>::SizeOfExcludingThis;
+ using nsTHashtable<EntryType>::SizeOfIncludingThis;
+
+ nsBaseHashtable() = default;
+ explicit nsBaseHashtable(uint32_t aInitLength)
+ : nsTHashtable<EntryType>(aInitLength) {}
+
+ /**
+ * Return the number of entries in the table.
+ * @return number of entries
+ */
+ [[nodiscard]] uint32_t Count() const {
+ return nsTHashtable<EntryType>::Count();
+ }
+
+ /**
+ * Return whether the table is empty.
+ * @return whether empty
+ */
+ [[nodiscard]] bool IsEmpty() const {
+ return nsTHashtable<EntryType>::IsEmpty();
+ }
+
+ /**
+ * Get the value, returning a flag indicating the presence of the entry in
+ * the table.
+ *
+ * @param aKey the key to retrieve
+ * @param aData data associated with this key will be placed at this pointer.
+ * If you only need to check if the key exists, aData may be null.
+ * @return true if the key exists. If key does not exist, aData is not
+ * modified.
+ *
+ * @attention As opposed to Remove, this does not assign a value to *aData if
+ * no entry is present! (And also as opposed to the member function Get with
+ * the same signature that nsClassHashtable defines and hides this one.)
+ */
+ [[nodiscard]] bool Get(KeyType aKey, UserDataType* aData) const {
+ EntryType* ent = this->GetEntry(aKey);
+ if (!ent) {
+ return false;
+ }
+
+ if (aData) {
+ *aData = Converter::Unwrap(ent->mData);
+ }
+
+ return true;
+ }
+
+ /**
+ * Get the value, returning a zero-initialized POD or a default-initialized
+ * object if the entry is not present in the table.
+ *
+ * This overload can only be used if UserDataType is default-constructible.
+ * Use the double-argument Get or MaybeGet with non-default-constructible
+ * UserDataType.
+ *
+ * @param aKey the key to retrieve
+ * @return The found value, or UserDataType{} if no entry was found with the
+ * given key.
+ * @note If zero/default-initialized values are stored in the table, it is
+ * not possible to distinguish between such a value and a missing entry.
+ */
+ [[nodiscard]] UserDataType Get(KeyType aKey) const {
+ EntryType* ent = this->GetEntry(aKey);
+ if (!ent) {
+ return UserDataType{};
+ }
+
+ return Converter::Unwrap(ent->mData);
+ }
+
+ /**
+ * Get the value, returning Nothing if the entry is not present in the table.
+ *
+ * @param aKey the key to retrieve
+ * @return The found value wrapped in a Maybe, or Nothing if no entry was
+ * found with the given key.
+ */
+ [[nodiscard]] mozilla::Maybe<UserDataType> MaybeGet(KeyType aKey) const {
+ EntryType* ent = this->GetEntry(aKey);
+ if (!ent) {
+ return mozilla::Nothing();
+ }
+
+ return mozilla::Some(Converter::Unwrap(ent->mData));
+ }
+
+ using SmartPtrTraits = mozilla::detail::SmartPtrTraits<DataType>;
+
+ /**
+ * Looks up aKey in the hash table. If it doesn't exist a new object of
+ * SmartPtrTraits::PointeeType will be created (using the arguments provided)
+ * and then returned.
+ *
+ * \note This can only be instantiated if DataType is a smart pointer.
+ */
+ template <typename... Args>
+ auto GetOrInsertNew(KeyType aKey, Args&&... aConstructionArgs) {
+ static_assert(
+ SmartPtrTraits::IsSmartPointer,
+ "GetOrInsertNew can only be used with smart pointer data types");
+ return mozilla::detail::PtrGetWeak(LookupOrInsertWith(std::move(aKey), [&] {
+ return SmartPtrTraits::template NewObject<
+ typename SmartPtrTraits::PointeeType>(
+ std::forward<Args>(aConstructionArgs)...);
+ }));
+ }
+
+ /**
+ * Add aKey to the table if not already present, and return a reference to its
+ * value. If aKey is not already in the table then the a default-constructed
+ * or the provided value aData is used.
+ *
+ * If the arguments are non-trivial to provide, consider using
+ * LookupOrInsertWith instead.
+ */
+ template <typename... Args>
+ DataType& LookupOrInsert(const KeyType& aKey, Args&&... aArgs) {
+ return WithEntryHandle(aKey, [&](auto entryHandle) -> DataType& {
+ return entryHandle.OrInsert(std::forward<Args>(aArgs)...);
+ });
+ }
+
+ /**
+ * Add aKey to the table if not already present, and return a reference to its
+ * value. If aKey is not already in the table then the value is
+ * constructed using the given factory.
+ */
+ template <typename F>
+ DataType& LookupOrInsertWith(const KeyType& aKey, F&& aFunc) {
+ return WithEntryHandle(aKey, [&aFunc](auto entryHandle) -> DataType& {
+ return entryHandle.OrInsertWith(std::forward<F>(aFunc));
+ });
+ }
+
+ /**
+ * Add aKey to the table if not already present, and return a reference to its
+ * value. If aKey is not already in the table then the value is
+ * constructed using the given factory.
+ */
+ template <typename F>
+ [[nodiscard]] auto TryLookupOrInsertWith(const KeyType& aKey, F&& aFunc) {
+ return WithEntryHandle(
+ aKey,
+ [&aFunc](auto entryHandle)
+ -> mozilla::Result<std::reference_wrapper<DataType>,
+ typename std::invoke_result_t<F>::err_type> {
+ if (entryHandle) {
+ return std::ref(entryHandle.Data());
+ }
+
+ // XXX Use MOZ_TRY after generalizing QM_TRY to mfbt.
+ auto res = std::forward<F>(aFunc)();
+ if (res.isErr()) {
+ return res.propagateErr();
+ }
+ return std::ref(entryHandle.Insert(res.unwrap()));
+ });
+ }
+
+ /**
+ * If it does not yet, inserts a new entry with the handle's key and the
+ * value passed to this function. Otherwise, it updates the entry by the
+ * value passed to this function.
+ *
+ * \tparam U DataType must be implicitly convertible (and assignable) from U
+ * \post HasEntry()
+ * \param aKey the key to put
+ * \param aData the new data
+ */
+ template <typename U>
+ DataType& InsertOrUpdate(KeyType aKey, U&& aData) {
+ return WithEntryHandle(aKey, [&aData](auto entryHandle) -> DataType& {
+ return entryHandle.InsertOrUpdate(std::forward<U>(aData));
+ });
+ }
+
+ template <typename U>
+ [[nodiscard]] bool InsertOrUpdate(KeyType aKey, U&& aData,
+ const fallible_t& aFallible) {
+ return WithEntryHandle(aKey, aFallible, [&aData](auto maybeEntryHandle) {
+ if (!maybeEntryHandle) {
+ return false;
+ }
+ maybeEntryHandle->InsertOrUpdate(std::forward<U>(aData));
+ return true;
+ });
+ }
+
+ /**
+ * Remove the entry associated with aKey (if any), _moving_ its current value
+ * into *aData. Return true if found.
+ *
+ * This overload can only be used if DataType is default-constructible. Use
+ * the single-argument Remove or Extract with non-default-constructible
+ * DataType.
+ *
+ * @param aKey the key to remove from the hashtable
+ * @param aData where to move the value. If an entry is not found, *aData
+ * will be assigned a default-constructed value (i.e. reset to
+ * zero or nullptr for primitive types).
+ * @return true if an entry for aKey was found (and removed)
+ */
+ // XXX This should also better be marked nodiscard, but due to
+ // nsClassHashtable not guaranteeing non-nullness of entries, it is usually
+ // only checked if aData is nullptr in such cases.
+ // [[nodiscard]]
+ bool Remove(KeyType aKey, DataType* aData) {
+ if (auto* ent = this->GetEntry(aKey)) {
+ if (aData) {
+ *aData = std::move(ent->mData);
+ }
+ this->RemoveEntry(ent);
+ return true;
+ }
+ if (aData) {
+ *aData = std::move(DataType());
+ }
+ return false;
+ }
+
+ /**
+ * Remove the entry associated with aKey (if any). Return true if found.
+ *
+ * @param aKey the key to remove from the hashtable
+ * @return true if an entry for aKey was found (and removed)
+ */
+ bool Remove(KeyType aKey) {
+ if (auto* ent = this->GetEntry(aKey)) {
+ this->RemoveEntry(ent);
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Retrieve the value for a key and remove the corresponding entry at
+ * the same time.
+ *
+ * @param aKey the key to retrieve and remove
+ * @return the found value, or Nothing if no entry was found with the
+ * given key.
+ */
+ [[nodiscard]] mozilla::Maybe<DataType> Extract(KeyType aKey) {
+ mozilla::Maybe<DataType> value;
+ if (EntryType* ent = this->GetEntry(aKey)) {
+ value.emplace(std::move(ent->mData));
+ this->RemoveEntry(ent);
+ }
+ return value;
+ }
+
+ template <typename HashtableRef>
+ struct LookupResult {
+ private:
+ EntryType* mEntry;
+ HashtableRef mTable;
+#ifdef DEBUG
+ uint32_t mTableGeneration;
+#endif
+
+ public:
+ LookupResult(EntryType* aEntry, HashtableRef aTable)
+ : mEntry(aEntry),
+ mTable(aTable)
+#ifdef DEBUG
+ ,
+ mTableGeneration(aTable.GetGeneration())
+#endif
+ {
+ }
+
+ // Is there something stored in the table?
+ explicit operator bool() const {
+ MOZ_ASSERT(mTableGeneration == mTable.GetGeneration());
+ return mEntry;
+ }
+
+ void Remove() {
+ if (!*this) {
+ return;
+ }
+ mTable.RemoveEntry(mEntry);
+ mEntry = nullptr;
+ }
+
+ [[nodiscard]] DataType& Data() {
+ MOZ_ASSERT(!!*this, "must have an entry to access its value");
+ return mEntry->mData;
+ }
+
+ [[nodiscard]] const DataType& Data() const {
+ MOZ_ASSERT(!!*this, "must have an entry to access its value");
+ return mEntry->mData;
+ }
+
+ [[nodiscard]] DataType* DataPtrOrNull() {
+ return static_cast<bool>(*this) ? &mEntry->mData : nullptr;
+ }
+
+ [[nodiscard]] const DataType* DataPtrOrNull() const {
+ return static_cast<bool>(*this) ? &mEntry->mData : nullptr;
+ }
+
+ [[nodiscard]] DataType* operator->() { return &Data(); }
+ [[nodiscard]] const DataType* operator->() const { return &Data(); }
+
+ [[nodiscard]] DataType& operator*() { return Data(); }
+ [[nodiscard]] const DataType& operator*() const { return Data(); }
+ };
+
+ /**
+ * Removes all entries matching a predicate.
+ *
+ * The predicate must be compatible with signature bool (const Iterator &).
+ */
+ template <typename Pred>
+ void RemoveIf(Pred&& aPred) {
+ for (auto iter = Iter(); !iter.Done(); iter.Next()) {
+ if (aPred(const_cast<std::add_const_t<decltype(iter)>&>(iter))) {
+ iter.Remove();
+ }
+ }
+ }
+
+ /**
+ * Looks up aKey in the hashtable and returns an object that allows you to
+ * read/modify the value of the entry, or remove the entry (if found).
+ *
+ * A typical usage of this API looks like this:
+ *
+ * if (auto entry = hashtable.Lookup(key)) {
+ * DoSomething(entry.Data());
+ * if (entry.Data() > 42) {
+ * entry.Remove();
+ * }
+ * } // else - an entry with the given key doesn't exist
+ *
+ * This is useful for cases where you want to read/write the value of an entry
+ * and (optionally) remove the entry without having to do multiple hashtable
+ * lookups. If you want to insert a new entry if one does not exist, then use
+ * WithEntryHandle instead, see below.
+ */
+ [[nodiscard]] auto Lookup(KeyType aKey) {
+ return LookupResult<nsBaseHashtable&>(this->GetEntry(aKey), *this);
+ }
+
+ [[nodiscard]] auto Lookup(KeyType aKey) const {
+ return LookupResult<const nsBaseHashtable&>(this->GetEntry(aKey), *this);
+ }
+
+ /**
+ * Used by WithEntryHandle as the argument type to its functor. It is
+ * associated with the Key passed to WithEntryHandle and manages only the
+ * potential entry with that key. Note that in case no modifying operations
+ * are called on the handle, the state of the hashtable remains unchanged,
+ * i.e. WithEntryHandle does not modify the hashtable itself.
+ *
+ * Provides query functions (Key, HasEntry/operator bool, Data) and
+ * modifying operations for inserting new entries (Insert), updating existing
+ * entries (Update) and removing existing entries (Remove). They have
+ * debug-only assertion that fail when the state of the entry doesn't match
+ * the expectation. There are variants prefixed with "Or" (OrInsert, OrUpdate,
+ * OrRemove) that are a no-op in case the entry does already exist resp. does
+ * not exist. There are also variants OrInsertWith and OrUpdateWith that don't
+ * accept a value, but a functor, which is only called if the operation takes
+ * place, which should be used if the provision of the value is not trivial
+ * (e.g. allocates a heap object). Finally, there's InsertOrUpdate that
+ * handles both existing and non-existing entries.
+ *
+ * Note that all functions of EntryHandle only deal with DataType, not with
+ * UserDataType.
+ */
+ class EntryHandle : protected nsTHashtable<EntryType>::EntryHandle {
+ public:
+ using Base = typename nsTHashtable<EntryType>::EntryHandle;
+
+ EntryHandle(EntryHandle&& aOther) = default;
+ ~EntryHandle() = default;
+
+ EntryHandle(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&&) = delete;
+
+ using Base::Key;
+
+ using Base::HasEntry;
+
+ using Base::operator bool;
+
+ using Base::Entry;
+
+ /**
+ * Inserts a new entry with the handle's key and the value passed to this
+ * function.
+ *
+ * \tparam Args DataType must be constructible from Args
+ * \pre !HasEntry()
+ * \post HasEntry()
+ */
+ template <typename... Args>
+ DataType& Insert(Args&&... aArgs) {
+ Base::InsertInternal(std::forward<Args>(aArgs)...);
+ return Data();
+ }
+
+ /**
+ * If it doesn't yet exist, inserts a new entry with the handle's key and
+ * the value passed to this function. The value is not consumed if no insert
+ * takes place.
+ *
+ * \tparam Args DataType must be constructible from Args
+ * \post HasEntry()
+ */
+ template <typename... Args>
+ DataType& OrInsert(Args&&... aArgs) {
+ if (!HasEntry()) {
+ return Insert(std::forward<Args>(aArgs)...);
+ }
+ return Data();
+ }
+
+ /**
+ * If it doesn't yet exist, inserts a new entry with the handle's key and
+ * the result of the functor passed to this function. The functor is not
+ * called if no insert takes place.
+ *
+ * \tparam F must return a value that is implicitly convertible to DataType
+ * \post HasEntry()
+ */
+ template <typename F>
+ DataType& OrInsertWith(F&& aFunc) {
+ if (!HasEntry()) {
+ return Insert(std::forward<F>(aFunc)());
+ }
+ return Data();
+ }
+
+ /**
+ * Updates the entry with the handle's key by the value passed to this
+ * function.
+ *
+ * \tparam U DataType must be assignable from U
+ * \pre HasEntry()
+ */
+ template <typename U>
+ DataType& Update(U&& aData) {
+ MOZ_RELEASE_ASSERT(HasEntry());
+ Data() = std::forward<U>(aData);
+ return Data();
+ }
+
+ /**
+ * If an entry with the handle's key already exists, updates its value by
+ * the value passed to this function. The value is not consumed if no update
+ * takes place.
+ *
+ * \tparam U DataType must be assignable from U
+ */
+ template <typename U>
+ void OrUpdate(U&& aData) {
+ if (HasEntry()) {
+ Update(std::forward<U>(aData));
+ }
+ }
+
+ /**
+ * If an entry with the handle's key already exists, updates its value by
+ * the the result of the functor passed to this function. The functor is not
+ * called if no update takes place.
+ *
+ * \tparam F must return a value that DataType is assignable from
+ */
+ template <typename F>
+ void OrUpdateWith(F&& aFunc) {
+ if (HasEntry()) {
+ Update(std::forward<F>(aFunc)());
+ }
+ }
+
+ /**
+ * If it does not yet, inserts a new entry with the handle's key and the
+ * value passed to this function. Otherwise, it updates the entry by the
+ * value passed to this function.
+ *
+ * \tparam U DataType must be implicitly convertible (and assignable) from U
+ * \post HasEntry()
+ */
+ template <typename U>
+ DataType& InsertOrUpdate(U&& aData) {
+ if (!HasEntry()) {
+ Insert(std::forward<U>(aData));
+ } else {
+ Update(std::forward<U>(aData));
+ }
+ return Data();
+ }
+
+ using Base::Remove;
+
+ using Base::OrRemove;
+
+ /**
+ * Returns a reference to the value of the entry.
+ *
+ * \pre HasEntry()
+ */
+ [[nodiscard]] DataType& Data() { return Entry()->mData; }
+
+ [[nodiscard]] DataType* DataPtrOrNull() {
+ return static_cast<bool>(*this) ? &Data() : nullptr;
+ }
+
+ [[nodiscard]] DataType* operator->() { return &Data(); }
+
+ [[nodiscard]] DataType& operator*() { return Data(); }
+
+ private:
+ friend class nsBaseHashtable;
+
+ explicit EntryHandle(Base&& aBase) : Base(std::move(aBase)) {}
+ };
+
+ /**
+ * Performs a scoped operation on the entry for aKey, which may or may not
+ * exist when the function is called. It calls aFunc with an EntryHandle. The
+ * result of aFunc is returned as the result of this function. Its return type
+ * may be void. See the documentation of EntryHandle for the query and
+ * modifying operations it offers.
+ *
+ * A simple use of this function is, e.g.,
+ *
+ * hashtable.WithEntryHandle(key, [](auto&& entry) { entry.OrInsert(42); });
+ *
+ * \attention It is not safe to perform modifying operations on the hashtable
+ * other than through the EntryHandle within aFunc, and trying to do so will
+ * trigger debug assertions, and result in undefined behaviour otherwise.
+ */
+ template <class F>
+ [[nodiscard]] auto WithEntryHandle(KeyType aKey, F&& aFunc)
+ -> std::invoke_result_t<F, EntryHandle&&> {
+ return Base::WithEntryHandle(
+ aKey, [&aFunc](auto entryHandle) -> decltype(auto) {
+ return std::forward<F>(aFunc)(EntryHandle{std::move(entryHandle)});
+ });
+ }
+
+ /**
+ * Fallible variant of WithEntryHandle, with the following differences:
+ * - The functor aFunc must accept a Maybe<EntryHandle> (instead of an
+ * EntryHandle).
+ * - In case allocation of the slot for the entry fails, Nothing is passed to
+ * the functor.
+ *
+ * For more details, see the explanation on the non-fallible overload above.
+ */
+ template <class F>
+ [[nodiscard]] auto WithEntryHandle(KeyType aKey, const fallible_t& aFallible,
+ F&& aFunc)
+ -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
+ return Base::WithEntryHandle(
+ aKey, aFallible, [&aFunc](auto maybeEntryHandle) {
+ return std::forward<F>(aFunc)(
+ maybeEntryHandle
+ ? mozilla::Some(EntryHandle{maybeEntryHandle.extract()})
+ : mozilla::Nothing());
+ });
+ }
+
+ public:
+ class ConstIterator {
+ public:
+ explicit ConstIterator(nsBaseHashtable* aTable)
+ : mBaseIterator(&aTable->mTable) {}
+ ~ConstIterator() = default;
+
+ KeyType Key() const {
+ return static_cast<EntryType*>(mBaseIterator.Get())->GetKey();
+ }
+ UserDataType UserData() const {
+ return Converter::Unwrap(
+ static_cast<EntryType*>(mBaseIterator.Get())->mData);
+ }
+ const DataType& Data() const {
+ return static_cast<EntryType*>(mBaseIterator.Get())->mData;
+ }
+
+ bool Done() const { return mBaseIterator.Done(); }
+ void Next() { mBaseIterator.Next(); }
+
+ ConstIterator() = delete;
+ ConstIterator(const ConstIterator&) = delete;
+ ConstIterator(ConstIterator&& aOther) = delete;
+ ConstIterator& operator=(const ConstIterator&) = delete;
+ ConstIterator& operator=(ConstIterator&&) = delete;
+
+ protected:
+ PLDHashTable::Iterator mBaseIterator;
+ };
+
+ // This is an iterator that also allows entry removal. Example usage:
+ //
+ // for (auto iter = table.Iter(); !iter.Done(); iter.Next()) {
+ // const KeyType key = iter.Key();
+ // const UserDataType data = iter.UserData();
+ // // or
+ // const DataType& data = iter.Data();
+ // // ... do stuff with |key| and/or |data| ...
+ // // ... possibly call iter.Remove() once ...
+ // }
+ //
+ class Iterator final : public ConstIterator {
+ public:
+ using ConstIterator::ConstIterator;
+
+ using ConstIterator::Data;
+ DataType& Data() {
+ return static_cast<EntryType*>(this->mBaseIterator.Get())->mData;
+ }
+
+ void Remove() { this->mBaseIterator.Remove(); }
+ };
+
+ Iterator Iter() { return Iterator(this); }
+
+ ConstIterator ConstIter() const {
+ return ConstIterator(const_cast<nsBaseHashtable*>(this));
+ }
+
+ using nsTHashtable<EntryType>::Remove;
+
+ /**
+ * Remove the entry associated with aIter.
+ *
+ * @param aIter the iterator pointing to the entry
+ * @pre !aIter.Done()
+ */
+ void Remove(ConstIterator& aIter) { aIter.mBaseIterator.Remove(); }
+
+ using typename nsTHashtable<EntryType>::iterator;
+ using typename nsTHashtable<EntryType>::const_iterator;
+
+ using nsTHashtable<EntryType>::begin;
+ using nsTHashtable<EntryType>::end;
+ using nsTHashtable<EntryType>::cbegin;
+ using nsTHashtable<EntryType>::cend;
+
+ using nsTHashtable<EntryType>::Keys;
+
+ /**
+ * Return a range of the values (of DataType). Note this range iterates over
+ * the values in place, so modifications to the nsTHashtable invalidate the
+ * range while it's iterated, except when calling Remove() with a value
+ * iterator derived from that range.
+ */
+ auto Values() const {
+ return mozilla::detail::nsBaseHashtableValueRange<EntryType>{this->mTable};
+ }
+
+ /**
+ * Remove an entry from a value range, specified via a value iterator, e.g.
+ *
+ * for (auto it = hash.Values().begin(), end = hash.Values().end();
+ * it != end; * ++it) {
+ * if (*it > 42) { hash.Remove(it); }
+ * }
+ *
+ * You might also consider using RemoveIf though.
+ */
+ void Remove(mozilla::detail::nsBaseHashtableValueIterator<EntryType>& aIter) {
+ aIter.mIterator.Remove();
+ }
+
+ /**
+ * reset the hashtable, removing all entries
+ */
+ void Clear() { nsTHashtable<EntryType>::Clear(); }
+
+ /**
+ * Measure the size of the table's entry storage. The size of things pointed
+ * to by entries must be measured separately; hence the "Shallow" prefix.
+ *
+ * @param aMallocSizeOf the function used to measure heap-allocated blocks
+ * @return the summed size of the table's storage
+ */
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return this->mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ /**
+ * Like ShallowSizeOfExcludingThis, but includes sizeof(*this).
+ */
+ size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ /**
+ * Swap the elements in this hashtable with the elements in aOther.
+ */
+ void SwapElements(nsBaseHashtable& aOther) {
+ nsTHashtable<EntryType>::SwapElements(aOther);
+ }
+
+ using nsTHashtable<EntryType>::MarkImmutable;
+
+ /**
+ * Makes a clone of this hashtable by copying all entries. This requires
+ * KeyType and DataType to be copy-constructible.
+ */
+ nsBaseHashtable Clone() const { return CloneAs<nsBaseHashtable>(); }
+
+ protected:
+ template <typename T>
+ T CloneAs() const {
+ static_assert(std::is_base_of_v<nsBaseHashtable, T>);
+ // XXX This can probably be optimized, see Bug 1694368.
+ T result(Count());
+ for (const auto& srcEntry : *this) {
+ result.WithEntryHandle(srcEntry.GetKey(), [&](auto&& dstEntry) {
+ dstEntry.Insert(srcEntry.GetData());
+ });
+ }
+ return result;
+ }
+};
+
+//
+// nsBaseHashtableET definitions
+//
+
+template <class KeyClass, class DataType>
+template <typename... Args>
+nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(KeyTypePointer aKey,
+ Args&&... aArgs)
+ : KeyClass(aKey), mData(std::forward<Args>(aArgs)...) {}
+
+#endif // nsBaseHashtable_h__
diff --git a/xpcom/ds/nsCOMArray.cpp b/xpcom/ds/nsCOMArray.cpp
new file mode 100644
index 0000000000..d388857573
--- /dev/null
+++ b/xpcom/ds/nsCOMArray.cpp
@@ -0,0 +1,252 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsCOMArray.h"
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/OperatorNewExtensions.h"
+#include "nsQuickSort.h"
+
+#include "nsCOMPtr.h"
+
+// This specialization is private to nsCOMArray.
+// It exists solely to automatically zero-out newly created array elements.
+template <>
+class nsTArrayElementTraits<nsISupports*> {
+ typedef nsISupports* E;
+
+ public:
+ // Zero out the value
+ static inline void Construct(E* aE) {
+ new (mozilla::KnownNotNull, static_cast<void*>(aE)) E();
+ }
+ // Invoke the copy-constructor in place.
+ template <class A>
+ static inline void Construct(E* aE, const A& aArg) {
+ new (mozilla::KnownNotNull, static_cast<void*>(aE)) E(aArg);
+ }
+ // Construct in place.
+ template <class... Args>
+ static inline void Emplace(E* aE, Args&&... aArgs) {
+ new (mozilla::KnownNotNull, static_cast<void*>(aE))
+ E(std::forward<Args>(aArgs)...);
+ }
+ // Invoke the destructor in place.
+ static inline void Destruct(E* aE) { aE->~E(); }
+};
+
+static void ReleaseObjects(nsTArray<nsISupports*>& aArray);
+
+// implementations of non-trivial methods in nsCOMArray_base
+
+nsCOMArray_base::nsCOMArray_base(const nsCOMArray_base& aOther) {
+ // make sure we do only one allocation
+ mArray.SetCapacity(aOther.Count());
+ AppendObjects(aOther);
+}
+
+nsCOMArray_base::~nsCOMArray_base() { Clear(); }
+
+int32_t nsCOMArray_base::IndexOf(nsISupports* aObject,
+ uint32_t aStartIndex) const {
+ return mArray.IndexOf(aObject, aStartIndex);
+}
+
+int32_t nsCOMArray_base::IndexOfObject(nsISupports* aObject) const {
+ nsCOMPtr<nsISupports> supports = do_QueryInterface(aObject);
+ if (NS_WARN_IF(!supports)) {
+ return -1;
+ }
+
+ uint32_t i, count;
+ int32_t retval = -1;
+ count = mArray.Length();
+ for (i = 0; i < count; ++i) {
+ nsCOMPtr<nsISupports> arrayItem = do_QueryInterface(mArray[i]);
+ if (arrayItem == supports) {
+ retval = i;
+ break;
+ }
+ }
+ return retval;
+}
+
+bool nsCOMArray_base::EnumerateForwards(nsBaseArrayEnumFunc aFunc,
+ void* aData) const {
+ for (uint32_t index = 0; index < mArray.Length(); ++index) {
+ if (!(*aFunc)(mArray[index], aData)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool nsCOMArray_base::EnumerateBackwards(nsBaseArrayEnumFunc aFunc,
+ void* aData) const {
+ for (uint32_t index = mArray.Length(); index--;) {
+ if (!(*aFunc)(mArray[index], aData)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+int nsCOMArray_base::VoidStarComparator(const void* aElement1,
+ const void* aElement2, void* aData) {
+ auto ctx = static_cast<nsISupportsComparatorContext*>(aData);
+ return (*ctx->mComparatorFunc)(*static_cast<nsISupports* const*>(aElement1),
+ *static_cast<nsISupports* const*>(aElement2),
+ ctx->mData);
+}
+
+void nsCOMArray_base::Sort(nsISupportsComparatorFunc aFunc, void* aData) {
+ if (mArray.Length() > 1) {
+ nsISupportsComparatorContext ctx = {aFunc, aData};
+ NS_QuickSort(mArray.Elements(), mArray.Length(), sizeof(nsISupports*),
+ VoidStarComparator, &ctx);
+ }
+}
+
+bool nsCOMArray_base::InsertObjectAt(nsISupports* aObject, int32_t aIndex) {
+ if ((uint32_t)aIndex > mArray.Length()) {
+ return false;
+ }
+
+ mArray.InsertElementAt(aIndex, aObject);
+
+ NS_IF_ADDREF(aObject);
+ return true;
+}
+
+void nsCOMArray_base::InsertElementAt(uint32_t aIndex, nsISupports* aElement) {
+ mArray.InsertElementAt(aIndex, aElement);
+ NS_IF_ADDREF(aElement);
+}
+
+void nsCOMArray_base::InsertElementAt(uint32_t aIndex,
+ already_AddRefed<nsISupports> aElement) {
+ mArray.InsertElementAt(aIndex, aElement.take());
+}
+
+bool nsCOMArray_base::InsertObjectsAt(const nsCOMArray_base& aObjects,
+ int32_t aIndex) {
+ if ((uint32_t)aIndex > mArray.Length()) {
+ return false;
+ }
+
+ mArray.InsertElementsAt(aIndex, aObjects.mArray);
+
+ // need to addref all these
+ uint32_t count = aObjects.Length();
+ for (uint32_t i = 0; i < count; ++i) {
+ NS_IF_ADDREF(aObjects[i]);
+ }
+
+ return true;
+}
+
+void nsCOMArray_base::InsertElementsAt(uint32_t aIndex,
+ const nsCOMArray_base& aElements) {
+ mArray.InsertElementsAt(aIndex, aElements.mArray);
+
+ // need to addref all these
+ uint32_t count = aElements.Length();
+ for (uint32_t i = 0; i < count; ++i) {
+ NS_IF_ADDREF(aElements[i]);
+ }
+}
+
+void nsCOMArray_base::InsertElementsAt(uint32_t aIndex,
+ nsISupports* const* aElements,
+ uint32_t aCount) {
+ mArray.InsertElementsAt(aIndex, aElements, aCount);
+
+ // need to addref all these
+ for (uint32_t i = 0; i < aCount; ++i) {
+ NS_IF_ADDREF(aElements[i]);
+ }
+}
+
+void nsCOMArray_base::ReplaceObjectAt(nsISupports* aObject, int32_t aIndex) {
+ mArray.EnsureLengthAtLeast(aIndex + 1);
+ nsISupports* oldObject = mArray[aIndex];
+ // Make sure to addref first, in case aObject == oldObject
+ NS_IF_ADDREF(mArray[aIndex] = aObject);
+ NS_IF_RELEASE(oldObject);
+}
+
+bool nsCOMArray_base::RemoveObject(nsISupports* aObject) {
+ bool result = mArray.RemoveElement(aObject);
+ if (result) {
+ NS_IF_RELEASE(aObject);
+ }
+ return result;
+}
+
+bool nsCOMArray_base::RemoveObjectAt(int32_t aIndex) {
+ if (uint32_t(aIndex) < mArray.Length()) {
+ nsISupports* element = mArray[aIndex];
+
+ mArray.RemoveElementAt(aIndex);
+ NS_IF_RELEASE(element);
+ return true;
+ }
+
+ return false;
+}
+
+void nsCOMArray_base::RemoveElementAt(uint32_t aIndex) {
+ nsISupports* element = mArray[aIndex];
+ mArray.RemoveElementAt(aIndex);
+ NS_IF_RELEASE(element);
+}
+
+bool nsCOMArray_base::RemoveObjectsAt(int32_t aIndex, int32_t aCount) {
+ if (uint32_t(aIndex) + uint32_t(aCount) <= mArray.Length()) {
+ nsTArray<nsISupports*> elementsToDestroy(aCount);
+ elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
+ mArray.RemoveElementsAt(aIndex, aCount);
+ ReleaseObjects(elementsToDestroy);
+ return true;
+ }
+
+ return false;
+}
+
+void nsCOMArray_base::RemoveElementsAt(uint32_t aIndex, uint32_t aCount) {
+ nsTArray<nsISupports*> elementsToDestroy(aCount);
+ elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
+ mArray.RemoveElementsAt(aIndex, aCount);
+ ReleaseObjects(elementsToDestroy);
+}
+
+// useful for destructors
+void ReleaseObjects(nsTArray<nsISupports*>& aArray) {
+ for (uint32_t i = 0; i < aArray.Length(); ++i) {
+ NS_IF_RELEASE(aArray[i]);
+ }
+}
+
+void nsCOMArray_base::Clear() {
+ nsTArray<nsISupports*> objects = std::move(mArray);
+ ReleaseObjects(objects);
+}
+
+bool nsCOMArray_base::SetCount(int32_t aNewCount) {
+ NS_ASSERTION(aNewCount >= 0, "SetCount(negative index)");
+ if (aNewCount < 0) {
+ return false;
+ }
+
+ int32_t count = mArray.Length();
+ if (count > aNewCount) {
+ RemoveObjectsAt(aNewCount, mArray.Length() - aNewCount);
+ }
+ mArray.SetLength(aNewCount);
+ return true;
+}
diff --git a/xpcom/ds/nsCOMArray.h b/xpcom/ds/nsCOMArray.h
new file mode 100644
index 0000000000..0ea1437f25
--- /dev/null
+++ b/xpcom/ds/nsCOMArray.h
@@ -0,0 +1,398 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsCOMArray_h__
+#define nsCOMArray_h__
+
+#include "mozilla/Attributes.h"
+#include "mozilla/ArrayIterator.h"
+#include "mozilla/MemoryReporting.h"
+
+#include "nsCycleCollectionNoteChild.h"
+#include "nsTArray.h"
+#include "nsISupports.h"
+
+#include <iterator>
+
+// See below for the definition of nsCOMArray<T>
+
+// a class that's nsISupports-specific, so that we can contain the
+// work of this class in the XPCOM dll
+class nsCOMArray_base {
+ friend class nsArrayBase;
+
+ protected:
+ nsCOMArray_base() = default;
+ explicit nsCOMArray_base(int32_t aCount) : mArray(aCount) {}
+ nsCOMArray_base(const nsCOMArray_base& aOther);
+ nsCOMArray_base(nsCOMArray_base&& aOther) = default;
+ nsCOMArray_base& operator=(nsCOMArray_base&& aOther) = default;
+ ~nsCOMArray_base();
+
+ int32_t IndexOf(nsISupports* aObject, uint32_t aStartIndex = 0) const;
+ bool Contains(nsISupports* aObject) const { return IndexOf(aObject) != -1; }
+
+ int32_t IndexOfObject(nsISupports* aObject) const;
+ bool ContainsObject(nsISupports* aObject) const {
+ return IndexOfObject(aObject) != -1;
+ }
+
+ typedef bool (*nsBaseArrayEnumFunc)(void* aElement, void* aData);
+
+ // enumerate through the array with a callback.
+ bool EnumerateForwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
+
+ bool EnumerateBackwards(nsBaseArrayEnumFunc aFunc, void* aData) const;
+
+ typedef int (*nsISupportsComparatorFunc)(nsISupports* aElement1,
+ nsISupports* aElement2, void* aData);
+
+ struct nsISupportsComparatorContext {
+ nsISupportsComparatorFunc mComparatorFunc;
+ void* mData;
+ };
+
+ static int VoidStarComparator(const void* aElement1, const void* aElement2,
+ void* aData);
+ void Sort(nsISupportsComparatorFunc aFunc, void* aData);
+
+ bool InsertObjectAt(nsISupports* aObject, int32_t aIndex);
+ void InsertElementAt(uint32_t aIndex, nsISupports* aElement);
+ void InsertElementAt(uint32_t aIndex, already_AddRefed<nsISupports> aElement);
+ bool InsertObjectsAt(const nsCOMArray_base& aObjects, int32_t aIndex);
+ void InsertElementsAt(uint32_t aIndex, const nsCOMArray_base& aElements);
+ void InsertElementsAt(uint32_t aIndex, nsISupports* const* aElements,
+ uint32_t aCount);
+ void ReplaceObjectAt(nsISupports* aObject, int32_t aIndex);
+ void ReplaceElementAt(uint32_t aIndex, nsISupports* aElement) {
+ nsISupports* oldElement = mArray[aIndex];
+ NS_IF_ADDREF(mArray[aIndex] = aElement);
+ NS_IF_RELEASE(oldElement);
+ }
+ bool AppendObject(nsISupports* aObject) {
+ return InsertObjectAt(aObject, Count());
+ }
+ void AppendElement(nsISupports* aElement) {
+ InsertElementAt(Length(), aElement);
+ }
+ void AppendElement(already_AddRefed<nsISupports> aElement) {
+ InsertElementAt(Length(), std::move(aElement));
+ }
+
+ bool AppendObjects(const nsCOMArray_base& aObjects) {
+ return InsertObjectsAt(aObjects, Count());
+ }
+ void AppendElements(const nsCOMArray_base& aElements) {
+ return InsertElementsAt(Length(), aElements);
+ }
+ void AppendElements(nsISupports* const* aElements, uint32_t aCount) {
+ return InsertElementsAt(Length(), aElements, aCount);
+ }
+ bool RemoveObject(nsISupports* aObject);
+ nsISupports** Elements() { return mArray.Elements(); }
+ void SwapElements(nsCOMArray_base& aOther) {
+ mArray.SwapElements(aOther.mArray);
+ }
+
+ public:
+ // elements in the array (including null elements!)
+ int32_t Count() const { return mArray.Length(); }
+ // nsTArray-compatible version
+ uint32_t Length() const { return mArray.Length(); }
+ bool IsEmpty() const { return mArray.IsEmpty(); }
+
+ // If the array grows, the newly created entries will all be null;
+ // if the array shrinks, the excess entries will all be released.
+ bool SetCount(int32_t aNewCount);
+ // nsTArray-compatible version
+ void TruncateLength(uint32_t aNewLength) {
+ if (mArray.Length() > aNewLength) {
+ RemoveElementsAt(aNewLength, mArray.Length() - aNewLength);
+ }
+ }
+
+ // remove all elements in the array, and call NS_RELEASE on each one
+ void Clear();
+
+ nsISupports* ObjectAt(int32_t aIndex) const { return mArray[aIndex]; }
+ // nsTArray-compatible version
+ nsISupports* ElementAt(uint32_t aIndex) const { return mArray[aIndex]; }
+
+ nsISupports* SafeObjectAt(int32_t aIndex) const {
+ return mArray.SafeElementAt(aIndex, nullptr);
+ }
+ // nsTArray-compatible version
+ nsISupports* SafeElementAt(uint32_t aIndex) const {
+ return mArray.SafeElementAt(aIndex, nullptr);
+ }
+
+ nsISupports* operator[](int32_t aIndex) const { return mArray[aIndex]; }
+
+ // remove an element at a specific position, shrinking the array
+ // as necessary
+ bool RemoveObjectAt(int32_t aIndex);
+ // nsTArray-compatible version
+ void RemoveElementAt(uint32_t aIndex);
+
+ // remove a range of elements at a specific position, shrinking the array
+ // as necessary
+ bool RemoveObjectsAt(int32_t aIndex, int32_t aCount);
+ // nsTArray-compatible version
+ void RemoveElementsAt(uint32_t aIndex, uint32_t aCount);
+
+ void SwapElementsAt(uint32_t aIndex1, uint32_t aIndex2) {
+ nsISupports* tmp = mArray[aIndex1];
+ mArray[aIndex1] = mArray[aIndex2];
+ mArray[aIndex2] = tmp;
+ }
+
+ // Ensures there is enough space to store a total of aCapacity objects.
+ // This method never deletes any objects.
+ void SetCapacity(uint32_t aCapacity) { mArray.SetCapacity(aCapacity); }
+ uint32_t Capacity() { return mArray.Capacity(); }
+
+ // Measures the size of the array's element storage. If you want to measure
+ // anything hanging off the array, you must iterate over the elements and
+ // measure them individually; hence the "Shallow" prefix. Note that because
+ // each element in an nsCOMArray<T> is actually a T* any such iteration
+ // should use a SizeOfIncludingThis() function on each element rather than a
+ // SizeOfExcludingThis() function, so that the memory taken by the T itself
+ // is included as well as anything it points to.
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ private:
+ // the actual storage
+ nsTArray<nsISupports*> mArray;
+
+ // don't implement these, defaults will muck with refcounts!
+ nsCOMArray_base& operator=(const nsCOMArray_base& aOther) = delete;
+};
+
+inline void ImplCycleCollectionUnlink(nsCOMArray_base& aField) {
+ aField.Clear();
+}
+
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback, nsCOMArray_base& aField,
+ const char* aName, uint32_t aFlags = 0) {
+ aFlags |= CycleCollectionEdgeNameArrayFlag;
+ int32_t length = aField.Count();
+ for (int32_t i = 0; i < length; ++i) {
+ CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
+ }
+}
+
+// a non-XPCOM, refcounting array of XPCOM objects
+// used as a member variable or stack variable - this object is NOT
+// refcounted, but the objects that it holds are
+//
+// most of the read-only accessors like ObjectAt()/etc do NOT refcount
+// on the way out. This means that you can do one of two things:
+//
+// * does an addref, but holds onto a reference
+// nsCOMPtr<T> foo = array[i];
+//
+// * avoids the refcount, but foo might go stale if array[i] is ever
+// * modified/removed. Be careful not to NS_RELEASE(foo)!
+// T* foo = array[i];
+//
+// This array will accept null as an argument for any object, and will store
+// null in the array. But that also means that methods like ObjectAt() may
+// return null when referring to an existing, but null entry in the array.
+template <class T>
+class nsCOMArray : public nsCOMArray_base {
+ public:
+ typedef int32_t index_type;
+ typedef mozilla::ArrayIterator<T*, nsCOMArray> iterator;
+ typedef mozilla::ArrayIterator<const T*, nsCOMArray> const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ nsCOMArray() = default;
+ explicit nsCOMArray(int32_t aCount) : nsCOMArray_base(aCount) {}
+ explicit nsCOMArray(const nsCOMArray<T>& aOther) : nsCOMArray_base(aOther) {}
+ nsCOMArray(nsCOMArray<T>&& aOther) = default;
+ ~nsCOMArray() = default;
+
+ // We have a move assignment operator, but no copy assignment operator.
+ nsCOMArray<T>& operator=(nsCOMArray<T>&& aOther) = default;
+
+ // these do NOT refcount on the way out, for speed
+ T* ObjectAt(int32_t aIndex) const {
+ return static_cast<T*>(nsCOMArray_base::ObjectAt(aIndex));
+ }
+ // nsTArray-compatible version
+ T* ElementAt(uint32_t aIndex) const {
+ return static_cast<T*>(nsCOMArray_base::ElementAt(aIndex));
+ }
+
+ // these do NOT refcount on the way out, for speed
+ T* SafeObjectAt(int32_t aIndex) const {
+ return static_cast<T*>(nsCOMArray_base::SafeObjectAt(aIndex));
+ }
+ // nsTArray-compatible version
+ T* SafeElementAt(uint32_t aIndex) const {
+ return static_cast<T*>(nsCOMArray_base::SafeElementAt(aIndex));
+ }
+
+ // indexing operator for syntactic sugar
+ T* operator[](int32_t aIndex) const { return ObjectAt(aIndex); }
+
+ // index of the element in question.. does NOT refcount
+ // note: this does not check COM object identity. Use
+ // IndexOfObject() for that purpose
+ int32_t IndexOf(T* aObject, uint32_t aStartIndex = 0) const {
+ return nsCOMArray_base::IndexOf(aObject, aStartIndex);
+ }
+ bool Contains(T* aObject) const { return nsCOMArray_base::Contains(aObject); }
+
+ // index of the element in question.. be careful!
+ // this is much slower than IndexOf() because it uses
+ // QueryInterface to determine actual COM identity of the object
+ // if you need to do this frequently then consider enforcing
+ // COM object identity before adding/comparing elements
+ int32_t IndexOfObject(T* aObject) const {
+ return nsCOMArray_base::IndexOfObject(aObject);
+ }
+ bool ContainsObject(nsISupports* aObject) const {
+ return nsCOMArray_base::ContainsObject(aObject);
+ }
+
+ // inserts aObject at aIndex, shifting the objects at aIndex and
+ // later to make space
+ bool InsertObjectAt(T* aObject, int32_t aIndex) {
+ return nsCOMArray_base::InsertObjectAt(aObject, aIndex);
+ }
+ // nsTArray-compatible version
+ void InsertElementAt(uint32_t aIndex, T* aElement) {
+ nsCOMArray_base::InsertElementAt(aIndex, aElement);
+ }
+
+ // inserts the objects from aObject at aIndex, shifting the
+ // objects at aIndex and later to make space
+ bool InsertObjectsAt(const nsCOMArray<T>& aObjects, int32_t aIndex) {
+ return nsCOMArray_base::InsertObjectsAt(aObjects, aIndex);
+ }
+ // nsTArray-compatible version
+ void InsertElementsAt(uint32_t aIndex, const nsCOMArray<T>& aElements) {
+ nsCOMArray_base::InsertElementsAt(aIndex, aElements);
+ }
+ void InsertElementsAt(uint32_t aIndex, T* const* aElements, uint32_t aCount) {
+ nsCOMArray_base::InsertElementsAt(
+ aIndex, reinterpret_cast<nsISupports* const*>(aElements), aCount);
+ }
+
+ // replaces an existing element. Warning: if the array grows,
+ // the newly created entries will all be null
+ void ReplaceObjectAt(T* aObject, int32_t aIndex) {
+ nsCOMArray_base::ReplaceObjectAt(aObject, aIndex);
+ }
+ // nsTArray-compatible version
+ void ReplaceElementAt(uint32_t aIndex, T* aElement) {
+ nsCOMArray_base::ReplaceElementAt(aIndex, aElement);
+ }
+
+ typedef int (*TComparatorFunc)(T* aElement1, T* aElement2, void* aData);
+
+ struct TComparatorContext {
+ TComparatorFunc mComparatorFunc;
+ void* mData;
+ };
+
+ static int nsISupportsComparator(nsISupports* aElement1,
+ nsISupports* aElement2, void* aData) {
+ auto ctx = static_cast<TComparatorContext*>(aData);
+ return (*ctx->mComparatorFunc)(static_cast<T*>(aElement1),
+ static_cast<T*>(aElement2), ctx->mData);
+ }
+
+ void Sort(TComparatorFunc aFunc, void* aData) {
+ TComparatorContext ctx = {aFunc, aData};
+ nsCOMArray_base::Sort(nsISupportsComparator, &ctx);
+ }
+
+ // append an object, growing the array as necessary
+ bool AppendObject(T* aObject) {
+ return nsCOMArray_base::AppendObject(aObject);
+ }
+ // nsTArray-compatible version
+ void AppendElement(T* aElement) { nsCOMArray_base::AppendElement(aElement); }
+ void AppendElement(already_AddRefed<T> aElement) {
+ nsCOMArray_base::AppendElement(std::move(aElement));
+ }
+
+ // append objects, growing the array as necessary
+ bool AppendObjects(const nsCOMArray<T>& aObjects) {
+ return nsCOMArray_base::AppendObjects(aObjects);
+ }
+ // nsTArray-compatible version
+ void AppendElements(const nsCOMArray<T>& aElements) {
+ return nsCOMArray_base::AppendElements(aElements);
+ }
+ void AppendElements(T* const* aElements, uint32_t aCount) {
+ InsertElementsAt(Length(), aElements, aCount);
+ }
+
+ // remove the first instance of the given object and shrink the
+ // array as necessary
+ // Warning: if you pass null here, it will remove the first null element
+ bool RemoveObject(T* aObject) {
+ return nsCOMArray_base::RemoveObject(aObject);
+ }
+ // nsTArray-compatible version
+ bool RemoveElement(T* aElement) {
+ return nsCOMArray_base::RemoveObject(aElement);
+ }
+
+ T** Elements() { return reinterpret_cast<T**>(nsCOMArray_base::Elements()); }
+ void SwapElements(nsCOMArray<T>& aOther) {
+ nsCOMArray_base::SwapElements(aOther);
+ }
+
+ // Methods for range-based for loops.
+ iterator begin() { return iterator(*this, 0); }
+ const_iterator begin() const { return const_iterator(*this, 0); }
+ const_iterator cbegin() const { return begin(); }
+ iterator end() { return iterator(*this, Length()); }
+ const_iterator end() const { return const_iterator(*this, Length()); }
+ const_iterator cend() const { return end(); }
+
+ // Methods for reverse iterating.
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
+ const_reverse_iterator crbegin() const { return rbegin(); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const {
+ return const_reverse_iterator(begin());
+ }
+ const_reverse_iterator crend() const { return rend(); }
+
+ private:
+ // don't implement these!
+ nsCOMArray<T>& operator=(const nsCOMArray<T>& aOther) = delete;
+};
+
+template <typename T>
+inline void ImplCycleCollectionUnlink(nsCOMArray<T>& aField) {
+ aField.Clear();
+}
+
+template <typename E>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback, nsCOMArray<E>& aField,
+ const char* aName, uint32_t aFlags = 0) {
+ aFlags |= CycleCollectionEdgeNameArrayFlag;
+ int32_t length = aField.Count();
+ for (int32_t i = 0; i < length; ++i) {
+ CycleCollectionNoteChild(aCallback, aField[i], aName, aFlags);
+ }
+}
+
+#endif
diff --git a/xpcom/ds/nsCRT.cpp b/xpcom/ds/nsCRT.cpp
new file mode 100644
index 0000000000..9d2fcb7120
--- /dev/null
+++ b/xpcom/ds/nsCRT.cpp
@@ -0,0 +1,123 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * MODULE NOTES:
+ * @update gess7/30/98
+ *
+ * Much as I hate to do it, we were using string compares wrong.
+ * Often, programmers call functions like strcmp(s1,s2), and pass
+ * one or more null strings. Rather than blow up on these, I've
+ * added quick checks to ensure that cases like this don't cause
+ * us to fail.
+ *
+ * In general, if you pass a null into any of these string compare
+ * routines, we simply return 0.
+ */
+
+#include "nsCRT.h"
+#include "nsDebug.h"
+
+//----------------------------------------------------------------------
+
+////////////////////////////////////////////////////////////////////////////////
+// My lovely strtok routine
+
+#define IS_DELIM(m, c) ((m)[(c) >> 3] & (1 << ((c)&7)))
+#define SET_DELIM(m, c) ((m)[(c) >> 3] |= (1 << ((c)&7)))
+#define DELIM_TABLE_SIZE 32
+
+char* nsCRT::strtok(char* aString, const char* aDelims, char** aNewStr) {
+ NS_ASSERTION(aString,
+ "Unlike regular strtok, the first argument cannot be null.");
+
+ char delimTable[DELIM_TABLE_SIZE];
+ uint32_t i;
+ char* result;
+ char* str = aString;
+
+ for (i = 0; i < DELIM_TABLE_SIZE; ++i) {
+ delimTable[i] = '\0';
+ }
+
+ for (i = 0; aDelims[i]; i++) {
+ SET_DELIM(delimTable, static_cast<uint8_t>(aDelims[i]));
+ }
+ NS_ASSERTION(aDelims[i] == '\0', "too many delimiters");
+
+ // skip to beginning
+ while (*str && IS_DELIM(delimTable, static_cast<uint8_t>(*str))) {
+ str++;
+ }
+ result = str;
+
+ // fix up the end of the token
+ while (*str) {
+ if (IS_DELIM(delimTable, static_cast<uint8_t>(*str))) {
+ *str++ = '\0';
+ break;
+ }
+ str++;
+ }
+ *aNewStr = str;
+
+ return str == result ? nullptr : result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Compare unichar string ptrs, stopping at the 1st null
+ * NOTE: If both are null, we return 0.
+ * NOTE: We terminate the search upon encountering a nullptr
+ *
+ * @update gess 11/10/99
+ * @param s1 and s2 both point to unichar strings
+ * @return 0 if they match, -1 if s1<s2; 1 if s1>s2
+ */
+int32_t nsCRT::strcmp(const char16_t* aStr1, const char16_t* aStr2) {
+ if (aStr1 && aStr2) {
+ for (;;) {
+ char16_t c1 = *aStr1++;
+ char16_t c2 = *aStr2++;
+ if (c1 != c2) {
+ if (c1 < c2) {
+ return -1;
+ }
+ return 1;
+ }
+ if (c1 == 0 || c2 == 0) {
+ break;
+ }
+ }
+ } else {
+ if (aStr1) { // aStr2 must have been null
+ return -1;
+ }
+ if (aStr2) { // aStr1 must have been null
+ return 1;
+ }
+ }
+ return 0;
+}
+
+// This should use NSPR but NSPR isn't exporting its PR_strtoll function
+// Until then...
+int64_t nsCRT::atoll(const char* aStr) {
+ if (!aStr) {
+ return 0;
+ }
+
+ int64_t ll = 0;
+
+ while (*aStr && *aStr >= '0' && *aStr <= '9') {
+ ll *= 10;
+ ll += *aStr - '0';
+ aStr++;
+ }
+
+ return ll;
+}
diff --git a/xpcom/ds/nsCRT.h b/xpcom/ds/nsCRT.h
new file mode 100644
index 0000000000..14b46c5059
--- /dev/null
+++ b/xpcom/ds/nsCRT.h
@@ -0,0 +1,119 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef nsCRT_h___
+#define nsCRT_h___
+
+#include <stdlib.h>
+#include <ctype.h>
+#include "plstr.h"
+#include "nscore.h"
+#include "nsCRTGlue.h"
+
+#if defined(XP_WIN)
+# define NS_LINEBREAK "\015\012"
+# define NS_ULINEBREAK u"\015\012"
+# define NS_LINEBREAK_LEN 2
+#else
+# ifdef XP_UNIX
+# define NS_LINEBREAK "\012"
+# define NS_ULINEBREAK u"\012"
+# define NS_LINEBREAK_LEN 1
+# endif /* XP_UNIX */
+#endif /* XP_WIN */
+
+/// This is a wrapper class around all the C runtime functions.
+
+class nsCRT {
+ public:
+ enum {
+ LF = '\n' /* Line Feed */,
+ VTAB = '\v' /* Vertical Tab */,
+ CR = '\r' /* Carriage Return */
+ };
+
+ /// String comparison.
+ static int32_t strcmp(const char* aStr1, const char* aStr2) {
+ return int32_t(PL_strcmp(aStr1, aStr2));
+ }
+
+ /// Case-insensitive string comparison.
+ static int32_t strcasecmp(const char* aStr1, const char* aStr2) {
+ /* Some functions like `PL_strcasecmp` are reimplementations
+ * of the their native POSIX counterparts, which breaks libFuzzer.
+ * For this purpose, we use the natives instead when fuzzing.
+ */
+#if defined(LIBFUZZER) && defined(LINUX)
+ return int32_t(::strcasecmp(aStr1, aStr2));
+#else
+ return int32_t(PL_strcasecmp(aStr1, aStr2));
+#endif
+ }
+
+ /// Case-insensitive string comparison with length
+ static int32_t strncasecmp(const char* aStr1, const char* aStr2,
+ uint32_t aMaxLen) {
+#if defined(LIBFUZZER) && defined(LINUX)
+ int32_t result = int32_t(::strncasecmp(aStr1, aStr2, aMaxLen));
+#else
+ int32_t result = int32_t(PL_strncasecmp(aStr1, aStr2, aMaxLen));
+#endif
+ // Egads. PL_strncasecmp is returning *very* negative numbers.
+ // Some folks expect -1,0,1, so let's temper its enthusiasm.
+ if (result < 0) {
+ result = -1;
+ }
+ return result;
+ }
+
+ /// Case-insensitive substring search.
+ static char* strcasestr(const char* aStr1, const char* aStr2) {
+#if defined(LIBFUZZER) && defined(LINUX)
+ return const_cast<char*>(::strcasestr(aStr1, aStr2));
+#else
+ return PL_strcasestr(aStr1, aStr2);
+#endif
+ }
+
+ /**
+
+ How to use this fancy (thread-safe) version of strtok:
+
+ void main(void) {
+ printf("%s\n\nTokens:\n", string);
+ // Establish string and get the first token:
+ char* newStr;
+ token = nsCRT::strtok(string, seps, &newStr);
+ while (token != nullptr) {
+ // While there are tokens in "string"
+ printf(" %s\n", token);
+ // Get next token:
+ token = nsCRT::strtok(newStr, seps, &newStr);
+ }
+ }
+ * WARNING - STRTOK WHACKS str THE FIRST TIME IT IS CALLED *
+ * MAKE A COPY OF str IF YOU NEED TO USE IT AFTER strtok() *
+ */
+ static char* strtok(char* aStr, const char* aDelims, char** aNewStr);
+
+ /// Like strcmp except for ucs2 strings
+ static int32_t strcmp(const char16_t* aStr1, const char16_t* aStr2);
+
+ // String to longlong
+ static int64_t atoll(const char* aStr);
+
+ static char ToUpper(char aChar) { return NS_ToUpper(aChar); }
+ static char ToLower(char aChar) { return NS_ToLower(aChar); }
+
+ static bool IsAsciiSpace(char16_t aChar) {
+ return NS_IsAsciiWhitespace(aChar);
+ }
+};
+
+inline bool NS_IS_SPACE(char16_t aChar) {
+ return ((int(aChar) & 0x7f) == int(aChar)) && isspace(int(aChar));
+}
+
+#endif /* nsCRT_h___ */
diff --git a/xpcom/ds/nsCharSeparatedTokenizer.cpp b/xpcom/ds/nsCharSeparatedTokenizer.cpp
new file mode 100644
index 0000000000..7288ed070f
--- /dev/null
+++ b/xpcom/ds/nsCharSeparatedTokenizer.cpp
@@ -0,0 +1,10 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsCharSeparatedTokenizer.h"
+
+template class nsTSubstringSplitter<char>;
+template class nsTSubstringSplitter<char16_t>;
diff --git a/xpcom/ds/nsCharSeparatedTokenizer.h b/xpcom/ds/nsCharSeparatedTokenizer.h
new file mode 100644
index 0000000000..5cf6992e3e
--- /dev/null
+++ b/xpcom/ds/nsCharSeparatedTokenizer.h
@@ -0,0 +1,274 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsCharSeparatedTokenizer_h
+#define __nsCharSeparatedTokenizer_h
+
+#include "mozilla/Maybe.h"
+#include "mozilla/RangedPtr.h"
+#include "mozilla/TypedEnumBits.h"
+
+#include "nsCRTGlue.h"
+#include "nsTDependentSubstring.h"
+
+// Flags -- only one for now. If we need more, they should be defined to
+// be 1 << 1, 1 << 2, etc. (They're masks, and aFlags is a bitfield.)
+enum class nsTokenizerFlags {
+ Default = 0,
+ SeparatorOptional = 1 << 0,
+ IncludeEmptyTokenAtEnd = 1 << 1
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsTokenizerFlags)
+
+/**
+ * This parses a SeparatorChar-separated string into tokens.
+ * Whitespace surrounding tokens is not treated as part of tokens, however
+ * whitespace inside a token is. If the final token is the empty string, it is
+ * not returned by default.
+ *
+ * Some examples, with SeparatorChar = ',':
+ *
+ * "foo, bar, baz" -> "foo" "bar" "baz"
+ * "foo,bar,baz" -> "foo" "bar" "baz"
+ * "foo , bar hi , baz" -> "foo" "bar hi" "baz"
+ * "foo, ,bar,baz" -> "foo" "" "bar" "baz"
+ * "foo,,bar,baz" -> "foo" "" "bar" "baz"
+ * "foo,bar,baz," -> "foo" "bar" "baz"
+ *
+ * The function used for whitespace detection is a template argument.
+ * By default, it is NS_IsAsciiWhitespace.
+ */
+template <typename TDependentSubstringType, bool IsWhitespace(char16_t),
+ nsTokenizerFlags Flags = nsTokenizerFlags::Default>
+class nsTCharSeparatedTokenizer {
+ using CharType = typename TDependentSubstringType::char_type;
+ using SubstringType = typename TDependentSubstringType::substring_type;
+
+ public:
+ using DependentSubstringType = TDependentSubstringType;
+
+ nsTCharSeparatedTokenizer(const SubstringType& aSource,
+ CharType aSeparatorChar)
+ : mIter(aSource.Data(), aSource.Length()),
+ mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+ aSource.Length()),
+ mSeparatorChar(aSeparatorChar),
+ mWhitespaceBeforeFirstToken(false),
+ mWhitespaceAfterCurrentToken(false),
+ mSeparatorAfterCurrentToken(false) {
+ // Skip initial whitespace
+ while (mIter < mEnd && IsWhitespace(*mIter)) {
+ mWhitespaceBeforeFirstToken = true;
+ ++mIter;
+ }
+ }
+
+ /**
+ * Checks if any more tokens are available.
+ */
+ bool hasMoreTokens() const {
+ MOZ_ASSERT(mIter == mEnd || !IsWhitespace(*mIter),
+ "Should be at beginning of token if there is one");
+
+ if constexpr (Flags & nsTokenizerFlags::IncludeEmptyTokenAtEnd) {
+ return mIter < mEnd || (mIter == mEnd && mSeparatorAfterCurrentToken);
+ } else {
+ return mIter < mEnd;
+ }
+ }
+
+ /*
+ * Returns true if there is whitespace prior to the first token.
+ */
+ bool whitespaceBeforeFirstToken() const {
+ return mWhitespaceBeforeFirstToken;
+ }
+
+ /*
+ * Returns true if there is a separator after the current token.
+ * Useful if you want to check whether the last token has a separator
+ * after it which may not be valid.
+ */
+ bool separatorAfterCurrentToken() const {
+ return mSeparatorAfterCurrentToken;
+ }
+
+ /*
+ * Returns true if there is any whitespace after the current token.
+ */
+ bool whitespaceAfterCurrentToken() const {
+ return mWhitespaceAfterCurrentToken;
+ }
+
+ /**
+ * Returns the next token.
+ */
+ const DependentSubstringType nextToken() {
+ mozilla::RangedPtr<const CharType> tokenStart = mIter;
+ mozilla::RangedPtr<const CharType> tokenEnd = mIter;
+
+ MOZ_ASSERT(mIter == mEnd || !IsWhitespace(*mIter),
+ "Should be at beginning of token if there is one");
+
+ // Search until we hit separator or end (or whitespace, if a separator
+ // isn't required -- see clause with 'break' below).
+ while (mIter < mEnd && *mIter != mSeparatorChar) {
+ // Skip to end of the current word.
+ while (mIter < mEnd && !IsWhitespace(*mIter) &&
+ *mIter != mSeparatorChar) {
+ ++mIter;
+ }
+ tokenEnd = mIter;
+
+ // Skip whitespace after the current word.
+ mWhitespaceAfterCurrentToken = false;
+ while (mIter < mEnd && IsWhitespace(*mIter)) {
+ mWhitespaceAfterCurrentToken = true;
+ ++mIter;
+ }
+ if constexpr (Flags & nsTokenizerFlags::SeparatorOptional) {
+ // We've hit (and skipped) whitespace, and that's sufficient to end
+ // our token, regardless of whether we've reached a SeparatorChar.
+ break;
+ } // (else, we'll keep looping until we hit mEnd or SeparatorChar)
+ }
+
+ mSeparatorAfterCurrentToken = (mIter != mEnd && *mIter == mSeparatorChar);
+ MOZ_ASSERT((Flags & nsTokenizerFlags::SeparatorOptional) ||
+ (mSeparatorAfterCurrentToken == (mIter < mEnd)),
+ "If we require a separator and haven't hit the end of "
+ "our string, then we shouldn't have left the loop "
+ "unless we hit a separator");
+
+ // Skip separator (and any whitespace after it), if we're at one.
+ if (mSeparatorAfterCurrentToken) {
+ ++mIter;
+
+ while (mIter < mEnd && IsWhitespace(*mIter)) {
+ mWhitespaceAfterCurrentToken = true;
+ ++mIter;
+ }
+ }
+
+ return Substring(tokenStart.get(), tokenEnd.get());
+ }
+
+ auto ToRange() const;
+
+ private:
+ mozilla::RangedPtr<const CharType> mIter;
+ const mozilla::RangedPtr<const CharType> mEnd;
+ const CharType mSeparatorChar;
+ bool mWhitespaceBeforeFirstToken;
+ bool mWhitespaceAfterCurrentToken;
+ bool mSeparatorAfterCurrentToken;
+};
+
+constexpr bool NS_TokenizerIgnoreNothing(char16_t) { return false; }
+
+template <bool IsWhitespace(char16_t), typename CharType,
+ nsTokenizerFlags Flags = nsTokenizerFlags::Default>
+using nsTCharSeparatedTokenizerTemplate =
+ nsTCharSeparatedTokenizer<nsTDependentSubstring<CharType>, IsWhitespace,
+ Flags>;
+
+template <bool IsWhitespace(char16_t),
+ nsTokenizerFlags Flags = nsTokenizerFlags::Default>
+using nsCharSeparatedTokenizerTemplate =
+ nsTCharSeparatedTokenizerTemplate<IsWhitespace, char16_t, Flags>;
+
+using nsCharSeparatedTokenizer =
+ nsCharSeparatedTokenizerTemplate<NS_IsAsciiWhitespace>;
+
+template <bool IsWhitespace(char16_t),
+ nsTokenizerFlags Flags = nsTokenizerFlags::Default>
+using nsCCharSeparatedTokenizerTemplate =
+ nsTCharSeparatedTokenizerTemplate<IsWhitespace, char, Flags>;
+
+using nsCCharSeparatedTokenizer =
+ nsCCharSeparatedTokenizerTemplate<NS_IsAsciiWhitespace>;
+
+/**
+ * Adapts a char separated tokenizer for use in a range-based for loop.
+ *
+ * Use this typically only indirectly, e.g. like
+ *
+ * for (const auto& token : nsCharSeparatedTokenizer(aText, ' ').ToRange()) {
+ * // ...
+ * }
+ */
+template <typename Tokenizer>
+class nsTokenizedRange {
+ public:
+ using DependentSubstringType = typename Tokenizer::DependentSubstringType;
+
+ explicit nsTokenizedRange(Tokenizer&& aTokenizer)
+ : mTokenizer(std::move(aTokenizer)) {}
+
+ struct EndSentinel {};
+ struct Iterator {
+ explicit Iterator(const Tokenizer& aTokenizer) : mTokenizer(aTokenizer) {
+ Next();
+ }
+
+ const DependentSubstringType& operator*() const { return *mCurrentToken; }
+
+ Iterator& operator++() {
+ Next();
+ return *this;
+ }
+
+ bool operator==(const EndSentinel&) const {
+ return mCurrentToken.isNothing();
+ }
+
+ bool operator!=(const EndSentinel&) const { return mCurrentToken.isSome(); }
+
+ private:
+ void Next() {
+ mCurrentToken.reset();
+
+ if (mTokenizer.hasMoreTokens()) {
+ mCurrentToken.emplace(mTokenizer.nextToken());
+ }
+ }
+
+ Tokenizer mTokenizer;
+ mozilla::Maybe<DependentSubstringType> mCurrentToken;
+ };
+
+ auto begin() const { return Iterator{mTokenizer}; }
+ auto end() const { return EndSentinel{}; }
+
+ private:
+ const Tokenizer mTokenizer;
+};
+
+template <typename TDependentSubstringType, bool IsWhitespace(char16_t),
+ nsTokenizerFlags Flags>
+auto nsTCharSeparatedTokenizer<TDependentSubstringType, IsWhitespace,
+ Flags>::ToRange() const {
+ return nsTokenizedRange{nsTCharSeparatedTokenizer{*this}};
+}
+
+// You should not need to instantiate this class directly.
+// Use nsTSubstring::Split instead.
+template <typename T>
+class nsTSubstringSplitter
+ : public nsTokenizedRange<nsTCharSeparatedTokenizerTemplate<
+ NS_TokenizerIgnoreNothing, T,
+ nsTokenizerFlags::IncludeEmptyTokenAtEnd>> {
+ public:
+ using nsTokenizedRange<nsTCharSeparatedTokenizerTemplate<
+ NS_TokenizerIgnoreNothing, T,
+ nsTokenizerFlags::IncludeEmptyTokenAtEnd>>::nsTokenizedRange;
+};
+
+extern template class nsTSubstringSplitter<char>;
+extern template class nsTSubstringSplitter<char16_t>;
+
+#endif /* __nsCharSeparatedTokenizer_h */
diff --git a/xpcom/ds/nsCheapSets.h b/xpcom/ds/nsCheapSets.h
new file mode 100644
index 0000000000..3d09ccfdb7
--- /dev/null
+++ b/xpcom/ds/nsCheapSets.h
@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsCheapSets_h__
+#define __nsCheapSets_h__
+
+#include "nsTHashtable.h"
+#include <stdint.h>
+
+enum nsCheapSetOperator {
+ OpNext = 0, // enumerator says continue
+ OpRemove = 1, // enumerator says remove and continue
+};
+
+/**
+ * A set that takes up minimal size when there are 0 or 1 entries in the set.
+ * Use for cases where sizes of 0 and 1 are even slightly common.
+ */
+template <typename EntryType>
+class nsCheapSet {
+ public:
+ typedef typename EntryType::KeyType KeyType;
+ typedef nsCheapSetOperator (*Enumerator)(EntryType* aEntry, void* userArg);
+
+ nsCheapSet() : mState(ZERO) { mUnion.table = nullptr; }
+ ~nsCheapSet() { Clear(); }
+
+ /**
+ * Remove all entries.
+ */
+ void Clear() {
+ switch (mState) {
+ case ZERO:
+ break;
+ case ONE:
+ GetSingleEntry()->~EntryType();
+ break;
+ case MANY:
+ delete mUnion.table;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("bogus state");
+ break;
+ }
+ mState = ZERO;
+ }
+
+ void Put(const KeyType aVal);
+
+ void Remove(const KeyType aVal);
+
+ bool Contains(const KeyType aVal) {
+ switch (mState) {
+ case ZERO:
+ return false;
+ case ONE:
+ return GetSingleEntry()->KeyEquals(EntryType::KeyToPointer(aVal));
+ case MANY:
+ return !!mUnion.table->GetEntry(aVal);
+ default:
+ MOZ_ASSERT_UNREACHABLE("bogus state");
+ return false;
+ }
+ }
+
+ uint32_t EnumerateEntries(Enumerator aEnumFunc, void* aUserArg) {
+ switch (mState) {
+ case ZERO:
+ return 0;
+ case ONE:
+ if (aEnumFunc(GetSingleEntry(), aUserArg) == OpRemove) {
+ GetSingleEntry()->~EntryType();
+ mState = ZERO;
+ }
+ return 1;
+ case MANY: {
+ uint32_t n = mUnion.table->Count();
+ for (auto iter = mUnion.table->Iter(); !iter.Done(); iter.Next()) {
+ auto entry = static_cast<EntryType*>(iter.Get());
+ if (aEnumFunc(entry, aUserArg) == OpRemove) {
+ iter.Remove();
+ }
+ }
+ return n;
+ }
+ default:
+ MOZ_ASSERT_UNREACHABLE("bogus state");
+ return 0;
+ }
+ }
+
+ private:
+ EntryType* GetSingleEntry() {
+ return reinterpret_cast<EntryType*>(&mUnion.singleEntry[0]);
+ }
+
+ enum SetState { ZERO, ONE, MANY };
+
+ union {
+ nsTHashtable<EntryType>* table;
+ char singleEntry[sizeof(EntryType)];
+ } mUnion;
+ enum SetState mState;
+};
+
+template <typename EntryType>
+void nsCheapSet<EntryType>::Put(const KeyType aVal) {
+ switch (mState) {
+ case ZERO:
+ new (GetSingleEntry()) EntryType(EntryType::KeyToPointer(aVal));
+ mState = ONE;
+ return;
+ case ONE: {
+ nsTHashtable<EntryType>* table = new nsTHashtable<EntryType>();
+ EntryType* entry = GetSingleEntry();
+ table->PutEntry(entry->GetKey());
+ entry->~EntryType();
+ mUnion.table = table;
+ mState = MANY;
+ }
+ [[fallthrough]];
+
+ case MANY:
+ mUnion.table->PutEntry(aVal);
+ return;
+ default:
+ MOZ_ASSERT_UNREACHABLE("bogus state");
+ return;
+ }
+}
+
+template <typename EntryType>
+void nsCheapSet<EntryType>::Remove(const KeyType aVal) {
+ switch (mState) {
+ case ZERO:
+ break;
+ case ONE:
+ if (Contains(aVal)) {
+ GetSingleEntry()->~EntryType();
+ mState = ZERO;
+ }
+ break;
+ case MANY:
+ mUnion.table->RemoveEntry(aVal);
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("bogus state");
+ break;
+ }
+}
+
+#endif
diff --git a/xpcom/ds/nsClassHashtable.h b/xpcom/ds/nsClassHashtable.h
new file mode 100644
index 0000000000..a1a2384f7e
--- /dev/null
+++ b/xpcom/ds/nsClassHashtable.h
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsClassHashtable_h__
+#define nsClassHashtable_h__
+
+#include <utility>
+
+#include "mozilla/UniquePtr.h"
+#include "nsBaseHashtable.h"
+#include "nsHashKeys.h"
+
+/**
+ * Helper class that provides methods to wrap and unwrap the UserDataType.
+ */
+template <class T>
+class nsUniquePtrConverter {
+ public:
+ using UserDataType = T*;
+ using DataType = mozilla::UniquePtr<T>;
+
+ static UserDataType Unwrap(DataType& src) { return src.get(); }
+ static DataType Wrap(UserDataType&& src) { return DataType(std::move(src)); }
+ static DataType Wrap(const UserDataType& src) { return DataType(src); }
+};
+
+/**
+ * templated hashtable class maps keys to C++ object pointers.
+ * See nsBaseHashtable for complete declaration.
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ * @param Class the class-type being wrapped
+ * @see nsInterfaceHashtable, nsClassHashtable
+ */
+template <class KeyClass, class T>
+class nsClassHashtable : public nsBaseHashtable<KeyClass, mozilla::UniquePtr<T>,
+ T*, nsUniquePtrConverter<T>> {
+ public:
+ typedef typename KeyClass::KeyType KeyType;
+ typedef T* UserDataType;
+ typedef nsBaseHashtable<KeyClass, mozilla::UniquePtr<T>, T*,
+ nsUniquePtrConverter<T>>
+ base_type;
+
+ using base_type::IsEmpty;
+ using base_type::Remove;
+
+ nsClassHashtable() = default;
+ explicit nsClassHashtable(uint32_t aInitLength) : base_type(aInitLength) {}
+
+ /**
+ * @copydoc nsBaseHashtable::Get
+ * @param aData if the key doesn't exist, pData will be set to nullptr.
+ */
+ bool Get(KeyType aKey, UserDataType* aData) const;
+
+ /**
+ * @copydoc nsBaseHashtable::Get
+ * @returns nullptr if the key is not present.
+ */
+ [[nodiscard]] UserDataType Get(KeyType aKey) const;
+};
+
+template <typename K, typename T>
+inline void ImplCycleCollectionUnlink(nsClassHashtable<K, T>& aField) {
+ aField.Clear();
+}
+
+template <typename K, typename T>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ const nsClassHashtable<K, T>& aField, const char* aName,
+ uint32_t aFlags = 0) {
+ for (auto iter = aField.ConstIter(); !iter.Done(); iter.Next()) {
+ ImplCycleCollectionTraverse(aCallback, *iter.UserData(), aName, aFlags);
+ }
+}
+
+//
+// nsClassHashtable definitions
+//
+
+template <class KeyClass, class T>
+bool nsClassHashtable<KeyClass, T>::Get(KeyType aKey, T** aRetVal) const {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+ if (ent) {
+ if (aRetVal) {
+ *aRetVal = ent->GetData().get();
+ }
+
+ return true;
+ }
+
+ if (aRetVal) {
+ *aRetVal = nullptr;
+ }
+
+ return false;
+}
+
+template <class KeyClass, class T>
+T* nsClassHashtable<KeyClass, T>::Get(KeyType aKey) const {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+ if (!ent) {
+ return nullptr;
+ }
+
+ return ent->GetData().get();
+}
+
+#endif // nsClassHashtable_h__
diff --git a/xpcom/ds/nsDeque.cpp b/xpcom/ds/nsDeque.cpp
new file mode 100644
index 0000000000..07f61fa471
--- /dev/null
+++ b/xpcom/ds/nsDeque.cpp
@@ -0,0 +1,265 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsDeque.h"
+#include "nsISupportsImpl.h"
+#include <string.h>
+
+#include "mozilla/CheckedInt.h"
+
+#define modulus(x, y) ((x) % (y))
+
+namespace mozilla {
+namespace detail {
+
+/**
+ * Standard constructor
+ * @param deallocator, called by Erase and ~nsDequeBase
+ */
+nsDequeBase::nsDequeBase() {
+ MOZ_COUNT_CTOR(nsDequeBase);
+ mOrigin = mSize = 0;
+ mData = mBuffer; // don't allocate space until you must
+ mCapacity = sizeof(mBuffer) / sizeof(mBuffer[0]);
+ memset(mData, 0, mCapacity * sizeof(mBuffer[0]));
+}
+
+/**
+ * Destructor
+ */
+nsDequeBase::~nsDequeBase() {
+ MOZ_COUNT_DTOR(nsDequeBase);
+
+ if (mData && mData != mBuffer) {
+ free(mData);
+ }
+ mData = nullptr;
+}
+
+size_t nsDequeBase::SizeOfExcludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) const {
+ size_t size = 0;
+ if (mData != mBuffer) {
+ size += aMallocSizeOf(mData);
+ }
+
+ return size;
+}
+
+/**
+ * Remove all items from container without destroying them.
+ */
+void nsDequeBase::Empty() {
+ if (mSize && mData) {
+ memset(mData, 0, mCapacity * sizeof(*mData));
+ }
+ mSize = 0;
+ mOrigin = 0;
+}
+
+/**
+ * This method quadruples the size of the deque
+ * Elements in the deque are resequenced so that elements
+ * in the deque are stored sequentially
+ *
+ * @return whether growing succeeded
+ */
+bool nsDequeBase::GrowCapacity() {
+ mozilla::CheckedInt<size_t> newCapacity = mCapacity;
+ newCapacity *= 4;
+
+ NS_ASSERTION(newCapacity.isValid(), "Overflow");
+ if (!newCapacity.isValid()) {
+ return false;
+ }
+
+ // Sanity check the new byte size.
+ mozilla::CheckedInt<size_t> newByteSize = newCapacity;
+ newByteSize *= sizeof(void*);
+
+ NS_ASSERTION(newByteSize.isValid(), "Overflow");
+ if (!newByteSize.isValid()) {
+ return false;
+ }
+
+ void** temp = (void**)malloc(newByteSize.value());
+ if (!temp) {
+ return false;
+ }
+
+ // Here's the interesting part: You can't just move the elements
+ // directly (in situ) from the old buffer to the new one.
+ // Since capacity has changed, the old origin doesn't make
+ // sense anymore. It's better to resequence the elements now.
+
+ memcpy(temp, mData + mOrigin, sizeof(void*) * (mCapacity - mOrigin));
+ memcpy(temp + (mCapacity - mOrigin), mData, sizeof(void*) * mOrigin);
+
+ if (mData != mBuffer) {
+ free(mData);
+ }
+
+ mCapacity = newCapacity.value();
+ mOrigin = 0; // now realign the origin...
+ mData = temp;
+
+ return true;
+}
+
+/**
+ * This method adds an item to the end of the deque.
+ * This operation has the potential to cause the
+ * underlying buffer to resize.
+ *
+ * @param aItem: new item to be added to deque
+ */
+bool nsDequeBase::Push(void* aItem, const fallible_t&) {
+ if (mSize == mCapacity && !GrowCapacity()) {
+ return false;
+ }
+ mData[modulus(mOrigin + mSize, mCapacity)] = aItem;
+ mSize++;
+ return true;
+}
+
+/**
+ * This method adds an item to the front of the deque.
+ * This operation has the potential to cause the
+ * underlying buffer to resize.
+ *
+ * --Commments for GrowCapacity() case
+ * We've grown and shifted which means that the old
+ * final element in the deque is now the first element
+ * in the deque. This is temporary.
+ * We haven't inserted the new element at the front.
+ *
+ * To continue with the idea of having the front at zero
+ * after a grow, we move the old final item (which through
+ * the voodoo of mOrigin-- is now the first) to its final
+ * position which is conveniently the old length.
+ *
+ * Note that this case only happens when the deque is full.
+ * [And that pieces of this magic only work if the deque is full.]
+ * picture:
+ * [ABCDEFGH] @[mOrigin:3]:D.
+ * Task: PushFront("Z")
+ * shift mOrigin so, @[mOrigin:2]:C
+ * stretch and rearrange: (mOrigin:0)
+ * [CDEFGHAB ________ ________ ________]
+ * copy: (The second C is currently out of bounds)
+ * [CDEFGHAB C_______ ________ ________]
+ * later we will insert Z:
+ * [ZDEFGHAB C_______ ________ ________]
+ * and increment size: 9. (C is no longer out of bounds)
+ * --
+ * @param aItem: new item to be added to deque
+ */
+bool nsDequeBase::PushFront(void* aItem, const fallible_t&) {
+ if (mOrigin == 0) {
+ mOrigin = mCapacity - 1;
+ } else {
+ mOrigin--;
+ }
+
+ if (mSize == mCapacity) {
+ if (!GrowCapacity()) {
+ return false;
+ }
+ /* Comments explaining this are above*/
+ mData[mSize] = mData[mOrigin];
+ }
+ mData[mOrigin] = aItem;
+ mSize++;
+ return true;
+}
+
+/**
+ * Remove and return the last item in the container.
+ *
+ * @return ptr to last item in container
+ */
+void* nsDequeBase::Pop() {
+ void* result = nullptr;
+ if (mSize > 0) {
+ --mSize;
+ size_t offset = modulus(mSize + mOrigin, mCapacity);
+ result = mData[offset];
+ mData[offset] = nullptr;
+ if (!mSize) {
+ mOrigin = 0;
+ }
+ }
+ return result;
+}
+
+/**
+ * This method gets called you want to remove and return
+ * the first member in the container.
+ *
+ * @return last item in container
+ */
+void* nsDequeBase::PopFront() {
+ void* result = nullptr;
+ if (mSize > 0) {
+ NS_ASSERTION(mOrigin < mCapacity, "Error: Bad origin");
+ result = mData[mOrigin];
+ mData[mOrigin++] = nullptr; // zero it out for debugging purposes.
+ mSize--;
+ // Cycle around if we pop off the end
+ // and reset origin if when we pop the last element
+ if (mCapacity == mOrigin || !mSize) {
+ mOrigin = 0;
+ }
+ }
+ return result;
+}
+
+/**
+ * This method gets called you want to peek at the bottom
+ * member without removing it.
+ *
+ * @return last item in container
+ */
+void* nsDequeBase::Peek() const {
+ void* result = nullptr;
+ if (mSize > 0) {
+ result = mData[modulus(mSize - 1 + mOrigin, mCapacity)];
+ }
+ return result;
+}
+
+/**
+ * This method gets called you want to peek at the topmost
+ * member without removing it.
+ *
+ * @return last item in container
+ */
+void* nsDequeBase::PeekFront() const {
+ void* result = nullptr;
+ if (mSize > 0) {
+ result = mData[mOrigin];
+ }
+ return result;
+}
+
+/**
+ * Call this to retrieve the ith element from this container.
+ * Keep in mind that accessing the underlying elements is
+ * done in a relative fashion. Object 0 is not necessarily
+ * the first element (the first element is at mOrigin).
+ *
+ * @param aIndex : 0 relative offset of item you want
+ * @return void* or null
+ */
+void* nsDequeBase::ObjectAt(size_t aIndex) const {
+ void* result = nullptr;
+ if (aIndex < mSize) {
+ result = mData[modulus(mOrigin + aIndex, mCapacity)];
+ }
+ return result;
+}
+} // namespace detail
+} // namespace mozilla
diff --git a/xpcom/ds/nsDeque.h b/xpcom/ds/nsDeque.h
new file mode 100644
index 0000000000..4f0bf27037
--- /dev/null
+++ b/xpcom/ds/nsDeque.h
@@ -0,0 +1,538 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * MODULE NOTES:
+ *
+ * The Deque is a very small, very efficient container object
+ * than can hold items of type T*, offering the following features:
+ * - Its interface supports pushing, popping, and peeking of items at the back
+ * or front, and retrieval from any position.
+ * - It can iterate over items via a ForEach method, range-for, or an iterator
+ * class.
+ * - When full, it can efficiently resize dynamically.
+ *
+ * NOTE: The only bit of trickery here is that this deque is
+ * built upon a ring-buffer. Like all ring buffers, the first
+ * item may not be at index[0]. The mOrigin member determines
+ * where the first child is. This point is quietly hidden from
+ * customers of this class.
+ */
+
+#ifndef _NSDEQUE
+#define _NSDEQUE
+#include <cstddef>
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/fallible.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsISupports.h"
+
+namespace mozilla {
+
+namespace detail {
+/**
+ * The deque (double-ended queue) class is a common container type,
+ * whose behavior mimics a line in your favorite checkout stand.
+ * Classic CS describes the common behavior of a queue as FIFO.
+ * A deque allows insertion and removal at both ends of
+ * the container.
+ *
+ * nsDequeBase implements the untyped deque data structure while
+ * nsDeque provides the typed implementation and iterators.
+ */
+class nsDequeBase {
+ public:
+ /**
+ * Returns the number of items currently stored in
+ * this deque.
+ *
+ * @return number of items currently in the deque
+ */
+ inline size_t GetSize() const { return mSize; }
+
+ protected:
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ /**
+ * Constructs an empty deque.
+ *
+ * @param aDeallocator Optional deallocator functor that will be called from
+ * Erase() and the destructor on any remaining item.
+ * The deallocator is owned by the deque and will be
+ * deleted at destruction time.
+ */
+ explicit nsDequeBase();
+
+ /**
+ * Deque destructor. Erases all items, deletes the deallocator.
+ */
+ ~nsDequeBase();
+
+ /**
+ * Appends new member at the end of the deque.
+ *
+ * @param aItem item to store in deque
+ * @return true if succeeded, false if failed to resize deque as needed
+ */
+ [[nodiscard]] bool Push(void* aItem, const fallible_t&);
+
+ /**
+ * Inserts new member at the front of the deque.
+ *
+ * @param aItem item to store in deque
+ * @return true if succeeded, false if failed to resize deque as needed
+ */
+ [[nodiscard]] bool PushFront(void* aItem, const fallible_t&);
+
+ /**
+ * Remove and return the last item in the container.
+ *
+ * @return the item that was the last item in container
+ */
+ void* Pop();
+
+ /**
+ * Remove and return the first item in the container.
+ *
+ * @return the item that was first item in container
+ */
+ void* PopFront();
+
+ /**
+ * Retrieve the last item without removing it.
+ *
+ * @return the last item in container
+ */
+ void* Peek() const;
+
+ /**
+ * Retrieve the first item without removing it.
+ *
+ * @return the first item in container
+ */
+ void* PeekFront() const;
+
+ /**
+ * Retrieve a member from the deque without removing it.
+ *
+ * @param index of desired item
+ * @return item in list, or nullptr if index is outside the deque
+ */
+ void* ObjectAt(size_t aIndex) const;
+
+ bool GrowCapacity();
+
+ /**
+ * Remove all items from container without destroying them.
+ */
+ void Empty();
+
+ size_t mSize;
+ size_t mCapacity;
+ size_t mOrigin;
+ void* mBuffer[8];
+ void** mData;
+
+ nsDequeBase& operator=(const nsDequeBase& aOther) = delete;
+ nsDequeBase(const nsDequeBase& aOther) = delete;
+};
+
+// This iterator assumes that the deque itself is const, i.e., it cannot be
+// modified while the iterator is used.
+// Also it is a 'const' iterator in that it provides copies of the deque's
+// elements, and therefore it is not possible to modify the deque's contents
+// by assigning to a dereference of this iterator.
+template <typename Deque>
+class ConstDequeIterator {
+ public:
+ ConstDequeIterator(const Deque& aDeque, size_t aIndex)
+ : mDeque(aDeque), mIndex(aIndex) {}
+ ConstDequeIterator& operator++() {
+ ++mIndex;
+ return *this;
+ }
+ bool operator==(const ConstDequeIterator& aOther) const {
+ return mIndex == aOther.mIndex;
+ }
+ bool operator!=(const ConstDequeIterator& aOther) const {
+ return mIndex != aOther.mIndex;
+ }
+ typename Deque::PointerType operator*() const {
+ // Don't allow out-of-deque dereferences.
+ MOZ_RELEASE_ASSERT(mIndex < mDeque.GetSize());
+ return mDeque.ObjectAt(mIndex);
+ }
+
+ private:
+ const Deque& mDeque;
+ size_t mIndex;
+};
+
+// It is a 'const' iterator in that it provides copies of the deque's
+// elements, and therefore it is not possible to modify the deque's contents
+// by assigning to a dereference of this iterator.
+// If the deque is modified in other ways, this iterator will stay at the same
+// index, and will handle past-the-end comparisons, but not dereferencing.
+template <typename Deque>
+class ConstIterator {
+ public:
+ // Special index for the end iterator, to track the possibly-shifting
+ // deque size.
+ static const size_t EndIteratorIndex = size_t(-1);
+
+ ConstIterator(const Deque& aDeque, size_t aIndex)
+ : mDeque(aDeque), mIndex(aIndex) {}
+ ConstIterator& operator++() {
+ // End-iterator shouldn't be modified.
+ MOZ_ASSERT(mIndex != EndIteratorIndex);
+ ++mIndex;
+ return *this;
+ }
+ bool operator==(const ConstIterator& aOther) const {
+ return EffectiveIndex() == aOther.EffectiveIndex();
+ }
+ bool operator!=(const ConstIterator& aOther) const {
+ return EffectiveIndex() != aOther.EffectiveIndex();
+ }
+ typename Deque::PointerType operator*() const {
+ // Don't allow out-of-deque dereferences.
+ MOZ_RELEASE_ASSERT(mIndex < mDeque.GetSize());
+ return mDeque.ObjectAt(mIndex);
+ }
+
+ private:
+ // 0 <= index < deque.GetSize() inside the deque, deque.GetSize() otherwise.
+ // Only used when comparing indices, not to actually access items.
+ size_t EffectiveIndex() const {
+ return (mIndex < mDeque.GetSize()) ? mIndex : mDeque.GetSize();
+ }
+
+ const Deque& mDeque;
+ size_t mIndex; // May point outside the deque!
+};
+
+} // namespace detail
+} // namespace mozilla
+
+/**
+ * The nsDequeFunctor class is used when you want to create
+ * callbacks between the deque and your generic code.
+ * Use these objects in a call to ForEach(), and as custom deallocators.
+ */
+template <typename T>
+class nsDequeFunctor {
+ public:
+ virtual void operator()(T* aObject) = 0;
+ virtual ~nsDequeFunctor() = default;
+};
+
+/******************************************************
+ * Here comes the nsDeque class itself...
+ ******************************************************/
+
+/**
+ * The deque (double-ended queue) class is a common container type,
+ * whose behavior mimics a line in your favorite checkout stand.
+ * Classic CS describes the common behavior of a queue as FIFO.
+ * A deque allows insertion and removal at both ends of
+ * the container.
+ *
+ * The deque stores pointers to items.
+ */
+template <typename T>
+class nsDeque : public mozilla::detail::nsDequeBase {
+ typedef mozilla::fallible_t fallible_t;
+
+ public:
+ using PointerType = T*;
+ using ConstDequeIterator = mozilla::detail::ConstDequeIterator<nsDeque<T>>;
+ using ConstIterator = mozilla::detail::ConstIterator<nsDeque<T>>;
+
+ /**
+ * Constructs an empty deque.
+ *
+ * @param aDeallocator Optional deallocator functor that will be called from
+ * Erase() and the destructor on any remaining item.
+ * The deallocator is owned by the deque and will be
+ * deleted at destruction time.
+ */
+ explicit nsDeque(nsDequeFunctor<T>* aDeallocator = nullptr) {
+ MOZ_COUNT_CTOR(nsDeque);
+ mDeallocator = aDeallocator;
+ }
+
+ /**
+ * Deque destructor. Erases all items, deletes the deallocator.
+ */
+ ~nsDeque() {
+ MOZ_COUNT_DTOR(nsDeque);
+
+ Erase();
+ SetDeallocator(nullptr);
+ }
+
+ /**
+ * Appends new member at the end of the deque.
+ *
+ * @param aItem item to store in deque
+ */
+ inline void Push(T* aItem) {
+ if (!nsDequeBase::Push(aItem, mozilla::fallible)) {
+ NS_ABORT_OOM(mSize * sizeof(T*));
+ }
+ }
+
+ /**
+ * Appends new member at the end of the deque.
+ *
+ * @param aItem item to store in deque
+ * @return true if succeeded, false if failed to resize deque as needed
+ */
+ [[nodiscard]] inline bool Push(T* aItem, const fallible_t& aFaillible) {
+ return nsDequeBase::Push(aItem, aFaillible);
+ }
+
+ /**
+ * Inserts new member at the front of the deque.
+ *
+ * @param aItem item to store in deque
+ */
+ inline void PushFront(T* aItem) {
+ if (!nsDequeBase::PushFront(aItem, mozilla::fallible)) {
+ NS_ABORT_OOM(mSize * sizeof(T*));
+ }
+ }
+
+ /**
+ * Inserts new member at the front of the deque.
+ *
+ * @param aItem item to store in deque
+ * @return true if succeeded, false if failed to resize deque as needed
+ */
+ [[nodiscard]] bool PushFront(T* aItem, const fallible_t& aFallible) {
+ return nsDequeBase::PushFront(aItem, aFallible);
+ }
+
+ /**
+ * Remove and return the last item in the container.
+ *
+ * @return the item that was the last item in container
+ */
+ inline T* Pop() { return static_cast<T*>(nsDequeBase::Pop()); }
+
+ /**
+ * Remove and return the first item in the container.
+ *
+ * @return the item that was first item in container
+ */
+ inline T* PopFront() { return static_cast<T*>(nsDequeBase::PopFront()); }
+
+ /**
+ * Retrieve the last item without removing it.
+ *
+ * @return the last item in container
+ */
+ inline T* Peek() const { return static_cast<T*>(nsDequeBase::Peek()); }
+
+ /**
+ * Retrieve the first item without removing it.
+ *
+ * @return the first item in container
+ */
+ inline T* PeekFront() const {
+ return static_cast<T*>(nsDequeBase::PeekFront());
+ }
+
+ /**
+ * Retrieve a member from the deque without removing it.
+ *
+ * @param index of desired item
+ * @return item in list, or nullptr if index is outside the deque
+ */
+ inline T* ObjectAt(size_t aIndex) const {
+ if (NS_WARN_IF(aIndex >= GetSize())) {
+ return nullptr;
+ }
+ return static_cast<T*>(nsDequeBase::ObjectAt(aIndex));
+ }
+
+ /**
+ * Remove and delete all items from container.
+ * Deletes are handled by the deallocator nsDequeFunctor
+ * which is specified at deque construction.
+ */
+ void Erase() {
+ if (mDeallocator && mSize) {
+ ForEach(*mDeallocator);
+ }
+ Empty();
+ }
+
+ /**
+ * Call this method when you want to iterate through all
+ * items in the container, passing a functor along
+ * to call your code.
+ * If the deque is modified during ForEach, iteration will continue based on
+ * item indices; meaning that front operations may effectively skip over
+ * items or visit some items multiple times.
+ *
+ * @param aFunctor object to call for each member
+ */
+ void ForEach(nsDequeFunctor<T>& aFunctor) const {
+ for (size_t i = 0; i < mSize; ++i) {
+ aFunctor(ObjectAt(i));
+ }
+ }
+
+ // If this deque is const, we can provide ConstDequeIterator's.
+ ConstDequeIterator begin() const { return ConstDequeIterator(*this, 0); }
+ ConstDequeIterator end() const { return ConstDequeIterator(*this, mSize); }
+
+ // If this deque is *not* const, we provide ConstIterator's that can handle
+ // deque size changes.
+ ConstIterator begin() { return ConstIterator(*this, 0); }
+ ConstIterator end() {
+ return ConstIterator(*this, ConstIterator::EndIteratorIndex);
+ }
+
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ size_t size = nsDequeBase::SizeOfExcludingThis(aMallocSizeOf);
+ if (mDeallocator) {
+ size += aMallocSizeOf(mDeallocator);
+ }
+ return size;
+ }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ protected:
+ nsDequeFunctor<T>* mDeallocator;
+
+ private:
+ /**
+ * Copy constructor (deleted)
+ *
+ * @param aOther another deque
+ */
+ nsDeque(const nsDeque& aOther) = delete;
+
+ /**
+ * Deque assignment operator (deleted)
+ *
+ * @param aOther another deque
+ * @return *this
+ */
+ nsDeque& operator=(const nsDeque& aOther) = delete;
+
+ void SetDeallocator(nsDequeFunctor<T>* aDeallocator) {
+ delete mDeallocator;
+ mDeallocator = aDeallocator;
+ }
+};
+
+/**
+ * Specialization of nsDeque for reference counted pointers.
+ *
+ * Provides builtin reference handling as part of Push/Peek/Pop
+ */
+template <typename T>
+class nsRefPtrDeque : private nsDeque<T> {
+ typedef mozilla::fallible_t fallible_t;
+
+ class RefPtrDeallocator : public nsDequeFunctor<T> {
+ public:
+ virtual void operator()(T* aObject) override {
+ RefPtr<T> releaseMe = dont_AddRef(aObject);
+ }
+ };
+
+ public:
+ using PointerType = RefPtr<T>;
+ using ConstDequeIterator =
+ mozilla::detail::ConstDequeIterator<nsRefPtrDeque<T>>;
+ using ConstIterator = mozilla::detail::ConstIterator<nsRefPtrDeque<T>>;
+
+ explicit nsRefPtrDeque() : nsDeque<T>(new RefPtrDeallocator()) {}
+
+ inline void PushFront(already_AddRefed<T> aItem) {
+ T* item = aItem.take();
+ nsDeque<T>::PushFront(item);
+ }
+
+ inline void PushFront(T* aItem) { PushFront(do_AddRef(aItem)); }
+
+ inline void Push(T* aItem) { Push(do_AddRef(aItem)); }
+
+ inline void Push(already_AddRefed<T> aItem) {
+ T* item = aItem.take();
+ nsDeque<T>::Push(item);
+ }
+
+ inline already_AddRefed<T> PopFront() {
+ return dont_AddRef(nsDeque<T>::PopFront());
+ }
+
+ inline already_AddRefed<T> Pop() { return dont_AddRef(nsDeque<T>::Pop()); }
+
+ inline T* PeekFront() const { return nsDeque<T>::PeekFront(); }
+
+ inline T* Peek() const { return nsDeque<T>::Peek(); }
+
+ inline T* ObjectAt(size_t aIndex) const {
+ return nsDeque<T>::ObjectAt(aIndex);
+ }
+
+ inline void Erase() { nsDeque<T>::Erase(); }
+
+ // If this deque is const, we can provide ConstDequeIterator's.
+ ConstDequeIterator begin() const { return ConstDequeIterator(*this, 0); }
+ ConstDequeIterator end() const {
+ return ConstDequeIterator(*this, GetSize());
+ }
+
+ // If this deque is *not* const, we provide ConstIterator's that can handle
+ // deque size changes.
+ ConstIterator begin() { return ConstIterator(*this, 0); }
+ ConstIterator end() {
+ return ConstIterator(*this, ConstIterator::EndIteratorIndex);
+ }
+
+ inline size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return nsDeque<T>::SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ inline size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return nsDeque<T>::SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ inline size_t GetSize() const { return nsDeque<T>::GetSize(); }
+
+ /**
+ * Call this method when you want to iterate through all
+ * items in the container, passing a functor along
+ * to call your code.
+ * If the deque is modified during ForEach, iteration will continue based on
+ * item indices; meaning that front operations may effectively skip over
+ * items or visit some items multiple times.
+ *
+ * @param aFunctor object to call for each member
+ */
+ void ForEach(nsDequeFunctor<T>& aFunctor) const {
+ size_t size = GetSize();
+ for (size_t i = 0; i < size; ++i) {
+ aFunctor(ObjectAt(i));
+ }
+ }
+};
+
+#endif
diff --git a/xpcom/ds/nsEnumeratorUtils.cpp b/xpcom/ds/nsEnumeratorUtils.cpp
new file mode 100644
index 0000000000..69631818a3
--- /dev/null
+++ b/xpcom/ds/nsEnumeratorUtils.cpp
@@ -0,0 +1,248 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Attributes.h"
+
+#include "nsEnumeratorUtils.h"
+
+#include "nsIStringEnumerator.h"
+#include "nsSimpleEnumerator.h"
+
+#include "nsCOMPtr.h"
+#include "mozilla/RefPtr.h"
+
+class EmptyEnumeratorImpl : public nsSimpleEnumerator,
+ public nsIUTF8StringEnumerator,
+ public nsIStringEnumerator {
+ public:
+ EmptyEnumeratorImpl() = default;
+
+ // nsISupports interface. Not really inherited, but no mRefCnt.
+ NS_DECL_ISUPPORTS_INHERITED
+
+ // nsISimpleEnumerator
+ NS_DECL_NSISIMPLEENUMERATOR
+ NS_DECL_NSIUTF8STRINGENUMERATOR
+ NS_DECL_NSISTRINGENUMERATORBASE
+ // can't use NS_DECL_NSISTRINGENUMERATOR because they share the
+ // HasMore() signature
+
+ NS_IMETHOD GetNext(nsAString& aResult) override;
+
+ static EmptyEnumeratorImpl* GetInstance() {
+ static const EmptyEnumeratorImpl kInstance;
+ return const_cast<EmptyEnumeratorImpl*>(&kInstance);
+ }
+};
+
+// nsISupports interface
+NS_IMETHODIMP_(MozExternalRefCountType)
+EmptyEnumeratorImpl::AddRef(void) { return 2; }
+
+NS_IMETHODIMP_(MozExternalRefCountType)
+EmptyEnumeratorImpl::Release(void) { return 1; }
+
+NS_IMPL_QUERY_INTERFACE_INHERITED(EmptyEnumeratorImpl, nsSimpleEnumerator,
+ nsIUTF8StringEnumerator, nsIStringEnumerator)
+
+// nsISimpleEnumerator interface
+NS_IMETHODIMP
+EmptyEnumeratorImpl::HasMoreElements(bool* aResult) {
+ *aResult = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+EmptyEnumeratorImpl::HasMore(bool* aResult) {
+ *aResult = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+EmptyEnumeratorImpl::GetNext(nsISupports** aResult) { return NS_ERROR_FAILURE; }
+
+NS_IMETHODIMP
+EmptyEnumeratorImpl::GetNext(nsACString& aResult) {
+ return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP
+EmptyEnumeratorImpl::GetNext(nsAString& aResult) { return NS_ERROR_UNEXPECTED; }
+
+NS_IMETHODIMP
+EmptyEnumeratorImpl::StringIterator(nsIJSEnumerator** aRetVal) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult NS_NewEmptyEnumerator(nsISimpleEnumerator** aResult) {
+ *aResult = EmptyEnumeratorImpl::GetInstance();
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsSingletonEnumerator final : public nsSimpleEnumerator {
+ public:
+ // nsISimpleEnumerator methods
+ NS_IMETHOD HasMoreElements(bool* aResult) override;
+ NS_IMETHOD GetNext(nsISupports** aResult) override;
+
+ explicit nsSingletonEnumerator(nsISupports* aValue);
+
+ private:
+ ~nsSingletonEnumerator() override;
+
+ protected:
+ nsCOMPtr<nsISupports> mValue;
+ bool mConsumed;
+};
+
+nsSingletonEnumerator::nsSingletonEnumerator(nsISupports* aValue)
+ : mValue(aValue) {
+ mConsumed = (mValue ? false : true);
+}
+
+nsSingletonEnumerator::~nsSingletonEnumerator() = default;
+
+NS_IMETHODIMP
+nsSingletonEnumerator::HasMoreElements(bool* aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ *aResult = !mConsumed;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSingletonEnumerator::GetNext(nsISupports** aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (mConsumed) {
+ return NS_ERROR_FAILURE;
+ }
+
+ mConsumed = true;
+
+ *aResult = mValue;
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+nsresult NS_NewSingletonEnumerator(nsISimpleEnumerator** aResult,
+ nsISupports* aSingleton) {
+ RefPtr<nsSingletonEnumerator> enumer = new nsSingletonEnumerator(aSingleton);
+ enumer.forget(aResult);
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsUnionEnumerator final : public nsSimpleEnumerator {
+ public:
+ // nsISimpleEnumerator methods
+ NS_IMETHOD HasMoreElements(bool* aResult) override;
+ NS_IMETHOD GetNext(nsISupports** aResult) override;
+
+ nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
+ nsISimpleEnumerator* aSecondEnumerator);
+
+ private:
+ ~nsUnionEnumerator() override;
+
+ protected:
+ nsCOMPtr<nsISimpleEnumerator> mFirstEnumerator, mSecondEnumerator;
+ bool mConsumed;
+ bool mAtSecond;
+};
+
+nsUnionEnumerator::nsUnionEnumerator(nsISimpleEnumerator* aFirstEnumerator,
+ nsISimpleEnumerator* aSecondEnumerator)
+ : mFirstEnumerator(aFirstEnumerator),
+ mSecondEnumerator(aSecondEnumerator),
+ mConsumed(false),
+ mAtSecond(false) {}
+
+nsUnionEnumerator::~nsUnionEnumerator() = default;
+
+NS_IMETHODIMP
+nsUnionEnumerator::HasMoreElements(bool* aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ nsresult rv;
+
+ if (mConsumed) {
+ *aResult = false;
+ return NS_OK;
+ }
+
+ if (!mAtSecond) {
+ rv = mFirstEnumerator->HasMoreElements(aResult);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ if (*aResult) {
+ return NS_OK;
+ }
+
+ mAtSecond = true;
+ }
+
+ rv = mSecondEnumerator->HasMoreElements(aResult);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ if (*aResult) {
+ return NS_OK;
+ }
+
+ *aResult = false;
+ mConsumed = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsUnionEnumerator::GetNext(nsISupports** aResult) {
+ MOZ_ASSERT(aResult != 0, "null ptr");
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (mConsumed) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!mAtSecond) {
+ return mFirstEnumerator->GetNext(aResult);
+ }
+
+ return mSecondEnumerator->GetNext(aResult);
+}
+
+nsresult NS_NewUnionEnumerator(nsISimpleEnumerator** aResult,
+ nsISimpleEnumerator* aFirstEnumerator,
+ nsISimpleEnumerator* aSecondEnumerator) {
+ *aResult = nullptr;
+ if (!aFirstEnumerator) {
+ *aResult = aSecondEnumerator;
+ } else if (!aSecondEnumerator) {
+ *aResult = aFirstEnumerator;
+ } else {
+ auto* enumer = new nsUnionEnumerator(aFirstEnumerator, aSecondEnumerator);
+ *aResult = enumer;
+ }
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
diff --git a/xpcom/ds/nsEnumeratorUtils.h b/xpcom/ds/nsEnumeratorUtils.h
new file mode 100644
index 0000000000..f7a0db099e
--- /dev/null
+++ b/xpcom/ds/nsEnumeratorUtils.h
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsEnumeratorUtils_h__
+#define nsEnumeratorUtils_h__
+
+#include "nscore.h"
+
+class nsISupports;
+class nsISimpleEnumerator;
+
+nsresult NS_NewEmptyEnumerator(nsISimpleEnumerator** aResult);
+
+nsresult NS_NewSingletonEnumerator(nsISimpleEnumerator** aResult,
+ nsISupports* aSingleton);
+
+nsresult NS_NewUnionEnumerator(nsISimpleEnumerator** aResult,
+ nsISimpleEnumerator* aFirstEnumerator,
+ nsISimpleEnumerator* aSecondEnumerator);
+
+#endif /* nsEnumeratorUtils_h__ */
diff --git a/xpcom/ds/nsExpirationTracker.h b/xpcom/ds/nsExpirationTracker.h
new file mode 100644
index 0000000000..ec2a25f67d
--- /dev/null
+++ b/xpcom/ds/nsExpirationTracker.h
@@ -0,0 +1,618 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef NSEXPIRATIONTRACKER_H_
+#define NSEXPIRATIONTRACKER_H_
+
+#include <cstring>
+#include "MainThreadUtils.h"
+#include "nsAlgorithm.h"
+#include "nsDebug.h"
+#include "nsTArray.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsIEventTarget.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsISupports.h"
+#include "nsIThread.h"
+#include "nsThreadUtils.h"
+#include "nscore.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RefCountType.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Services.h"
+
+/**
+ * Data used to track the expiration state of an object. We promise that this
+ * is 32 bits so that objects that includes this as a field can pad and align
+ * efficiently.
+ */
+struct nsExpirationState {
+ enum {
+ NOT_TRACKED = (1U << 4) - 1,
+ MAX_INDEX_IN_GENERATION = (1U << 28) - 1
+ };
+
+ nsExpirationState() : mGeneration(NOT_TRACKED), mIndexInGeneration(0) {}
+ bool IsTracked() { return mGeneration != NOT_TRACKED; }
+
+ /**
+ * The generation that this object belongs to, or NOT_TRACKED.
+ */
+ uint32_t mGeneration : 4;
+ uint32_t mIndexInGeneration : 28;
+};
+
+/**
+ * ExpirationTracker classes:
+ * - ExpirationTrackerImpl (Thread-safe class)
+ * - nsExpirationTracker (Main-thread only class)
+ *
+ * These classes can track the lifetimes and usage of a large number of
+ * objects, and send a notification some window of time after a live object was
+ * last used. This is very useful when you manage a large number of objects
+ * and want to flush some after they haven't been used for a while.
+ * nsExpirationTracker is designed to be very space and time efficient.
+ *
+ * The type parameter T is the object type that we will track pointers to. T
+ * must include an accessible method GetExpirationState() that returns a
+ * pointer to an nsExpirationState associated with the object (preferably,
+ * stored in a field of the object).
+ *
+ * The parameter K is the number of generations that will be used. Increasing
+ * the number of generations narrows the window within which we promise
+ * to fire notifications, at a slight increase in space cost for the tracker.
+ * We require 2 <= K <= nsExpirationState::NOT_TRACKED (currently 15).
+ *
+ * To use this class, you need to inherit from it and override the
+ * NotifyExpired() method.
+ *
+ * The approach is to track objects in K generations. When an object is accessed
+ * it moves from its current generation to the newest generation. Generations
+ * are stored in a cyclic array; when a timer interrupt fires, we advance
+ * the current generation pointer to effectively age all objects very
+ * efficiently. By storing information in each object about its generation and
+ * index within its generation array, we make removal of objects from a
+ * generation very cheap.
+ *
+ * Future work:
+ * -- Add a method to change the timer period?
+ */
+
+/**
+ * Base class for ExiprationTracker implementations.
+ *
+ * nsExpirationTracker class below is a specialized class to be inherited by the
+ * instances to be accessed only on main-thread.
+ *
+ * For creating a thread-safe tracker, you can define a subclass inheriting this
+ * base class and specialize the Mutex and AutoLock to be used.
+ *
+ * For an example of using ExpirationTrackerImpl with a DataMutex
+ * @see mozilla::gfx::GradientCache.
+ *
+ */
+template <typename T, uint32_t K, typename Mutex, typename AutoLock>
+class ExpirationTrackerImpl {
+ public:
+ /**
+ * Initialize the tracker.
+ * @param aTimerPeriod the timer period in milliseconds. The guarantees
+ * provided by the tracker are defined in terms of this period. If the
+ * period is zero, then we don't use a timer and rely on someone calling
+ * AgeOneGenerationLocked explicitly.
+ * @param aName the name of the subclass for telemetry.
+ * @param aEventTarget the optional event target on main thread to label the
+ * runnable of the asynchronous invocation to NotifyExpired().
+
+ */
+ ExpirationTrackerImpl(uint32_t aTimerPeriod, const char* aName,
+ nsIEventTarget* aEventTarget = nullptr)
+ : mTimerPeriod(aTimerPeriod),
+ mNewestGeneration(0),
+ mInAgeOneGeneration(false),
+ mName(aName),
+ mEventTarget(aEventTarget) {
+ static_assert(K >= 2 && K <= nsExpirationState::NOT_TRACKED,
+ "Unsupported number of generations (must be 2 <= K <= 15)");
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mEventTarget) {
+ bool current = false;
+ // NOTE: The following check+crash could be condensed into a
+ // MOZ_RELEASE_ASSERT, but that triggers a segfault during compilation in
+ // clang 3.8. Once we don't have to care about clang 3.8 anymore, though,
+ // we can convert to MOZ_RELEASE_ASSERT here.
+ if (MOZ_UNLIKELY(NS_FAILED(mEventTarget->IsOnCurrentThread(&current)) ||
+ !current)) {
+ MOZ_CRASH("Provided event target must be on the main thread");
+ }
+ }
+ mObserver = new ExpirationTrackerObserver();
+ mObserver->Init(this);
+ }
+
+ virtual ~ExpirationTrackerImpl() {
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mTimer) {
+ mTimer->Cancel();
+ }
+ mObserver->Destroy();
+ }
+
+ /**
+ * Add an object to be tracked. It must not already be tracked. It will
+ * be added to the newest generation, i.e., as if it was just used.
+ * @return an error on out-of-memory
+ */
+ nsresult AddObjectLocked(T* aObj, const AutoLock& aAutoLock) {
+ if (NS_WARN_IF(!aObj)) {
+ MOZ_DIAGNOSTIC_ASSERT(false, "Invalid object to add");
+ return NS_ERROR_UNEXPECTED;
+ }
+ nsExpirationState* state = aObj->GetExpirationState();
+ if (NS_WARN_IF(state->IsTracked())) {
+ MOZ_DIAGNOSTIC_ASSERT(false,
+ "Tried to add an object that's already tracked");
+ return NS_ERROR_UNEXPECTED;
+ }
+ nsTArray<T*>& generation = mGenerations[mNewestGeneration];
+ uint32_t index = generation.Length();
+ if (index > nsExpirationState::MAX_INDEX_IN_GENERATION) {
+ NS_WARNING("More than 256M elements tracked, this is probably a problem");
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ if (index == 0) {
+ // We might need to start the timer
+ nsresult rv = CheckStartTimerLocked(aAutoLock);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ generation.AppendElement(aObj);
+ state->mGeneration = mNewestGeneration;
+ state->mIndexInGeneration = index;
+ return NS_OK;
+ }
+
+ /**
+ * Remove an object from the tracker. It must currently be tracked.
+ */
+ void RemoveObjectLocked(T* aObj, const AutoLock& aAutoLock) {
+ if (NS_WARN_IF(!aObj)) {
+ MOZ_DIAGNOSTIC_ASSERT(false, "Invalid object to remove");
+ return;
+ }
+ nsExpirationState* state = aObj->GetExpirationState();
+ if (NS_WARN_IF(!state->IsTracked())) {
+ MOZ_DIAGNOSTIC_ASSERT(false,
+ "Tried to remove an object that's not tracked");
+ return;
+ }
+ nsTArray<T*>& generation = mGenerations[state->mGeneration];
+ uint32_t index = state->mIndexInGeneration;
+ MOZ_ASSERT(generation.Length() > index && generation[index] == aObj,
+ "Object is lying about its index");
+ // Move the last object to fill the hole created by removing aObj
+ T* lastObj = generation.PopLastElement();
+ // XXX It looks weird that index might point to the element that was just
+ // removed. Is that really correct?
+ if (index < generation.Length()) {
+ generation[index] = lastObj;
+ }
+ lastObj->GetExpirationState()->mIndexInGeneration = index;
+ state->mGeneration = nsExpirationState::NOT_TRACKED;
+ // We do not check whether we need to stop the timer here. The timer
+ // will check that itself next time it fires. Checking here would not
+ // be efficient since we'd need to track all generations. Also we could
+ // thrash by incessantly creating and destroying timers if someone
+ // kept adding and removing an object from the tracker.
+ }
+
+ /**
+ * Notify that an object has been used.
+ * @return an error if we lost the object from the tracker...
+ */
+ nsresult MarkUsedLocked(T* aObj, const AutoLock& aAutoLock) {
+ nsExpirationState* state = aObj->GetExpirationState();
+ if (mNewestGeneration == state->mGeneration) {
+ return NS_OK;
+ }
+ RemoveObjectLocked(aObj, aAutoLock);
+ return AddObjectLocked(aObj, aAutoLock);
+ }
+
+ /**
+ * The timer calls this, but it can also be manually called if you want
+ * to age objects "artifically". This can result in calls to
+ * NotifyExpiredLocked.
+ */
+ void AgeOneGenerationLocked(const AutoLock& aAutoLock) {
+ if (mInAgeOneGeneration) {
+ NS_WARNING("Can't reenter AgeOneGeneration from NotifyExpired");
+ return;
+ }
+
+ mInAgeOneGeneration = true;
+ uint32_t reapGeneration =
+ mNewestGeneration > 0 ? mNewestGeneration - 1 : K - 1;
+ nsTArray<T*>& generation = mGenerations[reapGeneration];
+ // The following is rather tricky. We have to cope with objects being
+ // removed from this generation either because of a call to RemoveObject
+ // (or indirectly via MarkUsedLocked) inside NotifyExpiredLocked.
+ // Fortunately no objects can be added to this generation because it's not
+ // the newest generation. We depend on the fact that RemoveObject can only
+ // cause the indexes of objects in this generation to *decrease*, not
+ // increase. So if we start from the end and work our way backwards we are
+ // guaranteed to see each object at least once.
+ size_t index = generation.Length();
+ for (;;) {
+ // Objects could have been removed so index could be outside
+ // the array
+ index = XPCOM_MIN(index, generation.Length());
+ if (index == 0) {
+ break;
+ }
+ --index;
+ NotifyExpiredLocked(generation[index], aAutoLock);
+ }
+ // Any leftover objects from reapGeneration just end up in the new
+ // newest-generation. This is bad form, though, so warn if there are any.
+ if (!generation.IsEmpty()) {
+ NS_WARNING("Expired objects were not removed or marked used");
+ }
+ // Free excess memory used by the generation array, since we probably
+ // just removed most or all of its elements.
+ generation.Compact();
+ mNewestGeneration = reapGeneration;
+ mInAgeOneGeneration = false;
+ }
+
+ /**
+ * This just calls AgeOneGenerationLocked K times. Under normal circumstances
+ * this will result in all objects getting NotifyExpiredLocked called on them,
+ * but if NotifyExpiredLocked itself marks some objects as used, then those
+ * objects might not expire. This would be a good thing to call if we get into
+ * a critically-low memory situation.
+ */
+ void AgeAllGenerationsLocked(const AutoLock& aAutoLock) {
+ uint32_t i;
+ for (i = 0; i < K; ++i) {
+ AgeOneGenerationLocked(aAutoLock);
+ }
+ }
+
+ class Iterator {
+ private:
+ ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mTracker;
+ uint32_t mGeneration;
+ uint32_t mIndex;
+
+ public:
+ Iterator(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aTracker,
+ AutoLock& aAutoLock)
+ : mTracker(aTracker), mGeneration(0), mIndex(0) {}
+
+ T* Next() {
+ while (mGeneration < K) {
+ nsTArray<T*>* generation = &mTracker->mGenerations[mGeneration];
+ if (mIndex < generation->Length()) {
+ ++mIndex;
+ return (*generation)[mIndex - 1];
+ }
+ ++mGeneration;
+ mIndex = 0;
+ }
+ return nullptr;
+ }
+ };
+
+ friend class Iterator;
+
+ bool IsEmptyLocked(const AutoLock& aAutoLock) const {
+ for (uint32_t i = 0; i < K; ++i) {
+ if (!mGenerations[i].IsEmpty()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ size_t Length(const AutoLock& aAutoLock) const {
+ size_t len = 0;
+ for (uint32_t i = 0; i < K; ++i) {
+ len += mGenerations[i].Length();
+ }
+ return len;
+ }
+
+ // @return The amount of memory used by this ExpirationTrackerImpl, excluding
+ // sizeof(*this). If you want to measure anything hanging off the mGenerations
+ // array, you must iterate over the elements and measure them individually;
+ // hence the "Shallow" prefix.
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ size_t bytes = 0;
+ for (uint32_t i = 0; i < K; ++i) {
+ bytes += mGenerations[i].ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+ return bytes;
+ }
+
+ protected:
+ /**
+ * This must be overridden to catch notifications. It is called whenever
+ * we detect that an object has not been used for at least (K-1)*mTimerPeriod
+ * milliseconds. If timer events are not delayed, it will be called within
+ * roughly K*mTimerPeriod milliseconds after the last use.
+ * (Unless AgeOneGenerationLocked or AgeAllGenerationsLocked have been called
+ * to accelerate the aging process.)
+ *
+ * NOTE: These bounds ignore delays in timer firings due to actual work being
+ * performed by the browser. We use a slack timer so there is always at least
+ * mTimerPeriod milliseconds between firings, which gives us
+ * (K-1)*mTimerPeriod as a pretty solid lower bound. The upper bound is rather
+ * loose, however. If the maximum amount by which any given timer firing is
+ * delayed is D, then the upper bound before NotifyExpiredLocked is called is
+ * K*(mTimerPeriod + D).
+ *
+ * The NotifyExpiredLocked call is expected to remove the object from the
+ * tracker, but it need not. The object (or other objects) could be
+ * "resurrected" by calling MarkUsedLocked() on them, or they might just not
+ * be removed. Any objects left over that have not been resurrected or removed
+ * are placed in the new newest-generation, but this is considered "bad form"
+ * and should be avoided (we'll issue a warning). (This recycling counts
+ * as "a use" for the purposes of the expiry guarantee above...)
+ *
+ * For robustness and simplicity, we allow objects to be notified more than
+ * once here in the same timer tick.
+ */
+ virtual void NotifyExpiredLocked(T*, const AutoLock&) = 0;
+
+ /**
+ * This may be overridden to perform any post-aging work that needs to be
+ * done while still holding the lock. It will be called once after each timer
+ * event, and each low memory event has been handled.
+ */
+ virtual void NotifyHandlerEndLocked(const AutoLock&){};
+
+ /**
+ * This may be overridden to perform any post-aging work that needs to be
+ * done outside the lock. It will be called once after each
+ * NotifyEndTransactionLocked call.
+ */
+ virtual void NotifyHandlerEnd(){};
+
+ virtual Mutex& GetMutex() = 0;
+
+ private:
+ class ExpirationTrackerObserver;
+ RefPtr<ExpirationTrackerObserver> mObserver;
+ nsTArray<T*> mGenerations[K];
+ nsCOMPtr<nsITimer> mTimer;
+ uint32_t mTimerPeriod;
+ uint32_t mNewestGeneration;
+ bool mInAgeOneGeneration;
+ const char* const mName; // Used for timer firing profiling.
+ const nsCOMPtr<nsIEventTarget> mEventTarget;
+
+ /**
+ * Whenever "memory-pressure" is observed, it calls AgeAllGenerationsLocked()
+ * to minimize memory usage.
+ */
+ class ExpirationTrackerObserver final : public nsIObserver {
+ public:
+ void Init(ExpirationTrackerImpl<T, K, Mutex, AutoLock>* aObj) {
+ mOwner = aObj;
+ nsCOMPtr<nsIObserverService> obs =
+ mozilla::services::GetObserverService();
+ if (obs) {
+ obs->AddObserver(this, "memory-pressure", false);
+ }
+ }
+ void Destroy() {
+ mOwner = nullptr;
+ nsCOMPtr<nsIObserverService> obs =
+ mozilla::services::GetObserverService();
+ if (obs) {
+ obs->RemoveObserver(this, "memory-pressure");
+ }
+ }
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+ private:
+ ExpirationTrackerImpl<T, K, Mutex, AutoLock>* mOwner;
+ };
+
+ void HandleLowMemory() {
+ {
+ AutoLock lock(GetMutex());
+ AgeAllGenerationsLocked(lock);
+ NotifyHandlerEndLocked(lock);
+ }
+ NotifyHandlerEnd();
+ }
+
+ void HandleTimeout() {
+ {
+ AutoLock lock(GetMutex());
+ AgeOneGenerationLocked(lock);
+ // Cancel the timer if we have no objects to track
+ if (IsEmptyLocked(lock)) {
+ mTimer->Cancel();
+ mTimer = nullptr;
+ }
+ NotifyHandlerEndLocked(lock);
+ }
+ NotifyHandlerEnd();
+ }
+
+ static void TimerCallback(nsITimer* aTimer, void* aThis) {
+ ExpirationTrackerImpl* tracker = static_cast<ExpirationTrackerImpl*>(aThis);
+ tracker->HandleTimeout();
+ }
+
+ nsresult CheckStartTimerLocked(const AutoLock& aAutoLock) {
+ if (mTimer || !mTimerPeriod) {
+ return NS_OK;
+ }
+ nsCOMPtr<nsIEventTarget> target = mEventTarget;
+ if (!target && !NS_IsMainThread()) {
+ // TimerCallback should always be run on the main thread to prevent races
+ // to the destruction of the tracker.
+ target = do_GetMainThread();
+ NS_ENSURE_STATE(target);
+ }
+
+ return NS_NewTimerWithFuncCallback(
+ getter_AddRefs(mTimer), TimerCallback, this, mTimerPeriod,
+ nsITimer::TYPE_REPEATING_SLACK_LOW_PRIORITY, mName, target);
+ }
+};
+
+namespace detail {
+
+class PlaceholderLock {
+ public:
+ void Lock() {}
+ void Unlock() {}
+};
+
+class PlaceholderAutoLock {
+ public:
+ explicit PlaceholderAutoLock(PlaceholderLock&) {}
+ ~PlaceholderAutoLock() = default;
+};
+
+template <typename T, uint32_t K>
+using SingleThreadedExpirationTracker =
+ ExpirationTrackerImpl<T, K, PlaceholderLock, PlaceholderAutoLock>;
+
+} // namespace detail
+
+template <typename T, uint32_t K>
+class nsExpirationTracker
+ : protected ::detail::SingleThreadedExpirationTracker<T, K> {
+ typedef ::detail::PlaceholderLock Lock;
+ typedef ::detail::PlaceholderAutoLock AutoLock;
+
+ Lock mLock;
+
+ AutoLock FakeLock() {
+ MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+ return AutoLock(mLock);
+ }
+
+ Lock& GetMutex() override {
+ MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+ return mLock;
+ }
+
+ void NotifyExpiredLocked(T* aObject, const AutoLock&) override {
+ NotifyExpired(aObject);
+ }
+
+ /**
+ * Since there are no users of these callbacks in the single threaded case,
+ * we mark them as final with the hope that the compiler can optimize the
+ * method calls out entirely.
+ */
+ void NotifyHandlerEndLocked(const AutoLock&) final {}
+ void NotifyHandlerEnd() final {}
+
+ protected:
+ virtual void NotifyExpired(T* aObj) = 0;
+
+ public:
+ nsExpirationTracker(uint32_t aTimerPeriod, const char* aName,
+ nsIEventTarget* aEventTarget = nullptr)
+ : ::detail::SingleThreadedExpirationTracker<T, K>(aTimerPeriod, aName,
+ aEventTarget) {}
+
+ virtual ~nsExpirationTracker() = default;
+
+ nsresult AddObject(T* aObj) {
+ return this->AddObjectLocked(aObj, FakeLock());
+ }
+
+ void RemoveObject(T* aObj) { this->RemoveObjectLocked(aObj, FakeLock()); }
+
+ nsresult MarkUsed(T* aObj) { return this->MarkUsedLocked(aObj, FakeLock()); }
+
+ void AgeOneGeneration() { this->AgeOneGenerationLocked(FakeLock()); }
+
+ void AgeAllGenerations() { this->AgeAllGenerationsLocked(FakeLock()); }
+
+ class Iterator {
+ private:
+ AutoLock mAutoLock;
+ typename ExpirationTrackerImpl<T, K, Lock, AutoLock>::Iterator mIterator;
+
+ public:
+ explicit Iterator(nsExpirationTracker<T, K>* aTracker)
+ : mAutoLock(aTracker->GetMutex()), mIterator(aTracker, mAutoLock) {}
+
+ T* Next() { return mIterator.Next(); }
+ };
+
+ friend class Iterator;
+
+ bool IsEmpty() { return this->IsEmptyLocked(FakeLock()); }
+};
+
+template <typename T, uint32_t K, typename Mutex, typename AutoLock>
+NS_IMETHODIMP ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ ExpirationTrackerObserver::Observe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData) {
+ if (!strcmp(aTopic, "memory-pressure") && mOwner) {
+ mOwner->HandleLowMemory();
+ }
+ return NS_OK;
+}
+
+template <class T, uint32_t K, typename Mutex, typename AutoLock>
+NS_IMETHODIMP_(MozExternalRefCountType)
+ExpirationTrackerImpl<T, K, Mutex, AutoLock>::ExpirationTrackerObserver::AddRef(
+ void) {
+ MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
+ NS_ASSERT_OWNINGTHREAD(ExpirationTrackerObserver);
+ ++mRefCnt;
+ NS_LOG_ADDREF(this, mRefCnt, "ExpirationTrackerObserver", sizeof(*this));
+ return mRefCnt;
+}
+
+template <class T, uint32_t K, typename Mutex, typename AutoLock>
+NS_IMETHODIMP_(MozExternalRefCountType)
+ExpirationTrackerImpl<T, K, Mutex,
+ AutoLock>::ExpirationTrackerObserver::Release(void) {
+ MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
+ NS_ASSERT_OWNINGTHREAD(ExpirationTrackerObserver);
+ --mRefCnt;
+ NS_LOG_RELEASE(this, mRefCnt, "ExpirationTrackerObserver");
+ if (mRefCnt == 0) {
+ NS_ASSERT_OWNINGTHREAD(ExpirationTrackerObserver);
+ mRefCnt = 1; /* stabilize */
+ delete (this);
+ return 0;
+ }
+ return mRefCnt;
+}
+
+template <class T, uint32_t K, typename Mutex, typename AutoLock>
+NS_IMETHODIMP ExpirationTrackerImpl<T, K, Mutex, AutoLock>::
+ ExpirationTrackerObserver::QueryInterface(REFNSIID aIID,
+ void** aInstancePtr) {
+ NS_ASSERTION(aInstancePtr, "QueryInterface requires a non-NULL destination!");
+ nsresult rv = NS_ERROR_FAILURE;
+ NS_INTERFACE_TABLE(ExpirationTrackerObserver, nsIObserver)
+ return rv;
+}
+
+#endif /*NSEXPIRATIONTRACKER_H_*/
diff --git a/xpcom/ds/nsGkAtoms.cpp b/xpcom/ds/nsGkAtoms.cpp
new file mode 100644
index 0000000000..402e0eb779
--- /dev/null
+++ b/xpcom/ds/nsGkAtoms.cpp
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsGkAtoms.h"
+
+namespace mozilla {
+namespace detail {
+
+// Because this is `constexpr` it ends up in read-only memory where it can be
+// shared between processes.
+extern constexpr GkAtoms gGkAtoms = {
+// The initialization of each atom's string.
+//
+// Expansion of the example GK_ATOM entries in nsGkAtoms.h:
+//
+// u"a",
+// u"bb",
+// u"Ccc",
+//
+#define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) \
+ u"" value_,
+#include "nsGkAtomList.h"
+#undef GK_ATOM
+ {
+// The initialization of the atoms themselves.
+//
+// Note that |value_| is an 8-bit string, and so |sizeof(value_)| is equal
+// to the number of chars (including the terminating '\0'). The |u""| prefix
+// converts |value_| to a 16-bit string.
+//
+// Expansion of the example GK_ATOM entries in nsGkAtoms.h:
+//
+// nsStaticAtom(
+// 1,
+// 0x01234567,
+// offsetof(GkAtoms, mAtoms[static_cast<size_t>(GkAtoms::Atoms::a)]) -
+// offsetof(GkAtoms, a_string),
+// true),
+//
+// nsStaticAtom(
+// 2,
+// 0x12345678,
+// offsetof(GkAtoms, mAtoms[static_cast<size_t>(GkAtoms::Atoms::bb)]) -
+// offsetof(GkAtoms, bb_string),
+// false),
+//
+// nsStaticAtom(
+// 3,
+// 0x23456789,
+// offsetof(GkAtoms, mAtoms[static_cast<size_t>(GkAtoms::Atoms::Ccc)]) -
+// offsetof(GkAtoms, Ccc_string),
+// false),
+//
+#define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) \
+ nsStaticAtom( \
+ sizeof(value_) - 1, hash_, \
+ offsetof(GkAtoms, mAtoms[static_cast<size_t>(GkAtoms::Atoms::name_)]) - \
+ offsetof(GkAtoms, name_##_string), \
+ is_ascii_lower_),
+#include "nsGkAtomList.h"
+#undef GK_ATOM
+ }};
+
+} // namespace detail
+} // namespace mozilla
+
+const nsStaticAtom* const nsGkAtoms::sAtoms = mozilla::detail::gGkAtoms.mAtoms;
diff --git a/xpcom/ds/nsGkAtoms.h b/xpcom/ds/nsGkAtoms.h
new file mode 100644
index 0000000000..eba33bf95c
--- /dev/null
+++ b/xpcom/ds/nsGkAtoms.h
@@ -0,0 +1,192 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsGkAtoms_h___
+#define nsGkAtoms_h___
+
+#include "nsAtom.h"
+
+// Static atoms are structured carefully to satisfy a lot of constraints.
+//
+// - We have ~2300 static atoms.
+//
+// - We want them to be constexpr so they end up in .rodata, and thus shared
+// between processes, minimizing memory usage.
+//
+// - We need them to be in an array, so we can iterate over them (for
+// registration and lookups).
+//
+// - Each static atom has a string literal associated with it. We can't use a
+// pointer to the string literal because then the atoms won't end up in
+// .rodata. Therefore the string literals and the atoms must be arranged in a
+// way such that a numeric index can be used instead. This numeric index
+// (nsStaticAtom::mStringOffset) must be computable at compile-time to keep
+// the static atom constexpr. It should also not be too large (a uint32_t is
+// reasonable).
+//
+// - Each static atom stores the hash value of its associated string literal;
+// it's used in various ways. The hash value must be specified at
+// compile-time, to keep the static atom constexpr.
+//
+// - As well as accessing each static atom via array indexing, we need an
+// individual pointer, e.g. nsGkAtoms::foo. We want this to be constexpr so
+// it doesn't take up any space in memory.
+//
+// - The array of static atoms can't be in a .h file, because it's a huge
+// constexpr expression, which would blow out compile times. But the
+// individual pointers for the static atoms must be in a .h file so they are
+// public.
+//
+// nsGkAtoms below defines static atoms in a way that satisfies these
+// constraints. It uses nsGkAtomList.h, which defines the names and values of
+// the atoms. nsGkAtomList.h is generated by StaticAtoms.py and has entries
+// that look like this:
+//
+// GK_ATOM(a, "a", 0x01234567, nsStaticAtom, Atom)
+// GK_ATOM(bb, "bb", 0x12345678, nsCSSPseudoElementStaticAtom,
+// PseudoElementAtom)
+// GK_ATOM(Ccc, "Ccc", 0x23456789, nsCSSAnonBoxPseudoStaticAtom,
+// InheritingAnonBoxAtom)
+//
+// Comments throughout this file and nsGkAtoms.cpp show how these entries get
+// expanded by macros.
+
+// Trivial subclasses of nsStaticAtom so that function signatures can require
+// an atom from a specific atom list.
+#define DEFINE_STATIC_ATOM_SUBCLASS(name_) \
+ class name_ : public nsStaticAtom { \
+ public: \
+ constexpr name_(uint32_t aLength, uint32_t aHash, uint32_t aOffset, \
+ bool aIsAsciiLowercase) \
+ : nsStaticAtom(aLength, aHash, aOffset, aIsAsciiLowercase) {} \
+ };
+
+DEFINE_STATIC_ATOM_SUBCLASS(nsCSSAnonBoxPseudoStaticAtom)
+DEFINE_STATIC_ATOM_SUBCLASS(nsCSSPseudoElementStaticAtom)
+
+#undef DEFINE_STATIC_ATOM_SUBCLASS
+
+namespace mozilla {
+namespace detail {
+
+// This `detail` class contains the atom strings and the atom objects. Because
+// they are together in a class, the `mStringOffset` field of the atoms will be
+// small and can be initialized at compile time.
+//
+// A `detail` namespace is used because the things within it aren't directly
+// referenced by external users of these static atoms.
+struct GkAtoms {
+// The declaration of each atom's string.
+//
+// Expansion of the example GK_ATOM entries from above:
+//
+// const char16_t a_string[sizeof("a")];
+// const char16_t bb_string[sizeof("bb")];
+// const char16_t Ccc_string[sizeof("Ccc")];
+//
+#define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) \
+ const char16_t name_##_string[sizeof(value_)];
+#include "nsGkAtomList.h"
+#undef GK_ATOM
+
+ // The enum value for each atom.
+ enum class Atoms {
+// Expansion of the example GK_ATOM entries above:
+//
+// a,
+// bb,
+// Ccc,
+//
+#define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) name_,
+#include "nsGkAtomList.h"
+#undef GK_ATOM
+ AtomsCount
+ };
+
+ const nsStaticAtom mAtoms[static_cast<size_t>(Atoms::AtomsCount)];
+};
+
+// The offset from the start of the GkAtoms object to the start of the
+// nsStaticAtom array inside it. This is used in Rust to avoid problems
+// with lld-link.exe on Windows when rust-bindgen generates a non-opaque
+// version of GkAtoms.
+//
+// https://bugzilla.mozilla.org/show_bug.cgi?id=1517685
+const ptrdiff_t kGkAtomsArrayOffset = offsetof(GkAtoms, mAtoms);
+
+// The GkAtoms instance is `extern const` so it can be defined in a .cpp file.
+//
+// XXX: The NS_EXTERNAL_VIS is necessary to work around an apparent GCC bug:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87494
+#if defined(__GNUC__) && !defined(__clang__)
+extern NS_EXTERNAL_VIS const GkAtoms gGkAtoms;
+#else
+extern const GkAtoms gGkAtoms;
+#endif
+
+} // namespace detail
+} // namespace mozilla
+
+// This class holds the pointers to the individual atoms.
+class nsGkAtoms {
+ private:
+ friend void NS_InitAtomTable();
+
+ // This is a useful handle to the array of atoms, used below and also
+ // possibly by Rust code.
+ static const nsStaticAtom* const sAtoms;
+
+ // The number of atoms, used below.
+ static constexpr size_t sAtomsLen =
+ static_cast<size_t>(mozilla::detail::GkAtoms::Atoms::AtomsCount);
+
+ public:
+ static nsStaticAtom* GetAtomByIndex(size_t aIndex) {
+ MOZ_ASSERT(aIndex < sAtomsLen);
+ return const_cast<nsStaticAtom*>(&sAtoms[aIndex]);
+ }
+
+ static size_t IndexOf(const nsStaticAtom* atom) {
+ nsStaticAtom* firstAtom = GetAtomByIndex(0);
+ size_t ret = atom - firstAtom;
+ MOZ_ASSERT(ret < sAtomsLen);
+ return ret;
+ }
+
+// The definition of the pointer to each static atom.
+//
+// These types are not `static constexpr <type>* const` -- even though these
+// atoms are immutable -- because they are often passed to functions with
+// `nsAtom*` parameters that can be passed both dynamic and static atoms.
+//
+// Expansion of the example GK_ATOM entries above:
+//
+// static constexpr nsStaticAtom* a =
+// const_cast<nsStaticAtom*>(
+// &mozilla::detail::gGkAtoms.mAtoms[
+// static_cast<size_t>(mozilla::detail::GkAtoms::Atoms::a)]);
+//
+// static constexpr nsStaticAtom* bb =
+// const_cast<nsStaticAtom*>(
+// &mozilla::detail::gGkAtoms.mAtoms[
+// static_cast<size_t>(mozilla::detail::GkAtoms::Atoms::bb)]);
+//
+// static constexpr nsStaticAtom* Ccc =
+// const_cast<nsStaticAtom*>(
+// &mozilla::detail::gGkAtoms.mAtoms[
+// static_cast<size_t>(mozilla::detail::GkAtoms::Atoms::Ccc)]);
+//
+#define GK_ATOM(name_, value_, hash_, is_ascii_lower_, type_, atom_type_) \
+ static constexpr nsStaticAtom* name_ = const_cast<nsStaticAtom*>( \
+ &mozilla::detail::gGkAtoms.mAtoms[static_cast<size_t>( \
+ mozilla::detail::GkAtoms::Atoms::name_)]);
+#include "nsGkAtomList.h"
+#undef GK_ATOM
+};
+
+inline bool nsAtom::IsEmpty() const { return this == nsGkAtoms::_empty; }
+
+#endif /* nsGkAtoms_h___ */
diff --git a/xpcom/ds/nsHashKeys.h b/xpcom/ds/nsHashKeys.h
new file mode 100644
index 0000000000..fb0a8244c4
--- /dev/null
+++ b/xpcom/ds/nsHashKeys.h
@@ -0,0 +1,636 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTHashKeys_h__
+#define nsTHashKeys_h__
+
+#include "nsID.h"
+#include "nsISupports.h"
+#include "nsCOMPtr.h"
+#include "PLDHashTable.h"
+#include <new>
+
+#include "nsString.h"
+#include "nsCRTGlue.h"
+#include "nsUnicharUtils.h"
+#include "nsPointerHashKeys.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "mozilla/HashFunctions.h"
+
+namespace mozilla {
+
+// These are defined analogously to the HashString overloads in mfbt.
+
+inline uint32_t HashString(const nsAString& aStr) {
+ return HashString(aStr.BeginReading(), aStr.Length());
+}
+
+inline uint32_t HashString(const nsACString& aStr) {
+ return HashString(aStr.BeginReading(), aStr.Length());
+}
+
+} // namespace mozilla
+
+/** @file nsHashKeys.h
+ * standard HashKey classes for nsBaseHashtable and relatives. Each of these
+ * classes follows the nsTHashtable::EntryType specification
+ *
+ * Lightweight keytypes provided here:
+ * nsStringHashKey
+ * nsCStringHashKey
+ * nsUint32HashKey
+ * nsUint64HashKey
+ * nsFloatHashKey
+ * IntPtrHashKey
+ * nsPtrHashKey
+ * nsClearingPtrHashKey
+ * nsVoidPtrHashKey
+ * nsClearingVoidPtrHashKey
+ * nsISupportsHashKey
+ * nsIDHashKey
+ * nsDepCharHashKey
+ * nsCharPtrHashKey
+ * nsUnicharPtrHashKey
+ * nsGenericHashKey
+ */
+
+/**
+ * hashkey wrapper using nsAString KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsStringHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const nsAString& KeyType;
+ typedef const nsAString* KeyTypePointer;
+
+ explicit nsStringHashKey(KeyTypePointer aStr) : mStr(*aStr) {}
+ nsStringHashKey(const nsStringHashKey&) = delete;
+ nsStringHashKey(nsStringHashKey&& aToMove)
+ : PLDHashEntryHdr(std::move(aToMove)), mStr(std::move(aToMove.mStr)) {}
+ ~nsStringHashKey() = default;
+
+ KeyType GetKey() const { return mStr; }
+ bool KeyEquals(const KeyTypePointer aKey) const { return mStr.Equals(*aKey); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(const KeyTypePointer aKey) {
+ return mozilla::HashString(*aKey);
+ }
+
+#ifdef MOZILLA_INTERNAL_API
+ // To avoid double-counting, only measure the string if it is unshared.
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+ }
+#endif
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ nsString mStr;
+};
+
+#ifdef MOZILLA_INTERNAL_API
+
+namespace mozilla::detail {
+
+template <class CharT, bool Unicode = true>
+struct comparatorTraits {};
+
+template <>
+struct comparatorTraits<char, false> {
+ static int caseInsensitiveCompare(const char* aLhs, const char* aRhs,
+ size_t aLhsLength, size_t aRhsLength) {
+ return nsCaseInsensitiveCStringComparator(aLhs, aRhs, aLhsLength,
+ aRhsLength);
+ };
+};
+
+template <>
+struct comparatorTraits<char, true> {
+ static int caseInsensitiveCompare(const char* aLhs, const char* aRhs,
+ size_t aLhsLength, size_t aRhsLength) {
+ return nsCaseInsensitiveUTF8StringComparator(aLhs, aRhs, aLhsLength,
+ aRhsLength);
+ };
+};
+
+template <>
+struct comparatorTraits<char16_t, true> {
+ static int caseInsensitiveCompare(const char16_t* aLhs, const char16_t* aRhs,
+ size_t aLhsLength, size_t aRhsLength) {
+ return nsCaseInsensitiveStringComparator(aLhs, aRhs, aLhsLength,
+ aRhsLength);
+ };
+};
+
+} // namespace mozilla::detail
+
+/**
+ * This is internal-API only because nsCaseInsensitive{C}StringComparator is
+ * internal-only.
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+
+template <typename T, bool Unicode>
+class nsTStringCaseInsensitiveHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const nsTSubstring<T>& KeyType;
+ typedef const nsTSubstring<T>* KeyTypePointer;
+
+ explicit nsTStringCaseInsensitiveHashKey(KeyTypePointer aStr) : mStr(*aStr) {
+ // take it easy just deal HashKey
+ }
+
+ nsTStringCaseInsensitiveHashKey(const nsTStringCaseInsensitiveHashKey&) =
+ delete;
+ nsTStringCaseInsensitiveHashKey(nsTStringCaseInsensitiveHashKey&& aToMove)
+ : PLDHashEntryHdr(std::move(aToMove)), mStr(std::move(aToMove.mStr)) {}
+ ~nsTStringCaseInsensitiveHashKey() = default;
+
+ KeyType GetKey() const { return mStr; }
+ bool KeyEquals(const KeyTypePointer aKey) const {
+ using comparator = typename mozilla::detail::comparatorTraits<T, Unicode>;
+ return mStr.Equals(*aKey, comparator::caseInsensitiveCompare);
+ }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(const KeyTypePointer aKey) {
+ nsTAutoString<T> tmKey(*aKey);
+ ToLowerCase(tmKey);
+ return mozilla::HashString(tmKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ // To avoid double-counting, only measure the string if it is unshared.
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+ }
+
+ private:
+ const nsTString<T> mStr;
+};
+
+using nsStringCaseInsensitiveHashKey =
+ nsTStringCaseInsensitiveHashKey<char16_t, true>;
+using nsCStringASCIICaseInsensitiveHashKey =
+ nsTStringCaseInsensitiveHashKey<char, false>;
+using nsCStringUTF8CaseInsensitiveHashKey =
+ nsTStringCaseInsensitiveHashKey<char, true>;
+
+#endif // MOZILLA_INTERNAL_API
+
+/**
+ * hashkey wrapper using nsACString KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsCStringHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const nsACString& KeyType;
+ typedef const nsACString* KeyTypePointer;
+
+ explicit nsCStringHashKey(const nsACString* aStr) : mStr(*aStr) {}
+ nsCStringHashKey(nsCStringHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mStr(std::move(aOther.mStr)) {}
+ ~nsCStringHashKey() = default;
+
+ KeyType GetKey() const { return mStr; }
+ bool KeyEquals(KeyTypePointer aKey) const { return mStr.Equals(*aKey); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return mozilla::HashString(*aKey);
+ }
+
+#ifdef MOZILLA_INTERNAL_API
+ // To avoid double-counting, only measure the string if it is unshared.
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+ }
+#endif
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const nsCString mStr;
+};
+
+/**
+ * hashkey wrapper using integral or enum KeyTypes
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+template <typename T,
+ std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>, int> = 0>
+class nsIntegralHashKey : public PLDHashEntryHdr {
+ public:
+ using KeyType = const T&;
+ using KeyTypePointer = const T*;
+
+ explicit nsIntegralHashKey(KeyTypePointer aKey) : mValue(*aKey) {}
+ nsIntegralHashKey(nsIntegralHashKey&& aOther) noexcept
+ : PLDHashEntryHdr(std::move(aOther)), mValue(aOther.mValue) {}
+ ~nsIntegralHashKey() = default;
+
+ KeyType GetKey() const { return mValue; }
+ bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return mozilla::HashGeneric(*aKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const T mValue;
+};
+
+/**
+ * hashkey wrapper using uint32_t KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+using nsUint32HashKey = nsIntegralHashKey<uint32_t>;
+
+/**
+ * hashkey wrapper using uint64_t KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+using nsUint64HashKey = nsIntegralHashKey<uint64_t>;
+
+/**
+ * hashkey wrapper using float KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsFloatHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const float& KeyType;
+ typedef const float* KeyTypePointer;
+
+ explicit nsFloatHashKey(KeyTypePointer aKey) : mValue(*aKey) {}
+ nsFloatHashKey(nsFloatHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mValue(std::move(aOther.mValue)) {}
+ ~nsFloatHashKey() = default;
+
+ KeyType GetKey() const { return mValue; }
+ bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return *reinterpret_cast<const uint32_t*>(aKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const float mValue;
+};
+
+/**
+ * hashkey wrapper using intptr_t KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+using IntPtrHashKey = nsIntegralHashKey<intptr_t>;
+
+/**
+ * hashkey wrapper using nsISupports* KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsISupportsHashKey : public PLDHashEntryHdr {
+ public:
+ typedef nsISupports* KeyType;
+ typedef const nsISupports* KeyTypePointer;
+
+ explicit nsISupportsHashKey(const nsISupports* aKey)
+ : mSupports(const_cast<nsISupports*>(aKey)) {}
+ nsISupportsHashKey(nsISupportsHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)),
+ mSupports(std::move(aOther.mSupports)) {}
+ ~nsISupportsHashKey() = default;
+
+ KeyType GetKey() const { return mSupports; }
+ bool KeyEquals(KeyTypePointer aKey) const { return aKey == mSupports; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return NS_PTR_TO_UINT32(aKey) >> 2;
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ nsCOMPtr<nsISupports> mSupports;
+};
+
+/**
+ * hashkey wrapper using refcounted * KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+template <class T>
+class nsRefPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef T* KeyType;
+ typedef const T* KeyTypePointer;
+
+ explicit nsRefPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
+ nsRefPtrHashKey(nsRefPtrHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mKey(std::move(aOther.mKey)) {}
+ ~nsRefPtrHashKey() = default;
+
+ KeyType GetKey() const { return mKey; }
+ bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return NS_PTR_TO_UINT32(aKey) >> 2;
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ RefPtr<T> mKey;
+};
+
+template <class T>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback, nsRefPtrHashKey<T>& aField,
+ const char* aName, uint32_t aFlags = 0) {
+ CycleCollectionNoteChild(aCallback, aField.GetKey(), aName, aFlags);
+}
+
+/**
+ * hashkey wrapper using T* KeyType that sets key to nullptr upon
+ * destruction. Relevant only in cases where a memory pointer-scanner
+ * like valgrind might get confused about stale references.
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+
+template <class T>
+class nsClearingPtrHashKey : public nsPtrHashKey<T> {
+ public:
+ explicit nsClearingPtrHashKey(const T* aKey) : nsPtrHashKey<T>(aKey) {}
+ nsClearingPtrHashKey(nsClearingPtrHashKey&& aToMove)
+ : nsPtrHashKey<T>(std::move(aToMove)) {}
+ ~nsClearingPtrHashKey() { nsPtrHashKey<T>::mKey = nullptr; }
+};
+
+typedef nsClearingPtrHashKey<const void> nsClearingVoidPtrHashKey;
+
+/**
+ * hashkey wrapper using a function pointer KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+template <class T>
+class nsFuncPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef T& KeyType;
+ typedef const T* KeyTypePointer;
+
+ explicit nsFuncPtrHashKey(const T* aKey) : mKey(*const_cast<T*>(aKey)) {}
+ nsFuncPtrHashKey(const nsFuncPtrHashKey<T>& aToCopy) : mKey(aToCopy.mKey) {}
+ ~nsFuncPtrHashKey() = default;
+
+ KeyType GetKey() const { return const_cast<T&>(mKey); }
+ bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return NS_PTR_TO_UINT32(*aKey) >> 2;
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ protected:
+ T mKey;
+};
+
+/**
+ * hashkey wrapper using nsID KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsIDHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const nsID& KeyType;
+ typedef const nsID* KeyTypePointer;
+
+ explicit nsIDHashKey(const nsID* aInID) : mID(*aInID) {}
+ nsIDHashKey(nsIDHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mID(std::move(aOther.mID)) {}
+ ~nsIDHashKey() = default;
+
+ KeyType GetKey() const { return mID; }
+ bool KeyEquals(KeyTypePointer aKey) const { return aKey->Equals(mID); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ // Hash the nsID object's raw bytes.
+ return mozilla::HashBytes(aKey, sizeof(KeyType));
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ nsID mID;
+};
+
+/**
+ * hashkey wrapper using nsID* KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsIDPointerHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const nsID* KeyType;
+ typedef const nsID* KeyTypePointer;
+
+ explicit nsIDPointerHashKey(const nsID* aInID) : mID(aInID) {}
+ nsIDPointerHashKey(nsIDPointerHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mID(aOther.mID) {}
+ ~nsIDPointerHashKey() = default;
+
+ KeyType GetKey() const { return mID; }
+ bool KeyEquals(KeyTypePointer aKey) const { return aKey->Equals(*mID); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ // Hash the nsID object's raw bytes.
+ return mozilla::HashBytes(aKey, sizeof(*aKey));
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const nsID* mID;
+};
+
+/**
+ * hashkey wrapper for "dependent" const char*; this class does not "own"
+ * its string pointer.
+ *
+ * This class must only be used if the strings have a lifetime longer than
+ * the hashtable they occupy. This normally occurs only for static
+ * strings or strings that have been arena-allocated.
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+class nsDepCharHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const char* KeyType;
+ typedef const char* KeyTypePointer;
+
+ explicit nsDepCharHashKey(const char* aKey) : mKey(aKey) {}
+ nsDepCharHashKey(nsDepCharHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mKey(std::move(aOther.mKey)) {}
+ ~nsDepCharHashKey() = default;
+
+ const char* GetKey() const { return mKey; }
+ bool KeyEquals(const char* aKey) const { return !strcmp(mKey, aKey); }
+
+ static const char* KeyToPointer(const char* aKey) { return aKey; }
+ static PLDHashNumber HashKey(const char* aKey) {
+ return mozilla::HashString(aKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const char* mKey;
+};
+
+/**
+ * hashkey wrapper for const char*; at construction, this class duplicates
+ * a string pointed to by the pointer so that it doesn't matter whether or not
+ * the string lives longer than the hash table.
+ */
+class nsCharPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const char* KeyType;
+ typedef const char* KeyTypePointer;
+
+ explicit nsCharPtrHashKey(const char* aKey) : mKey(strdup(aKey)) {}
+
+ nsCharPtrHashKey(const nsCharPtrHashKey&) = delete;
+ nsCharPtrHashKey(nsCharPtrHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mKey(aOther.mKey) {
+ aOther.mKey = nullptr;
+ }
+
+ ~nsCharPtrHashKey() {
+ if (mKey) {
+ free(const_cast<char*>(mKey));
+ }
+ }
+
+ const char* GetKey() const { return mKey; }
+ bool KeyEquals(KeyTypePointer aKey) const { return !strcmp(mKey, aKey); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return mozilla::HashString(aKey);
+ }
+
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(mKey);
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const char* mKey;
+};
+
+/**
+ * hashkey wrapper for const char16_t*; at construction, this class duplicates
+ * a string pointed to by the pointer so that it doesn't matter whether or not
+ * the string lives longer than the hash table.
+ */
+class nsUnicharPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const char16_t* KeyType;
+ typedef const char16_t* KeyTypePointer;
+
+ explicit nsUnicharPtrHashKey(const char16_t* aKey) : mKey(NS_xstrdup(aKey)) {}
+ nsUnicharPtrHashKey(const nsUnicharPtrHashKey& aToCopy) = delete;
+ nsUnicharPtrHashKey(nsUnicharPtrHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mKey(aOther.mKey) {
+ aOther.mKey = nullptr;
+ }
+
+ ~nsUnicharPtrHashKey() {
+ if (mKey) {
+ free(const_cast<char16_t*>(mKey));
+ }
+ }
+
+ const char16_t* GetKey() const { return mKey; }
+ bool KeyEquals(KeyTypePointer aKey) const { return !NS_strcmp(mKey, aKey); }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return mozilla::HashString(aKey);
+ }
+
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(mKey);
+ }
+
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ const char16_t* mKey;
+};
+
+namespace mozilla {
+
+template <typename T>
+PLDHashNumber Hash(const T& aValue) {
+ return aValue.Hash();
+}
+
+} // namespace mozilla
+
+/**
+ * Hashtable key class to use with objects for which Hash() and operator==()
+ * are defined.
+ */
+template <typename T>
+class nsGenericHashKey : public PLDHashEntryHdr {
+ public:
+ typedef const T& KeyType;
+ typedef const T* KeyTypePointer;
+
+ explicit nsGenericHashKey(KeyTypePointer aKey) : mKey(*aKey) {}
+ nsGenericHashKey(const nsGenericHashKey&) = delete;
+ nsGenericHashKey(nsGenericHashKey&& aOther)
+ : PLDHashEntryHdr(std::move(aOther)), mKey(std::move(aOther.mKey)) {}
+
+ KeyType GetKey() const { return mKey; }
+ bool KeyEquals(KeyTypePointer aKey) const { return *aKey == mKey; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return ::mozilla::Hash(*aKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ T mKey;
+};
+
+#endif // nsTHashKeys_h__
diff --git a/xpcom/ds/nsHashPropertyBag.cpp b/xpcom/ds/nsHashPropertyBag.cpp
new file mode 100644
index 0000000000..68dd612c57
--- /dev/null
+++ b/xpcom/ds/nsHashPropertyBag.cpp
@@ -0,0 +1,366 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsHashPropertyBag.h"
+
+#include <utility>
+
+#include "mozilla/Attributes.h"
+#include "mozilla/SimpleEnumerator.h"
+#include "nsArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsIProperty.h"
+#include "nsIVariant.h"
+#include "nsThreadUtils.h"
+#include "nsVariant.h"
+
+using mozilla::MakeRefPtr;
+using mozilla::SimpleEnumerator;
+using mozilla::Unused;
+
+extern "C" {
+
+// This function uses C linkage because it's exposed to Rust to support the
+// `HashPropertyBag` wrapper in the `storage_variant` crate.
+void NS_NewHashPropertyBag(nsIWritablePropertyBag** aBag) {
+ MakeRefPtr<nsHashPropertyBag>().forget(aBag);
+}
+
+} // extern "C"
+
+/*
+ * nsHashPropertyBagBase implementation.
+ */
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::HasKey(const nsAString& aName, bool* aResult) {
+ *aResult = mPropertyHash.Get(aName, nullptr);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::Get(const nsAString& aName, nsIVariant** aResult) {
+ if (!mPropertyHash.Get(aName, aResult)) {
+ *aResult = nullptr;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetProperty(const nsAString& aName,
+ nsIVariant** aResult) {
+ bool isFound = mPropertyHash.Get(aName, aResult);
+ if (!isFound) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::SetProperty(const nsAString& aName, nsIVariant* aValue) {
+ if (NS_WARN_IF(!aValue)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ mPropertyHash.InsertOrUpdate(aName, aValue);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::DeleteProperty(const nsAString& aName) {
+ return mPropertyHash.Remove(aName) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+//
+// nsSimpleProperty class and impl; used for GetEnumerator
+//
+
+class nsSimpleProperty final : public nsIProperty {
+ ~nsSimpleProperty() = default;
+
+ public:
+ nsSimpleProperty(const nsAString& aName, nsIVariant* aValue)
+ : mName(aName), mValue(aValue) {}
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIPROPERTY
+ protected:
+ nsString mName;
+ nsCOMPtr<nsIVariant> mValue;
+};
+
+NS_IMPL_ISUPPORTS(nsSimpleProperty, nsIProperty)
+
+NS_IMETHODIMP
+nsSimpleProperty::GetName(nsAString& aName) {
+ aName.Assign(mName);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimpleProperty::GetValue(nsIVariant** aValue) {
+ NS_IF_ADDREF(*aValue = mValue);
+ return NS_OK;
+}
+
+// end nsSimpleProperty
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetEnumerator(nsISimpleEnumerator** aResult) {
+ nsCOMPtr<nsIMutableArray> propertyArray = nsArray::Create();
+ if (!propertyArray) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ for (auto iter = mPropertyHash.Iter(); !iter.Done(); iter.Next()) {
+ const nsAString& key = iter.Key();
+ nsIVariant* data = iter.UserData();
+ nsSimpleProperty* sprop = new nsSimpleProperty(key, data);
+ propertyArray->AppendElement(sprop);
+ }
+
+ return NS_NewArrayEnumerator(aResult, propertyArray, NS_GET_IID(nsIProperty));
+}
+
+#define IMPL_GETSETPROPERTY_AS(Name, Type) \
+ NS_IMETHODIMP \
+ nsHashPropertyBagBase::GetPropertyAs##Name(const nsAString& prop, \
+ Type* _retval) { \
+ nsIVariant* v = mPropertyHash.GetWeak(prop); \
+ if (!v) return NS_ERROR_NOT_AVAILABLE; \
+ return v->GetAs##Name(_retval); \
+ } \
+ \
+ NS_IMETHODIMP \
+ nsHashPropertyBagBase::SetPropertyAs##Name(const nsAString& prop, \
+ Type value) { \
+ nsCOMPtr<nsIWritableVariant> var = new nsVariant(); \
+ var->SetAs##Name(value); \
+ return SetProperty(prop, var); \
+ }
+
+IMPL_GETSETPROPERTY_AS(Int32, int32_t)
+IMPL_GETSETPROPERTY_AS(Uint32, uint32_t)
+IMPL_GETSETPROPERTY_AS(Int64, int64_t)
+IMPL_GETSETPROPERTY_AS(Uint64, uint64_t)
+IMPL_GETSETPROPERTY_AS(Double, double)
+IMPL_GETSETPROPERTY_AS(Bool, bool)
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetPropertyAsAString(const nsAString& aProp,
+ nsAString& aResult) {
+ nsIVariant* v = mPropertyHash.GetWeak(aProp);
+ if (!v) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ return v->GetAsAString(aResult);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetPropertyAsACString(const nsAString& aProp,
+ nsACString& aResult) {
+ nsIVariant* v = mPropertyHash.GetWeak(aProp);
+ if (!v) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ return v->GetAsACString(aResult);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetPropertyAsAUTF8String(const nsAString& aProp,
+ nsACString& aResult) {
+ nsIVariant* v = mPropertyHash.GetWeak(aProp);
+ if (!v) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ return v->GetAsAUTF8String(aResult);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::GetPropertyAsInterface(const nsAString& aProp,
+ const nsIID& aIID,
+ void** aResult) {
+ nsIVariant* v = mPropertyHash.GetWeak(aProp);
+ if (!v) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ nsCOMPtr<nsISupports> val;
+ nsresult rv = v->GetAsISupports(getter_AddRefs(val));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ if (!val) {
+ // We have a value, but it's null
+ *aResult = nullptr;
+ return NS_OK;
+ }
+ return val->QueryInterface(aIID, aResult);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::SetPropertyAsAString(const nsAString& aProp,
+ const nsAString& aValue) {
+ nsCOMPtr<nsIWritableVariant> var = new nsVariant();
+ var->SetAsAString(aValue);
+ return SetProperty(aProp, var);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::SetPropertyAsACString(const nsAString& aProp,
+ const nsACString& aValue) {
+ nsCOMPtr<nsIWritableVariant> var = new nsVariant();
+ var->SetAsACString(aValue);
+ return SetProperty(aProp, var);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::SetPropertyAsAUTF8String(const nsAString& aProp,
+ const nsACString& aValue) {
+ nsCOMPtr<nsIWritableVariant> var = new nsVariant();
+ var->SetAsAUTF8String(aValue);
+ return SetProperty(aProp, var);
+}
+
+NS_IMETHODIMP
+nsHashPropertyBagBase::SetPropertyAsInterface(const nsAString& aProp,
+ nsISupports* aValue) {
+ nsCOMPtr<nsIWritableVariant> var = new nsVariant();
+ var->SetAsISupports(aValue);
+ return SetProperty(aProp, var);
+}
+
+void nsHashPropertyBagBase::CopyFrom(const nsHashPropertyBagBase* aOther) {
+ for (const auto& entry : aOther->mPropertyHash) {
+ SetProperty(entry.GetKey(), entry.GetWeak());
+ }
+}
+
+void nsHashPropertyBagBase::CopyFrom(nsIPropertyBag* aOther) {
+ CopyFrom(this, aOther);
+}
+
+/* static */ void nsHashPropertyBagBase::CopyFrom(nsIWritablePropertyBag* aTo,
+ nsIPropertyBag* aFrom) {
+ if (aTo && aFrom) {
+ nsCOMPtr<nsISimpleEnumerator> enumerator;
+ if (NS_SUCCEEDED(aFrom->GetEnumerator(getter_AddRefs(enumerator)))) {
+ for (auto& property : SimpleEnumerator<nsIProperty>(enumerator)) {
+ nsString name;
+ nsCOMPtr<nsIVariant> value;
+ Unused << NS_WARN_IF(NS_FAILED(property->GetName(name)));
+ Unused << NS_WARN_IF(
+ NS_FAILED(property->GetValue(getter_AddRefs(value))));
+ Unused << NS_WARN_IF(
+ NS_FAILED(aTo->SetProperty(std::move(name), value)));
+ }
+ } else {
+ NS_WARNING("Unable to copy nsIPropertyBag");
+ }
+ }
+}
+
+nsresult nsGetProperty::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult rv;
+
+ if (mPropBag) {
+ rv = mPropBag->GetPropertyAsInterface(mPropName, aIID, aInstancePtr);
+ } else {
+ rv = NS_ERROR_NULL_POINTER;
+ *aInstancePtr = 0;
+ }
+
+ if (mErrorPtr) {
+ *mErrorPtr = rv;
+ }
+ return rv;
+}
+
+/*
+ * nsHashPropertyBag implementation.
+ */
+
+NS_IMPL_ADDREF(nsHashPropertyBag)
+NS_IMPL_RELEASE(nsHashPropertyBag)
+
+NS_INTERFACE_MAP_BEGIN(nsHashPropertyBag)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIPropertyBag, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY(nsIPropertyBag2)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag2)
+NS_INTERFACE_MAP_END
+
+/*
+ * We need to ensure that the hashtable is destroyed on the main thread, as
+ * the nsIVariant values are main-thread only objects.
+ */
+class ProxyHashtableDestructor final : public mozilla::Runnable {
+ public:
+ using HashtableType = nsInterfaceHashtable<nsStringHashKey, nsIVariant>;
+ explicit ProxyHashtableDestructor(HashtableType&& aTable)
+ : mozilla::Runnable("ProxyHashtableDestructor"),
+ mPropertyHash(std::move(aTable)) {}
+
+ NS_IMETHODIMP
+ Run() override {
+ MOZ_ASSERT(NS_IsMainThread());
+ HashtableType table(std::move(mPropertyHash));
+ return NS_OK;
+ }
+
+ private:
+ HashtableType mPropertyHash;
+};
+
+nsHashPropertyBag::~nsHashPropertyBag() {
+ if (!NS_IsMainThread()) {
+ RefPtr<ProxyHashtableDestructor> runnable =
+ new ProxyHashtableDestructor(std::move(mPropertyHash));
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
+ }
+}
+
+/*
+ * nsHashPropertyBagOMT implementation
+ */
+NS_IMPL_ADDREF(nsHashPropertyBagOMT)
+NS_IMPL_RELEASE(nsHashPropertyBagOMT)
+
+NS_INTERFACE_MAP_BEGIN(nsHashPropertyBagOMT)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIPropertyBag, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY(nsIPropertyBag2)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag2)
+NS_INTERFACE_MAP_END
+
+nsHashPropertyBagOMT::nsHashPropertyBagOMT() {
+ // nsHashPropertyBagOMT is supposed to be used off-main thread. If you need a
+ // single threaded property bag on the main thread, you should consider using
+ // nsHashPropertyBagCC instead, to prevent leaks.
+ MOZ_ASSERT(!NS_IsMainThread());
+}
+
+/*
+ * nsHashPropertyBagCC implementation.
+ */
+
+NS_IMPL_CYCLE_COLLECTION(nsHashPropertyBagCC, mPropertyHash)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsHashPropertyBagCC)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsHashPropertyBagCC)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsHashPropertyBagCC)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIPropertyBag, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWritablePropertyBag)
+ NS_INTERFACE_MAP_ENTRY(nsIPropertyBag2)
+ NS_INTERFACE_MAP_ENTRY(nsIWritablePropertyBag2)
+NS_INTERFACE_MAP_END
diff --git a/xpcom/ds/nsHashPropertyBag.h b/xpcom/ds/nsHashPropertyBag.h
new file mode 100644
index 0000000000..7a2e6b0ac8
--- /dev/null
+++ b/xpcom/ds/nsHashPropertyBag.h
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsHashPropertyBag_h___
+#define nsHashPropertyBag_h___
+
+#include "nsIVariant.h"
+#include "nsIWritablePropertyBag.h"
+#include "nsIWritablePropertyBag2.h"
+
+#include "nsCycleCollectionParticipant.h"
+#include "nsInterfaceHashtable.h"
+
+class nsHashPropertyBagBase : public nsIWritablePropertyBag,
+ public nsIWritablePropertyBag2 {
+ public:
+ nsHashPropertyBagBase() = default;
+
+ void CopyFrom(const nsHashPropertyBagBase* aOther);
+ void CopyFrom(nsIPropertyBag* aOther);
+ static void CopyFrom(nsIWritablePropertyBag* aTo, nsIPropertyBag* aFrom);
+
+ NS_DECL_NSIPROPERTYBAG
+ NS_DECL_NSIPROPERTYBAG2
+
+ NS_DECL_NSIWRITABLEPROPERTYBAG
+ NS_DECL_NSIWRITABLEPROPERTYBAG2
+
+ protected:
+ // a hash table of string -> nsIVariant
+ nsInterfaceHashtable<nsStringHashKey, nsIVariant> mPropertyHash;
+};
+
+class nsHashPropertyBag : public nsHashPropertyBagBase {
+ public:
+ nsHashPropertyBag() = default;
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+ protected:
+ virtual ~nsHashPropertyBag();
+};
+
+/*
+ * Off Main Thread variant of nsHashPropertyBag. Instances of this class
+ * should not be created on a main thread, nor should it contain main thread
+ * only objects, such as XPCVariants. The purpose of this class is to provide a
+ * way to use the property bag off main thread.
+ * Note: this class needs to be created and destroyed on the same thread and
+ * should be used single threaded.
+ */
+class nsHashPropertyBagOMT final : public nsHashPropertyBagBase {
+ public:
+ nsHashPropertyBagOMT();
+ NS_DECL_ISUPPORTS
+
+ protected:
+ // Doesn't need to dispatch to main thread because it cannot contain
+ // XPCVariants
+ virtual ~nsHashPropertyBagOMT() = default;
+};
+
+/* A cycle collected nsHashPropertyBag for main-thread-only use. */
+class nsHashPropertyBagCC final : public nsHashPropertyBagBase {
+ public:
+ nsHashPropertyBagCC() = default;
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsHashPropertyBagCC,
+ nsIWritablePropertyBag)
+ protected:
+ virtual ~nsHashPropertyBagCC() = default;
+};
+
+inline nsISupports* ToSupports(nsHashPropertyBagBase* aPropertyBag) {
+ return static_cast<nsIWritablePropertyBag*>(aPropertyBag);
+}
+
+#endif /* nsHashPropertyBag_h___ */
diff --git a/xpcom/ds/nsHashtablesFwd.h b/xpcom/ds/nsHashtablesFwd.h
new file mode 100644
index 0000000000..080f79887d
--- /dev/null
+++ b/xpcom/ds/nsHashtablesFwd.h
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef XPCOM_DS_NSHASHTABLESFWD_H_
+#define XPCOM_DS_NSHASHTABLESFWD_H_
+
+#include "mozilla/Attributes.h"
+
+struct PLDHashEntryHdr;
+
+template <class T>
+class MOZ_IS_REFPTR nsCOMPtr;
+
+template <class T>
+class MOZ_IS_REFPTR RefPtr;
+
+template <class EntryType>
+class MOZ_NEEDS_NO_VTABLE_TYPE nsTHashtable;
+
+template <class DataType, class UserDataType>
+class nsDefaultConverter;
+
+template <class KeyClass, class DataType, class UserDataType,
+ class Converter = nsDefaultConverter<DataType, UserDataType>>
+class nsBaseHashtable;
+
+template <class KeyClass, class T>
+class nsClassHashtable;
+
+template <class KeyClass, class PtrType>
+class nsRefCountedHashtable;
+
+/**
+ * templated hashtable class maps keys to interface pointers.
+ * See nsBaseHashtable for complete declaration.
+ * @deprecated This is going to be removed. Use nsTHashMap instead.
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ * @param Interface the interface-type being wrapped
+ * @see nsClassHashtable, nsTHashMap
+ */
+template <class KeyClass, class Interface>
+using nsInterfaceHashtable =
+ nsRefCountedHashtable<KeyClass, nsCOMPtr<Interface>>;
+
+/**
+ * templated hashtable class maps keys to reference pointers.
+ * See nsBaseHashtable for complete declaration.
+ * @deprecated This is going to be removed. Use nsTHashMap instead.
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ * @param PtrType the reference-type being wrapped
+ * @see nsClassHashtable, nsTHashMap
+ */
+template <class KeyClass, class ClassType>
+using nsRefPtrHashtable = nsRefCountedHashtable<KeyClass, RefPtr<ClassType>>;
+
+namespace mozilla::detail {
+template <class KeyType, class = void>
+struct nsKeyClass;
+} // namespace mozilla::detail
+
+/**
+ * A universal hash map that maps some KeyType to some DataType. It can be used
+ * for any DataType, including RefPtr<T>, nsCOMPtr<T> and UniquePtr<T>.
+ *
+ * For the default hash keys types, the appropriate hash key class is determined
+ * automatically, so you can just specify `nsTHashMap<uint32_t,
+ * RefPtr<Foo>>`, for example.
+ *
+ * If you require custom hash behaviour (e.g. case insensitive string handling),
+ * you can still specify a hash key class derived from PLDHashEntryHdr
+ * explicitly.
+ *
+ * If you need to use a custom UserDataType, use nsBaseHashtable (or
+ * nsTHashtable) directly. However, you should double-check if that's really
+ * necessary.
+ */
+template <class KeyType, class DataType>
+using nsTHashMap =
+ nsBaseHashtable<typename mozilla::detail::nsKeyClass<KeyType>::type,
+ DataType, DataType>;
+
+template <class KeyClass>
+class nsTBaseHashSet;
+
+template <class KeyType>
+using nsTHashSet =
+ nsTBaseHashSet<typename mozilla::detail::nsKeyClass<KeyType>::type>;
+
+#endif // XPCOM_DS_NSHASHTABLESFWD_H_
diff --git a/xpcom/ds/nsIArray.idl b/xpcom/ds/nsIArray.idl
new file mode 100644
index 0000000000..7e514649cb
--- /dev/null
+++ b/xpcom/ds/nsIArray.idl
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsISimpleEnumerator;
+
+/**
+ * nsIArray
+ *
+ * An indexed collection of elements. Provides basic functionality for
+ * retrieving elements at a specific position, searching for
+ * elements. Indexes are zero-based, such that the last element in the
+ * array is stored at the index length-1.
+ *
+ * For an array which can be modified, see nsIMutableArray below.
+ *
+ * Neither interface makes any attempt to protect the individual
+ * elements from modification. The convention is that the elements of
+ * the array should not be modified. Documentation within a specific
+ * interface should describe variations from this convention.
+ *
+ * It is also convention that if an interface provides access to an
+ * nsIArray, that the array should not be QueryInterfaced to an
+ * nsIMutableArray for modification. If the interface in question had
+ * intended the array to be modified, it would have returned an
+ * nsIMutableArray!
+ *
+ * null is a valid entry in the array, and as such any nsISupports
+ * parameters may be null, except where noted.
+ */
+[scriptable, builtinclass, uuid(114744d9-c369-456e-b55a-52fe52880d2d)]
+interface nsIArray : nsISupports
+{
+ /**
+ * length
+ *
+ * number of elements in the array.
+ */
+ readonly attribute unsigned long length;
+
+ /**
+ * queryElementAt()
+ *
+ * Retrieve a specific element of the array, and QueryInterface it
+ * to the specified interface. null is a valid result for
+ * this method, but exceptions are thrown in other circumstances
+ *
+ * @param index position of element
+ * @param uuid the IID of the requested interface
+ * @param result the object, QI'd to the requested interface
+ *
+ * @throws NS_ERROR_NO_INTERFACE when an entry exists at the
+ * specified index, but the requested interface is not
+ * available.
+ * @throws NS_ERROR_ILLEGAL_VALUE when index > length-1
+ *
+ */
+ void queryElementAt(in unsigned long index,
+ in nsIIDRef uuid,
+ [iid_is(uuid), retval] out nsQIResult result);
+
+ /**
+ * indexOf()
+ *
+ * Get the position of a specific element. Note that since null is
+ * a valid input, exceptions are used to indicate that an element
+ * is not found.
+ *
+ * @param startIndex The initial element to search in the array
+ * To start at the beginning, use 0 as the
+ * startIndex
+ * @param element The element you are looking for
+ * @returns a number >= startIndex which is the position of the
+ * element in the array.
+ * @throws NS_ERROR_FAILURE if the element was not in the array.
+ */
+ unsigned long indexOf(in unsigned long startIndex,
+ in nsISupports element);
+
+ /**
+ * enumerate the array
+ *
+ * @returns a new enumerator positioned at the start of the array
+ * @throws NS_ERROR_FAILURE if the array is empty (to make it easy
+ * to detect errors), or NS_ERROR_OUT_OF_MEMORY if out of memory.
+ */
+ [binaryname(ScriptedEnumerate), optional_argc]
+ nsISimpleEnumerator enumerate([optional] in nsIIDRef aElemIID);
+
+ [noscript]
+ nsISimpleEnumerator enumerateImpl(in nsIDRef aElemIID);
+
+ %{C++
+ nsresult
+ Enumerate(nsISimpleEnumerator** aRetVal, const nsID& aElemIID = NS_GET_IID(nsISupports))
+ {
+ return EnumerateImpl(aElemIID, aRetVal);
+ }
+ %}
+};
diff --git a/xpcom/ds/nsIArrayExtensions.idl b/xpcom/ds/nsIArrayExtensions.idl
new file mode 100644
index 0000000000..872a5c018d
--- /dev/null
+++ b/xpcom/ds/nsIArrayExtensions.idl
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIArray.idl"
+
+/**
+ * Helper interface for allowing scripts to treat nsIArray instances as if
+ * they were nsISupportsArray instances while iterating.
+ *
+ * nsISupportsArray is convenient to iterate over in JavaScript:
+ *
+ * for (let i = 0; i < array.Count(); ++i) {
+ * let elem = array.GetElementAt(i);
+ * ...
+ * }
+ *
+ * but doing the same with nsIArray is somewhat less convenient, since
+ * queryElementAt is not nearly so nice to use from JavaScript. So we provide
+ * this extension interface so interfaces that currently return
+ * nsISupportsArray can start returning nsIArrayExtensions and all JavaScript
+ * should Just Work. Eventually we'll roll this interface into nsIArray
+ * itself, possibly getting rid of the Count() method, as it duplicates
+ * nsIArray functionality.
+ */
+[scriptable, builtinclass, uuid(261d442e-050c-453d-8aaa-b3f23bcc528b)]
+interface nsIArrayExtensions : nsIArray
+{
+ /**
+ * Count()
+ *
+ * Retrieves the length of the array. This is an alias for the
+ * |nsIArray.length| attribute.
+ */
+ uint32_t Count();
+
+ /**
+ * GetElementAt()
+ *
+ * Retrieve a specific element of the array. null is a valid result for
+ * this method.
+ *
+ * Note: If the index is out of bounds null will be returned.
+ * This differs from the behavior of nsIArray.queryElementAt() which
+ * will throw if an invalid index is specified.
+ *
+ * @param index position of element
+ */
+ nsISupports GetElementAt(in uint32_t index);
+};
diff --git a/xpcom/ds/nsIINIParser.idl b/xpcom/ds/nsIINIParser.idl
new file mode 100644
index 0000000000..434490bf42
--- /dev/null
+++ b/xpcom/ds/nsIINIParser.idl
@@ -0,0 +1,61 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIUTF8StringEnumerator;
+interface nsIFile;
+
+[scriptable, uuid(7eb955f6-3e78-4d39-b72f-c1bf12a94bce)]
+interface nsIINIParser : nsISupports
+{
+ /**
+ * Initializes an INI file from string data
+ */
+ void initFromString(in AUTF8String aData);
+
+ /**
+ * Enumerates the [section]s available in the INI file.
+ */
+ nsIUTF8StringEnumerator getSections();
+
+ /**
+ * Enumerates the keys available within a section.
+ */
+ nsIUTF8StringEnumerator getKeys(in AUTF8String aSection);
+
+ /**
+ * Get the value of a string for a particular section and key.
+ */
+ AUTF8String getString(in AUTF8String aSection, in AUTF8String aKey);
+};
+
+[scriptable, uuid(b67bb24b-31a3-4a6a-a5d9-0485c9af5a04)]
+interface nsIINIParserWriter : nsISupports
+{
+
+ /**
+ * Set the value of a string for a particular section and key.
+ */
+ void setString(in AUTF8String aSection, in AUTF8String aKey, in AUTF8String aValue);
+
+ /**
+ * Write to the INI file.
+ */
+ void writeFile(in nsIFile aINIFile);
+
+ /**
+ * Return the formatted INI file contents
+ */
+ AUTF8String writeToString();
+};
+
+[scriptable, uuid(ccae7ea5-1218-4b51-aecb-c2d8ecd46af9)]
+interface nsIINIParserFactory : nsISupports
+{
+ /**
+ * Create an iniparser instance from a local file.
+ */
+ nsIINIParser createINIParser([optional] in nsIFile aINIFile);
+};
diff --git a/xpcom/ds/nsIMutableArray.idl b/xpcom/ds/nsIMutableArray.idl
new file mode 100644
index 0000000000..3f06ecbeb1
--- /dev/null
+++ b/xpcom/ds/nsIMutableArray.idl
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIArrayExtensions.idl"
+
+/**
+ * nsIMutableArray
+ * A separate set of methods that will act on the array. Consumers of
+ * nsIArray should not QueryInterface to nsIMutableArray unless they
+ * own the array.
+ *
+ * As above, it is legal to add null elements to the array. Note also
+ * that null elements can be created as a side effect of
+ * insertElementAt(). Conversely, if insertElementAt() is never used,
+ * and null elements are never explicitly added to the array, then it
+ * is guaranteed that queryElementAt() will never return a null value.
+ *
+ * Any of these methods may throw NS_ERROR_OUT_OF_MEMORY when the
+ * array must grow to complete the call, but the allocation fails.
+ */
+[scriptable, builtinclass, uuid(af059da0-c85b-40ec-af07-ae4bfdc192cc)]
+interface nsIMutableArray : nsIArrayExtensions
+{
+ /**
+ * appendElement()
+ *
+ * Append an element at the end of the array.
+ *
+ * @param element The element to append.
+ */
+ void appendElement(in nsISupports element);
+
+ /**
+ * removeElementAt()
+ *
+ * Remove an element at a specific position, moving all elements
+ * stored at a higher position down one.
+ * To remove a specific element, use indexOf() to find the index
+ * first, then call removeElementAt().
+ *
+ * @param index the position of the item
+ *
+ */
+ void removeElementAt(in unsigned long index);
+
+ /**
+ * insertElementAt()
+ *
+ * Insert an element at the given position, moving the element
+ * currently located in that position, and all elements in higher
+ * position, up by one.
+ *
+ * @param element The element to insert
+ * @param index The position in the array:
+ * If the position is lower than the current length
+ * of the array, the elements at that position and
+ * onwards are bumped one position up.
+ * If the position is equal to the current length
+ * of the array, the new element is appended.
+ * An index lower than 0 or higher than the current
+ * length of the array is invalid and will be ignored.
+ */
+ void insertElementAt(in nsISupports element, in unsigned long index);
+
+ /**
+ * replaceElementAt()
+ *
+ * Replace the element at the given position.
+ *
+ * @param element The new element to insert
+ * @param index The position in the array
+ * If the position is lower than the current length
+ * of the array, an existing element will be replaced.
+ * If the position is equal to the current length
+ * of the array, the new element is appended.
+ * If the position is higher than the current length
+ * of the array, empty elements are appended followed
+ * by the new element at the specified position.
+ * An index lower than 0 is invalid and will be ignored.
+ */
+ void replaceElementAt(in nsISupports element, in unsigned long index);
+
+
+ /**
+ * clear()
+ *
+ * clear the entire array, releasing all stored objects
+ */
+ void clear();
+};
diff --git a/xpcom/ds/nsINIParserImpl.cpp b/xpcom/ds/nsINIParserImpl.cpp
new file mode 100644
index 0000000000..6ed52947d8
--- /dev/null
+++ b/xpcom/ds/nsINIParserImpl.cpp
@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsINIParserImpl.h"
+
+#include "nsINIParser.h"
+#include "nsStringEnumerator.h"
+#include "nsTArray.h"
+#include "mozilla/Attributes.h"
+
+class nsINIParserImpl final : public nsIINIParser, public nsIINIParserWriter {
+ ~nsINIParserImpl() = default;
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIINIPARSER
+ NS_DECL_NSIINIPARSERWRITER
+
+ nsresult Init(nsIFile* aINIFile) { return mParser.Init(aINIFile); }
+
+ private:
+ nsINIParser mParser;
+ bool ContainsNull(const nsACString& aStr);
+};
+
+NS_IMPL_ISUPPORTS(nsINIParserFactory, nsIINIParserFactory)
+
+NS_IMETHODIMP
+nsINIParserFactory::CreateINIParser(nsIFile* aINIFile, nsIINIParser** aResult) {
+ *aResult = nullptr;
+
+ RefPtr<nsINIParserImpl> p(new nsINIParserImpl());
+
+ if (aINIFile) {
+ nsresult rv = p->Init(aINIFile);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+
+ p.forget(aResult);
+ return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsINIParserImpl, nsIINIParser, nsIINIParserWriter)
+
+bool nsINIParserImpl::ContainsNull(const nsACString& aStr) {
+ return aStr.CountChar('\0') > 0;
+}
+
+static bool SectionCB(const char* aSection, void* aClosure) {
+ nsTArray<nsCString>* strings = static_cast<nsTArray<nsCString>*>(aClosure);
+ strings->AppendElement()->Assign(aSection);
+ return true;
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::GetSections(nsIUTF8StringEnumerator** aResult) {
+ nsTArray<nsCString>* strings = new nsTArray<nsCString>;
+
+ nsresult rv = mParser.GetSections(SectionCB, strings);
+ if (NS_SUCCEEDED(rv)) {
+ rv = NS_NewAdoptingUTF8StringEnumerator(aResult, strings);
+ }
+
+ if (NS_FAILED(rv)) {
+ delete strings;
+ }
+
+ return rv;
+}
+
+static bool KeyCB(const char* aKey, const char* aValue, void* aClosure) {
+ nsTArray<nsCString>* strings = static_cast<nsTArray<nsCString>*>(aClosure);
+ strings->AppendElement()->Assign(aKey);
+ return true;
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::GetKeys(const nsACString& aSection,
+ nsIUTF8StringEnumerator** aResult) {
+ if (ContainsNull(aSection)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsTArray<nsCString>* strings = new nsTArray<nsCString>;
+
+ nsresult rv =
+ mParser.GetStrings(PromiseFlatCString(aSection).get(), KeyCB, strings);
+ if (NS_SUCCEEDED(rv)) {
+ rv = NS_NewAdoptingUTF8StringEnumerator(aResult, strings);
+ }
+
+ if (NS_FAILED(rv)) {
+ delete strings;
+ }
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::GetString(const nsACString& aSection, const nsACString& aKey,
+ nsACString& aResult) {
+ if (ContainsNull(aSection) || ContainsNull(aKey)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ return mParser.GetString(PromiseFlatCString(aSection).get(),
+ PromiseFlatCString(aKey).get(), aResult);
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::InitFromString(const nsACString& aData) {
+ return mParser.InitFromString(nsCString(aData));
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::SetString(const nsACString& aSection, const nsACString& aKey,
+ const nsACString& aValue) {
+ if (ContainsNull(aSection) || ContainsNull(aKey) || ContainsNull(aValue)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ return mParser.SetString(PromiseFlatCString(aSection).get(),
+ PromiseFlatCString(aKey).get(),
+ PromiseFlatCString(aValue).get());
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::WriteFile(nsIFile* aINIFile) {
+ return mParser.WriteToFile(aINIFile);
+}
+
+NS_IMETHODIMP
+nsINIParserImpl::WriteToString(nsACString& aOutput) {
+ aOutput.Truncate();
+ mParser.WriteToString(aOutput);
+
+ return NS_OK;
+}
diff --git a/xpcom/ds/nsINIParserImpl.h b/xpcom/ds/nsINIParserImpl.h
new file mode 100644
index 0000000000..1a60fd1071
--- /dev/null
+++ b/xpcom/ds/nsINIParserImpl.h
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsINIParserImpl_h__
+#define nsINIParserImpl_h__
+
+#include "nsIINIParser.h"
+#include "mozilla/Attributes.h"
+
+#define NS_INIPARSERFACTORY_CONTRACTID "@mozilla.org/xpcom/ini-parser-factory;1"
+
+class nsINIParserFactory final : public nsIINIParserFactory {
+ ~nsINIParserFactory() = default;
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIINIPARSERFACTORY
+};
+
+#endif // nsINIParserImpl_h__
diff --git a/xpcom/ds/nsIObserver.idl b/xpcom/ds/nsIObserver.idl
new file mode 100644
index 0000000000..773424d0a7
--- /dev/null
+++ b/xpcom/ds/nsIObserver.idl
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+/**
+ * This interface is implemented by an object that wants
+ * to observe an event corresponding to a topic.
+ */
+
+[scriptable, function, uuid(DB242E01-E4D9-11d2-9DDE-000064657374)]
+interface nsIObserver : nsISupports {
+
+ /**
+ * Observe will be called when there is a notification for the
+ * topic |aTopic|. This assumes that the object implementing
+ * this interface has been registered with an observer service
+ * such as the nsIObserverService.
+ *
+ * If you expect multiple topics/subjects, the impl is
+ * responsible for filtering.
+ *
+ * You should not modify, add, remove, or enumerate
+ * notifications in the implemention of observe.
+ *
+ * @param aSubject : Notification specific interface pointer.
+ * @param aTopic : The notification topic or subject.
+ * @param aData : Notification specific wide string.
+ * subject event.
+ */
+ void observe( in nsISupports aSubject,
+ in string aTopic,
+ in wstring aData );
+
+};
diff --git a/xpcom/ds/nsIObserverService.idl b/xpcom/ds/nsIObserverService.idl
new file mode 100644
index 0000000000..5ca51d5d44
--- /dev/null
+++ b/xpcom/ds/nsIObserverService.idl
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIObserver;
+interface nsISimpleEnumerator;
+
+/**
+ * nsIObserverService
+ *
+ * Service allows a client listener (nsIObserver) to register and unregister for
+ * notifications of specific string referenced topic. Service also provides a
+ * way to notify registered listeners and a way to enumerate registered client
+ * listeners.
+ */
+
+[scriptable, builtinclass, uuid(D07F5192-E3D1-11d2-8ACD-00105A1B8860)]
+interface nsIObserverService : nsISupports
+{
+
+ /**
+ * AddObserver
+ *
+ * Registers a given listener for a notifications regarding the specified
+ * topic.
+ *
+ * @param anObserve : The interface pointer which will receive notifications.
+ * @param aTopic : The notification topic or subject.
+ * @param ownsWeak : If set to false, the nsIObserverService will hold a
+ * strong reference to |anObserver|. If set to true and
+ * |anObserver| supports the nsIWeakReference interface,
+ * a weak reference will be held. Otherwise an error will be
+ * returned.
+ */
+ void addObserver( in nsIObserver anObserver, in string aTopic,
+ [optional] in boolean ownsWeak);
+
+ /**
+ * removeObserver
+ *
+ * Unregisters a given listener from notifications regarding the specified
+ * topic.
+ *
+ * @param anObserver : The interface pointer which will stop recieving
+ * notifications.
+ * @param aTopic : The notification topic or subject.
+ */
+ void removeObserver( in nsIObserver anObserver, in string aTopic );
+
+ /**
+ * notifyObservers
+ *
+ * Notifies all registered listeners of the given topic.
+ * Must not be used with shutdown topics (will assert
+ * on the parent process).
+ *
+ * @param aSubject : Notification specific interface pointer.
+ * @param aTopic : The notification topic or subject.
+ * @param someData : Notification specific wide string.
+ */
+ void notifyObservers( in nsISupports aSubject,
+ in string aTopic,
+ [optional] in wstring someData );
+
+ /**
+ * hasObservers
+ *
+ * Checks to see if there are registered listeners for the given topic.
+ *
+ * Implemented in "nsObserverService.cpp".
+ *
+ * @param aTopic : The notification topic or subject.
+ * @param aFound : An out parameter; True if there are registered observers,
+ * False otherwise.
+ */
+ [noscript, notxpcom, nostdcall] boolean hasObservers(in string aTopic);
+
+ %{C++
+ /**
+ * notifyWhenScriptSafe
+ *
+ * Notifies all registered listeners of the given topic once it is safe to
+ * run script.
+ *
+ * Implemented in "nsObserverService.cpp".
+ *
+ * @param aSubject : Notification specific interface pointer.
+ * @param aTopic : The notification topic or subject.
+ * @param someData : Notification specific wide string.
+ */
+ nsresult NotifyWhenScriptSafe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData = nullptr);
+ %}
+
+ /**
+ * enumerateObservers
+ *
+ * Returns an enumeration of all registered listeners.
+ *
+ * @param aTopic : The notification topic or subject.
+ */
+ nsISimpleEnumerator enumerateObservers( in string aTopic );
+
+
+};
diff --git a/xpcom/ds/nsIPersistentProperties.h b/xpcom/ds/nsIPersistentProperties.h
new file mode 100644
index 0000000000..eef30c2ff2
--- /dev/null
+++ b/xpcom/ds/nsIPersistentProperties.h
@@ -0,0 +1,13 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __gen_nsIPersistentProperties_h__
+#define __gen_nsIPersistentProperties_h__
+
+// "soft" switch over to an IDL generated header file
+#include "nsIPersistentProperties2.h"
+
+#endif /* __gen_nsIPersistentProperties_h__ */
diff --git a/xpcom/ds/nsIPersistentProperties2.idl b/xpcom/ds/nsIPersistentProperties2.idl
new file mode 100644
index 0000000000..7b07ba33ab
--- /dev/null
+++ b/xpcom/ds/nsIPersistentProperties2.idl
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIProperties.idl"
+
+interface nsIInputStream;
+interface nsIOutputStream;
+interface nsISimpleEnumerator;
+
+%{C++
+#include "mozilla/MemoryReporting.h"
+%}
+
+native MallocSizeOf(mozilla::MallocSizeOf);
+
+[scriptable, uuid(283EE646-1AEF-11D4-98B3-00C04fA0CE9A)]
+interface nsIPropertyElement : nsISupports {
+ attribute AUTF8String key;
+ attribute AString value;
+};
+
+[scriptable, builtinclass, uuid(706867af-0400-4faa-beb1-0dae87308784)]
+interface nsIPersistentProperties : nsIProperties
+{
+ /**
+ * load a set of name/value pairs from the input stream
+ * names and values should be in UTF8
+ */
+ void load(in nsIInputStream input);
+
+ /**
+ * output the values to the stream - results will be in UTF8
+ */
+ void save(in nsIOutputStream output, in AUTF8String header);
+
+ /**
+ * get an enumeration of nsIPropertyElement objects,
+ * which are read-only (i.e. setting properties on the element will
+ * not make changes back into the source nsIPersistentProperties
+ */
+ nsISimpleEnumerator enumerate();
+
+ /**
+ * shortcut to nsIProperty's get() which retrieves a string value
+ * directly (and thus faster)
+ */
+ AString getStringProperty(in AUTF8String key);
+
+ /**
+ * shortcut to nsIProperty's set() which sets a string value
+ * directly (and thus faster). If the given property already exists,
+ * then the old value will be returned
+ */
+ AString setStringProperty(in AUTF8String key, in AString value);
+
+ [notxpcom, nostdcall] size_t sizeOfIncludingThis(in MallocSizeOf aMallocSizeOf);
+};
diff --git a/xpcom/ds/nsIProperties.idl b/xpcom/ds/nsIProperties.idl
new file mode 100644
index 0000000000..50d833e231
--- /dev/null
+++ b/xpcom/ds/nsIProperties.idl
@@ -0,0 +1,46 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+/*
+ * Simple mapping service interface.
+ */
+
+[scriptable, uuid(78650582-4e93-4b60-8e85-26ebd3eb14ca)]
+interface nsIProperties : nsISupports
+{
+ /**
+ * Gets a property with a given name.
+ *
+ * @throws NS_ERROR_FAILURE if a property with that name doesn't exist.
+ * @throws NS_ERROR_NO_INTERFACE if the found property fails to QI to the
+ * given iid.
+ */
+ void get(in string prop, in nsIIDRef iid,
+ [iid_is(iid),retval] out nsQIResult result);
+
+ /**
+ * Sets a property with a given name to a given value.
+ */
+ void set(in string prop, in nsISupports value);
+
+ /**
+ * Returns true if the property with the given name exists.
+ */
+ boolean has(in string prop);
+
+ /**
+ * Undefines a property.
+ * @throws NS_ERROR_FAILURE if a property with that name doesn't
+ * already exist.
+ */
+ void undefine(in string prop);
+
+ /**
+ * Returns an array of the keys.
+ */
+ Array<ACString> getKeys();
+};
diff --git a/xpcom/ds/nsIProperty.idl b/xpcom/ds/nsIProperty.idl
new file mode 100644
index 0000000000..9e6e1e487e
--- /dev/null
+++ b/xpcom/ds/nsIProperty.idl
@@ -0,0 +1,25 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/* nsIVariant based Property support. */
+
+#include "nsISupports.idl"
+
+interface nsIVariant;
+
+[scriptable, uuid(6dcf9030-a49f-11d5-910d-0010a4e73d9a)]
+interface nsIProperty : nsISupports
+{
+ /**
+ * Get the name of the property.
+ */
+ readonly attribute AString name;
+
+ /**
+ * Get the value of the property.
+ */
+ readonly attribute nsIVariant value;
+};
diff --git a/xpcom/ds/nsIPropertyBag.idl b/xpcom/ds/nsIPropertyBag.idl
new file mode 100644
index 0000000000..57bd263451
--- /dev/null
+++ b/xpcom/ds/nsIPropertyBag.idl
@@ -0,0 +1,28 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/* nsIVariant based Property Bag support. */
+
+#include "nsISupports.idl"
+
+interface nsIVariant;
+interface nsISimpleEnumerator;
+
+[scriptable, uuid(bfcd37b0-a49f-11d5-910d-0010a4e73d9a)]
+interface nsIPropertyBag : nsISupports
+{
+ /**
+ * Get a nsISimpleEnumerator whose elements are nsIProperty objects.
+ */
+ readonly attribute nsISimpleEnumerator enumerator;
+
+ /**
+ * Get a property value for the given name.
+ * @throws NS_ERROR_FAILURE if a property with that name doesn't
+ * exist.
+ */
+ nsIVariant getProperty(in AString name);
+};
diff --git a/xpcom/ds/nsIPropertyBag2.idl b/xpcom/ds/nsIPropertyBag2.idl
new file mode 100644
index 0000000000..3232dce0ce
--- /dev/null
+++ b/xpcom/ds/nsIPropertyBag2.idl
@@ -0,0 +1,80 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* nsIVariant based Property Bag support. */
+
+#include "nsIPropertyBag.idl"
+
+[scriptable, uuid(625cfd1e-da1e-4417-9ee9-dbc8e0b3fd79)]
+interface nsIPropertyBag2 : nsIPropertyBag
+{
+ // Accessing a property as a different type may attempt conversion to the
+ // requested value
+
+ int32_t getPropertyAsInt32 (in AString prop);
+ uint32_t getPropertyAsUint32 (in AString prop);
+ int64_t getPropertyAsInt64 (in AString prop);
+ uint64_t getPropertyAsUint64 (in AString prop);
+ double getPropertyAsDouble (in AString prop);
+ AString getPropertyAsAString (in AString prop);
+ ACString getPropertyAsACString (in AString prop);
+ AUTF8String getPropertyAsAUTF8String (in AString prop);
+ boolean getPropertyAsBool (in AString prop);
+
+ /**
+ * This method returns null if the value exists, but is null.
+ *
+ * Note: C++ callers should not use this method. They should use the
+ * typesafe `do_GetProperty` wrapper instead.
+ */
+ void getPropertyAsInterface (in AString prop,
+ in nsIIDRef iid,
+ [iid_is(iid), retval] out nsQIResult result);
+
+ /**
+ * This method returns null if the value does not exist,
+ * or exists but is null.
+ */
+ nsIVariant get (in AString prop);
+
+ /**
+ * Check for the existence of a key.
+ */
+ boolean hasKey (in AString prop);
+};
+
+
+%{C++
+#include "nsCOMPtr.h"
+#include "nsAString.h"
+
+class MOZ_STACK_CLASS nsGetProperty final : public nsCOMPtr_helper {
+ public:
+ nsGetProperty(nsIPropertyBag2* aPropBag, const nsAString& aPropName, nsresult* aError)
+ : mPropBag(aPropBag), mPropName(aPropName), mErrorPtr(aError) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ nsIPropertyBag2* MOZ_NON_OWNING_REF mPropBag;
+ const nsAString& mPropName;
+ nsresult* mErrorPtr;
+};
+
+/**
+ * A typesafe wrapper around nsIPropertyBag2::GetPropertyAsInterface. Similar
+ * to the `do_QueryInterface` family of functions, when assigned to a
+ * `nsCOMPtr` of a given type, attempts to query the given property to that
+ * type.
+ *
+ * If `aError` is passed, the return value of `GetPropertyAsInterface` is
+ * stored in it.
+ */
+inline const nsGetProperty do_GetProperty(nsIPropertyBag2* aPropBag,
+ const nsAString& aPropName,
+ nsresult* aError = 0) {
+ return nsGetProperty(aPropBag, aPropName, aError);
+}
+
+%}
diff --git a/xpcom/ds/nsISerializable.idl b/xpcom/ds/nsISerializable.idl
new file mode 100644
index 0000000000..1920fa1b16
--- /dev/null
+++ b/xpcom/ds/nsISerializable.idl
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIObjectInputStream;
+interface nsIObjectOutputStream;
+
+[scriptable, uuid(91cca981-c26d-44a8-bebe-d9ed4891503a)]
+interface nsISerializable : nsISupports
+{
+ /**
+ * Initialize the object implementing nsISerializable, which must have
+ * been freshly constructed via CreateInstance. All data members that
+ * can't be set to default values must have been serialized by write,
+ * and should be read from aInputStream in the same order by this method.
+ */
+ [must_use] void read(in nsIObjectInputStream aInputStream);
+
+ /**
+ * Serialize the object implementing nsISerializable to aOutputStream, by
+ * writing each data member that must be recovered later to reconstitute
+ * a working replica of this object, in a canonical member and byte order,
+ * to aOutputStream.
+ *
+ * NB: a class that implements nsISerializable *must* also implement
+ * nsIClassInfo, in particular nsIClassInfo::GetClassID.
+ */
+ void write(in nsIObjectOutputStream aOutputStream);
+};
diff --git a/xpcom/ds/nsISimpleEnumerator.idl b/xpcom/ds/nsISimpleEnumerator.idl
new file mode 100644
index 0000000000..1a2b47705d
--- /dev/null
+++ b/xpcom/ds/nsISimpleEnumerator.idl
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+/**
+ * Used to enumerate over elements defined by its implementor.
+ * Although hasMoreElements() can be called independently of getNext(),
+ * getNext() must be pre-ceeded by a call to hasMoreElements(). There is
+ * no way to "reset" an enumerator, once you obtain one.
+ *
+ * @version 1.0
+ */
+
+/**
+ * A wrapper for an nsISimpleEnumerator instance which implements the
+ * JavaScript iteration protocol.
+ */
+[scriptable, uuid(4432e8ae-d4d3-42a6-a4d1-829f1c29512b)]
+interface nsIJSEnumerator : nsISupports {
+ [symbol]
+ nsIJSEnumerator iterator();
+
+ [implicit_jscontext]
+ jsval next();
+};
+
+[scriptable, uuid(796f340d-0a2a-490b-9c60-640765e99782)]
+interface nsISimpleEnumeratorBase : nsISupports {
+ /**
+ * Returns a JavaScript iterator for all remaining entries in the enumerator.
+ * Each entry is typically queried to the appropriate interface for the
+ * enumerator.
+ */
+ [symbol]
+ nsIJSEnumerator iterator();
+
+ /**
+ * Returns JavaScript iterator for all remaining entries in the enumerator.
+ * Each entry is queried only to the supplied interface. If any element
+ * fails to query to that interface, the error is propagated to the caller.
+ */
+ nsIJSEnumerator entries(in nsIIDRef aIface);
+};
+
+[scriptable, uuid(D1899240-F9D2-11D2-BDD6-000064657374)]
+interface nsISimpleEnumerator : nsISimpleEnumeratorBase {
+ /**
+ * Called to determine whether or not the enumerator has
+ * any elements that can be returned via getNext(). This method
+ * is generally used to determine whether or not to initiate or
+ * continue iteration over the enumerator, though it can be
+ * called without subsequent getNext() calls. Does not affect
+ * internal state of enumerator.
+ *
+ * @see getNext()
+ * @return true if there are remaining elements in the enumerator.
+ * false if there are no more elements in the enumerator.
+ */
+ boolean hasMoreElements();
+
+ /**
+ * Called to retrieve the next element in the enumerator. The "next"
+ * element is the first element upon the first call. Must be
+ * pre-ceeded by a call to hasMoreElements() which returns PR_TRUE.
+ * This method is generally called within a loop to iterate over
+ * the elements in the enumerator.
+ *
+ * @see hasMoreElements()
+ * @throws NS_ERROR_FAILURE if there are no more elements
+ * to enumerate.
+ * @return the next element in the enumeration.
+ */
+ nsISupports getNext();
+};
diff --git a/xpcom/ds/nsIStringEnumerator.idl b/xpcom/ds/nsIStringEnumerator.idl
new file mode 100644
index 0000000000..96ab966bff
--- /dev/null
+++ b/xpcom/ds/nsIStringEnumerator.idl
@@ -0,0 +1,37 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIJSEnumerator;
+
+/**
+ * Used to enumerate over an ordered list of strings.
+ */
+
+/**
+ * Base class for C++-implemented string iterators. JS implementors need not
+ * be queryable to it.
+ */
+[scriptable, uuid(f5213d15-a4d1-4fb7-8a48-d69ccb7fb0eb)]
+interface nsIStringEnumeratorBase : nsISupports
+{
+ [symbol, binaryname(StringIterator)]
+ nsIJSEnumerator iterator();
+};
+
+[scriptable, uuid(50d3ef6c-9380-4f06-9fb2-95488f7d141c)]
+interface nsIStringEnumerator : nsIStringEnumeratorBase
+{
+ boolean hasMore();
+ AString getNext();
+};
+
+[scriptable, uuid(9bdf1010-3695-4907-95ed-83d0410ec307)]
+interface nsIUTF8StringEnumerator : nsIStringEnumeratorBase
+{
+ boolean hasMore();
+ AUTF8String getNext();
+};
diff --git a/xpcom/ds/nsISupportsIterators.idl b/xpcom/ds/nsISupportsIterators.idl
new file mode 100644
index 0000000000..8d47375d57
--- /dev/null
+++ b/xpcom/ds/nsISupportsIterators.idl
@@ -0,0 +1,292 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/* nsISupportsIterators.idl --- IDL defining general purpose iterators */
+
+
+#include "nsISupports.idl"
+
+
+ /*
+ ...
+ */
+
+
+ /**
+ * ...
+ */
+[scriptable, uuid(7330650e-1dd2-11b2-a0c2-9ff86ee97bed)]
+interface nsIOutputIterator : nsISupports
+ {
+ /**
+ * Put |anElementToPut| into the underlying container or sequence at the position currently pointed to by this iterator.
+ * The iterator and the underlying container or sequence cooperate to |Release()|
+ * the replaced element, if any and if necessary, and to |AddRef()| the new element.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anElementToPut the element to place into the underlying container or sequence
+ */
+ void putElement( in nsISupports anElementToPut );
+
+ /**
+ * Advance this iterator to the next position in the underlying container or sequence.
+ */
+ void stepForward();
+ };
+
+ /**
+ * ...
+ */
+[scriptable, uuid(85585e12-1dd2-11b2-a930-f6929058269a)]
+interface nsIInputIterator : nsISupports
+ {
+ /**
+ * Retrieve (and |AddRef()|) the element this iterator currently points to.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @result a new reference to the element this iterator currently points to (if any)
+ */
+ nsISupports getElement();
+
+ /**
+ * Advance this iterator to the next position in the underlying container or sequence.
+ */
+ void stepForward();
+
+ /**
+ * Test if |anotherIterator| points to the same position in the underlying container or sequence.
+ *
+ * The result is undefined if |anotherIterator| was not created by or for the same underlying container or sequence.
+ *
+ * @param anotherIterator another iterator to compare against, created by or for the same underlying container or sequence
+ * @result true if |anotherIterator| points to the same position in the underlying container or sequence
+ */
+ boolean isEqualTo( in nsISupports anotherIterator );
+
+ /**
+ * Create a new iterator pointing to the same position in the underlying container or sequence to which this iterator currently points.
+ * The returned iterator is suitable for use in a subsequent call to |isEqualTo()| against this iterator.
+ *
+ * @result a new iterator pointing at the same position in the same underlying container or sequence as this iterator
+ */
+ nsISupports clone();
+ };
+
+ /**
+ * ...
+ */
+[scriptable, uuid(8da01646-1dd2-11b2-98a7-c7009045be7e)]
+interface nsIForwardIterator : nsISupports
+ {
+ /**
+ * Retrieve (and |AddRef()|) the element this iterator currently points to.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @result a new reference to the element this iterator currently points to (if any)
+ */
+ nsISupports getElement();
+
+ /**
+ * Put |anElementToPut| into the underlying container or sequence at the position currently pointed to by this iterator.
+ * The iterator and the underlying container or sequence cooperate to |Release()|
+ * the replaced element, if any and if necessary, and to |AddRef()| the new element.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anElementToPut the element to place into the underlying container or sequence
+ */
+ void putElement( in nsISupports anElementToPut );
+
+ /**
+ * Advance this iterator to the next position in the underlying container or sequence.
+ */
+ void stepForward();
+
+ /**
+ * Test if |anotherIterator| points to the same position in the underlying container or sequence.
+ *
+ * The result is undefined if |anotherIterator| was not created by or for the same underlying container or sequence.
+ *
+ * @param anotherIterator another iterator to compare against, created by or for the same underlying container or sequence
+ * @result true if |anotherIterator| points to the same position in the underlying container or sequence
+ */
+ boolean isEqualTo( in nsISupports anotherIterator );
+
+ /**
+ * Create a new iterator pointing to the same position in the underlying container or sequence to which this iterator currently points.
+ * The returned iterator is suitable for use in a subsequent call to |isEqualTo()| against this iterator.
+ *
+ * @result a new iterator pointing at the same position in the same underlying container or sequence as this iterator
+ */
+ nsISupports clone();
+ };
+
+ /**
+ * ...
+ */
+[scriptable, uuid(948defaa-1dd1-11b2-89f6-8ce81f5ebda9)]
+interface nsIBidirectionalIterator : nsISupports
+ {
+ /**
+ * Retrieve (and |AddRef()|) the element this iterator currently points to.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @result a new reference to the element this iterator currently points to (if any)
+ */
+ nsISupports getElement();
+
+ /**
+ * Put |anElementToPut| into the underlying container or sequence at the position currently pointed to by this iterator.
+ * The iterator and the underlying container or sequence cooperate to |Release()|
+ * the replaced element, if any and if necessary, and to |AddRef()| the new element.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anElementToPut the element to place into the underlying container or sequence
+ */
+ void putElement( in nsISupports anElementToPut );
+
+ /**
+ * Advance this iterator to the next position in the underlying container or sequence.
+ */
+ void stepForward();
+
+ /**
+ * Move this iterator to the previous position in the underlying container or sequence.
+ */
+ void stepBackward();
+
+ /**
+ * Test if |anotherIterator| points to the same position in the underlying container or sequence.
+ *
+ * The result is undefined if |anotherIterator| was not created by or for the same underlying container or sequence.
+ *
+ * @param anotherIterator another iterator to compare against, created by or for the same underlying container or sequence
+ * @result true if |anotherIterator| points to the same position in the underlying container or sequence
+ */
+ boolean isEqualTo( in nsISupports anotherIterator );
+
+ /**
+ * Create a new iterator pointing to the same position in the underlying container or sequence to which this iterator currently points.
+ * The returned iterator is suitable for use in a subsequent call to |isEqualTo()| against this iterator.
+ *
+ * @result a new iterator pointing at the same position in the same underlying container or sequence as this iterator
+ */
+ nsISupports clone();
+ };
+
+ /**
+ * ...
+ */
+[scriptable, uuid(9bd6fdb0-1dd1-11b2-9101-d15375968230)]
+interface nsIRandomAccessIterator : nsISupports
+ {
+ /**
+ * Retrieve (and |AddRef()|) the element this iterator currently points to.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @result a new reference to the element this iterator currently points to (if any)
+ */
+ nsISupports getElement();
+
+ /**
+ * Retrieve (and |AddRef()|) an element at some offset from where this iterator currently points.
+ * The offset may be negative. |getElementAt(0)| is equivalent to |getElement()|.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anOffset a |0|-based offset from the position to which this iterator currently points
+ * @result a new reference to the indicated element (if any)
+ */
+ nsISupports getElementAt( in int32_t anOffset );
+
+ /**
+ * Put |anElementToPut| into the underlying container or sequence at the position currently pointed to by this iterator.
+ * The iterator and the underlying container or sequence cooperate to |Release()|
+ * the replaced element, if any and if necessary, and to |AddRef()| the new element.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anElementToPut the element to place into the underlying container or sequence
+ */
+ void putElement( in nsISupports anElementToPut );
+
+ /**
+ * Put |anElementToPut| into the underlying container or sequence at the position |anOffset| away from that currently pointed to by this iterator.
+ * The iterator and the underlying container or sequence cooperate to |Release()|
+ * the replaced element, if any and if necessary, and to |AddRef()| the new element.
+ * |putElementAt(0, obj)| is equivalent to |putElement(obj)|.
+ *
+ * The result is undefined if this iterator currently points outside the
+ * useful range of the underlying container or sequence.
+ *
+ * @param anOffset a |0|-based offset from the position to which this iterator currently points
+ * @param anElementToPut the element to place into the underlying container or sequence
+ */
+ void putElementAt( in int32_t anOffset, in nsISupports anElementToPut );
+
+ /**
+ * Advance this iterator to the next position in the underlying container or sequence.
+ */
+ void stepForward();
+
+ /**
+ * Move this iterator by |anOffset| positions in the underlying container or sequence.
+ * |anOffset| may be negative. |stepForwardBy(1)| is equivalent to |stepForward()|.
+ * |stepForwardBy(0)| is a no-op.
+ *
+ * @param anOffset a |0|-based offset from the position to which this iterator currently points
+ */
+ void stepForwardBy( in int32_t anOffset );
+
+ /**
+ * Move this iterator to the previous position in the underlying container or sequence.
+ */
+ void stepBackward();
+
+ /**
+ * Move this iterator backwards by |anOffset| positions in the underlying container or sequence.
+ * |anOffset| may be negative. |stepBackwardBy(1)| is equivalent to |stepBackward()|.
+ * |stepBackwardBy(n)| is equivalent to |stepForwardBy(-n)|. |stepBackwardBy(0)| is a no-op.
+ *
+ * @param anOffset a |0|-based offset from the position to which this iterator currently points
+ */
+ void stepBackwardBy( in int32_t anOffset );
+
+ /**
+ * Test if |anotherIterator| points to the same position in the underlying container or sequence.
+ *
+ * The result is undefined if |anotherIterator| was not created by or for the same underlying container or sequence.
+ *
+ * @param anotherIterator another iterator to compare against, created by or for the same underlying container or sequence
+ * @result true if |anotherIterator| points to the same position in the underlying container or sequence
+ */
+ boolean isEqualTo( in nsISupports anotherIterator );
+
+ /**
+ * Create a new iterator pointing to the same position in the underlying container or sequence to which this iterator currently points.
+ * The returned iterator is suitable for use in a subsequent call to |isEqualTo()| against this iterator.
+ *
+ * @result a new iterator pointing at the same position in the same underlying container or sequence as this iterator
+ */
+ nsISupports clone();
+ };
+
+%{C++
+%}
diff --git a/xpcom/ds/nsISupportsPrimitives.idl b/xpcom/ds/nsISupportsPrimitives.idl
new file mode 100644
index 0000000000..d661ce3b21
--- /dev/null
+++ b/xpcom/ds/nsISupportsPrimitives.idl
@@ -0,0 +1,222 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+/* nsISupports wrappers for single primitive pieces of data. */
+
+#include "nsISupports.idl"
+
+/**
+ * Primitive base interface.
+ *
+ * These first three are pointer types and do data copying
+ * using the nsIMemory. Be careful!
+ */
+
+[scriptable, builtinclass, uuid(d0d4b136-1dd1-11b2-9371-f0727ef827c0)]
+interface nsISupportsPrimitive : nsISupports
+{
+ const unsigned short TYPE_ID = 1;
+ const unsigned short TYPE_CSTRING = 2;
+ const unsigned short TYPE_STRING = 3;
+ const unsigned short TYPE_PRBOOL = 4;
+ const unsigned short TYPE_PRUINT8 = 5;
+ const unsigned short TYPE_PRUINT16 = 6;
+ const unsigned short TYPE_PRUINT32 = 7;
+ const unsigned short TYPE_PRUINT64 = 8;
+ const unsigned short TYPE_PRTIME = 9;
+ const unsigned short TYPE_CHAR = 10;
+ const unsigned short TYPE_PRINT16 = 11;
+ const unsigned short TYPE_PRINT32 = 12;
+ const unsigned short TYPE_PRINT64 = 13;
+ const unsigned short TYPE_FLOAT = 14;
+ const unsigned short TYPE_DOUBLE = 15;
+ // 16 was for TYPE_VOID
+ const unsigned short TYPE_INTERFACE_POINTER = 17;
+
+ readonly attribute unsigned short type;
+};
+
+/**
+ * Scriptable storage for nsID structures
+ */
+
+[scriptable, builtinclass, uuid(d18290a0-4a1c-11d3-9890-006008962422)]
+interface nsISupportsID : nsISupportsPrimitive
+{
+ attribute nsIDPtr data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for ASCII strings
+ */
+
+[scriptable, builtinclass, uuid(d65ff270-4a1c-11d3-9890-006008962422)]
+interface nsISupportsCString : nsISupportsPrimitive
+{
+ attribute ACString data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for Unicode strings
+ */
+
+[scriptable, builtinclass, uuid(d79dc970-4a1c-11d3-9890-006008962422)]
+interface nsISupportsString : nsISupportsPrimitive
+{
+ attribute AString data;
+ wstring toString();
+};
+
+/**
+ * The rest are truly primitive and are passed by value
+ */
+
+/**
+ * Scriptable storage for booleans
+ */
+
+[scriptable, builtinclass, uuid(ddc3b490-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRBool : nsISupportsPrimitive
+{
+ attribute boolean data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for 8-bit integers
+ */
+
+[scriptable, builtinclass, uuid(dec2e4e0-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRUint8 : nsISupportsPrimitive
+{
+ attribute uint8_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for unsigned 16-bit integers
+ */
+
+[scriptable, builtinclass, uuid(dfacb090-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRUint16 : nsISupportsPrimitive
+{
+ attribute uint16_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for unsigned 32-bit integers
+ */
+
+[scriptable, builtinclass, uuid(e01dc470-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRUint32 : nsISupportsPrimitive
+{
+ attribute uint32_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for 64-bit integers
+ */
+
+[scriptable, builtinclass, uuid(e13567c0-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRUint64 : nsISupportsPrimitive
+{
+ attribute uint64_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for NSPR date/time values
+ */
+
+[scriptable, builtinclass, uuid(e2563630-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRTime : nsISupportsPrimitive
+{
+ attribute PRTime data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for single character values
+ * (often used to store an ASCII character)
+ */
+
+[scriptable, builtinclass, uuid(e2b05e40-4a1c-11d3-9890-006008962422)]
+interface nsISupportsChar : nsISupportsPrimitive
+{
+ attribute char data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for 16-bit integers
+ */
+
+[scriptable, builtinclass, uuid(e30d94b0-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRInt16 : nsISupportsPrimitive
+{
+ attribute int16_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for 32-bit integers
+ */
+
+[scriptable, builtinclass, uuid(e36c5250-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRInt32 : nsISupportsPrimitive
+{
+ attribute int32_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for 64-bit integers
+ */
+
+[scriptable, builtinclass, uuid(e3cb0ff0-4a1c-11d3-9890-006008962422)]
+interface nsISupportsPRInt64 : nsISupportsPrimitive
+{
+ attribute int64_t data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for floating point numbers
+ */
+
+[scriptable, builtinclass, uuid(abeaa390-4ac0-11d3-baea-00805f8a5dd7)]
+interface nsISupportsFloat : nsISupportsPrimitive
+{
+ attribute float data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for doubles
+ */
+
+[scriptable, builtinclass, uuid(b32523a0-4ac0-11d3-baea-00805f8a5dd7)]
+interface nsISupportsDouble : nsISupportsPrimitive
+{
+ attribute double data;
+ string toString();
+};
+
+/**
+ * Scriptable storage for other XPCOM objects
+ */
+
+[scriptable, builtinclass, uuid(995ea724-1dd1-11b2-9211-c21bdd3e7ed0)]
+interface nsISupportsInterfacePointer : nsISupportsPrimitive
+{
+ attribute nsISupports data;
+ attribute nsIDPtr dataIID;
+
+ string toString();
+};
diff --git a/xpcom/ds/nsIVariant.idl b/xpcom/ds/nsIVariant.idl
new file mode 100644
index 0000000000..0d7f7e70c3
--- /dev/null
+++ b/xpcom/ds/nsIVariant.idl
@@ -0,0 +1,162 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/* The long avoided variant support for xpcom. */
+
+#include "nsISupports.idl"
+
+%{C++
+#include "xptinfo.h"
+
+// This enum class used to be a const-only XPIDL interface, containing literal
+// integer descriptions of the different fields. Instead, it now directly
+// references the nsXPTTypeTag variants VTYPE_ are intended to match.
+struct nsIDataType
+{
+ enum {
+ // These MUST match the declarations in xptinfo.h.
+ // Otherwise the world is likely to explode.
+ VTYPE_INT8 = TD_INT8 ,
+ VTYPE_INT16 = TD_INT16 ,
+ VTYPE_INT32 = TD_INT32 ,
+ VTYPE_INT64 = TD_INT64 ,
+ VTYPE_UINT8 = TD_UINT8 ,
+ VTYPE_UINT16 = TD_UINT16 ,
+ VTYPE_UINT32 = TD_UINT32 ,
+ VTYPE_UINT64 = TD_UINT64 ,
+ VTYPE_FLOAT = TD_FLOAT ,
+ VTYPE_DOUBLE = TD_DOUBLE ,
+ VTYPE_BOOL = TD_BOOL ,
+ VTYPE_CHAR = TD_CHAR ,
+ VTYPE_WCHAR = TD_WCHAR ,
+ VTYPE_VOID = TD_VOID ,
+ VTYPE_ID = TD_NSIDPTR ,
+ VTYPE_CHAR_STR = TD_PSTRING ,
+ VTYPE_WCHAR_STR = TD_PWSTRING ,
+ VTYPE_INTERFACE = TD_INTERFACE_TYPE ,
+ VTYPE_INTERFACE_IS = TD_INTERFACE_IS_TYPE,
+ VTYPE_ARRAY = TD_LEGACY_ARRAY ,
+ VTYPE_STRING_SIZE_IS = TD_PSTRING_SIZE_IS ,
+ VTYPE_WSTRING_SIZE_IS = TD_PWSTRING_SIZE_IS ,
+ VTYPE_UTF8STRING = TD_UTF8STRING ,
+ VTYPE_CSTRING = TD_CSTRING ,
+ VTYPE_ASTRING = TD_ASTRING ,
+
+ // Non-xpt variant types
+ VTYPE_EMPTY_ARRAY = 254 ,
+ VTYPE_EMPTY = 255
+ };
+};
+%}
+
+
+/**
+ * XPConnect has magic to transparently convert between nsIVariant and JS types.
+ * We mark the interface [scriptable] so that JS can use methods
+ * that refer to this interface. But we mark all the methods and attributes
+ * [noscript] since any nsIVariant object will be automatically converted to a
+ * JS type anyway.
+ */
+
+[scriptable, builtinclass, uuid(81e4c2de-acac-4ad6-901a-b5fb1b851a0d)]
+interface nsIVariant : nsISupports
+{
+ [notxpcom,nostdcall] readonly attribute uint16_t dataType;
+
+ [noscript] uint8_t getAsInt8();
+ [noscript] int16_t getAsInt16();
+ [noscript] int32_t getAsInt32();
+ [noscript] int64_t getAsInt64();
+ [noscript] uint8_t getAsUint8();
+ [noscript] uint16_t getAsUint16();
+ [noscript] uint32_t getAsUint32();
+ [noscript] uint64_t getAsUint64();
+ [noscript] float getAsFloat();
+ [noscript] double getAsDouble();
+ [noscript] boolean getAsBool();
+ [noscript] char getAsChar();
+ [noscript] wchar getAsWChar();
+ [notxpcom] nsresult getAsID(out nsID retval);
+ [noscript] AString getAsAString();
+ [noscript] ACString getAsACString();
+ [noscript] AUTF8String getAsAUTF8String();
+ [noscript] string getAsString();
+ [noscript] wstring getAsWString();
+ [noscript] nsISupports getAsISupports();
+ [noscript] jsval getAsJSVal();
+
+ [noscript] void getAsInterface(out nsIIDPtr iid,
+ [iid_is(iid), retval] out nsQIResult iface);
+
+ [notxpcom] nsresult getAsArray(out uint16_t type, out nsIID iid,
+ out uint32_t count, out voidPtr ptr);
+
+ [noscript] void getAsStringWithSize(out uint32_t size,
+ [size_is(size), retval] out string str);
+
+ [noscript] void getAsWStringWithSize(out uint32_t size,
+ [size_is(size), retval] out wstring str);
+};
+
+/**
+ * An object that implements nsIVariant may or may NOT also implement this
+ * nsIWritableVariant.
+ *
+ * If the 'writable' attribute is false then attempts to call any of the 'set'
+ * methods can be expected to fail. Setting the 'writable' attribute may or
+ * may not succeed.
+ *
+ */
+
+[scriptable, builtinclass, uuid(5586a590-8c82-11d5-90f3-0010a4e73d9a)]
+interface nsIWritableVariant : nsIVariant
+{
+ attribute boolean writable;
+
+ void setAsInt8(in uint8_t aValue);
+ void setAsInt16(in int16_t aValue);
+ void setAsInt32(in int32_t aValue);
+ void setAsInt64(in int64_t aValue);
+ void setAsUint8(in uint8_t aValue);
+ void setAsUint16(in uint16_t aValue);
+ void setAsUint32(in uint32_t aValue);
+ void setAsUint64(in uint64_t aValue);
+ void setAsFloat(in float aValue);
+ void setAsDouble(in double aValue);
+ void setAsBool(in boolean aValue);
+ void setAsChar(in char aValue);
+ void setAsWChar(in wchar aValue);
+ void setAsID(in nsIDRef aValue);
+ void setAsAString(in AString aValue);
+ void setAsACString(in ACString aValue);
+ void setAsAUTF8String(in AUTF8String aValue);
+ void setAsString(in string aValue);
+ void setAsWString(in wstring aValue);
+ void setAsISupports(in nsISupports aValue);
+
+ void setAsInterface(in nsIIDRef iid,
+ [iid_is(iid)] in nsQIResult iface);
+
+ [noscript] void setAsArray(in uint16_t type, in nsIIDPtr iid,
+ in uint32_t count, in voidPtr ptr);
+
+ void setAsStringWithSize(in uint32_t size,
+ [size_is(size)] in string str);
+
+ void setAsWStringWithSize(in uint32_t size,
+ [size_is(size)] in wstring str);
+
+ void setAsVoid();
+ void setAsEmpty();
+ void setAsEmptyArray();
+
+ void setFromVariant(in nsIVariant aValue);
+};
+
+%{C++
+// The contractID for the generic implementation built in to xpcom.
+#define NS_VARIANT_CONTRACTID "@mozilla.org/variant;1"
+%}
diff --git a/xpcom/ds/nsIWindowsRegKey.idl b/xpcom/ds/nsIWindowsRegKey.idl
new file mode 100644
index 0000000000..197ba69c6d
--- /dev/null
+++ b/xpcom/ds/nsIWindowsRegKey.idl
@@ -0,0 +1,336 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+%{C++
+#include <windows.h>
+%}
+
+native HKEY(HKEY);
+
+/**
+ * This interface is designed to provide scriptable access to the Windows
+ * registry system ("With Great Power Comes Great Responsibility"). The
+ * interface represents a single key in the registry.
+ *
+ * This interface is highly Win32 specific.
+ */
+[scriptable, uuid(2555b930-d64f-437e-9be7-0a2cb252c1f4)]
+interface nsIWindowsRegKey : nsISupports
+{
+ /**
+ * Root keys. The values for these keys correspond to the values from
+ * WinReg.h in the MS Platform SDK. The ROOT_KEY_ prefix corresponds to the
+ * HKEY_ prefix in the MS Platform SDK.
+ *
+ * This interface is not restricted to using only these root keys.
+ */
+ const unsigned long ROOT_KEY_CLASSES_ROOT = 0x80000000;
+ const unsigned long ROOT_KEY_CURRENT_USER = 0x80000001;
+ const unsigned long ROOT_KEY_LOCAL_MACHINE = 0x80000002;
+
+ /**
+ * Values for the mode parameter passed to the open and create methods.
+ * The values defined here correspond to the REGSAM values defined in
+ * WinNT.h in the MS Platform SDK, where ACCESS_ is replaced with KEY_.
+ *
+ * This interface is not restricted to using only these access types.
+ */
+ const unsigned long ACCESS_BASIC = 0x00020000;
+ const unsigned long ACCESS_QUERY_VALUE = 0x00000001;
+ const unsigned long ACCESS_SET_VALUE = 0x00000002;
+ const unsigned long ACCESS_CREATE_SUB_KEY = 0x00000004;
+ const unsigned long ACCESS_ENUMERATE_SUB_KEYS = 0x00000008;
+ const unsigned long ACCESS_NOTIFY = 0x00000010;
+ const unsigned long ACCESS_READ = ACCESS_BASIC |
+ ACCESS_QUERY_VALUE |
+ ACCESS_ENUMERATE_SUB_KEYS |
+ ACCESS_NOTIFY;
+ const unsigned long ACCESS_WRITE = ACCESS_BASIC |
+ ACCESS_SET_VALUE |
+ ACCESS_CREATE_SUB_KEY;
+ const unsigned long ACCESS_ALL = ACCESS_READ |
+ ACCESS_WRITE;
+ const unsigned long WOW64_32 = 0x00000200;
+ const unsigned long WOW64_64 = 0x00000100;
+
+
+ /**
+ * Values for the type of a registry value. The numeric values of these
+ * constants are taken directly from WinNT.h in the MS Platform SDK.
+ * The Microsoft documentation should be consulted for the exact meaning of
+ * these value types.
+ *
+ * This interface is somewhat restricted to using only these value types.
+ * There is no method that is directly equivalent to RegQueryValueEx or
+ * RegSetValueEx. In particular, this interface does not support the
+ * REG_MULTI_SZ and REG_EXPAND_SZ value types. It is still possible to
+ * enumerate values that have other types (i.e., getValueType may return a
+ * type not defined below).
+ */
+ const unsigned long TYPE_NONE = 0; // REG_NONE
+ const unsigned long TYPE_STRING = 1; // REG_SZ
+ const unsigned long TYPE_BINARY = 3; // REG_BINARY
+ const unsigned long TYPE_INT = 4; // REG_DWORD
+ const unsigned long TYPE_INT64 = 11; // REG_QWORD
+
+ /**
+ * This attribute exposes the native HKEY and is available to provide C++
+ * consumers with the flexibility of making other Windows registry API calls
+ * that are not exposed via this interface.
+ *
+ * It is possible to initialize this object by setting an HKEY on it. In
+ * that case, it is the responsibility of the consumer setting the HKEY to
+ * ensure that it is a valid HKEY.
+ *
+ * WARNING: Setting the key does not close the old key.
+ */
+ [noscript] attribute HKEY key;
+
+ /**
+ * This method closes the key. If the key is already closed, then this
+ * method does nothing.
+ */
+ void close();
+
+ /**
+ * This method opens an existing key. This method fails if the key
+ * does not exist.
+ *
+ * NOTE: On 32-bit Windows, it is valid to pass any HKEY as the rootKey
+ * parameter of this function. However, for compatibility with 64-bit
+ * Windows, that usage should probably be avoided in favor of openChild.
+ *
+ * @param rootKey
+ * A root key defined above or any valid HKEY on 32-bit Windows.
+ * @param relPath
+ * A relative path from the given root key.
+ * @param mode
+ * Access mode, which is a bit-wise OR of the ACCESS_ values defined
+ * above.
+ */
+ void open(in unsigned long rootKey, in AString relPath, in unsigned long mode);
+
+ /**
+ * This method opens an existing key or creates a new key.
+ *
+ * NOTE: On 32-bit Windows, it is valid to pass any HKEY as the rootKey
+ * parameter of this function. However, for compatibility with 64-bit
+ * Windows, that usage should probably be avoided in favor of createChild.
+ *
+ * @param rootKey
+ * A root key defined above or any valid HKEY on 32-bit Windows.
+ * @param relPath
+ * A relative path from the given root key.
+ * @param mode
+ * Access mode, which is a bit-wise OR of the ACCESS_ values defined
+ * above.
+ */
+ void create(in unsigned long rootKey, in AString relPath, in unsigned long mode);
+
+ /**
+ * This method opens a subkey relative to this key. This method fails if the
+ * key does not exist.
+ *
+ * @return nsIWindowsRegKey for the newly opened subkey.
+ */
+ nsIWindowsRegKey openChild(in AString relPath, in unsigned long mode);
+
+ /**
+ * This method opens or creates a subkey relative to this key.
+ *
+ * @return nsIWindowsRegKey for the newly opened or created subkey.
+ */
+ nsIWindowsRegKey createChild(in AString relPath, in unsigned long mode);
+
+ /**
+ * This attribute returns the number of child keys.
+ */
+ readonly attribute unsigned long childCount;
+
+ /**
+ * This method returns the name of the n'th child key.
+ *
+ * @param index
+ * The index of the requested child key.
+ */
+ AString getChildName(in unsigned long index);
+
+ /**
+ * This method checks to see if the key has a child by the given name.
+ *
+ * @param name
+ * The name of the requested child key.
+ */
+ boolean hasChild(in AString name);
+
+ /**
+ * This attribute returns the number of values under this key.
+ */
+ readonly attribute unsigned long valueCount;
+
+ /**
+ * This method returns the name of the n'th value under this key.
+ *
+ * @param index
+ * The index of the requested value.
+ */
+ AString getValueName(in unsigned long index);
+
+ /**
+ * This method checks to see if the key has a value by the given name.
+ *
+ * @param name
+ * The name of the requested value.
+ */
+ boolean hasValue(in AString name);
+
+ /**
+ * This method removes a child key and all of its values. This method will
+ * fail if the key has any children of its own.
+ *
+ * @param relPath
+ * The relative path from this key to the key to be removed.
+ */
+ void removeChild(in AString relPath);
+
+ /**
+ * This method removes the value with the given name.
+ *
+ * @param name
+ * The name of the value to be removed.
+ */
+ void removeValue(in AString name);
+
+ /**
+ * This method returns the type of the value with the given name. The return
+ * value is one of the "TYPE_" constants defined above.
+ *
+ * @param name
+ * The name of the value to query.
+ */
+ unsigned long getValueType(in AString name);
+
+ /**
+ * This method reads the string contents of the named value as a Unicode
+ * string.
+ *
+ * @param name
+ * The name of the value to query. This parameter can be the empty
+ * string to request the key's default value.
+ */
+ AString readStringValue(in AString name);
+
+ /**
+ * This method reads the integer contents of the named value.
+ *
+ * @param name
+ * The name of the value to query.
+ */
+ unsigned long readIntValue(in AString name);
+
+ /**
+ * This method reads the 64-bit integer contents of the named value.
+ *
+ * @param name
+ * The name of the value to query.
+ */
+ unsigned long long readInt64Value(in AString name);
+
+ /**
+ * This method reads the binary contents of the named value under this key.
+ *
+ * JavaScript callers should take care with the result of this method since
+ * it will be byte-expanded to form a JS string. (The binary data will be
+ * treated as an ISO-Latin-1 character string, which it is not).
+ *
+ * @param name
+ * The name of the value to query.
+ */
+ ACString readBinaryValue(in AString name);
+
+ /**
+ * This method writes the unicode string contents of the named value. The
+ * value will be created if it does not already exist.
+ *
+ * @param name
+ * The name of the value to modify. This parameter can be the empty
+ * string to modify the key's default value.
+ * @param data
+ * The data for the value to modify.
+ */
+ void writeStringValue(in AString name, in AString data);
+
+ /**
+ * This method writes the integer contents of the named value. The value
+ * will be created if it does not already exist.
+ *
+ * @param name
+ * The name of the value to modify.
+ * @param data
+ * The data for the value to modify.
+ */
+ void writeIntValue(in AString name, in unsigned long data);
+
+ /**
+ * This method writes the 64-bit integer contents of the named value. The
+ * value will be created if it does not already exist.
+ *
+ * @param name
+ * The name of the value to modify.
+ * @param data
+ * The data for the value to modify.
+ */
+ void writeInt64Value(in AString name, in unsigned long long data);
+
+ /**
+ * This method writes the binary contents of the named value. The value will
+ * be created if it does not already exist.
+ *
+ * JavaScript callers should take care with the value passed to this method
+ * since it will be truncated from a JS string (unicode) to a ISO-Latin-1
+ * string. (The binary data will be treated as an ISO-Latin-1 character
+ * string, which it is not). So, JavaScript callers should only pass
+ * character values in the range \u0000 to \u00FF, or else data loss will
+ * occur.
+ *
+ * @param name
+ * The name of the value to modify.
+ * @param data
+ * The data for the value to modify.
+ */
+ void writeBinaryValue(in AString name, in ACString data);
+
+ /**
+ * This method starts watching the key to see if any of its values have
+ * changed. The key must have been opened with mode including ACCESS_NOTIFY.
+ * If recurse is true, then this key and any of its descendant keys are
+ * watched. Otherwise, only this key is watched.
+ *
+ * @param recurse
+ * Indicates whether or not to also watch child keys.
+ */
+ void startWatching(in boolean recurse);
+
+ /**
+ * This method stops any watching of the key initiated by a call to
+ * startWatching. This method does nothing if the key is not being watched.
+ */
+ void stopWatching();
+
+ /**
+ * This method returns true if the key is being watched for changes (i.e.,
+ * if startWatching() was called).
+ */
+ boolean isWatching();
+
+ /**
+ * This method returns true if the key has changed and false otherwise.
+ * This method will always return false if startWatching was not called.
+ */
+ boolean hasChanged();
+};
diff --git a/xpcom/ds/nsIWritablePropertyBag.idl b/xpcom/ds/nsIWritablePropertyBag.idl
new file mode 100644
index 0000000000..e916b7ccd6
--- /dev/null
+++ b/xpcom/ds/nsIWritablePropertyBag.idl
@@ -0,0 +1,27 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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/. */
+
+/* nsIVariant based writable Property Bag support. */
+
+#include "nsIPropertyBag.idl"
+
+[scriptable, uuid(96fc4671-eeb4-4823-9421-e50fb70ad353)]
+interface nsIWritablePropertyBag : nsIPropertyBag
+{
+ /**
+ * Set a property with the given name to the given value. If
+ * a property already exists with the given name, it is
+ * overwritten.
+ */
+ void setProperty(in AString name, in nsIVariant value);
+
+ /**
+ * Delete a property with the given name.
+ * @throws NS_ERROR_FAILURE if a property with that name doesn't
+ * exist.
+ */
+ void deleteProperty(in AString name);
+};
diff --git a/xpcom/ds/nsIWritablePropertyBag2.idl b/xpcom/ds/nsIWritablePropertyBag2.idl
new file mode 100644
index 0000000000..50f093905d
--- /dev/null
+++ b/xpcom/ds/nsIWritablePropertyBag2.idl
@@ -0,0 +1,22 @@
+/* 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/. */
+
+/* nsIVariant based Property Bag support. */
+
+#include "nsIPropertyBag2.idl"
+
+[scriptable, uuid(9cfd1587-360e-4957-a58f-4c2b1c5e7ed9)]
+interface nsIWritablePropertyBag2 : nsIPropertyBag2
+{
+ void setPropertyAsInt32 (in AString prop, in int32_t value);
+ void setPropertyAsUint32 (in AString prop, in uint32_t value);
+ void setPropertyAsInt64 (in AString prop, in int64_t value);
+ void setPropertyAsUint64 (in AString prop, in uint64_t value);
+ void setPropertyAsDouble (in AString prop, in double value);
+ void setPropertyAsAString (in AString prop, in AString value);
+ void setPropertyAsACString (in AString prop, in ACString value);
+ void setPropertyAsAUTF8String (in AString prop, in AUTF8String value);
+ void setPropertyAsBool (in AString prop, in boolean value);
+ void setPropertyAsInterface (in AString prop, in nsISupports value);
+};
diff --git a/xpcom/ds/nsInterfaceHashtable.h b/xpcom/ds/nsInterfaceHashtable.h
new file mode 100644
index 0000000000..644864cf8f
--- /dev/null
+++ b/xpcom/ds/nsInterfaceHashtable.h
@@ -0,0 +1,14 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsInterfaceHashtable_h__
+#define nsInterfaceHashtable_h__
+
+#include "nsRefCountedHashtable.h"
+#include "nsHashKeys.h"
+#include "nsCOMPtr.h"
+
+#endif // nsInterfaceHashtable_h__
diff --git a/xpcom/ds/nsMathUtils.h b/xpcom/ds/nsMathUtils.h
new file mode 100644
index 0000000000..527e0c3eb2
--- /dev/null
+++ b/xpcom/ds/nsMathUtils.h
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsMathUtils_h__
+#define nsMathUtils_h__
+
+#include "nscore.h"
+#include <cmath>
+#include <float.h>
+
+#if defined(XP_SOLARIS)
+# include <ieeefp.h>
+#endif
+
+/*
+ * round
+ */
+inline double NS_round(double aNum) {
+ return aNum >= 0.0 ? floor(aNum + 0.5) : ceil(aNum - 0.5);
+}
+inline float NS_roundf(float aNum) {
+ return aNum >= 0.0f ? floorf(aNum + 0.5f) : ceilf(aNum - 0.5f);
+}
+inline int32_t NS_lround(double aNum) {
+ return aNum >= 0.0 ? int32_t(aNum + 0.5) : int32_t(aNum - 0.5);
+}
+
+/* NS_roundup30 rounds towards infinity for positive and */
+/* negative numbers. */
+
+#if defined(XP_WIN) && defined(_M_IX86) && !defined(__GNUC__) && \
+ !defined(__clang__)
+inline int32_t NS_lroundup30(float x) {
+ /* Code derived from Laurent de Soras' paper at */
+ /* http://ldesoras.free.fr/doc/articles/rounding_en.pdf */
+
+ /* Rounding up on Windows is expensive using the float to */
+ /* int conversion and the floor function. A faster */
+ /* approach is to use f87 rounding while assuming the */
+ /* default rounding mode of rounding to the nearest */
+ /* integer. This rounding mode, however, actually rounds */
+ /* to the nearest integer so we add the floating point */
+ /* number to itself and add our rounding factor before */
+ /* doing the conversion to an integer. We then do a right */
+ /* shift of one bit on the integer to divide by two. */
+
+ /* This routine doesn't handle numbers larger in magnitude */
+ /* than 2^30 but this is fine for NSToCoordRound because */
+ /* Coords are limited to 2^30 in magnitude. */
+
+ static const double round_to_nearest = 0.5f;
+ int i;
+
+ __asm {
+ fld x ; load fp argument
+ fadd st, st(0) ; double it
+ fadd round_to_nearest ; add the rounding factor
+ fistp dword ptr i ; convert the result to int
+ }
+ return i >> 1; /* divide by 2 */
+}
+#endif /* XP_WIN && _M_IX86 && !__GNUC__ */
+
+inline int32_t NS_lroundf(float aNum) {
+ return aNum >= 0.0f ? int32_t(aNum + 0.5f) : int32_t(aNum - 0.5f);
+}
+
+/*
+ * hypot. We don't need a super accurate version of this, if a platform
+ * turns up with none of the possibilities below it would be okay to fall
+ * back to sqrt(x*x + y*y).
+ */
+inline double NS_hypot(double aNum1, double aNum2) {
+#ifdef __GNUC__
+ return __builtin_hypot(aNum1, aNum2);
+#elif defined _WIN32
+ return _hypot(aNum1, aNum2);
+#else
+ return hypot(aNum1, aNum2);
+#endif
+}
+
+/**
+ * Check whether a floating point number is finite (not +/-infinity and not a
+ * NaN value).
+ */
+inline bool NS_finite(double aNum) {
+#ifdef WIN32
+ // NOTE: '!!' casts an int to bool without spamming MSVC warning C4800.
+ return !!_finite(aNum);
+#else
+ return std::isfinite(aNum);
+#endif
+}
+
+/**
+ * Returns the result of the modulo of x by y using a floored division.
+ * fmod(x, y) is using a truncated division.
+ * The main difference is that the result of this method will have the sign of
+ * y while the result of fmod(x, y) will have the sign of x.
+ */
+inline double NS_floorModulo(double aNum1, double aNum2) {
+ return (aNum1 - aNum2 * floor(aNum1 / aNum2));
+}
+
+#endif
diff --git a/xpcom/ds/nsObserverList.cpp b/xpcom/ds/nsObserverList.cpp
new file mode 100644
index 0000000000..ba3eaaa2aa
--- /dev/null
+++ b/xpcom/ds/nsObserverList.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsObserverList.h"
+
+#include "mozilla/ResultExtensions.h"
+#include "nsCOMArray.h"
+#include "xpcpublic.h"
+
+nsresult nsObserverList::AddObserver(nsIObserver* anObserver, bool ownsWeak) {
+ NS_ASSERTION(anObserver, "Null input");
+
+ MOZ_TRY(mObservers.AppendWeakElement(anObserver, ownsWeak));
+ return NS_OK;
+}
+
+nsresult nsObserverList::RemoveObserver(nsIObserver* anObserver) {
+ NS_ASSERTION(anObserver, "Null input");
+
+ MOZ_TRY(mObservers.RemoveWeakElement(anObserver));
+ return NS_OK;
+}
+
+void nsObserverList::GetObserverList(nsISimpleEnumerator** anEnumerator) {
+ RefPtr<nsObserverEnumerator> e(new nsObserverEnumerator(this));
+ e.forget(anEnumerator);
+}
+
+nsCOMArray<nsIObserver> nsObserverList::ReverseCloneObserverArray() {
+ nsCOMArray<nsIObserver> array;
+ array.SetCapacity(mObservers.Length());
+
+ // XXX This could also use RemoveElementsBy if we lifted the promise to fill
+ // aArray in reverse order. Although there shouldn't be anyone explicitly
+ // relying on the order, changing this might cause subtle problems, so we
+ // better leave it as it is.
+
+ for (int32_t i = mObservers.Length() - 1; i >= 0; --i) {
+ nsCOMPtr<nsIObserver> observer = mObservers[i].GetValue();
+ if (observer) {
+ array.AppendElement(observer.forget());
+ } else {
+ // the object has gone away, remove the weakref
+ mObservers.RemoveElementAt(i);
+ }
+ }
+
+ return array;
+}
+
+void nsObserverList::AppendStrongObservers(nsCOMArray<nsIObserver>& aArray) {
+ aArray.SetCapacity(aArray.Length() + mObservers.Length());
+
+ for (int32_t i = mObservers.Length() - 1; i >= 0; --i) {
+ if (!mObservers[i].IsWeak()) {
+ nsCOMPtr<nsIObserver> observer = mObservers[i].GetValue();
+ aArray.AppendObject(observer);
+ }
+ }
+}
+
+void nsObserverList::NotifyObservers(nsISupports* aSubject, const char* aTopic,
+ const char16_t* someData) {
+ const nsCOMArray<nsIObserver> observers = ReverseCloneObserverArray();
+
+ for (int32_t i = 0; i < observers.Count(); ++i) {
+ observers[i]->Observe(aSubject, aTopic, someData);
+ }
+}
+
+nsObserverEnumerator::nsObserverEnumerator(nsObserverList* aObserverList)
+ : mIndex(0), mObservers(aObserverList->ReverseCloneObserverArray()) {}
+
+NS_IMETHODIMP
+nsObserverEnumerator::HasMoreElements(bool* aResult) {
+ *aResult = (mIndex < mObservers.Count());
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsObserverEnumerator::GetNext(nsISupports** aResult) {
+ if (mIndex == mObservers.Count()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ NS_ADDREF(*aResult = mObservers[mIndex]);
+ ++mIndex;
+ return NS_OK;
+}
diff --git a/xpcom/ds/nsObserverList.h b/xpcom/ds/nsObserverList.h
new file mode 100644
index 0000000000..9f209e40d6
--- /dev/null
+++ b/xpcom/ds/nsObserverList.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsObserverList_h___
+#define nsObserverList_h___
+
+#include "nsISupports.h"
+#include "nsCOMArray.h"
+#include "nsIObserver.h"
+#include "nsHashKeys.h"
+#include "nsMaybeWeakPtr.h"
+#include "nsSimpleEnumerator.h"
+#include "mozilla/Attributes.h"
+
+class nsObserverList : public nsCharPtrHashKey {
+ friend class nsObserverService;
+
+ public:
+ explicit nsObserverList(const char* aKey) : nsCharPtrHashKey(aKey) {
+ MOZ_COUNT_CTOR(nsObserverList);
+ }
+
+ nsObserverList(nsObserverList&& aOther)
+ : nsCharPtrHashKey(std::move(aOther)),
+ mObservers(std::move(aOther.mObservers)) {
+ MOZ_COUNT_CTOR(nsObserverList);
+ }
+
+ MOZ_COUNTED_DTOR(nsObserverList)
+
+ [[nodiscard]] nsresult AddObserver(nsIObserver* aObserver, bool aOwnsWeak);
+ [[nodiscard]] nsresult RemoveObserver(nsIObserver* aObserver);
+
+ void NotifyObservers(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aSomeData);
+ void GetObserverList(nsISimpleEnumerator** aEnumerator);
+
+ // Clone an array with the observers of this category.
+ // The array is filled in last-added-first order.
+ nsCOMArray<nsIObserver> ReverseCloneObserverArray();
+
+ // Like FillObserverArray(), but only for strongly held observers.
+ void AppendStrongObservers(nsCOMArray<nsIObserver>& aArray);
+
+ private:
+ nsMaybeWeakPtrArray<nsIObserver> mObservers;
+};
+
+class nsObserverEnumerator final : public nsSimpleEnumerator {
+ public:
+ NS_DECL_NSISIMPLEENUMERATOR
+
+ explicit nsObserverEnumerator(nsObserverList* aObserverList);
+
+ const nsID& DefaultInterface() override { return NS_GET_IID(nsIObserver); }
+
+ private:
+ ~nsObserverEnumerator() override = default;
+
+ int32_t mIndex; // Counts up from 0
+ nsCOMArray<nsIObserver> mObservers;
+};
+
+#endif /* nsObserverList_h___ */
diff --git a/xpcom/ds/nsObserverService.cpp b/xpcom/ds/nsObserverService.cpp
new file mode 100644
index 0000000000..5ed81b01a7
--- /dev/null
+++ b/xpcom/ds/nsObserverService.cpp
@@ -0,0 +1,357 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/Logging.h"
+#include "nsComponentManagerUtils.h"
+#include "nsContentUtils.h"
+#include "nsIConsoleService.h"
+#include "nsIObserverService.h"
+#include "nsIObserver.h"
+#include "nsIScriptError.h"
+#include "nsObserverService.h"
+#include "nsObserverList.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "nsEnumeratorUtils.h"
+#include "xpcpublic.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/net/NeckoCommon.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "nsString.h"
+
+// Log module for nsObserverService logging...
+//
+// To enable logging (see prlog.h for full details):
+//
+// set MOZ_LOG=ObserverService:5
+// set MOZ_LOG_FILE=service.log
+//
+// This enables LogLevel::Debug level information and places all output in
+// the file service.log.
+static mozilla::LazyLogModule sObserverServiceLog("ObserverService");
+#define LOG(x) MOZ_LOG(sObserverServiceLog, mozilla::LogLevel::Debug, x)
+
+using namespace mozilla;
+
+NS_IMETHODIMP
+nsObserverService::CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) {
+ struct SuspectObserver {
+ SuspectObserver(const char* aTopic, size_t aReferentCount)
+ : mTopic(aTopic), mReferentCount(aReferentCount) {}
+ const char* mTopic;
+ size_t mReferentCount;
+ };
+
+ size_t totalNumStrong = 0;
+ size_t totalNumWeakAlive = 0;
+ size_t totalNumWeakDead = 0;
+ nsTArray<SuspectObserver> suspectObservers;
+
+ for (auto iter = mObserverTopicTable.Iter(); !iter.Done(); iter.Next()) {
+ nsObserverList* observerList = iter.Get();
+ if (!observerList) {
+ continue;
+ }
+
+ size_t topicNumStrong = 0;
+ size_t topicNumWeakAlive = 0;
+ size_t topicNumWeakDead = 0;
+
+ nsMaybeWeakPtrArray<nsIObserver>& observers = observerList->mObservers;
+ for (uint32_t i = 0; i < observers.Length(); i++) {
+ if (observers[i].IsWeak()) {
+ nsCOMPtr<nsIObserver> ref = observers[i].GetValue();
+ if (ref) {
+ topicNumWeakAlive++;
+ } else {
+ topicNumWeakDead++;
+ }
+ } else {
+ topicNumStrong++;
+ }
+ }
+
+ totalNumStrong += topicNumStrong;
+ totalNumWeakAlive += topicNumWeakAlive;
+ totalNumWeakDead += topicNumWeakDead;
+
+ // Keep track of topics that have a suspiciously large number
+ // of referents (symptom of leaks).
+ size_t topicTotal = topicNumStrong + topicNumWeakAlive + topicNumWeakDead;
+ if (topicTotal > kSuspectReferentCount) {
+ SuspectObserver suspect(observerList->GetKey(), topicTotal);
+ suspectObservers.AppendElement(suspect);
+ }
+ }
+
+ // These aren't privacy-sensitive and so don't need anonymizing.
+ for (uint32_t i = 0; i < suspectObservers.Length(); i++) {
+ SuspectObserver& suspect = suspectObservers[i];
+ nsPrintfCString suspectPath("observer-service-suspect/referent(topic=%s)",
+ suspect.mTopic);
+ aHandleReport->Callback(
+ /* process */ ""_ns, suspectPath, KIND_OTHER, UNITS_COUNT,
+ suspect.mReferentCount,
+ nsLiteralCString("A topic with a suspiciously large number of "
+ "referents. This may be symptomatic of a leak "
+ "if the number of referents is high with "
+ "respect to the number of windows."),
+ aData);
+ }
+
+ MOZ_COLLECT_REPORT(
+ "observer-service/referent/strong", KIND_OTHER, UNITS_COUNT,
+ totalNumStrong,
+ "The number of strong references held by the observer service.");
+
+ MOZ_COLLECT_REPORT(
+ "observer-service/referent/weak/alive", KIND_OTHER, UNITS_COUNT,
+ totalNumWeakAlive,
+ "The number of weak references held by the observer service that are "
+ "still alive.");
+
+ MOZ_COLLECT_REPORT(
+ "observer-service/referent/weak/dead", KIND_OTHER, UNITS_COUNT,
+ totalNumWeakDead,
+ "The number of weak references held by the observer service that are "
+ "dead.");
+
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsObserverService Implementation
+
+NS_IMPL_ISUPPORTS(nsObserverService, nsIObserverService, nsObserverService,
+ nsIMemoryReporter)
+
+nsObserverService::nsObserverService() : mShuttingDown(false) {}
+
+nsObserverService::~nsObserverService(void) { Shutdown(); }
+
+void nsObserverService::RegisterReporter() { RegisterWeakMemoryReporter(this); }
+
+void nsObserverService::Shutdown() {
+ if (mShuttingDown) {
+ return;
+ }
+
+ mShuttingDown = true;
+ UnregisterWeakMemoryReporter(this);
+ mObserverTopicTable.Clear();
+}
+
+nsresult nsObserverService::Create(const nsIID& aIID, void** aInstancePtr) {
+ LOG(("nsObserverService::Create()"));
+
+ RefPtr<nsObserverService> os = new nsObserverService();
+
+ // The memory reporter can not be immediately registered here because
+ // the nsMemoryReporterManager may attempt to get the nsObserverService
+ // during initialization, causing a recursive GetService.
+ NS_DispatchToCurrentThread(
+ NewRunnableMethod("nsObserverService::RegisterReporter", os,
+ &nsObserverService::RegisterReporter));
+
+ return os->QueryInterface(aIID, aInstancePtr);
+}
+
+nsresult nsObserverService::EnsureValidCall() const {
+ if (!NS_IsMainThread()) {
+ MOZ_CRASH("Using observer service off the main thread!");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (mShuttingDown) {
+ NS_ERROR("Using observer service after XPCOM shutdown!");
+ return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
+ }
+
+ return NS_OK;
+}
+
+nsresult nsObserverService::FilterHttpOnTopics(const char* aTopic) {
+ // Specifically allow http-on-opening-request and http-on-stop-request in the
+ // child process; see bug 1269765.
+ if (mozilla::net::IsNeckoChild() && !strncmp(aTopic, "http-on-", 8) &&
+ strcmp(aTopic, "http-on-failed-opening-request") &&
+ strcmp(aTopic, "http-on-opening-request") &&
+ strcmp(aTopic, "http-on-stop-request") &&
+ strcmp(aTopic, "http-on-image-cache-response")) {
+ nsCOMPtr<nsIConsoleService> console(
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+ nsCOMPtr<nsIScriptError> error(
+ do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
+ error->Init(u"http-on-* observers only work in the parent process"_ns,
+ u""_ns, u""_ns, 0, 0, nsIScriptError::warningFlag,
+ "chrome javascript"_ns, false /* from private window */,
+ true /* from chrome context */);
+ console->LogMessage(error);
+
+ return NS_ERROR_NOT_IMPLEMENTED;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsObserverService::AddObserver(nsIObserver* aObserver, const char* aTopic,
+ bool aOwnsWeak) {
+ LOG(("nsObserverService::AddObserver(%p: %s, %s)", (void*)aObserver, aTopic,
+ aOwnsWeak ? "weak" : "strong"));
+
+ MOZ_TRY(EnsureValidCall());
+ if (NS_WARN_IF(!aObserver) || NS_WARN_IF(!aTopic)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ MOZ_TRY(FilterHttpOnTopics(aTopic));
+
+ nsObserverList* observerList = mObserverTopicTable.PutEntry(aTopic);
+ if (!observerList) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return observerList->AddObserver(aObserver, aOwnsWeak);
+}
+
+NS_IMETHODIMP
+nsObserverService::RemoveObserver(nsIObserver* aObserver, const char* aTopic) {
+ LOG(("nsObserverService::RemoveObserver(%p: %s)", (void*)aObserver, aTopic));
+
+ if (mShuttingDown) {
+ // The service is shutting down. Let's ignore this call.
+ return NS_OK;
+ }
+
+ MOZ_TRY(EnsureValidCall());
+ if (NS_WARN_IF(!aObserver) || NS_WARN_IF(!aTopic)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsObserverList* observerList = mObserverTopicTable.GetEntry(aTopic);
+ if (!observerList) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return observerList->RemoveObserver(aObserver);
+}
+
+NS_IMETHODIMP
+nsObserverService::EnumerateObservers(const char* aTopic,
+ nsISimpleEnumerator** anEnumerator) {
+ LOG(("nsObserverService::EnumerateObservers(%s)", aTopic));
+
+ MOZ_TRY(EnsureValidCall());
+ if (NS_WARN_IF(!anEnumerator) || NS_WARN_IF(!aTopic)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsObserverList* observerList = mObserverTopicTable.GetEntry(aTopic);
+ if (!observerList) {
+ return NS_NewEmptyEnumerator(anEnumerator);
+ }
+
+ observerList->GetObserverList(anEnumerator);
+ return NS_OK;
+}
+
+// Enumerate observers of aTopic and call Observe on each.
+NS_IMETHODIMP nsObserverService::NotifyObservers(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aSomeData) {
+ LOG(("nsObserverService::NotifyObservers(%s)", aTopic));
+
+ MOZ_TRY(EnsureValidCall());
+ if (NS_WARN_IF(!aTopic)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ MOZ_ASSERT(AppShutdown::IsNoOrLegalShutdownTopic(aTopic));
+
+ AUTO_PROFILER_MARKER_TEXT("NotifyObservers", OTHER, MarkerStack::Capture(),
+ nsDependentCString(aTopic));
+ AUTO_PROFILER_LABEL_DYNAMIC_CSTR_NONSENSITIVE(
+ "nsObserverService::NotifyObservers", OTHER, aTopic);
+
+ nsObserverList* observerList = mObserverTopicTable.GetEntry(aTopic);
+ if (observerList) {
+ observerList->NotifyObservers(aSubject, aTopic, aSomeData);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsObserverService::UnmarkGrayStrongObservers() {
+ MOZ_TRY(EnsureValidCall());
+
+ nsCOMArray<nsIObserver> strongObservers;
+ for (auto iter = mObserverTopicTable.Iter(); !iter.Done(); iter.Next()) {
+ nsObserverList* aObserverList = iter.Get();
+ if (aObserverList) {
+ aObserverList->AppendStrongObservers(strongObservers);
+ }
+ }
+
+ for (uint32_t i = 0; i < strongObservers.Length(); ++i) {
+ xpc_TryUnmarkWrappedGrayObject(strongObservers[i]);
+ }
+
+ return NS_OK;
+}
+
+bool nsObserverService::HasObservers(const char* aTopic) {
+ return mObserverTopicTable.Contains(aTopic);
+}
+
+namespace {
+
+class NotifyWhenScriptSafeRunnable : public mozilla::Runnable {
+ public:
+ NotifyWhenScriptSafeRunnable(nsIObserverService* aObs, nsISupports* aSubject,
+ const char* aTopic, const char16_t* aData)
+ : mozilla::Runnable("NotifyWhenScriptSafeRunnable"),
+ mObs(aObs),
+ mSubject(aSubject),
+ mTopic(aTopic) {
+ if (aData) {
+ mData.Assign(aData);
+ } else {
+ mData.SetIsVoid(true);
+ }
+ }
+
+ NS_IMETHOD Run() override {
+ const char16_t* data = mData.IsVoid() ? nullptr : mData.get();
+ return mObs->NotifyObservers(mSubject, mTopic.get(), data);
+ }
+
+ private:
+ nsCOMPtr<nsIObserverService> mObs;
+ nsCOMPtr<nsISupports> mSubject;
+ nsCString mTopic;
+ nsString mData;
+};
+
+} // namespace
+
+nsresult nsIObserverService::NotifyWhenScriptSafe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData) {
+ if (nsContentUtils::IsSafeToRunScript()) {
+ return NotifyObservers(aSubject, aTopic, aData);
+ }
+
+ nsContentUtils::AddScriptRunner(MakeAndAddRef<NotifyWhenScriptSafeRunnable>(
+ this, aSubject, aTopic, aData));
+ return NS_OK;
+}
diff --git a/xpcom/ds/nsObserverService.h b/xpcom/ds/nsObserverService.h
new file mode 100644
index 0000000000..f4e445995b
--- /dev/null
+++ b/xpcom/ds/nsObserverService.h
@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsObserverService_h___
+#define nsObserverService_h___
+
+#include "nsIObserverService.h"
+#include "nsObserverList.h"
+#include "nsIMemoryReporter.h"
+#include "nsTHashtable.h"
+#include "mozilla/Attributes.h"
+
+// {D07F5195-E3D1-11d2-8ACD-00105A1B8860}
+#define NS_OBSERVERSERVICE_CID \
+ { \
+ 0xd07f5195, 0xe3d1, 0x11d2, { \
+ 0x8a, 0xcd, 0x0, 0x10, 0x5a, 0x1b, 0x88, 0x60 \
+ } \
+ }
+
+class nsObserverService final : public nsIObserverService,
+ public nsIMemoryReporter {
+ public:
+ NS_DECLARE_STATIC_IID_ACCESSOR(NS_OBSERVERSERVICE_CID)
+
+ nsObserverService();
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVERSERVICE
+ NS_DECL_NSIMEMORYREPORTER
+
+ void Shutdown();
+
+ [[nodiscard]] static nsresult Create(const nsIID& aIID, void** aInstancePtr);
+
+ // Unmark any strongly held observers implemented in JS so the cycle
+ // collector will not traverse them.
+ NS_IMETHOD UnmarkGrayStrongObservers();
+
+ private:
+ ~nsObserverService(void);
+ void RegisterReporter();
+ nsresult EnsureValidCall() const;
+ nsresult FilterHttpOnTopics(const char* aTopic);
+
+ static const size_t kSuspectReferentCount = 100;
+ bool mShuttingDown;
+ nsTHashtable<nsObserverList> mObserverTopicTable;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsObserverService, NS_OBSERVERSERVICE_CID)
+
+#endif /* nsObserverService_h___ */
diff --git a/xpcom/ds/nsPersistentProperties.cpp b/xpcom/ds/nsPersistentProperties.cpp
new file mode 100644
index 0000000000..4e83870742
--- /dev/null
+++ b/xpcom/ds/nsPersistentProperties.cpp
@@ -0,0 +1,584 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsArrayEnumerator.h"
+#include "nsID.h"
+#include "nsCOMArray.h"
+#include "nsUnicharInputStream.h"
+#include "nsPrintfCString.h"
+
+#include "nsPersistentProperties.h"
+#include "nsIProperties.h"
+
+#include "mozilla/ArenaAllocatorExtensions.h"
+
+using mozilla::ArenaStrdup;
+
+struct PropertyTableEntry : public PLDHashEntryHdr {
+ // both of these are arena-allocated
+ const char* mKey;
+ const char16_t* mValue;
+};
+
+static const struct PLDHashTableOps property_HashTableOps = {
+ PLDHashTable::HashStringKey,
+ PLDHashTable::MatchStringKey,
+ PLDHashTable::MoveEntryStub,
+ PLDHashTable::ClearEntryStub,
+ nullptr,
+};
+
+//
+// parser stuff
+//
+enum EParserState {
+ eParserState_AwaitingKey,
+ eParserState_Key,
+ eParserState_AwaitingValue,
+ eParserState_Value,
+ eParserState_Comment
+};
+
+enum EParserSpecial {
+ eParserSpecial_None, // not parsing a special character
+ eParserSpecial_Escaped, // awaiting a special character
+ eParserSpecial_Unicode // parsing a \Uxxx value
+};
+
+class MOZ_STACK_CLASS nsPropertiesParser {
+ public:
+ explicit nsPropertiesParser(nsIPersistentProperties* aProps)
+ : mUnicodeValuesRead(0),
+ mUnicodeValue(u'\0'),
+ mHaveMultiLine(false),
+ mMultiLineCanSkipN(false),
+ mMinLength(0),
+ mState(eParserState_AwaitingKey),
+ mSpecialState(eParserSpecial_None),
+ mProps(aProps) {}
+
+ void FinishValueState(nsAString& aOldValue) {
+ static const char trimThese[] = " \t";
+ mKey.Trim(trimThese, false, true);
+
+ // This is really ugly hack but it should be fast
+ char16_t backup_char;
+ uint32_t minLength = mMinLength;
+ if (minLength) {
+ backup_char = mValue[minLength - 1];
+ mValue.SetCharAt('x', minLength - 1);
+ }
+ mValue.Trim(trimThese, false, true);
+ if (minLength) {
+ mValue.SetCharAt(backup_char, minLength - 1);
+ }
+
+ mProps->SetStringProperty(NS_ConvertUTF16toUTF8(mKey), mValue, aOldValue);
+ mSpecialState = eParserSpecial_None;
+ WaitForKey();
+ }
+
+ EParserState GetState() { return mState; }
+
+ static nsresult SegmentWriter(nsIUnicharInputStream* aStream, void* aClosure,
+ const char16_t* aFromSegment,
+ uint32_t aToOffset, uint32_t aCount,
+ uint32_t* aWriteCount);
+
+ nsresult ParseBuffer(const char16_t* aBuffer, uint32_t aBufferLength);
+
+ private:
+ bool ParseValueCharacter(
+ char16_t aChar, // character that is just being parsed
+ const char16_t* aCur, // pointer to character aChar in the buffer
+ const char16_t*& aTokenStart, // string copying is done in blocks as big
+ // as possible, aTokenStart points to the
+ // beginning of this block
+ nsAString& aOldValue); // when duplicate property is found, new value
+ // is stored into hashtable and the old one is
+ // placed in this variable
+
+ void WaitForKey() { mState = eParserState_AwaitingKey; }
+
+ void EnterKeyState() {
+ mKey.Truncate();
+ mState = eParserState_Key;
+ }
+
+ void WaitForValue() { mState = eParserState_AwaitingValue; }
+
+ void EnterValueState() {
+ mValue.Truncate();
+ mMinLength = 0;
+ mState = eParserState_Value;
+ mSpecialState = eParserSpecial_None;
+ }
+
+ void EnterCommentState() { mState = eParserState_Comment; }
+
+ nsAutoString mKey;
+ nsAutoString mValue;
+
+ uint32_t mUnicodeValuesRead; // should be 4!
+ char16_t mUnicodeValue; // currently parsed unicode value
+ bool mHaveMultiLine; // is TRUE when last processed characters form
+ // any of following sequences:
+ // - "\\\r"
+ // - "\\\n"
+ // - "\\\r\n"
+ // - any sequence above followed by any
+ // combination of ' ' and '\t'
+ bool mMultiLineCanSkipN; // TRUE if "\\\r" was detected
+ uint32_t mMinLength; // limit right trimming at the end to not trim
+ // escaped whitespaces
+ EParserState mState;
+ // if we see a '\' then we enter this special state
+ EParserSpecial mSpecialState;
+ nsCOMPtr<nsIPersistentProperties> mProps;
+};
+
+inline bool IsWhiteSpace(char16_t aChar) {
+ return (aChar == ' ') || (aChar == '\t') || (aChar == '\r') ||
+ (aChar == '\n');
+}
+
+inline bool IsEOL(char16_t aChar) { return (aChar == '\r') || (aChar == '\n'); }
+
+bool nsPropertiesParser::ParseValueCharacter(char16_t aChar,
+ const char16_t* aCur,
+ const char16_t*& aTokenStart,
+ nsAString& aOldValue) {
+ switch (mSpecialState) {
+ // the normal state - look for special characters
+ case eParserSpecial_None:
+ switch (aChar) {
+ case '\\':
+ if (mHaveMultiLine) {
+ // there is nothing to append to mValue yet
+ mHaveMultiLine = false;
+ } else {
+ mValue += Substring(aTokenStart, aCur);
+ }
+
+ mSpecialState = eParserSpecial_Escaped;
+ break;
+
+ case '\n':
+ // if we detected multiline and got only "\\\r" ignore next "\n" if
+ // any
+ if (mHaveMultiLine && mMultiLineCanSkipN) {
+ // but don't allow another '\n' to be skipped
+ mMultiLineCanSkipN = false;
+ // Now there is nothing to append to the mValue since we are
+ // skipping whitespaces at the beginning of the new line of the
+ // multiline property. Set aTokenStart properly to ensure that
+ // nothing is appended if we find regular line-end or the end of the
+ // buffer.
+ aTokenStart = aCur + 1;
+ break;
+ }
+ [[fallthrough]];
+
+ case '\r':
+ // we're done! We have a key and value
+ mValue += Substring(aTokenStart, aCur);
+ FinishValueState(aOldValue);
+ mHaveMultiLine = false;
+ break;
+
+ default:
+ // there is nothing to do with normal characters,
+ // but handle multilines correctly
+ if (mHaveMultiLine) {
+ if (aChar == ' ' || aChar == '\t') {
+ // don't allow another '\n' to be skipped
+ mMultiLineCanSkipN = false;
+ // Now there is nothing to append to the mValue since we are
+ // skipping whitespaces at the beginning of the new line of the
+ // multiline property. Set aTokenStart properly to ensure that
+ // nothing is appended if we find regular line-end or the end of
+ // the buffer.
+ aTokenStart = aCur + 1;
+ break;
+ }
+ mHaveMultiLine = false;
+ aTokenStart = aCur;
+ }
+ break; // from switch on (aChar)
+ }
+ break; // from switch on (mSpecialState)
+
+ // saw a \ character, so parse the character after that
+ case eParserSpecial_Escaped:
+ // probably want to start parsing at the next token
+ // other characters, like 'u' might override this
+ aTokenStart = aCur + 1;
+ mSpecialState = eParserSpecial_None;
+
+ switch (aChar) {
+ // the easy characters - \t, \n, and so forth
+ case 't':
+ mValue += char16_t('\t');
+ mMinLength = mValue.Length();
+ break;
+ case 'n':
+ mValue += char16_t('\n');
+ mMinLength = mValue.Length();
+ break;
+ case 'r':
+ mValue += char16_t('\r');
+ mMinLength = mValue.Length();
+ break;
+ case '\\':
+ mValue += char16_t('\\');
+ break;
+
+ // switch to unicode mode!
+ case 'u':
+ case 'U':
+ mSpecialState = eParserSpecial_Unicode;
+ mUnicodeValuesRead = 0;
+ mUnicodeValue = 0;
+ break;
+
+ // a \ immediately followed by a newline means we're going multiline
+ case '\r':
+ case '\n':
+ mHaveMultiLine = true;
+ mMultiLineCanSkipN = (aChar == '\r');
+ mSpecialState = eParserSpecial_None;
+ break;
+
+ default:
+ // don't recognize the character, so just append it
+ mValue += aChar;
+ break;
+ }
+ break;
+
+ // we're in the middle of parsing a 4-character unicode value
+ // like \u5f39
+ case eParserSpecial_Unicode:
+ if ('0' <= aChar && aChar <= '9') {
+ mUnicodeValue = (mUnicodeValue << 4) | (aChar - '0');
+ } else if ('a' <= aChar && aChar <= 'f') {
+ mUnicodeValue = (mUnicodeValue << 4) | (aChar - 'a' + 0x0a);
+ } else if ('A' <= aChar && aChar <= 'F') {
+ mUnicodeValue = (mUnicodeValue << 4) | (aChar - 'A' + 0x0a);
+ } else {
+ // non-hex character. Append what we have, and move on.
+ mValue += mUnicodeValue;
+ mMinLength = mValue.Length();
+ mSpecialState = eParserSpecial_None;
+
+ // leave aTokenStart at this unknown character, so it gets appended
+ aTokenStart = aCur;
+
+ // ensure parsing this non-hex character again
+ return false;
+ }
+
+ if (++mUnicodeValuesRead >= 4) {
+ aTokenStart = aCur + 1;
+ mSpecialState = eParserSpecial_None;
+ mValue += mUnicodeValue;
+ mMinLength = mValue.Length();
+ }
+
+ break;
+ }
+
+ return true;
+}
+
+nsresult nsPropertiesParser::SegmentWriter(nsIUnicharInputStream* aStream,
+ void* aClosure,
+ const char16_t* aFromSegment,
+ uint32_t aToOffset, uint32_t aCount,
+ uint32_t* aWriteCount) {
+ nsPropertiesParser* parser = static_cast<nsPropertiesParser*>(aClosure);
+ parser->ParseBuffer(aFromSegment, aCount);
+
+ *aWriteCount = aCount;
+ return NS_OK;
+}
+
+nsresult nsPropertiesParser::ParseBuffer(const char16_t* aBuffer,
+ uint32_t aBufferLength) {
+ const char16_t* cur = aBuffer;
+ const char16_t* end = aBuffer + aBufferLength;
+
+ // points to the start/end of the current key or value
+ const char16_t* tokenStart = nullptr;
+
+ // if we're in the middle of parsing a key or value, make sure
+ // the current token points to the beginning of the current buffer
+ if (mState == eParserState_Key || mState == eParserState_Value) {
+ tokenStart = aBuffer;
+ }
+
+ nsAutoString oldValue;
+
+ while (cur != end) {
+ char16_t c = *cur;
+
+ switch (mState) {
+ case eParserState_AwaitingKey:
+ if (c == '#' || c == '!') {
+ EnterCommentState();
+ }
+
+ else if (!IsWhiteSpace(c)) {
+ // not a comment, not whitespace, we must have found a key!
+ EnterKeyState();
+ tokenStart = cur;
+ }
+ break;
+
+ case eParserState_Key:
+ if (c == '=' || c == ':') {
+ mKey += Substring(tokenStart, cur);
+ WaitForValue();
+ }
+ break;
+
+ case eParserState_AwaitingValue:
+ if (IsEOL(c)) {
+ // no value at all! mimic the normal value-ending
+ EnterValueState();
+ FinishValueState(oldValue);
+ }
+
+ // ignore white space leading up to the value
+ else if (!IsWhiteSpace(c)) {
+ tokenStart = cur;
+ EnterValueState();
+
+ // make sure to handle this first character
+ if (ParseValueCharacter(c, cur, tokenStart, oldValue)) {
+ cur++;
+ }
+ // If the character isn't consumed, don't do cur++ and parse
+ // the character again. This can happen f.e. for char 'X' in sequence
+ // "\u00X". This character can be control character and must be
+ // processed again.
+ continue;
+ }
+ break;
+
+ case eParserState_Value:
+ if (ParseValueCharacter(c, cur, tokenStart, oldValue)) {
+ cur++;
+ }
+ // See few lines above for reason of doing this
+ continue;
+
+ case eParserState_Comment:
+ // stay in this state till we hit EOL
+ if (c == '\r' || c == '\n') {
+ WaitForKey();
+ }
+ break;
+ }
+
+ // finally, advance to the next character
+ cur++;
+ }
+
+ // if we're still parsing the value and are in eParserSpecial_None, then
+ // append whatever we have..
+ if (mState == eParserState_Value && tokenStart &&
+ mSpecialState == eParserSpecial_None) {
+ mValue += Substring(tokenStart, cur);
+ }
+ // if we're still parsing the key, then append whatever we have..
+ else if (mState == eParserState_Key && tokenStart) {
+ mKey += Substring(tokenStart, cur);
+ }
+
+ return NS_OK;
+}
+
+nsPersistentProperties::nsPersistentProperties()
+ : mIn(nullptr),
+ mTable(&property_HashTableOps, sizeof(PropertyTableEntry), 16),
+ mArena() {}
+
+nsPersistentProperties::~nsPersistentProperties() = default;
+
+size_t nsPersistentProperties::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ // The memory used by mTable is accounted for in mArena.
+ size_t n = 0;
+ n += mArena.SizeOfExcludingThis(aMallocSizeOf);
+ n += mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ return aMallocSizeOf(this) + n;
+}
+
+NS_IMPL_ISUPPORTS(nsPersistentProperties, nsIPersistentProperties,
+ nsIProperties)
+
+NS_IMETHODIMP
+nsPersistentProperties::Load(nsIInputStream* aIn) {
+ nsresult rv = NS_NewUnicharInputStream(aIn, getter_AddRefs(mIn));
+
+ if (rv != NS_OK) {
+ NS_WARNING("Error creating UnicharInputStream");
+ return NS_ERROR_FAILURE;
+ }
+
+ nsPropertiesParser parser(this);
+
+ uint32_t nProcessed;
+ // If this 4096 is changed to some other value, make sure to adjust
+ // the bug121341.properties test file accordingly.
+ while (NS_SUCCEEDED(rv = mIn->ReadSegments(nsPropertiesParser::SegmentWriter,
+ &parser, 4096, &nProcessed)) &&
+ nProcessed != 0)
+ ;
+ mIn = nullptr;
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ // We may have an unprocessed value at this point
+ // if the last line did not have a proper line ending.
+ if (parser.GetState() == eParserState_Value) {
+ nsAutoString oldValue;
+ parser.FinishValueState(oldValue);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::SetStringProperty(const nsACString& aKey,
+ const nsAString& aNewValue,
+ nsAString& aOldValue) {
+ const nsCString& flatKey = PromiseFlatCString(aKey);
+ auto entry = static_cast<PropertyTableEntry*>(mTable.Add(flatKey.get()));
+
+ if (entry->mKey) {
+ aOldValue = entry->mValue;
+ NS_WARNING(
+ nsPrintfCString("the property %s already exists", flatKey.get()).get());
+ } else {
+ aOldValue.Truncate();
+ }
+
+ entry->mKey = ArenaStrdup(flatKey, mArena);
+ entry->mValue = ArenaStrdup(aNewValue, mArena);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::Save(nsIOutputStream* aOut, const nsACString& aHeader) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::GetStringProperty(const nsACString& aKey,
+ nsAString& aValue) {
+ const nsCString& flatKey = PromiseFlatCString(aKey);
+
+ auto entry = static_cast<PropertyTableEntry*>(mTable.Search(flatKey.get()));
+ if (!entry) {
+ return NS_ERROR_FAILURE;
+ }
+
+ aValue = entry->mValue;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::Enumerate(nsISimpleEnumerator** aResult) {
+ nsCOMArray<nsIPropertyElement> props;
+
+ // We know the necessary size; we can avoid growing it while adding elements
+ props.SetCapacity(mTable.EntryCount());
+
+ // Step through hash entries populating a transient array
+ for (auto iter = mTable.Iter(); !iter.Done(); iter.Next()) {
+ auto entry = static_cast<PropertyTableEntry*>(iter.Get());
+
+ RefPtr<nsPropertyElement> element = new nsPropertyElement(
+ nsDependentCString(entry->mKey), nsDependentString(entry->mValue));
+
+ if (!props.AppendObject(element)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ return NS_NewArrayEnumerator(aResult, props, NS_GET_IID(nsIPropertyElement));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XXX Some day we'll unify the nsIPersistentProperties interface with
+// nsIProperties, but until now...
+
+NS_IMETHODIMP
+nsPersistentProperties::Get(const char* aProp, const nsIID& aUUID,
+ void** aResult) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::Set(const char* aProp, nsISupports* value) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsPersistentProperties::Undefine(const char* aProp) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::Has(const char* aProp, bool* aResult) {
+ *aResult = !!mTable.Search(aProp);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPersistentProperties::GetKeys(nsTArray<nsCString>& aKeys) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyElement
+////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsPropertyElement::Create(REFNSIID aIID, void** aResult) {
+ RefPtr<nsPropertyElement> propElem = new nsPropertyElement();
+ return propElem->QueryInterface(aIID, aResult);
+}
+
+NS_IMPL_ISUPPORTS(nsPropertyElement, nsIPropertyElement)
+
+NS_IMETHODIMP
+nsPropertyElement::GetKey(nsACString& aReturnKey) {
+ aReturnKey = mKey;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPropertyElement::GetValue(nsAString& aReturnValue) {
+ aReturnValue = mValue;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPropertyElement::SetKey(const nsACString& aKey) {
+ mKey = aKey;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPropertyElement::SetValue(const nsAString& aValue) {
+ mValue = aValue;
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
diff --git a/xpcom/ds/nsPersistentProperties.h b/xpcom/ds/nsPersistentProperties.h
new file mode 100644
index 0000000000..e35f938371
--- /dev/null
+++ b/xpcom/ds/nsPersistentProperties.h
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsPersistentProperties_h___
+#define nsPersistentProperties_h___
+
+#include "nsIPersistentProperties2.h"
+#include "PLDHashTable.h"
+#include "nsString.h"
+#include "nsCOMPtr.h"
+#include "mozilla/ArenaAllocator.h"
+#include "mozilla/Attributes.h"
+
+class nsIUnicharInputStream;
+
+class nsPersistentProperties final : public nsIPersistentProperties {
+ public:
+ nsPersistentProperties();
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIPROPERTIES
+ NS_DECL_NSIPERSISTENTPROPERTIES
+
+ private:
+ ~nsPersistentProperties();
+
+ protected:
+ nsCOMPtr<nsIUnicharInputStream> mIn;
+
+ PLDHashTable mTable;
+ mozilla::ArenaAllocator<2048, 4> mArena;
+};
+
+class nsPropertyElement final : public nsIPropertyElement {
+ public:
+ nsPropertyElement() = default;
+
+ nsPropertyElement(const nsACString& aKey, const nsAString& aValue)
+ : mKey(aKey), mValue(aValue) {}
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIPROPERTYELEMENT
+
+ static nsresult Create(REFNSIID aIID, void** aResult);
+
+ private:
+ ~nsPropertyElement() = default;
+
+ protected:
+ nsCString mKey;
+ nsString mValue;
+};
+
+#endif /* nsPersistentProperties_h___ */
diff --git a/xpcom/ds/nsPointerHashKeys.h b/xpcom/ds/nsPointerHashKeys.h
new file mode 100644
index 0000000000..5cf2e8c4d3
--- /dev/null
+++ b/xpcom/ds/nsPointerHashKeys.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Definitions for nsPtrHashKey<T> and nsVoidPtrHashKey. */
+
+#ifndef nsPointerHashKeys_h
+#define nsPointerHashKeys_h
+
+#include "nscore.h"
+
+#include "mozilla/Attributes.h"
+#include "mozilla/HashFunctions.h"
+
+#include "PLDHashTable.h"
+
+/**
+ * hashkey wrapper using T* KeyType
+ *
+ * @see nsTHashtable::EntryType for specification
+ */
+template <class T>
+class nsPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef T* KeyType;
+ typedef const T* KeyTypePointer;
+
+ explicit nsPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
+ nsPtrHashKey(nsPtrHashKey<T>&& aToMove)
+ : PLDHashEntryHdr(std::move(aToMove)), mKey(std::move(aToMove.mKey)) {}
+ ~nsPtrHashKey() = default;
+
+ KeyType GetKey() const { return mKey; }
+ bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
+
+ static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return mozilla::HashGeneric(aKey);
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ protected:
+ T* MOZ_NON_OWNING_REF mKey;
+};
+
+typedef nsPtrHashKey<const void> nsVoidPtrHashKey;
+
+#endif // nsPointerHashKeys_h
diff --git a/xpcom/ds/nsProperties.cpp b/xpcom/ds/nsProperties.cpp
new file mode 100644
index 0000000000..2094981634
--- /dev/null
+++ b/xpcom/ds/nsProperties.cpp
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsProperties.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+NS_IMPL_ISUPPORTS(nsProperties, nsIProperties)
+
+NS_IMETHODIMP
+nsProperties::Get(const char* prop, const nsIID& uuid, void** result) {
+ if (NS_WARN_IF(!prop)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsCOMPtr<nsISupports> value;
+ if (!nsProperties_HashBase::Get(prop, getter_AddRefs(value))) {
+ return NS_ERROR_FAILURE;
+ }
+ return (value) ? value->QueryInterface(uuid, result) : NS_ERROR_NO_INTERFACE;
+}
+
+NS_IMETHODIMP
+nsProperties::Set(const char* prop, nsISupports* value) {
+ if (NS_WARN_IF(!prop)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ InsertOrUpdate(prop, value);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsProperties::Undefine(const char* prop) {
+ if (NS_WARN_IF(!prop)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ return nsProperties_HashBase::Remove(prop) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsProperties::Has(const char* prop, bool* result) {
+ if (NS_WARN_IF(!prop)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *result = nsProperties_HashBase::Contains(prop);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsProperties::GetKeys(nsTArray<nsCString>& aKeys) {
+ mozilla::AppendToArray(aKeys, this->Keys());
+
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
diff --git a/xpcom/ds/nsProperties.h b/xpcom/ds/nsProperties.h
new file mode 100644
index 0000000000..c45c7361ea
--- /dev/null
+++ b/xpcom/ds/nsProperties.h
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsProperties_h___
+#define nsProperties_h___
+
+#include "nsIProperties.h"
+#include "nsInterfaceHashtable.h"
+#include "nsHashKeys.h"
+#include "mozilla/Attributes.h"
+
+typedef nsInterfaceHashtable<nsCharPtrHashKey, nsISupports>
+ nsProperties_HashBase;
+
+class nsProperties final : public nsIProperties, public nsProperties_HashBase {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIPROPERTIES
+
+ nsProperties() = default;
+
+ private:
+ ~nsProperties() = default;
+};
+
+#endif /* nsProperties_h___ */
diff --git a/xpcom/ds/nsQuickSort.cpp b/xpcom/ds/nsQuickSort.cpp
new file mode 100644
index 0000000000..1fb3dede88
--- /dev/null
+++ b/xpcom/ds/nsQuickSort.cpp
@@ -0,0 +1,175 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+/*-
+ * Copyright (c) 1992, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* We need this because Solaris' version of qsort is broken and
+ * causes array bounds reads.
+ */
+
+#include <stdlib.h>
+#include "nsAlgorithm.h"
+#include "nsQuickSort.h"
+
+extern "C" {
+
+#if !defined(DEBUG) && (defined(__cplusplus) || defined(__gcc))
+# ifndef INLINE
+# define INLINE inline
+# endif
+#else
+# define INLINE
+#endif
+
+typedef int cmp_t(const void*, const void*, void*);
+static INLINE char* med3(char*, char*, char*, cmp_t*, void*);
+static INLINE void swapfunc(char*, char*, int, int);
+
+/*
+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
+ */
+#define swapcode(TYPE, parmi, parmj, n) \
+ { \
+ long i = (n) / sizeof(TYPE); \
+ TYPE* pi = (TYPE*)(parmi); \
+ TYPE* pj = (TYPE*)(parmj); \
+ do { \
+ TYPE t = *pi; \
+ *pi++ = *pj; \
+ *pj++ = t; \
+ } while (--i > 0); \
+ }
+
+#define SWAPINIT(a, es) \
+ swaptype = ((char*)a - (char*)0) % sizeof(long) || es % sizeof(long) ? 2 \
+ : es == sizeof(long) ? 0 \
+ : 1;
+
+static INLINE void swapfunc(char* a, char* b, int n, int swaptype) {
+ if (swaptype <= 1) swapcode(long, a, b, n) else swapcode(char, a, b, n)
+}
+
+#define swap(a, b) \
+ if (swaptype == 0) { \
+ long t = *(long*)(a); \
+ *(long*)(a) = *(long*)(b); \
+ *(long*)(b) = t; \
+ } else \
+ swapfunc((char*)a, (char*)b, (int)es, swaptype)
+
+#define vecswap(a, b, n) \
+ if ((n) > 0) swapfunc((char*)a, (char*)b, (int)n, swaptype)
+
+static INLINE char* med3(char* a, char* b, char* c, cmp_t* cmp, void* data) {
+ return cmp(a, b, data) < 0
+ ? (cmp(b, c, data) < 0 ? b : (cmp(a, c, data) < 0 ? c : a))
+ : (cmp(b, c, data) > 0 ? b : (cmp(a, c, data) < 0 ? a : c));
+}
+
+void NS_QuickSort(void* a, unsigned int n, unsigned int es, cmp_t* cmp,
+ void* data) {
+ char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+ int d, r, swaptype;
+
+loop:
+ SWAPINIT(a, es);
+ /* Use insertion sort when input is small */
+ if (n < 7) {
+ for (pm = (char*)a + es; pm < (char*)a + n * es; pm += es)
+ for (pl = pm; pl > (char*)a && cmp(pl - es, pl, data) > 0; pl -= es)
+ swap(pl, pl - es);
+ return;
+ }
+ /* Choose pivot */
+ pm = (char*)a + (n / 2) * es;
+ if (n > 7) {
+ pl = (char*)a;
+ pn = (char*)a + (n - 1) * es;
+ if (n > 40) {
+ d = (n / 8) * es;
+ pl = med3(pl, pl + d, pl + 2 * d, cmp, data);
+ pm = med3(pm - d, pm, pm + d, cmp, data);
+ pn = med3(pn - 2 * d, pn - d, pn, cmp, data);
+ }
+ pm = med3(pl, pm, pn, cmp, data);
+ }
+ swap(a, pm);
+ pa = pb = (char*)a + es;
+
+ pc = pd = (char*)a + (n - 1) * es;
+ /* loop invariants:
+ * [a, pa) = pivot
+ * [pa, pb) < pivot
+ * [pb, pc + es) unprocessed
+ * [pc + es, pd + es) > pivot
+ * [pd + es, pn) = pivot
+ */
+ for (;;) {
+ while (pb <= pc && (r = cmp(pb, a, data)) <= 0) {
+ if (r == 0) {
+ swap(pa, pb);
+ pa += es;
+ }
+ pb += es;
+ }
+ while (pb <= pc && (r = cmp(pc, a, data)) >= 0) {
+ if (r == 0) {
+ swap(pc, pd);
+ pd -= es;
+ }
+ pc -= es;
+ }
+ if (pb > pc) break;
+ swap(pb, pc);
+ pb += es;
+ pc -= es;
+ }
+ /* Move pivot values */
+ pn = (char*)a + n * es;
+ r = XPCOM_MIN(pa - (char*)a, pb - pa);
+ vecswap(a, pb - r, r);
+ r = XPCOM_MIN<size_t>(pd - pc, pn - pd - es);
+ vecswap(pb, pn - r, r);
+ /* Recursively process partitioned items */
+ if ((r = pb - pa) > (int)es) NS_QuickSort(a, r / es, es, cmp, data);
+ if ((r = pd - pc) > (int)es) {
+ /* Iterate rather than recurse to save stack space */
+ a = pn - r;
+ n = r / es;
+ goto loop;
+ }
+ /* NS_QuickSort(pn - r, r / es, es, cmp, data);*/
+}
+}
+
+#undef INLINE
+#undef swapcode
+#undef SWAPINIT
+#undef swap
+#undef vecswap
diff --git a/xpcom/ds/nsQuickSort.h b/xpcom/ds/nsQuickSort.h
new file mode 100644
index 0000000000..c2b842bea3
--- /dev/null
+++ b/xpcom/ds/nsQuickSort.h
@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* We need this because Solaris' version of qsort is broken and
+ * causes array bounds reads.
+ */
+
+#ifndef nsQuickSort_h___
+#define nsQuickSort_h___
+
+#include "nscore.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Parameters:
+ * 1. the array to sort
+ * 2. the number of elements in the array
+ * 3. the size of each array element
+ * 4. comparison function taking two elements and parameter #5 and
+ * returning an integer:
+ * + less than zero if the first element should be before the second
+ * + 0 if the order of the elements does not matter
+ * + greater than zero if the second element should be before the first
+ * 5. extra data to pass to comparison function
+ */
+void NS_QuickSort(void*, unsigned int, unsigned int,
+ int (*)(const void*, const void*, void*), void*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* nsQuickSort_h___ */
diff --git a/xpcom/ds/nsRefCountedHashtable.h b/xpcom/ds/nsRefCountedHashtable.h
new file mode 100644
index 0000000000..e3a0456a09
--- /dev/null
+++ b/xpcom/ds/nsRefCountedHashtable.h
@@ -0,0 +1,245 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef XPCOM_DS_NSREFCOUNTEDHASHTABLE_H_
+#define XPCOM_DS_NSREFCOUNTEDHASHTABLE_H_
+
+#include "nsBaseHashtable.h"
+#include "nsHashKeys.h"
+
+/**
+ * templated hashtable class maps keys to reference pointers.
+ * See nsBaseHashtable for complete declaration.
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ * @param PtrType the reference-type being wrapped
+ * @see nsClassHashtable, nsTHashMap
+ */
+template <class KeyClass, class PtrType>
+class nsRefCountedHashtable
+ : public nsBaseHashtable<
+ KeyClass, PtrType,
+ typename mozilla::detail::SmartPtrTraits<PtrType>::RawPointerType> {
+ public:
+ using KeyType = typename KeyClass::KeyType;
+ using SmartPtrTraits = mozilla::detail::SmartPtrTraits<PtrType>;
+ using PointeeType = typename SmartPtrTraits::PointeeType;
+ using RawPointerType = typename SmartPtrTraits::RawPointerType;
+ using base_type = nsBaseHashtable<KeyClass, PtrType, RawPointerType>;
+
+ using base_type::base_type;
+
+ static_assert(SmartPtrTraits::IsRefCounted);
+
+ /**
+ * @copydoc nsBaseHashtable::Get
+ * @param aData This is an XPCOM getter, so aData is already_addrefed.
+ * If the key doesn't exist, *aData will be set to nullptr.
+ */
+ bool Get(KeyType aKey, RawPointerType* aData) const;
+
+ /**
+ * @copydoc nsBaseHashtable::Get
+ */
+ [[nodiscard]] already_AddRefed<PointeeType> Get(KeyType aKey) const;
+
+ /**
+ * Gets a weak reference to the hashtable entry.
+ * @param aFound If not nullptr, will be set to true if the entry is found,
+ * to false otherwise.
+ * @return The entry, or nullptr if not found. Do not release this pointer!
+ */
+ [[nodiscard]] RawPointerType GetWeak(KeyType aKey,
+ bool* aFound = nullptr) const;
+
+ using base_type::InsertOrUpdate;
+
+ template <typename U,
+ typename = std::enable_if_t<std::is_base_of_v<PointeeType, U>>>
+ void InsertOrUpdate(
+ KeyType aKey,
+ typename SmartPtrTraits::template OtherSmartPtrType<U>&& aData);
+
+ template <typename U,
+ typename = std::enable_if_t<std::is_base_of_v<PointeeType, U>>>
+ [[nodiscard]] bool InsertOrUpdate(
+ KeyType aKey,
+ typename SmartPtrTraits::template OtherSmartPtrType<U>&& aData,
+ const mozilla::fallible_t&);
+
+ template <typename U,
+ typename = std::enable_if_t<std::is_base_of_v<PointeeType, U>>>
+ void InsertOrUpdate(KeyType aKey, already_AddRefed<U>&& aData);
+
+ template <typename U,
+ typename = std::enable_if_t<std::is_base_of_v<PointeeType, U>>>
+ [[nodiscard]] bool InsertOrUpdate(KeyType aKey, already_AddRefed<U>&& aData,
+ const mozilla::fallible_t&);
+
+ /**
+ * Remove the entry associated with aKey (if any), optionally _moving_ its
+ * current value into *aData, thereby avoiding calls to AddRef and Release.
+ * Return true if found.
+ * @param aKey the key to remove from the hashtable
+ * @param aData where to move the value (if non-null). If an entry is not
+ * found it will be set to nullptr.
+ * @return true if an entry for aKey was found (and removed)
+ */
+ inline bool Remove(KeyType aKey, RawPointerType* aData = nullptr);
+
+ nsRefCountedHashtable Clone() const {
+ return this->template CloneAs<nsRefCountedHashtable>();
+ }
+};
+
+template <typename K, typename T>
+inline void ImplCycleCollectionUnlink(nsRefCountedHashtable<K, T>& aField) {
+ aField.Clear();
+}
+
+template <typename K, typename T>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ nsRefCountedHashtable<K, T>& aField, const char* aName,
+ uint32_t aFlags = 0) {
+ for (auto iter = aField.ConstIter(); !iter.Done(); iter.Next()) {
+ CycleCollectionNoteChild(aCallback, iter.UserData(), aName, aFlags);
+ }
+}
+
+//
+// nsRefCountedHashtable definitions
+//
+
+template <class KeyClass, class PtrType>
+bool nsRefCountedHashtable<KeyClass, PtrType>::Get(
+ KeyType aKey, RawPointerType* aRefPtr) const {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+ if (ent) {
+ if (aRefPtr) {
+ *aRefPtr = ent->GetData();
+
+ NS_IF_ADDREF(*aRefPtr);
+ }
+
+ return true;
+ }
+
+ // if the key doesn't exist, set *aRefPtr to null
+ // so that it is a valid XPCOM getter
+ if (aRefPtr) {
+ *aRefPtr = nullptr;
+ }
+
+ return false;
+}
+
+template <class KeyClass, class PtrType>
+already_AddRefed<typename nsRefCountedHashtable<KeyClass, PtrType>::PointeeType>
+nsRefCountedHashtable<KeyClass, PtrType>::Get(KeyType aKey) const {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+ if (!ent) {
+ return nullptr;
+ }
+
+ PtrType copy = ent->GetData();
+ return copy.forget();
+}
+
+template <class KeyClass, class PtrType>
+typename nsRefCountedHashtable<KeyClass, PtrType>::RawPointerType
+nsRefCountedHashtable<KeyClass, PtrType>::GetWeak(KeyType aKey,
+ bool* aFound) const {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+ if (ent) {
+ if (aFound) {
+ *aFound = true;
+ }
+
+ return ent->GetData();
+ }
+
+ // Key does not exist, return nullptr and set aFound to false
+ if (aFound) {
+ *aFound = false;
+ }
+
+ return nullptr;
+}
+
+template <class KeyClass, class PtrType>
+template <typename U, typename>
+void nsRefCountedHashtable<KeyClass, PtrType>::InsertOrUpdate(
+ KeyType aKey,
+ typename SmartPtrTraits::template OtherSmartPtrType<U>&& aData) {
+ if (!InsertOrUpdate(aKey, std::move(aData), mozilla::fallible)) {
+ NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
+ }
+}
+
+template <class KeyClass, class PtrType>
+template <typename U, typename>
+bool nsRefCountedHashtable<KeyClass, PtrType>::InsertOrUpdate(
+ KeyType aKey,
+ typename SmartPtrTraits::template OtherSmartPtrType<U>&& aData,
+ const mozilla::fallible_t&) {
+ typename base_type::EntryType* ent = this->PutEntry(aKey, mozilla::fallible);
+
+ if (!ent) {
+ return false;
+ }
+
+ ent->SetData(std::move(aData));
+
+ return true;
+}
+
+template <class KeyClass, class PtrType>
+template <typename U, typename>
+void nsRefCountedHashtable<KeyClass, PtrType>::InsertOrUpdate(
+ KeyType aKey, already_AddRefed<U>&& aData) {
+ if (!InsertOrUpdate(aKey, std::move(aData), mozilla::fallible)) {
+ NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
+ }
+}
+
+template <class KeyClass, class PtrType>
+template <typename U, typename>
+bool nsRefCountedHashtable<KeyClass, PtrType>::InsertOrUpdate(
+ KeyType aKey, already_AddRefed<U>&& aData, const mozilla::fallible_t&) {
+ typename base_type::EntryType* ent = this->PutEntry(aKey, mozilla::fallible);
+
+ if (!ent) {
+ return false;
+ }
+
+ ent->SetData(std::move(aData));
+
+ return true;
+}
+
+template <class KeyClass, class PtrType>
+bool nsRefCountedHashtable<KeyClass, PtrType>::Remove(KeyType aKey,
+ RawPointerType* aRefPtr) {
+ typename base_type::EntryType* ent = this->GetEntry(aKey);
+
+ if (ent) {
+ if (aRefPtr) {
+ ent->GetModifiableData()->forget(aRefPtr);
+ }
+ this->RemoveEntry(ent);
+ return true;
+ }
+
+ if (aRefPtr) {
+ *aRefPtr = nullptr;
+ }
+ return false;
+}
+
+#endif // XPCOM_DS_NSREFCOUNTEDHASHTABLE_H_
diff --git a/xpcom/ds/nsRefPtrHashtable.h b/xpcom/ds/nsRefPtrHashtable.h
new file mode 100644
index 0000000000..55b946bf7b
--- /dev/null
+++ b/xpcom/ds/nsRefPtrHashtable.h
@@ -0,0 +1,12 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsRefPtrHashtable_h__
+#define nsRefPtrHashtable_h__
+
+#include "nsRefCountedHashtable.h"
+
+#endif // nsRefPtrHashtable_h__
diff --git a/xpcom/ds/nsSimpleEnumerator.cpp b/xpcom/ds/nsSimpleEnumerator.cpp
new file mode 100644
index 0000000000..7f7ca9d674
--- /dev/null
+++ b/xpcom/ds/nsSimpleEnumerator.cpp
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsSimpleEnumerator.h"
+
+#include "mozilla/dom/IteratorResultBinding.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "mozilla/ResultExtensions.h"
+#include "nsContentUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+namespace {
+
+class JSEnumerator final : public nsIJSEnumerator {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIJSENUMERATOR
+
+ explicit JSEnumerator(nsISimpleEnumerator* aEnumerator, const nsID& aIID)
+ : mEnumerator(aEnumerator), mIID(aIID) {}
+
+ private:
+ ~JSEnumerator() = default;
+
+ nsCOMPtr<nsISimpleEnumerator> mEnumerator;
+ const nsID mIID;
+};
+
+} // anonymous namespace
+
+nsresult JSEnumerator::Iterator(nsIJSEnumerator** aResult) {
+ RefPtr<JSEnumerator> result(this);
+ result.forget(aResult);
+ return NS_OK;
+}
+
+nsresult JSEnumerator::Next(JSContext* aCx, JS::MutableHandleValue aResult) {
+ RootedDictionary<IteratorResult> result(aCx);
+
+ nsCOMPtr<nsISupports> elem;
+ if (NS_FAILED(mEnumerator->GetNext(getter_AddRefs(elem)))) {
+ result.mDone = true;
+ } else {
+ result.mDone = false;
+
+ JS::RootedValue value(aCx);
+ MOZ_TRY(nsContentUtils::WrapNative(aCx, elem, &mIID, &value));
+ result.mValue = value;
+ }
+
+ if (!ToJSValue(aCx, result, aResult)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(JSEnumerator, nsIJSEnumerator)
+
+nsresult nsSimpleEnumerator::Iterator(nsIJSEnumerator** aResult) {
+ auto result = MakeRefPtr<JSEnumerator>(this, DefaultInterface());
+ result.forget(aResult);
+ return NS_OK;
+}
+
+nsresult nsSimpleEnumerator::Entries(const nsIID& aIface,
+ nsIJSEnumerator** aResult) {
+ auto result = MakeRefPtr<JSEnumerator>(this, aIface);
+ result.forget(aResult);
+ return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsSimpleEnumerator, nsISimpleEnumerator,
+ nsISimpleEnumeratorBase)
diff --git a/xpcom/ds/nsSimpleEnumerator.h b/xpcom/ds/nsSimpleEnumerator.h
new file mode 100644
index 0000000000..60ab6419bc
--- /dev/null
+++ b/xpcom/ds/nsSimpleEnumerator.h
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsSimpleEnumerator_h
+#define nsSimpleEnumerator_h
+
+#include "nsISimpleEnumerator.h"
+
+class nsSimpleEnumerator : public nsISimpleEnumerator {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISIMPLEENUMERATORBASE
+
+ virtual const nsID& DefaultInterface() { return NS_GET_IID(nsISupports); }
+
+ protected:
+ virtual ~nsSimpleEnumerator() = default;
+};
+
+#endif
diff --git a/xpcom/ds/nsStaticAtomUtils.h b/xpcom/ds/nsStaticAtomUtils.h
new file mode 100644
index 0000000000..8c766f63e1
--- /dev/null
+++ b/xpcom/ds/nsStaticAtomUtils.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsStaticAtomUtils_h
+#define nsStaticAtomUtils_h
+
+#include <stdint.h>
+#include "nsAtom.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Maybe.h"
+
+// This class holds basic operations on arrays of static atoms.
+class nsStaticAtomUtils {
+ public:
+ static mozilla::Maybe<uint32_t> Lookup(nsAtom* aAtom,
+ const nsStaticAtom* aAtoms,
+ uint32_t aCount) {
+ if (aAtom->IsStatic()) {
+ ptrdiff_t index = aAtom->AsStatic() - aAtoms;
+ if (index >= 0 && index < static_cast<ptrdiff_t>(aCount)) {
+ return mozilla::Some(static_cast<uint32_t>(index));
+ }
+ }
+ return mozilla::Nothing();
+ }
+
+ static bool IsMember(nsAtom* aAtom, const nsStaticAtom* aAtoms,
+ uint32_t aCount) {
+ return Lookup(aAtom, aAtoms, aCount).isSome();
+ }
+};
+
+#endif // nsStaticAtomUtils_h
diff --git a/xpcom/ds/nsStaticNameTable.cpp b/xpcom/ds/nsStaticNameTable.cpp
new file mode 100644
index 0000000000..2ee731c153
--- /dev/null
+++ b/xpcom/ds/nsStaticNameTable.cpp
@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Class to manage lookup of static names in a table. */
+
+#include "mozilla/HashFunctions.h"
+#include "mozilla/TextUtils.h"
+
+#include "nsCRT.h"
+
+#include "nscore.h"
+#include "nsISupportsImpl.h"
+
+#include "nsStaticNameTable.h"
+
+using namespace mozilla;
+
+struct NameTableKey {
+ NameTableKey(const nsDependentCString aNameArray[], const nsCString* aKeyStr)
+ : mNameArray(aNameArray), mIsUnichar(false) {
+ mKeyStr.m1b = aKeyStr;
+ }
+
+ NameTableKey(const nsDependentCString aNameArray[], const nsString* aKeyStr)
+ : mNameArray(aNameArray), mIsUnichar(true) {
+ mKeyStr.m2b = aKeyStr;
+ }
+
+ const nsDependentCString* mNameArray;
+ union {
+ const nsCString* m1b;
+ const nsString* m2b;
+ } mKeyStr;
+ bool mIsUnichar;
+};
+
+struct NameTableEntry : public PLDHashEntryHdr {
+ int32_t mIndex;
+};
+
+static bool matchNameKeysCaseInsensitive(const PLDHashEntryHdr* aHdr,
+ const void* aVoidKey) {
+ auto entry = static_cast<const NameTableEntry*>(aHdr);
+ auto key = static_cast<const NameTableKey*>(aVoidKey);
+ const nsDependentCString* name = &key->mNameArray[entry->mIndex];
+
+ return key->mIsUnichar ? key->mKeyStr.m2b->LowerCaseEqualsASCII(
+ name->get(), name->Length())
+ : key->mKeyStr.m1b->LowerCaseEqualsASCII(
+ name->get(), name->Length());
+}
+
+/*
+ * caseInsensitiveHashKey is just like PLDHashTable::HashStringKey except it
+ * uses (*s & ~0x20) instead of simply *s. This means that "aFOO" and
+ * "afoo" and "aFoo" will all hash to the same thing. It also means
+ * that some strings that aren't case-insensensitively equal will hash
+ * to the same value, but it's just a hash function so it doesn't
+ * matter.
+ */
+static PLDHashNumber caseInsensitiveStringHashKey(const void* aKey) {
+ PLDHashNumber h = 0;
+ const NameTableKey* tableKey = static_cast<const NameTableKey*>(aKey);
+ if (tableKey->mIsUnichar) {
+ for (const char16_t* s = tableKey->mKeyStr.m2b->get(); *s != '\0'; s++) {
+ h = AddToHash(h, *s & ~0x20);
+ }
+ } else {
+ for (const unsigned char* s = reinterpret_cast<const unsigned char*>(
+ tableKey->mKeyStr.m1b->get());
+ *s != '\0'; s++) {
+ h = AddToHash(h, *s & ~0x20);
+ }
+ }
+ return h;
+}
+
+static const struct PLDHashTableOps nametable_CaseInsensitiveHashTableOps = {
+ caseInsensitiveStringHashKey,
+ matchNameKeysCaseInsensitive,
+ PLDHashTable::MoveEntryStub,
+ PLDHashTable::ClearEntryStub,
+ nullptr,
+};
+
+nsStaticCaseInsensitiveNameTable::nsStaticCaseInsensitiveNameTable(
+ const char* const aNames[], int32_t aLength)
+ : mNameArray(nullptr),
+ mNameTable(&nametable_CaseInsensitiveHashTableOps, sizeof(NameTableEntry),
+ aLength),
+ mNullStr("") {
+ MOZ_COUNT_CTOR(nsStaticCaseInsensitiveNameTable);
+
+ MOZ_ASSERT(aNames, "null name table");
+ MOZ_ASSERT(aLength, "0 length");
+
+ mNameArray =
+ (nsDependentCString*)moz_xmalloc(aLength * sizeof(nsDependentCString));
+
+ for (int32_t index = 0; index < aLength; ++index) {
+ const char* raw = aNames[index];
+#ifdef DEBUG
+ {
+ // verify invariants of contents
+ nsAutoCString temp1(raw);
+ nsDependentCString temp2(raw);
+ ToLowerCase(temp1);
+ MOZ_ASSERT(temp1.Equals(temp2), "upper case char in table");
+ MOZ_ASSERT(IsAsciiNullTerminated(raw),
+ "non-ascii string in table -- "
+ "case-insensitive matching won't work right");
+ }
+#endif
+ // use placement-new to initialize the string object
+ nsDependentCString* strPtr = &mNameArray[index];
+ new (strPtr) nsDependentCString(raw);
+
+ NameTableKey key(mNameArray, strPtr);
+
+ auto entry = static_cast<NameTableEntry*>(mNameTable.Add(&key, fallible));
+ if (!entry) {
+ continue;
+ }
+
+ // If the entry already exists it's unlikely but possible that its index is
+ // zero, in which case this assertion won't fail. But if the index is
+ // non-zero (highly likely) then it will fail. In other words, this
+ // assertion is likely but not guaranteed to detect if an entry is already
+ // used.
+ MOZ_ASSERT(entry->mIndex == 0, "Entry already exists!");
+
+ entry->mIndex = index;
+ }
+ mNameTable.MarkImmutable();
+}
+
+nsStaticCaseInsensitiveNameTable::~nsStaticCaseInsensitiveNameTable() {
+ // manually call the destructor on placement-new'ed objects
+ for (uint32_t index = 0; index < mNameTable.EntryCount(); index++) {
+ mNameArray[index].~nsDependentCString();
+ }
+ free((void*)mNameArray);
+ MOZ_COUNT_DTOR(nsStaticCaseInsensitiveNameTable);
+}
+
+int32_t nsStaticCaseInsensitiveNameTable::Lookup(
+ const nsACString& aName) const {
+ NS_ASSERTION(mNameArray, "not inited");
+
+ const nsCString& str = PromiseFlatCString(aName);
+
+ NameTableKey key(mNameArray, &str);
+ auto entry = static_cast<NameTableEntry*>(mNameTable.Search(&key));
+
+ return entry ? entry->mIndex : nsStaticCaseInsensitiveNameTable::NOT_FOUND;
+}
+
+int32_t nsStaticCaseInsensitiveNameTable::Lookup(const nsAString& aName) const {
+ NS_ASSERTION(mNameArray, "not inited");
+
+ const nsString& str = PromiseFlatString(aName);
+
+ NameTableKey key(mNameArray, &str);
+ auto entry = static_cast<NameTableEntry*>(mNameTable.Search(&key));
+
+ return entry ? entry->mIndex : nsStaticCaseInsensitiveNameTable::NOT_FOUND;
+}
+
+const nsCString& nsStaticCaseInsensitiveNameTable::GetStringValue(
+ int32_t aIndex) {
+ NS_ASSERTION(mNameArray, "not inited");
+
+ if ((NOT_FOUND < aIndex) && ((uint32_t)aIndex < mNameTable.EntryCount())) {
+ return mNameArray[aIndex];
+ }
+ return mNullStr;
+}
diff --git a/xpcom/ds/nsStaticNameTable.h b/xpcom/ds/nsStaticNameTable.h
new file mode 100644
index 0000000000..302d82c1e4
--- /dev/null
+++ b/xpcom/ds/nsStaticNameTable.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Classes to manage lookup of static names in a table. */
+
+#ifndef nsStaticNameTable_h___
+#define nsStaticNameTable_h___
+
+#include "PLDHashTable.h"
+#include "nsString.h"
+
+/* This class supports case insensitive lookup.
+ *
+ * It differs from atom tables:
+ * - It supports case insensitive lookup.
+ * - It has minimal footprint by not copying the string table.
+ * - It does no locking.
+ * - It returns zero based indexes and const nsCString& as required by its
+ * callers in the parser.
+ * - It is not an xpcom interface - meant for fast lookup in static tables.
+ *
+ * ***REQUIREMENTS***
+ * - It *requires* that all entries in the table be lowercase only.
+ * - It *requires* that the table of strings be in memory that lives at least
+ * as long as this table object - typically a static string array.
+ */
+
+class nsStaticCaseInsensitiveNameTable {
+ public:
+ enum { NOT_FOUND = -1 };
+
+ int32_t Lookup(const nsACString& aName) const;
+ int32_t Lookup(const nsAString& aName) const;
+ const nsCString& GetStringValue(int32_t aIndex);
+
+ nsStaticCaseInsensitiveNameTable(const char* const aNames[], int32_t aLength);
+ ~nsStaticCaseInsensitiveNameTable();
+
+ private:
+ nsDependentCString* mNameArray;
+ PLDHashTable mNameTable;
+ nsDependentCString mNullStr;
+};
+
+#endif /* nsStaticNameTable_h___ */
diff --git a/xpcom/ds/nsStringEnumerator.cpp b/xpcom/ds/nsStringEnumerator.cpp
new file mode 100644
index 0000000000..7b8cf72d00
--- /dev/null
+++ b/xpcom/ds/nsStringEnumerator.cpp
@@ -0,0 +1,311 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsStringEnumerator.h"
+#include "nsSimpleEnumerator.h"
+#include "nsSupportsPrimitives.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/dom/IteratorResultBinding.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "nsTArray.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+namespace {
+
+class JSStringEnumerator final : public nsIJSEnumerator {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIJSENUMERATOR
+
+ explicit JSStringEnumerator(nsIStringEnumerator* aEnumerator)
+ : mEnumerator(aEnumerator) {
+ MOZ_ASSERT(mEnumerator);
+ }
+
+ private:
+ ~JSStringEnumerator() = default;
+
+ nsCOMPtr<nsIStringEnumerator> mEnumerator;
+};
+
+} // anonymous namespace
+
+nsresult JSStringEnumerator::Iterator(nsIJSEnumerator** aResult) {
+ RefPtr<JSStringEnumerator> result(this);
+ result.forget(aResult);
+ return NS_OK;
+}
+
+nsresult JSStringEnumerator::Next(JSContext* aCx,
+ JS::MutableHandleValue aResult) {
+ RootedDictionary<IteratorResult> result(aCx);
+
+ nsAutoString elem;
+ if (NS_FAILED(mEnumerator->GetNext(elem))) {
+ result.mDone = true;
+ } else {
+ result.mDone = false;
+
+ if (!ToJSValue(
+ aCx, elem,
+ JS::MutableHandleValue::fromMarkedLocation(&result.mValue))) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if (!ToJSValue(aCx, result, aResult)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(JSStringEnumerator, nsIJSEnumerator)
+
+//
+// nsStringEnumeratorBase
+//
+
+nsresult nsStringEnumeratorBase::GetNext(nsAString& aResult) {
+ nsAutoCString str;
+ MOZ_TRY(GetNext(str));
+
+ CopyUTF8toUTF16(str, aResult);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStringEnumeratorBase::StringIterator(nsIJSEnumerator** aRetVal) {
+ auto result = MakeRefPtr<JSStringEnumerator>(this);
+ result.forget(aRetVal);
+ return NS_OK;
+}
+
+//
+// nsStringEnumerator
+//
+
+class nsStringEnumerator final : public nsSimpleEnumerator,
+ public nsIStringEnumerator,
+ public nsIUTF8StringEnumerator {
+ public:
+ nsStringEnumerator(const nsTArray<nsString>* aArray, bool aOwnsArray)
+ : mArray(aArray), mIndex(0), mOwnsArray(aOwnsArray), mIsUnicode(true) {}
+
+ nsStringEnumerator(const nsTArray<nsCString>* aArray, bool aOwnsArray)
+ : mCArray(aArray), mIndex(0), mOwnsArray(aOwnsArray), mIsUnicode(false) {}
+
+ nsStringEnumerator(const nsTArray<nsString>* aArray, nsISupports* aOwner)
+ : mArray(aArray),
+ mIndex(0),
+ mOwner(aOwner),
+ mOwnsArray(false),
+ mIsUnicode(true) {}
+
+ nsStringEnumerator(const nsTArray<nsCString>* aArray, nsISupports* aOwner)
+ : mCArray(aArray),
+ mIndex(0),
+ mOwner(aOwner),
+ mOwnsArray(false),
+ mIsUnicode(false) {}
+
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_NSIUTF8STRINGENUMERATOR
+ NS_DECL_NSISTRINGENUMERATORBASE
+
+ // have to declare nsIStringEnumerator manually, because of
+ // overlapping method names
+ NS_IMETHOD GetNext(nsAString& aResult) override;
+ NS_DECL_NSISIMPLEENUMERATOR
+
+ const nsID& DefaultInterface() override {
+ if (mIsUnicode) {
+ return NS_GET_IID(nsISupportsString);
+ }
+ return NS_GET_IID(nsISupportsCString);
+ }
+
+ private:
+ ~nsStringEnumerator() {
+ if (mOwnsArray) {
+ // const-casting is safe here, because the NS_New*
+ // constructors make sure mOwnsArray is consistent with
+ // the constness of the objects
+ if (mIsUnicode) {
+ delete const_cast<nsTArray<nsString>*>(mArray);
+ } else {
+ delete const_cast<nsTArray<nsCString>*>(mCArray);
+ }
+ }
+ }
+
+ union {
+ const nsTArray<nsString>* mArray;
+ const nsTArray<nsCString>* mCArray;
+ };
+
+ inline uint32_t Count() {
+ return mIsUnicode ? mArray->Length() : mCArray->Length();
+ }
+
+ uint32_t mIndex;
+
+ // the owner allows us to hold a strong reference to the object
+ // that owns the array. Having a non-null value in mOwner implies
+ // that mOwnsArray is false, because we rely on the real owner
+ // to release the array
+ nsCOMPtr<nsISupports> mOwner;
+ bool mOwnsArray;
+ bool mIsUnicode;
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(nsStringEnumerator, nsSimpleEnumerator,
+ nsIStringEnumerator, nsIUTF8StringEnumerator)
+
+NS_IMETHODIMP
+nsStringEnumerator::HasMore(bool* aResult) {
+ *aResult = mIndex < Count();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStringEnumerator::HasMoreElements(bool* aResult) { return HasMore(aResult); }
+
+NS_IMETHODIMP
+nsStringEnumerator::GetNext(nsISupports** aResult) {
+ if (mIndex >= mArray->Length()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (mIsUnicode) {
+ nsSupportsString* stringImpl = new nsSupportsString();
+
+ stringImpl->SetData(mArray->ElementAt(mIndex++));
+ *aResult = stringImpl;
+ } else {
+ nsSupportsCString* cstringImpl = new nsSupportsCString();
+
+ cstringImpl->SetData(mCArray->ElementAt(mIndex++));
+ *aResult = cstringImpl;
+ }
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStringEnumerator::GetNext(nsAString& aResult) {
+ if (NS_WARN_IF(mIndex >= Count())) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (mIsUnicode) {
+ aResult = mArray->ElementAt(mIndex++);
+ } else {
+ CopyUTF8toUTF16(mCArray->ElementAt(mIndex++), aResult);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStringEnumerator::GetNext(nsACString& aResult) {
+ if (NS_WARN_IF(mIndex >= Count())) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (mIsUnicode) {
+ CopyUTF16toUTF8(mArray->ElementAt(mIndex++), aResult);
+ } else {
+ aResult = mCArray->ElementAt(mIndex++);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStringEnumerator::StringIterator(nsIJSEnumerator** aRetVal) {
+ auto result = MakeRefPtr<JSStringEnumerator>(this);
+ result.forget(aRetVal);
+ return NS_OK;
+}
+
+template <class T>
+static inline nsresult StringEnumeratorTail(T** aResult) {
+ if (!*aResult) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+//
+// constructors
+//
+
+nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
+ const nsTArray<nsString>* aArray,
+ nsISupports* aOwner) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, aOwner);
+ return StringEnumeratorTail(aResult);
+}
+
+nsresult NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
+ const nsTArray<nsCString>* aArray,
+ nsISupports* aOwner) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, aOwner);
+ return StringEnumeratorTail(aResult);
+}
+
+nsresult NS_NewAdoptingStringEnumerator(nsIStringEnumerator** aResult,
+ nsTArray<nsString>* aArray) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, true);
+ return StringEnumeratorTail(aResult);
+}
+
+nsresult NS_NewAdoptingUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
+ nsTArray<nsCString>* aArray) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, true);
+ return StringEnumeratorTail(aResult);
+}
+
+// const ones internally just forward to the non-const equivalents
+nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
+ const nsTArray<nsString>* aArray) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, false);
+ return StringEnumeratorTail(aResult);
+}
+
+nsresult NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
+ const nsTArray<nsCString>* aArray) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = new nsStringEnumerator(aArray, false);
+ return StringEnumeratorTail(aResult);
+}
diff --git a/xpcom/ds/nsStringEnumerator.h b/xpcom/ds/nsStringEnumerator.h
new file mode 100644
index 0000000000..0061227c34
--- /dev/null
+++ b/xpcom/ds/nsStringEnumerator.h
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsStringEnumerator_h
+#define nsStringEnumerator_h
+
+#include "nsIStringEnumerator.h"
+#include "nsStringFwd.h"
+#include "nsTArrayForwardDeclare.h"
+
+class nsStringEnumeratorBase : public nsIStringEnumerator,
+ public nsIUTF8StringEnumerator {
+ public:
+ NS_DECL_NSISTRINGENUMERATORBASE
+
+ NS_IMETHOD GetNext(nsAString&) override;
+
+ using nsIUTF8StringEnumerator::GetNext;
+
+ protected:
+ virtual ~nsStringEnumeratorBase() = default;
+};
+
+// nsIStringEnumerator/nsIUTF8StringEnumerator implementations
+//
+// Currently all implementations support both interfaces. The
+// constructors below provide the most common interface for the given
+// type (i.e. nsIStringEnumerator for char16_t* strings, and so
+// forth) but any resulting enumerators can be queried to the other
+// type. Internally, the enumerators will hold onto the type that was
+// passed in and do conversion if GetNext() for the other type of
+// string is called.
+
+// There are a few different types of enumerators:
+
+//
+// These enumerators hold a pointer to the array. Be careful
+// because modifying the array may confuse the iterator, especially if
+// you insert or remove elements in the middle of the array.
+//
+
+// The non-adopting enumerator requires that the array sticks around
+// at least as long as the enumerator does. These are for constant
+// string arrays that the enumerator does not own, this could be used
+// in VERY specialized cases such as when the provider KNOWS that the
+// string enumerator will be consumed immediately, or will at least
+// outlast the array.
+// For example:
+//
+// nsTArray<nsCString> array;
+// array.AppendCString("abc");
+// array.AppendCString("def");
+// NS_NewStringEnumerator(&enumerator, &array, true);
+//
+// // call some internal method which iterates the enumerator
+// InternalMethod(enumerator);
+// NS_RELEASE(enumerator);
+//
+[[nodiscard]] nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
+ const nsTArray<nsString>* aArray,
+ nsISupports* aOwner);
+[[nodiscard]] nsresult NS_NewUTF8StringEnumerator(
+ nsIUTF8StringEnumerator** aResult, const nsTArray<nsCString>* aArray);
+
+[[nodiscard]] nsresult NS_NewStringEnumerator(nsIStringEnumerator** aResult,
+ const nsTArray<nsString>* aArray);
+
+// Adopting string enumerators assume ownership of the array and will
+// call |operator delete| on the array when the enumerator is destroyed
+// this is useful when the provider creates an array solely for the
+// purpose of creating the enumerator.
+// For example:
+//
+// nsTArray<nsCString>* array = new nsTArray<nsCString>;
+// array->AppendString("abcd");
+// NS_NewAdoptingStringEnumerator(&result, array);
+[[nodiscard]] nsresult NS_NewAdoptingStringEnumerator(
+ nsIStringEnumerator** aResult, nsTArray<nsString>* aArray);
+
+[[nodiscard]] nsresult NS_NewAdoptingUTF8StringEnumerator(
+ nsIUTF8StringEnumerator** aResult, nsTArray<nsCString>* aArray);
+
+// these versions take a refcounted "owner" which will be addreffed
+// when the enumerator is created, and destroyed when the enumerator
+// is released. This allows providers to give non-owning pointers to
+// ns*StringArray member variables without worrying about lifetime
+// issues
+// For example:
+//
+// nsresult MyClass::Enumerate(nsIUTF8StringEnumerator** aResult) {
+// mCategoryList->AppendString("abcd");
+// return NS_NewStringEnumerator(aResult, mCategoryList, this);
+// }
+//
+[[nodiscard]] nsresult NS_NewUTF8StringEnumerator(
+ nsIUTF8StringEnumerator** aResult, const nsTArray<nsCString>* aArray,
+ nsISupports* aOwner);
+
+#endif // defined nsStringEnumerator_h
diff --git a/xpcom/ds/nsSupportsPrimitives.cpp b/xpcom/ds/nsSupportsPrimitives.cpp
new file mode 100644
index 0000000000..1d0db73187
--- /dev/null
+++ b/xpcom/ds/nsSupportsPrimitives.cpp
@@ -0,0 +1,603 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsSupportsPrimitives.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Sprintf.h"
+#include <algorithm>
+
+template <typename T>
+static char* DataToString(const char* aFormat, T aData) {
+ static const int size = 32;
+ char buf[size];
+
+ SprintfLiteral(buf, aFormat, aData);
+
+ return moz_xstrdup(buf);
+}
+
+/*****************************************************************************
+ * nsSupportsCString
+ *****************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsCString, nsISupportsCString, nsISupportsPrimitive)
+
+NS_IMETHODIMP
+nsSupportsCString::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_CSTRING;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsCString::GetData(nsACString& aData) {
+ aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsCString::ToString(char** aResult) {
+ *aResult = ToNewCString(mData, mozilla::fallible);
+ if (!*aResult) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsCString::SetData(const nsACString& aData) {
+ bool ok = mData.Assign(aData, mozilla::fallible);
+ if (!ok) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+/*****************************************************************************
+ * nsSupportsString
+ *****************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsString, nsISupportsString, nsISupportsPrimitive)
+
+NS_IMETHODIMP
+nsSupportsString::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_STRING;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsString::GetData(nsAString& aData) {
+ aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsString::ToString(char16_t** aResult) {
+ *aResult = ToNewUnicode(mData, mozilla::fallible);
+ if (!*aResult) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsString::SetData(const nsAString& aData) {
+ bool ok = mData.Assign(aData, mozilla::fallible);
+ if (!ok) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRBool, nsISupportsPRBool, nsISupportsPrimitive)
+
+nsSupportsPRBool::nsSupportsPRBool() : mData(false) {}
+
+NS_IMETHODIMP
+nsSupportsPRBool::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRBOOL;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRBool::GetData(bool* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRBool::SetData(bool aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRBool::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = moz_xstrdup(mData ? "true" : "false");
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRUint8, nsISupportsPRUint8, nsISupportsPrimitive)
+
+nsSupportsPRUint8::nsSupportsPRUint8() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRUint8::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRUINT8;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint8::GetData(uint8_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint8::SetData(uint8_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint8::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%u", static_cast<unsigned int>(mData));
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRUint16, nsISupportsPRUint16, nsISupportsPrimitive)
+
+nsSupportsPRUint16::nsSupportsPRUint16() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRUint16::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRUINT16;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint16::GetData(uint16_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint16::SetData(uint16_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint16::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%u", static_cast<unsigned int>(mData));
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRUint32, nsISupportsPRUint32, nsISupportsPrimitive)
+
+nsSupportsPRUint32::nsSupportsPRUint32() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRUint32::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRUINT32;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint32::GetData(uint32_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint32::SetData(uint32_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint32::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%u", mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRUint64, nsISupportsPRUint64, nsISupportsPrimitive)
+
+nsSupportsPRUint64::nsSupportsPRUint64() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRUint64::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRUINT64;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint64::GetData(uint64_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint64::SetData(uint64_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRUint64::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%llu", mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRTime, nsISupportsPRTime, nsISupportsPrimitive)
+
+nsSupportsPRTime::nsSupportsPRTime() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRTime::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRTIME;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRTime::GetData(PRTime* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRTime::SetData(PRTime aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRTime::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%" PRIu64, mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsChar, nsISupportsChar, nsISupportsPrimitive)
+
+nsSupportsChar::nsSupportsChar() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsChar::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_CHAR;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsChar::GetData(char* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsChar::SetData(char aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsChar::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = static_cast<char*>(moz_xmalloc(2 * sizeof(char)));
+ *aResult[0] = mData;
+ *aResult[1] = '\0';
+
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRInt16, nsISupportsPRInt16, nsISupportsPrimitive)
+
+nsSupportsPRInt16::nsSupportsPRInt16() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRInt16::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRINT16;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt16::GetData(int16_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt16::SetData(int16_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt16::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%d", static_cast<int>(mData));
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRInt32, nsISupportsPRInt32, nsISupportsPrimitive)
+
+nsSupportsPRInt32::nsSupportsPRInt32() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRInt32::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRINT32;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt32::GetData(int32_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt32::SetData(int32_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt32::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%d", mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsPRInt64, nsISupportsPRInt64, nsISupportsPrimitive)
+
+nsSupportsPRInt64::nsSupportsPRInt64() : mData(0) {}
+
+NS_IMETHODIMP
+nsSupportsPRInt64::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_PRINT64;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt64::GetData(int64_t* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt64::SetData(int64_t aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsPRInt64::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%" PRId64, mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsFloat, nsISupportsFloat, nsISupportsPrimitive)
+
+nsSupportsFloat::nsSupportsFloat() : mData(float(0.0)) {}
+
+NS_IMETHODIMP
+nsSupportsFloat::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_FLOAT;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsFloat::GetData(float* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsFloat::SetData(float aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsFloat::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%f", static_cast<double>(mData));
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsDouble, nsISupportsDouble, nsISupportsPrimitive)
+
+nsSupportsDouble::nsSupportsDouble() : mData(double(0.0)) {}
+
+NS_IMETHODIMP
+nsSupportsDouble::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_DOUBLE;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDouble::GetData(double* aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDouble::SetData(double aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDouble::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+ *aResult = DataToString("%f", mData);
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsInterfacePointer, nsISupportsInterfacePointer,
+ nsISupportsPrimitive)
+
+nsSupportsInterfacePointer::nsSupportsInterfacePointer() : mIID(nullptr) {}
+
+nsSupportsInterfacePointer::~nsSupportsInterfacePointer() {
+ if (mIID) {
+ free(mIID);
+ }
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::GetType(uint16_t* aType) {
+ NS_ASSERTION(aType, "Bad pointer");
+ *aType = TYPE_INTERFACE_POINTER;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::GetData(nsISupports** aData) {
+ NS_ASSERTION(aData, "Bad pointer");
+ *aData = mData;
+ NS_IF_ADDREF(*aData);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::SetData(nsISupports* aData) {
+ mData = aData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::GetDataIID(nsID** aIID) {
+ NS_ASSERTION(aIID, "Bad pointer");
+
+ *aIID = mIID ? mIID->Clone() : nullptr;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::SetDataIID(const nsID* aIID) {
+ if (mIID) {
+ free(mIID);
+ }
+
+ mIID = aIID ? aIID->Clone() : nullptr;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsInterfacePointer::ToString(char** aResult) {
+ NS_ASSERTION(aResult, "Bad pointer");
+
+ // jband sez: think about asking nsIInterfaceInfoManager whether
+ // the interface has a known human-readable name
+ *aResult = moz_xstrdup("[interface pointer]");
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsSupportsDependentCString, nsISupportsCString,
+ nsISupportsPrimitive)
+
+nsSupportsDependentCString::nsSupportsDependentCString(const char* aStr)
+ : mData(aStr) {}
+
+NS_IMETHODIMP
+nsSupportsDependentCString::GetType(uint16_t* aType) {
+ if (NS_WARN_IF(!aType)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aType = TYPE_CSTRING;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDependentCString::GetData(nsACString& aData) {
+ aData = mData;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDependentCString::ToString(char** aResult) {
+ if (NS_WARN_IF(!aResult)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aResult = ToNewCString(mData, mozilla::fallible);
+ if (!*aResult) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSupportsDependentCString::SetData(const nsACString& aData) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
diff --git a/xpcom/ds/nsSupportsPrimitives.h b/xpcom/ds/nsSupportsPrimitives.h
new file mode 100644
index 0000000000..28d768a135
--- /dev/null
+++ b/xpcom/ds/nsSupportsPrimitives.h
@@ -0,0 +1,279 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsSupportsPrimitives_h__
+#define nsSupportsPrimitives_h__
+
+#include "mozilla/Attributes.h"
+
+#include "nsISupportsPrimitives.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+/***************************************************************************/
+
+class nsSupportsCString final : public nsISupportsCString {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSCSTRING
+
+ nsSupportsCString() = default;
+
+ private:
+ ~nsSupportsCString() = default;
+
+ nsCString mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsString final : public nsISupportsString {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSSTRING
+
+ nsSupportsString() = default;
+
+ private:
+ ~nsSupportsString() = default;
+
+ nsString mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRBool final : public nsISupportsPRBool {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRBOOL
+
+ nsSupportsPRBool();
+
+ private:
+ ~nsSupportsPRBool() = default;
+
+ bool mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRUint8 final : public nsISupportsPRUint8 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRUINT8
+
+ nsSupportsPRUint8();
+
+ private:
+ ~nsSupportsPRUint8() = default;
+
+ uint8_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRUint16 final : public nsISupportsPRUint16 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRUINT16
+
+ nsSupportsPRUint16();
+
+ private:
+ ~nsSupportsPRUint16() = default;
+
+ uint16_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRUint32 final : public nsISupportsPRUint32 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRUINT32
+
+ nsSupportsPRUint32();
+
+ private:
+ ~nsSupportsPRUint32() = default;
+
+ uint32_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRUint64 final : public nsISupportsPRUint64 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRUINT64
+
+ nsSupportsPRUint64();
+
+ private:
+ ~nsSupportsPRUint64() = default;
+
+ uint64_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRTime final : public nsISupportsPRTime {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRTIME
+
+ nsSupportsPRTime();
+
+ private:
+ ~nsSupportsPRTime() = default;
+
+ PRTime mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsChar final : public nsISupportsChar {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSCHAR
+
+ nsSupportsChar();
+
+ private:
+ ~nsSupportsChar() = default;
+
+ char mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRInt16 final : public nsISupportsPRInt16 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRINT16
+
+ nsSupportsPRInt16();
+
+ private:
+ ~nsSupportsPRInt16() = default;
+
+ int16_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRInt32 final : public nsISupportsPRInt32 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRINT32
+
+ nsSupportsPRInt32();
+
+ private:
+ ~nsSupportsPRInt32() = default;
+
+ int32_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsPRInt64 final : public nsISupportsPRInt64 {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSPRINT64
+
+ nsSupportsPRInt64();
+
+ private:
+ ~nsSupportsPRInt64() = default;
+
+ int64_t mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsFloat final : public nsISupportsFloat {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSFLOAT
+
+ nsSupportsFloat();
+
+ private:
+ ~nsSupportsFloat() = default;
+
+ float mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsDouble final : public nsISupportsDouble {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSDOUBLE
+
+ nsSupportsDouble();
+
+ private:
+ ~nsSupportsDouble() = default;
+
+ double mData;
+};
+
+/***************************************************************************/
+
+class nsSupportsInterfacePointer final : public nsISupportsInterfacePointer {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSINTERFACEPOINTER
+
+ nsSupportsInterfacePointer();
+
+ private:
+ ~nsSupportsInterfacePointer();
+
+ nsCOMPtr<nsISupports> mData;
+ nsID* mIID;
+};
+
+/***************************************************************************/
+
+/**
+ * Wraps a static const char* buffer for use with nsISupportsCString
+ *
+ * Only use this class with static buffers, or arena-allocated buffers of
+ * permanent lifetime!
+ */
+class nsSupportsDependentCString final : public nsISupportsCString {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSISUPPORTSPRIMITIVE
+ NS_DECL_NSISUPPORTSCSTRING
+
+ explicit nsSupportsDependentCString(const char* aStr);
+
+ private:
+ ~nsSupportsDependentCString() = default;
+
+ nsDependentCString mData;
+};
+
+#endif /* nsSupportsPrimitives_h__ */
diff --git a/xpcom/ds/nsTArray-inl.h b/xpcom/ds/nsTArray-inl.h
new file mode 100644
index 0000000000..801d3fab01
--- /dev/null
+++ b/xpcom/ds/nsTArray-inl.h
@@ -0,0 +1,691 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTArray_h__
+# error "Don't include this file directly"
+#endif
+
+// NOTE: We don't use MOZ_COUNT_CTOR/MOZ_COUNT_DTOR to perform leak checking of
+// nsTArray_base objects intentionally for the following reasons:
+// * The leak logging isn't as useful as other types of logging, as
+// nsTArray_base is frequently relocated without invoking a constructor, such
+// as when stored within another nsTArray. This means that
+// XPCOM_MEM_LOG_CLASSES cannot be used to identify specific leaks of nsTArray
+// objects.
+// * The nsTArray type is layout compatible with the ThinVec crate with the
+// correct flags, and ThinVec does not currently perform leak logging.
+// This means that if a large number of arrays are transferred between Rust
+// and C++ code using ThinVec, for example within another ThinVec, they
+// will not be logged correctly and might appear as e.g. negative leaks.
+// * Leaks which have been found thanks to the leak logging added by this
+// type have often not been significant, and/or have needed to be
+// circumvented using some other mechanism. Most leaks found with this type
+// in them also include other types which will continue to be tracked.
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc, RelocationStrategy>::nsTArray_base() : mHdr(EmptyHdr()) {}
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc, RelocationStrategy>::~nsTArray_base() {
+ if (!HasEmptyHeader() && !UsesAutoArrayBuffer()) {
+ Alloc::Free(mHdr);
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc, RelocationStrategy>::nsTArray_base(const nsTArray_base&)
+ : mHdr(EmptyHdr()) {
+ // Actual copying happens through nsTArray_CopyEnabler, we just need to do the
+ // initialization of mHdr.
+}
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc, RelocationStrategy>&
+nsTArray_base<Alloc, RelocationStrategy>::operator=(const nsTArray_base&) {
+ // Actual copying happens through nsTArray_CopyEnabler, so do nothing here (do
+ // not copy mHdr).
+ return *this;
+}
+
+template <class Alloc, class RelocationStrategy>
+const nsTArrayHeader*
+nsTArray_base<Alloc, RelocationStrategy>::GetAutoArrayBufferUnsafe(
+ size_t aElemAlign) const {
+ // Assuming |this| points to an nsAutoArray, we want to get a pointer to
+ // mAutoBuf. So just cast |this| to nsAutoArray* and read &mAutoBuf!
+
+ const void* autoBuf =
+ &reinterpret_cast<const AutoTArray<nsTArray<uint32_t>, 1>*>(this)
+ ->mAutoBuf;
+
+ // If we're on a 32-bit system and aElemAlign is 8, we need to adjust our
+ // pointer to take into account the extra alignment in the auto array.
+
+ static_assert(
+ sizeof(void*) != 4 || (MOZ_ALIGNOF(mozilla::AlignedElem<8>) == 8 &&
+ sizeof(AutoTArray<mozilla::AlignedElem<8>, 1>) ==
+ sizeof(void*) + sizeof(nsTArrayHeader) + 4 +
+ sizeof(mozilla::AlignedElem<8>)),
+ "auto array padding wasn't what we expected");
+
+ // We don't support alignments greater than 8 bytes.
+ MOZ_ASSERT(aElemAlign <= 4 || aElemAlign == 8, "unsupported alignment.");
+ if (sizeof(void*) == 4 && aElemAlign == 8) {
+ autoBuf = reinterpret_cast<const char*>(autoBuf) + 4;
+ }
+
+ return reinterpret_cast<const Header*>(autoBuf);
+}
+
+template <class Alloc, class RelocationStrategy>
+bool nsTArray_base<Alloc, RelocationStrategy>::UsesAutoArrayBuffer() const {
+ if (!mHdr->mIsAutoArray) {
+ return false;
+ }
+
+ // This is nuts. If we were sane, we'd pass aElemAlign as a parameter to
+ // this function. Unfortunately this function is called in nsTArray_base's
+ // destructor, at which point we don't know value_type's alignment.
+ //
+ // We'll fall on our face and return true when we should say false if
+ //
+ // * we're not using our auto buffer,
+ // * aElemAlign == 4, and
+ // * mHdr == GetAutoArrayBuffer(8).
+ //
+ // This could happen if |*this| lives on the heap and malloc allocated our
+ // buffer on the heap adjacent to |*this|.
+ //
+ // However, we can show that this can't happen. If |this| is an auto array
+ // (as we ensured at the beginning of the method), GetAutoArrayBuffer(8)
+ // always points to memory owned by |*this|, because (as we assert below)
+ //
+ // * GetAutoArrayBuffer(8) is at most 4 bytes past GetAutoArrayBuffer(4),
+ // and
+ // * sizeof(nsTArrayHeader) > 4.
+ //
+ // Since AutoTArray always contains an nsTArrayHeader,
+ // GetAutoArrayBuffer(8) will always point inside the auto array object,
+ // even if it doesn't point at the beginning of the header.
+ //
+ // Note that this means that we can't store elements with alignment 16 in an
+ // nsTArray, because GetAutoArrayBuffer(16) could lie outside the memory
+ // owned by this AutoTArray. We statically assert that value_type's
+ // alignment is 8 bytes or less in AutoTArray.
+
+ static_assert(sizeof(nsTArrayHeader) > 4, "see comment above");
+
+#ifdef DEBUG
+ ptrdiff_t diff = reinterpret_cast<const char*>(GetAutoArrayBuffer(8)) -
+ reinterpret_cast<const char*>(GetAutoArrayBuffer(4));
+ MOZ_ASSERT(diff >= 0 && diff <= 4,
+ "GetAutoArrayBuffer doesn't do what we expect.");
+#endif
+
+ return mHdr == GetAutoArrayBuffer(4) || mHdr == GetAutoArrayBuffer(8);
+}
+
+// defined in nsTArray.cpp
+bool IsTwiceTheRequiredBytesRepresentableAsUint32(size_t aCapacity,
+ size_t aElemSize);
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, RelocationStrategy>::ExtendCapacity(size_type aLength,
+ size_type aCount,
+ size_type aElemSize) {
+ mozilla::CheckedInt<size_type> newLength = aLength;
+ newLength += aCount;
+
+ if (!newLength.isValid()) {
+ return ActualAlloc::FailureResult();
+ }
+
+ return this->EnsureCapacity<ActualAlloc>(newLength.value(), aElemSize);
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, RelocationStrategy>::EnsureCapacity(size_type aCapacity,
+ size_type aElemSize) {
+ // This should be the most common case so test this first
+ if (aCapacity <= mHdr->mCapacity) {
+ return ActualAlloc::SuccessResult();
+ }
+
+ // If the requested memory allocation exceeds size_type(-1)/2, then
+ // our doubling algorithm may not be able to allocate it.
+ // Additionally, if it exceeds uint32_t(-1) then we couldn't fit in the
+ // Header::mCapacity member. Just bail out in cases like that. We don't want
+ // to be allocating 2 GB+ arrays anyway.
+ if (!IsTwiceTheRequiredBytesRepresentableAsUint32(aCapacity, aElemSize)) {
+ ActualAlloc::SizeTooBig((size_t)aCapacity * aElemSize);
+ return ActualAlloc::FailureResult();
+ }
+
+ size_t reqSize = sizeof(Header) + aCapacity * aElemSize;
+
+ if (HasEmptyHeader()) {
+ // Malloc() new data
+ Header* header = static_cast<Header*>(ActualAlloc::Malloc(reqSize));
+ if (!header) {
+ return ActualAlloc::FailureResult();
+ }
+ header->mLength = 0;
+ header->mCapacity = aCapacity;
+ header->mIsAutoArray = 0;
+ mHdr = header;
+
+ return ActualAlloc::SuccessResult();
+ }
+
+ // We increase our capacity so that the allocated buffer grows exponentially,
+ // which gives us amortized O(1) appending. Below the threshold, we use
+ // powers-of-two. Above the threshold, we grow by at least 1.125, rounding up
+ // to the nearest MiB.
+ const size_t slowGrowthThreshold = 8 * 1024 * 1024;
+
+ size_t bytesToAlloc;
+ if (reqSize >= slowGrowthThreshold) {
+ size_t currSize = sizeof(Header) + Capacity() * aElemSize;
+ size_t minNewSize = currSize + (currSize >> 3); // multiply by 1.125
+ bytesToAlloc = reqSize > minNewSize ? reqSize : minNewSize;
+
+ // Round up to the next multiple of MiB.
+ const size_t MiB = 1 << 20;
+ bytesToAlloc = MiB * ((bytesToAlloc + MiB - 1) / MiB);
+ } else {
+ // Round up to the next power of two.
+ bytesToAlloc = mozilla::RoundUpPow2(reqSize);
+ }
+
+ Header* header;
+ if (UsesAutoArrayBuffer() || !RelocationStrategy::allowRealloc) {
+ // Malloc() and copy
+ header = static_cast<Header*>(ActualAlloc::Malloc(bytesToAlloc));
+ if (!header) {
+ return ActualAlloc::FailureResult();
+ }
+
+ RelocationStrategy::RelocateNonOverlappingRegionWithHeader(
+ header, mHdr, Length(), aElemSize);
+
+ if (!UsesAutoArrayBuffer()) {
+ ActualAlloc::Free(mHdr);
+ }
+ } else {
+ // Realloc() existing data
+ header = static_cast<Header*>(ActualAlloc::Realloc(mHdr, bytesToAlloc));
+ if (!header) {
+ return ActualAlloc::FailureResult();
+ }
+ }
+
+ // How many elements can we fit in bytesToAlloc?
+ size_t newCapacity = (bytesToAlloc - sizeof(Header)) / aElemSize;
+ MOZ_ASSERT(newCapacity >= aCapacity, "Didn't enlarge the array enough!");
+ header->mCapacity = newCapacity;
+
+ mHdr = header;
+
+ return ActualAlloc::SuccessResult();
+}
+
+// We don't need use Alloc template parameter specified here because failure to
+// shrink the capacity will leave the array unchanged.
+template <class Alloc, class RelocationStrategy>
+void nsTArray_base<Alloc, RelocationStrategy>::ShrinkCapacity(
+ size_type aElemSize, size_t aElemAlign) {
+ if (HasEmptyHeader() || UsesAutoArrayBuffer()) {
+ return;
+ }
+
+ if (mHdr->mLength >= mHdr->mCapacity) { // should never be greater than...
+ return;
+ }
+
+ size_type length = Length();
+
+ if (IsAutoArray() && GetAutoArrayBuffer(aElemAlign)->mCapacity >= length) {
+ Header* header = GetAutoArrayBuffer(aElemAlign);
+
+ // Move the data, but don't copy the header to avoid overwriting mCapacity.
+ header->mLength = length;
+ RelocationStrategy::RelocateNonOverlappingRegion(header + 1, mHdr + 1,
+ length, aElemSize);
+
+ nsTArrayFallibleAllocator::Free(mHdr);
+ mHdr = header;
+ return;
+ }
+
+ if (length == 0) {
+ MOZ_ASSERT(!IsAutoArray(), "autoarray should have fit 0 elements");
+ nsTArrayFallibleAllocator::Free(mHdr);
+ mHdr = EmptyHdr();
+ return;
+ }
+
+ size_type newSize = sizeof(Header) + length * aElemSize;
+
+ Header* newHeader;
+ if (!RelocationStrategy::allowRealloc) {
+ // Malloc() and copy.
+ newHeader =
+ static_cast<Header*>(nsTArrayFallibleAllocator::Malloc(newSize));
+ if (!newHeader) {
+ return;
+ }
+
+ RelocationStrategy::RelocateNonOverlappingRegionWithHeader(
+ newHeader, mHdr, Length(), aElemSize);
+
+ nsTArrayFallibleAllocator::Free(mHdr);
+ } else {
+ // Realloc() existing data.
+ newHeader =
+ static_cast<Header*>(nsTArrayFallibleAllocator::Realloc(mHdr, newSize));
+ if (!newHeader) {
+ return;
+ }
+ }
+
+ mHdr = newHeader;
+ mHdr->mCapacity = length;
+}
+
+template <class Alloc, class RelocationStrategy>
+void nsTArray_base<Alloc, RelocationStrategy>::ShrinkCapacityToZero(
+ size_type aElemSize, size_t aElemAlign) {
+ MOZ_ASSERT(mHdr->mLength == 0);
+
+ if (HasEmptyHeader() || UsesAutoArrayBuffer()) {
+ return;
+ }
+
+ const bool isAutoArray = IsAutoArray();
+
+ nsTArrayFallibleAllocator::Free(mHdr);
+
+ if (isAutoArray) {
+ mHdr = GetAutoArrayBufferUnsafe(aElemAlign);
+ mHdr->mLength = 0;
+ } else {
+ mHdr = EmptyHdr();
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+void nsTArray_base<Alloc, RelocationStrategy>::ShiftData(index_type aStart,
+ size_type aOldLen,
+ size_type aNewLen,
+ size_type aElemSize,
+ size_t aElemAlign) {
+ if (aOldLen == aNewLen) {
+ return;
+ }
+
+ // Determine how many elements need to be shifted
+ size_type num = mHdr->mLength - (aStart + aOldLen);
+
+ // Compute the resulting length of the array
+ mHdr->mLength += aNewLen - aOldLen;
+ if (mHdr->mLength == 0) {
+ ShrinkCapacityToZero(aElemSize, aElemAlign);
+ } else {
+ // Maybe nothing needs to be shifted
+ if (num == 0) {
+ return;
+ }
+ // Perform shift (change units to bytes first)
+ aStart *= aElemSize;
+ aNewLen *= aElemSize;
+ aOldLen *= aElemSize;
+ char* baseAddr = reinterpret_cast<char*>(mHdr + 1) + aStart;
+ RelocationStrategy::RelocateOverlappingRegion(
+ baseAddr + aNewLen, baseAddr + aOldLen, num, aElemSize);
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+void nsTArray_base<Alloc, RelocationStrategy>::SwapFromEnd(index_type aStart,
+ size_type aCount,
+ size_type aElemSize,
+ size_t aElemAlign) {
+ // This method is part of the implementation of
+ // nsTArray::SwapRemoveElement{s,}At. For more information, read the
+ // documentation on that method.
+ if (aCount == 0) {
+ return;
+ }
+
+ // We are going to be removing aCount elements. Update our length to point to
+ // the new end of the array.
+ size_type oldLength = mHdr->mLength;
+ mHdr->mLength -= aCount;
+
+ if (mHdr->mLength == 0) {
+ // If we have no elements remaining in the array, we can free our buffer.
+ ShrinkCapacityToZero(aElemSize, aElemAlign);
+ return;
+ }
+
+ // Determine how many elements we need to move from the end of the array into
+ // the now-removed section. This will either be the number of elements which
+ // were removed (if there are more elements in the tail of the array), or the
+ // entire tail of the array, whichever is smaller.
+ size_type relocCount = std::min(aCount, mHdr->mLength - aStart);
+ if (relocCount == 0) {
+ return;
+ }
+
+ // Move the elements which are now stranded after the end of the array back
+ // into the now-vacated memory.
+ index_type sourceBytes = (oldLength - relocCount) * aElemSize;
+ index_type destBytes = aStart * aElemSize;
+
+ // Perform the final copy. This is guaranteed to be a non-overlapping copy
+ // as our source contains only still-valid entries, and the destination
+ // contains only invalid entries which need to be overwritten.
+ MOZ_ASSERT(sourceBytes >= destBytes,
+ "The source should be after the destination.");
+ MOZ_ASSERT(sourceBytes - destBytes >= relocCount * aElemSize,
+ "The range should be nonoverlapping");
+
+ char* baseAddr = reinterpret_cast<char*>(mHdr + 1);
+ RelocationStrategy::RelocateNonOverlappingRegion(
+ baseAddr + destBytes, baseAddr + sourceBytes, relocCount, aElemSize);
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, RelocationStrategy>::InsertSlotsAt(index_type aIndex,
+ size_type aCount,
+ size_type aElemSize,
+ size_t aElemAlign) {
+ if (MOZ_UNLIKELY(aIndex > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
+ }
+
+ if (!ActualAlloc::Successful(
+ this->ExtendCapacity<ActualAlloc>(Length(), aCount, aElemSize))) {
+ return ActualAlloc::FailureResult();
+ }
+
+ // Move the existing elements as needed. Note that this will
+ // change our mLength, so no need to call IncrementLength.
+ ShiftData<ActualAlloc>(aIndex, 0, aCount, aElemSize, aElemAlign);
+
+ return ActualAlloc::SuccessResult();
+}
+
+// nsTArray_base::IsAutoArrayRestorer is an RAII class which takes
+// |nsTArray_base &array| in its constructor. When it's destructed, it ensures
+// that
+//
+// * array.mIsAutoArray has the same value as it did when we started, and
+// * if array has an auto buffer and mHdr would otherwise point to
+// sEmptyTArrayHeader, array.mHdr points to array's auto buffer.
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc, RelocationStrategy>::IsAutoArrayRestorer::
+ IsAutoArrayRestorer(nsTArray_base<Alloc, RelocationStrategy>& aArray,
+ size_t aElemAlign)
+ : mArray(aArray), mElemAlign(aElemAlign), mIsAuto(aArray.IsAutoArray()) {}
+
+template <class Alloc, class RelocationStrategy>
+nsTArray_base<Alloc,
+ RelocationStrategy>::IsAutoArrayRestorer::~IsAutoArrayRestorer() {
+ // Careful: We don't want to set mIsAutoArray = 1 on sEmptyTArrayHeader.
+ if (mIsAuto && mArray.HasEmptyHeader()) {
+ // Call GetAutoArrayBufferUnsafe() because GetAutoArrayBuffer() asserts
+ // that mHdr->mIsAutoArray is true, which surely isn't the case here.
+ mArray.mHdr = mArray.GetAutoArrayBufferUnsafe(mElemAlign);
+ mArray.mHdr->mLength = 0;
+ } else if (!mArray.HasEmptyHeader()) {
+ mArray.mHdr->mIsAutoArray = mIsAuto;
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc, class Allocator>
+typename ActualAlloc::ResultTypeProxy
+nsTArray_base<Alloc, RelocationStrategy>::SwapArrayElements(
+ nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
+ size_t aElemAlign) {
+ // EnsureNotUsingAutoArrayBuffer will set mHdr = sEmptyTArrayHeader even if we
+ // have an auto buffer. We need to point mHdr back to our auto buffer before
+ // we return, otherwise we'll forget that we have an auto buffer at all!
+ // IsAutoArrayRestorer takes care of this for us.
+
+ IsAutoArrayRestorer ourAutoRestorer(*this, aElemAlign);
+ typename nsTArray_base<Allocator, RelocationStrategy>::IsAutoArrayRestorer
+ otherAutoRestorer(aOther, aElemAlign);
+
+ // If neither array uses an auto buffer which is big enough to store the
+ // other array's elements, then ensure that both arrays use malloc'ed storage
+ // and swap their mHdr pointers.
+ if ((!UsesAutoArrayBuffer() || Capacity() < aOther.Length()) &&
+ (!aOther.UsesAutoArrayBuffer() || aOther.Capacity() < Length())) {
+ if (!EnsureNotUsingAutoArrayBuffer<ActualAlloc>(aElemSize) ||
+ !aOther.template EnsureNotUsingAutoArrayBuffer<ActualAlloc>(
+ aElemSize)) {
+ return ActualAlloc::FailureResult();
+ }
+
+ Header* temp = mHdr;
+ mHdr = aOther.mHdr;
+ aOther.mHdr = temp;
+
+ return ActualAlloc::SuccessResult();
+ }
+
+ // Swap the two arrays by copying, since at least one is using an auto
+ // buffer which is large enough to hold all of the aOther's elements. We'll
+ // copy the shorter array into temporary storage.
+ //
+ // (We could do better than this in some circumstances. Suppose we're
+ // swapping arrays X and Y. X has space for 2 elements in its auto buffer,
+ // but currently has length 4, so it's using malloc'ed storage. Y has length
+ // 2. When we swap X and Y, we don't need to use a temporary buffer; we can
+ // write Y straight into X's auto buffer, write X's malloc'ed buffer on top
+ // of Y, and then switch X to using its auto buffer.)
+
+ if (!ActualAlloc::Successful(
+ EnsureCapacity<ActualAlloc>(aOther.Length(), aElemSize)) ||
+ !Allocator::Successful(
+ aOther.template EnsureCapacity<Allocator>(Length(), aElemSize))) {
+ return ActualAlloc::FailureResult();
+ }
+
+ // The EnsureCapacity calls above shouldn't have caused *both* arrays to
+ // switch from their auto buffers to malloc'ed space.
+ MOZ_ASSERT(UsesAutoArrayBuffer() || aOther.UsesAutoArrayBuffer(),
+ "One of the arrays should be using its auto buffer.");
+
+ size_type smallerLength = XPCOM_MIN(Length(), aOther.Length());
+ size_type largerLength = XPCOM_MAX(Length(), aOther.Length());
+ void* smallerElements;
+ void* largerElements;
+ if (Length() <= aOther.Length()) {
+ smallerElements = Hdr() + 1;
+ largerElements = aOther.Hdr() + 1;
+ } else {
+ smallerElements = aOther.Hdr() + 1;
+ largerElements = Hdr() + 1;
+ }
+
+ // Allocate temporary storage for the smaller of the two arrays. We want to
+ // allocate this space on the stack, if it's not too large. Sounds like a
+ // job for AutoTArray! (One of the two arrays we're swapping is using an
+ // auto buffer, so we're likely not allocating a lot of space here. But one
+ // could, in theory, allocate a huge AutoTArray on the heap.)
+ AutoTArray<uint8_t, 64 * sizeof(void*)> temp;
+ if (!ActualAlloc::Successful(temp.template EnsureCapacity<ActualAlloc>(
+ smallerLength * aElemSize, sizeof(uint8_t)))) {
+ return ActualAlloc::FailureResult();
+ }
+
+ RelocationStrategy::RelocateNonOverlappingRegion(
+ temp.Elements(), smallerElements, smallerLength, aElemSize);
+ RelocationStrategy::RelocateNonOverlappingRegion(
+ smallerElements, largerElements, largerLength, aElemSize);
+ RelocationStrategy::RelocateNonOverlappingRegion(
+ largerElements, temp.Elements(), smallerLength, aElemSize);
+
+ // Swap the arrays' lengths.
+ MOZ_ASSERT((aOther.Length() == 0 || !HasEmptyHeader()) &&
+ (Length() == 0 || !aOther.HasEmptyHeader()),
+ "Don't set sEmptyTArrayHeader's length.");
+ size_type tempLength = Length();
+
+ // Avoid writing to EmptyHdr, since it can trigger false
+ // positives with TSan.
+ if (!HasEmptyHeader()) {
+ mHdr->mLength = aOther.Length();
+ }
+ if (!aOther.HasEmptyHeader()) {
+ aOther.mHdr->mLength = tempLength;
+ }
+
+ return ActualAlloc::SuccessResult();
+}
+
+template <class Alloc, class RelocationStrategy>
+template <class Allocator>
+void nsTArray_base<Alloc, RelocationStrategy>::MoveInit(
+ nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
+ size_t aElemAlign) {
+ // This method is similar to SwapArrayElements, but specialized for the case
+ // where the target array is empty with no allocated heap storage. It is
+ // provided and used to simplify template instantiation and enable better code
+ // generation.
+
+ MOZ_ASSERT(Length() == 0);
+ MOZ_ASSERT(Capacity() == 0 || (IsAutoArray() && UsesAutoArrayBuffer()));
+
+ // EnsureNotUsingAutoArrayBuffer will set mHdr = sEmptyTArrayHeader even if we
+ // have an auto buffer. We need to point mHdr back to our auto buffer before
+ // we return, otherwise we'll forget that we have an auto buffer at all!
+ // IsAutoArrayRestorer takes care of this for us.
+
+ IsAutoArrayRestorer ourAutoRestorer(*this, aElemAlign);
+ typename nsTArray_base<Allocator, RelocationStrategy>::IsAutoArrayRestorer
+ otherAutoRestorer(aOther, aElemAlign);
+
+ // If neither array uses an auto buffer which is big enough to store the
+ // other array's elements, then ensure that both arrays use malloc'ed storage
+ // and swap their mHdr pointers.
+ if ((!IsAutoArray() || Capacity() < aOther.Length()) &&
+ !aOther.UsesAutoArrayBuffer()) {
+ mHdr = aOther.mHdr;
+
+ aOther.mHdr = EmptyHdr();
+
+ return;
+ }
+
+ // Move the data by copying, since at least one has an auto
+ // buffer which is large enough to hold all of the aOther's elements.
+
+ EnsureCapacity<nsTArrayInfallibleAllocator>(aOther.Length(), aElemSize);
+
+ // The EnsureCapacity calls above shouldn't have caused *both* arrays to
+ // switch from their auto buffers to malloc'ed space.
+ MOZ_ASSERT(UsesAutoArrayBuffer() || aOther.UsesAutoArrayBuffer(),
+ "One of the arrays should be using its auto buffer.");
+
+ RelocationStrategy::RelocateNonOverlappingRegion(Hdr() + 1, aOther.Hdr() + 1,
+ aOther.Length(), aElemSize);
+
+ // Swap the arrays' lengths.
+ MOZ_ASSERT((aOther.Length() == 0 || !HasEmptyHeader()) &&
+ (Length() == 0 || !aOther.HasEmptyHeader()),
+ "Don't set sEmptyTArrayHeader's length.");
+
+ // Avoid writing to EmptyHdr, since it can trigger false
+ // positives with TSan.
+ if (!HasEmptyHeader()) {
+ mHdr->mLength = aOther.Length();
+ }
+ if (!aOther.HasEmptyHeader()) {
+ aOther.mHdr->mLength = 0;
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+template <class Allocator>
+void nsTArray_base<Alloc, RelocationStrategy>::MoveConstructNonAutoArray(
+ nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
+ size_t aElemAlign) {
+ // We know that we are not an (Copyable)AutoTArray and we know that we are
+ // empty, so don't use SwapArrayElements which doesn't know either of these
+ // facts and is very complex.
+
+ if (aOther.IsEmpty()) {
+ return;
+ }
+
+ // aOther might be an (Copyable)AutoTArray though, and it might use its inline
+ // buffer.
+ const bool otherUsesAutoArrayBuffer = aOther.UsesAutoArrayBuffer();
+ if (otherUsesAutoArrayBuffer) {
+ // Use nsTArrayInfallibleAllocator regardless of Alloc because this is
+ // called from a move constructor, which cannot report an error to the
+ // caller.
+ aOther.template EnsureNotUsingAutoArrayBuffer<nsTArrayInfallibleAllocator>(
+ aElemSize);
+ }
+
+ const bool otherIsAuto = otherUsesAutoArrayBuffer || aOther.IsAutoArray();
+ mHdr = aOther.mHdr;
+ // We might write to mHdr, so ensure it's not the static empty header. aOther
+ // shouldn't have been empty if we get here anyway.
+ MOZ_ASSERT(!HasEmptyHeader());
+
+ if (otherIsAuto) {
+ mHdr->mIsAutoArray = false;
+ aOther.mHdr = aOther.GetAutoArrayBufferUnsafe(aElemAlign);
+ aOther.mHdr->mLength = 0;
+ } else {
+ aOther.mHdr = aOther.EmptyHdr();
+ }
+}
+
+template <class Alloc, class RelocationStrategy>
+template <typename ActualAlloc>
+bool nsTArray_base<Alloc, RelocationStrategy>::EnsureNotUsingAutoArrayBuffer(
+ size_type aElemSize) {
+ if (UsesAutoArrayBuffer()) {
+ // If you call this on a 0-length array, we'll set that array's mHdr to
+ // sEmptyTArrayHeader, in flagrant violation of the AutoTArray invariants.
+ // It's up to you to set it back! (If you don't, the AutoTArray will
+ // forget that it has an auto buffer.)
+ if (Length() == 0) {
+ mHdr = EmptyHdr();
+ return true;
+ }
+
+ size_type size = sizeof(Header) + Length() * aElemSize;
+
+ Header* header = static_cast<Header*>(ActualAlloc::Malloc(size));
+ if (!header) {
+ return false;
+ }
+
+ RelocationStrategy::RelocateNonOverlappingRegionWithHeader(
+ header, mHdr, Length(), aElemSize);
+ header->mCapacity = Length();
+ mHdr = header;
+ }
+
+ return true;
+}
diff --git a/xpcom/ds/nsTArray.cpp b/xpcom/ds/nsTArray.cpp
new file mode 100644
index 0000000000..50326fb331
--- /dev/null
+++ b/xpcom/ds/nsTArray.cpp
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string.h>
+#include "nsTArray.h"
+#include "nsXPCOM.h"
+#include "nsCycleCollectionNoteChild.h"
+#include "nsDebug.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/IntegerPrintfMacros.h"
+
+// Ensure this is sufficiently aligned so that Elements() and co don't create
+// unaligned pointers, or slices with unaligned pointers for empty arrays, see
+// https://github.com/servo/servo/issues/22613.
+alignas(8) const nsTArrayHeader sEmptyTArrayHeader = {0, 0, 0};
+
+bool IsTwiceTheRequiredBytesRepresentableAsUint32(size_t aCapacity,
+ size_t aElemSize) {
+ using mozilla::CheckedUint32;
+ return ((CheckedUint32(aCapacity) * aElemSize) * 2).isValid();
+}
+
+void ::detail::SetCycleCollectionArrayFlag(uint32_t& aFlags) {
+ aFlags |= CycleCollectionEdgeNameArrayFlag;
+}
diff --git a/xpcom/ds/nsTArray.h b/xpcom/ds/nsTArray.h
new file mode 100644
index 0000000000..ed8c05943c
--- /dev/null
+++ b/xpcom/ds/nsTArray.h
@@ -0,0 +1,3345 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTArray_h__
+#define nsTArray_h__
+
+#include <string.h>
+
+#include <algorithm>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <new>
+#include <ostream>
+#include <type_traits>
+#include <utility>
+
+#include "mozilla/Alignment.h"
+#include "mozilla/ArrayIterator.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/BinarySearch.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/FunctionTypeTraits.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/Span.h"
+#include "mozilla/fallible.h"
+#include "mozilla/mozalloc.h"
+#include "nsAlgorithm.h"
+#include "nsDebug.h"
+#include "nsISupports.h"
+#include "nsQuickSort.h"
+#include "nsRegionFwd.h"
+#include "nsTArrayForwardDeclare.h"
+
+namespace JS {
+template <class T>
+class Heap;
+} /* namespace JS */
+
+class nsCycleCollectionTraversalCallback;
+class nsRegion;
+
+namespace mozilla::a11y {
+class BatchData;
+}
+
+namespace mozilla {
+namespace layers {
+class Animation;
+class FrameStats;
+struct PropertyAnimationGroup;
+struct TileClient;
+} // namespace layers
+} // namespace mozilla
+
+namespace mozilla {
+struct SerializedStructuredCloneBuffer;
+class SourceBufferTask;
+} // namespace mozilla
+
+namespace mozilla::dom::binding_detail {
+template <typename, typename>
+class RecordEntry;
+}
+
+namespace mozilla::dom::ipc {
+class StructuredCloneData;
+} // namespace mozilla::dom::ipc
+
+namespace mozilla::dom {
+class ClonedMessageData;
+class MessageData;
+class MessagePortIdentifier;
+struct MozPluginParameter;
+template <typename T>
+struct Nullable;
+class OwningFileOrDirectory;
+class OwningStringOrBooleanOrObject;
+class OwningUTF8StringOrDouble;
+class Pref;
+class RefMessageData;
+class ResponsiveImageCandidate;
+class ServiceWorkerRegistrationData;
+namespace indexedDB {
+class SerializedStructuredCloneReadInfo;
+class ObjectStoreCursorResponse;
+class IndexCursorResponse;
+} // namespace indexedDB
+} // namespace mozilla::dom
+
+namespace mozilla::ipc {
+class ContentSecurityPolicy;
+template <class T>
+class Endpoint;
+} // namespace mozilla::ipc
+
+class JSStructuredCloneData;
+
+template <class T>
+class RefPtr;
+
+//
+// nsTArray<E> is a resizable array class, like std::vector.
+//
+// Unlike std::vector, which follows C++'s construction/destruction rules,
+// By default, nsTArray assumes that instances of E can be relocated safely
+// using memory utils (memcpy/memmove).
+//
+// The public classes defined in this header are
+//
+// nsTArray<E>,
+// CopyableTArray<E>,
+// FallibleTArray<E>,
+// AutoTArray<E, N>,
+// CopyableAutoTArray<E, N>
+//
+// nsTArray, CopyableTArray, AutoTArray and CopyableAutoTArray are infallible by
+// default. To opt-in to fallible behaviour, use the `mozilla::fallible`
+// parameter and check the return value.
+//
+// CopyableTArray and CopyableAutoTArray< are copy-constructible and
+// copy-assignable. Use these only when syntactically necessary to avoid implcit
+// unintentional copies. nsTArray/AutoTArray can be conveniently copied using
+// the Clone() member function. Consider using std::move where possible.
+//
+// If you just want to declare the nsTArray types (e.g., if you're in a header
+// file and don't need the full nsTArray definitions) consider including
+// nsTArrayForwardDeclare.h instead of nsTArray.h.
+//
+// The template parameter E specifies the type of the elements and has the
+// following requirements:
+//
+// E MUST be safely memmove()'able.
+// E MUST define a copy-constructor.
+// E MAY define operator< for sorting.
+// E MAY define operator== for searching.
+//
+// (Note that the memmove requirement may be relaxed for certain types - see
+// nsTArray_RelocationStrategy below.)
+//
+// There is a public type value_type defined as E within each array class, and
+// we reference the type under this name below.
+//
+// For member functions taking a Comparator instance, Comparator must be either
+// a functor with a tri-state comparison function with a signature compatible to
+//
+// /** @return negative iff a < b, 0 iff a == b, positive iff a > b */
+// int (const value_type& a, const value_type& b);
+//
+// or a class defining member functions with signatures compatible to:
+//
+// class Comparator {
+// public:
+// /** @return True if the elements are equals; false otherwise. */
+// bool Equals(const value_type& a, const value_type& b) const;
+//
+// /** @return True if (a < b); false otherwise. */
+// bool LessThan(const value_type& a, const value_type& b) const;
+// };
+//
+// The Equals member function is used for searching, and the LessThan member
+// function is used for searching and sorting. Note that some member functions,
+// e.g. Compare, are templates where a different type Item can be used for the
+// element to compare to. In that case, the signatures must be compatible to
+// allow those comparisons, but the details are not documented here.
+//
+
+//
+// nsTArrayFallibleResult and nsTArrayInfallibleResult types are proxy types
+// which are used because you cannot use a templated type which is bound to
+// void as an argument to a void function. In order to work around that, we
+// encode either a void or a boolean inside these proxy objects, and pass them
+// to the aforementioned function instead, and then use the type information to
+// decide what to do in the function.
+//
+// Note that public nsTArray methods should never return a proxy type. Such
+// types are only meant to be used in the internal nsTArray helper methods.
+// Public methods returning non-proxy types cannot be called from other
+// nsTArray members.
+//
+struct nsTArrayFallibleResult {
+ // Note: allows implicit conversions from and to bool
+ MOZ_IMPLICIT constexpr nsTArrayFallibleResult(bool aResult)
+ : mResult(aResult) {}
+
+ MOZ_IMPLICIT constexpr operator bool() { return mResult; }
+
+ private:
+ bool mResult;
+};
+
+struct nsTArrayInfallibleResult {};
+
+//
+// nsTArray*Allocators must all use the same |free()|, to allow swap()'ing
+// between fallible and infallible variants.
+//
+
+struct nsTArrayFallibleAllocatorBase {
+ typedef bool ResultType;
+ typedef nsTArrayFallibleResult ResultTypeProxy;
+
+ static constexpr ResultType Result(ResultTypeProxy aResult) {
+ return aResult;
+ }
+ static constexpr bool Successful(ResultTypeProxy aResult) { return aResult; }
+ static constexpr ResultTypeProxy SuccessResult() { return true; }
+ static constexpr ResultTypeProxy FailureResult() { return false; }
+ static constexpr ResultType ConvertBoolToResultType(bool aValue) {
+ return aValue;
+ }
+};
+
+struct nsTArrayInfallibleAllocatorBase {
+ typedef void ResultType;
+ typedef nsTArrayInfallibleResult ResultTypeProxy;
+
+ static constexpr ResultType Result(ResultTypeProxy aResult) {}
+ static constexpr bool Successful(ResultTypeProxy) { return true; }
+ static constexpr ResultTypeProxy SuccessResult() { return ResultTypeProxy(); }
+
+ [[noreturn]] static ResultTypeProxy FailureResult() {
+ MOZ_CRASH("Infallible nsTArray should never fail");
+ }
+
+ template <typename T>
+ static constexpr ResultType ConvertBoolToResultType(T aValue) {
+ if (!aValue) {
+ MOZ_CRASH("infallible nsTArray should never convert false to ResultType");
+ }
+ }
+
+ template <typename T>
+ static constexpr ResultType ConvertBoolToResultType(
+ const mozilla::NotNull<T>& aValue) {}
+};
+
+struct nsTArrayFallibleAllocator : nsTArrayFallibleAllocatorBase {
+ static void* Malloc(size_t aSize) { return malloc(aSize); }
+ static void* Realloc(void* aPtr, size_t aSize) {
+ return realloc(aPtr, aSize);
+ }
+
+ static void Free(void* aPtr) { free(aPtr); }
+ static void SizeTooBig(size_t) {}
+};
+
+struct nsTArrayInfallibleAllocator : nsTArrayInfallibleAllocatorBase {
+ static void* Malloc(size_t aSize) MOZ_NONNULL_RETURN {
+ return moz_xmalloc(aSize);
+ }
+ static void* Realloc(void* aPtr, size_t aSize) MOZ_NONNULL_RETURN {
+ return moz_xrealloc(aPtr, aSize);
+ }
+
+ static void Free(void* aPtr) { free(aPtr); }
+ static void SizeTooBig(size_t aSize) { NS_ABORT_OOM(aSize); }
+};
+
+// nsTArray_base stores elements into the space allocated beyond
+// sizeof(*this). This is done to minimize the size of the nsTArray
+// object when it is empty.
+struct nsTArrayHeader {
+ uint32_t mLength;
+ uint32_t mCapacity : 31;
+ uint32_t mIsAutoArray : 1;
+};
+
+extern "C" {
+extern const nsTArrayHeader sEmptyTArrayHeader;
+}
+
+namespace detail {
+// nsTArray_CopyDisabler disables copy operations.
+class nsTArray_CopyDisabler {
+ public:
+ nsTArray_CopyDisabler() = default;
+
+ nsTArray_CopyDisabler(const nsTArray_CopyDisabler&) = delete;
+ nsTArray_CopyDisabler& operator=(const nsTArray_CopyDisabler&) = delete;
+};
+
+} // namespace detail
+
+// This class provides a SafeElementAt method to nsTArray<E*> which does
+// not take a second default value parameter.
+template <class E, class Derived>
+struct nsTArray_SafeElementAtHelper : public ::detail::nsTArray_CopyDisabler {
+ typedef E* elem_type;
+ typedef size_t index_type;
+
+ // No implementation is provided for these two methods, and that is on
+ // purpose, since we don't support these functions on non-pointer type
+ // instantiations.
+ elem_type& SafeElementAt(index_type aIndex);
+ const elem_type& SafeElementAt(index_type aIndex) const;
+};
+
+template <class E, class Derived>
+struct nsTArray_SafeElementAtHelper<E*, Derived>
+ : public ::detail::nsTArray_CopyDisabler {
+ typedef E* elem_type;
+ // typedef const E* const_elem_type; XXX: see below
+ typedef size_t index_type;
+
+ elem_type SafeElementAt(index_type aIndex) {
+ return static_cast<Derived*>(this)->SafeElementAt(aIndex, nullptr);
+ }
+
+ // XXX: Probably should return const_elem_type, but callsites must be fixed.
+ // Also, the use of const_elem_type for nsTArray<xpcGCCallback> in
+ // xpcprivate.h causes build failures on Windows because xpcGCCallback is a
+ // function pointer and MSVC doesn't like qualifying it with |const|.
+ elem_type SafeElementAt(index_type aIndex) const {
+ return static_cast<const Derived*>(this)->SafeElementAt(aIndex, nullptr);
+ }
+};
+
+// E is a smart pointer type; the
+// smart pointer can act as its element_type*.
+template <class E, class Derived>
+struct nsTArray_SafeElementAtSmartPtrHelper
+ : public ::detail::nsTArray_CopyDisabler {
+ typedef typename E::element_type* elem_type;
+ typedef const typename E::element_type* const_elem_type;
+ typedef size_t index_type;
+
+ elem_type SafeElementAt(index_type aIndex) {
+ auto* derived = static_cast<Derived*>(this);
+ if (aIndex < derived->Length()) {
+ return derived->Elements()[aIndex];
+ }
+ return nullptr;
+ }
+
+ // XXX: Probably should return const_elem_type, but callsites must be fixed.
+ elem_type SafeElementAt(index_type aIndex) const {
+ auto* derived = static_cast<const Derived*>(this);
+ if (aIndex < derived->Length()) {
+ return derived->Elements()[aIndex];
+ }
+ return nullptr;
+ }
+};
+
+template <class T>
+class nsCOMPtr;
+
+template <class E, class Derived>
+struct nsTArray_SafeElementAtHelper<nsCOMPtr<E>, Derived>
+ : public nsTArray_SafeElementAtSmartPtrHelper<nsCOMPtr<E>, Derived> {};
+
+template <class E, class Derived>
+struct nsTArray_SafeElementAtHelper<RefPtr<E>, Derived>
+ : public nsTArray_SafeElementAtSmartPtrHelper<RefPtr<E>, Derived> {};
+
+namespace mozilla {
+template <class T>
+class OwningNonNull;
+} // namespace mozilla
+
+template <class E, class Derived>
+struct nsTArray_SafeElementAtHelper<mozilla::OwningNonNull<E>, Derived>
+ : public nsTArray_SafeElementAtSmartPtrHelper<mozilla::OwningNonNull<E>,
+ Derived> {};
+
+// Servo bindings.
+extern "C" void Gecko_EnsureTArrayCapacity(void* aArray, size_t aCapacity,
+ size_t aElementSize);
+extern "C" void Gecko_ClearPODTArray(void* aArray, size_t aElementSize,
+ size_t aElementAlign);
+
+//
+// This class serves as a base class for nsTArray. It shouldn't be used
+// directly. It holds common implementation code that does not depend on the
+// element type of the nsTArray.
+//
+template <class Alloc, class RelocationStrategy>
+class nsTArray_base {
+ // Allow swapping elements with |nsTArray_base|s created using a
+ // different allocator. This is kosher because all allocators use
+ // the same free().
+ template <class XAlloc, class XRelocationStrategy>
+ friend class nsTArray_base;
+
+ // Needed for AppendElements from an array with a different allocator, which
+ // calls ShiftData.
+ template <class E, class XAlloc>
+ friend class nsTArray_Impl;
+
+ friend void Gecko_EnsureTArrayCapacity(void* aArray, size_t aCapacity,
+ size_t aElemSize);
+ friend void Gecko_ClearPODTArray(void* aTArray, size_t aElementSize,
+ size_t aElementAlign);
+
+ protected:
+ typedef nsTArrayHeader Header;
+
+ public:
+ typedef size_t size_type;
+ typedef size_t index_type;
+
+ // @return The number of elements in the array.
+ size_type Length() const { return mHdr->mLength; }
+
+ // @return True if the array is empty or false otherwise.
+ bool IsEmpty() const { return Length() == 0; }
+
+ // @return The number of elements that can fit in the array without forcing
+ // the array to be re-allocated. The length of an array is always less
+ // than or equal to its capacity.
+ size_type Capacity() const { return mHdr->mCapacity; }
+
+#ifdef DEBUG
+ void* DebugGetHeader() const { return mHdr; }
+#endif
+
+ protected:
+ nsTArray_base();
+
+ ~nsTArray_base();
+
+ nsTArray_base(const nsTArray_base&);
+ nsTArray_base& operator=(const nsTArray_base&);
+
+ // Resize the storage if necessary to achieve the requested capacity.
+ // @param aCapacity The requested number of array elements.
+ // @param aElemSize The size of an array element.
+ // @return False if insufficient memory is available; true otherwise.
+ template <typename ActualAlloc>
+ typename ActualAlloc::ResultTypeProxy EnsureCapacity(size_type aCapacity,
+ size_type aElemSize);
+
+ // Extend the storage to accommodate aCount extra elements.
+ // @param aLength The current size of the array.
+ // @param aCount The number of elements to add.
+ // @param aElemSize The size of an array element.
+ // @return False if insufficient memory is available or the new length
+ // would overflow; true otherwise.
+ template <typename ActualAlloc>
+ typename ActualAlloc::ResultTypeProxy ExtendCapacity(size_type aLength,
+ size_type aCount,
+ size_type aElemSize);
+
+ // Tries to resize the storage to the minimum required amount. If this fails,
+ // the array is left as-is.
+ // @param aElemSize The size of an array element.
+ // @param aElemAlign The alignment in bytes of an array element.
+ void ShrinkCapacity(size_type aElemSize, size_t aElemAlign);
+
+ // Resizes the storage to 0. This may only be called when Length() is already
+ // 0.
+ // @param aElemSize The size of an array element.
+ // @param aElemAlign The alignment in bytes of an array element.
+ void ShrinkCapacityToZero(size_type aElemSize, size_t aElemAlign);
+
+ // This method may be called to resize a "gap" in the array by shifting
+ // elements around. It updates mLength appropriately. If the resulting
+ // array has zero elements, then the array's memory is free'd.
+ // @param aStart The starting index of the gap.
+ // @param aOldLen The current length of the gap.
+ // @param aNewLen The desired length of the gap.
+ // @param aElemSize The size of an array element.
+ // @param aElemAlign The alignment in bytes of an array element.
+ template <typename ActualAlloc>
+ void ShiftData(index_type aStart, size_type aOldLen, size_type aNewLen,
+ size_type aElemSize, size_t aElemAlign);
+
+ // This method may be called to swap elements from the end of the array to
+ // fill a "gap" in the array. If the resulting array has zero elements, then
+ // the array's memory is free'd.
+ // @param aStart The starting index of the gap.
+ // @param aCount The length of the gap.
+ // @param aElemSize The size of an array element.
+ // @param aElemAlign The alignment in bytes of an array element.
+ template <typename ActualAlloc>
+ void SwapFromEnd(index_type aStart, size_type aCount, size_type aElemSize,
+ size_t aElemAlign);
+
+ // This method increments the length member of the array's header.
+ // Note that mHdr may actually be sEmptyTArrayHeader in the case where a
+ // zero-length array is inserted into our array. But then aNum should
+ // always be 0.
+ void IncrementLength(size_t aNum) {
+ if (HasEmptyHeader()) {
+ if (MOZ_UNLIKELY(aNum != 0)) {
+ // Writing a non-zero length to the empty header would be extremely bad.
+ MOZ_CRASH();
+ }
+ } else {
+ mHdr->mLength += aNum;
+ }
+ }
+
+ // This method inserts blank slots into the array.
+ // @param aIndex the place to insert the new elements. This must be no
+ // greater than the current length of the array.
+ // @param aCount the number of slots to insert
+ // @param aElementSize the size of an array element.
+ // @param aElemAlign the alignment in bytes of an array element.
+ template <typename ActualAlloc>
+ typename ActualAlloc::ResultTypeProxy InsertSlotsAt(index_type aIndex,
+ size_type aCount,
+ size_type aElementSize,
+ size_t aElemAlign);
+
+ template <typename ActualAlloc, class Allocator>
+ typename ActualAlloc::ResultTypeProxy SwapArrayElements(
+ nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
+ size_t aElemAlign);
+
+ template <class Allocator>
+ void MoveConstructNonAutoArray(
+ nsTArray_base<Allocator, RelocationStrategy>& aOther, size_type aElemSize,
+ size_t aElemAlign);
+
+ template <class Allocator>
+ void MoveInit(nsTArray_base<Allocator, RelocationStrategy>& aOther,
+ size_type aElemSize, size_t aElemAlign);
+
+ // This is an RAII class used in SwapArrayElements.
+ class IsAutoArrayRestorer {
+ public:
+ IsAutoArrayRestorer(nsTArray_base<Alloc, RelocationStrategy>& aArray,
+ size_t aElemAlign);
+ ~IsAutoArrayRestorer();
+
+ private:
+ nsTArray_base<Alloc, RelocationStrategy>& mArray;
+ size_t mElemAlign;
+ bool mIsAuto;
+ };
+
+ // Helper function for SwapArrayElements. Ensures that if the array
+ // is an AutoTArray that it doesn't use the built-in buffer.
+ template <typename ActualAlloc>
+ bool EnsureNotUsingAutoArrayBuffer(size_type aElemSize);
+
+ // Returns true if this nsTArray is an AutoTArray with a built-in buffer.
+ bool IsAutoArray() const { return mHdr->mIsAutoArray; }
+
+ // Returns a Header for the built-in buffer of this AutoTArray.
+ Header* GetAutoArrayBuffer(size_t aElemAlign) {
+ MOZ_ASSERT(IsAutoArray(), "Should be an auto array to call this");
+ return GetAutoArrayBufferUnsafe(aElemAlign);
+ }
+ const Header* GetAutoArrayBuffer(size_t aElemAlign) const {
+ MOZ_ASSERT(IsAutoArray(), "Should be an auto array to call this");
+ return GetAutoArrayBufferUnsafe(aElemAlign);
+ }
+
+ // Returns a Header for the built-in buffer of this AutoTArray, but doesn't
+ // assert that we are an AutoTArray.
+ Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) {
+ return const_cast<Header*>(
+ static_cast<const nsTArray_base<Alloc, RelocationStrategy>*>(this)
+ ->GetAutoArrayBufferUnsafe(aElemAlign));
+ }
+ const Header* GetAutoArrayBufferUnsafe(size_t aElemAlign) const;
+
+ // Returns true if this is an AutoTArray and it currently uses the
+ // built-in buffer to store its elements.
+ bool UsesAutoArrayBuffer() const;
+
+ // The array's elements (prefixed with a Header). This pointer is never
+ // null. If the array is empty, then this will point to sEmptyTArrayHeader.
+ Header* mHdr;
+
+ Header* Hdr() const MOZ_NONNULL_RETURN { return mHdr; }
+ Header** PtrToHdr() MOZ_NONNULL_RETURN { return &mHdr; }
+ static Header* EmptyHdr() MOZ_NONNULL_RETURN {
+ return const_cast<Header*>(&sEmptyTArrayHeader);
+ }
+
+ [[nodiscard]] bool HasEmptyHeader() const { return mHdr == EmptyHdr(); }
+};
+
+namespace detail {
+
+// Used for argument checking in nsTArrayElementTraits::Emplace.
+template <typename... T>
+struct ChooseFirst;
+
+template <>
+struct ChooseFirst<> {
+ // Choose a default type that is guaranteed to not match E* for any
+ // nsTArray<E>.
+ typedef void Type;
+};
+
+template <typename A, typename... Args>
+struct ChooseFirst<A, Args...> {
+ typedef A Type;
+};
+
+} // namespace detail
+
+//
+// This class defines convenience functions for element specific operations.
+// Specialize this template if necessary.
+//
+template <class E>
+class nsTArrayElementTraits {
+ public:
+ // Invoke the default constructor in place.
+ static inline void Construct(E* aE) {
+ // Do NOT call "E()"! That triggers C++ "default initialization"
+ // which zeroes out POD ("plain old data") types such as regular
+ // ints. We don't want that because it can be a performance issue
+ // and people don't expect it; nsTArray should work like a regular
+ // C/C++ array in this respect.
+ new (static_cast<void*>(aE)) E;
+ }
+ // Invoke the copy-constructor in place.
+ template <class A>
+ static inline void Construct(E* aE, A&& aArg) {
+ using E_NoCV = std::remove_cv_t<E>;
+ using A_NoCV = std::remove_cv_t<A>;
+ static_assert(!std::is_same_v<E_NoCV*, A_NoCV>,
+ "For safety, we disallow constructing nsTArray<E> elements "
+ "from E* pointers. See bug 960591.");
+ new (static_cast<void*>(aE)) E(std::forward<A>(aArg));
+ }
+ // Construct in place.
+ template <class... Args>
+ static inline void Emplace(E* aE, Args&&... aArgs) {
+ using E_NoCV = std::remove_cv_t<E>;
+ using A_NoCV =
+ std::remove_cv_t<typename ::detail::ChooseFirst<Args...>::Type>;
+ static_assert(!std::is_same_v<E_NoCV*, A_NoCV>,
+ "For safety, we disallow constructing nsTArray<E> elements "
+ "from E* pointers. See bug 960591.");
+ new (static_cast<void*>(aE)) E(std::forward<Args>(aArgs)...);
+ }
+ // Invoke the destructor in place.
+ static inline void Destruct(E* aE) { aE->~E(); }
+};
+
+// The default comparator used by nsTArray
+template <class A, class B>
+class nsDefaultComparator {
+ public:
+ bool Equals(const A& aA, const B& aB) const { return aA == aB; }
+ bool LessThan(const A& aA, const B& aB) const { return aA < aB; }
+};
+
+template <bool IsTriviallyCopyConstructible, bool IsSameType>
+struct AssignRangeAlgorithm {
+ template <class Item, class ElemType, class IndexType, class SizeType>
+ static void implementation(ElemType* aElements, IndexType aStart,
+ SizeType aCount, const Item* aValues) {
+ ElemType* iter = aElements + aStart;
+ ElemType* end = iter + aCount;
+ for (; iter != end; ++iter, ++aValues) {
+ nsTArrayElementTraits<ElemType>::Construct(iter, *aValues);
+ }
+ }
+};
+
+template <>
+struct AssignRangeAlgorithm<true, true> {
+ template <class Item, class ElemType, class IndexType, class SizeType>
+ static void implementation(ElemType* aElements, IndexType aStart,
+ SizeType aCount, const Item* aValues) {
+ if (aValues) {
+ memcpy(aElements + aStart, aValues, aCount * sizeof(ElemType));
+ }
+ }
+};
+
+//
+// Normally elements are copied with memcpy and memmove, but for some element
+// types that is problematic. The nsTArray_RelocationStrategy template class
+// can be specialized to ensure that copying calls constructors and destructors
+// instead, as is done below for JS::Heap<E> elements.
+//
+
+//
+// A class that defines how to copy elements using memcpy/memmove.
+//
+struct nsTArray_RelocateUsingMemutils {
+ const static bool allowRealloc = true;
+
+ static void RelocateNonOverlappingRegionWithHeader(void* aDest,
+ const void* aSrc,
+ size_t aCount,
+ size_t aElemSize) {
+ memcpy(aDest, aSrc, sizeof(nsTArrayHeader) + aCount * aElemSize);
+ }
+
+ static void RelocateOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+ size_t aElemSize) {
+ memmove(aDest, aSrc, aCount * aElemSize);
+ }
+
+ static void RelocateNonOverlappingRegion(void* aDest, void* aSrc,
+ size_t aCount, size_t aElemSize) {
+ memcpy(aDest, aSrc, aCount * aElemSize);
+ }
+};
+
+//
+// A template class that defines how to relocate elements using the type's move
+// constructor and destructor appropriately.
+//
+template <class ElemType>
+struct nsTArray_RelocateUsingMoveConstructor {
+ typedef nsTArrayElementTraits<ElemType> traits;
+
+ const static bool allowRealloc = false;
+
+ static void RelocateNonOverlappingRegionWithHeader(void* aDest, void* aSrc,
+ size_t aCount,
+ size_t aElemSize) {
+ nsTArrayHeader* destHeader = static_cast<nsTArrayHeader*>(aDest);
+ nsTArrayHeader* srcHeader = static_cast<nsTArrayHeader*>(aSrc);
+ *destHeader = *srcHeader;
+ RelocateNonOverlappingRegion(
+ static_cast<uint8_t*>(aDest) + sizeof(nsTArrayHeader),
+ static_cast<uint8_t*>(aSrc) + sizeof(nsTArrayHeader), aCount,
+ aElemSize);
+ }
+
+ // RelocateNonOverlappingRegion and RelocateOverlappingRegion are defined by
+ // analogy with memmove and memcpy that are used for relocation of
+ // trivially-relocatable types through nsTArray_RelocateUsingMemutils. What
+ // they actually do is slightly different: RelocateOverlappingRegion checks to
+ // see which direction the movement needs to take place, whether from
+ // back-to-front of the range to be moved or from front-to-back.
+ // RelocateNonOverlappingRegion assumes that relocating front-to-back is
+ // always valid. They use RelocateRegionForward and RelocateRegionBackward,
+ // which are analogous to std::move and std::move_backward respectively,
+ // except they don't move-assign the destination from the source but
+ // move-construct the destination from the source and destroy the source.
+ static void RelocateOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
+ size_t aElemSize) {
+ ElemType* destBegin = static_cast<ElemType*>(aDest);
+ ElemType* srcBegin = static_cast<ElemType*>(aSrc);
+
+ // If destination and source are the same, this is a no-op.
+ // In practice, we don't do this.
+ if (destBegin == srcBegin) {
+ return;
+ }
+
+ ElemType* srcEnd = srcBegin + aCount;
+ ElemType* destEnd = destBegin + aCount;
+
+ // Figure out whether to relocate back-to-front or front-to-back.
+ if (srcEnd > destBegin && srcEnd < destEnd) {
+ RelocateRegionBackward(srcBegin, srcEnd, destEnd);
+ } else {
+ RelocateRegionForward(srcBegin, srcEnd, destBegin);
+ }
+ }
+
+ static void RelocateNonOverlappingRegion(void* aDest, void* aSrc,
+ size_t aCount, size_t aElemSize) {
+ ElemType* destBegin = static_cast<ElemType*>(aDest);
+ ElemType* srcBegin = static_cast<ElemType*>(aSrc);
+ ElemType* srcEnd = srcBegin + aCount;
+#ifdef DEBUG
+ ElemType* destEnd = destBegin + aCount;
+ MOZ_ASSERT(srcEnd <= destBegin || srcBegin >= destEnd);
+#endif
+ RelocateRegionForward(srcBegin, srcEnd, destBegin);
+ }
+
+ private:
+ static void RelocateRegionForward(ElemType* srcBegin, ElemType* srcEnd,
+ ElemType* destBegin) {
+ ElemType* srcElem = srcBegin;
+ ElemType* destElem = destBegin;
+
+ while (srcElem != srcEnd) {
+ RelocateElement(srcElem, destElem);
+ ++destElem;
+ ++srcElem;
+ }
+ }
+
+ static void RelocateRegionBackward(ElemType* srcBegin, ElemType* srcEnd,
+ ElemType* destEnd) {
+ ElemType* srcElem = srcEnd;
+ ElemType* destElem = destEnd;
+ while (srcElem != srcBegin) {
+ --destElem;
+ --srcElem;
+ RelocateElement(srcElem, destElem);
+ }
+ }
+
+ static void RelocateElement(ElemType* srcElem, ElemType* destElem) {
+ traits::Construct(destElem, std::move(*srcElem));
+ traits::Destruct(srcElem);
+ }
+};
+
+//
+// The default behaviour is to use memcpy/memmove for everything.
+//
+template <class E>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE nsTArray_RelocationStrategy {
+ using Type = nsTArray_RelocateUsingMemutils;
+};
+
+//
+// Some classes require constructors/destructors to be called, so they are
+// specialized here.
+//
+#define MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(E) \
+ template <> \
+ struct nsTArray_RelocationStrategy<E> { \
+ using Type = nsTArray_RelocateUsingMoveConstructor<E>; \
+ };
+
+#define MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(T) \
+ template <typename S> \
+ struct nsTArray_RelocationStrategy<T<S>> { \
+ using Type = nsTArray_RelocateUsingMoveConstructor<T<S>>; \
+ };
+
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(JS::Heap)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(std::function)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(mozilla::ipc::Endpoint)
+
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(nsRegion)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(nsIntRegion)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::layers::TileClient)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(
+ mozilla::SerializedStructuredCloneBuffer)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(
+ mozilla::dom::ipc::StructuredCloneData)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::dom::ClonedMessageData)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(
+ mozilla::dom::indexedDB::ObjectStoreCursorResponse)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(
+ mozilla::dom::indexedDB::IndexCursorResponse)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(
+ mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo);
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(JSStructuredCloneData)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::dom::MessageData)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::dom::RefMessageData)
+MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::SourceBufferTask)
+
+//
+// Base class for nsTArray_Impl that is templated on element type and derived
+// nsTArray_Impl class, to allow extra conversions to be added for specific
+// types.
+//
+template <class E, class Derived>
+struct nsTArray_TypedBase : public nsTArray_SafeElementAtHelper<E, Derived> {};
+
+//
+// Specialization of nsTArray_TypedBase for arrays containing JS::Heap<E>
+// elements.
+//
+// These conversions are safe because JS::Heap<E> and E share the same
+// representation, and since the result of the conversions are const references
+// we won't miss any barriers.
+//
+// The static_cast is necessary to obtain the correct address for the derived
+// class since we are a base class used in multiple inheritance.
+//
+template <class E, class Derived>
+struct nsTArray_TypedBase<JS::Heap<E>, Derived>
+ : public nsTArray_SafeElementAtHelper<JS::Heap<E>, Derived> {
+ operator const nsTArray<E>&() {
+ static_assert(sizeof(E) == sizeof(JS::Heap<E>),
+ "JS::Heap<E> must be binary compatible with E.");
+ Derived* self = static_cast<Derived*>(this);
+ return *reinterpret_cast<nsTArray<E>*>(self);
+ }
+
+ operator const FallibleTArray<E>&() {
+ Derived* self = static_cast<Derived*>(this);
+ return *reinterpret_cast<FallibleTArray<E>*>(self);
+ }
+};
+
+namespace detail {
+
+// These helpers allow us to differentiate between tri-state comparator
+// functions and classes with LessThan() and Equal() methods. If an object, when
+// called as a function with two instances of our element type, returns an int,
+// we treat it as a tri-state comparator.
+//
+// T is the type of the comparator object we want to check. U is the array
+// element type that we'll be comparing.
+//
+// V is never passed, and is only used to allow us to specialize on the return
+// value of the comparator function.
+template <typename T, typename U, typename V = int>
+struct IsCompareMethod : std::false_type {};
+
+template <typename T, typename U>
+struct IsCompareMethod<
+ T, U, decltype(std::declval<T>()(std::declval<U>(), std::declval<U>()))>
+ : std::true_type {};
+
+// These two wrappers allow us to use either a tri-state comparator, or an
+// object with Equals() and LessThan() methods interchangeably. They provide a
+// tri-state Compare() method, and Equals() method, and a LessThan() method.
+//
+// Depending on the type of the underlying comparator, they either pass these
+// through directly, or synthesize them from the methods available on the
+// comparator.
+//
+// Callers should always use the most-specific of these methods that match their
+// purpose.
+
+// Comparator wrapper for a tri-state comparator function
+template <typename T, typename U, bool IsCompare = IsCompareMethod<T, U>::value>
+struct CompareWrapper {
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4180) /* Silence "qualifier applied to function \
+ type has no meaning" warning */
+#endif
+ MOZ_IMPLICIT CompareWrapper(const T& aComparator)
+ : mComparator(aComparator) {}
+
+ template <typename A, typename B>
+ int Compare(A& aLeft, B& aRight) const {
+ return mComparator(aLeft, aRight);
+ }
+
+ template <typename A, typename B>
+ bool Equals(A& aLeft, B& aRight) const {
+ return Compare(aLeft, aRight) == 0;
+ }
+
+ template <typename A, typename B>
+ bool LessThan(A& aLeft, B& aRight) const {
+ return Compare(aLeft, aRight) < 0;
+ }
+
+ const T& mComparator;
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+};
+
+// Comparator wrapper for a class with Equals() and LessThan() methods.
+template <typename T, typename U>
+struct CompareWrapper<T, U, false> {
+ MOZ_IMPLICIT CompareWrapper(const T& aComparator)
+ : mComparator(aComparator) {}
+
+ template <typename A, typename B>
+ int Compare(A& aLeft, B& aRight) const {
+ if (Equals(aLeft, aRight)) {
+ return 0;
+ }
+ return LessThan(aLeft, aRight) ? -1 : 1;
+ }
+
+ template <typename A, typename B>
+ bool Equals(A& aLeft, B& aRight) const {
+ return mComparator.Equals(aLeft, aRight);
+ }
+
+ template <typename A, typename B>
+ bool LessThan(A& aLeft, B& aRight) const {
+ return mComparator.LessThan(aLeft, aRight);
+ }
+
+ const T& mComparator;
+};
+
+} // namespace detail
+
+//
+// nsTArray_Impl contains most of the guts supporting nsTArray, FallibleTArray,
+// AutoTArray.
+//
+// The only situation in which you might need to use nsTArray_Impl in your code
+// is if you're writing code which mutates a TArray which may or may not be
+// infallible.
+//
+// Code which merely reads from a TArray which may or may not be infallible can
+// simply cast the TArray to |const nsTArray&|; both fallible and infallible
+// TArrays can be cast to |const nsTArray&|.
+//
+template <class E, class Alloc>
+class nsTArray_Impl
+ : public nsTArray_base<Alloc,
+ typename nsTArray_RelocationStrategy<E>::Type>,
+ public nsTArray_TypedBase<E, nsTArray_Impl<E, Alloc>> {
+ private:
+ friend class nsTArray<E>;
+
+ typedef nsTArrayFallibleAllocator FallibleAlloc;
+ typedef nsTArrayInfallibleAllocator InfallibleAlloc;
+
+ public:
+ typedef typename nsTArray_RelocationStrategy<E>::Type relocation_type;
+ typedef nsTArray_base<Alloc, relocation_type> base_type;
+ typedef typename base_type::size_type size_type;
+ typedef typename base_type::index_type index_type;
+ typedef E value_type;
+ typedef nsTArray_Impl<E, Alloc> self_type;
+ typedef nsTArrayElementTraits<E> elem_traits;
+ typedef nsTArray_SafeElementAtHelper<E, self_type> safeelementat_helper_type;
+ typedef mozilla::ArrayIterator<value_type&, self_type> iterator;
+ typedef mozilla::ArrayIterator<const value_type&, self_type> const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ using base_type::EmptyHdr;
+ using safeelementat_helper_type::SafeElementAt;
+
+ // A special value that is used to indicate an invalid or unknown index
+ // into the array.
+ static const index_type NoIndex = index_type(-1);
+
+ using base_type::Length;
+
+ //
+ // Finalization method
+ //
+
+ ~nsTArray_Impl() {
+ if (!base_type::IsEmpty()) {
+ ClearAndRetainStorage();
+ }
+ // mHdr cleanup will be handled by base destructor
+ }
+
+ //
+ // Initialization methods
+ //
+
+ nsTArray_Impl() = default;
+
+ // Initialize this array and pre-allocate some number of elements.
+ explicit nsTArray_Impl(size_type aCapacity) { SetCapacity(aCapacity); }
+
+ // Initialize this array with an r-value.
+ // Allow different types of allocators, since the allocator doesn't matter.
+ template <typename Allocator>
+ explicit nsTArray_Impl(nsTArray_Impl<E, Allocator>&& aOther) noexcept {
+ // We cannot be a (Copyable)AutoTArray because that overrides this ctor.
+ MOZ_ASSERT(!this->IsAutoArray());
+
+ // This does not use SwapArrayElements because that's unnecessarily complex.
+ this->MoveConstructNonAutoArray(aOther, sizeof(value_type),
+ MOZ_ALIGNOF(value_type));
+ }
+
+ // The array's copy-constructor performs a 'deep' copy of the given array.
+ // @param aOther The array object to copy.
+ //
+ // It's very important that we declare this method as taking |const
+ // self_type&| as opposed to taking |const nsTArray_Impl<E, OtherAlloc>| for
+ // an arbitrary OtherAlloc.
+ //
+ // If we don't declare a constructor taking |const self_type&|, C++ generates
+ // a copy-constructor for this class which merely copies the object's
+ // members, which is obviously wrong.
+ //
+ // You can pass an nsTArray_Impl<E, OtherAlloc> to this method because
+ // nsTArray_Impl<E, X> can be cast to const nsTArray_Impl<E, Y>&. So the
+ // effect on the API is the same as if we'd declared this method as taking
+ // |const nsTArray_Impl<E, OtherAlloc>&|.
+ nsTArray_Impl(const nsTArray_Impl&) = default;
+
+ // Allow converting to a const array with a different kind of allocator,
+ // Since the allocator doesn't matter for const arrays
+ template <typename Allocator>
+ [[nodiscard]] operator const nsTArray_Impl<E, Allocator>&() const& {
+ return *reinterpret_cast<const nsTArray_Impl<E, Allocator>*>(this);
+ }
+ // And we have to do this for our subclasses too
+ [[nodiscard]] operator const nsTArray<E>&() const& {
+ return *reinterpret_cast<const nsTArray<E>*>(this);
+ }
+ [[nodiscard]] operator const FallibleTArray<E>&() const& {
+ return *reinterpret_cast<const FallibleTArray<E>*>(this);
+ }
+
+ // The array's assignment operator performs a 'deep' copy of the given
+ // array. It is optimized to reuse existing storage if possible.
+ // @param aOther The array object to copy.
+ nsTArray_Impl& operator=(const nsTArray_Impl&) = default;
+
+ // The array's move assignment operator steals the underlying data from
+ // the other array.
+ // @param other The array object to move from.
+ self_type& operator=(self_type&& aOther) {
+ if (this != &aOther) {
+ Clear();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+ return *this;
+ }
+
+ // Return true if this array has the same length and the same
+ // elements as |aOther|.
+ template <typename Allocator>
+ [[nodiscard]] bool operator==(
+ const nsTArray_Impl<E, Allocator>& aOther) const {
+ size_type len = Length();
+ if (len != aOther.Length()) {
+ return false;
+ }
+
+ // XXX std::equal would be as fast or faster here
+ for (index_type i = 0; i < len; ++i) {
+ if (!(operator[](i) == aOther[i])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ // Return true if this array does not have the same length and the same
+ // elements as |aOther|.
+ [[nodiscard]] bool operator!=(const self_type& aOther) const {
+ return !operator==(aOther);
+ }
+
+ // If Alloc == FallibleAlloc, ReplaceElementsAt might fail, without a way to
+ // signal this to the caller, so we disallow copying via operator=. Callers
+ // should use ReplaceElementsAt with a fallible argument instead, and check
+ // the result.
+ template <typename Allocator,
+ typename = std::enable_if_t<std::is_same_v<Alloc, InfallibleAlloc>,
+ Allocator>>
+ self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther) {
+ AssignInternal<InfallibleAlloc>(aOther.Elements(), aOther.Length());
+ return *this;
+ }
+
+ template <typename Allocator>
+ self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
+ Clear();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ return *this;
+ }
+
+ // @return The amount of memory used by this nsTArray_Impl, excluding
+ // sizeof(*this). If you want to measure anything hanging off the array, you
+ // must iterate over the elements and measure them individually; hence the
+ // "Shallow" prefix.
+ [[nodiscard]] size_t ShallowSizeOfExcludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) const {
+ if (this->UsesAutoArrayBuffer() || this->HasEmptyHeader()) {
+ return 0;
+ }
+ return aMallocSizeOf(this->Hdr());
+ }
+
+ // @return The amount of memory used by this nsTArray_Impl, including
+ // sizeof(*this). If you want to measure anything hanging off the array, you
+ // must iterate over the elements and measure them individually; hence the
+ // "Shallow" prefix.
+ [[nodiscard]] size_t ShallowSizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ //
+ // Accessor methods
+ //
+
+ // This method provides direct access to the array elements.
+ // @return A pointer to the first element of the array. If the array is
+ // empty, then this pointer must not be dereferenced.
+ [[nodiscard]] value_type* Elements() MOZ_NONNULL_RETURN {
+ return reinterpret_cast<value_type*>(Hdr() + 1);
+ }
+
+ // This method provides direct, readonly access to the array elements.
+ // @return A pointer to the first element of the array. If the array is
+ // empty, then this pointer must not be dereferenced.
+ [[nodiscard]] const value_type* Elements() const MOZ_NONNULL_RETURN {
+ return reinterpret_cast<const value_type*>(Hdr() + 1);
+ }
+
+ // This method provides direct access to an element of the array. The given
+ // index must be within the array bounds.
+ // @param aIndex The index of an element in the array.
+ // @return A reference to the i'th element of the array.
+ [[nodiscard]] value_type& ElementAt(index_type aIndex) {
+ if (MOZ_UNLIKELY(aIndex >= Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
+ }
+ return Elements()[aIndex];
+ }
+
+ // This method provides direct, readonly access to an element of the array
+ // The given index must be within the array bounds.
+ // @param aIndex The index of an element in the array.
+ // @return A const reference to the i'th element of the array.
+ [[nodiscard]] const value_type& ElementAt(index_type aIndex) const {
+ if (MOZ_UNLIKELY(aIndex >= Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
+ }
+ return Elements()[aIndex];
+ }
+
+ // This method provides direct access to an element of the array in a bounds
+ // safe manner. If the requested index is out of bounds the provided default
+ // value is returned.
+ // @param aIndex The index of an element in the array.
+ // @param aDef The value to return if the index is out of bounds.
+ [[nodiscard]] value_type& SafeElementAt(index_type aIndex, value_type& aDef) {
+ return aIndex < Length() ? Elements()[aIndex] : aDef;
+ }
+
+ // This method provides direct access to an element of the array in a bounds
+ // safe manner. If the requested index is out of bounds the provided default
+ // value is returned.
+ // @param aIndex The index of an element in the array.
+ // @param aDef The value to return if the index is out of bounds.
+ [[nodiscard]] const value_type& SafeElementAt(index_type aIndex,
+ const value_type& aDef) const {
+ return aIndex < Length() ? Elements()[aIndex] : aDef;
+ }
+
+ // Shorthand for ElementAt(aIndex)
+ [[nodiscard]] value_type& operator[](index_type aIndex) {
+ return ElementAt(aIndex);
+ }
+
+ // Shorthand for ElementAt(aIndex)
+ [[nodiscard]] const value_type& operator[](index_type aIndex) const {
+ return ElementAt(aIndex);
+ }
+
+ // Shorthand for ElementAt(length - 1)
+ [[nodiscard]] value_type& LastElement() { return ElementAt(Length() - 1); }
+
+ // Shorthand for ElementAt(length - 1)
+ [[nodiscard]] const value_type& LastElement() const {
+ return ElementAt(Length() - 1);
+ }
+
+ // Shorthand for SafeElementAt(length - 1, def)
+ [[nodiscard]] value_type& SafeLastElement(value_type& aDef) {
+ return SafeElementAt(Length() - 1, aDef);
+ }
+
+ // Shorthand for SafeElementAt(length - 1, def)
+ [[nodiscard]] const value_type& SafeLastElement(
+ const value_type& aDef) const {
+ return SafeElementAt(Length() - 1, aDef);
+ }
+
+ // Methods for range-based for loops.
+ [[nodiscard]] iterator begin() { return iterator(*this, 0); }
+ [[nodiscard]] const_iterator begin() const {
+ return const_iterator(*this, 0);
+ }
+ [[nodiscard]] const_iterator cbegin() const { return begin(); }
+ [[nodiscard]] iterator end() { return iterator(*this, Length()); }
+ [[nodiscard]] const_iterator end() const {
+ return const_iterator(*this, Length());
+ }
+ [[nodiscard]] const_iterator cend() const { return end(); }
+
+ // Methods for reverse iterating.
+ [[nodiscard]] reverse_iterator rbegin() { return reverse_iterator(end()); }
+ [[nodiscard]] const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
+ [[nodiscard]] const_reverse_iterator crbegin() const { return rbegin(); }
+ [[nodiscard]] reverse_iterator rend() { return reverse_iterator(begin()); }
+ [[nodiscard]] const_reverse_iterator rend() const {
+ return const_reverse_iterator(begin());
+ }
+ [[nodiscard]] const_reverse_iterator crend() const { return rend(); }
+
+ // Span integration
+
+ [[nodiscard]] operator mozilla::Span<value_type>() {
+ return mozilla::Span<value_type>(Elements(), Length());
+ }
+
+ [[nodiscard]] operator mozilla::Span<const value_type>() const {
+ return mozilla::Span<const value_type>(Elements(), Length());
+ }
+
+ //
+ // Search methods
+ //
+
+ // This method searches for the first element in this array that is equal
+ // to the given element.
+ // @param aItem The item to search for.
+ // @param aComp The Comparator used to determine element equality.
+ // @return true if the element was found.
+ template <class Item, class Comparator>
+ [[nodiscard]] bool Contains(const Item& aItem,
+ const Comparator& aComp) const {
+ return ApplyIf(
+ aItem, 0, aComp, []() { return true; }, []() { return false; });
+ }
+
+ // Like Contains(), but assumes a sorted array.
+ template <class Item, class Comparator>
+ [[nodiscard]] bool ContainsSorted(const Item& aItem,
+ const Comparator& aComp) const {
+ return BinaryIndexOf(aItem, aComp) != NoIndex;
+ }
+
+ // This method searches for the first element in this array that is equal
+ // to the given element. This method assumes that 'operator==' is defined
+ // for value_type.
+ // @param aItem The item to search for.
+ // @return true if the element was found.
+ template <class Item>
+ [[nodiscard]] bool Contains(const Item& aItem) const {
+ return Contains(aItem, nsDefaultComparator<value_type, Item>());
+ }
+
+ // Like Contains(), but assumes a sorted array.
+ template <class Item>
+ [[nodiscard]] bool ContainsSorted(const Item& aItem) const {
+ return BinaryIndexOf(aItem) != NoIndex;
+ }
+
+ // This method searches for the offset of the first element in this
+ // array that is equal to the given element.
+ // @param aItem The item to search for.
+ // @param aStart The index to start from.
+ // @param aComp The Comparator used to determine element equality.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item, class Comparator>
+ [[nodiscard]] index_type IndexOf(const Item& aItem, index_type aStart,
+ const Comparator& aComp) const {
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ const value_type* iter = Elements() + aStart;
+ const value_type* iend = Elements() + Length();
+ for (; iter != iend; ++iter) {
+ if (comp.Equals(*iter, aItem)) {
+ return index_type(iter - Elements());
+ }
+ }
+ return NoIndex;
+ }
+
+ // This method searches for the offset of the first element in this
+ // array that is equal to the given element. This method assumes
+ // that 'operator==' is defined for value_type.
+ // @param aItem The item to search for.
+ // @param aStart The index to start from.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item>
+ [[nodiscard]] index_type IndexOf(const Item& aItem,
+ index_type aStart = 0) const {
+ return IndexOf(aItem, aStart, nsDefaultComparator<value_type, Item>());
+ }
+
+ // This method searches for the offset of the last element in this
+ // array that is equal to the given element.
+ // @param aItem The item to search for.
+ // @param aStart The index to start from. If greater than or equal to the
+ // length of the array, then the entire array is searched.
+ // @param aComp The Comparator used to determine element equality.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item, class Comparator>
+ [[nodiscard]] index_type LastIndexOf(const Item& aItem, index_type aStart,
+ const Comparator& aComp) const {
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ size_type endOffset = aStart >= Length() ? Length() : aStart + 1;
+ const value_type* iend = Elements() - 1;
+ const value_type* iter = iend + endOffset;
+ for (; iter != iend; --iter) {
+ if (comp.Equals(*iter, aItem)) {
+ return index_type(iter - Elements());
+ }
+ }
+ return NoIndex;
+ }
+
+ // This method searches for the offset of the last element in this
+ // array that is equal to the given element. This method assumes
+ // that 'operator==' is defined for value_type.
+ // @param aItem The item to search for.
+ // @param aStart The index to start from. If greater than or equal to the
+ // length of the array, then the entire array is searched.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item>
+ [[nodiscard]] index_type LastIndexOf(const Item& aItem,
+ index_type aStart = NoIndex) const {
+ return LastIndexOf(aItem, aStart, nsDefaultComparator<value_type, Item>());
+ }
+
+ // This method searches for the offset for the element in this array
+ // that is equal to the given element. The array is assumed to be sorted.
+ // If there is more than one equivalent element, there is no guarantee
+ // on which one will be returned.
+ // @param aItem The item to search for.
+ // @param aComp The Comparator used.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item, class Comparator>
+ [[nodiscard]] index_type BinaryIndexOf(const Item& aItem,
+ const Comparator& aComp) const {
+ using mozilla::BinarySearchIf;
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ size_t index;
+ bool found = BinarySearchIf(
+ Elements(), 0, Length(),
+ // Note: We pass the Compare() args here in reverse order and negate the
+ // results for compatibility reasons. Some existing callers use Equals()
+ // functions with first arguments which match aElement but not aItem, or
+ // second arguments that match aItem but not aElement. To accommodate
+ // those callers, we preserve the argument order of the older version of
+ // this API. These callers, however, should be fixed, and this special
+ // case removed.
+ [&](const value_type& aElement) {
+ return -comp.Compare(aElement, aItem);
+ },
+ &index);
+ return found ? index : NoIndex;
+ }
+
+ // This method searches for the offset for the element in this array
+ // that is equal to the given element. The array is assumed to be sorted.
+ // This method assumes that 'operator==' and 'operator<' are defined.
+ // @param aItem The item to search for.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item>
+ [[nodiscard]] index_type BinaryIndexOf(const Item& aItem) const {
+ return BinaryIndexOf(aItem, nsDefaultComparator<value_type, Item>());
+ }
+
+ //
+ // Mutation methods
+ //
+ private:
+ template <typename ActualAlloc, class Item>
+ typename ActualAlloc::ResultType AssignInternal(const Item* aArray,
+ size_type aArrayLen);
+
+ public:
+ template <class Allocator, typename ActualAlloc = Alloc>
+ [[nodiscard]] typename ActualAlloc::ResultType Assign(
+ const nsTArray_Impl<E, Allocator>& aOther) {
+ return AssignInternal<ActualAlloc>(aOther.Elements(), aOther.Length());
+ }
+
+ template <class Allocator>
+ [[nodiscard]] bool Assign(const nsTArray_Impl<E, Allocator>& aOther,
+ const mozilla::fallible_t&) {
+ return Assign<Allocator, FallibleAlloc>(aOther);
+ }
+
+ template <class Allocator>
+ void Assign(nsTArray_Impl<E, Allocator>&& aOther) {
+ Clear();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ // This method call the destructor on each element of the array, empties it,
+ // but does not shrink the array's capacity.
+ // See also SetLengthAndRetainStorage.
+ // Make sure to call Compact() if needed to avoid keeping a huge array
+ // around.
+ void ClearAndRetainStorage() {
+ if (this->HasEmptyHeader()) {
+ return;
+ }
+
+ DestructRange(0, Length());
+ base_type::mHdr->mLength = 0;
+ }
+
+ // This method modifies the length of the array, but unlike SetLength
+ // it doesn't deallocate/reallocate the current internal storage.
+ // The new length MUST be shorter than or equal to the current capacity.
+ // If the new length is larger than the existing length of the array,
+ // then new elements will be constructed using value_type's default
+ // constructor. If shorter, elements will be destructed and removed.
+ // See also ClearAndRetainStorage.
+ // @param aNewLen The desired length of this array.
+ void SetLengthAndRetainStorage(size_type aNewLen) {
+ MOZ_ASSERT(aNewLen <= base_type::Capacity());
+ size_type oldLen = Length();
+ if (aNewLen > oldLen) {
+ /// XXX(Bug 1631367) SetLengthAndRetainStorage should be disabled for
+ /// FallibleTArray.
+ InsertElementsAtInternal<InfallibleAlloc>(oldLen, aNewLen - oldLen);
+ return;
+ }
+ if (aNewLen < oldLen) {
+ DestructRange(aNewLen, oldLen - aNewLen);
+ base_type::mHdr->mLength = aNewLen;
+ }
+ }
+
+ // This method replaces a range of elements in this array.
+ // @param aStart The starting index of the elements to replace.
+ // @param aCount The number of elements to replace. This may be zero to
+ // insert elements without removing any existing elements.
+ // @param aArray The values to copy into this array. Must be non-null,
+ // and these elements must not already exist in the array
+ // being modified.
+ // @param aArrayLen The number of values to copy into this array.
+ // @return A pointer to the new elements in the array, or null if
+ // the operation failed due to insufficient memory.
+ private:
+ template <typename ActualAlloc, class Item>
+ value_type* ReplaceElementsAtInternal(index_type aStart, size_type aCount,
+ const Item* aArray,
+ size_type aArrayLen);
+
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ const Item* aArray,
+ size_type aArrayLen,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aStart, aCount, aArray,
+ aArrayLen);
+ }
+
+ // A variation on the ReplaceElementsAt method defined above.
+ template <class Item>
+ [[nodiscard]] value_type* ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ const nsTArray<Item>& aArray,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aStart, aCount, aArray);
+ }
+
+ template <class Item>
+ [[nodiscard]] value_type* ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ mozilla::Span<Item> aSpan,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aStart, aCount, aSpan);
+ }
+
+ // A variation on the ReplaceElementsAt method defined above.
+ template <class Item>
+ [[nodiscard]] value_type* ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ const Item& aItem,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aStart, aCount, aItem);
+ }
+
+ // A variation on the ReplaceElementsAt method defined above.
+ template <class Item>
+ mozilla::NotNull<value_type*> ReplaceElementAt(index_type aIndex,
+ Item&& aItem) {
+ value_type* const elem = &ElementAt(aIndex);
+ elem_traits::Destruct(elem);
+ elem_traits::Construct(elem, std::forward<Item>(aItem));
+ return mozilla::WrapNotNullUnchecked(elem);
+ }
+
+ // InsertElementsAt is ReplaceElementsAt with 0 elements to replace.
+ // XXX Provide a proper documentation of InsertElementsAt.
+ template <class Item>
+ [[nodiscard]] value_type* InsertElementsAt(index_type aIndex,
+ const Item* aArray,
+ size_type aArrayLen,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aIndex, 0, aArray,
+ aArrayLen);
+ }
+
+ template <class Item, class Allocator>
+ [[nodiscard]] value_type* InsertElementsAt(
+ index_type aIndex, const nsTArray_Impl<Item, Allocator>& aArray,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(
+ aIndex, 0, aArray.Elements(), aArray.Length());
+ }
+
+ template <class Item>
+ [[nodiscard]] value_type* InsertElementsAt(index_type aIndex,
+ mozilla::Span<Item> aSpan,
+ const mozilla::fallible_t&) {
+ return ReplaceElementsAtInternal<FallibleAlloc>(aIndex, 0, aSpan.Elements(),
+ aSpan.Length());
+ }
+
+ private:
+ template <typename ActualAlloc>
+ value_type* InsertElementAtInternal(index_type aIndex);
+
+ // Insert a new element without copy-constructing. This is useful to avoid
+ // temporaries.
+ // @return A pointer to the newly inserted element, or null on OOM.
+ public:
+ [[nodiscard]] value_type* InsertElementAt(index_type aIndex,
+ const mozilla::fallible_t&) {
+ return InsertElementAtInternal<FallibleAlloc>(aIndex);
+ }
+
+ private:
+ template <typename ActualAlloc, class Item>
+ value_type* InsertElementAtInternal(index_type aIndex, Item&& aItem);
+
+ // Insert a new element, move constructing if possible.
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* InsertElementAt(index_type aIndex, Item&& aItem,
+ const mozilla::fallible_t&) {
+ return InsertElementAtInternal<FallibleAlloc>(aIndex,
+ std::forward<Item>(aItem));
+ }
+
+ // Reconstruct the element at the given index, and return a pointer to the
+ // reconstructed element. This will destroy the existing element and
+ // default-construct a new one, giving you a state much like what single-arg
+ // InsertElementAt(), or no-arg AppendElement() does, but without changing the
+ // length of the array.
+ //
+ // array[idx] = value_type()
+ //
+ // would accomplish the same thing as long as value_type has the appropriate
+ // moving operator=, but some types don't for various reasons.
+ mozilla::NotNull<value_type*> ReconstructElementAt(index_type aIndex) {
+ value_type* elem = &ElementAt(aIndex);
+ elem_traits::Destruct(elem);
+ elem_traits::Construct(elem);
+ return mozilla::WrapNotNullUnchecked(elem);
+ }
+
+ // This method searches for the smallest index of an element that is strictly
+ // greater than |aItem|. If |aItem| is inserted at this index, the array will
+ // remain sorted and |aItem| would come after all elements that are equal to
+ // it. If |aItem| is greater than or equal to all elements in the array, the
+ // array length is returned.
+ //
+ // Note that consumers who want to know whether there are existing items equal
+ // to |aItem| in the array can just check that the return value here is > 0
+ // and indexing into the previous slot gives something equal to |aItem|.
+ //
+ //
+ // @param aItem The item to search for.
+ // @param aComp The Comparator used.
+ // @return The index of greatest element <= to |aItem|
+ // @precondition The array is sorted
+ template <class Item, class Comparator>
+ [[nodiscard]] index_type IndexOfFirstElementGt(
+ const Item& aItem, const Comparator& aComp) const {
+ using mozilla::BinarySearchIf;
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ size_t index;
+ BinarySearchIf(
+ Elements(), 0, Length(),
+ [&](const value_type& aElement) {
+ return comp.Compare(aElement, aItem) <= 0 ? 1 : -1;
+ },
+ &index);
+ return index;
+ }
+
+ // A variation on the IndexOfFirstElementGt method defined above.
+ template <class Item>
+ [[nodiscard]] index_type IndexOfFirstElementGt(const Item& aItem) const {
+ return IndexOfFirstElementGt(aItem,
+ nsDefaultComparator<value_type, Item>());
+ }
+
+ private:
+ template <typename ActualAlloc, class Item, class Comparator>
+ value_type* InsertElementSortedInternal(Item&& aItem,
+ const Comparator& aComp) {
+ index_type index = IndexOfFirstElementGt<Item, Comparator>(aItem, aComp);
+ return InsertElementAtInternal<ActualAlloc>(index,
+ std::forward<Item>(aItem));
+ }
+
+ // Inserts |aItem| at such an index to guarantee that if the array
+ // was previously sorted, it will remain sorted after this
+ // insertion.
+ public:
+ template <class Item, class Comparator>
+ [[nodiscard]] value_type* InsertElementSorted(Item&& aItem,
+ const Comparator& aComp,
+ const mozilla::fallible_t&) {
+ return InsertElementSortedInternal<FallibleAlloc>(std::forward<Item>(aItem),
+ aComp);
+ }
+
+ // A variation on the InsertElementSorted method defined above.
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* InsertElementSorted(Item&& aItem,
+ const mozilla::fallible_t&) {
+ return InsertElementSortedInternal<FallibleAlloc>(
+ std::forward<Item>(aItem), nsDefaultComparator<value_type, Item>{});
+ }
+
+ private:
+ template <typename ActualAlloc, class Item>
+ value_type* AppendElementsInternal(const Item* aArray, size_type aArrayLen);
+
+ // This method appends elements to the end of this array.
+ // @param aArray The elements to append to this array.
+ // @param aArrayLen The number of elements to append to this array.
+ // @return A pointer to the new elements in the array, or null if
+ // the operation failed due to insufficient memory.
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* AppendElements(const Item* aArray,
+ size_type aArrayLen,
+ const mozilla::fallible_t&) {
+ return AppendElementsInternal<FallibleAlloc>(aArray, aArrayLen);
+ }
+
+ template <class Item>
+ [[nodiscard]] value_type* AppendElements(mozilla::Span<Item> aSpan,
+ const mozilla::fallible_t&) {
+ return AppendElementsInternal<FallibleAlloc>(aSpan.Elements(),
+ aSpan.Length());
+ }
+
+ // A variation on the AppendElements method defined above.
+ template <class Item, class Allocator>
+ [[nodiscard]] value_type* AppendElements(
+ const nsTArray_Impl<Item, Allocator>& aArray,
+ const mozilla::fallible_t&) {
+ return AppendElementsInternal<FallibleAlloc>(aArray.Elements(),
+ aArray.Length());
+ }
+
+ private:
+ template <typename ActualAlloc, class Item, class Allocator>
+ value_type* AppendElementsInternal(nsTArray_Impl<Item, Allocator>&& aArray);
+
+ // Move all elements from another array to the end of this array.
+ // @return A pointer to the newly appended elements, or null on OOM.
+ public:
+ template <class Item, class Allocator>
+ [[nodiscard]] value_type* AppendElements(
+ nsTArray_Impl<Item, Allocator>&& aArray, const mozilla::fallible_t&) {
+ return AppendElementsInternal<FallibleAlloc>(std::move(aArray));
+ }
+
+ // Append a new element, constructed in place from the provided arguments.
+ protected:
+ template <typename ActualAlloc, class... Args>
+ value_type* EmplaceBackInternal(Args&&... aItem);
+
+ public:
+ template <class... Args>
+ [[nodiscard]] value_type* EmplaceBack(const mozilla::fallible_t&,
+ Args&&... aArgs) {
+ return EmplaceBackInternal<FallibleAlloc, Args...>(
+ std::forward<Args>(aArgs)...);
+ }
+
+ private:
+ template <typename ActualAlloc, class Item>
+ value_type* AppendElementInternal(Item&& aItem);
+
+ // Append a new element, move constructing if possible.
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* AppendElement(Item&& aItem,
+ const mozilla::fallible_t&) {
+ return AppendElementInternal<FallibleAlloc>(std::forward<Item>(aItem));
+ }
+
+ private:
+ template <typename ActualAlloc>
+ value_type* AppendElementsInternal(size_type aCount) {
+ if (!ActualAlloc::Successful(this->template ExtendCapacity<ActualAlloc>(
+ Length(), aCount, sizeof(value_type)))) {
+ return nullptr;
+ }
+ value_type* elems = Elements() + Length();
+ size_type i;
+ for (i = 0; i < aCount; ++i) {
+ elem_traits::Construct(elems + i);
+ }
+ this->IncrementLength(aCount);
+ return elems;
+ }
+
+ // Append new elements without copy-constructing. This is useful to avoid
+ // temporaries.
+ // @return A pointer to the newly appended elements, or null on OOM.
+ public:
+ [[nodiscard]] value_type* AppendElements(size_type aCount,
+ const mozilla::fallible_t&) {
+ return AppendElementsInternal<FallibleAlloc>(aCount);
+ }
+
+ private:
+ // Append a new element without copy-constructing. This is useful to avoid
+ // temporaries.
+ // @return A pointer to the newly appended element, or null on OOM.
+ public:
+ [[nodiscard]] value_type* AppendElement(const mozilla::fallible_t&) {
+ return AppendElements(1, mozilla::fallible);
+ }
+
+ // This method removes a single element from this array, like
+ // std::vector::erase.
+ // @param pos to the element to remove
+ const_iterator RemoveElementAt(const_iterator pos) {
+ MOZ_ASSERT(pos.GetArray() == this);
+
+ RemoveElementAt(pos.GetIndex());
+ return pos;
+ }
+
+ // This method removes a range of elements from this array, like
+ // std::vector::erase.
+ // @param first iterator to the first of elements to remove
+ // @param last iterator to the last of elements to remove
+ const_iterator RemoveElementsRange(const_iterator first,
+ const_iterator last) {
+ MOZ_ASSERT(first.GetArray() == this);
+ MOZ_ASSERT(last.GetArray() == this);
+ MOZ_ASSERT(last.GetIndex() >= first.GetIndex());
+
+ RemoveElementsAt(first.GetIndex(), last.GetIndex() - first.GetIndex());
+ return first;
+ }
+
+ // This method removes a range of elements from this array.
+ // @param aStart The starting index of the elements to remove.
+ // @param aCount The number of elements to remove.
+ void RemoveElementsAt(index_type aStart, size_type aCount);
+
+ private:
+ // Remove a range of elements from this array, but do not check that
+ // the range is in bounds.
+ // @param aStart The starting index of the elements to remove.
+ // @param aCount The number of elements to remove.
+ void RemoveElementsAtUnsafe(index_type aStart, size_type aCount);
+
+ public:
+ // A variation on the RemoveElementsAt method defined above.
+ void RemoveElementAt(index_type aIndex) { RemoveElementsAt(aIndex, 1); }
+
+ // A variation on RemoveElementAt that removes the last element.
+ void RemoveLastElement() { RemoveLastElements(1); }
+
+ // A variation on RemoveElementsAt that removes the last 'aCount' elements.
+ void RemoveLastElements(const size_type aCount) {
+ // This assertion is redundant, but produces a better error message than the
+ // release assertion within TruncateLength.
+ MOZ_ASSERT(aCount <= Length());
+ TruncateLength(Length() - aCount);
+ }
+
+ // Removes the last element of the array and returns a copy of it.
+ [[nodiscard]] value_type PopLastElement() {
+ // This function intentionally does not call ElementsAt and calls
+ // TruncateLengthUnsafe directly to avoid multiple release checks for
+ // non-emptiness.
+ // This debug assertion is redundant, but produces a better error message
+ // than the release assertion below.
+ MOZ_ASSERT(!base_type::IsEmpty());
+ const size_type oldLen = Length();
+ if (MOZ_UNLIKELY(0 == oldLen)) {
+ mozilla::detail::InvalidArrayIndex_CRASH(1, 0);
+ }
+ value_type elem = std::move(Elements()[oldLen - 1]);
+ TruncateLengthUnsafe(oldLen - 1);
+ return elem;
+ }
+
+ // This method performs index-based removals from an array without preserving
+ // the order of the array. This is useful if you are using the array as a
+ // set-like data structure.
+ //
+ // These removals are efficient, as they move as few elements as possible. At
+ // most N elements, where N is the number of removed elements, will have to
+ // be relocated.
+ //
+ // ## Examples
+ //
+ // When removing an element from the end of the array, it can be removed in
+ // place, by destroying it and decrementing the length.
+ //
+ // [ 1, 2, 3 ] => [ 1, 2 ]
+ // ^
+ //
+ // When removing any other single element, it is removed by swapping it with
+ // the last element, and then decrementing the length as before.
+ //
+ // [ 1, 2, 3, 4, 5, 6 ] => [ 1, 6, 3, 4, 5 ]
+ // ^
+ //
+ // This method also supports efficiently removing a range of elements. If they
+ // are at the end, then they can all be removed like in the one element case.
+ //
+ // [ 1, 2, 3, 4, 5, 6 ] => [ 1, 2 ]
+ // ^--------^
+ //
+ // If more elements are removed than exist after the removed section, the
+ // remaining elements will be shifted down like in a normal removal.
+ //
+ // [ 1, 2, 3, 4, 5, 6, 7, 8 ] => [ 1, 2, 7, 8 ]
+ // ^--------^
+ //
+ // And if fewer elements are removed than exist after the removed section,
+ // elements will be moved from the end of the array to fill the vacated space.
+ //
+ // [ 1, 2, 3, 4, 5, 6, 7, 8 ] => [ 1, 7, 8, 4, 5, 6 ]
+ // ^--^
+ //
+ // @param aStart The starting index of the elements to remove. @param aCount
+ // The number of elements to remove.
+ void UnorderedRemoveElementsAt(index_type aStart, size_type aCount);
+
+ // A variation on the UnorderedRemoveElementsAt method defined above to remove
+ // a single element. This operation is sometimes called `SwapRemove`.
+ //
+ // This method is O(1), but does not preserve the order of the elements.
+ void UnorderedRemoveElementAt(index_type aIndex) {
+ UnorderedRemoveElementsAt(aIndex, 1);
+ }
+
+ void Clear() {
+ ClearAndRetainStorage();
+ base_type::ShrinkCapacityToZero(sizeof(value_type),
+ MOZ_ALIGNOF(value_type));
+ }
+
+ // This method removes elements based on the return value of the
+ // callback function aPredicate. If the function returns true for
+ // an element, the element is removed. aPredicate will be called
+ // for each element in order. It is not safe to access the array
+ // inside aPredicate.
+ //
+ // Returns the number of elements removed.
+ template <typename Predicate>
+ size_type RemoveElementsBy(Predicate aPredicate);
+
+ // This helper function combines IndexOf with RemoveElementAt to "search
+ // and destroy" the first element that is equal to the given element.
+ // @param aItem The item to search for.
+ // @param aComp The Comparator used to determine element equality.
+ // @return true if the element was found
+ template <class Item, class Comparator>
+ bool RemoveElement(const Item& aItem, const Comparator& aComp) {
+ index_type i = IndexOf(aItem, 0, aComp);
+ if (i == NoIndex) {
+ return false;
+ }
+
+ RemoveElementsAtUnsafe(i, 1);
+ return true;
+ }
+
+ // A variation on the RemoveElement method defined above that assumes
+ // that 'operator==' is defined for value_type.
+ template <class Item>
+ bool RemoveElement(const Item& aItem) {
+ return RemoveElement(aItem, nsDefaultComparator<value_type, Item>());
+ }
+
+ // This helper function combines IndexOfFirstElementGt with
+ // RemoveElementAt to "search and destroy" the last element that
+ // is equal to the given element.
+ // @param aItem The item to search for.
+ // @param aComp The Comparator used to determine element equality.
+ // @return true if the element was found
+ template <class Item, class Comparator>
+ bool RemoveElementSorted(const Item& aItem, const Comparator& aComp) {
+ index_type index = IndexOfFirstElementGt(aItem, aComp);
+ if (index > 0 && aComp.Equals(ElementAt(index - 1), aItem)) {
+ RemoveElementsAtUnsafe(index - 1, 1);
+ return true;
+ }
+ return false;
+ }
+
+ // A variation on the RemoveElementSorted method defined above.
+ template <class Item>
+ bool RemoveElementSorted(const Item& aItem) {
+ return RemoveElementSorted(aItem, nsDefaultComparator<value_type, Item>());
+ }
+
+ // This method causes the elements contained in this array and the given
+ // array to be swapped.
+ template <class Allocator>
+ void SwapElements(nsTArray_Impl<E, Allocator>& aOther) {
+ // The only case this might fail were if someone called this with a
+ // AutoTArray upcast to nsTArray_Impl, under the conditions mentioned in the
+ // overload for AutoTArray below.
+ this->template SwapArrayElements<InfallibleAlloc>(
+ aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ template <size_t N>
+ void SwapElements(AutoTArray<E, N>& aOther) {
+ // Allocation might fail if Alloc==FallibleAlloc and
+ // Allocator==InfallibleAlloc and aOther uses auto storage. Allow this for
+ // small inline sizes, and crash in the rare case of a small OOM error.
+ static_assert(!std::is_same_v<Alloc, FallibleAlloc> ||
+ sizeof(E) * N <= 1024);
+ this->template SwapArrayElements<InfallibleAlloc>(
+ aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ template <class Allocator>
+ [[nodiscard]] auto SwapElements(nsTArray_Impl<E, Allocator>& aOther,
+ const mozilla::fallible_t&) {
+ // Allocation might fail if Alloc==FallibleAlloc and
+ // Allocator==InfallibleAlloc and aOther uses auto storage.
+ return FallibleAlloc::Result(
+ this->template SwapArrayElements<FallibleAlloc>(
+ aOther, sizeof(value_type), MOZ_ALIGNOF(value_type)));
+ }
+
+ private:
+ // Used by ApplyIf functions to invoke a callable that takes either:
+ // - Nothing: F(void)
+ // - Index only: F(size_t)
+ // - Reference to element only: F(maybe-const value_type&)
+ // - Both index and reference: F(size_t, maybe-const value_type&)
+ // `value_type` must be const when called from const method.
+ template <typename T, typename Param0, typename Param1>
+ struct InvokeWithIndexAndOrReferenceHelper {
+ static constexpr bool valid = false;
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, void, void> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t, T&) {
+ return f();
+ }
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, size_t, void> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t i, T&) {
+ return f(i);
+ }
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, T&, void> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t, T& e) {
+ return f(e);
+ }
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, const T&, void> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t, T& e) {
+ return f(e);
+ }
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, size_t, T&> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t i, T& e) {
+ return f(i, e);
+ }
+ };
+ template <typename T>
+ struct InvokeWithIndexAndOrReferenceHelper<T, size_t, const T&> {
+ static constexpr bool valid = true;
+ template <typename F>
+ static auto Invoke(F&& f, size_t i, T& e) {
+ return f(i, e);
+ }
+ };
+ template <typename T, typename F>
+ static auto InvokeWithIndexAndOrReference(F&& f, size_t i, T& e) {
+ using Invoker = InvokeWithIndexAndOrReferenceHelper<
+ T, typename mozilla::FunctionTypeTraits<F>::template ParameterType<0>,
+ typename mozilla::FunctionTypeTraits<F>::template ParameterType<1>>;
+ static_assert(Invoker::valid,
+ "ApplyIf's Function parameters must match either: (void), "
+ "(size_t), (maybe-const value_type&), or "
+ "(size_t, maybe-const value_type&)");
+ return Invoker::Invoke(std::forward<F>(f), i, e);
+ }
+
+ public:
+ // 'Apply' family of methods.
+ //
+ // The advantages of using Apply methods with lambdas include:
+ // - Safety of accessing elements from within the call, when the array cannot
+ // have been modified between the iteration and the subsequent access.
+ // - Avoiding moot conversions: pointer->index during a search, followed by
+ // index->pointer after the search when accessing the element.
+ // - Embedding your code into the algorithm, giving the compiler more chances
+ // to optimize.
+
+ // Search for the first element comparing equal to aItem with the given
+ // comparator (`==` by default).
+ // If such an element exists, return the result of evaluating either:
+ // - `aFunction()`
+ // - `aFunction(index_type)`
+ // - `aFunction(maybe-const? value_type&)`
+ // - `aFunction(index_type, maybe-const? value_type&)`
+ // (`aFunction` must have one of the above signatures with these exact types,
+ // including references; implicit conversions or generic types not allowed.
+ // If `this` array is const, the referenced `value_type` must be const too;
+ // otherwise it may be either const or non-const.)
+ // But if the element is not found, return the result of evaluating
+ // `aFunctionElse()`.
+ template <class Item, class Comparator, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, index_type aStart, const Comparator& aComp,
+ Function&& aFunction, FunctionElse&& aFunctionElse) const {
+ static_assert(
+ std::is_same_v<
+ typename mozilla::FunctionTypeTraits<Function>::ReturnType,
+ typename mozilla::FunctionTypeTraits<FunctionElse>::ReturnType>,
+ "ApplyIf's `Function` and `FunctionElse` must return the same type.");
+
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ const value_type* const elements = Elements();
+ const value_type* const iend = elements + Length();
+ for (const value_type* iter = elements + aStart; iter != iend; ++iter) {
+ if (comp.Equals(*iter, aItem)) {
+ return InvokeWithIndexAndOrReference<const value_type>(
+ std::forward<Function>(aFunction), iter - elements, *iter);
+ }
+ }
+ return aFunctionElse();
+ }
+ template <class Item, class Comparator, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, index_type aStart, const Comparator& aComp,
+ Function&& aFunction, FunctionElse&& aFunctionElse) {
+ static_assert(
+ std::is_same_v<
+ typename mozilla::FunctionTypeTraits<Function>::ReturnType,
+ typename mozilla::FunctionTypeTraits<FunctionElse>::ReturnType>,
+ "ApplyIf's `Function` and `FunctionElse` must return the same type.");
+
+ ::detail::CompareWrapper<Comparator, Item> comp(aComp);
+
+ value_type* const elements = Elements();
+ value_type* const iend = elements + Length();
+ for (value_type* iter = elements + aStart; iter != iend; ++iter) {
+ if (comp.Equals(*iter, aItem)) {
+ return InvokeWithIndexAndOrReference<value_type>(
+ std::forward<Function>(aFunction), iter - elements, *iter);
+ }
+ }
+ return aFunctionElse();
+ }
+ template <class Item, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, index_type aStart, Function&& aFunction,
+ FunctionElse&& aFunctionElse) const {
+ return ApplyIf(aItem, aStart, nsDefaultComparator<value_type, Item>(),
+ std::forward<Function>(aFunction),
+ std::forward<FunctionElse>(aFunctionElse));
+ }
+ template <class Item, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, index_type aStart, Function&& aFunction,
+ FunctionElse&& aFunctionElse) {
+ return ApplyIf(aItem, aStart, nsDefaultComparator<value_type, Item>(),
+ std::forward<Function>(aFunction),
+ std::forward<FunctionElse>(aFunctionElse));
+ }
+ template <class Item, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, Function&& aFunction,
+ FunctionElse&& aFunctionElse) const {
+ return ApplyIf(aItem, 0, std::forward<Function>(aFunction),
+ std::forward<FunctionElse>(aFunctionElse));
+ }
+ template <class Item, class Function, class FunctionElse>
+ auto ApplyIf(const Item& aItem, Function&& aFunction,
+ FunctionElse&& aFunctionElse) {
+ return ApplyIf(aItem, 0, std::forward<Function>(aFunction),
+ std::forward<FunctionElse>(aFunctionElse));
+ }
+
+ //
+ // Allocation
+ //
+
+ // This method may increase the capacity of this array object to the
+ // specified amount. This method may be called in advance of several
+ // AppendElement operations to minimize heap re-allocations. This method
+ // will not reduce the number of elements in this array.
+ // @param aCapacity The desired capacity of this array.
+ // @return True if the operation succeeded; false if we ran out of memory
+ protected:
+ template <typename ActualAlloc = Alloc>
+ typename ActualAlloc::ResultType SetCapacity(size_type aCapacity) {
+ return ActualAlloc::Result(this->template EnsureCapacity<ActualAlloc>(
+ aCapacity, sizeof(value_type)));
+ }
+
+ public:
+ [[nodiscard]] bool SetCapacity(size_type aCapacity,
+ const mozilla::fallible_t&) {
+ return SetCapacity<FallibleAlloc>(aCapacity);
+ }
+
+ // This method modifies the length of the array. If the new length is
+ // larger than the existing length of the array, then new elements will be
+ // constructed using value_type's default constructor. Otherwise, this call
+ // removes elements from the array (see also RemoveElementsAt).
+ // @param aNewLen The desired length of this array.
+ // @return True if the operation succeeded; false otherwise.
+ // See also TruncateLength for a more efficient variant if the new length is
+ // guaranteed to be smaller than the old.
+ protected:
+ template <typename ActualAlloc = Alloc>
+ typename ActualAlloc::ResultType SetLength(size_type aNewLen) {
+ const size_type oldLen = Length();
+ if (aNewLen > oldLen) {
+ return ActualAlloc::ConvertBoolToResultType(
+ InsertElementsAtInternal<ActualAlloc>(oldLen, aNewLen - oldLen) !=
+ nullptr);
+ }
+
+ TruncateLengthUnsafe(aNewLen);
+ return ActualAlloc::ConvertBoolToResultType(true);
+ }
+
+ public:
+ [[nodiscard]] bool SetLength(size_type aNewLen, const mozilla::fallible_t&) {
+ return SetLength<FallibleAlloc>(aNewLen);
+ }
+
+ // This method modifies the length of the array, but may only be
+ // called when the new length is shorter than the old. It can
+ // therefore be called when value_type has no default constructor,
+ // unlike SetLength. It removes elements from the array (see also
+ // RemoveElementsAt).
+ // @param aNewLen The desired length of this array.
+ void TruncateLength(size_type aNewLen) {
+ // This assertion is redundant, but produces a better error message than the
+ // release assertion below.
+ MOZ_ASSERT(aNewLen <= Length(), "caller should use SetLength instead");
+
+ if (MOZ_UNLIKELY(aNewLen > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aNewLen, Length());
+ }
+
+ TruncateLengthUnsafe(aNewLen);
+ }
+
+ private:
+ void TruncateLengthUnsafe(size_type aNewLen) {
+ const size_type oldLen = Length();
+ if (oldLen) {
+ DestructRange(aNewLen, oldLen - aNewLen);
+ base_type::mHdr->mLength = aNewLen;
+ }
+ }
+
+ // This method ensures that the array has length at least the given
+ // length. If the current length is shorter than the given length,
+ // then new elements will be constructed using value_type's default
+ // constructor.
+ // @param aMinLen The desired minimum length of this array.
+ // @return True if the operation succeeded; false otherwise.
+ protected:
+ template <typename ActualAlloc = Alloc>
+ typename ActualAlloc::ResultType EnsureLengthAtLeast(size_type aMinLen) {
+ size_type oldLen = Length();
+ if (aMinLen > oldLen) {
+ return ActualAlloc::ConvertBoolToResultType(
+ !!InsertElementsAtInternal<ActualAlloc>(oldLen, aMinLen - oldLen));
+ }
+ return ActualAlloc::ConvertBoolToResultType(true);
+ }
+
+ public:
+ [[nodiscard]] bool EnsureLengthAtLeast(size_type aMinLen,
+ const mozilla::fallible_t&) {
+ return EnsureLengthAtLeast<FallibleAlloc>(aMinLen);
+ }
+
+ // This method inserts elements into the array, constructing
+ // them using value_type's default constructor.
+ // @param aIndex the place to insert the new elements. This must be no
+ // greater than the current length of the array.
+ // @param aCount the number of elements to insert
+ private:
+ template <typename ActualAlloc>
+ value_type* InsertElementsAtInternal(index_type aIndex, size_type aCount) {
+ if (!ActualAlloc::Successful(this->template InsertSlotsAt<ActualAlloc>(
+ aIndex, aCount, sizeof(value_type), MOZ_ALIGNOF(value_type)))) {
+ return nullptr;
+ }
+
+ // Initialize the extra array elements
+ value_type* iter = Elements() + aIndex;
+ value_type* iend = iter + aCount;
+ for (; iter != iend; ++iter) {
+ elem_traits::Construct(iter);
+ }
+
+ return Elements() + aIndex;
+ }
+
+ public:
+ [[nodiscard]] value_type* InsertElementsAt(index_type aIndex,
+ size_type aCount,
+ const mozilla::fallible_t&) {
+ return InsertElementsAtInternal<FallibleAlloc>(aIndex, aCount);
+ }
+
+ // This method inserts elements into the array, constructing them
+ // value_type's copy constructor (or whatever one-arg constructor
+ // happens to match the Item type).
+ // @param aIndex the place to insert the new elements. This must be no
+ // greater than the current length of the array.
+ // @param aCount the number of elements to insert.
+ // @param aItem the value to use when constructing the new elements.
+ private:
+ template <typename ActualAlloc, class Item>
+ value_type* InsertElementsAtInternal(index_type aIndex, size_type aCount,
+ const Item& aItem);
+
+ public:
+ template <class Item>
+ [[nodiscard]] value_type* InsertElementsAt(index_type aIndex,
+ size_type aCount,
+ const Item& aItem,
+ const mozilla::fallible_t&) {
+ return InsertElementsAt<Item, FallibleAlloc>(aIndex, aCount, aItem);
+ }
+
+ // This method may be called to minimize the memory used by this array.
+ void Compact() {
+ ShrinkCapacity(sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ //
+ // Sorting
+ //
+
+ // This function is meant to be used with the NS_QuickSort function. It
+ // maps the callback API expected by NS_QuickSort to the Comparator API
+ // used by nsTArray_Impl. See nsTArray_Impl::Sort.
+ template <class Comparator>
+ static int Compare(const void* aE1, const void* aE2, void* aData) {
+ const Comparator* c = reinterpret_cast<const Comparator*>(aData);
+ const value_type* a = static_cast<const value_type*>(aE1);
+ const value_type* b = static_cast<const value_type*>(aE2);
+ return c->Compare(*a, *b);
+ }
+
+ // This method sorts the elements of the array. It uses the LessThan
+ // method defined on the given Comparator object to collate elements.
+ // @param aComp The Comparator used to collate elements.
+ template <class Comparator>
+ void Sort(const Comparator& aComp) {
+ ::detail::CompareWrapper<Comparator, value_type> comp(aComp);
+
+ NS_QuickSort(Elements(), Length(), sizeof(value_type),
+ Compare<decltype(comp)>, &comp);
+ }
+
+ // A variation on the Sort method defined above that assumes that
+ // 'operator<' is defined for value_type.
+ void Sort() { Sort(nsDefaultComparator<value_type, value_type>()); }
+
+ // This method sorts the elements of the array in a stable way (i.e. not
+ // changing the relative order of elements considered equal by the
+ // Comparator). It uses the LessThan
+ // method defined on the given Comparator object to collate elements.
+ // @param aComp The Comparator used to collate elements.
+ template <class Comparator>
+ void StableSort(const Comparator& aComp) {
+ const ::detail::CompareWrapper<Comparator, value_type> comp(aComp);
+
+ std::stable_sort(Elements(), Elements() + Length(),
+ [&comp](const auto& lhs, const auto& rhs) {
+ return comp.LessThan(lhs, rhs);
+ });
+ }
+
+ // This method reverses the array in place.
+ void Reverse() {
+ value_type* elements = Elements();
+ const size_type len = Length();
+ for (index_type i = 0, iend = len / 2; i < iend; ++i) {
+ std::swap(elements[i], elements[len - i - 1]);
+ }
+ }
+
+ protected:
+ using base_type::Hdr;
+ using base_type::ShrinkCapacity;
+
+ // This method invokes value_type's destructor on a range of elements.
+ // @param aStart The index of the first element to destroy.
+ // @param aCount The number of elements to destroy.
+ void DestructRange(index_type aStart, size_type aCount) {
+ value_type* iter = Elements() + aStart;
+ value_type* iend = iter + aCount;
+ for (; iter != iend; ++iter) {
+ elem_traits::Destruct(iter);
+ }
+ }
+
+ // This method invokes value_type's copy-constructor on a range of elements.
+ // @param aStart The index of the first element to construct.
+ // @param aCount The number of elements to construct.
+ // @param aValues The array of elements to copy.
+ template <class Item>
+ void AssignRange(index_type aStart, size_type aCount, const Item* aValues) {
+ AssignRangeAlgorithm<
+ std::is_trivially_copy_constructible_v<Item>,
+ std::is_same_v<Item, value_type>>::implementation(Elements(), aStart,
+ aCount, aValues);
+ }
+};
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::AssignInternal(const Item* aArray,
+ size_type aArrayLen) ->
+ typename ActualAlloc::ResultType {
+ static_assert(std::is_same_v<ActualAlloc, InfallibleAlloc> ||
+ std::is_same_v<ActualAlloc, FallibleAlloc>);
+
+ if constexpr (std::is_same_v<ActualAlloc, InfallibleAlloc>) {
+ ClearAndRetainStorage();
+ }
+ // Adjust memory allocation up-front to catch errors in the fallible case.
+ // We might relocate the elements to be destroyed unnecessarily. This could be
+ // optimized, but would make things more complicated.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ aArrayLen, sizeof(value_type)))) {
+ return ActualAlloc::ConvertBoolToResultType(false);
+ }
+
+ MOZ_ASSERT_IF(this->HasEmptyHeader(), aArrayLen == 0);
+ if (!this->HasEmptyHeader()) {
+ if constexpr (std::is_same_v<ActualAlloc, FallibleAlloc>) {
+ ClearAndRetainStorage();
+ }
+ AssignRange(0, aArrayLen, aArray);
+ base_type::mHdr->mLength = aArrayLen;
+ }
+
+ return ActualAlloc::ConvertBoolToResultType(true);
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::ReplaceElementsAtInternal(index_type aStart,
+ size_type aCount,
+ const Item* aArray,
+ size_type aArrayLen)
+ -> value_type* {
+ if (MOZ_UNLIKELY(aStart > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aStart, Length());
+ }
+ if (MOZ_UNLIKELY(aCount > Length() - aStart)) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aStart + aCount, Length());
+ }
+
+ // Adjust memory allocation up-front to catch errors.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ Length() + aArrayLen - aCount, sizeof(value_type)))) {
+ return nullptr;
+ }
+ DestructRange(aStart, aCount);
+ this->template ShiftData<ActualAlloc>(
+ aStart, aCount, aArrayLen, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ AssignRange(aStart, aArrayLen, aArray);
+ return Elements() + aStart;
+}
+
+template <typename E, class Alloc>
+void nsTArray_Impl<E, Alloc>::RemoveElementsAt(index_type aStart,
+ size_type aCount) {
+ MOZ_ASSERT(aCount == 0 || aStart < Length(), "Invalid aStart index");
+
+ mozilla::CheckedInt<index_type> rangeEnd = aStart;
+ rangeEnd += aCount;
+
+ if (MOZ_UNLIKELY(!rangeEnd.isValid() || rangeEnd.value() > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aStart, Length());
+ }
+
+ RemoveElementsAtUnsafe(aStart, aCount);
+}
+
+template <typename E, class Alloc>
+void nsTArray_Impl<E, Alloc>::RemoveElementsAtUnsafe(index_type aStart,
+ size_type aCount) {
+ DestructRange(aStart, aCount);
+ this->template ShiftData<InfallibleAlloc>(
+ aStart, aCount, 0, sizeof(value_type), MOZ_ALIGNOF(value_type));
+}
+
+template <typename E, class Alloc>
+void nsTArray_Impl<E, Alloc>::UnorderedRemoveElementsAt(index_type aStart,
+ size_type aCount) {
+ MOZ_ASSERT(aCount == 0 || aStart < Length(), "Invalid aStart index");
+
+ mozilla::CheckedInt<index_type> rangeEnd = aStart;
+ rangeEnd += aCount;
+
+ if (MOZ_UNLIKELY(!rangeEnd.isValid() || rangeEnd.value() > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aStart, Length());
+ }
+
+ // Destroy the elements which are being removed, and then swap elements in to
+ // replace them from the end. See the docs on the declaration of this
+ // function.
+ DestructRange(aStart, aCount);
+ this->template SwapFromEnd<InfallibleAlloc>(
+ aStart, aCount, sizeof(value_type), MOZ_ALIGNOF(value_type));
+}
+
+template <typename E, class Alloc>
+template <typename Predicate>
+auto nsTArray_Impl<E, Alloc>::RemoveElementsBy(Predicate aPredicate)
+ -> size_type {
+ if (this->HasEmptyHeader()) {
+ return 0;
+ }
+
+ index_type j = 0;
+ const index_type len = Length();
+ value_type* const elements = Elements();
+ for (index_type i = 0; i < len; ++i) {
+ const bool result = aPredicate(elements[i]);
+
+ // Check that the array has not been modified by the predicate.
+ MOZ_DIAGNOSTIC_ASSERT(len == base_type::mHdr->mLength &&
+ elements == Elements());
+
+ if (result) {
+ elem_traits::Destruct(elements + i);
+ } else {
+ if (j < i) {
+ relocation_type::RelocateNonOverlappingRegion(
+ elements + j, elements + i, 1, sizeof(value_type));
+ }
+ ++j;
+ }
+ }
+
+ base_type::mHdr->mLength = j;
+ return len - j;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::InsertElementsAtInternal(index_type aIndex,
+ size_type aCount,
+ const Item& aItem)
+ -> value_type* {
+ if (!ActualAlloc::Successful(this->template InsertSlotsAt<ActualAlloc>(
+ aIndex, aCount, sizeof(value_type), MOZ_ALIGNOF(value_type)))) {
+ return nullptr;
+ }
+
+ // Initialize the extra array elements
+ value_type* iter = Elements() + aIndex;
+ value_type* iend = iter + aCount;
+ for (; iter != iend; ++iter) {
+ elem_traits::Construct(iter, aItem);
+ }
+
+ return Elements() + aIndex;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc>
+auto nsTArray_Impl<E, Alloc>::InsertElementAtInternal(index_type aIndex)
+ -> value_type* {
+ if (MOZ_UNLIKELY(aIndex > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
+ }
+
+ // Length() + 1 is guaranteed to not overflow, so EnsureCapacity is OK.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ Length() + 1, sizeof(value_type)))) {
+ return nullptr;
+ }
+ this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type),
+ MOZ_ALIGNOF(value_type));
+ value_type* elem = Elements() + aIndex;
+ elem_traits::Construct(elem);
+ return elem;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::InsertElementAtInternal(index_type aIndex,
+ Item&& aItem)
+ -> value_type* {
+ if (MOZ_UNLIKELY(aIndex > Length())) {
+ mozilla::detail::InvalidArrayIndex_CRASH(aIndex, Length());
+ }
+
+ // Length() + 1 is guaranteed to not overflow, so EnsureCapacity is OK.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ Length() + 1, sizeof(value_type)))) {
+ return nullptr;
+ }
+ this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(value_type),
+ MOZ_ALIGNOF(value_type));
+ value_type* elem = Elements() + aIndex;
+ elem_traits::Construct(elem, std::forward<Item>(aItem));
+ return elem;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::AppendElementsInternal(const Item* aArray,
+ size_type aArrayLen)
+ -> value_type* {
+ if (!ActualAlloc::Successful(this->template ExtendCapacity<ActualAlloc>(
+ Length(), aArrayLen, sizeof(value_type)))) {
+ return nullptr;
+ }
+ index_type len = Length();
+ AssignRange(len, aArrayLen, aArray);
+ this->IncrementLength(aArrayLen);
+ return Elements() + len;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item, class Allocator>
+auto nsTArray_Impl<E, Alloc>::AppendElementsInternal(
+ nsTArray_Impl<Item, Allocator>&& aArray) -> value_type* {
+ if constexpr (std::is_same_v<Alloc, Allocator>) {
+ MOZ_ASSERT(&aArray != this, "argument must be different aArray");
+ }
+ if (Length() == 0) {
+ // XXX This might still be optimized. If aArray uses auto-storage but we
+ // won't, we might better retain our storage if it's sufficiently large.
+ this->ShrinkCapacityToZero(sizeof(value_type), MOZ_ALIGNOF(value_type));
+ this->MoveInit(aArray, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ return Elements();
+ }
+
+ index_type len = Length();
+ index_type otherLen = aArray.Length();
+ if (!ActualAlloc::Successful(this->template ExtendCapacity<ActualAlloc>(
+ len, otherLen, sizeof(value_type)))) {
+ return nullptr;
+ }
+ relocation_type::RelocateNonOverlappingRegion(
+ Elements() + len, aArray.Elements(), otherLen, sizeof(value_type));
+ this->IncrementLength(otherLen);
+ aArray.template ShiftData<ActualAlloc>(0, otherLen, 0, sizeof(value_type),
+ MOZ_ALIGNOF(value_type));
+ return Elements() + len;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class Item>
+auto nsTArray_Impl<E, Alloc>::AppendElementInternal(Item&& aItem)
+ -> value_type* {
+ // Length() + 1 is guaranteed to not overflow, so EnsureCapacity is OK.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ Length() + 1, sizeof(value_type)))) {
+ return nullptr;
+ }
+ value_type* elem = Elements() + Length();
+ elem_traits::Construct(elem, std::forward<Item>(aItem));
+ this->mHdr->mLength += 1;
+ return elem;
+}
+
+template <typename E, class Alloc>
+template <typename ActualAlloc, class... Args>
+auto nsTArray_Impl<E, Alloc>::EmplaceBackInternal(Args&&... aArgs)
+ -> value_type* {
+ // Length() + 1 is guaranteed to not overflow, so EnsureCapacity is OK.
+ if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
+ Length() + 1, sizeof(value_type)))) {
+ return nullptr;
+ }
+ value_type* elem = Elements() + Length();
+ elem_traits::Emplace(elem, std::forward<Args>(aArgs)...);
+ this->mHdr->mLength += 1;
+ return elem;
+}
+
+template <typename E, typename Alloc>
+inline void ImplCycleCollectionUnlink(nsTArray_Impl<E, Alloc>& aField) {
+ aField.Clear();
+}
+
+namespace detail {
+// This is defined in the cpp file to avoid including
+// nsCycleCollectionNoteChild.h in this header file.
+void SetCycleCollectionArrayFlag(uint32_t& aFlags);
+} // namespace detail
+
+template <typename E, typename Alloc>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ nsTArray_Impl<E, Alloc>& aField, const char* aName, uint32_t aFlags = 0) {
+ ::detail::SetCycleCollectionArrayFlag(aFlags);
+ size_t length = aField.Length();
+ for (size_t i = 0; i < length; ++i) {
+ ImplCycleCollectionTraverse(aCallback, aField[i], aName, aFlags);
+ }
+}
+
+//
+// nsTArray is an infallible vector class. See the comment at the top of this
+// file for more details.
+//
+template <class E>
+class nsTArray : public nsTArray_Impl<E, nsTArrayInfallibleAllocator> {
+ public:
+ using InfallibleAlloc = nsTArrayInfallibleAllocator;
+ using base_type = nsTArray_Impl<E, InfallibleAlloc>;
+ using self_type = nsTArray<E>;
+ using typename base_type::index_type;
+ using typename base_type::size_type;
+ using typename base_type::value_type;
+
+ nsTArray() {}
+ explicit nsTArray(size_type aCapacity) : base_type(aCapacity) {}
+ MOZ_IMPLICIT nsTArray(std::initializer_list<E> aIL) {
+ AppendElements(aIL.begin(), aIL.size());
+ }
+
+ template <class Item>
+ nsTArray(const Item* aArray, size_type aArrayLen) {
+ AppendElements(aArray, aArrayLen);
+ }
+
+ template <class Item>
+ explicit nsTArray(mozilla::Span<Item> aSpan) {
+ AppendElements(aSpan);
+ }
+
+ template <class Allocator>
+ explicit nsTArray(const nsTArray_Impl<E, Allocator>& aOther)
+ : base_type(aOther) {}
+ template <class Allocator>
+ MOZ_IMPLICIT nsTArray(nsTArray_Impl<E, Allocator>&& aOther)
+ : base_type(std::move(aOther)) {}
+
+ template <class Allocator>
+ self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther) {
+ base_type::operator=(aOther);
+ return *this;
+ }
+ template <class Allocator>
+ self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
+ // This is quite complex, since we don't know if we are an AutoTArray. While
+ // AutoTArray overrides this operator=, this might be called on a nsTArray&
+ // bound to an AutoTArray.
+ base_type::operator=(std::move(aOther));
+ return *this;
+ }
+
+ using base_type::AppendElement;
+ using base_type::AppendElements;
+ using base_type::EmplaceBack;
+ using base_type::EnsureLengthAtLeast;
+ using base_type::InsertElementAt;
+ using base_type::InsertElementsAt;
+ using base_type::InsertElementSorted;
+ using base_type::ReplaceElementsAt;
+ using base_type::SetCapacity;
+ using base_type::SetLength;
+
+ template <class Item>
+ mozilla::NotNull<value_type*> AppendElements(const Item* aArray,
+ size_type aArrayLen) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(aArray,
+ aArrayLen));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> AppendElements(mozilla::Span<Item> aSpan) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(aSpan.Elements(),
+ aSpan.Length()));
+ }
+
+ template <class Item, class Allocator>
+ mozilla::NotNull<value_type*> AppendElements(
+ const nsTArray_Impl<Item, Allocator>& aArray) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(
+ aArray.Elements(), aArray.Length()));
+ }
+
+ template <class Item, class Allocator>
+ mozilla::NotNull<value_type*> AppendElements(
+ nsTArray_Impl<Item, Allocator>&& aArray) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(
+ std::move(aArray)));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> AppendElement(Item&& aItem) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementInternal<InfallibleAlloc>(
+ std::forward<Item>(aItem)));
+ }
+
+ mozilla::NotNull<value_type*> AppendElements(size_type aCount) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(aCount));
+ }
+
+ mozilla::NotNull<value_type*> AppendElement() {
+ return mozilla::WrapNotNullUnchecked(
+ this->template AppendElementsInternal<InfallibleAlloc>(1));
+ }
+
+ self_type Clone() const {
+ self_type result;
+ result.Assign(*this);
+ return result;
+ }
+
+ mozilla::NotNull<value_type*> InsertElementsAt(index_type aIndex,
+ size_type aCount) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementsAtInternal<InfallibleAlloc>(aIndex,
+ aCount));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> InsertElementsAt(index_type aIndex,
+ size_type aCount,
+ const Item& aItem) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementsAtInternal<InfallibleAlloc>(aIndex, aCount,
+ aItem));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> InsertElementsAt(index_type aIndex,
+ const Item* aArray,
+ size_type aArrayLen) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template ReplaceElementsAtInternal<InfallibleAlloc>(
+ aIndex, 0, aArray, aArrayLen));
+ }
+
+ template <class Item, class Allocator>
+ mozilla::NotNull<value_type*> InsertElementsAt(
+ index_type aIndex, const nsTArray_Impl<Item, Allocator>& aArray) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template ReplaceElementsAtInternal<InfallibleAlloc>(
+ aIndex, 0, aArray.Elements(), aArray.Length()));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> InsertElementsAt(index_type aIndex,
+ mozilla::Span<Item> aSpan) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template ReplaceElementsAtInternal<InfallibleAlloc>(
+ aIndex, 0, aSpan.Elements(), aSpan.Length()));
+ }
+
+ mozilla::NotNull<value_type*> InsertElementAt(index_type aIndex) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementAtInternal<InfallibleAlloc>(aIndex));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> InsertElementAt(index_type aIndex,
+ Item&& aItem) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementAtInternal<InfallibleAlloc>(
+ aIndex, std::forward<Item>(aItem)));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ const Item* aArray,
+ size_type aArrayLen) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template ReplaceElementsAtInternal<InfallibleAlloc>(
+ aStart, aCount, aArray, aArrayLen));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> ReplaceElementsAt(
+ index_type aStart, size_type aCount, const nsTArray<Item>& aArray) {
+ return ReplaceElementsAt(aStart, aCount, aArray.Elements(),
+ aArray.Length());
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ mozilla::Span<Item> aSpan) {
+ return ReplaceElementsAt(aStart, aCount, aSpan.Elements(), aSpan.Length());
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> ReplaceElementsAt(index_type aStart,
+ size_type aCount,
+ const Item& aItem) {
+ return ReplaceElementsAt(aStart, aCount, &aItem, 1);
+ }
+
+ template <class Item, class Comparator>
+ mozilla::NotNull<value_type*> InsertElementSorted(Item&& aItem,
+ const Comparator& aComp) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementSortedInternal<InfallibleAlloc>(
+ std::forward<Item>(aItem), aComp));
+ }
+
+ template <class Item>
+ mozilla::NotNull<value_type*> InsertElementSorted(Item&& aItem) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template InsertElementSortedInternal<InfallibleAlloc>(
+ std::forward<Item>(aItem),
+ nsDefaultComparator<value_type, Item>{}));
+ }
+
+ template <class... Args>
+ mozilla::NotNull<value_type*> EmplaceBack(Args&&... aArgs) {
+ return mozilla::WrapNotNullUnchecked(
+ this->template EmplaceBackInternal<InfallibleAlloc, Args...>(
+ std::forward<Args>(aArgs)...));
+ }
+};
+
+template <class E>
+class CopyableTArray : public nsTArray<E> {
+ public:
+ using nsTArray<E>::nsTArray;
+
+ CopyableTArray(const CopyableTArray& aOther) : nsTArray<E>() {
+ this->Assign(aOther);
+ }
+ CopyableTArray& operator=(const CopyableTArray& aOther) {
+ if (this != &aOther) {
+ this->Assign(aOther);
+ }
+ return *this;
+ }
+ template <typename Allocator>
+ MOZ_IMPLICIT CopyableTArray(const nsTArray_Impl<E, Allocator>& aOther) {
+ this->Assign(aOther);
+ }
+ template <typename Allocator>
+ CopyableTArray& operator=(const nsTArray_Impl<E, Allocator>& aOther) {
+ if constexpr (std::is_same_v<Allocator, nsTArrayInfallibleAllocator>) {
+ if (this == &aOther) {
+ return *this;
+ }
+ }
+ this->Assign(aOther);
+ return *this;
+ }
+ template <typename Allocator>
+ MOZ_IMPLICIT CopyableTArray(nsTArray_Impl<E, Allocator>&& aOther)
+ : nsTArray<E>{std::move(aOther)} {}
+ template <typename Allocator>
+ CopyableTArray& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
+ static_cast<nsTArray<E>&>(*this) = std::move(aOther);
+ return *this;
+ }
+
+ CopyableTArray(CopyableTArray&&) = default;
+ CopyableTArray& operator=(CopyableTArray&&) = default;
+};
+
+//
+// FallibleTArray is a fallible vector class.
+//
+template <class E>
+class FallibleTArray : public nsTArray_Impl<E, nsTArrayFallibleAllocator> {
+ public:
+ typedef nsTArray_Impl<E, nsTArrayFallibleAllocator> base_type;
+ typedef FallibleTArray<E> self_type;
+ typedef typename base_type::size_type size_type;
+
+ FallibleTArray() = default;
+ explicit FallibleTArray(size_type aCapacity) : base_type(aCapacity) {}
+
+ template <class Allocator>
+ explicit FallibleTArray(const nsTArray_Impl<E, Allocator>& aOther)
+ : base_type(aOther) {}
+ template <class Allocator>
+ explicit FallibleTArray(nsTArray_Impl<E, Allocator>&& aOther)
+ : base_type(std::move(aOther)) {}
+
+ template <class Allocator>
+ self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther) {
+ base_type::operator=(aOther);
+ return *this;
+ }
+ template <class Allocator>
+ self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
+ base_type::operator=(std::move(aOther));
+ return *this;
+ }
+};
+
+//
+// AutoTArray<E, N> is like nsTArray<E>, but with N elements of inline storage.
+// Storing more than N elements is fine, but it will cause a heap allocation.
+//
+template <class E, size_t N>
+class MOZ_NON_MEMMOVABLE AutoTArray : public nsTArray<E> {
+ static_assert(N != 0, "AutoTArray<E, 0> should be specialized");
+
+ public:
+ typedef AutoTArray<E, N> self_type;
+ typedef nsTArray<E> base_type;
+ typedef typename base_type::Header Header;
+ typedef typename base_type::value_type value_type;
+
+ AutoTArray() : mAlign() { Init(); }
+
+ AutoTArray(self_type&& aOther) : nsTArray<E>() {
+ Init();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ explicit AutoTArray(base_type&& aOther) : mAlign() {
+ Init();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ template <typename Allocator>
+ explicit AutoTArray(nsTArray_Impl<value_type, Allocator>&& aOther) {
+ Init();
+ this->MoveInit(aOther, sizeof(value_type), MOZ_ALIGNOF(value_type));
+ }
+
+ MOZ_IMPLICIT AutoTArray(std::initializer_list<E> aIL) : mAlign() {
+ Init();
+ this->AppendElements(aIL.begin(), aIL.size());
+ }
+
+ self_type& operator=(self_type&& aOther) {
+ base_type::operator=(std::move(aOther));
+ return *this;
+ }
+
+ template <typename Allocator>
+ self_type& operator=(nsTArray_Impl<value_type, Allocator>&& aOther) {
+ base_type::operator=(std::move(aOther));
+ return *this;
+ }
+
+ // Intentionally hides nsTArray_Impl::Clone to make clones usually be
+ // AutoTArray as well.
+ self_type Clone() const {
+ self_type result;
+ result.Assign(*this);
+ return result;
+ }
+
+ private:
+ // nsTArray_base casts itself as an nsAutoArrayBase in order to get a pointer
+ // to mAutoBuf.
+ template <class Allocator, class RelocationStrategy>
+ friend class nsTArray_base;
+
+ void Init() {
+ static_assert(MOZ_ALIGNOF(value_type) <= 8,
+ "can't handle alignments greater than 8, "
+ "see nsTArray_base::UsesAutoArrayBuffer()");
+ // Temporary work around for VS2012 RC compiler crash
+ Header** phdr = base_type::PtrToHdr();
+ *phdr = reinterpret_cast<Header*>(&mAutoBuf);
+ (*phdr)->mLength = 0;
+ (*phdr)->mCapacity = N;
+ (*phdr)->mIsAutoArray = 1;
+
+ MOZ_ASSERT(base_type::GetAutoArrayBuffer(MOZ_ALIGNOF(value_type)) ==
+ reinterpret_cast<Header*>(&mAutoBuf),
+ "GetAutoArrayBuffer needs to be fixed");
+ }
+
+ // Declare mAutoBuf aligned to the maximum of the header's alignment and
+ // value_type's alignment. We need to use a union rather than
+ // MOZ_ALIGNED_DECL because GCC is picky about what goes into
+ // __attribute__((aligned(foo))).
+ union {
+ char mAutoBuf[sizeof(nsTArrayHeader) + N * sizeof(value_type)];
+ // Do the max operation inline to ensure that it is a compile-time constant.
+ mozilla::AlignedElem<(MOZ_ALIGNOF(Header) > MOZ_ALIGNOF(value_type))
+ ? MOZ_ALIGNOF(Header)
+ : MOZ_ALIGNOF(value_type)>
+ mAlign;
+ };
+};
+
+//
+// Specialization of AutoTArray<E, N> for the case where N == 0.
+// AutoTArray<E, 0> behaves exactly like nsTArray<E>, but without this
+// specialization, it stores a useless inline header.
+//
+// We do have many AutoTArray<E, 0> objects in memory: about 2,000 per tab as
+// of May 2014. These are typically not explicitly AutoTArray<E, 0> but rather
+// AutoTArray<E, N> for some value N depending on template parameters, in
+// generic code.
+//
+// For that reason, we optimize this case with the below partial specialization,
+// which ensures that AutoTArray<E, 0> is just like nsTArray<E>, without any
+// inline header overhead.
+//
+template <class E>
+class AutoTArray<E, 0> : public nsTArray<E> {
+ using nsTArray<E>::nsTArray;
+};
+
+template <class E, size_t N>
+struct nsTArray_RelocationStrategy<AutoTArray<E, N>> {
+ using Type = nsTArray_RelocateUsingMoveConstructor<AutoTArray<E, N>>;
+};
+
+template <class E, size_t N>
+class CopyableAutoTArray : public AutoTArray<E, N> {
+ public:
+ typedef CopyableAutoTArray<E, N> self_type;
+ using AutoTArray<E, N>::AutoTArray;
+
+ CopyableAutoTArray(const CopyableAutoTArray& aOther) : AutoTArray<E, N>() {
+ this->Assign(aOther);
+ }
+ CopyableAutoTArray& operator=(const CopyableAutoTArray& aOther) {
+ if (this != &aOther) {
+ this->Assign(aOther);
+ }
+ return *this;
+ }
+ template <typename Allocator>
+ MOZ_IMPLICIT CopyableAutoTArray(const nsTArray_Impl<E, Allocator>& aOther) {
+ this->Assign(aOther);
+ }
+ template <typename Allocator>
+ CopyableAutoTArray& operator=(const nsTArray_Impl<E, Allocator>& aOther) {
+ if constexpr (std::is_same_v<Allocator, nsTArrayInfallibleAllocator>) {
+ if (this == &aOther) {
+ return *this;
+ }
+ }
+ this->Assign(aOther);
+ return *this;
+ }
+ template <typename Allocator>
+ MOZ_IMPLICIT CopyableAutoTArray(nsTArray_Impl<E, Allocator>&& aOther)
+ : AutoTArray<E, N>{std::move(aOther)} {}
+ template <typename Allocator>
+ CopyableAutoTArray& operator=(nsTArray_Impl<E, Allocator>&& aOther) {
+ static_cast<AutoTArray<E, N>&>(*this) = std::move(aOther);
+ return *this;
+ }
+
+ // CopyableTArray exists for cases where an explicit Clone is not possible.
+ // These uses should not be mixed, so we delete Clone() here.
+ self_type Clone() const = delete;
+
+ CopyableAutoTArray(CopyableAutoTArray&&) = default;
+ CopyableAutoTArray& operator=(CopyableAutoTArray&&) = default;
+};
+
+namespace mozilla {
+template <typename E, typename ArrayT>
+class nsTArrayBackInserter {
+ ArrayT* mArray;
+
+ class Proxy {
+ ArrayT& mArray;
+
+ public:
+ explicit Proxy(ArrayT& aArray) : mArray{aArray} {}
+
+ template <typename E2>
+ void operator=(E2&& aValue) {
+ mArray.AppendElement(std::forward<E2>(aValue));
+ }
+ };
+
+ public:
+ using iterator_category = std::output_iterator_tag;
+ using value_type = void;
+ using difference_type = void;
+ using pointer = void;
+ using reference = void;
+ explicit nsTArrayBackInserter(ArrayT& aArray) : mArray{&aArray} {}
+
+ // Return a proxy so that nsTArrayBackInserter has the default special member
+ // functions, and the operator= template is defined in Proxy rather than this
+ // class (which otherwise breaks with recent MS STL versions).
+ // See also Bug 1331137, comment 11.
+ Proxy operator*() { return Proxy(*mArray); }
+
+ nsTArrayBackInserter& operator++() { return *this; }
+ nsTArrayBackInserter& operator++(int) { return *this; }
+};
+} // namespace mozilla
+
+template <typename E>
+auto MakeBackInserter(nsTArray<E>& aArray) {
+ return mozilla::nsTArrayBackInserter<E, nsTArray<E>>{aArray};
+}
+
+// Span integration
+namespace mozilla {
+template <typename E, class Alloc>
+Span(nsTArray_Impl<E, Alloc>&) -> Span<E>;
+
+template <typename E, class Alloc>
+Span(const nsTArray_Impl<E, Alloc>&) -> Span<const E>;
+
+// Provides a view on a nsTArray through which the existing array elements can
+// be accessed in a non-const way, but the array itself cannot be modified, so
+// that references to elements are guaranteed to be stable.
+template <typename E>
+class nsTArrayView {
+ public:
+ using element_type = E;
+ using pointer = element_type*;
+ using reference = element_type&;
+ using index_type = typename Span<element_type>::index_type;
+ using size_type = typename Span<element_type>::index_type;
+
+ explicit nsTArrayView(nsTArray<element_type> aArray)
+ : mArray(std::move(aArray)), mSpan(mArray) {}
+
+ element_type& operator[](index_type aIndex) { return mSpan[aIndex]; }
+
+ const element_type& operator[](index_type aIndex) const {
+ return mSpan[aIndex];
+ }
+
+ size_type Length() const { return mSpan.Length(); }
+
+ auto begin() { return mSpan.begin(); }
+ auto end() { return mSpan.end(); }
+ auto begin() const { return mSpan.begin(); }
+ auto end() const { return mSpan.end(); }
+ auto cbegin() const { return mSpan.cbegin(); }
+ auto cend() const { return mSpan.cend(); }
+
+ Span<element_type> AsSpan() { return mSpan; }
+ Span<const element_type> AsSpan() const { return mSpan; }
+
+ private:
+ nsTArray<element_type> mArray;
+ const Span<element_type> mSpan;
+};
+
+template <typename Range, typename = std::enable_if_t<std::is_same_v<
+ typename std::iterator_traits<
+ typename Range::iterator>::iterator_category,
+ std::random_access_iterator_tag>>>
+auto RangeSize(const Range& aRange) {
+ // See https://en.cppreference.com/w/cpp/iterator/begin, section 'User-defined
+ // overloads'.
+ using std::begin;
+ using std::end;
+
+ return std::distance(begin(aRange), end(aRange));
+}
+
+/**
+ * Materialize a range as a nsTArray (or a compatible variant, like AutoTArray)
+ * of an explicitly specified type. The array value type must be implicitly
+ * convertible from the range's value type.
+ */
+template <typename Array, typename Range>
+auto ToTArray(const Range& aRange) {
+ using std::begin;
+ using std::end;
+
+ Array res;
+ res.SetCapacity(RangeSize(aRange));
+ std::copy(begin(aRange), end(aRange), MakeBackInserter(res));
+ return res;
+}
+
+/**
+ * Materialize a range as a nsTArray of its (decayed) value type.
+ */
+template <typename Range>
+auto ToArray(const Range& aRange) {
+ return ToTArray<nsTArray<std::decay_t<
+ typename std::iterator_traits<typename Range::iterator>::value_type>>>(
+ aRange);
+}
+
+/**
+ * Appends all elements from a range to an array.
+ */
+template <typename Array, typename Range>
+void AppendToArray(Array& aArray, const Range& aRange) {
+ using std::begin;
+ using std::end;
+
+ aArray.SetCapacity(aArray.Length() + RangeSize(aRange));
+ std::copy(begin(aRange), end(aRange), MakeBackInserter(aArray));
+}
+
+} // namespace mozilla
+
+// MOZ_DBG support
+
+template <class E, class Alloc>
+std::ostream& operator<<(std::ostream& aOut,
+ const nsTArray_Impl<E, Alloc>& aTArray) {
+ return aOut << mozilla::Span(aTArray);
+}
+
+// Assert that AutoTArray doesn't have any extra padding inside.
+//
+// It's important that the data stored in this auto array takes up a multiple of
+// 8 bytes; e.g. AutoTArray<uint32_t, 1> wouldn't work. Since AutoTArray
+// contains a pointer, its size must be a multiple of alignof(void*). (This is
+// because any type may be placed into an array, and there's no padding between
+// elements of an array.) The compiler pads the end of the structure to
+// enforce this rule.
+//
+// If we used AutoTArray<uint32_t, 1> below, this assertion would fail on a
+// 64-bit system, where the compiler inserts 4 bytes of padding at the end of
+// the auto array to make its size a multiple of alignof(void*) == 8 bytes.
+
+static_assert(sizeof(AutoTArray<uint32_t, 2>) ==
+ sizeof(void*) + sizeof(nsTArrayHeader) + sizeof(uint32_t) * 2,
+ "AutoTArray shouldn't contain any extra padding, "
+ "see the comment");
+
+// Definitions of nsTArray_Impl methods
+#include "nsTArray-inl.h"
+
+#endif // nsTArray_h__
diff --git a/xpcom/ds/nsTArrayForwardDeclare.h b/xpcom/ds/nsTArrayForwardDeclare.h
new file mode 100644
index 0000000000..f888550803
--- /dev/null
+++ b/xpcom/ds/nsTArrayForwardDeclare.h
@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTArrayForwardDeclare_h__
+#define nsTArrayForwardDeclare_h__
+
+//
+// This simple header file contains forward declarations for the TArray family
+// of classes.
+//
+// Including this header is preferable to writing
+//
+// template<class E> class nsTArray;
+//
+// yourself, since this header gives us flexibility to e.g. change the default
+// template parameters.
+//
+
+#include <stddef.h>
+
+template <class E>
+class nsTArray;
+
+template <class E>
+class FallibleTArray;
+
+template <class E>
+class CopyableTArray;
+
+template <class E, size_t N>
+class AutoTArray;
+
+template <class E, size_t N>
+class CopyableAutoTArray;
+
+#endif
diff --git a/xpcom/ds/nsTHashMap.h b/xpcom/ds/nsTHashMap.h
new file mode 100644
index 0000000000..8357d2ae7b
--- /dev/null
+++ b/xpcom/ds/nsTHashMap.h
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef XPCOM_DS_NSTHASHMAP_H_
+#define XPCOM_DS_NSTHASHMAP_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsBaseHashtable.h"
+#include "nsCOMPtr.h"
+#include "nsHashKeys.h"
+#include "nsHashtablesFwd.h"
+#include <type_traits>
+
+namespace mozilla::detail {
+template <class KeyType>
+struct nsKeyClass<
+ KeyType, std::enable_if_t<sizeof(KeyType) &&
+ std::is_base_of_v<PLDHashEntryHdr, KeyType>>> {
+ using type = KeyType;
+};
+
+template <typename KeyType>
+struct nsKeyClass<KeyType*> {
+ using type = nsPtrHashKey<KeyType>;
+};
+
+template <>
+struct nsKeyClass<nsCString> {
+ using type = nsCStringHashKey;
+};
+
+// This uses the case-sensitive hash key class, if you want the
+// case-insensitive hash key, use nsStringCaseInsensitiveHashKey explicitly.
+template <>
+struct nsKeyClass<nsString> {
+ using type = nsStringHashKey;
+};
+
+template <typename KeyType>
+struct nsKeyClass<KeyType, std::enable_if_t<std::is_integral_v<KeyType> ||
+ std::is_enum_v<KeyType>>> {
+ using type = nsIntegralHashKey<KeyType>;
+};
+
+template <>
+struct nsKeyClass<nsCOMPtr<nsISupports>> {
+ using type = nsISupportsHashKey;
+};
+
+template <typename T>
+struct nsKeyClass<RefPtr<T>> {
+ using type = nsRefPtrHashKey<T>;
+};
+
+template <>
+struct nsKeyClass<nsID> {
+ using type = nsIDHashKey;
+};
+
+} // namespace mozilla::detail
+
+// The actual definition of nsTHashMap is in nsHashtablesFwd.h, since it is a
+// type alias.
+
+#endif // XPCOM_DS_NSTHASHMAP_H_
diff --git a/xpcom/ds/nsTHashSet.h b/xpcom/ds/nsTHashSet.h
new file mode 100644
index 0000000000..4d905299db
--- /dev/null
+++ b/xpcom/ds/nsTHashSet.h
@@ -0,0 +1,193 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef XPCOM_DS_NSTHASHSET_H_
+#define XPCOM_DS_NSTHASHSET_H_
+
+#include "nsHashtablesFwd.h"
+#include "nsTHashMap.h" // for nsKeyClass
+
+/**
+ * Templated hash set. Don't use this directly, but use nsTHashSet instead
+ * (defined as a type alias in nsHashtablesFwd.h).
+ *
+ * @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
+ * for a complete specification.
+ */
+template <class KeyClass>
+class nsTBaseHashSet : protected nsTHashtable<KeyClass> {
+ using Base = nsTHashtable<KeyClass>;
+ typedef mozilla::fallible_t fallible_t;
+
+ public:
+ // XXX We have a similar situation here like with DataType/UserDataType in
+ // nsBaseHashtable. It's less problematic here due to the more constrained
+ // interface, but it may still be confusing. KeyType is not the stored key
+ // type, but the one exposed to the user, i.e. as a parameter type, and as the
+ // value type when iterating. It is currently impossible to move-insert a
+ // RefPtr<T>, e.g., since the KeyType is T* in that case.
+ using ValueType = typename KeyClass::KeyType;
+
+ // KeyType is defined just for compatibility with nsTHashMap. For a set, the
+ // key type is conceptually equivalent to the value type.
+ using KeyType = typename KeyClass::KeyType;
+
+ using Base::Base;
+
+ // Query operations.
+
+ using Base::Contains;
+ using Base::GetGeneration;
+ using Base::ShallowSizeOfExcludingThis;
+ using Base::ShallowSizeOfIncludingThis;
+ using Base::SizeOfExcludingThis;
+ using Base::SizeOfIncludingThis;
+
+ /**
+ * Return the number of entries in the table.
+ * @return number of entries
+ */
+ [[nodiscard]] uint32_t Count() const { return Base::Count(); }
+
+ /**
+ * Return whether the table is empty.
+ * @return whether empty
+ */
+ [[nodiscard]] bool IsEmpty() const { return Base::IsEmpty(); }
+
+ using iterator = ::detail::nsTHashtableKeyIterator<KeyClass>;
+ using const_iterator = iterator;
+
+ [[nodiscard]] auto begin() const { return Base::Keys().begin(); }
+
+ [[nodiscard]] auto end() const { return Base::Keys().end(); }
+
+ [[nodiscard]] auto cbegin() const { return Base::Keys().cbegin(); }
+
+ [[nodiscard]] auto cend() const { return Base::Keys().cend(); }
+
+ // Mutating operations.
+
+ using Base::Clear;
+ using Base::MarkImmutable;
+
+ /**
+ * Inserts a value into the set. Has no effect if the value is already in the
+ * set. This overload is infallible and crashes if memory is exhausted.
+ *
+ * \note For strict consistency with nsTHashtable::EntryHandle method naming,
+ * this should rather be called OrInsert, as it is legal to call it when the
+ * value is already in the set. For simplicity, as we don't have two methods,
+ * we still use "Insert" instead.
+ */
+ void Insert(ValueType aValue) { Base::PutEntry(aValue); }
+
+ /**
+ * Inserts a value into the set. Has no effect if the value is already in the
+ * set. This overload is fallible and returns false if memory is exhausted.
+ *
+ * \note See note on infallible overload.
+ */
+ [[nodiscard]] bool Insert(ValueType aValue, const mozilla::fallible_t&) {
+ return Base::PutEntry(aValue, mozilla::fallible);
+ }
+
+ /**
+ * Inserts a value into the set. Has no effect if the value is already in the
+ * set. This member function is infallible and crashes if memory is exhausted.
+ *
+ * \return true if the value was actually inserted, false if it was already in
+ * the set.
+ */
+ bool EnsureInserted(ValueType aValue) { return Base::EnsureInserted(aValue); }
+
+ using Base::Remove;
+
+ /**
+ * Removes a value from the set. Has no effect if the value is not in the set.
+ *
+ * \note For strict consistency with nsTHashtable::EntryHandle method naming,
+ * this should rather be called OrRemove, as it is legal to call it when the
+ * value is not in the set. For simplicity, as we don't have two methods,
+ * we still use "Remove" instead.
+ */
+ void Remove(ValueType aValue) { Base::RemoveEntry(aValue); }
+
+ using Base::EnsureRemoved;
+
+ /**
+ * Removes all elements matching a predicate.
+ *
+ * The predicate must be compatible with signature bool (ValueType).
+ */
+ template <typename Pred>
+ void RemoveIf(Pred&& aPred) {
+ for (auto it = cbegin(), end = cend(); it != end; ++it) {
+ if (aPred(static_cast<ValueType>(*it))) {
+ Remove(it);
+ }
+ }
+ }
+};
+
+template <typename KeyClass>
+auto RangeSize(const nsTBaseHashSet<KeyClass>& aRange) {
+ return aRange.Count();
+}
+
+class nsCycleCollectionTraversalCallback;
+
+template <class KeyClass>
+inline void ImplCycleCollectionUnlink(nsTBaseHashSet<KeyClass>& aField) {
+ aField.Clear();
+}
+
+template <class KeyClass>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ const nsTBaseHashSet<KeyClass>& aField, const char* aName,
+ uint32_t aFlags = 0) {
+ for (const auto& entry : aField) {
+ CycleCollectionNoteChild(aCallback, mozilla::detail::PtrGetWeak(entry),
+ aName, aFlags);
+ }
+}
+
+namespace mozilla {
+template <typename SetT>
+class nsTSetInserter {
+ SetT* mSet;
+
+ class Proxy {
+ SetT& mSet;
+
+ public:
+ explicit Proxy(SetT& aSet) : mSet{aSet} {}
+
+ template <typename E2>
+ void operator=(E2&& aValue) {
+ mSet.Insert(std::forward<E2>(aValue));
+ }
+ };
+
+ public:
+ using iterator_category = std::output_iterator_tag;
+
+ explicit nsTSetInserter(SetT& aSet) : mSet{&aSet} {}
+
+ Proxy operator*() { return Proxy(*mSet); }
+
+ nsTSetInserter& operator++() { return *this; }
+ nsTSetInserter& operator++(int) { return *this; }
+};
+} // namespace mozilla
+
+template <typename E>
+auto MakeInserter(nsTBaseHashSet<E>& aSet) {
+ return mozilla::nsTSetInserter<nsTBaseHashSet<E>>{aSet};
+}
+
+#endif // XPCOM_DS_NSTHASHSET_H_
diff --git a/xpcom/ds/nsTHashtable.h b/xpcom/ds/nsTHashtable.h
new file mode 100644
index 0000000000..d4a385551f
--- /dev/null
+++ b/xpcom/ds/nsTHashtable.h
@@ -0,0 +1,966 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// See the comment at the top of mfbt/HashTable.h for a comparison between
+// PLDHashTable and mozilla::HashTable.
+
+#ifndef nsTHashtable_h__
+#define nsTHashtable_h__
+
+#include <iterator>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "PLDHashTable.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/OperatorNewExtensions.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/fallible.h"
+#include "nsPointerHashKeys.h"
+#include "nsTArrayForwardDeclare.h"
+
+template <class EntryType>
+class nsTHashtable;
+
+namespace detail {
+class nsTHashtableIteratorBase {
+ public:
+ using EndIteratorTag = PLDHashTable::Iterator::EndIteratorTag;
+
+ nsTHashtableIteratorBase(nsTHashtableIteratorBase&& aOther) = default;
+
+ nsTHashtableIteratorBase& operator=(nsTHashtableIteratorBase&& aOther) {
+ // User-defined because the move assignment operator is deleted in
+ // PLDHashtable::Iterator.
+ return operator=(static_cast<const nsTHashtableIteratorBase&>(aOther));
+ }
+
+ nsTHashtableIteratorBase(const nsTHashtableIteratorBase& aOther)
+ : mIterator{aOther.mIterator.Clone()} {}
+ nsTHashtableIteratorBase& operator=(const nsTHashtableIteratorBase& aOther) {
+ // Since PLDHashTable::Iterator has no assignment operator, we destroy and
+ // recreate mIterator.
+ mIterator.~Iterator();
+ new (&mIterator) PLDHashTable::Iterator(aOther.mIterator.Clone());
+ return *this;
+ }
+
+ explicit nsTHashtableIteratorBase(PLDHashTable::Iterator aFrom)
+ : mIterator{std::move(aFrom)} {}
+
+ explicit nsTHashtableIteratorBase(const PLDHashTable& aTable)
+ : mIterator{&const_cast<PLDHashTable&>(aTable)} {}
+
+ nsTHashtableIteratorBase(const PLDHashTable& aTable, EndIteratorTag aTag)
+ : mIterator{&const_cast<PLDHashTable&>(aTable), aTag} {}
+
+ bool operator==(const nsTHashtableIteratorBase& aRhs) const {
+ return mIterator == aRhs.mIterator;
+ }
+ bool operator!=(const nsTHashtableIteratorBase& aRhs) const {
+ return !(*this == aRhs);
+ }
+
+ protected:
+ PLDHashTable::Iterator mIterator;
+};
+
+// STL-style iterators to allow the use in range-based for loops, e.g.
+template <typename T>
+class nsTHashtableEntryIterator : public nsTHashtableIteratorBase {
+ friend class nsTHashtable<std::remove_const_t<T>>;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = T;
+ using difference_type = int32_t;
+ using pointer = value_type*;
+ using reference = value_type&;
+
+ using iterator_type = nsTHashtableEntryIterator;
+ using const_iterator_type = nsTHashtableEntryIterator<const T>;
+
+ using nsTHashtableIteratorBase::nsTHashtableIteratorBase;
+
+ value_type* operator->() const {
+ return static_cast<value_type*>(mIterator.Get());
+ }
+ value_type& operator*() const {
+ return *static_cast<value_type*>(mIterator.Get());
+ }
+
+ iterator_type& operator++() {
+ mIterator.Next();
+ return *this;
+ }
+ iterator_type operator++(int) {
+ iterator_type it = *this;
+ ++*this;
+ return it;
+ }
+
+ operator const_iterator_type() const {
+ return const_iterator_type{mIterator.Clone()};
+ }
+};
+
+template <typename EntryType>
+class nsTHashtableKeyIterator : public nsTHashtableIteratorBase {
+ friend class nsTHashtable<EntryType>;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = const std::decay_t<typename EntryType::KeyType>;
+ using difference_type = int32_t;
+ using pointer = value_type*;
+ using reference = value_type&;
+
+ using iterator_type = nsTHashtableKeyIterator;
+ using const_iterator_type = nsTHashtableKeyIterator;
+
+ using nsTHashtableIteratorBase::nsTHashtableIteratorBase;
+
+ value_type* operator->() const {
+ return &static_cast<const EntryType*>(mIterator.Get())->GetKey();
+ }
+ decltype(auto) operator*() const {
+ return static_cast<const EntryType*>(mIterator.Get())->GetKey();
+ }
+
+ iterator_type& operator++() {
+ mIterator.Next();
+ return *this;
+ }
+ iterator_type operator++(int) {
+ iterator_type it = *this;
+ ++*this;
+ return it;
+ }
+};
+
+template <typename EntryType>
+class nsTHashtableKeyRange {
+ public:
+ using IteratorType = nsTHashtableKeyIterator<EntryType>;
+ using iterator = IteratorType;
+
+ explicit nsTHashtableKeyRange(const PLDHashTable& aHashtable)
+ : mHashtable{aHashtable} {}
+
+ auto begin() const { return IteratorType{mHashtable}; }
+ auto end() const {
+ return IteratorType{mHashtable, typename IteratorType::EndIteratorTag{}};
+ }
+ auto cbegin() const { return begin(); }
+ auto cend() const { return end(); }
+
+ uint32_t Count() const { return mHashtable.EntryCount(); }
+
+ private:
+ const PLDHashTable& mHashtable;
+};
+
+template <typename EntryType>
+auto RangeSize(const ::detail::nsTHashtableKeyRange<EntryType>& aRange) {
+ return aRange.Count();
+}
+
+} // namespace detail
+
+/**
+ * a base class for templated hashtables.
+ *
+ * Clients will rarely need to use this class directly. Check the derived
+ * classes first, to see if they will meet your needs.
+ *
+ * @param EntryType the templated entry-type class that is managed by the
+ * hashtable. <code>EntryType</code> must extend the following declaration,
+ * and <strong>must not declare any virtual functions or derive from classes
+ * with virtual functions.</strong> Any vtable pointer would break the
+ * PLDHashTable code.
+ *<pre> class EntryType : public PLDHashEntryHdr
+ * {
+ * public: or friend nsTHashtable<EntryType>;
+ * // KeyType is what we use when Get()ing or Put()ing this entry
+ * // this should either be a simple datatype (uint32_t, nsISupports*) or
+ * // a const reference (const nsAString&)
+ * typedef something KeyType;
+ * // KeyTypePointer is the pointer-version of KeyType, because
+ * // PLDHashTable.h requires keys to cast to <code>const void*</code>
+ * typedef const something* KeyTypePointer;
+ *
+ * EntryType(KeyTypePointer aKey);
+ *
+ * // A copy or C++11 Move constructor must be defined, even if
+ * // AllowMemMove() == true, otherwise you will cause link errors.
+ * EntryType(const EntryType& aEnt); // Either this...
+ * EntryType(EntryType&& aEnt); // ...or this
+ *
+ * // the destructor must be defined... or you will cause link errors!
+ * ~EntryType();
+ *
+ * // KeyEquals(): does this entry match this key?
+ * bool KeyEquals(KeyTypePointer aKey) const;
+ *
+ * // KeyToPointer(): Convert KeyType to KeyTypePointer
+ * static KeyTypePointer KeyToPointer(KeyType aKey);
+ *
+ * // HashKey(): calculate the hash number
+ * static PLDHashNumber HashKey(KeyTypePointer aKey);
+ *
+ * // ALLOW_MEMMOVE can we move this class with memmove(), or do we have
+ * // to use the copy constructor?
+ * enum { ALLOW_MEMMOVE = true/false };
+ * }</pre>
+ *
+ * @see nsInterfaceHashtable
+ * @see nsClassHashtable
+ * @see nsTHashMap
+ * @author "Benjamin Smedberg <bsmedberg@covad.net>"
+ */
+
+template <class EntryType>
+class MOZ_NEEDS_NO_VTABLE_TYPE nsTHashtable {
+ typedef mozilla::fallible_t fallible_t;
+ static_assert(std::is_pointer_v<typename EntryType::KeyTypePointer>,
+ "KeyTypePointer should be a pointer");
+
+ public:
+ // Separate constructors instead of default aInitLength parameter since
+ // otherwise the default no-arg constructor isn't found.
+ nsTHashtable()
+ : mTable(Ops(), sizeof(EntryType), PLDHashTable::kDefaultInitialLength) {}
+ explicit nsTHashtable(uint32_t aInitLength)
+ : mTable(Ops(), sizeof(EntryType), aInitLength) {}
+
+ /**
+ * destructor, cleans up and deallocates
+ */
+ ~nsTHashtable() = default;
+
+ nsTHashtable(nsTHashtable<EntryType>&& aOther);
+ nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>&& aOther);
+
+ nsTHashtable(const nsTHashtable<EntryType>&) = delete;
+ nsTHashtable& operator=(const nsTHashtable<EntryType>&) = delete;
+
+ /**
+ * Return the generation number for the table. This increments whenever
+ * the table data items are moved.
+ */
+ uint32_t GetGeneration() const { return mTable.Generation(); }
+
+ /**
+ * KeyType is typedef'ed for ease of use.
+ */
+ typedef typename EntryType::KeyType KeyType;
+
+ /**
+ * KeyTypePointer is typedef'ed for ease of use.
+ */
+ typedef typename EntryType::KeyTypePointer KeyTypePointer;
+
+ /**
+ * Return the number of entries in the table.
+ * @return number of entries
+ */
+ uint32_t Count() const { return mTable.EntryCount(); }
+
+ /**
+ * Return true if the hashtable is empty.
+ */
+ bool IsEmpty() const { return Count() == 0; }
+
+ /**
+ * Get the entry associated with a key.
+ * @param aKey the key to retrieve
+ * @return pointer to the entry class, if the key exists; nullptr if the
+ * key doesn't exist
+ */
+ EntryType* GetEntry(KeyType aKey) const {
+ return static_cast<EntryType*>(
+ mTable.Search(EntryType::KeyToPointer(aKey)));
+ }
+
+ /**
+ * Return true if an entry for the given key exists, false otherwise.
+ * @param aKey the key to retrieve
+ * @return true if the key exists, false if the key doesn't exist
+ */
+ bool Contains(KeyType aKey) const { return !!GetEntry(aKey); }
+
+ /**
+ * Infallibly get the entry associated with a key, or create a new entry,
+ * @param aKey the key to retrieve
+ * @return pointer to the entry retrieved; never nullptr
+ */
+ EntryType* PutEntry(KeyType aKey) {
+ // Infallible WithEntryHandle.
+ return WithEntryHandle(
+ aKey, [](auto entryHandle) { return entryHandle.OrInsert(); });
+ }
+
+ /**
+ * Fallibly get the entry associated with a key, or create a new entry,
+ * @param aKey the key to retrieve
+ * @return pointer to the entry retrieved; nullptr only if memory can't
+ * be allocated
+ */
+ [[nodiscard]] EntryType* PutEntry(KeyType aKey, const fallible_t& aFallible) {
+ return WithEntryHandle(aKey, aFallible, [](auto maybeEntryHandle) {
+ return maybeEntryHandle ? maybeEntryHandle->OrInsert() : nullptr;
+ });
+ }
+
+ /**
+ * Get the entry associated with a key, or create a new entry using infallible
+ * allocation and insert that.
+ * @param aKey the key to retrieve
+ * @param aEntry will be assigned (if non-null) to the entry that was
+ * found or created
+ * @return true if a new entry was created, or false if an existing entry
+ * was found
+ */
+ [[nodiscard]] bool EnsureInserted(KeyType aKey,
+ EntryType** aEntry = nullptr) {
+ auto oldCount = Count();
+ EntryType* entry = PutEntry(aKey);
+ if (aEntry) {
+ *aEntry = entry;
+ }
+ return oldCount != Count();
+ }
+
+ /**
+ * Remove the entry associated with a key.
+ * @param aKey of the entry to remove
+ */
+ void RemoveEntry(KeyType aKey) {
+ mTable.Remove(EntryType::KeyToPointer(aKey));
+ }
+
+ /**
+ * Lookup the entry associated with aKey and remove it if found, otherwise
+ * do nothing.
+ * @param aKey of the entry to remove
+ * @return true if an entry was found and removed, or false if no entry
+ * was found for aKey
+ */
+ bool EnsureRemoved(KeyType aKey) {
+ auto* entry = GetEntry(aKey);
+ if (entry) {
+ RemoveEntry(entry);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Remove the entry associated with a key.
+ * @param aEntry the entry-pointer to remove (obtained from GetEntry)
+ */
+ void RemoveEntry(EntryType* aEntry) { mTable.RemoveEntry(aEntry); }
+
+ /**
+ * Remove the entry associated with a key, but don't resize the hashtable.
+ * This is a low-level method, and is not recommended unless you know what
+ * you're doing. If you use it, please add a comment explaining why you
+ * didn't use RemoveEntry().
+ * @param aEntry the entry-pointer to remove (obtained from GetEntry)
+ */
+ void RawRemoveEntry(EntryType* aEntry) { mTable.RawRemove(aEntry); }
+
+ protected:
+ class EntryHandle {
+ public:
+ EntryHandle(EntryHandle&& aOther) = default;
+ ~EntryHandle() = default;
+
+ EntryHandle(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&&) = delete;
+
+ KeyType Key() const { return mKey; }
+
+ bool HasEntry() const { return mEntryHandle.HasEntry(); }
+
+ explicit operator bool() const { return mEntryHandle.operator bool(); }
+
+ EntryType* Entry() { return static_cast<EntryType*>(mEntryHandle.Entry()); }
+
+ void Insert() { InsertInternal(); }
+
+ EntryType* OrInsert() {
+ if (!HasEntry()) {
+ Insert();
+ }
+ return Entry();
+ }
+
+ void Remove() { mEntryHandle.Remove(); }
+
+ void OrRemove() { mEntryHandle.OrRemove(); }
+
+ protected:
+ template <typename... Args>
+ void InsertInternal(Args&&... aArgs) {
+ MOZ_RELEASE_ASSERT(!HasEntry());
+ mEntryHandle.Insert([&](PLDHashEntryHdr* entry) {
+ new (mozilla::KnownNotNull, entry) EntryType(
+ EntryType::KeyToPointer(mKey), std::forward<Args>(aArgs)...);
+ });
+ }
+
+ private:
+ friend class nsTHashtable;
+
+ EntryHandle(KeyType aKey, PLDHashTable::EntryHandle&& aEntryHandle)
+ : mKey(aKey), mEntryHandle(std::move(aEntryHandle)) {}
+
+ KeyType mKey;
+ PLDHashTable::EntryHandle mEntryHandle;
+ };
+
+ template <class F>
+ auto WithEntryHandle(KeyType aKey, F&& aFunc)
+ -> std::invoke_result_t<F, EntryHandle&&> {
+ return this->mTable.WithEntryHandle(
+ EntryType::KeyToPointer(aKey),
+ [&aKey, &aFunc](auto entryHandle) -> decltype(auto) {
+ return std::forward<F>(aFunc)(
+ EntryHandle{aKey, std::move(entryHandle)});
+ });
+ }
+
+ template <class F>
+ auto WithEntryHandle(KeyType aKey, const mozilla::fallible_t& aFallible,
+ F&& aFunc)
+ -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
+ return this->mTable.WithEntryHandle(
+ EntryType::KeyToPointer(aKey), aFallible,
+ [&aKey, &aFunc](auto maybeEntryHandle) {
+ return std::forward<F>(aFunc)(
+ maybeEntryHandle
+ ? mozilla::Some(EntryHandle{aKey, maybeEntryHandle.extract()})
+ : mozilla::Nothing());
+ });
+ }
+
+ public:
+ class ConstIterator {
+ public:
+ explicit ConstIterator(nsTHashtable* aTable)
+ : mBaseIterator(&aTable->mTable) {}
+ ~ConstIterator() = default;
+
+ KeyType Key() const { return Get()->GetKey(); }
+
+ const EntryType* Get() const {
+ return static_cast<const EntryType*>(mBaseIterator.Get());
+ }
+
+ bool Done() const { return mBaseIterator.Done(); }
+ void Next() { mBaseIterator.Next(); }
+
+ ConstIterator() = delete;
+ ConstIterator(const ConstIterator&) = delete;
+ ConstIterator(ConstIterator&& aOther) = delete;
+ ConstIterator& operator=(const ConstIterator&) = delete;
+ ConstIterator& operator=(ConstIterator&&) = delete;
+
+ protected:
+ PLDHashTable::Iterator mBaseIterator;
+ };
+
+ // This is an iterator that also allows entry removal. Example usage:
+ //
+ // for (auto iter = table.Iter(); !iter.Done(); iter.Next()) {
+ // Entry* entry = iter.Get();
+ // // ... do stuff with |entry| ...
+ // // ... possibly call iter.Remove() once ...
+ // }
+ //
+ class Iterator final : public ConstIterator {
+ public:
+ using ConstIterator::ConstIterator;
+
+ using ConstIterator::Get;
+
+ EntryType* Get() const {
+ return static_cast<EntryType*>(this->mBaseIterator.Get());
+ }
+
+ void Remove() { this->mBaseIterator.Remove(); }
+ };
+
+ Iterator Iter() { return Iterator(this); }
+
+ ConstIterator ConstIter() const {
+ return ConstIterator(const_cast<nsTHashtable*>(this));
+ }
+
+ using const_iterator = ::detail::nsTHashtableEntryIterator<const EntryType>;
+ using iterator = ::detail::nsTHashtableEntryIterator<EntryType>;
+
+ iterator begin() { return iterator{mTable}; }
+ const_iterator begin() const { return const_iterator{mTable}; }
+ const_iterator cbegin() const { return begin(); }
+ iterator end() {
+ return iterator{mTable, typename iterator::EndIteratorTag{}};
+ }
+ const_iterator end() const {
+ return const_iterator{mTable, typename const_iterator::EndIteratorTag{}};
+ }
+ const_iterator cend() const { return end(); }
+
+ void Remove(const_iterator& aIter) { aIter.mIterator.Remove(); }
+
+ /**
+ * Return a range of the keys (of KeyType). Note this range iterates over the
+ * keys in place, so modifications to the nsTHashtable invalidate the range
+ * while it's iterated, except when calling Remove() with a key iterator
+ * derived from that range.
+ */
+ auto Keys() const {
+ return ::detail::nsTHashtableKeyRange<EntryType>{mTable};
+ }
+
+ /**
+ * Remove an entry from a key range, specified via a key iterator, e.g.
+ *
+ * for (auto it = hash.Keys().begin(), end = hash.Keys().end();
+ * it != end; * ++it) {
+ * if (*it > 42) { hash.Remove(it); }
+ * }
+ */
+ void Remove(::detail::nsTHashtableKeyIterator<EntryType>& aIter) {
+ aIter.mIterator.Remove();
+ }
+
+ /**
+ * Remove all entries, return hashtable to "pristine" state. It's
+ * conceptually the same as calling the destructor and then re-calling the
+ * constructor.
+ */
+ void Clear() { mTable.Clear(); }
+
+ /**
+ * Measure the size of the table's entry storage. Does *not* measure anything
+ * hanging off table entries; hence the "Shallow" prefix. To measure that,
+ * either use SizeOfExcludingThis() or iterate manually over the entries,
+ * calling SizeOfExcludingThis() on each one.
+ *
+ * @param aMallocSizeOf the function used to measure heap-allocated blocks
+ * @return the measured shallow size of the table
+ */
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ /**
+ * Like ShallowSizeOfExcludingThis, but includes sizeof(*this).
+ */
+ size_t ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ /**
+ * This is a "deep" measurement of the table. To use it, |EntryType| must
+ * define SizeOfExcludingThis, and that method will be called on all live
+ * entries.
+ */
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ size_t n = ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (auto iter = ConstIter(); !iter.Done(); iter.Next()) {
+ n += (*iter.Get()).SizeOfExcludingThis(aMallocSizeOf);
+ }
+ return n;
+ }
+
+ /**
+ * Like SizeOfExcludingThis, but includes sizeof(*this).
+ */
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ /**
+ * Swap the elements in this hashtable with the elements in aOther.
+ */
+ void SwapElements(nsTHashtable<EntryType>& aOther) {
+ MOZ_ASSERT_IF(this->mTable.Ops() && aOther.mTable.Ops(),
+ this->mTable.Ops() == aOther.mTable.Ops());
+ std::swap(this->mTable, aOther.mTable);
+ }
+
+ /**
+ * Mark the table as constant after initialization.
+ *
+ * This will prevent assertions when a read-only hash is accessed on multiple
+ * threads without synchronization.
+ */
+ void MarkImmutable() { mTable.MarkImmutable(); }
+
+ protected:
+ PLDHashTable mTable;
+
+ static PLDHashNumber s_HashKey(const void* aKey);
+
+ static bool s_MatchEntry(const PLDHashEntryHdr* aEntry, const void* aKey);
+
+ static void s_CopyEntry(PLDHashTable* aTable, const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo);
+
+ static void s_ClearEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry);
+
+ private:
+ // copy constructor, not implemented
+ nsTHashtable(nsTHashtable<EntryType>& aToCopy) = delete;
+
+ /**
+ * Gets the table's ops.
+ */
+ static const PLDHashTableOps* Ops();
+
+ // assignment operator, not implemented
+ nsTHashtable<EntryType>& operator=(nsTHashtable<EntryType>& aToEqual) =
+ delete;
+};
+
+namespace mozilla {
+namespace detail {
+
+// Like PLDHashTable::MoveEntryStub, but specialized for fixed N (i.e. the size
+// of the entries in the hashtable). Saves a memory read to figure out the size
+// from the table and gives the compiler the opportunity to inline the memcpy.
+//
+// We define this outside of nsTHashtable so only one copy exists for every N,
+// rather than separate copies for every EntryType used with nsTHashtable.
+template <size_t N>
+static void FixedSizeEntryMover(PLDHashTable*, const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo) {
+ memcpy(aTo, aFrom, N);
+}
+
+} // namespace detail
+} // namespace mozilla
+
+//
+// template definitions
+//
+
+template <class EntryType>
+nsTHashtable<EntryType>::nsTHashtable(nsTHashtable<EntryType>&& aOther)
+ : mTable(std::move(aOther.mTable)) {}
+
+template <class EntryType>
+nsTHashtable<EntryType>& nsTHashtable<EntryType>::operator=(
+ nsTHashtable<EntryType>&& aOther) {
+ mTable = std::move(aOther.mTable);
+ return *this;
+}
+
+template <class EntryType>
+/* static */ const PLDHashTableOps* nsTHashtable<EntryType>::Ops() {
+ // If this variable is a global variable, we get strange start-up failures on
+ // WindowsCrtPatch.h (see bug 1166598 comment 20). But putting it inside a
+ // function avoids that problem.
+ static const PLDHashTableOps sOps = {
+ s_HashKey, s_MatchEntry,
+ EntryType::ALLOW_MEMMOVE
+ ? mozilla::detail::FixedSizeEntryMover<sizeof(EntryType)>
+ : s_CopyEntry,
+ // Simplify hashtable clearing in case our entries are trivially
+ // destructible.
+ std::is_trivially_destructible_v<EntryType> ? nullptr : s_ClearEntry,
+ // We don't use a generic initEntry hook because we want to allow
+ // initialization of data members defined in derived classes directly
+ // in the entry constructor (for example when a member can't be default
+ // constructed).
+ nullptr};
+ return &sOps;
+}
+
+// static definitions
+
+template <class EntryType>
+PLDHashNumber nsTHashtable<EntryType>::s_HashKey(const void* aKey) {
+ return EntryType::HashKey(static_cast<KeyTypePointer>(aKey));
+}
+
+template <class EntryType>
+bool nsTHashtable<EntryType>::s_MatchEntry(const PLDHashEntryHdr* aEntry,
+ const void* aKey) {
+ return (static_cast<const EntryType*>(aEntry))
+ ->KeyEquals(static_cast<KeyTypePointer>(aKey));
+}
+
+template <class EntryType>
+void nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable* aTable,
+ const PLDHashEntryHdr* aFrom,
+ PLDHashEntryHdr* aTo) {
+ auto* fromEntry = const_cast<std::remove_const_t<EntryType>*>(
+ static_cast<const EntryType*>(aFrom));
+
+ new (mozilla::KnownNotNull, aTo) EntryType(std::move(*fromEntry));
+
+ fromEntry->~EntryType();
+}
+
+template <class EntryType>
+void nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable* aTable,
+ PLDHashEntryHdr* aEntry) {
+ static_cast<EntryType*>(aEntry)->~EntryType();
+}
+
+class nsCycleCollectionTraversalCallback;
+
+template <class EntryType>
+inline void ImplCycleCollectionUnlink(nsTHashtable<EntryType>& aField) {
+ aField.Clear();
+}
+
+template <class EntryType>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ nsTHashtable<EntryType>& aField, const char* aName, uint32_t aFlags = 0) {
+ for (auto iter = aField.Iter(); !iter.Done(); iter.Next()) {
+ EntryType* entry = iter.Get();
+ ImplCycleCollectionTraverse(aCallback, *entry, aName, aFlags);
+ }
+}
+
+/**
+ * For nsTHashtable with pointer entries, we can have a template specialization
+ * that layers a typed T* interface on top of a common implementation that
+ * works internally with void pointers. This arrangement saves code size and
+ * might slightly improve performance as well.
+ */
+
+/**
+ * We need a separate entry type class for the inheritance structure of the
+ * nsTHashtable specialization below; nsVoidPtrHashKey is simply typedefed to a
+ * specialization of nsPtrHashKey, and the formulation:
+ *
+ * class nsTHashtable<nsPtrHashKey<T>> :
+ * protected nsTHashtable<nsPtrHashKey<const void>
+ *
+ * is not going to turn out very well, since we'd wind up with an nsTHashtable
+ * instantiation that is its own base class.
+ */
+namespace detail {
+
+class VoidPtrHashKey : public nsPtrHashKey<const void> {
+ typedef nsPtrHashKey<const void> Base;
+
+ public:
+ explicit VoidPtrHashKey(const void* aKey) : Base(aKey) {}
+};
+
+} // namespace detail
+
+/**
+ * See the main nsTHashtable documentation for descriptions of this class's
+ * methods.
+ */
+template <typename T>
+class nsTHashtable<nsPtrHashKey<T>>
+ : protected nsTHashtable<::detail::VoidPtrHashKey> {
+ typedef nsTHashtable<::detail::VoidPtrHashKey> Base;
+ typedef nsPtrHashKey<T> EntryType;
+
+ // We play games with reinterpret_cast'ing between these two classes, so
+ // try to ensure that playing said games is reasonable.
+ static_assert(sizeof(nsPtrHashKey<T>) == sizeof(::detail::VoidPtrHashKey),
+ "hash keys must be the same size");
+
+ nsTHashtable(const nsTHashtable& aOther) = delete;
+ nsTHashtable& operator=(const nsTHashtable& aOther) = delete;
+
+ public:
+ nsTHashtable() = default;
+ explicit nsTHashtable(uint32_t aInitLength) : Base(aInitLength) {}
+
+ ~nsTHashtable() = default;
+
+ nsTHashtable(nsTHashtable&&) = default;
+
+ using Base::Clear;
+ using Base::Count;
+ using Base::GetGeneration;
+ using Base::IsEmpty;
+
+ using Base::MarkImmutable;
+ using Base::ShallowSizeOfExcludingThis;
+ using Base::ShallowSizeOfIncludingThis;
+
+ /* Wrapper functions */
+ EntryType* GetEntry(T* aKey) const {
+ return reinterpret_cast<EntryType*>(Base::GetEntry(aKey));
+ }
+
+ bool Contains(T* aKey) const { return Base::Contains(aKey); }
+
+ EntryType* PutEntry(T* aKey) {
+ return reinterpret_cast<EntryType*>(Base::PutEntry(aKey));
+ }
+
+ [[nodiscard]] EntryType* PutEntry(T* aKey,
+ const mozilla::fallible_t& aFallible) {
+ return reinterpret_cast<EntryType*>(Base::PutEntry(aKey, aFallible));
+ }
+
+ [[nodiscard]] bool EnsureInserted(T* aKey, EntryType** aEntry = nullptr) {
+ return Base::EnsureInserted(
+ aKey, reinterpret_cast<::detail::VoidPtrHashKey**>(aEntry));
+ }
+
+ void RemoveEntry(T* aKey) { Base::RemoveEntry(aKey); }
+
+ bool EnsureRemoved(T* aKey) { return Base::EnsureRemoved(aKey); }
+
+ void RemoveEntry(EntryType* aEntry) {
+ Base::RemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
+ }
+
+ void RawRemoveEntry(EntryType* aEntry) {
+ Base::RawRemoveEntry(reinterpret_cast<::detail::VoidPtrHashKey*>(aEntry));
+ }
+
+ protected:
+ class EntryHandle : protected Base::EntryHandle {
+ public:
+ using Base = nsTHashtable::Base::EntryHandle;
+
+ EntryHandle(EntryHandle&& aOther) = default;
+ ~EntryHandle() = default;
+
+ EntryHandle(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&) = delete;
+ EntryHandle& operator=(const EntryHandle&&) = delete;
+
+ using Base::Key;
+
+ using Base::HasEntry;
+
+ using Base::operator bool;
+
+ EntryType* Entry() { return reinterpret_cast<EntryType*>(Base::Entry()); }
+
+ using Base::Insert;
+
+ EntryType* OrInsert() {
+ if (!HasEntry()) {
+ Insert();
+ }
+ return Entry();
+ }
+
+ using Base::Remove;
+
+ using Base::OrRemove;
+
+ private:
+ friend class nsTHashtable;
+
+ explicit EntryHandle(Base&& aBase) : Base(std::move(aBase)) {}
+ };
+
+ template <class F>
+ auto WithEntryHandle(KeyType aKey, F aFunc)
+ -> std::invoke_result_t<F, EntryHandle&&> {
+ return Base::WithEntryHandle(aKey, [&aFunc](auto entryHandle) {
+ return aFunc(EntryHandle{std::move(entryHandle)});
+ });
+ }
+
+ template <class F>
+ auto WithEntryHandle(KeyType aKey, const mozilla::fallible_t& aFallible,
+ F aFunc)
+ -> std::invoke_result_t<F, mozilla::Maybe<EntryHandle>&&> {
+ return Base::WithEntryHandle(
+ aKey, aFallible, [&aFunc](auto maybeEntryHandle) {
+ return aFunc(maybeEntryHandle ? mozilla::Some(EntryHandle{
+ maybeEntryHandle.extract()})
+ : mozilla::Nothing());
+ });
+ }
+
+ public:
+ class ConstIterator {
+ public:
+ explicit ConstIterator(nsTHashtable* aTable)
+ : mBaseIterator(&aTable->mTable) {}
+ ~ConstIterator() = default;
+
+ KeyType Key() const { return Get()->GetKey(); }
+
+ const EntryType* Get() const {
+ return static_cast<const EntryType*>(mBaseIterator.Get());
+ }
+
+ bool Done() const { return mBaseIterator.Done(); }
+ void Next() { mBaseIterator.Next(); }
+
+ ConstIterator() = delete;
+ ConstIterator(const ConstIterator&) = delete;
+ ConstIterator(ConstIterator&& aOther) = delete;
+ ConstIterator& operator=(const ConstIterator&) = delete;
+ ConstIterator& operator=(ConstIterator&&) = delete;
+
+ protected:
+ PLDHashTable::Iterator mBaseIterator;
+ };
+
+ class Iterator final : public ConstIterator {
+ public:
+ using ConstIterator::ConstIterator;
+
+ using ConstIterator::Get;
+
+ EntryType* Get() const {
+ return static_cast<EntryType*>(this->mBaseIterator.Get());
+ }
+
+ void Remove() { this->mBaseIterator.Remove(); }
+ };
+
+ Iterator Iter() { return Iterator(this); }
+
+ ConstIterator ConstIter() const {
+ return ConstIterator(const_cast<nsTHashtable*>(this));
+ }
+
+ using const_iterator = ::detail::nsTHashtableEntryIterator<const EntryType>;
+ using iterator = ::detail::nsTHashtableEntryIterator<EntryType>;
+
+ iterator begin() { return iterator{mTable}; }
+ const_iterator begin() const { return const_iterator{mTable}; }
+ const_iterator cbegin() const { return begin(); }
+ iterator end() {
+ return iterator{mTable, typename iterator::EndIteratorTag{}};
+ }
+ const_iterator end() const {
+ return const_iterator{mTable, typename const_iterator::EndIteratorTag{}};
+ }
+ const_iterator cend() const { return end(); }
+
+ auto Keys() const {
+ return ::detail::nsTHashtableKeyRange<nsPtrHashKey<T>>{mTable};
+ }
+
+ void Remove(::detail::nsTHashtableKeyIterator<EntryType>& aIter) {
+ aIter.mIterator.Remove();
+ }
+
+ void SwapElements(nsTHashtable& aOther) { Base::SwapElements(aOther); }
+};
+
+#endif // nsTHashtable_h__
diff --git a/xpcom/ds/nsTObserverArray.cpp b/xpcom/ds/nsTObserverArray.cpp
new file mode 100644
index 0000000000..68211873dd
--- /dev/null
+++ b/xpcom/ds/nsTObserverArray.cpp
@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsTObserverArray.h"
+
+void nsTObserverArray_base::AdjustIterators(index_type aModPos,
+ diff_type aAdjustment) {
+ MOZ_ASSERT(aAdjustment == -1 || aAdjustment == 1, "invalid adjustment");
+ Iterator_base* iter = mIterators;
+ while (iter) {
+ if (iter->mPosition > aModPos) {
+ iter->mPosition += aAdjustment;
+ }
+ iter = iter->mNext;
+ }
+}
+
+void nsTObserverArray_base::ClearIterators() {
+ Iterator_base* iter = mIterators;
+ while (iter) {
+ iter->mPosition = 0;
+ iter = iter->mNext;
+ }
+}
diff --git a/xpcom/ds/nsTObserverArray.h b/xpcom/ds/nsTObserverArray.h
new file mode 100644
index 0000000000..4d3e4087e0
--- /dev/null
+++ b/xpcom/ds/nsTObserverArray.h
@@ -0,0 +1,583 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsTObserverArray_h___
+#define nsTObserverArray_h___
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/ReverseIterator.h"
+#include "nsTArray.h"
+#include "nsCycleCollectionNoteChild.h"
+
+/**
+ * An array of observers. Like a normal array, but supports iterators that are
+ * stable even if the array is modified during iteration.
+ * The template parameter T is the observer type the array will hold;
+ * N is the number of built-in storage slots that come with the array.
+ * NOTE: You probably want to use nsTObserverArray, unless you specifically
+ * want built-in storage. See below.
+ * @see nsTObserverArray, nsTArray
+ */
+
+class nsTObserverArray_base {
+ public:
+ typedef size_t index_type;
+ typedef size_t size_type;
+ typedef ptrdiff_t diff_type;
+
+ protected:
+ class Iterator_base {
+ public:
+ Iterator_base(const Iterator_base&) = delete;
+
+ protected:
+ friend class nsTObserverArray_base;
+
+ Iterator_base(index_type aPosition, Iterator_base* aNext)
+ : mPosition(aPosition), mNext(aNext) {}
+
+ // The current position of the iterator. Its exact meaning differs
+ // depending on iterator. See nsTObserverArray<T>::ForwardIterator.
+ index_type mPosition;
+
+ // The next iterator currently iterating the same array
+ Iterator_base* mNext;
+ };
+
+ nsTObserverArray_base() : mIterators(nullptr) {}
+
+ ~nsTObserverArray_base() {
+ NS_ASSERTION(mIterators == nullptr, "iterators outlasting array");
+ }
+
+ /**
+ * Adjusts iterators after an element has been inserted or removed
+ * from the array.
+ * @param aModPos Position where elements were added or removed.
+ * @param aAdjustment -1 if an element was removed, 1 if an element was
+ * added.
+ */
+ void AdjustIterators(index_type aModPos, diff_type aAdjustment);
+
+ /**
+ * Clears iterators when the array is destroyed.
+ */
+ void ClearIterators();
+
+ mutable Iterator_base* mIterators;
+};
+
+template <class T, size_t N>
+class nsAutoTObserverArray : protected nsTObserverArray_base {
+ public:
+ typedef T value_type;
+ typedef nsTArray<T> array_type;
+
+ nsAutoTObserverArray() = default;
+
+ //
+ // Accessor methods
+ //
+
+ // @return The number of elements in the array.
+ size_type Length() const { return mArray.Length(); }
+
+ // @return True if the array is empty or false otherwise.
+ bool IsEmpty() const { return mArray.IsEmpty(); }
+
+ // This method provides direct, readonly access to the array elements.
+ // @return A pointer to the first element of the array. If the array is
+ // empty, then this pointer must not be dereferenced.
+ const value_type* Elements() const { return mArray.Elements(); }
+ value_type* Elements() { return mArray.Elements(); }
+
+ // This method provides direct access to an element of the array. The given
+ // index must be within the array bounds. If the underlying array may change
+ // during iteration, use an iterator instead of this function.
+ // @param aIndex The index of an element in the array.
+ // @return A reference to the i'th element of the array.
+ value_type& ElementAt(index_type aIndex) { return mArray.ElementAt(aIndex); }
+
+ // Same as above, but readonly.
+ const value_type& ElementAt(index_type aIndex) const {
+ return mArray.ElementAt(aIndex);
+ }
+
+ // This method provides direct access to an element of the array in a bounds
+ // safe manner. If the requested index is out of bounds the provided default
+ // value is returned.
+ // @param aIndex The index of an element in the array.
+ // @param aDef The value to return if the index is out of bounds.
+ value_type& SafeElementAt(index_type aIndex, value_type& aDef) {
+ return mArray.SafeElementAt(aIndex, aDef);
+ }
+
+ // Same as above, but readonly.
+ const value_type& SafeElementAt(index_type aIndex,
+ const value_type& aDef) const {
+ return mArray.SafeElementAt(aIndex, aDef);
+ }
+
+ // No operator[] is provided because the point of this class is to support
+ // allow modifying the array during iteration, and ElementAt() is not safe
+ // in those conditions.
+
+ //
+ // Search methods
+ //
+
+ // This method searches, starting from the beginning of the array,
+ // for the first element in this array that is equal to the given element.
+ // 'operator==' must be defined for value_type.
+ // @param aItem The item to search for.
+ // @return true if the element was found.
+ template <class Item>
+ bool Contains(const Item& aItem) const {
+ return IndexOf(aItem) != array_type::NoIndex;
+ }
+
+ // This method searches for the offset of the first element in this
+ // array that is equal to the given element.
+ // 'operator==' must be defined for value_type.
+ // @param aItem The item to search for.
+ // @param aStart The index to start from.
+ // @return The index of the found element or NoIndex if not found.
+ template <class Item>
+ index_type IndexOf(const Item& aItem, index_type aStart = 0) const {
+ return mArray.IndexOf(aItem, aStart);
+ }
+
+ //
+ // Mutation methods
+ //
+
+ // Insert a given element at the given index.
+ // @param aIndex The index at which to insert item.
+ // @param aItem The item to insert,
+ template <class Item>
+ void InsertElementAt(index_type aIndex, const Item& aItem) {
+ mArray.InsertElementAt(aIndex, aItem);
+ AdjustIterators(aIndex, 1);
+ }
+
+ // Same as above but without copy constructing.
+ // This is useful to avoid temporaries.
+ value_type* InsertElementAt(index_type aIndex) {
+ value_type* item = mArray.InsertElementAt(aIndex);
+ AdjustIterators(aIndex, 1);
+ return item;
+ }
+
+ // Prepend an element to the array unless it already exists in the array.
+ // 'operator==' must be defined for value_type.
+ // @param aItem The item to prepend.
+ template <class Item>
+ void PrependElementUnlessExists(const Item& aItem) {
+ if (!Contains(aItem)) {
+ mArray.InsertElementAt(0, aItem);
+ AdjustIterators(0, 1);
+ }
+ }
+
+ // Append an element to the array.
+ // @param aItem The item to append.
+ template <class Item>
+ void AppendElement(Item&& aItem) {
+ mArray.AppendElement(std::forward<Item>(aItem));
+ }
+
+ // Same as above, but without copy-constructing. This is useful to avoid
+ // temporaries.
+ value_type* AppendElement() { return mArray.AppendElement(); }
+
+ // Append an element to the array unless it already exists in the array.
+ // 'operator==' must be defined for value_type.
+ // @param aItem The item to append.
+ template <class Item>
+ void AppendElementUnlessExists(const Item& aItem) {
+ if (!Contains(aItem)) {
+ mArray.AppendElement(aItem);
+ }
+ }
+
+ // Remove an element from the array.
+ // @param aIndex The index of the item to remove.
+ void RemoveElementAt(index_type aIndex) {
+ NS_ASSERTION(aIndex < mArray.Length(), "invalid index");
+ mArray.RemoveElementAt(aIndex);
+ AdjustIterators(aIndex, -1);
+ }
+
+ // This helper function combines IndexOf with RemoveElementAt to "search
+ // and destroy" the first element that is equal to the given element.
+ // 'operator==' must be defined for value_type.
+ // @param aItem The item to search for.
+ // @return true if the element was found and removed.
+ template <class Item>
+ bool RemoveElement(const Item& aItem) {
+ index_type index = mArray.IndexOf(aItem, 0);
+ if (index == array_type::NoIndex) {
+ return false;
+ }
+
+ mArray.RemoveElementAt(index);
+ AdjustIterators(index, -1);
+ return true;
+ }
+
+ // See nsTArray::RemoveElementsBy. Neither the predicate nor the removal of
+ // elements from the array must have any side effects that modify the array.
+ template <typename Predicate>
+ void NonObservingRemoveElementsBy(Predicate aPredicate) {
+ index_type i = 0;
+ mArray.RemoveElementsBy([&](const value_type& aItem) {
+ if (aPredicate(aItem)) {
+ // This element is going to be removed.
+ AdjustIterators(i, -1);
+ return true;
+ }
+ ++i;
+ return false;
+ });
+ }
+
+ // Removes all observers and collapses all iterators to the beginning of
+ // the array. The result is that forward iterators will see all elements
+ // in the array.
+ void Clear() {
+ mArray.Clear();
+ ClearIterators();
+ }
+
+ // Compact the array to minimize the memory it uses
+ void Compact() { mArray.Compact(); }
+
+ // Returns the number of bytes on the heap taken up by this object, not
+ // including sizeof(*this). If you want to measure anything hanging off the
+ // array, you must iterate over the elements and measure them individually;
+ // hence the "Shallow" prefix.
+ size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+ return mArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ //
+ // Iterators
+ //
+
+ // Base class for iterators. Do not use this directly.
+ class Iterator : public Iterator_base {
+ protected:
+ friend class nsAutoTObserverArray;
+ typedef nsAutoTObserverArray<T, N> array_type;
+
+ Iterator(const Iterator& aOther)
+ : Iterator(aOther.mPosition, aOther.mArray) {}
+
+ Iterator(index_type aPosition, const array_type& aArray)
+ : Iterator_base(aPosition, aArray.mIterators),
+ mArray(const_cast<array_type&>(aArray)) {
+ aArray.mIterators = this;
+ }
+
+ ~Iterator() {
+ NS_ASSERTION(mArray.mIterators == this,
+ "Iterators must currently be destroyed in opposite order "
+ "from the construction order. It is suggested that you "
+ "simply put them on the stack");
+ mArray.mIterators = mNext;
+ }
+
+ // The array we're iterating
+ array_type& mArray;
+ };
+
+ // Iterates the array forward from beginning to end. mPosition points
+ // to the element that will be returned on next call to GetNext.
+ // Elements:
+ // - prepended to the array during iteration *will not* be traversed
+ // - appended during iteration *will* be traversed
+ // - removed during iteration *will not* be traversed.
+ // @see EndLimitedIterator
+ class ForwardIterator : protected Iterator {
+ public:
+ typedef nsAutoTObserverArray<T, N> array_type;
+ typedef Iterator base_type;
+
+ explicit ForwardIterator(const array_type& aArray) : Iterator(0, aArray) {}
+
+ ForwardIterator(const array_type& aArray, index_type aPos)
+ : Iterator(aPos, aArray) {}
+
+ bool operator<(const ForwardIterator& aOther) const {
+ NS_ASSERTION(&this->mArray == &aOther.mArray,
+ "not iterating the same array");
+ return base_type::mPosition < aOther.mPosition;
+ }
+
+ // Returns true if there are more elements to iterate.
+ // This must precede a call to GetNext(). If false is
+ // returned, GetNext() must not be called.
+ bool HasMore() const {
+ return base_type::mPosition < base_type::mArray.Length();
+ }
+
+ // Returns the next element and steps one step. This must
+ // be preceded by a call to HasMore().
+ // @return The next observer.
+ value_type& GetNext() {
+ NS_ASSERTION(HasMore(), "iterating beyond end of array");
+ return base_type::mArray.Elements()[base_type::mPosition++];
+ }
+
+ // Removes the element at the current iterator position.
+ // (the last element returned from |GetNext()|)
+ // This will not affect the next call to |GetNext()|
+ void Remove() {
+ return base_type::mArray.RemoveElementAt(base_type::mPosition - 1);
+ }
+ };
+
+ // EndLimitedIterator works like ForwardIterator, but will not iterate new
+ // observers appended to the array after the iterator was created.
+ class EndLimitedIterator : protected ForwardIterator {
+ public:
+ typedef nsAutoTObserverArray<T, N> array_type;
+ typedef Iterator base_type;
+
+ explicit EndLimitedIterator(const array_type& aArray)
+ : ForwardIterator(aArray), mEnd(aArray, aArray.Length()) {}
+
+ // Returns true if there are more elements to iterate.
+ // This must precede a call to GetNext(). If false is
+ // returned, GetNext() must not be called.
+ bool HasMore() const { return *this < mEnd; }
+
+ // Returns the next element and steps one step. This must
+ // be preceded by a call to HasMore().
+ // @return The next observer.
+ value_type& GetNext() {
+ NS_ASSERTION(HasMore(), "iterating beyond end of array");
+ return base_type::mArray.Elements()[base_type::mPosition++];
+ }
+
+ // Removes the element at the current iterator position.
+ // (the last element returned from |GetNext()|)
+ // This will not affect the next call to |GetNext()|
+ void Remove() {
+ return base_type::mArray.RemoveElementAt(base_type::mPosition - 1);
+ }
+
+ private:
+ ForwardIterator mEnd;
+ };
+
+ // Iterates the array backward from end to start. mPosition points
+ // to the element that was returned last.
+ // Elements:
+ // - prepended to the array during iteration *will* be traversed,
+ // unless the iteration already arrived at the first element
+ // - appended during iteration *will not* be traversed
+ // - removed during iteration *will not* be traversed.
+ class BackwardIterator : protected Iterator {
+ public:
+ typedef nsAutoTObserverArray<T, N> array_type;
+ typedef Iterator base_type;
+
+ explicit BackwardIterator(const array_type& aArray)
+ : Iterator(aArray.Length(), aArray) {}
+
+ // Returns true if there are more elements to iterate.
+ // This must precede a call to GetNext(). If false is
+ // returned, GetNext() must not be called.
+ bool HasMore() const { return base_type::mPosition > 0; }
+
+ // Returns the next element and steps one step. This must
+ // be preceded by a call to HasMore().
+ // @return The next observer.
+ value_type& GetNext() {
+ NS_ASSERTION(HasMore(), "iterating beyond start of array");
+ return base_type::mArray.Elements()[--base_type::mPosition];
+ }
+
+ // Removes the element at the current iterator position.
+ // (the last element returned from |GetNext()|)
+ // This will not affect the next call to |GetNext()|
+ void Remove() {
+ return base_type::mArray.RemoveElementAt(base_type::mPosition);
+ }
+ };
+
+ struct EndSentinel {};
+
+ // Internal type, do not use directly, see
+ // ForwardRange()/EndLimitedRange()/BackwardRange().
+ template <typename Iterator, typename U>
+ struct STLIterator {
+ using value_type = std::remove_reference_t<U>;
+
+ explicit STLIterator(const nsAutoTObserverArray<T, N>& aArray)
+ : mIterator{aArray} {
+ operator++();
+ }
+
+ bool operator!=(const EndSentinel&) const {
+ // We are a non-end-sentinel and the other is an end-sentinel, so we are
+ // still valid if mCurrent is valid.
+ return mCurrent;
+ }
+
+ STLIterator& operator++() {
+ mCurrent = mIterator.HasMore() ? &mIterator.GetNext() : nullptr;
+ return *this;
+ }
+
+ value_type* operator->() { return mCurrent; }
+ U& operator*() { return *mCurrent; }
+
+ private:
+ Iterator mIterator;
+ value_type* mCurrent;
+ };
+
+ // Internal type, do not use directly, see
+ // ForwardRange()/EndLimitedRange()/BackwardRange().
+ template <typename Iterator, typename U>
+ class STLIteratorRange {
+ public:
+ using iterator = STLIterator<Iterator, U>;
+
+ explicit STLIteratorRange(const nsAutoTObserverArray<T, N>& aArray)
+ : mArray{aArray} {}
+
+ STLIteratorRange(const STLIteratorRange& aOther) = delete;
+
+ iterator begin() const { return iterator{mArray}; }
+ EndSentinel end() const { return {}; }
+
+ private:
+ const nsAutoTObserverArray<T, N>& mArray;
+ };
+
+ template <typename U>
+ using STLForwardIteratorRange = STLIteratorRange<ForwardIterator, U>;
+
+ template <typename U>
+ using STLEndLimitedIteratorRange = STLIteratorRange<EndLimitedIterator, U>;
+
+ template <typename U>
+ using STLBackwardIteratorRange = STLIteratorRange<BackwardIterator, U>;
+
+ // Constructs a range (usable with range-based for) based on the
+ // ForwardIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto ForwardRange() { return STLForwardIteratorRange<T>{*this}; }
+
+ // Constructs a const range (usable with range-based for) based on the
+ // ForwardIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto ForwardRange() const { return STLForwardIteratorRange<const T>{*this}; }
+
+ // Constructs a range (usable with range-based for) based on the
+ // EndLimitedIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto EndLimitedRange() { return STLEndLimitedIteratorRange<T>{*this}; }
+
+ // Constructs a const range (usable with range-based for) based on the
+ // EndLimitedIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto EndLimitedRange() const {
+ return STLEndLimitedIteratorRange<const T>{*this};
+ }
+
+ // Constructs a range (usable with range-based for) based on the
+ // BackwardIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto BackwardRange() { return STLBackwardIteratorRange<T>{*this}; }
+
+ // Constructs a const range (usable with range-based for) based on the
+ // BackwardIterator semantics. Note that this range does not provide
+ // full-feature STL-style iterators usable with STL-style algorithms.
+ auto BackwardRange() const {
+ return STLBackwardIteratorRange<const T>{*this};
+ }
+
+ // Constructs a const range (usable with range-based for and STL-style
+ // algorithms) based on a non-observing iterator. The array must not be
+ // modified during iteration.
+ auto NonObservingRange() const {
+ return mozilla::detail::IteratorRange<
+ typename AutoTArray<T, N>::const_iterator,
+ typename AutoTArray<T, N>::const_reverse_iterator>{mArray.cbegin(),
+ mArray.cend()};
+ }
+
+ protected:
+ AutoTArray<T, N> mArray;
+};
+
+template <class T>
+class nsTObserverArray : public nsAutoTObserverArray<T, 0> {
+ public:
+ typedef nsAutoTObserverArray<T, 0> base_type;
+ typedef nsTObserverArray_base::size_type size_type;
+
+ //
+ // Initialization methods
+ //
+
+ nsTObserverArray() = default;
+
+ // Initialize this array and pre-allocate some number of elements.
+ explicit nsTObserverArray(size_type aCapacity) {
+ base_type::mArray.SetCapacity(aCapacity);
+ }
+
+ nsTObserverArray Clone() const {
+ auto result = nsTObserverArray{};
+ result.mArray.Assign(this->mArray);
+ return result;
+ }
+};
+
+template <typename T, size_t N>
+auto MakeBackInserter(nsAutoTObserverArray<T, N>& aArray) {
+ return mozilla::nsTArrayBackInserter<T, nsAutoTObserverArray<T, N>>{aArray};
+}
+
+template <typename T, size_t N>
+inline void ImplCycleCollectionUnlink(nsAutoTObserverArray<T, N>& aField) {
+ aField.Clear();
+}
+
+template <typename T, size_t N>
+inline void ImplCycleCollectionTraverse(
+ nsCycleCollectionTraversalCallback& aCallback,
+ nsAutoTObserverArray<T, N>& aField, const char* aName,
+ uint32_t aFlags = 0) {
+ aFlags |= CycleCollectionEdgeNameArrayFlag;
+ size_t length = aField.Length();
+ for (size_t i = 0; i < length; ++i) {
+ ImplCycleCollectionTraverse(aCallback, aField.ElementAt(i), aName, aFlags);
+ }
+}
+
+// Note that this macro only works if the array holds pointers to XPCOM objects.
+#define NS_OBSERVER_ARRAY_NOTIFY_XPCOM_OBSERVERS(array_, func_, params_) \
+ do { \
+ for (RefPtr obs_ : (array_).ForwardRange()) { \
+ obs_->func_ params_; \
+ } \
+ } while (0)
+
+// Note that this macro only works if the array holds pointers to XPCOM objects.
+#define NS_OBSERVER_ARRAY_NOTIFY_OBSERVERS(array_, func_, params_) \
+ do { \
+ for (auto* obs_ : (array_).ForwardRange()) { \
+ obs_->func_ params_; \
+ } \
+ } while (0)
+
+#endif // nsTObserverArray_h___
diff --git a/xpcom/ds/nsTPriorityQueue.h b/xpcom/ds/nsTPriorityQueue.h
new file mode 100644
index 0000000000..1fa1cc1e50
--- /dev/null
+++ b/xpcom/ds/nsTPriorityQueue.h
@@ -0,0 +1,147 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef NS_TPRIORITY_QUEUE_H_
+#define NS_TPRIORITY_QUEUE_H_
+
+#include "mozilla/Assertions.h"
+#include "nsTArray.h"
+
+/**
+ * A templatized priority queue data structure that uses an nsTArray to serve as
+ * a binary heap. The default comparator causes this to act like a min-heap.
+ * Only the LessThan method of the comparator is used.
+ */
+template <class T, class Compare = nsDefaultComparator<T, T>>
+class nsTPriorityQueue {
+ public:
+ typedef typename nsTArray<T>::size_type size_type;
+
+ /**
+ * Default constructor also creates a comparator object using the default
+ * constructor for type Compare.
+ */
+ nsTPriorityQueue() : mCompare(Compare()) {}
+
+ /**
+ * Constructor to allow a specific instance of a comparator object to be
+ * used.
+ */
+ explicit nsTPriorityQueue(const Compare& aComp) : mCompare(aComp) {}
+
+ nsTPriorityQueue(nsTPriorityQueue&&) = default;
+ nsTPriorityQueue& operator=(nsTPriorityQueue&&) = default;
+
+ /**
+ * @return True if the queue is empty or false otherwise.
+ */
+ bool IsEmpty() const { return mElements.IsEmpty(); }
+
+ /**
+ * @return The number of elements in the queue.
+ */
+ size_type Length() const { return mElements.Length(); }
+
+ /**
+ * @return The topmost element in the queue without changing the queue. This
+ * is the element 'a' such that there is no other element 'b' in the queue for
+ * which Compare(b, a) returns true. (Since this container does not check
+ * for duplicate entries there may exist 'b' for which Compare(a, b) returns
+ * false.)
+ */
+ const T& Top() const {
+ MOZ_ASSERT(!mElements.IsEmpty(), "Empty queue");
+ return mElements[0];
+ }
+
+ /**
+ * Adds an element to the queue
+ * @param aElement The element to add
+ * @return true on success, false on out of memory.
+ */
+ void Push(T&& aElement) {
+ mElements.AppendElement(std::move(aElement));
+
+ // Sift up
+ size_type i = mElements.Length() - 1;
+ while (i) {
+ size_type parent = (size_type)((i - 1) / 2);
+ if (mCompare.LessThan(mElements[parent], mElements[i])) {
+ break;
+ }
+ std::swap(mElements[i], mElements[parent]);
+ i = parent;
+ }
+ }
+
+ /**
+ * Removes and returns the top-most element from the queue.
+ * @return The topmost element, that is, the element 'a' such that there is no
+ * other element 'b' in the queue for which Compare(b, a) returns true.
+ * @see Top()
+ */
+ T Pop() {
+ MOZ_ASSERT(!mElements.IsEmpty(), "Empty queue");
+ T pop = std::move(mElements[0]);
+
+ const size_type newLength = mElements.Length() - 1;
+ if (newLength == 0) {
+ mElements.Clear();
+ return pop;
+ }
+
+ // Move last to front
+ mElements[0] = mElements.PopLastElement();
+
+ // Sift down
+ size_type i = 0;
+ while (2 * i + 1 < newLength) {
+ size_type swap = i;
+ size_type l_child = 2 * i + 1;
+ if (mCompare.LessThan(mElements[l_child], mElements[i])) {
+ swap = l_child;
+ }
+ size_type r_child = l_child + 1;
+ if (r_child < newLength &&
+ mCompare.LessThan(mElements[r_child], mElements[swap])) {
+ swap = r_child;
+ }
+ if (swap == i) {
+ break;
+ }
+ std::swap(mElements[i], mElements[swap]);
+ i = swap;
+ }
+
+ return pop;
+ }
+
+ /**
+ * Removes all elements from the queue.
+ */
+ void Clear() { mElements.Clear(); }
+
+ /**
+ * Provides readonly access to the queue elements as an array. Generally this
+ * should be avoided but may be needed in some situations such as when the
+ * elements contained in the queue need to be enumerated for cycle-collection.
+ * @return A pointer to the first element of the array. If the array is
+ * empty, then this pointer must not be dereferenced.
+ */
+ const T* Elements() const { return mElements.Elements(); }
+
+ nsTPriorityQueue Clone() const {
+ auto res = nsTPriorityQueue{mCompare};
+ res.mElements = mElements.Clone();
+ return res;
+ }
+
+ protected:
+ nsTArray<T> mElements;
+ Compare mCompare; // Comparator object
+};
+
+#endif // NS_TPRIORITY_QUEUE_H_
diff --git a/xpcom/ds/nsVariant.cpp b/xpcom/ds/nsVariant.cpp
new file mode 100644
index 0000000000..f8a40431c7
--- /dev/null
+++ b/xpcom/ds/nsVariant.cpp
@@ -0,0 +1,1876 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsVariant.h"
+#include "prprf.h"
+#include "prdtoa.h"
+#include <math.h>
+#include "nsCycleCollectionParticipant.h"
+#include "xptinfo.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsCRTGlue.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Printf.h"
+
+/***************************************************************************/
+// Helpers for static convert functions...
+
+static nsresult String2Double(const char* aString, double* aResult) {
+ char* next;
+ double value = PR_strtod(aString, &next);
+ if (next == aString) {
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+ *aResult = value;
+ return NS_OK;
+}
+
+static nsresult AString2Double(const nsAString& aString, double* aResult) {
+ char* pChars = ToNewCString(aString, mozilla::fallible);
+ if (!pChars) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ nsresult rv = String2Double(pChars, aResult);
+ free(pChars);
+ return rv;
+}
+
+static nsresult AUTF8String2Double(const nsAUTF8String& aString,
+ double* aResult) {
+ return String2Double(PromiseFlatUTF8String(aString).get(), aResult);
+}
+
+static nsresult ACString2Double(const nsACString& aString, double* aResult) {
+ return String2Double(PromiseFlatCString(aString).get(), aResult);
+}
+
+// Fills aOutData with double, uint32_t, or int32_t.
+// Returns NS_OK, an error code, or a non-NS_OK success code
+nsresult nsDiscriminatedUnion::ToManageableNumber(
+ nsDiscriminatedUnion* aOutData) const {
+ nsresult rv;
+
+ switch (mType) {
+ // This group results in a int32_t...
+
+#define CASE__NUMBER_INT32(type_, member_) \
+ case nsIDataType::type_: \
+ aOutData->u.mInt32Value = u.member_; \
+ aOutData->mType = nsIDataType::VTYPE_INT32; \
+ return NS_OK;
+
+ CASE__NUMBER_INT32(VTYPE_INT8, mInt8Value)
+ CASE__NUMBER_INT32(VTYPE_INT16, mInt16Value)
+ CASE__NUMBER_INT32(VTYPE_INT32, mInt32Value)
+ CASE__NUMBER_INT32(VTYPE_UINT8, mUint8Value)
+ CASE__NUMBER_INT32(VTYPE_UINT16, mUint16Value)
+ CASE__NUMBER_INT32(VTYPE_BOOL, mBoolValue)
+ CASE__NUMBER_INT32(VTYPE_CHAR, mCharValue)
+ CASE__NUMBER_INT32(VTYPE_WCHAR, mWCharValue)
+
+#undef CASE__NUMBER_INT32
+
+ // This group results in a uint32_t...
+
+ case nsIDataType::VTYPE_UINT32:
+ aOutData->u.mUint32Value = u.mUint32Value;
+ aOutData->mType = nsIDataType::VTYPE_UINT32;
+ return NS_OK;
+
+ // This group results in a double...
+
+ case nsIDataType::VTYPE_INT64:
+ case nsIDataType::VTYPE_UINT64:
+ // XXX Need boundary checking here.
+ // We may need to return NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA
+ aOutData->u.mDoubleValue = double(u.mInt64Value);
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_FLOAT:
+ aOutData->u.mDoubleValue = u.mFloatValue;
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_DOUBLE:
+ aOutData->u.mDoubleValue = u.mDoubleValue;
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ rv = String2Double(u.str.mStringValue, &aOutData->u.mDoubleValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_ASTRING:
+ rv = AString2Double(*u.mAStringValue, &aOutData->u.mDoubleValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_UTF8STRING:
+ rv = AUTF8String2Double(*u.mUTF8StringValue, &aOutData->u.mDoubleValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_CSTRING:
+ rv = ACString2Double(*u.mCStringValue, &aOutData->u.mDoubleValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ rv = AString2Double(nsDependentString(u.wstr.mWStringValue),
+ &aOutData->u.mDoubleValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutData->mType = nsIDataType::VTYPE_DOUBLE;
+ return NS_OK;
+
+ // This group fails...
+
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_ID:
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ case nsIDataType::VTYPE_ARRAY:
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_EMPTY:
+ default:
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+}
+
+/***************************************************************************/
+// Array helpers...
+
+void nsDiscriminatedUnion::FreeArray() {
+ NS_ASSERTION(mType == nsIDataType::VTYPE_ARRAY, "bad FreeArray call");
+ NS_ASSERTION(u.array.mArrayValue, "bad array");
+ NS_ASSERTION(u.array.mArrayCount, "bad array count");
+
+#define CASE__FREE_ARRAY_PTR(type_, ctype_) \
+ case nsIDataType::type_: { \
+ ctype_** p = (ctype_**)u.array.mArrayValue; \
+ for (uint32_t i = u.array.mArrayCount; i > 0; p++, i--) \
+ if (*p) free((char*)*p); \
+ break; \
+ }
+
+#define CASE__FREE_ARRAY_IFACE(type_, ctype_) \
+ case nsIDataType::type_: { \
+ ctype_** p = (ctype_**)u.array.mArrayValue; \
+ for (uint32_t i = u.array.mArrayCount; i > 0; p++, i--) \
+ if (*p) (*p)->Release(); \
+ break; \
+ }
+
+ switch (u.array.mArrayType) {
+ case nsIDataType::VTYPE_INT8:
+ case nsIDataType::VTYPE_INT16:
+ case nsIDataType::VTYPE_INT32:
+ case nsIDataType::VTYPE_INT64:
+ case nsIDataType::VTYPE_UINT8:
+ case nsIDataType::VTYPE_UINT16:
+ case nsIDataType::VTYPE_UINT32:
+ case nsIDataType::VTYPE_UINT64:
+ case nsIDataType::VTYPE_FLOAT:
+ case nsIDataType::VTYPE_DOUBLE:
+ case nsIDataType::VTYPE_BOOL:
+ case nsIDataType::VTYPE_CHAR:
+ case nsIDataType::VTYPE_WCHAR:
+ break;
+
+ // XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
+ CASE__FREE_ARRAY_PTR(VTYPE_ID, nsID)
+ CASE__FREE_ARRAY_PTR(VTYPE_CHAR_STR, char)
+ CASE__FREE_ARRAY_PTR(VTYPE_WCHAR_STR, char16_t)
+ CASE__FREE_ARRAY_IFACE(VTYPE_INTERFACE, nsISupports)
+ CASE__FREE_ARRAY_IFACE(VTYPE_INTERFACE_IS, nsISupports)
+
+ // The rest are illegal.
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_UTF8STRING:
+ case nsIDataType::VTYPE_CSTRING:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ case nsIDataType::VTYPE_ARRAY:
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_EMPTY:
+ default:
+ NS_ERROR("bad type in array!");
+ break;
+ }
+
+ // Free the array memory.
+ free((char*)u.array.mArrayValue);
+
+#undef CASE__FREE_ARRAY_PTR
+#undef CASE__FREE_ARRAY_IFACE
+}
+
+static nsresult CloneArray(uint16_t aInType, const nsIID* aInIID,
+ uint32_t aInCount, void* aInValue,
+ uint16_t* aOutType, nsIID* aOutIID,
+ uint32_t* aOutCount, void** aOutValue) {
+ NS_ASSERTION(aInCount, "bad param");
+ NS_ASSERTION(aInValue, "bad param");
+ NS_ASSERTION(aOutType, "bad param");
+ NS_ASSERTION(aOutCount, "bad param");
+ NS_ASSERTION(aOutValue, "bad param");
+
+ uint32_t i;
+
+ // First we figure out the size of the elements for the new u.array.
+
+ size_t elementSize;
+ size_t allocSize;
+
+ switch (aInType) {
+ case nsIDataType::VTYPE_INT8:
+ elementSize = sizeof(int8_t);
+ break;
+ case nsIDataType::VTYPE_INT16:
+ elementSize = sizeof(int16_t);
+ break;
+ case nsIDataType::VTYPE_INT32:
+ elementSize = sizeof(int32_t);
+ break;
+ case nsIDataType::VTYPE_INT64:
+ elementSize = sizeof(int64_t);
+ break;
+ case nsIDataType::VTYPE_UINT8:
+ elementSize = sizeof(uint8_t);
+ break;
+ case nsIDataType::VTYPE_UINT16:
+ elementSize = sizeof(uint16_t);
+ break;
+ case nsIDataType::VTYPE_UINT32:
+ elementSize = sizeof(uint32_t);
+ break;
+ case nsIDataType::VTYPE_UINT64:
+ elementSize = sizeof(uint64_t);
+ break;
+ case nsIDataType::VTYPE_FLOAT:
+ elementSize = sizeof(float);
+ break;
+ case nsIDataType::VTYPE_DOUBLE:
+ elementSize = sizeof(double);
+ break;
+ case nsIDataType::VTYPE_BOOL:
+ elementSize = sizeof(bool);
+ break;
+ case nsIDataType::VTYPE_CHAR:
+ elementSize = sizeof(char);
+ break;
+ case nsIDataType::VTYPE_WCHAR:
+ elementSize = sizeof(char16_t);
+ break;
+
+ // XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
+ case nsIDataType::VTYPE_ID:
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ elementSize = sizeof(void*);
+ break;
+
+ // The rest are illegal.
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_UTF8STRING:
+ case nsIDataType::VTYPE_CSTRING:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_ARRAY:
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_EMPTY:
+ default:
+ NS_ERROR("bad type in array!");
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+
+ // Alloc the u.array.
+
+ allocSize = aInCount * elementSize;
+ *aOutValue = moz_xmalloc(allocSize);
+
+ // Clone the elements.
+
+ switch (aInType) {
+ case nsIDataType::VTYPE_INT8:
+ case nsIDataType::VTYPE_INT16:
+ case nsIDataType::VTYPE_INT32:
+ case nsIDataType::VTYPE_INT64:
+ case nsIDataType::VTYPE_UINT8:
+ case nsIDataType::VTYPE_UINT16:
+ case nsIDataType::VTYPE_UINT32:
+ case nsIDataType::VTYPE_UINT64:
+ case nsIDataType::VTYPE_FLOAT:
+ case nsIDataType::VTYPE_DOUBLE:
+ case nsIDataType::VTYPE_BOOL:
+ case nsIDataType::VTYPE_CHAR:
+ case nsIDataType::VTYPE_WCHAR:
+ memcpy(*aOutValue, aInValue, allocSize);
+ break;
+
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ if (aOutIID) {
+ *aOutIID = *aInIID;
+ }
+ [[fallthrough]];
+
+ case nsIDataType::VTYPE_INTERFACE: {
+ memcpy(*aOutValue, aInValue, allocSize);
+
+ nsISupports** p = (nsISupports**)*aOutValue;
+ for (i = aInCount; i > 0; ++p, --i)
+ if (*p) {
+ (*p)->AddRef();
+ }
+ break;
+ }
+
+ // XXX We ASSUME that "array of nsID" means "array of pointers to nsID".
+ case nsIDataType::VTYPE_ID: {
+ nsID** inp = (nsID**)aInValue;
+ nsID** outp = (nsID**)*aOutValue;
+ for (i = aInCount; i > 0; --i) {
+ nsID* idp = *(inp++);
+ if (idp) {
+ *(outp++) = idp->Clone();
+ } else {
+ *(outp++) = nullptr;
+ }
+ }
+ break;
+ }
+
+ case nsIDataType::VTYPE_CHAR_STR: {
+ char** inp = (char**)aInValue;
+ char** outp = (char**)*aOutValue;
+ for (i = aInCount; i > 0; i--) {
+ char* str = *(inp++);
+ if (str) {
+ *(outp++) = moz_xstrdup(str);
+ } else {
+ *(outp++) = nullptr;
+ }
+ }
+ break;
+ }
+
+ case nsIDataType::VTYPE_WCHAR_STR: {
+ char16_t** inp = (char16_t**)aInValue;
+ char16_t** outp = (char16_t**)*aOutValue;
+ for (i = aInCount; i > 0; i--) {
+ char16_t* str = *(inp++);
+ if (str) {
+ *(outp++) = NS_xstrdup(str);
+ } else {
+ *(outp++) = nullptr;
+ }
+ }
+ break;
+ }
+
+ // The rest are illegal.
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_ARRAY:
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_EMPTY:
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_UTF8STRING:
+ case nsIDataType::VTYPE_CSTRING:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ default:
+ NS_ERROR("bad type in array!");
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+
+ *aOutType = aInType;
+ *aOutCount = aInCount;
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+#define TRIVIAL_DATA_CONVERTER(type_, member_, retval_) \
+ if (mType == nsIDataType::type_) { \
+ *retval_ = u.member_; \
+ return NS_OK; \
+ }
+
+#define NUMERIC_CONVERSION_METHOD_BEGIN(type_, Ctype_, name_) \
+ nsresult nsDiscriminatedUnion::ConvertTo##name_(Ctype_* aResult) const { \
+ TRIVIAL_DATA_CONVERTER(type_, m##name_##Value, aResult) \
+ nsDiscriminatedUnion tempData; \
+ nsresult rv = ToManageableNumber(&tempData); \
+ /* */ \
+ /* NOTE: rv may indicate a success code that we want to preserve */ \
+ /* For the final return. So all the return cases below should return */ \
+ /* this rv when indicating success. */ \
+ /* */ \
+ if (NS_FAILED(rv)) return rv; \
+ switch (tempData.mType) {
+#define CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(Ctype_) \
+ case nsIDataType::VTYPE_INT32: \
+ *aResult = (Ctype_)tempData.u.mInt32Value; \
+ return rv;
+
+#define CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(Ctype_, min_, max_) \
+ case nsIDataType::VTYPE_INT32: { \
+ int32_t value = tempData.u.mInt32Value; \
+ if (value < (min_) || value > (max_)) { \
+ return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
+ } \
+ *aResult = (Ctype_)value; \
+ return rv; \
+ }
+
+#define CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(Ctype_) \
+ case nsIDataType::VTYPE_UINT32: \
+ *aResult = (Ctype_)tempData.u.mUint32Value; \
+ return rv;
+
+#define CASE__NUMERIC_CONVERSION_UINT32_MAX(Ctype_, max_) \
+ case nsIDataType::VTYPE_UINT32: { \
+ uint32_t value = tempData.u.mUint32Value; \
+ if (value > (max_)) return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
+ *aResult = (Ctype_)value; \
+ return rv; \
+ }
+
+#define CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(Ctype_) \
+ case nsIDataType::VTYPE_DOUBLE: \
+ *aResult = (Ctype_)tempData.u.mDoubleValue; \
+ return rv;
+
+#define CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(Ctype_, min_, max_) \
+ case nsIDataType::VTYPE_DOUBLE: { \
+ double value = tempData.u.mDoubleValue; \
+ if (std::isnan(value) || value < (min_) || value > (max_)) { \
+ return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA; \
+ } \
+ *aResult = (Ctype_)value; \
+ return (0.0 == fmod(value, 1.0)) ? rv \
+ : NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA; \
+ }
+
+#define CASES__NUMERIC_CONVERSION_NORMAL(Ctype_, min_, max_) \
+ CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(Ctype_, min_, max_) \
+ CASE__NUMERIC_CONVERSION_UINT32_MAX(Ctype_, max_) \
+ CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(Ctype_, min_, max_)
+
+#define NUMERIC_CONVERSION_METHOD_END \
+ default: \
+ NS_ERROR("bad type returned from ToManageableNumber"); \
+ return NS_ERROR_CANNOT_CONVERT_DATA; \
+ } \
+ }
+
+#define NUMERIC_CONVERSION_METHOD_NORMAL(type_, Ctype_, name_, min_, max_) \
+ NUMERIC_CONVERSION_METHOD_BEGIN(type_, Ctype_, name_) \
+ CASES__NUMERIC_CONVERSION_NORMAL(Ctype_, min_, max_) \
+ NUMERIC_CONVERSION_METHOD_END
+
+/***************************************************************************/
+// These expand into full public methods...
+
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_INT8, uint8_t, Int8, (-127 - 1), 127)
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_INT16, int16_t, Int16, (-32767 - 1),
+ 32767)
+
+NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_INT32, int32_t, Int32)
+CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(int32_t)
+CASE__NUMERIC_CONVERSION_UINT32_MAX(int32_t, 2147483647)
+CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(int32_t, (-2147483647 - 1),
+ 2147483647)
+NUMERIC_CONVERSION_METHOD_END
+
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_UINT8, uint8_t, Uint8, 0, 255)
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_UINT16, uint16_t, Uint16, 0, 65535)
+
+NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_UINT32, uint32_t, Uint32)
+CASE__NUMERIC_CONVERSION_INT32_MIN_MAX(uint32_t, 0, 2147483647)
+CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(uint32_t)
+CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT(uint32_t, 0, 4294967295U)
+NUMERIC_CONVERSION_METHOD_END
+
+// XXX toFloat conversions need to be fixed!
+NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_FLOAT, float, Float)
+CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(float)
+CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(float)
+CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(float)
+NUMERIC_CONVERSION_METHOD_END
+
+NUMERIC_CONVERSION_METHOD_BEGIN(VTYPE_DOUBLE, double, Double)
+CASE__NUMERIC_CONVERSION_INT32_JUST_CAST(double)
+CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST(double)
+CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST(double)
+NUMERIC_CONVERSION_METHOD_END
+
+// XXX toChar conversions need to be fixed!
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_CHAR, char, Char, CHAR_MIN, CHAR_MAX)
+
+// XXX toWChar conversions need to be fixed!
+NUMERIC_CONVERSION_METHOD_NORMAL(VTYPE_WCHAR, char16_t, WChar, 0,
+ std::numeric_limits<char16_t>::max())
+
+#undef NUMERIC_CONVERSION_METHOD_BEGIN
+#undef CASE__NUMERIC_CONVERSION_INT32_JUST_CAST
+#undef CASE__NUMERIC_CONVERSION_INT32_MIN_MAX
+#undef CASE__NUMERIC_CONVERSION_UINT32_JUST_CAST
+#undef CASE__NUMERIC_CONVERSION_UINT32_MIN_MAX
+#undef CASE__NUMERIC_CONVERSION_DOUBLE_JUST_CAST
+#undef CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX
+#undef CASE__NUMERIC_CONVERSION_DOUBLE_MIN_MAX_INT
+#undef CASES__NUMERIC_CONVERSION_NORMAL
+#undef NUMERIC_CONVERSION_METHOD_END
+#undef NUMERIC_CONVERSION_METHOD_NORMAL
+
+/***************************************************************************/
+
+// Just leverage a numeric converter for bool (but restrict the values).
+// XXX Is this really what we want to do?
+
+nsresult nsDiscriminatedUnion::ConvertToBool(bool* aResult) const {
+ TRIVIAL_DATA_CONVERTER(VTYPE_BOOL, mBoolValue, aResult)
+
+ double val;
+ nsresult rv = ConvertToDouble(&val);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ // NaN is falsy in JS, so we might as well make it false here.
+ if (std::isnan(val)) {
+ *aResult = false;
+ } else {
+ *aResult = 0.0 != val;
+ }
+ return rv;
+}
+
+/***************************************************************************/
+
+nsresult nsDiscriminatedUnion::ConvertToInt64(int64_t* aResult) const {
+ TRIVIAL_DATA_CONVERTER(VTYPE_INT64, mInt64Value, aResult)
+ TRIVIAL_DATA_CONVERTER(VTYPE_UINT64, mUint64Value, aResult)
+
+ nsDiscriminatedUnion tempData;
+ nsresult rv = ToManageableNumber(&tempData);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ switch (tempData.mType) {
+ case nsIDataType::VTYPE_INT32:
+ *aResult = tempData.u.mInt32Value;
+ return rv;
+ case nsIDataType::VTYPE_UINT32:
+ *aResult = tempData.u.mUint32Value;
+ return rv;
+ case nsIDataType::VTYPE_DOUBLE: {
+ double value = tempData.u.mDoubleValue;
+ if (std::isnan(value)) {
+ return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA;
+ }
+ // XXX should check for data loss here!
+ *aResult = value;
+ return rv;
+ }
+ default:
+ NS_ERROR("bad type returned from ToManageableNumber");
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+}
+
+nsresult nsDiscriminatedUnion::ConvertToUint64(uint64_t* aResult) const {
+ return ConvertToInt64((int64_t*)aResult);
+}
+
+/***************************************************************************/
+
+bool nsDiscriminatedUnion::String2ID(nsID* aPid) const {
+ nsAutoString tempString;
+ nsAString* pString;
+
+ switch (mType) {
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ return aPid->Parse(u.str.mStringValue);
+ case nsIDataType::VTYPE_CSTRING:
+ return aPid->Parse(PromiseFlatCString(*u.mCStringValue).get());
+ case nsIDataType::VTYPE_UTF8STRING:
+ return aPid->Parse(PromiseFlatUTF8String(*u.mUTF8StringValue).get());
+ case nsIDataType::VTYPE_ASTRING:
+ pString = u.mAStringValue;
+ break;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ tempString.Assign(u.wstr.mWStringValue);
+ pString = &tempString;
+ break;
+ default:
+ NS_ERROR("bad type in call to String2ID");
+ return false;
+ }
+
+ char* pChars = ToNewCString(*pString, mozilla::fallible);
+ if (!pChars) {
+ return false;
+ }
+ bool result = aPid->Parse(pChars);
+ free(pChars);
+ return result;
+}
+
+nsresult nsDiscriminatedUnion::ConvertToID(nsID* aResult) const {
+ nsID id;
+
+ switch (mType) {
+ case nsIDataType::VTYPE_ID:
+ *aResult = u.mIDValue;
+ return NS_OK;
+ case nsIDataType::VTYPE_INTERFACE:
+ *aResult = NS_GET_IID(nsISupports);
+ return NS_OK;
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ *aResult = u.iface.mInterfaceID;
+ return NS_OK;
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_UTF8STRING:
+ case nsIDataType::VTYPE_CSTRING:
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ if (!String2ID(&id)) {
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+ *aResult = id;
+ return NS_OK;
+ default:
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+}
+
+/***************************************************************************/
+
+nsresult nsDiscriminatedUnion::ToString(nsACString& aOutString) const {
+ mozilla::SmprintfPointer pptr;
+
+ switch (mType) {
+ // all the stuff we don't handle...
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_UTF8STRING:
+ case nsIDataType::VTYPE_CSTRING:
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ case nsIDataType::VTYPE_WCHAR:
+ NS_ERROR("ToString being called for a string type - screwy logic!");
+ [[fallthrough]];
+
+ // XXX We might want stringified versions of these... ???
+
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_EMPTY:
+ aOutString.SetIsVoid(true);
+ return NS_OK;
+
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_ARRAY:
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ default:
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+
+ // nsID has its own text formatter.
+
+ case nsIDataType::VTYPE_ID: {
+ aOutString.Assign(u.mIDValue.ToString().get());
+ return NS_OK;
+ }
+
+ // Can't use Smprintf for floats, since it's locale-dependent
+#define CASE__APPENDFLOAT_NUMBER(type_, member_) \
+ case nsIDataType::type_: { \
+ nsAutoCString str; \
+ str.AppendFloat(u.member_); \
+ aOutString.Assign(str); \
+ return NS_OK; \
+ }
+
+ CASE__APPENDFLOAT_NUMBER(VTYPE_FLOAT, mFloatValue)
+ CASE__APPENDFLOAT_NUMBER(VTYPE_DOUBLE, mDoubleValue)
+
+#undef CASE__APPENDFLOAT_NUMBER
+
+ // the rest can be Smprintf'd and use common code.
+
+#define CASE__SMPRINTF_NUMBER(type_, format_, cast_, member_) \
+ case nsIDataType::type_: \
+ static_assert(sizeof(cast_) >= sizeof(u.member_), \
+ "size of type should be at least as big as member"); \
+ pptr = mozilla::Smprintf(format_, (cast_)u.member_); \
+ break;
+
+ CASE__SMPRINTF_NUMBER(VTYPE_INT8, "%d", int, mInt8Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_INT16, "%d", int, mInt16Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_INT32, "%d", int, mInt32Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_INT64, "%" PRId64, int64_t, mInt64Value)
+
+ CASE__SMPRINTF_NUMBER(VTYPE_UINT8, "%u", unsigned, mUint8Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_UINT16, "%u", unsigned, mUint16Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_UINT32, "%u", unsigned, mUint32Value)
+ CASE__SMPRINTF_NUMBER(VTYPE_UINT64, "%" PRIu64, int64_t, mUint64Value)
+
+ // XXX Would we rather print "true" / "false" ?
+ CASE__SMPRINTF_NUMBER(VTYPE_BOOL, "%d", int, mBoolValue)
+
+ CASE__SMPRINTF_NUMBER(VTYPE_CHAR, "%c", char, mCharValue)
+
+#undef CASE__SMPRINTF_NUMBER
+ }
+
+ if (!pptr) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ aOutString.Assign(pptr.get());
+ return NS_OK;
+}
+
+nsresult nsDiscriminatedUnion::ConvertToAString(nsAString& aResult) const {
+ switch (mType) {
+ case nsIDataType::VTYPE_ASTRING:
+ aResult.Assign(*u.mAStringValue);
+ return NS_OK;
+ case nsIDataType::VTYPE_CSTRING:
+ CopyASCIItoUTF16(*u.mCStringValue, aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_UTF8STRING:
+ CopyUTF8toUTF16(*u.mUTF8StringValue, aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_CHAR_STR:
+ CopyASCIItoUTF16(mozilla::MakeStringSpan(u.str.mStringValue), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ aResult.Assign(u.wstr.mWStringValue);
+ return NS_OK;
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ CopyASCIItoUTF16(
+ nsDependentCString(u.str.mStringValue, u.str.mStringLength), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ aResult.Assign(u.wstr.mWStringValue, u.wstr.mWStringLength);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR:
+ aResult.Assign(u.mWCharValue);
+ return NS_OK;
+ default: {
+ nsAutoCString tempCString;
+ nsresult rv = ToString(tempCString);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ CopyASCIItoUTF16(tempCString, aResult);
+ return NS_OK;
+ }
+ }
+}
+
+nsresult nsDiscriminatedUnion::ConvertToACString(nsACString& aResult) const {
+ switch (mType) {
+ case nsIDataType::VTYPE_ASTRING:
+ LossyCopyUTF16toASCII(*u.mAStringValue, aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_CSTRING:
+ aResult.Assign(*u.mCStringValue);
+ return NS_OK;
+ case nsIDataType::VTYPE_UTF8STRING:
+ // XXX This is an extra copy that should be avoided
+ // once Jag lands support for UTF8String and associated
+ // conversion methods.
+ LossyCopyUTF16toASCII(NS_ConvertUTF8toUTF16(*u.mUTF8StringValue),
+ aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_CHAR_STR:
+ aResult.Assign(*u.str.mStringValue);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ LossyCopyUTF16toASCII(nsDependentString(u.wstr.mWStringValue), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ aResult.Assign(u.str.mStringValue, u.str.mStringLength);
+ return NS_OK;
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ LossyCopyUTF16toASCII(
+ nsDependentString(u.wstr.mWStringValue, u.wstr.mWStringLength),
+ aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR: {
+ const char16_t* str = &u.mWCharValue;
+ LossyCopyUTF16toASCII(Substring(str, 1), aResult);
+ return NS_OK;
+ }
+ default:
+ return ToString(aResult);
+ }
+}
+
+nsresult nsDiscriminatedUnion::ConvertToAUTF8String(
+ nsAUTF8String& aResult) const {
+ switch (mType) {
+ case nsIDataType::VTYPE_ASTRING:
+ CopyUTF16toUTF8(*u.mAStringValue, aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_CSTRING:
+ // XXX Extra copy, can be removed if we're sure CSTRING can
+ // only contain ASCII.
+ CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(*u.mCStringValue), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_UTF8STRING:
+ aResult.Assign(*u.mUTF8StringValue);
+ return NS_OK;
+ case nsIDataType::VTYPE_CHAR_STR:
+ // XXX Extra copy, can be removed if we're sure CHAR_STR can
+ // only contain ASCII.
+ CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(u.str.mStringValue), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ CopyUTF16toUTF8(mozilla::MakeStringSpan(u.wstr.mWStringValue), aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ // XXX Extra copy, can be removed if we're sure CHAR_STR can
+ // only contain ASCII.
+ CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(nsDependentCString(
+ u.str.mStringValue, u.str.mStringLength)),
+ aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ CopyUTF16toUTF8(
+ nsDependentString(u.wstr.mWStringValue, u.wstr.mWStringLength),
+ aResult);
+ return NS_OK;
+ case nsIDataType::VTYPE_WCHAR: {
+ const char16_t* str = &u.mWCharValue;
+ CopyUTF16toUTF8(Substring(str, 1), aResult);
+ return NS_OK;
+ }
+ default: {
+ nsAutoCString tempCString;
+ nsresult rv = ToString(tempCString);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ // XXX Extra copy, can be removed if we're sure tempCString can
+ // only contain ASCII.
+ CopyUTF16toUTF8(NS_ConvertASCIItoUTF16(tempCString), aResult);
+ return NS_OK;
+ }
+ }
+}
+
+nsresult nsDiscriminatedUnion::ConvertToString(char** aResult) const {
+ uint32_t ignored;
+ return ConvertToStringWithSize(&ignored, aResult);
+}
+
+nsresult nsDiscriminatedUnion::ConvertToWString(char16_t** aResult) const {
+ uint32_t ignored;
+ return ConvertToWStringWithSize(&ignored, aResult);
+}
+
+nsresult nsDiscriminatedUnion::ConvertToStringWithSize(uint32_t* aSize,
+ char** aStr) const {
+ nsAutoString tempString;
+ nsAutoCString tempCString;
+ nsresult rv;
+
+ switch (mType) {
+ case nsIDataType::VTYPE_ASTRING:
+ *aSize = u.mAStringValue->Length();
+ *aStr = ToNewCString(*u.mAStringValue);
+ break;
+ case nsIDataType::VTYPE_CSTRING:
+ *aSize = u.mCStringValue->Length();
+ *aStr = ToNewCString(*u.mCStringValue);
+ break;
+ case nsIDataType::VTYPE_UTF8STRING: {
+ // XXX This is doing 1 extra copy. Need to fix this
+ // when Jag lands UTF8String
+ // we want:
+ // *aSize = *mUTF8StringValue->Length();
+ // *aStr = ToNewCString(*mUTF8StringValue);
+ // But this will have to do for now.
+ const NS_ConvertUTF8toUTF16 tempString16(*u.mUTF8StringValue);
+ *aSize = tempString16.Length();
+ *aStr = ToNewCString(tempString16);
+ break;
+ }
+ case nsIDataType::VTYPE_CHAR_STR: {
+ nsDependentCString cString(u.str.mStringValue);
+ *aSize = cString.Length();
+ *aStr = ToNewCString(cString);
+ break;
+ }
+ case nsIDataType::VTYPE_WCHAR_STR: {
+ nsDependentString string(u.wstr.mWStringValue);
+ *aSize = string.Length();
+ *aStr = ToNewCString(string);
+ break;
+ }
+ case nsIDataType::VTYPE_STRING_SIZE_IS: {
+ nsDependentCString cString(u.str.mStringValue, u.str.mStringLength);
+ *aSize = cString.Length();
+ *aStr = ToNewCString(cString);
+ break;
+ }
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS: {
+ nsDependentString string(u.wstr.mWStringValue, u.wstr.mWStringLength);
+ *aSize = string.Length();
+ *aStr = ToNewCString(string);
+ break;
+ }
+ case nsIDataType::VTYPE_WCHAR:
+ tempString.Assign(u.mWCharValue);
+ *aSize = tempString.Length();
+ *aStr = ToNewCString(tempString);
+ break;
+ default:
+ rv = ToString(tempCString);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ *aSize = tempCString.Length();
+ *aStr = ToNewCString(tempCString);
+ break;
+ }
+
+ return *aStr ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+nsresult nsDiscriminatedUnion::ConvertToWStringWithSize(uint32_t* aSize,
+ char16_t** aStr) const {
+ nsAutoString tempString;
+ nsAutoCString tempCString;
+ nsresult rv;
+
+ switch (mType) {
+ case nsIDataType::VTYPE_ASTRING:
+ *aSize = u.mAStringValue->Length();
+ *aStr = ToNewUnicode(*u.mAStringValue);
+ break;
+ case nsIDataType::VTYPE_CSTRING:
+ *aSize = u.mCStringValue->Length();
+ *aStr = ToNewUnicode(*u.mCStringValue);
+ break;
+ case nsIDataType::VTYPE_UTF8STRING: {
+ *aStr = UTF8ToNewUnicode(*u.mUTF8StringValue, aSize);
+ break;
+ }
+ case nsIDataType::VTYPE_CHAR_STR: {
+ nsDependentCString cString(u.str.mStringValue);
+ *aSize = cString.Length();
+ *aStr = ToNewUnicode(cString);
+ break;
+ }
+ case nsIDataType::VTYPE_WCHAR_STR: {
+ nsDependentString string(u.wstr.mWStringValue);
+ *aSize = string.Length();
+ *aStr = ToNewUnicode(string);
+ break;
+ }
+ case nsIDataType::VTYPE_STRING_SIZE_IS: {
+ nsDependentCString cString(u.str.mStringValue, u.str.mStringLength);
+ *aSize = cString.Length();
+ *aStr = ToNewUnicode(cString);
+ break;
+ }
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS: {
+ nsDependentString string(u.wstr.mWStringValue, u.wstr.mWStringLength);
+ *aSize = string.Length();
+ *aStr = ToNewUnicode(string);
+ break;
+ }
+ case nsIDataType::VTYPE_WCHAR:
+ tempString.Assign(u.mWCharValue);
+ *aSize = tempString.Length();
+ *aStr = ToNewUnicode(tempString);
+ break;
+ default:
+ rv = ToString(tempCString);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ *aSize = tempCString.Length();
+ *aStr = ToNewUnicode(tempCString);
+ break;
+ }
+
+ return *aStr ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+nsresult nsDiscriminatedUnion::ConvertToISupports(nsISupports** aResult) const {
+ switch (mType) {
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ if (u.iface.mInterfaceValue) {
+ return u.iface.mInterfaceValue->QueryInterface(NS_GET_IID(nsISupports),
+ (void**)aResult);
+ } else {
+ *aResult = nullptr;
+ return NS_OK;
+ }
+ default:
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+}
+
+nsresult nsDiscriminatedUnion::ConvertToInterface(nsIID** aIID,
+ void** aInterface) const {
+ const nsIID* piid;
+
+ switch (mType) {
+ case nsIDataType::VTYPE_INTERFACE:
+ piid = &NS_GET_IID(nsISupports);
+ break;
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ piid = &u.iface.mInterfaceID;
+ break;
+ default:
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+ }
+
+ *aIID = piid->Clone();
+
+ if (u.iface.mInterfaceValue) {
+ return u.iface.mInterfaceValue->QueryInterface(*piid, aInterface);
+ }
+
+ *aInterface = nullptr;
+ return NS_OK;
+}
+
+nsresult nsDiscriminatedUnion::ConvertToArray(uint16_t* aType, nsIID* aIID,
+ uint32_t* aCount,
+ void** aPtr) const {
+ // XXX perhaps we'd like to add support for converting each of the various
+ // types into an array containing one element of that type. We can leverage
+ // CloneArray to do this if we want to support this.
+
+ if (mType == nsIDataType::VTYPE_ARRAY) {
+ return CloneArray(u.array.mArrayType, &u.array.mArrayInterfaceID,
+ u.array.mArrayCount, u.array.mArrayValue, aType, aIID,
+ aCount, aPtr);
+ }
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+}
+
+/***************************************************************************/
+// static setter functions...
+
+#define DATA_SETTER_PROLOGUE Cleanup()
+
+#define DATA_SETTER_EPILOGUE(type_) mType = nsIDataType::type_;
+
+#define DATA_SETTER(type_, member_, value_) \
+ DATA_SETTER_PROLOGUE; \
+ u.member_ = value_; \
+ DATA_SETTER_EPILOGUE(type_)
+
+#define DATA_SETTER_WITH_CAST(type_, member_, cast_, value_) \
+ DATA_SETTER_PROLOGUE; \
+ u.member_ = cast_ value_; \
+ DATA_SETTER_EPILOGUE(type_)
+
+/********************************************/
+
+#define CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) {
+#define CASE__SET_FROM_VARIANT_VTYPE__GETTER(member_, name_) \
+ rv = aValue->GetAs##name_(&(u.member_));
+
+#define CASE__SET_FROM_VARIANT_VTYPE__GETTER_CAST(cast_, member_, name_) \
+ rv = aValue->GetAs##name_(cast_ & (u.member_));
+
+#define CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_) \
+ if (NS_SUCCEEDED(rv)) { \
+ mType = nsIDataType::type_; \
+ } \
+ break; \
+ }
+
+#define CASE__SET_FROM_VARIANT_TYPE(type_, member_, name_) \
+ case nsIDataType::type_: \
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) \
+ CASE__SET_FROM_VARIANT_VTYPE__GETTER(member_, name_) \
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_)
+
+#define CASE__SET_FROM_VARIANT_VTYPE_CAST(type_, cast_, member_, name_) \
+ case nsIDataType::type_: \
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(type_) \
+ CASE__SET_FROM_VARIANT_VTYPE__GETTER_CAST(cast_, member_, name_) \
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(type_)
+
+nsresult nsDiscriminatedUnion::SetFromVariant(nsIVariant* aValue) {
+ nsresult rv = NS_OK;
+
+ Cleanup();
+
+ uint16_t type = aValue->GetDataType();
+
+ switch (type) {
+ CASE__SET_FROM_VARIANT_VTYPE_CAST(VTYPE_INT8, (uint8_t*), mInt8Value, Int8)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_INT16, mInt16Value, Int16)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_INT32, mInt32Value, Int32)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT8, mUint8Value, Uint8)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT16, mUint16Value, Uint16)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_UINT32, mUint32Value, Uint32)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_FLOAT, mFloatValue, Float)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_DOUBLE, mDoubleValue, Double)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_BOOL, mBoolValue, Bool)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_CHAR, mCharValue, Char)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_WCHAR, mWCharValue, WChar)
+ CASE__SET_FROM_VARIANT_TYPE(VTYPE_ID, mIDValue, ID)
+
+ case nsIDataType::VTYPE_ASTRING:
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_ASTRING);
+ u.mAStringValue = new nsString();
+
+ rv = aValue->GetAsAString(*u.mAStringValue);
+ if (NS_FAILED(rv)) {
+ delete u.mAStringValue;
+ }
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ASTRING)
+
+ case nsIDataType::VTYPE_CSTRING:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_CSTRING);
+ u.mCStringValue = new nsCString();
+
+ rv = aValue->GetAsACString(*u.mCStringValue);
+ if (NS_FAILED(rv)) {
+ delete u.mCStringValue;
+ }
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_CSTRING)
+
+ case nsIDataType::VTYPE_UTF8STRING:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_UTF8STRING);
+ u.mUTF8StringValue = new nsUTF8String();
+
+ rv = aValue->GetAsAUTF8String(*u.mUTF8StringValue);
+ if (NS_FAILED(rv)) {
+ delete u.mUTF8StringValue;
+ }
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_UTF8STRING)
+
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_STRING_SIZE_IS);
+ rv = aValue->GetAsStringWithSize(&u.str.mStringLength,
+ &u.str.mStringValue);
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_STRING_SIZE_IS)
+
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_INTERFACE_IS);
+ // XXX This iid handling is ugly!
+ nsIID* iid;
+ rv = aValue->GetAsInterface(&iid, (void**)&u.iface.mInterfaceValue);
+ if (NS_SUCCEEDED(rv)) {
+ u.iface.mInterfaceID = *iid;
+ free((char*)iid);
+ }
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_INTERFACE_IS)
+
+ case nsIDataType::VTYPE_ARRAY:
+ CASE__SET_FROM_VARIANT_VTYPE_PROLOGUE(VTYPE_ARRAY);
+ rv = aValue->GetAsArray(&u.array.mArrayType, &u.array.mArrayInterfaceID,
+ &u.array.mArrayCount, &u.array.mArrayValue);
+ CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ARRAY)
+
+ case nsIDataType::VTYPE_VOID:
+ SetToVoid();
+ rv = NS_OK;
+ break;
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ SetToEmptyArray();
+ rv = NS_OK;
+ break;
+ case nsIDataType::VTYPE_EMPTY:
+ SetToEmpty();
+ rv = NS_OK;
+ break;
+ default:
+ NS_ERROR("bad type in variant!");
+ rv = NS_ERROR_FAILURE;
+ break;
+ }
+ return rv;
+}
+
+void nsDiscriminatedUnion::SetFromInt8(uint8_t aValue) {
+ DATA_SETTER_WITH_CAST(VTYPE_INT8, mInt8Value, (uint8_t), aValue);
+}
+void nsDiscriminatedUnion::SetFromInt16(int16_t aValue) {
+ DATA_SETTER(VTYPE_INT16, mInt16Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromInt32(int32_t aValue) {
+ DATA_SETTER(VTYPE_INT32, mInt32Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromInt64(int64_t aValue) {
+ DATA_SETTER(VTYPE_INT64, mInt64Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromUint8(uint8_t aValue) {
+ DATA_SETTER(VTYPE_UINT8, mUint8Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromUint16(uint16_t aValue) {
+ DATA_SETTER(VTYPE_UINT16, mUint16Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromUint32(uint32_t aValue) {
+ DATA_SETTER(VTYPE_UINT32, mUint32Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromUint64(uint64_t aValue) {
+ DATA_SETTER(VTYPE_UINT64, mUint64Value, aValue);
+}
+void nsDiscriminatedUnion::SetFromFloat(float aValue) {
+ DATA_SETTER(VTYPE_FLOAT, mFloatValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromDouble(double aValue) {
+ DATA_SETTER(VTYPE_DOUBLE, mDoubleValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromBool(bool aValue) {
+ DATA_SETTER(VTYPE_BOOL, mBoolValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromChar(char aValue) {
+ DATA_SETTER(VTYPE_CHAR, mCharValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromWChar(char16_t aValue) {
+ DATA_SETTER(VTYPE_WCHAR, mWCharValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromID(const nsID& aValue) {
+ DATA_SETTER(VTYPE_ID, mIDValue, aValue);
+}
+void nsDiscriminatedUnion::SetFromAString(const nsAString& aValue) {
+ DATA_SETTER_PROLOGUE;
+ u.mAStringValue = new nsString(aValue);
+ DATA_SETTER_EPILOGUE(VTYPE_ASTRING);
+}
+
+void nsDiscriminatedUnion::SetFromACString(const nsACString& aValue) {
+ DATA_SETTER_PROLOGUE;
+ u.mCStringValue = new nsCString(aValue);
+ DATA_SETTER_EPILOGUE(VTYPE_CSTRING);
+}
+
+void nsDiscriminatedUnion::SetFromAUTF8String(const nsAUTF8String& aValue) {
+ DATA_SETTER_PROLOGUE;
+ u.mUTF8StringValue = new nsUTF8String(aValue);
+ DATA_SETTER_EPILOGUE(VTYPE_UTF8STRING);
+}
+
+nsresult nsDiscriminatedUnion::SetFromString(const char* aValue) {
+ DATA_SETTER_PROLOGUE;
+ if (!aValue) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ return SetFromStringWithSize(strlen(aValue), aValue);
+}
+nsresult nsDiscriminatedUnion::SetFromWString(const char16_t* aValue) {
+ DATA_SETTER_PROLOGUE;
+ if (!aValue) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ return SetFromWStringWithSize(NS_strlen(aValue), aValue);
+}
+void nsDiscriminatedUnion::SetFromISupports(nsISupports* aValue) {
+ return SetFromInterface(NS_GET_IID(nsISupports), aValue);
+}
+void nsDiscriminatedUnion::SetFromInterface(const nsIID& aIID,
+ nsISupports* aValue) {
+ DATA_SETTER_PROLOGUE;
+ NS_IF_ADDREF(aValue);
+ u.iface.mInterfaceValue = aValue;
+ u.iface.mInterfaceID = aIID;
+ DATA_SETTER_EPILOGUE(VTYPE_INTERFACE_IS);
+}
+nsresult nsDiscriminatedUnion::SetFromArray(uint16_t aType, const nsIID* aIID,
+ uint32_t aCount, void* aValue) {
+ DATA_SETTER_PROLOGUE;
+ if (!aValue || !aCount) {
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ nsresult rv = CloneArray(aType, aIID, aCount, aValue, &u.array.mArrayType,
+ &u.array.mArrayInterfaceID, &u.array.mArrayCount,
+ &u.array.mArrayValue);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ DATA_SETTER_EPILOGUE(VTYPE_ARRAY);
+ return NS_OK;
+}
+nsresult nsDiscriminatedUnion::SetFromStringWithSize(uint32_t aSize,
+ const char* aValue) {
+ DATA_SETTER_PROLOGUE;
+ if (!aValue) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ u.str.mStringValue = (char*)moz_xmemdup(aValue, (aSize + 1) * sizeof(char));
+ u.str.mStringLength = aSize;
+ DATA_SETTER_EPILOGUE(VTYPE_STRING_SIZE_IS);
+ return NS_OK;
+}
+nsresult nsDiscriminatedUnion::SetFromWStringWithSize(uint32_t aSize,
+ const char16_t* aValue) {
+ DATA_SETTER_PROLOGUE;
+ if (!aValue) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ u.wstr.mWStringValue =
+ (char16_t*)moz_xmemdup(aValue, (aSize + 1) * sizeof(char16_t));
+ u.wstr.mWStringLength = aSize;
+ DATA_SETTER_EPILOGUE(VTYPE_WSTRING_SIZE_IS);
+ return NS_OK;
+}
+void nsDiscriminatedUnion::AllocateWStringWithSize(uint32_t aSize) {
+ DATA_SETTER_PROLOGUE;
+ u.wstr.mWStringValue = (char16_t*)moz_xmalloc((aSize + 1) * sizeof(char16_t));
+ u.wstr.mWStringValue[aSize] = '\0';
+ u.wstr.mWStringLength = aSize;
+ DATA_SETTER_EPILOGUE(VTYPE_WSTRING_SIZE_IS);
+}
+void nsDiscriminatedUnion::SetToVoid() {
+ DATA_SETTER_PROLOGUE;
+ DATA_SETTER_EPILOGUE(VTYPE_VOID);
+}
+void nsDiscriminatedUnion::SetToEmpty() {
+ DATA_SETTER_PROLOGUE;
+ DATA_SETTER_EPILOGUE(VTYPE_EMPTY);
+}
+void nsDiscriminatedUnion::SetToEmptyArray() {
+ DATA_SETTER_PROLOGUE;
+ DATA_SETTER_EPILOGUE(VTYPE_EMPTY_ARRAY);
+}
+
+/***************************************************************************/
+
+void nsDiscriminatedUnion::Cleanup() {
+ switch (mType) {
+ case nsIDataType::VTYPE_INT8:
+ case nsIDataType::VTYPE_INT16:
+ case nsIDataType::VTYPE_INT32:
+ case nsIDataType::VTYPE_INT64:
+ case nsIDataType::VTYPE_UINT8:
+ case nsIDataType::VTYPE_UINT16:
+ case nsIDataType::VTYPE_UINT32:
+ case nsIDataType::VTYPE_UINT64:
+ case nsIDataType::VTYPE_FLOAT:
+ case nsIDataType::VTYPE_DOUBLE:
+ case nsIDataType::VTYPE_BOOL:
+ case nsIDataType::VTYPE_CHAR:
+ case nsIDataType::VTYPE_WCHAR:
+ case nsIDataType::VTYPE_VOID:
+ case nsIDataType::VTYPE_ID:
+ break;
+ case nsIDataType::VTYPE_ASTRING:
+ delete u.mAStringValue;
+ break;
+ case nsIDataType::VTYPE_CSTRING:
+ delete u.mCStringValue;
+ break;
+ case nsIDataType::VTYPE_UTF8STRING:
+ delete u.mUTF8StringValue;
+ break;
+ case nsIDataType::VTYPE_CHAR_STR:
+ case nsIDataType::VTYPE_STRING_SIZE_IS:
+ free((char*)u.str.mStringValue);
+ break;
+ case nsIDataType::VTYPE_WCHAR_STR:
+ case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+ free((char*)u.wstr.mWStringValue);
+ break;
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ NS_IF_RELEASE(u.iface.mInterfaceValue);
+ break;
+ case nsIDataType::VTYPE_ARRAY:
+ FreeArray();
+ break;
+ case nsIDataType::VTYPE_EMPTY_ARRAY:
+ case nsIDataType::VTYPE_EMPTY:
+ break;
+ default:
+ NS_ERROR("bad type in variant!");
+ break;
+ }
+
+ mType = nsIDataType::VTYPE_EMPTY;
+}
+
+void nsDiscriminatedUnion::Traverse(
+ nsCycleCollectionTraversalCallback& aCb) const {
+ switch (mType) {
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS:
+ NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mData");
+ aCb.NoteXPCOMChild(u.iface.mInterfaceValue);
+ break;
+ case nsIDataType::VTYPE_ARRAY:
+ switch (u.array.mArrayType) {
+ case nsIDataType::VTYPE_INTERFACE:
+ case nsIDataType::VTYPE_INTERFACE_IS: {
+ nsISupports** p = (nsISupports**)u.array.mArrayValue;
+ for (uint32_t i = u.array.mArrayCount; i > 0; ++p, --i) {
+ NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mData[i]");
+ aCb.NoteXPCOMChild(*p);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+/***************************************************************************/
+/***************************************************************************/
+// members...
+
+nsVariantBase::nsVariantBase() : mWritable(true) {}
+
+// For all the data getters we just forward to the static (and sharable)
+// 'ConvertTo' functions.
+
+uint16_t nsVariantBase::GetDataType() { return mData.GetType(); }
+
+NS_IMETHODIMP
+nsVariantBase::GetAsInt8(uint8_t* aResult) {
+ return mData.ConvertToInt8(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsInt16(int16_t* aResult) {
+ return mData.ConvertToInt16(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsInt32(int32_t* aResult) {
+ return mData.ConvertToInt32(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsInt64(int64_t* aResult) {
+ return mData.ConvertToInt64(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsUint8(uint8_t* aResult) {
+ return mData.ConvertToUint8(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsUint16(uint16_t* aResult) {
+ return mData.ConvertToUint16(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsUint32(uint32_t* aResult) {
+ return mData.ConvertToUint32(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsUint64(uint64_t* aResult) {
+ return mData.ConvertToUint64(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsFloat(float* aResult) {
+ return mData.ConvertToFloat(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsDouble(double* aResult) {
+ return mData.ConvertToDouble(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsBool(bool* aResult) { return mData.ConvertToBool(aResult); }
+
+NS_IMETHODIMP
+nsVariantBase::GetAsChar(char* aResult) { return mData.ConvertToChar(aResult); }
+
+NS_IMETHODIMP
+nsVariantBase::GetAsWChar(char16_t* aResult) {
+ return mData.ConvertToWChar(aResult);
+}
+
+NS_IMETHODIMP_(nsresult)
+nsVariantBase::GetAsID(nsID* aResult) { return mData.ConvertToID(aResult); }
+
+NS_IMETHODIMP
+nsVariantBase::GetAsAString(nsAString& aResult) {
+ return mData.ConvertToAString(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsACString(nsACString& aResult) {
+ return mData.ConvertToACString(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsAUTF8String(nsAUTF8String& aResult) {
+ return mData.ConvertToAUTF8String(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsString(char** aResult) {
+ return mData.ConvertToString(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsWString(char16_t** aResult) {
+ return mData.ConvertToWString(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsISupports(nsISupports** aResult) {
+ return mData.ConvertToISupports(aResult);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsJSVal(JS::MutableHandleValue) {
+ // Can only get the jsval from an XPCVariant.
+ return NS_ERROR_CANNOT_CONVERT_DATA;
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsInterface(nsIID** aIID, void** aInterface) {
+ return mData.ConvertToInterface(aIID, aInterface);
+}
+
+NS_IMETHODIMP_(nsresult)
+nsVariantBase::GetAsArray(uint16_t* aType, nsIID* aIID, uint32_t* aCount,
+ void** aPtr) {
+ return mData.ConvertToArray(aType, aIID, aCount, aPtr);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsStringWithSize(uint32_t* aSize, char** aStr) {
+ return mData.ConvertToStringWithSize(aSize, aStr);
+}
+
+NS_IMETHODIMP
+nsVariantBase::GetAsWStringWithSize(uint32_t* aSize, char16_t** aStr) {
+ return mData.ConvertToWStringWithSize(aSize, aStr);
+}
+
+/***************************************************************************/
+
+NS_IMETHODIMP
+nsVariantBase::GetWritable(bool* aWritable) {
+ *aWritable = mWritable;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsVariantBase::SetWritable(bool aWritable) {
+ if (!mWritable && aWritable) {
+ return NS_ERROR_FAILURE;
+ }
+ mWritable = aWritable;
+ return NS_OK;
+}
+
+/***************************************************************************/
+
+// For all the data setters we just forward to the static (and sharable)
+// 'SetFrom' functions.
+
+NS_IMETHODIMP
+nsVariantBase::SetAsInt8(uint8_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromInt8(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsInt16(int16_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromInt16(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsInt32(int32_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromInt32(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsInt64(int64_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromInt64(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsUint8(uint8_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromUint8(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsUint16(uint16_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromUint16(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsUint32(uint32_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromUint32(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsUint64(uint64_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromUint64(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsFloat(float aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromFloat(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsDouble(double aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromDouble(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsBool(bool aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromBool(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsChar(char aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromChar(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsWChar(char16_t aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromWChar(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsID(const nsID& aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromID(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsAString(const nsAString& aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromAString(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsACString(const nsACString& aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromACString(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsAUTF8String(const nsAUTF8String& aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromAUTF8String(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsString(const char* aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromString(aValue);
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsWString(const char16_t* aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromWString(aValue);
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsISupports(nsISupports* aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromISupports(aValue);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsInterface(const nsIID& aIID, void* aInterface) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetFromInterface(aIID, (nsISupports*)aInterface);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsArray(uint16_t aType, const nsIID* aIID, uint32_t aCount,
+ void* aPtr) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromArray(aType, aIID, aCount, aPtr);
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsStringWithSize(uint32_t aSize, const char* aStr) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromStringWithSize(aSize, aStr);
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsWStringWithSize(uint32_t aSize, const char16_t* aStr) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromWStringWithSize(aSize, aStr);
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsVoid() {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetToVoid();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsEmpty() {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetToEmpty();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetAsEmptyArray() {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ mData.SetToEmptyArray();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsVariantBase::SetFromVariant(nsIVariant* aValue) {
+ if (!mWritable) {
+ return NS_ERROR_OBJECT_IS_IMMUTABLE;
+ }
+ return mData.SetFromVariant(aValue);
+}
+
+/* nsVariant implementation */
+
+NS_IMPL_ISUPPORTS(nsVariant, nsIVariant, nsIWritableVariant)
+
+/* nsVariantCC implementation */
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsVariantCC)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(nsIVariant)
+ NS_INTERFACE_MAP_ENTRY(nsIWritableVariant)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsVariantCC)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsVariantCC)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsVariantCC)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsVariantCC)
+ tmp->mData.Traverse(cb);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsVariantCC)
+ tmp->mData.Cleanup();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
diff --git a/xpcom/ds/nsVariant.h b/xpcom/ds/nsVariant.h
new file mode 100644
index 0000000000..8de1fe4618
--- /dev/null
+++ b/xpcom/ds/nsVariant.h
@@ -0,0 +1,223 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsVariant_h
+#define nsVariant_h
+
+#include "nsIVariant.h"
+#include "nsStringFwd.h"
+#include "mozilla/Attributes.h"
+#include "nsCycleCollectionParticipant.h"
+
+/**
+ * Map the nsAUTF8String, nsUTF8String classes to the nsACString and
+ * nsCString classes respectively for now. These defines need to be removed
+ * once Jag lands his nsUTF8String implementation.
+ */
+#define nsAUTF8String nsACString
+#define nsUTF8String nsCString
+#define PromiseFlatUTF8String PromiseFlatCString
+
+/**
+ * nsDiscriminatedUnion is a class that nsIVariant implementors can use
+ * to hold the underlying data.
+ */
+
+class nsDiscriminatedUnion {
+ public:
+ nsDiscriminatedUnion() : mType(nsIDataType::VTYPE_EMPTY) {
+ u.mInt8Value = '\0';
+ }
+ nsDiscriminatedUnion(const nsDiscriminatedUnion&) = delete;
+ nsDiscriminatedUnion(nsDiscriminatedUnion&&) = delete;
+
+ ~nsDiscriminatedUnion() { Cleanup(); }
+
+ nsDiscriminatedUnion& operator=(const nsDiscriminatedUnion&) = delete;
+ nsDiscriminatedUnion& operator=(nsDiscriminatedUnion&&) = delete;
+
+ void Cleanup();
+
+ uint16_t GetType() const { return mType; }
+
+ [[nodiscard]] nsresult ConvertToInt8(uint8_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToInt16(int16_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToInt32(int32_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToInt64(int64_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToUint8(uint8_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToUint16(uint16_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToUint32(uint32_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToUint64(uint64_t* aResult) const;
+ [[nodiscard]] nsresult ConvertToFloat(float* aResult) const;
+ [[nodiscard]] nsresult ConvertToDouble(double* aResult) const;
+ [[nodiscard]] nsresult ConvertToBool(bool* aResult) const;
+ [[nodiscard]] nsresult ConvertToChar(char* aResult) const;
+ [[nodiscard]] nsresult ConvertToWChar(char16_t* aResult) const;
+
+ [[nodiscard]] nsresult ConvertToID(nsID* aResult) const;
+
+ [[nodiscard]] nsresult ConvertToAString(nsAString& aResult) const;
+ [[nodiscard]] nsresult ConvertToAUTF8String(nsAUTF8String& aResult) const;
+ [[nodiscard]] nsresult ConvertToACString(nsACString& aResult) const;
+ [[nodiscard]] nsresult ConvertToString(char** aResult) const;
+ [[nodiscard]] nsresult ConvertToWString(char16_t** aResult) const;
+ [[nodiscard]] nsresult ConvertToStringWithSize(uint32_t* aSize,
+ char** aStr) const;
+ [[nodiscard]] nsresult ConvertToWStringWithSize(uint32_t* aSize,
+ char16_t** aStr) const;
+
+ [[nodiscard]] nsresult ConvertToISupports(nsISupports** aResult) const;
+ [[nodiscard]] nsresult ConvertToInterface(nsIID** aIID,
+ void** aInterface) const;
+ [[nodiscard]] nsresult ConvertToArray(uint16_t* aType, nsIID* aIID,
+ uint32_t* aCount, void** aPtr) const;
+
+ [[nodiscard]] nsresult SetFromVariant(nsIVariant* aValue);
+
+ void SetFromInt8(uint8_t aValue);
+ void SetFromInt16(int16_t aValue);
+ void SetFromInt32(int32_t aValue);
+ void SetFromInt64(int64_t aValue);
+ void SetFromUint8(uint8_t aValue);
+ void SetFromUint16(uint16_t aValue);
+ void SetFromUint32(uint32_t aValue);
+ void SetFromUint64(uint64_t aValue);
+ void SetFromFloat(float aValue);
+ void SetFromDouble(double aValue);
+ void SetFromBool(bool aValue);
+ void SetFromChar(char aValue);
+ void SetFromWChar(char16_t aValue);
+ void SetFromID(const nsID& aValue);
+ void SetFromAString(const nsAString& aValue);
+ void SetFromAUTF8String(const nsAUTF8String& aValue);
+ void SetFromACString(const nsACString& aValue);
+ [[nodiscard]] nsresult SetFromString(const char* aValue);
+ [[nodiscard]] nsresult SetFromWString(const char16_t* aValue);
+ void SetFromISupports(nsISupports* aValue);
+ void SetFromInterface(const nsIID& aIID, nsISupports* aValue);
+ [[nodiscard]] nsresult SetFromArray(uint16_t aType, const nsIID* aIID,
+ uint32_t aCount, void* aValue);
+ [[nodiscard]] nsresult SetFromStringWithSize(uint32_t aSize,
+ const char* aValue);
+ [[nodiscard]] nsresult SetFromWStringWithSize(uint32_t aSize,
+ const char16_t* aValue);
+
+ // Like SetFromWStringWithSize, but leaves the string uninitialized. It does
+ // does write the null-terminator.
+ void AllocateWStringWithSize(uint32_t aSize);
+
+ void SetToVoid();
+ void SetToEmpty();
+ void SetToEmptyArray();
+
+ void Traverse(nsCycleCollectionTraversalCallback& aCb) const;
+
+ private:
+ [[nodiscard]] nsresult ToManageableNumber(
+ nsDiscriminatedUnion* aOutData) const;
+ void FreeArray();
+ [[nodiscard]] bool String2ID(nsID* aPid) const;
+ [[nodiscard]] nsresult ToString(nsACString& aOutString) const;
+
+ public:
+ union {
+ int8_t mInt8Value;
+ int16_t mInt16Value;
+ int32_t mInt32Value;
+ int64_t mInt64Value;
+ uint8_t mUint8Value;
+ uint16_t mUint16Value;
+ uint32_t mUint32Value;
+ uint64_t mUint64Value;
+ float mFloatValue;
+ double mDoubleValue;
+ bool mBoolValue;
+ char mCharValue;
+ char16_t mWCharValue;
+ nsIID mIDValue;
+ nsAString* mAStringValue;
+ nsAUTF8String* mUTF8StringValue;
+ nsACString* mCStringValue;
+ struct {
+ // This is an owning reference that cannot be an nsCOMPtr because
+ // nsDiscriminatedUnion needs to be POD. AddRef/Release are manually
+ // called on this.
+ nsISupports* MOZ_OWNING_REF mInterfaceValue;
+ nsIID mInterfaceID;
+ } iface;
+ struct {
+ nsIID mArrayInterfaceID;
+ void* mArrayValue;
+ uint32_t mArrayCount;
+ uint16_t mArrayType;
+ } array;
+ struct {
+ char* mStringValue;
+ uint32_t mStringLength;
+ } str;
+ struct {
+ char16_t* mWStringValue;
+ uint32_t mWStringLength;
+ } wstr;
+ } u;
+ uint16_t mType;
+};
+
+/**
+ * nsVariant implements the generic variant support. The xpcom module registers
+ * a factory (see NS_VARIANT_CONTRACTID in nsIVariant.idl) that will create
+ * these objects. They are created 'empty' and 'writable'.
+ *
+ * nsIVariant users won't usually need to see this class.
+ */
+class nsVariantBase : public nsIWritableVariant {
+ public:
+ NS_DECL_NSIVARIANT
+ NS_DECL_NSIWRITABLEVARIANT
+
+ nsVariantBase();
+
+ protected:
+ ~nsVariantBase() = default;
+
+ nsDiscriminatedUnion mData;
+ bool mWritable;
+};
+
+class nsVariant final : public nsVariantBase {
+ public:
+ NS_DECL_ISUPPORTS
+
+ nsVariant() = default;
+
+ private:
+ ~nsVariant() = default;
+};
+
+class nsVariantCC final : public nsVariantBase {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS(nsVariantCC)
+
+ nsVariantCC() = default;
+
+ private:
+ ~nsVariantCC() = default;
+};
+
+/**
+ * Users of nsIVariant should be using the contractID and not this CID.
+ * - see NS_VARIANT_CONTRACTID in nsIVariant.idl.
+ */
+
+#define NS_VARIANT_CID \
+ { /* 0D6EA1D0-879C-11d5-90EF-0010A4E73D9A */ \
+ 0xd6ea1d0, 0x879c, 0x11d5, { \
+ 0x90, 0xef, 0x0, 0x10, 0xa4, 0xe7, 0x3d, 0x9a \
+ } \
+ }
+
+#endif // nsVariant_h
diff --git a/xpcom/ds/nsWhitespaceTokenizer.h b/xpcom/ds/nsWhitespaceTokenizer.h
new file mode 100644
index 0000000000..77fea70850
--- /dev/null
+++ b/xpcom/ds/nsWhitespaceTokenizer.h
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsWhitespaceTokenizer_h
+#define __nsWhitespaceTokenizer_h
+
+#include "mozilla/RangedPtr.h"
+#include "nsDependentSubstring.h"
+#include "nsCRTGlue.h"
+
+template <typename DependentSubstringType, bool IsWhitespace(char16_t)>
+class nsTWhitespaceTokenizer {
+ typedef typename DependentSubstringType::char_type CharType;
+ typedef typename DependentSubstringType::substring_type SubstringType;
+
+ public:
+ explicit nsTWhitespaceTokenizer(const SubstringType& aSource)
+ : mIter(aSource.Data(), aSource.Length()),
+ mEnd(aSource.Data() + aSource.Length(), aSource.Data(),
+ aSource.Length()),
+ mWhitespaceBeforeFirstToken(false),
+ mWhitespaceAfterCurrentToken(false) {
+ while (mIter < mEnd && IsWhitespace(*mIter)) {
+ mWhitespaceBeforeFirstToken = true;
+ ++mIter;
+ }
+ }
+
+ /**
+ * Checks if any more tokens are available.
+ */
+ bool hasMoreTokens() const { return mIter < mEnd; }
+
+ /*
+ * Returns true if there is whitespace prior to the first token.
+ */
+ bool whitespaceBeforeFirstToken() const {
+ return mWhitespaceBeforeFirstToken;
+ }
+
+ /*
+ * Returns true if there is any whitespace after the current token.
+ * This is always true unless we're reading the last token.
+ */
+ bool whitespaceAfterCurrentToken() const {
+ return mWhitespaceAfterCurrentToken;
+ }
+
+ /**
+ * Returns the next token.
+ */
+ const DependentSubstringType nextToken() {
+ const mozilla::RangedPtr<const CharType> tokenStart = mIter;
+ while (mIter < mEnd && !IsWhitespace(*mIter)) {
+ ++mIter;
+ }
+ const mozilla::RangedPtr<const CharType> tokenEnd = mIter;
+ mWhitespaceAfterCurrentToken = false;
+ while (mIter < mEnd && IsWhitespace(*mIter)) {
+ mWhitespaceAfterCurrentToken = true;
+ ++mIter;
+ }
+ return Substring(tokenStart.get(), tokenEnd.get());
+ }
+
+ private:
+ mozilla::RangedPtr<const CharType> mIter;
+ const mozilla::RangedPtr<const CharType> mEnd;
+ bool mWhitespaceBeforeFirstToken;
+ bool mWhitespaceAfterCurrentToken;
+};
+
+template <bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
+class nsWhitespaceTokenizerTemplate
+ : public nsTWhitespaceTokenizer<nsDependentSubstring, IsWhitespace> {
+ public:
+ explicit nsWhitespaceTokenizerTemplate(const nsAString& aSource)
+ : nsTWhitespaceTokenizer<nsDependentSubstring, IsWhitespace>(aSource) {}
+};
+
+typedef nsWhitespaceTokenizerTemplate<> nsWhitespaceTokenizer;
+
+template <bool IsWhitespace(char16_t) = NS_IsAsciiWhitespace>
+class nsCWhitespaceTokenizerTemplate
+ : public nsTWhitespaceTokenizer<nsDependentCSubstring, IsWhitespace> {
+ public:
+ explicit nsCWhitespaceTokenizerTemplate(const nsACString& aSource)
+ : nsTWhitespaceTokenizer<nsDependentCSubstring, IsWhitespace>(aSource) {}
+};
+
+typedef nsCWhitespaceTokenizerTemplate<> nsCWhitespaceTokenizer;
+
+#endif /* __nsWhitespaceTokenizer_h */
diff --git a/xpcom/ds/nsWindowsRegKey.cpp b/xpcom/ds/nsWindowsRegKey.cpp
new file mode 100644
index 0000000000..1f9bb58ac6
--- /dev/null
+++ b/xpcom/ds/nsWindowsRegKey.cpp
@@ -0,0 +1,523 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <windows.h>
+#include <shlwapi.h>
+#include <stdlib.h>
+#include "nsWindowsRegKey.h"
+#include "nsString.h"
+#include "nsCOMPtr.h"
+#include "mozilla/Attributes.h"
+
+//-----------------------------------------------------------------------------
+
+// According to MSDN, the following limits apply (in characters excluding room
+// for terminating null character):
+#define MAX_KEY_NAME_LEN 255
+#define MAX_VALUE_NAME_LEN 16383
+
+class nsWindowsRegKey final : public nsIWindowsRegKey {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIWINDOWSREGKEY
+
+ nsWindowsRegKey()
+ : mKey(nullptr), mWatchEvent(nullptr), mWatchRecursive(FALSE) {}
+
+ private:
+ ~nsWindowsRegKey() { Close(); }
+
+ HKEY mKey;
+ HANDLE mWatchEvent;
+ BOOL mWatchRecursive;
+};
+
+NS_IMPL_ISUPPORTS(nsWindowsRegKey, nsIWindowsRegKey)
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetKey(HKEY* aKey) {
+ *aKey = mKey;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::SetKey(HKEY aKey) {
+ // We do not close the older aKey!
+ StopWatching();
+
+ mKey = aKey;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::Close() {
+ StopWatching();
+
+ if (mKey) {
+ RegCloseKey(mKey);
+ mKey = nullptr;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::Open(uint32_t aRootKey, const nsAString& aPath,
+ uint32_t aMode) {
+ Close();
+
+ LONG rv =
+ RegOpenKeyExW((HKEY)(intptr_t)aRootKey, PromiseFlatString(aPath).get(), 0,
+ (REGSAM)aMode, &mKey);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::Create(uint32_t aRootKey, const nsAString& aPath,
+ uint32_t aMode) {
+ Close();
+
+ DWORD disposition;
+ LONG rv = RegCreateKeyExW(
+ (HKEY)(intptr_t)aRootKey, PromiseFlatString(aPath).get(), 0, nullptr,
+ REG_OPTION_NON_VOLATILE, (REGSAM)aMode, nullptr, &mKey, &disposition);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::OpenChild(const nsAString& aPath, uint32_t aMode,
+ nsIWindowsRegKey** aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
+
+ nsresult rv = child->Open((uintptr_t)mKey, aPath, aMode);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ child.swap(*aResult);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::CreateChild(const nsAString& aPath, uint32_t aMode,
+ nsIWindowsRegKey** aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
+
+ nsresult rv = child->Create((uintptr_t)mKey, aPath, aMode);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ child.swap(*aResult);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetChildCount(uint32_t* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD numSubKeys;
+ LONG rv =
+ RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, &numSubKeys, nullptr,
+ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aResult = numSubKeys;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetChildName(uint32_t aIndex, nsAString& aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ FILETIME lastWritten;
+
+ wchar_t nameBuf[MAX_KEY_NAME_LEN + 1];
+ DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
+
+ LONG rv = RegEnumKeyExW(mKey, aIndex, nameBuf, &nameLen, nullptr, nullptr,
+ nullptr, &lastWritten);
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_NOT_AVAILABLE; // XXX what's the best error code here?
+ }
+
+ aResult.Assign(nameBuf, nameLen);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::HasChild(const nsAString& aName, bool* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // Check for the existence of a child key by opening the key with minimal
+ // rights. Perhaps there is a more efficient way to do this?
+
+ HKEY key;
+ LONG rv = RegOpenKeyExW(mKey, PromiseFlatString(aName).get(), 0,
+ STANDARD_RIGHTS_READ, &key);
+
+ if ((*aResult = (rv == ERROR_SUCCESS && key))) {
+ RegCloseKey(key);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetValueCount(uint32_t* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD numValues;
+ LONG rv =
+ RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, nullptr, nullptr,
+ nullptr, &numValues, nullptr, nullptr, nullptr, nullptr);
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aResult = numValues;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetValueName(uint32_t aIndex, nsAString& aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ wchar_t nameBuf[MAX_VALUE_NAME_LEN];
+ DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
+
+ LONG rv = RegEnumValueW(mKey, aIndex, nameBuf, &nameLen, nullptr, nullptr,
+ nullptr, nullptr);
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_NOT_AVAILABLE; // XXX what's the best error code here?
+ }
+
+ aResult.Assign(nameBuf, nameLen);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::HasValue(const nsAString& aName, bool* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0, nullptr,
+ nullptr, nullptr);
+
+ *aResult = (rv == ERROR_SUCCESS);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::RemoveChild(const nsAString& aName) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegDeleteKeyW(mKey, PromiseFlatString(aName).get());
+
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::RemoveValue(const nsAString& aName) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegDeleteValueW(mKey, PromiseFlatString(aName).get());
+
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::GetValueType(const nsAString& aName, uint32_t* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0,
+ (LPDWORD)aResult, nullptr, nullptr);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::ReadStringValue(const nsAString& aName, nsAString& aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD type, size;
+
+ const nsString& flatName = PromiseFlatString(aName);
+
+ LONG rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, nullptr, &size);
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // This must be a string type in order to fetch the value as a string.
+ // We're being a bit forgiving here by allowing types other than REG_SZ.
+ if (type != REG_SZ && type != REG_EXPAND_SZ && type != REG_MULTI_SZ) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // The buffer size must be a multiple of 2.
+ if (size % 2 != 0) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (size == 0) {
+ aResult.Truncate();
+ return NS_OK;
+ }
+
+ // |size| may or may not include the terminating null character.
+ DWORD resultLen = size / 2;
+
+ if (!aResult.SetLength(resultLen, mozilla::fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ auto begin = aResult.BeginWriting();
+
+ rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, (LPBYTE)begin, &size);
+
+ if (!aResult.CharAt(resultLen - 1)) {
+ // The string passed to us had a null terminator in the final position.
+ aResult.Truncate(resultLen - 1);
+ }
+
+ // Expand the environment variables if needed
+ if (type == REG_EXPAND_SZ) {
+ const nsString& flatSource = PromiseFlatString(aResult);
+ resultLen = ExpandEnvironmentStringsW(flatSource.get(), nullptr, 0);
+ if (resultLen > 1) {
+ nsAutoString expandedResult;
+ // |resultLen| includes the terminating null character
+ --resultLen;
+ if (!expandedResult.SetLength(resultLen, mozilla::fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ resultLen = ExpandEnvironmentStringsW(
+ flatSource.get(), expandedResult.get(), resultLen + 1);
+ if (resultLen <= 0) {
+ rv = ERROR_UNKNOWN_FEATURE;
+ aResult.Truncate();
+ } else {
+ rv = ERROR_SUCCESS;
+ aResult = expandedResult;
+ }
+ } else if (resultLen == 1) {
+ // It apparently expands to nothing (just a null terminator).
+ aResult.Truncate();
+ }
+ }
+
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::ReadIntValue(const nsAString& aName, uint32_t* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD size = sizeof(*aResult);
+ LONG rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0, nullptr,
+ (LPBYTE)aResult, &size);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::ReadInt64Value(const nsAString& aName, uint64_t* aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD size = sizeof(*aResult);
+ LONG rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0, nullptr,
+ (LPBYTE)aResult, &size);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::ReadBinaryValue(const nsAString& aName, nsACString& aResult) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ DWORD size;
+ LONG rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0, nullptr,
+ nullptr, &size);
+
+ if (rv != ERROR_SUCCESS) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!size) {
+ aResult.Truncate();
+ return NS_OK;
+ }
+
+ if (!aResult.SetLength(size, mozilla::fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ auto begin = aResult.BeginWriting();
+
+ rv = RegQueryValueExW(mKey, PromiseFlatString(aName).get(), 0, nullptr,
+ (LPBYTE)begin, &size);
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::WriteStringValue(const nsAString& aName,
+ const nsAString& aValue) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // Need to indicate complete size of buffer including null terminator.
+ const nsString& flatValue = PromiseFlatString(aValue);
+
+ LONG rv = RegSetValueExW(mKey, PromiseFlatString(aName).get(), 0, REG_SZ,
+ (const BYTE*)flatValue.get(),
+ (flatValue.Length() + 1) * sizeof(char16_t));
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::WriteIntValue(const nsAString& aName, uint32_t aValue) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegSetValueExW(mKey, PromiseFlatString(aName).get(), 0, REG_DWORD,
+ (const BYTE*)&aValue, sizeof(aValue));
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::WriteInt64Value(const nsAString& aName, uint64_t aValue) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ LONG rv = RegSetValueExW(mKey, PromiseFlatString(aName).get(), 0, REG_QWORD,
+ (const BYTE*)&aValue, sizeof(aValue));
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::WriteBinaryValue(const nsAString& aName,
+ const nsACString& aValue) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ const nsCString& flatValue = PromiseFlatCString(aValue);
+ LONG rv = RegSetValueExW(mKey, PromiseFlatString(aName).get(), 0, REG_BINARY,
+ (const BYTE*)flatValue.get(), flatValue.Length());
+ return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::StartWatching(bool aRecurse) {
+ if (NS_WARN_IF(!mKey)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ if (mWatchEvent) {
+ return NS_OK;
+ }
+
+ mWatchEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
+ if (!mWatchEvent) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ DWORD filter = REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_ATTRIBUTES |
+ REG_NOTIFY_CHANGE_LAST_SET | REG_NOTIFY_CHANGE_SECURITY;
+
+ LONG rv = RegNotifyChangeKeyValue(mKey, aRecurse, filter, mWatchEvent, TRUE);
+ if (rv != ERROR_SUCCESS) {
+ StopWatching();
+ // On older versions of Windows, this call is not implemented, so simply
+ // return NS_OK in those cases and pretend that the watching is happening.
+ return (rv == ERROR_CALL_NOT_IMPLEMENTED) ? NS_OK : NS_ERROR_FAILURE;
+ }
+
+ mWatchRecursive = aRecurse;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::StopWatching() {
+ if (mWatchEvent) {
+ CloseHandle(mWatchEvent);
+ mWatchEvent = nullptr;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::HasChanged(bool* aResult) {
+ if (mWatchEvent && WaitForSingleObject(mWatchEvent, 0) == WAIT_OBJECT_0) {
+ // An event only gets signaled once, then it's done, so we have to set up
+ // another event to watch.
+ StopWatching();
+ StartWatching(mWatchRecursive);
+ *aResult = true;
+ } else {
+ *aResult = false;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindowsRegKey::IsWatching(bool* aResult) {
+ *aResult = (mWatchEvent != nullptr);
+ return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+
+void NS_NewWindowsRegKey(nsIWindowsRegKey** aResult) {
+ RefPtr<nsWindowsRegKey> key = new nsWindowsRegKey();
+ key.forget(aResult);
+}
+
+//-----------------------------------------------------------------------------
+
+nsresult nsWindowsRegKeyConstructor(const nsIID& aIID, void** aResult) {
+ nsCOMPtr<nsIWindowsRegKey> key;
+ NS_NewWindowsRegKey(getter_AddRefs(key));
+ return key->QueryInterface(aIID, aResult);
+}
diff --git a/xpcom/ds/nsWindowsRegKey.h b/xpcom/ds/nsWindowsRegKey.h
new file mode 100644
index 0000000000..c8032540ab
--- /dev/null
+++ b/xpcom/ds/nsWindowsRegKey.h
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsWindowsRegKey_h__
+#define nsWindowsRegKey_h__
+
+//-----------------------------------------------------------------------------
+
+#include "nsIWindowsRegKey.h"
+
+/**
+ * This ContractID may be used to instantiate a windows registry key object
+ * via the XPCOM component manager.
+ */
+#define NS_WINDOWSREGKEY_CONTRACTID "@mozilla.org/windows-registry-key;1"
+
+/**
+ * This function may be used to instantiate a windows registry key object prior
+ * to XPCOM being initialized.
+ */
+extern "C" void NS_NewWindowsRegKey(nsIWindowsRegKey** aResult);
+
+//-----------------------------------------------------------------------------
+
+#ifdef IMPL_LIBXUL
+
+// a53bc624-d577-4839-b8ec-bb5040a52ff4
+# define NS_WINDOWSREGKEY_CID \
+ { \
+ 0xa53bc624, 0xd577, 0x4839, { \
+ 0xb8, 0xec, 0xbb, 0x50, 0x40, 0xa5, 0x2f, 0xf4 \
+ } \
+ }
+
+[[nodiscard]] extern nsresult nsWindowsRegKeyConstructor(const nsIID& aIID,
+ void** aResult);
+
+#endif // IMPL_LIBXUL
+
+//-----------------------------------------------------------------------------
+
+#endif // nsWindowsRegKey_h__
diff --git a/xpcom/ds/test/python.ini b/xpcom/ds/test/python.ini
new file mode 100644
index 0000000000..680185c496
--- /dev/null
+++ b/xpcom/ds/test/python.ini
@@ -0,0 +1,4 @@
+[DEFAULT]
+subsuite = xpcom
+
+[test_dafsa.py]
diff --git a/xpcom/ds/test/test_dafsa.py b/xpcom/ds/test/test_dafsa.py
new file mode 100644
index 0000000000..9becdd6c06
--- /dev/null
+++ b/xpcom/ds/test/test_dafsa.py
@@ -0,0 +1,546 @@
+# 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/.
+
+import unittest
+from io import StringIO
+
+import mozunit
+from incremental_dafsa import Dafsa, Node
+
+
+def _node_to_string(node: Node, prefix, buffer, cache):
+ if not node.is_end_node:
+ prefix += (
+ str(ord(node.character)) if ord(node.character) < 10 else node.character
+ )
+ else:
+ prefix += "$"
+ cached = cache.get(id(node))
+ buffer.write("{}{}".format(prefix, "=" if cached else "").strip() + "\n")
+
+ if not cached:
+ cache[id(node)] = node
+ if node:
+ for node in sorted(node.children.values(), key=lambda n: n.character):
+ _node_to_string(node, prefix, buffer, cache)
+
+
+def _dafsa_to_string(dafsa: Dafsa):
+ """Encodes the dafsa into a string notation.
+
+ Each node is printed on its own line with all the nodes that precede it.
+ The end node is designated with the "$" character.
+ If it joins into an existing node, the end of the line is adorned with a "=".
+ Though this doesn't carry information about which other prefix it has joined with,
+ it has seemed to be precise enough for testing.
+
+ For example, with the input data of:
+ * a1
+ * ac1
+ * bc1
+
+ [root] --- a ---- 1 --- [end]
+ | | /
+ -- b -- c---
+
+ The output will be:
+ a
+ a1
+ a1$ <- end node was found
+ ac
+ ac1= <- joins with the "a1" prefix
+ b
+ bc= <- joins with the "ac" prefix
+ """
+ buffer = StringIO()
+ cache = {}
+
+ for node in sorted(dafsa.root_node.children.values(), key=lambda n: n.character):
+ _node_to_string(node, "", buffer, cache)
+ return buffer.getvalue().strip()
+
+
+def _to_words(data):
+ return [line.strip() for line in data.strip().split("\n")]
+
+
+def _assert_dafsa(data, expected):
+ words = _to_words(data)
+ dafsa = Dafsa.from_tld_data(words)
+
+ expected = expected.strip()
+ expected = "\n".join([line.strip() for line in expected.split("\n")])
+ as_string = _dafsa_to_string(dafsa)
+ assert as_string == expected
+
+
+class TestDafsa(unittest.TestCase):
+ def test_1(self):
+ _assert_dafsa(
+ """
+ a1
+ ac1
+ acc1
+ bd1
+ bc1
+ bcc1
+ """,
+ """
+ a
+ a1
+ a1$
+ ac
+ ac1=
+ acc
+ acc1=
+ b
+ bc=
+ bd
+ bd1=
+ """,
+ )
+
+ def test_2(self):
+ _assert_dafsa(
+ """
+ ab1
+ b1
+ bb1
+ bbb1
+ """,
+ """
+ a
+ ab
+ ab1
+ ab1$
+ b
+ b1=
+ bb
+ bb1=
+ bbb=
+ """,
+ )
+
+ def test_3(self):
+ _assert_dafsa(
+ """
+ a.ca1
+ a.com1
+ c.corg1
+ b.ca1
+ b.com1
+ b.corg1
+ """,
+ """
+ a
+ a.
+ a.c
+ a.ca
+ a.ca1
+ a.ca1$
+ a.co
+ a.com
+ a.com1=
+ b
+ b.
+ b.c
+ b.ca=
+ b.co
+ b.com=
+ b.cor
+ b.corg
+ b.corg1=
+ c
+ c.
+ c.c
+ c.co
+ c.cor=
+ """,
+ )
+
+ def test_4(self):
+ _assert_dafsa(
+ """
+ acom1
+ bcomcom1
+ acomcom1
+ """,
+ """
+ a
+ ac
+ aco
+ acom
+ acom1
+ acom1$
+ acomc
+ acomco
+ acomcom
+ acomcom1=
+ b
+ bc
+ bco
+ bcom
+ bcomc=
+ """,
+ )
+
+ def test_5(self):
+ _assert_dafsa(
+ """
+ a.d1
+ a.c.d1
+ b.d1
+ b.c.d1
+ """,
+ """
+ a
+ a.
+ a.c
+ a.c.
+ a.c.d
+ a.c.d1
+ a.c.d1$
+ a.d=
+ b
+ b.=
+ """,
+ )
+
+ def test_6(self):
+ _assert_dafsa(
+ """
+ a61
+ a661
+ b61
+ b661
+ """,
+ """
+ a
+ a6
+ a61
+ a61$
+ a66
+ a661=
+ b
+ b6=
+ """,
+ )
+
+ def test_7(self):
+ _assert_dafsa(
+ """
+ a61
+ a6661
+ b61
+ b6661
+ """,
+ """
+ a
+ a6
+ a61
+ a61$
+ a66
+ a666
+ a6661=
+ b
+ b6=
+ """,
+ )
+
+ def test_8(self):
+ _assert_dafsa(
+ """
+ acc1
+ bc1
+ bccc1
+ """,
+ """
+ a
+ ac
+ acc
+ acc1
+ acc1$
+ b
+ bc
+ bc1=
+ bcc=
+ """,
+ )
+
+ def test_9(self):
+ _assert_dafsa(
+ """
+ acc1
+ bc1
+ bcc1
+ """,
+ """
+ a
+ ac
+ acc
+ acc1
+ acc1$
+ b
+ bc
+ bc1=
+ bcc=
+ """,
+ )
+
+ def test_10(self):
+ _assert_dafsa(
+ """
+ acc1
+ cc1
+ cccc1
+ """,
+ """
+ a
+ ac
+ acc
+ acc1
+ acc1$
+ c
+ cc
+ cc1=
+ ccc=
+ """,
+ )
+
+ def test_11(self):
+ _assert_dafsa(
+ """
+ ac1
+ acc1
+ bc1
+ bcc1
+ """,
+ """
+ a
+ ac
+ ac1
+ ac1$
+ acc
+ acc1=
+ b
+ bc=
+ """,
+ )
+
+ def test_12(self):
+ _assert_dafsa(
+ """
+ acd1
+ bcd1
+ bcdd1
+ """,
+ """
+ a
+ ac
+ acd
+ acd1
+ acd1$
+ b
+ bc
+ bcd
+ bcd1=
+ bcdd=
+ """,
+ )
+
+ def test_13(self):
+ _assert_dafsa(
+ """
+ ac1
+ acc1
+ bc1
+ bcc1
+ bccc1
+ """,
+ """
+ a
+ ac
+ ac1
+ ac1$
+ acc
+ acc1=
+ b
+ bc
+ bc1=
+ bcc=
+ """,
+ )
+
+ def test_14(self):
+ _assert_dafsa(
+ """
+ acc1
+ acccc1
+ bcc1
+ bcccc1
+ bcccccc1
+ """,
+ """
+ a
+ ac
+ acc
+ acc1
+ acc1$
+ accc
+ acccc
+ acccc1=
+ b
+ bc
+ bcc
+ bcc1=
+ bccc=
+ """,
+ )
+
+ def test_15(self):
+ _assert_dafsa(
+ """
+ ac1
+ bc1
+ acac1
+ """,
+ """
+ a
+ ac
+ ac1
+ ac1$
+ aca
+ acac
+ acac1=
+ b
+ bc=
+ """,
+ )
+
+ def test_16(self):
+ _assert_dafsa(
+ """
+ bat1
+ t1
+ tbat1
+ """,
+ """
+ b
+ ba
+ bat
+ bat1
+ bat1$
+ t
+ t1=
+ tb=
+ """,
+ )
+
+ def test_17(self):
+ _assert_dafsa(
+ """
+ acow1
+ acat1
+ t1
+ tcat1
+ acatcat1
+ """,
+ """
+ a
+ ac
+ aca
+ acat
+ acat1
+ acat1$
+ acatc
+ acatca
+ acatcat
+ acatcat1=
+ aco
+ acow
+ acow1=
+ t=
+ """,
+ )
+
+ def test_18(self):
+ _assert_dafsa(
+ """
+ bc1
+ abc1
+ abcxyzc1
+ """,
+ """
+ a
+ ab
+ abc
+ abc1
+ abc1$
+ abcx
+ abcxy
+ abcxyz
+ abcxyzc
+ abcxyzc1=
+ b
+ bc=
+ """,
+ )
+
+ def test_19(self):
+ _assert_dafsa(
+ """
+ a.z1
+ a.y1
+ c.z1
+ d.z1
+ d.y1
+ """,
+ """
+ a
+ a.
+ a.y
+ a.y1
+ a.y1$
+ a.z
+ a.z1=
+ c
+ c.
+ c.z=
+ d
+ d.=
+ """,
+ )
+
+ def test_20(self):
+ _assert_dafsa(
+ """
+ acz1
+ acy1
+ accz1
+ acccz1
+ bcz1
+ bcy1
+ bccz1
+ bcccz1
+ """,
+ """
+ a
+ ac
+ acc
+ accc
+ acccz
+ acccz1
+ acccz1$
+ accz=
+ acy
+ acy1=
+ acz=
+ b
+ bc=
+ """,
+ )
+
+
+if __name__ == "__main__":
+ mozunit.main()
diff --git a/xpcom/ds/tools/incremental_dafsa.py b/xpcom/ds/tools/incremental_dafsa.py
new file mode 100644
index 0000000000..1157c26850
--- /dev/null
+++ b/xpcom/ds/tools/incremental_dafsa.py
@@ -0,0 +1,509 @@
+# 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/.
+
+"""
+Incremental algorithm for creating a "deterministic acyclic finite state
+automaton" (DAFSA). At the time of writing this algorithm, there was existing logic
+that depended on a different format for the DAFSA, so this contains convenience
+functions for converting to a compatible structure. This legacy format is defined
+in make_dafsa.py.
+"""
+
+from typing import Callable, Dict, List, Optional
+
+
+class Node:
+ children: Dict[str, "Node"]
+ parents: Dict[str, List["Node"]]
+ character: str
+ is_root_node: bool
+ is_end_node: bool
+
+ def __init__(self, character, is_root_node=False, is_end_node=False):
+ self.children = {}
+ self.parents = {}
+ self.character = character
+ self.is_root_node = is_root_node
+ self.is_end_node = is_end_node
+
+ def __str__(self):
+ """Produce a helpful string representation of this node.
+
+ This is expected to only be used for debugging.
+ The produced output is:
+
+ "c[def.] <123>"
+ ^ ^ ^
+ | | Internal python ID of the node (used for de-duping)
+ | |
+ | One possible path through the tree to the end
+ |
+ Current node character
+ """
+
+ if self.is_root_node:
+ return "<root>"
+ elif self.is_end_node:
+ return "<end>"
+
+ first_potential_match = ""
+ node = self
+ while node.children:
+ first_character = next(iter(node.children))
+ if first_character:
+ first_potential_match += first_character
+ node = node.children[first_character]
+
+ return "%s[%s] <%d>" % (self.character, first_potential_match, id(self))
+
+ def add_child(self, child):
+ self.children[child.character] = child
+ child.parents.setdefault(self.character, [])
+ child.parents[self.character].append(self)
+
+ def remove(self):
+ # remove() must only be called when this node has only a single parent, and that
+ # parent doesn't need this child anymore.
+ # The caller is expected to have performed this validation.
+ # (placing asserts here add a non-trivial performance hit)
+
+ # There's only a single parent, so only one list should be in the "parents" map
+ parent_list = next(iter(self.parents.values()))
+ self.remove_parent(parent_list[0])
+ for child in list(self.children.values()):
+ child.remove_parent(self)
+
+ def remove_parent(self, parent_node: "Node"):
+ parent_node.children.pop(self.character)
+ parents_for_character = self.parents[parent_node.character]
+ parents_for_character.remove(parent_node)
+ if not parents_for_character:
+ self.parents.pop(parent_node.character)
+
+ def copy_fork_node(self, fork_node: "Node", child_to_avoid: Optional["Node"]):
+ """Shallow-copy a node's children.
+
+ When adding a new word, sometimes previously-joined suffixes aren't perfect
+ matches any more. When this happens, some nodes need to be "copied" out.
+ For all non-end nodes, there's a child to avoid in the shallow-copy.
+ """
+
+ for child in fork_node.children.values():
+ if child is not child_to_avoid:
+ self.add_child(child)
+
+ def is_fork(self):
+ """Check if this node has multiple parents"""
+
+ if len(self.parents) == 0:
+ return False
+
+ if len(self.parents) > 1:
+ return True
+
+ return len(next(iter(self.parents.values()))) > 1
+
+ def is_replacement_for_prefix_end_node(self, old: "Node"):
+ """Check if this node is a valid replacement for an old end node.
+
+ A node is a valid replacement if it maintains all existing child paths while
+ adding the new child path needed for the new word.
+
+ Args:
+ old: node being replaced
+
+ Returns: True if this node is a valid replacement node.
+ """
+
+ if len(self.children) != len(old.children) + 1:
+ return False
+
+ for character, other_node in old.children.items():
+ this_node = self.children.get(character)
+ if other_node is not this_node:
+ return False
+
+ return True
+
+ def is_replacement_for_prefix_node(self, old: "Node"):
+ """Check if this node is a valid replacement for a non-end node.
+
+ A node is a valid replacement if it:
+ * Has one new child that the old node doesn't
+ * Is missing a child that the old node has
+ * Shares all other children
+
+ Returns: True if this node is a valid replacement node.
+ """
+
+ if len(self.children) != len(old.children):
+ return False
+
+ found_extra_child = False
+
+ for character, other_node in old.children.items():
+ this_node = self.children.get(character)
+ if other_node is not this_node:
+ if found_extra_child:
+ # Found two children in the old node that aren't in the new one,
+ # this isn't a valid replacement
+ return False
+ else:
+ found_extra_child = True
+
+ return found_extra_child
+
+
+class SuffixCursor:
+ index: int # Current position of the cursor within the DAFSA.
+ node: Node
+
+ def __init__(self, index, node):
+ self.index = index
+ self.node = node
+
+ def _query(self, character: str, check: Callable[[Node], bool]):
+ for node in self.node.parents.get(character, []):
+ if check(node):
+ self.index -= 1
+ self.node = node
+ return True
+ return False
+
+ def find_single_child(self, character):
+ """Find the next matching suffix node that has a single child.
+
+ Return True if such a node is found."""
+ return self._query(character, lambda node: len(node.children) == 1)
+
+ def find_end_of_prefix_replacement(self, end_of_prefix: Node):
+ """Find the next matching suffix node that replaces the old prefix-end node.
+
+ Return True if such a node is found."""
+ return self._query(
+ end_of_prefix.character,
+ lambda node: node.is_replacement_for_prefix_end_node(end_of_prefix),
+ )
+
+ def find_inside_of_prefix_replacement(self, prefix_node: Node):
+ """Find the next matching suffix node that replaces a node within the prefix.
+
+ Return True if such a node is found."""
+ return self._query(
+ prefix_node.character,
+ lambda node: node.is_replacement_for_prefix_node(prefix_node),
+ )
+
+
+class DafsaAppendStateMachine:
+ """State machine for adding a word to a Dafsa.
+
+ Each state returns a function reference to the "next state". States should be
+ invoked until "None" is returned, in which case the new word has been appended.
+
+ The prefix and suffix indexes are placed according to the currently-known valid
+ value (not the next value being investigated). Additionally, they are 0-indexed
+ against the root node (which sits behind the beginning of the string).
+
+ Let's imagine we're at the following state when adding, for example, the
+ word "mozilla.org":
+
+ mozilla.org
+ ^ ^ ^ ^
+ | | | |
+ / | | \
+ [root] | | [end] node
+ node | \
+ | suffix
+ \
+ prefix
+
+ In this state, the furthest prefix match we could find was:
+ [root] - m - o - z - i - l
+ The index of the prefix match is "5".
+
+ Additionally, we've been looking for suffix nodes, and we've already found:
+ r - g - [end]
+ The current suffix index is "10".
+ The next suffix node we'll attempt to find is at index "9".
+ """
+
+ root_node: Node
+ prefix_index: int
+ suffix_cursor: SuffixCursor
+ stack: List[Node]
+ word: str
+ suffix_overlaps_prefix: bool
+ first_fork_index: Optional[int]
+ _state: Callable
+
+ def __init__(self, word, root_node, end_node):
+ self.root_node = root_node
+ self.prefix_index = 0
+ self.suffix_cursor = SuffixCursor(len(word) + 1, end_node)
+ self.stack = [root_node]
+ self.word = word
+ self.suffix_overlaps_prefix = False
+ self.first_fork_index = None
+ self._state = self._find_prefix
+
+ def run(self):
+ """Run this state machine to completion, adding the new word."""
+ while self._state is not None:
+ self._state = self._state()
+
+ def _find_prefix(self):
+ """Find the longest existing prefix that matches the current word."""
+ prefix_node = self.root_node
+ while self.prefix_index < len(self.word):
+ next_character = self.word[self.prefix_index]
+ next_node = prefix_node.children.get(next_character)
+ if not next_node:
+ # We're finished finding the prefix, let's find the longest suffix
+ # match now.
+ return self._find_suffix_nodes_after_prefix
+
+ self.prefix_index += 1
+ prefix_node = next_node
+ self.stack.append(next_node)
+
+ if not self.first_fork_index and next_node.is_fork():
+ self.first_fork_index = self.prefix_index
+
+ # Deja vu, we've appended this string before. Since this string has
+ # already been appended, we don't have to do anything.
+ return None
+
+ def _find_suffix_nodes_after_prefix(self):
+ """Find the chain of suffix nodes for characters after the prefix."""
+ while self.suffix_cursor.index - 1 > self.prefix_index:
+ # To fetch the next character, we need to subtract two from the current
+ # suffix index. This is because:
+ # * The next suffix node is 1 node before our current node (subtract 1)
+ # * The suffix index includes the root node before the beginning of the
+ # string - it's like the string is 1-indexed (subtract 1 again).
+ next_character = self.word[self.suffix_cursor.index - 2]
+ if not self.suffix_cursor.find_single_child(next_character):
+ return self._add_new_nodes
+
+ if self.suffix_cursor.node is self.stack[-1]:
+ # The suffix match is overlapping with the prefix! This can happen in
+ # cases like:
+ # * "ab"
+ # * "abb"
+ # The suffix cursor is at the same node as the prefix match, but they're
+ # at different positions in the word.
+ #
+ # [root] - a - b - [end]
+ # ^
+ # / \
+ # / \
+ # prefix suffix
+ # \ /
+ # \ /
+ # VV
+ # "abb"
+ if not self.first_fork_index:
+ # There hasn't been a fork, so our prefix isn't shared. So, we
+ # can mark this node as a fork, since the repetition means
+ # that there's two paths that are now using this node
+ self.first_fork_index = self.prefix_index
+ return self._add_new_nodes
+
+ # Removes the link between the unique part of the prefix and the
+ # shared part of the prefix.
+ self.stack[self.first_fork_index].remove_parent(
+ self.stack[self.first_fork_index - 1]
+ )
+ self.suffix_overlaps_prefix = True
+
+ if self.first_fork_index is None:
+ return self._find_next_suffix_nodes
+ elif self.suffix_cursor.index - 1 == self.first_fork_index:
+ return self._find_next_suffix_node_at_prefix_end_at_fork
+ else:
+ return self._find_next_suffix_node_at_prefix_end_after_fork
+
+ def _find_next_suffix_node_at_prefix_end_at_fork(self):
+ """Find the next suffix node that replaces the end of the prefix.
+
+ In this state, the prefix_end node is the same as the first fork node.
+ Therefore, if a match can be found, the old prefix node can't be entirely
+ deleted since it's used elsewhere. Instead, just the link between our
+ unique prefix and the end of the fork is removed.
+ """
+ existing_node = self.stack[self.prefix_index]
+ if not self.suffix_cursor.find_end_of_prefix_replacement(existing_node):
+ return self._add_new_nodes
+
+ self.prefix_index -= 1
+ self.first_fork_index = None
+
+ if not self.suffix_overlaps_prefix:
+ existing_node.remove_parent(self.stack[self.prefix_index])
+ else:
+ # When the suffix overlaps the prefix, the old "parent link" was removed
+ # earlier in the "find_suffix_nodes_after_prefix" step.
+ self.suffix_overlaps_prefix = False
+
+ return self._find_next_suffix_nodes
+
+ def _find_next_suffix_node_at_prefix_end_after_fork(self):
+ """Find the next suffix node that replaces the end of the prefix.
+
+ In this state, the prefix_end node is after the first fork node.
+ Therefore, even if a match is found, we don't want to modify the replaced
+ prefix node since an unrelated word chain uses it.
+ """
+ existing_node = self.stack[self.prefix_index]
+ if not self.suffix_cursor.find_end_of_prefix_replacement(existing_node):
+ return self._add_new_nodes
+
+ self.prefix_index -= 1
+ if self.prefix_index == self.first_fork_index:
+ return self._find_next_suffix_node_within_prefix_at_fork
+ else:
+ return self._find_next_suffix_nodes_within_prefix_after_fork
+
+ def _find_next_suffix_node_within_prefix_at_fork(self):
+ """Find the next suffix node within a prefix.
+
+ In this state, we've already worked our way back and found nodes in the suffix
+ to replace prefix nodes after the fork node. We have now reached the fork node,
+ and if we find a replacement for it, then we can remove the link between it
+ and our then-unique prefix and clear the fork status.
+ """
+ existing_node = self.stack[self.prefix_index]
+ if not self.suffix_cursor.find_inside_of_prefix_replacement(existing_node):
+ return self._add_new_nodes
+
+ self.prefix_index -= 1
+ self.first_fork_index = None
+
+ if not self.suffix_overlaps_prefix:
+ existing_node.remove_parent(self.stack[self.prefix_index])
+ else:
+ # When the suffix overlaps the prefix, the old "parent link" was removed
+ # earlier in the "find_suffix_nodes_after_prefix" step.
+ self.suffix_overlaps_prefix = False
+
+ return self._find_next_suffix_nodes
+
+ def _find_next_suffix_nodes_within_prefix_after_fork(self):
+ """Find the next suffix nodes within a prefix.
+
+ Finds suffix nodes to replace prefix nodes, but doesn't modify the prefix
+ nodes since they're after a fork (so, we're sharing prefix nodes with
+ other words and can't modify them).
+ """
+ while True:
+ existing_node = self.stack[self.prefix_index]
+ if not self.suffix_cursor.find_inside_of_prefix_replacement(existing_node):
+ return self._add_new_nodes
+
+ self.prefix_index -= 1
+ if self.prefix_index == self.first_fork_index:
+ return self._find_next_suffix_node_within_prefix_at_fork
+
+ def _find_next_suffix_nodes(self):
+ """Find all remaining suffix nodes in the chain.
+
+ In this state, there's no (longer) any fork, so there's no other words
+ using our current prefix. Therefore, as we find replacement nodes as we
+ work our way backwards, we can remove the now-unused prefix nodes.
+ """
+ while True:
+ existing_node = self.stack[self.prefix_index]
+ if not self.suffix_cursor.find_end_of_prefix_replacement(existing_node):
+ return self._add_new_nodes
+
+ # This prefix node is wholly replaced by the new suffix node, so it can
+ # be deleted.
+ existing_node.remove()
+ self.prefix_index -= 1
+
+ def _add_new_nodes(self):
+ """Adds new nodes to support the new word.
+
+ Duplicates forked nodes to make room for new links, adds new nodes for new
+ characters, and splices the prefix to the suffix to finish embedding the new
+ word into the DAFSA.
+ """
+ if self.first_fork_index is not None:
+ front_node = _duplicate_fork_nodes(
+ self.stack,
+ self.first_fork_index,
+ self.prefix_index,
+ # if suffix_overlaps_parent, the parent link was removed
+ # earlier in the word-adding process.
+ remove_parent_link=not self.suffix_overlaps_prefix,
+ )
+ else:
+ front_node = self.stack[self.prefix_index]
+
+ new_text = self.word[self.prefix_index : self.suffix_cursor.index - 1]
+ for character in new_text:
+ new_node = Node(character)
+ front_node.add_child(new_node)
+ front_node = new_node
+
+ front_node.add_child(self.suffix_cursor.node)
+ return None # Done!
+
+
+def _duplicate_fork_nodes(stack, fork_index, prefix_index, remove_parent_link=True):
+ parent_node = stack[fork_index - 1]
+ if remove_parent_link:
+ # remove link to old chain that we're going to be copying
+ stack[fork_index].remove_parent(parent_node)
+
+ for index in range(fork_index, prefix_index + 1):
+ fork_node = stack[index]
+ replacement_node = Node(fork_node.character)
+ child_to_avoid = None
+ if index < len(stack) - 1:
+ # We're going to be manually replacing the next node in the stack,
+ # so don't connect it as a child.
+ child_to_avoid = stack[index + 1]
+
+ replacement_node.copy_fork_node(fork_node, child_to_avoid)
+ parent_node.add_child(replacement_node)
+ parent_node = replacement_node
+
+ return parent_node
+
+
+class Dafsa:
+ root_node: Node
+ end_node: Node
+
+ def __init__(self):
+ self.root_node = Node(None, is_root_node=True)
+ self.end_node = Node(None, is_end_node=True)
+
+ @classmethod
+ def from_tld_data(cls, lines):
+ """Create a dafsa for TLD data.
+
+ TLD data has a domain and a "type" enum. The source data encodes the type as a
+ text number, but the dafsa-consuming code assumes that the type is a raw byte
+ number (e.g.: "1" => 0x01).
+
+ This function acts as a helper, processing this TLD detail before creating a
+ standard dafsa.
+ """
+
+ dafsa = cls()
+ for i, word in enumerate(lines):
+ domain_number = word[-1]
+ # Convert type from string to byte representation
+ raw_domain_number = chr(ord(domain_number) & 0x0F)
+
+ word = "%s%s" % (word[:-1], raw_domain_number)
+ dafsa.append(word)
+ return dafsa
+
+ def append(self, word):
+ state_machine = DafsaAppendStateMachine(word, self.root_node, self.end_node)
+ state_machine.run()
diff --git a/xpcom/ds/tools/make_dafsa.py b/xpcom/ds/tools/make_dafsa.py
new file mode 100644
index 0000000000..a9cedf78a8
--- /dev/null
+++ b/xpcom/ds/tools/make_dafsa.py
@@ -0,0 +1,372 @@
+#!/usr/bin/env python
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+A Deterministic acyclic finite state automaton (DAFSA) is a compact
+representation of an unordered word list (dictionary).
+
+http://en.wikipedia.org/wiki/Deterministic_acyclic_finite_state_automaton
+
+This python program converts a list of strings to a byte array in C++.
+This python program fetches strings and return values from a gperf file
+and generates a C++ file with a byte array representing graph that can be
+used as a memory efficient replacement for the perfect hash table.
+
+The input strings are assumed to consist of printable 7-bit ASCII characters
+and the return values are assumed to be one digit integers.
+
+In this program a DAFSA is a diamond shaped graph starting at a common
+root node and ending at a common end node. All internal nodes contain
+a character and each word is represented by the characters in one path from
+the root node to the end node.
+
+The order of the operations is crucial since lookups will be performed
+starting from the source with no backtracking. Thus a node must have at
+most one child with a label starting by the same character. The output
+is also arranged so that all jumps are to increasing addresses, thus forward
+in memory.
+
+The generated output has suffix free decoding so that the sign of leading
+bits in a link (a reference to a child node) indicate if it has a size of one,
+two or three bytes and if it is the last outgoing link from the actual node.
+A node label is terminated by a byte with the leading bit set.
+
+The generated byte array can described by the following BNF:
+
+<byte> ::= < 8-bit value in range [0x00-0xFF] >
+
+<char> ::= < printable 7-bit ASCII character, byte in range [0x20-0x7F] >
+<end_char> ::= < char + 0x80, byte in range [0xA0-0xFF] >
+<return value> ::= < value + 0x80, byte in range [0x80-0x8F] >
+
+<offset1> ::= < byte in range [0x00-0x3F] >
+<offset2> ::= < byte in range [0x40-0x5F] >
+<offset3> ::= < byte in range [0x60-0x7F] >
+
+<end_offset1> ::= < byte in range [0x80-0xBF] >
+<end_offset2> ::= < byte in range [0xC0-0xDF] >
+<end_offset3> ::= < byte in range [0xE0-0xFF] >
+
+<prefix> ::= <char>
+
+<label> ::= <end_char>
+ | <char> <label>
+
+<end_label> ::= <return_value>
+ | <char> <end_label>
+
+<offset> ::= <offset1>
+ | <offset2> <byte>
+ | <offset3> <byte> <byte>
+
+<end_offset> ::= <end_offset1>
+ | <end_offset2> <byte>
+ | <end_offset3> <byte> <byte>
+
+<offsets> ::= <end_offset>
+ | <offset> <offsets>
+
+<source> ::= <offsets>
+
+<node> ::= <label> <offsets>
+ | <prefix> <node>
+ | <end_label>
+
+<dafsa> ::= <source>
+ | <dafsa> <node>
+
+Decoding:
+
+<char> -> printable 7-bit ASCII character
+<end_char> & 0x7F -> printable 7-bit ASCII character
+<return value> & 0x0F -> integer
+<offset1 & 0x3F> -> integer
+((<offset2> & 0x1F>) << 8) + <byte> -> integer
+((<offset3> & 0x1F>) << 16) + (<byte> << 8) + <byte> -> integer
+
+end_offset1, end_offset2 and and_offset3 are decoded same as offset1,
+offset2 and offset3 respectively.
+
+The first offset in a list of offsets is the distance in bytes between the
+offset itself and the first child node. Subsequent offsets are the distance
+between previous child node and next child node. Thus each offset links a node
+to a child node. The distance is always counted between start addresses, i.e.
+first byte in decoded offset or first byte in child node.
+
+Example 1:
+
+%%
+aa, 1
+a, 2
+%%
+
+The input is first parsed to a list of words:
+["aa1", "a2"]
+
+This produces the following graph:
+[root] --- a --- 0x02 --- [end]
+ | /
+ | /
+ - a --- 0x01
+
+A C++ representation of the compressed graph is generated:
+
+const unsigned char dafsa[7] = {
+ 0x81, 0xE1, 0x02, 0x81, 0x82, 0x61, 0x81,
+};
+
+The bytes in the generated array has the following meaning:
+
+ 0: 0x81 <end_offset1> child at position 0 + (0x81 & 0x3F) -> jump to 1
+
+ 1: 0xE1 <end_char> label character (0xE1 & 0x7F) -> match "a"
+ 2: 0x02 <offset1> child at position 2 + (0x02 & 0x3F) -> jump to 4
+
+ 3: 0x81 <end_offset1> child at position 4 + (0x81 & 0x3F) -> jump to 5
+ 4: 0x82 <return_value> 0x82 & 0x0F -> return 2
+
+ 5: 0x61 <char> label character 0x61 -> match "a"
+ 6: 0x81 <return_value> 0x81 & 0x0F -> return 1
+
+Example 2:
+
+%%
+aa, 1
+bbb, 2
+baa, 1
+%%
+
+The input is first parsed to a list of words:
+["aa1", "bbb2", "baa1"]
+
+This produces the following graph:
+[root] --- a --- a --- 0x01 --- [end]
+ | / / /
+ | / / /
+ - b --- b --- b --- 0x02
+
+A C++ representation of the compressed graph is generated:
+
+const unsigned char dafsa[11] = {
+ 0x02, 0x83, 0xE2, 0x02, 0x83, 0x61, 0x61, 0x81, 0x62, 0x62, 0x82,
+};
+
+The bytes in the generated array has the following meaning:
+
+ 0: 0x02 <offset1> child at position 0 + (0x02 & 0x3F) -> jump to 2
+ 1: 0x83 <end_offset1> child at position 2 + (0x83 & 0x3F) -> jump to 5
+
+ 2: 0xE2 <end_char> label character (0xE2 & 0x7F) -> match "b"
+ 3: 0x02 <offset1> child at position 3 + (0x02 & 0x3F) -> jump to 5
+ 4: 0x83 <end_offset1> child at position 5 + (0x83 & 0x3F) -> jump to 8
+
+ 5: 0x61 <char> label character 0x61 -> match "a"
+ 6: 0x61 <char> label character 0x61 -> match "a"
+ 7: 0x81 <return_value> 0x81 & 0x0F -> return 1
+
+ 8: 0x62 <char> label character 0x62 -> match "b"
+ 9: 0x62 <char> label character 0x62 -> match "b"
+10: 0x82 <return_value> 0x82 & 0x0F -> return 2
+"""
+import struct
+import sys
+
+from incremental_dafsa import Dafsa, Node
+
+
+class InputError(Exception):
+ """Exception raised for errors in the input file."""
+
+
+def top_sort(dafsa: Dafsa):
+ """Generates list of nodes in topological sort order."""
+ incoming = {}
+
+ def count_incoming(node: Node):
+ """Counts incoming references."""
+ if not node.is_end_node:
+ if id(node) not in incoming:
+ incoming[id(node)] = 1
+ for child in node.children.values():
+ count_incoming(child)
+ else:
+ incoming[id(node)] += 1
+
+ for node in dafsa.root_node.children.values():
+ count_incoming(node)
+
+ for node in dafsa.root_node.children.values():
+ incoming[id(node)] -= 1
+
+ waiting = [
+ node for node in dafsa.root_node.children.values() if incoming[id(node)] == 0
+ ]
+ nodes = []
+
+ while waiting:
+ node = waiting.pop()
+ assert incoming[id(node)] == 0
+ nodes.append(node)
+ for child in node.children.values():
+ if not child.is_end_node:
+ incoming[id(child)] -= 1
+ if incoming[id(child)] == 0:
+ waiting.append(child)
+ return nodes
+
+
+def encode_links(node: Node, offsets, current):
+ """Encodes a list of children as one, two or three byte offsets."""
+ if next(iter(node.children.values())).is_end_node:
+ # This is an <end_label> node and no links follow such nodes
+ return []
+ guess = 3 * len(node.children)
+ assert node.children
+
+ children = sorted(node.children.values(), key=lambda x: -offsets[id(x)])
+ while True:
+ offset = current + guess
+ buf = []
+ for child in children:
+ last = len(buf)
+ distance = offset - offsets[id(child)]
+ assert distance > 0 and distance < (1 << 21)
+
+ if distance < (1 << 6):
+ # A 6-bit offset: "s0xxxxxx"
+ buf.append(distance)
+ elif distance < (1 << 13):
+ # A 13-bit offset: "s10xxxxxxxxxxxxx"
+ buf.append(0x40 | (distance >> 8))
+ buf.append(distance & 0xFF)
+ else:
+ # A 21-bit offset: "s11xxxxxxxxxxxxxxxxxxxxx"
+ buf.append(0x60 | (distance >> 16))
+ buf.append((distance >> 8) & 0xFF)
+ buf.append(distance & 0xFF)
+ # Distance in first link is relative to following record.
+ # Distance in other links are relative to previous link.
+ offset -= distance
+ if len(buf) == guess:
+ break
+ guess = len(buf)
+ # Set most significant bit to mark end of links in this node.
+ buf[last] |= 1 << 7
+ buf.reverse()
+ return buf
+
+
+def encode_prefix(label):
+ """Encodes a node label as a list of bytes without a trailing high byte.
+
+ This method encodes a node if there is exactly one child and the
+ child follows immediately after so that no jump is needed. This label
+ will then be a prefix to the label in the child node.
+ """
+ assert label
+ return [ord(c) for c in reversed(label)]
+
+
+def encode_label(label):
+ """Encodes a node label as a list of bytes with a trailing high byte >0x80."""
+ buf = encode_prefix(label)
+ # Set most significant bit to mark end of label in this node.
+ buf[0] |= 1 << 7
+ return buf
+
+
+def encode(dafsa: Dafsa):
+ """Encodes a DAFSA to a list of bytes"""
+ output = []
+ offsets = {}
+
+ for node in reversed(top_sort(dafsa)):
+ if (
+ len(node.children) == 1
+ and not next(iter(node.children.values())).is_end_node
+ and (offsets[id(next(iter(node.children.values())))] == len(output))
+ ):
+ output.extend(encode_prefix(node.character))
+ else:
+ output.extend(encode_links(node, offsets, len(output)))
+ output.extend(encode_label(node.character))
+ offsets[id(node)] = len(output)
+
+ output.extend(encode_links(dafsa.root_node, offsets, len(output)))
+ output.reverse()
+ return output
+
+
+def to_cxx(data, preamble=None):
+ """Generates C++ code from a list of encoded bytes."""
+ text = "/* This file is generated. DO NOT EDIT!\n\n"
+ text += "The byte array encodes a dictionary of strings and values. See "
+ text += "make_dafsa.py for documentation."
+ text += "*/\n\n"
+
+ if preamble:
+ text += preamble
+ text += "\n\n"
+
+ text += "const unsigned char kDafsa[%s] = {\n" % len(data)
+ for i in range(0, len(data), 12):
+ text += " "
+ text += ", ".join("0x%02x" % byte for byte in data[i : i + 12])
+ text += ",\n"
+ text += "};\n"
+ return text
+
+
+def words_to_cxx(words, preamble=None):
+ """Generates C++ code from a word list"""
+ dafsa = Dafsa.from_tld_data(words)
+ return to_cxx(encode(dafsa), preamble)
+
+
+def words_to_bin(words):
+ """Generates bytes from a word list"""
+ dafsa = Dafsa.from_tld_data(words)
+ data = encode(dafsa)
+ return struct.pack("%dB" % len(data), *data)
+
+
+def parse_gperf(infile):
+ """Parses gperf file and extract strings and return code"""
+ lines = [line.strip() for line in infile]
+
+ # Extract the preamble.
+ first_delimeter = lines.index("%%")
+ preamble = "\n".join(lines[0:first_delimeter])
+
+ # Extract strings after the first '%%' and before the second '%%'.
+ begin = first_delimeter + 1
+ end = lines.index("%%", begin)
+ lines = lines[begin:end]
+ for line in lines:
+ if line[-3:-1] != ", ":
+ raise InputError('Expected "domainname, <digit>", found "%s"' % line)
+ # Technically the DAFSA format could support return values in range [0-31],
+ # but the values below are the only with a defined meaning.
+ if line[-1] not in "0124":
+ raise InputError(
+ 'Expected value to be one of {0,1,2,4}, found "%s"' % line[-1]
+ )
+ return (preamble, [line[:-3] + line[-1] for line in lines])
+
+
+def main(outfile, infile):
+ with open(infile, "r") as infile:
+ preamble, words = parse_gperf(infile)
+ outfile.write(words_to_cxx(words, preamble))
+ return 0
+
+
+if __name__ == "__main__":
+ if len(sys.argv) != 3:
+ print("usage: %s infile outfile" % sys.argv[0])
+ sys.exit(1)
+
+ with open(sys.argv[2], "w") as outfile:
+ sys.exit(main(outfile, sys.argv[1]))
diff --git a/xpcom/ds/tools/perfecthash.py b/xpcom/ds/tools/perfecthash.py
new file mode 100644
index 0000000000..b4e964a125
--- /dev/null
+++ b/xpcom/ds/tools/perfecthash.py
@@ -0,0 +1,371 @@
+# perfecthash.py - Helper for generating perfect hash functions
+#
+# 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/.
+
+"""
+A perfect hash function (PHF) is a function which maps distinct elements from a
+source set to a sequence of integers with no collisions.
+
+PHFs generated by this module use a 32-bit FNV hash to index an intermediate
+table. The value from that table is then used to run a second 32-bit FNV hash to
+get a final index.
+
+The algorithm works by starting with the largest set of conflicts, and testing
+intermediate table values until no conflicts are generated, allowing efficient
+index lookup at runtime. (see also: http://stevehanov.ca/blog/index.php?id=119)
+
+NOTE: This perfect hash generator was designed to be simple, easy to follow, and
+maintainable, rather than being as optimized as possible, due to the relatively
+small dataset it was designed for. In the future we may want to optimize further.
+"""
+
+import textwrap
+from collections import namedtuple
+
+import six
+from mozbuild.util import ensure_bytes
+
+
+# Iteration over bytestrings works differently in Python 2 and 3; this function
+# captures the two possibilities. Returns an 'int' given the output of iterating
+# through a bytestring regardless of the input.
+def _ord(c):
+ if six.PY3:
+ return c
+ return ord(c)
+
+
+class PerfectHash(object):
+ """PerfectHash objects represent a computed perfect hash function, which
+ can be generated at compile time to provide highly efficient and compact
+ static HashTables.
+
+ Consumers must provide an intermediate table size to store the generated
+ hash function. Larger tables will generate more quickly, while smaller
+ tables will consume less space on disk."""
+
+ # 32-bit FNV offset basis and prime value.
+ # NOTE: Must match values in |PerfectHash.h|
+ FNV_OFFSET_BASIS = 0x811C9DC5
+ FNV_PRIME = 16777619
+ U32_MAX = 0xFFFFFFFF
+
+ # Bucket of entries which map into a given intermediate index.
+ Bucket = namedtuple("Bucket", "index entries")
+
+ def __init__(self, entries, size, validate=True, key=lambda e: e[0]):
+ """Create a new PerfectHash
+
+ @param entries set of entries to generate a PHF for
+ @param size size of the PHF intermediate table
+ @param validate test the generated hash function after generation
+ @param key function to get 'memoryview'-compatible key for an
+ entry. defaults to extracting the first element of an
+ entry 2-tuple.
+ """
+
+ assert 0 < len(entries) < self.U32_MAX, "bad # of entries!"
+ self._key = key
+
+ # Allocate the intermediate table and keys.
+ self.table = [0] * size
+ self.entries = [None] * len(entries)
+
+ # A set of Bucket values. Each bucket contains the index into the
+ # intermediate table, and a list of Entries which map into that bucket.
+ buckets = [self.Bucket(idx, []) for idx in range(size)]
+
+ # Determine which input strings map to which buckets in the table.
+ for entry in entries:
+ assert entry is not None, "None entry in entries"
+ assert self.key(entry).itemsize == 1, "non-byte key elements"
+ buckets[self._hash(self.key(entry)) % size].entries.append(entry)
+
+ # Sort the buckets such that the largest one comes first.
+ buckets.sort(key=lambda b: len(b.entries), reverse=True)
+
+ for bucket in buckets:
+ # Once we've reached an empty bucket, we're done.
+ if len(bucket.entries) == 0:
+ break
+
+ # Try values for the basis until we find one with no conflicts.
+ idx = 0
+ basis = 1
+ slots = []
+ while idx < len(bucket.entries):
+ slot = self._hash(self.key(bucket.entries[idx]), basis) % len(
+ self.entries
+ )
+ if self.entries[slot] is not None or slot in slots:
+ # There was a conflict, try the next basis.
+ basis += 1
+ idx = 0
+ del slots[:]
+ assert basis < self.U32_MAX, "table too small"
+ else:
+ slots.append(slot)
+ idx += 1
+
+ assert basis < self.U32_MAX
+
+ # We've found a basis which doesn't conflict
+ self.table[bucket.index] = basis
+ for slot, entry in zip(slots, bucket.entries):
+ self.entries[slot] = entry
+
+ # Validate that looking up each key succeeds
+ if validate:
+ for entry in entries:
+ assert self.get_entry(self.key(entry)), "get_entry(%s)" % repr(entry)
+
+ @classmethod
+ def _hash(cls, key, basis=FNV_OFFSET_BASIS):
+ """A basic FNV-based hash function. key is the memoryview to hash.
+ 32-bit FNV is used for indexing into the first table, and the value
+ stored in that table is used as the offset basis for indexing into the
+ values table."""
+ for byte in memoryview(ensure_bytes(key)):
+ obyte = _ord(byte)
+ basis ^= obyte # xor-in the byte
+ basis *= cls.FNV_PRIME # Multiply by the FNV prime
+ basis &= cls.U32_MAX # clamp to 32-bits
+ return basis
+
+ def key(self, entry):
+ return memoryview(ensure_bytes(self._key(entry)))
+
+ def get_raw_index(self, key):
+ """Determine the index in self.entries without validating"""
+ mid = self.table[self._hash(key) % len(self.table)]
+ return self._hash(key, mid) % len(self.entries)
+
+ def get_index(self, key):
+ """Given a key, determine the index in self.entries"""
+ idx = self.get_raw_index(key)
+ if memoryview(ensure_bytes(key)) != self.key(self.entries[idx]):
+ return None
+ return idx
+
+ def get_entry(self, key):
+ """Given a key, get the corresponding entry"""
+ idx = self.get_index(key)
+ if idx is None:
+ return None
+ return self.entries[idx]
+
+ @staticmethod
+ def _indent(text, amount=1):
+ return text.replace("\n", "\n" + (" " * amount))
+
+ def codegen(self, name, entry_type):
+ """Create a helper for codegening PHF logic"""
+ return CGHelper(self, name, entry_type)
+
+ def cxx_codegen(
+ self,
+ name,
+ entry_type,
+ lower_entry,
+ entries_name=None,
+ return_type=None,
+ return_entry="return entry;",
+ key_type="const char*",
+ key_bytes="aKey",
+ key_length="strlen(aKey)",
+ ):
+ """Generate complete C++ code for a get_entry-style method.
+
+ @param name Name for the entry getter function.
+ @param entry_type C++ type of each entry in static memory.
+ @param lower_entry Function called with each entry to convert it to a
+ C++ literal of type 'entry_type'.
+
+ # Optional Keyword Parameters:
+ @param entries_name Name for the generated entry table.
+
+ @param return_type C++ return type, default: 'const entry_type&'
+ @param return_entry Override the default behaviour for returning the
+ found entry. 'entry' is a reference to the found
+ entry, and 'aKey' is the lookup key. 'return_entry'
+ can be used for additional checks, e.g. for keys
+ not in the table.
+
+ @param key_type C++ key type, default: 'const char*'
+ @param key_bytes 'const char*' expression to get bytes for 'aKey'
+ @param key_length 'size_t' expression to get length of 'aKey'"""
+
+ if entries_name is None:
+ entries_name = "s%sEntries" % name
+
+ cg = self.codegen(entries_name, entry_type)
+ entries = cg.gen_entries(lower_entry)
+ getter = cg.gen_getter(
+ name, return_type, return_entry, key_type, key_bytes, key_length
+ )
+
+ return "%s\n\n%s" % (entries, getter)
+
+
+class CGHelper(object):
+ """Helper object for generating C++ code for a PerfectHash.
+ Created using PerfectHash.codegen()."""
+
+ def __init__(self, phf, entries_name, entry_type):
+ self.phf = phf
+ self.entries_name = entries_name
+ self.entry_type = entry_type
+
+ @staticmethod
+ def _indent(text, amount=1):
+ return text.replace("\n", "\n" + (" " * amount))
+
+ def basis_ty(self):
+ """Determine how big of an integer is needed for bases table."""
+ max_base = max(self.phf.table)
+ if max_base <= 0xFF:
+ return "uint8_t"
+ elif max_base <= 0xFFFF:
+ return "uint16_t"
+ return "uint32_t"
+
+ def basis_table(self, name="BASES"):
+ """Generate code for a static basis table"""
+ bases = ""
+ for idx, base in enumerate(self.phf.table):
+ if idx and idx % 16 == 0: # 16 bases per line
+ bases += "\n "
+ bases += "%4d," % base
+ return (
+ textwrap.dedent(
+ """\
+ static const %s %s[] = {
+ %s
+ };
+ """
+ )
+ % (self.basis_ty(), name, bases)
+ )
+
+ def gen_entries(self, lower_entry):
+ """Generate code for an entries table"""
+ entries = self._indent(
+ ",\n".join(lower_entry(entry).rstrip() for entry in self.phf.entries)
+ )
+ return (
+ textwrap.dedent(
+ """\
+ const %s %s[] = {
+ %s
+ };
+ """
+ )
+ % (self.entry_type, self.entries_name, entries)
+ )
+
+ def gen_getter(
+ self,
+ name,
+ return_type=None,
+ return_entry="return entry;",
+ key_type="const char*",
+ key_bytes="aKey",
+ key_length="strlen(aKey)",
+ ):
+ """Generate the code for a C++ getter.
+
+ @param name Name for the entry getter function.
+ @param return_type C++ return type, default: 'const entry_type&'
+ @param return_entry Override the default behaviour for returning the
+ found entry. 'entry' is a reference to the found
+ entry, and 'aKey' is the lookup key. 'return_entry'
+ can be used for additional checks, e.g. for keys
+ not in the table.
+
+ @param key_type C++ key type, default: 'const char*'
+ @param key_bytes 'const char*' expression to get bytes for 'aKey'
+ @param key_length 'size_t' expression to get length of 'aKey'"""
+
+ if return_type is None:
+ return_type = "const %s&" % self.entry_type
+
+ return textwrap.dedent(
+ """
+ %(return_type)s
+ %(name)s(%(key_type)s aKey)
+ {
+ %(basis_table)s
+
+ const char* bytes = %(key_bytes)s;
+ size_t length = %(key_length)s;
+ auto& entry = mozilla::perfecthash::Lookup(bytes, length, BASES,
+ %(entries_name)s);
+ %(return_entry)s
+ }
+ """
+ ) % {
+ "name": name,
+ "basis_table": self._indent(self.basis_table()),
+ "entries_name": self.entries_name,
+ "return_type": return_type,
+ "return_entry": self._indent(return_entry),
+ "key_type": key_type,
+ "key_bytes": key_bytes,
+ "key_length": key_length,
+ }
+
+ def gen_jslinearstr_getter(
+ self, name, return_type=None, return_entry="return entry;"
+ ):
+ """Generate code for a specialized getter taking JSLinearStrings.
+ This getter avoids copying the JS string, but only supports ASCII keys.
+
+ @param name Name for the entry getter function.
+ @param return_type C++ return type, default: 'const entry_type&'
+ @param return_entry Override the default behaviour for returning the
+ found entry. 'entry' is a reference to the found
+ entry, and 'aKey' is the lookup key. 'return_entry'
+ can be used for additional checks, e.g. for keys
+ not in the table."""
+
+ assert all(
+ _ord(b) <= 0x7F for e in self.phf.entries for b in self.phf.key(e)
+ ), "non-ASCII key"
+
+ if return_type is None:
+ return_type = "const %s&" % self.entry_type
+
+ return textwrap.dedent(
+ """
+ %(return_type)s
+ %(name)s(JSLinearString* aKey)
+ {
+ %(basis_table)s
+
+ size_t length = JS::GetLinearStringLength(aKey);
+
+ JS::AutoCheckCannotGC nogc;
+ if (JS::LinearStringHasLatin1Chars(aKey)) {
+ auto& entry = mozilla::perfecthash::Lookup(
+ JS::GetLatin1LinearStringChars(nogc, aKey),
+ length, BASES, %(entries_name)s);
+
+ %(return_entry)s
+ } else {
+ auto& entry = mozilla::perfecthash::Lookup(
+ JS::GetTwoByteLinearStringChars(nogc, aKey),
+ length, BASES, %(entries_name)s);
+
+ %(return_entry)s
+ }
+ }
+ """
+ ) % {
+ "name": name,
+ "basis_table": self._indent(self.basis_table()),
+ "entries_name": self.entries_name,
+ "return_type": return_type,
+ "return_entry": self._indent(return_entry, 2),
+ }