heap: Add more Oilpan library stubs

Drive-by: Cleanup HashTraits for Member and friends.

Bug: 1056170
Change-Id: I5fe4c7c2b5ae958e80e8078919f4bfec9cd8b539
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626660Reviewed-by: Omer Katz <omerkatz@chromium.org>
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843138}

third_party/blink/renderer/platform/heap/member.h

@@ -74,105 +74,65 @@ struct IsTraceable<blink::WeakMember<T>> {
   static const bool value = true;
 };
 
-template <typename T>
-struct HashTraits<blink::Member<T>> : SimpleClassHashTraits<blink::Member<T>> {
-  STATIC_ONLY(HashTraits);
-  // FIXME: Implement proper const'ness for iterator types. Requires support
-  // in the marking Visitor.
+template <typename T, typename MemberType>
+struct BaseMemberHashTraits : SimpleClassHashTraits<MemberType> {
+  STATIC_ONLY(BaseMemberHashTraits);
+
   using PeekInType = T*;
-  using IteratorGetType = blink::Member<T>*;
-  using IteratorConstGetType = const blink::Member<T>*;
-  using IteratorReferenceType = blink::Member<T>&;
-  using IteratorConstReferenceType = const blink::Member<T>&;
+  using PeekOutType = T*;
+  using IteratorGetType = MemberType*;
+  using IteratorConstGetType = const MemberType*;
+  using IteratorReferenceType = MemberType&;
+  using IteratorConstReferenceType = const MemberType&;
+
+  static PeekOutType Peek(const MemberType& value) { return value; }
+
   static IteratorReferenceType GetToReferenceConversion(IteratorGetType x) {
     return *x;
   }
+
   static IteratorConstReferenceType GetToReferenceConstConversion(
       IteratorConstGetType x) {
     return *x;
   }
 
-  using PeekOutType = T*;
-
   template <typename U>
-  static void Store(const U& value, blink::Member<T>& storage) {
+  static void Store(const U& value, MemberType& storage) {
     storage = value;
   }
 
-  static PeekOutType Peek(const blink::Member<T>& value) { return value; }
-
-  static void ConstructDeletedValue(blink::Member<T>& slot, bool) {
+  static void ConstructDeletedValue(MemberType& slot, bool) {
+#if BUILDFLAG(USE_V8_OILPAN)
+    slot = cppgc::kSentinelPointer;
+#else   // !USE_V8_OILPAN
     slot = WTF::kHashTableDeletedValue;
+#endif  // !USE_V8_OILPAN
+  }
+
+  static bool IsDeletedValue(const MemberType& value) {
+#if BUILDFLAG(USE_V8_OILPAN)
+    return value.Get() == cppgc::kSentinelPointer;
+#else   // !USE_V8_OILPAN
+    return value.IsHashTableDeletedValue();
+#endif  // !USE_V8_OILPAN
   }
+};
 
+template <typename T>
+struct HashTraits<blink::Member<T>>
+    : BaseMemberHashTraits<T, blink::Member<T>> {
   static constexpr bool kCanTraceConcurrently = true;
 };
 
 template <typename T>
 struct HashTraits<blink::WeakMember<T>>
-    : SimpleClassHashTraits<blink::WeakMember<T>> {
-  STATIC_ONLY(HashTraits);
-  static const bool kNeedsDestruction = false;
-  // FIXME: Implement proper const'ness for iterator types. Requires support
-  // in the marking Visitor.
-  using PeekInType = T*;
-  using IteratorGetType = blink::WeakMember<T>*;
-  using IteratorConstGetType = const blink::WeakMember<T>*;
-  using IteratorReferenceType = blink::WeakMember<T>&;
-  using IteratorConstReferenceType = const blink::WeakMember<T>&;
-  static IteratorReferenceType GetToReferenceConversion(IteratorGetType x) {
-    return *x;
-  }
-  static IteratorConstReferenceType GetToReferenceConstConversion(
-      IteratorConstGetType x) {
-    return *x;
-  }
-
-  using PeekOutType = T*;
-
-  template <typename U>
-  static void Store(const U& value, blink::WeakMember<T>& storage) {
-    storage = value;
-  }
-
-  static PeekOutType Peek(const blink::WeakMember<T>& value) { return value; }
-
-  static void ConstructDeletedValue(blink::WeakMember<T>& slot, bool) {
-    slot = WTF::kHashTableDeletedValue;
-  }
-
+    : BaseMemberHashTraits<T, blink::WeakMember<T>> {
   static constexpr bool kCanTraceConcurrently = true;
 };
 
 template <typename T>
 struct HashTraits<blink::UntracedMember<T>>
-    : SimpleClassHashTraits<blink::UntracedMember<T>> {
-  STATIC_ONLY(HashTraits);
-  static const bool kNeedsDestruction = false;
-  // FIXME: Implement proper const'ness for iterator types.
-  using PeekInType = T*;
-  using IteratorGetType = blink::UntracedMember<T>*;
-  using IteratorConstGetType = const blink::UntracedMember<T>*;
-  using IteratorReferenceType = blink::UntracedMember<T>&;
-  using IteratorConstReferenceType = const blink::UntracedMember<T>&;
-  static IteratorReferenceType GetToReferenceConversion(IteratorGetType x) {
-    return *x;
-  }
-  static IteratorConstReferenceType GetToReferenceConstConversion(
-      IteratorConstGetType x) {
-    return *x;
-  }
-  using PeekOutType = T*;
-
-  template <typename U>
-  static void Store(const U& value, blink::UntracedMember<T>& storage) {
-    storage = value;
-  }
-
-  static PeekOutType Peek(const blink::UntracedMember<T>& value) {
-    return value;
-  }
-};
+    : BaseMemberHashTraits<T, blink::UntracedMember<T>> {};
 
 }  // namespace WTF
 

third_party/blink/renderer/platform/heap/v8_wrapper/heap_allocator_impl.h

@@ -15,6 +15,100 @@ class PLATFORM_EXPORT HeapAllocator {
 
  public:
   static constexpr bool kIsGarbageCollected = true;
+
+  // See wtf/size_t.h for details.
+  static constexpr size_t kMaxHeapObjectSizeLog2 = 27;
+  static constexpr size_t kMaxHeapObjectSize = 1 << kMaxHeapObjectSizeLog2;
+
+  template <typename T>
+  static size_t MaxElementCountInBackingStore() {
+    return kMaxHeapObjectSize / sizeof(T);
+  }
+
+  template <typename T>
+  static size_t QuantizedSize(size_t count) {
+    CHECK_LE(count, MaxElementCountInBackingStore<T>());
+    // Oilpan's internal size is independent of MaxElementCountInBackingStore()
+    // and the required size to match capacity needs.
+    return count * sizeof(T);
+  }
+
+  template <typename T>
+  static T* AllocateVectorBacking(size_t) {
+    // TODO(1056170): Implement.
+    return nullptr;
+  }
+
+  static void FreeVectorBacking(void*) {
+    // TODO(1056170): Implement.
+  }
+
+  static bool ExpandVectorBacking(void*, size_t) {
+    // TODO(1056170): Implement.
+    return false;
+  }
+
+  static bool ShrinkVectorBacking(void*, size_t, size_t) {
+    // TODO(1056170): Implement.
+    return false;
+  }
+
+  template <typename T, typename HashTable>
+  static T* AllocateHashTableBacking(size_t) {
+    // TODO(1056170): Implement.
+    return nullptr;
+  }
+
+  template <typename T, typename HashTable>
+  static T* AllocateZeroedHashTableBacking(size_t size) {
+    return AllocateHashTableBacking<T, HashTable>(size);
+  }
+
+  static void FreeHashTableBacking(void*) {
+    // TODO(1056170): Implement.
+  }
+
+  static bool ExpandHashTableBacking(void*, size_t) {
+    // TODO(1056170): Implement.
+    return false;
+  }
+
+  static bool IsAllocationAllowed() {
+    // TODO(1056170): Implement.
+    return true;
+  }
+
+  static bool IsIncrementalMarking() {
+    // TODO(1056170): Implement.
+    return false;
+  }
+
+  static void EnterGCForbiddenScope() {
+    // TODO(1056170): Implement.
+  }
+
+  static void LeaveGCForbiddenScope() {
+    // TODO(1056170): Implement.
+  }
+
+  template <typename T>
+  static void BackingWriteBarrier(T**) {
+    // TODO(1056170): Implement.
+  }
+
+  static void TraceBackingStoreIfMarked(const void* object) {
+    // TODO(1056170): Implement.
+  }
+
+  template <typename T, typename Traits>
+  static void NotifyNewObject(T*) {
+    // TODO(1056170): Implement.
+  }
+
+  template <typename T, typename Traits>
+  static void NotifyNewObjects(T*, size_t) {
+    // TODO(1056170): Implement.
+  }
 };
 
 }  // namespace blink