wtf: Build traits based on cppgc for when using Oilpan library

Currently WTF uses forward declarations to define basic GC traits that
are used throughout WTF and Blink globally, i.e., without any specific
context or other traits being available. This is an implicit
dependency on blink.

With Oilpan throuhg V8, we make this dependency a header-only
dependency that is explicit which allows to re-use existing traits
from the library to define the WTF equivalents.

Change-Id: I3995c0d587424299ed880adcd5ac848a635e4f1e
Bug: chromium:1056170
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2532236
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#826397}

third_party/blink/renderer/platform/heap/impl/heap_allocator.h

@@ -346,11 +346,6 @@ namespace internal {
 template <typename T>
 constexpr bool IsMember = WTF::IsSubclassOfTemplate<T, Member>::value;
 
-template <typename T>
-constexpr bool IsMemberOrWeakMemberType =
-    WTF::IsSubclassOfTemplate<T, Member>::value ||
-    WTF::IsSubclassOfTemplate<T, WeakMember>::value;
-
 }  // namespace internal
 
 template <typename KeyArg,
@@ -380,11 +375,11 @@ class HeapHashMap : public HashMap<KeyArg,
         WTF::IsTraceable<KeyArg>::value || WTF::IsTraceable<MappedArg>::value,
         "For hash maps without traceable elements, use HashMap<> "
         "instead of HeapHashMap<>.");
-    static_assert(internal::IsMemberOrWeakMemberType<KeyArg> ||
+    static_assert(WTF::IsMemberOrWeakMemberType<KeyArg>::value ||
                       !WTF::IsTraceable<KeyArg>::value,
                   "HeapHashMap supports only Member, WeakMember and "
                   "non-traceable types as keys.");
-    static_assert(internal::IsMemberOrWeakMemberType<MappedArg> ||
+    static_assert(WTF::IsMemberOrWeakMemberType<MappedArg>::value ||
                       !WTF::IsTraceable<MappedArg>::value ||
                       WTF::IsSubclassOfTemplate<MappedArg,
                                                 TraceWrapperV8Reference>::value,
@@ -417,7 +412,7 @@ class HeapHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
+    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
                   "HeapHashSet supports only Member and WeakMember.");
     static_assert(std::is_trivially_destructible<HeapHashSet>::value,
                   "HeapHashSet must be trivially destructible.");
@@ -450,7 +445,7 @@ class HeapLinkedHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
+    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
                   "HeapLinkedHashSet supports only Member and WeakMember.");
     // If not trivially destructible, we have to add a destructor which will
     // hinder performance.
@@ -490,7 +485,7 @@ class HeapListHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
+    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
                   "HeapListHashSet supports only Member and WeakMember.");
     static_assert(std::is_trivially_destructible<HeapListHashSet>::value,
                   "HeapListHashSet must be trivially destructible.");
@@ -529,7 +524,7 @@ class HeapHashCountedSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(internal::IsMemberOrWeakMemberType<Value>,
+    static_assert(WTF::IsMemberOrWeakMemberType<Value>::value,
                   "HeapHashCountedSet supports only Member and WeakMember.");
     static_assert(std::is_trivially_destructible<HeapHashCountedSet>::value,
                   "HeapHashCountedSet must be trivially destructible.");

third_party/blink/renderer/platform/wtf/BUILD.gn

@@ -4,10 +4,19 @@
 
 assert(!is_ios)
 
+import("//build/buildflag_header.gni")
 import("//build/config/compiler/compiler.gni")
 import("//testing/test.gni")
+import("//third_party/blink/public/public_features.gni")
 import("//third_party/blink/renderer/config.gni")
 
+buildflag_header("buildflags") {
+  header = "buildflags.h"
+  header_dir = "third_party/blink/renderer/platform/wtf"
+
+  flags = [ "USE_V8_OILPAN=$enable_blink_heap_use_v8_oilpan" ]
+}
+
 visibility = [
   ":*",
   "//mojo/public/cpp/bindings/*",
@@ -201,8 +210,12 @@ component("wtf") {
     "//third_party/blink/renderer:features",
   ]
 
+  deps = [
+    ":buildflags",
+
     # TODO(tkent): WTF should not depend on it.
-  deps = [ "//third_party/blink/public/common:headers" ]
+    "//third_party/blink/public/common:headers",
+  ]
 
   public_deps = [
     "//base",
@@ -211,6 +224,10 @@ component("wtf") {
     "//third_party/icu",
   ]
 
+  if (enable_blink_heap_use_v8_oilpan) {
+    public_deps += [ "//v8:cppgc" ]
+  }
+
   # Rules changing the |sources| list are temporarily commented out, until
   # those files are actually moved to here.
 

third_party/blink/renderer/platform/wtf/DEPS

@@ -32,4 +32,6 @@ include_rules = [
     "-third_party/blink/renderer/platform",
     "+third_party/blink/renderer/platform/wtf",
     "-v8",
+    # Allow pulling in cppgc for Oilpan use.
+    "+v8/include/cppgc",
 ]

third_party/blink/renderer/platform/wtf/functional.h

@@ -36,13 +36,6 @@
 #include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
 #include "third_party/blink/renderer/platform/wtf/type_traits.h"
 
-namespace blink {
-template <typename T>
-class Member;
-template <typename T>
-class WeakMember;
-}
-
 namespace WTF {
 
 // Functional.h provides a very simple way to bind a function pointer and
@@ -200,8 +193,7 @@ struct CheckGCedTypeRestriction {
                 "it with either WrapPersistent, WrapWeakPersistent, "
                 "WrapCrossThreadPersistent, WrapCrossThreadWeakPersistent, "
                 "RefPtr or unretained.");
-  static_assert(!IsSubclassOfTemplate<T, blink::Member>::value &&
-                    !IsSubclassOfTemplate<T, blink::WeakMember>::value,
+  static_assert(!WTF::IsMemberOrWeakMemberType<T>::value,
                 "Member and WeakMember are not allowed to bind into "
                 "WTF::Function. Wrap it with either WrapPersistent, "
                 "WrapWeakPersistent, WrapCrossThreadPersistent or "

third_party/blink/renderer/platform/wtf/type_traits.h

@@ -28,6 +28,19 @@
 #include "base/compiler_specific.h"
 #include "base/template_util.h"
 #include "build/build_config.h"
+#include "third_party/blink/renderer/platform/wtf/buildflags.h"
+
+#if BUILDFLAG(USE_V8_OILPAN)
+#include "v8/include/cppgc/type-traits.h"  // nogncheck
+#else
+namespace blink {
+template <typename T>
+class Member;
+class Visitor;
+template <typename T>
+class WeakMember;
+}  // namespace blink
+#endif  // BUILDFLAG(BLINK_HEAP_USE_V8_OILPAN)
 
 namespace WTF {
 
@@ -37,24 +50,6 @@ inline const char* GetStringWithTypeName() {
   return PRETTY_FUNCTION;
 }
 
-// Specifies whether a type should be treated weakly by the memory management
-// system. Only supported by the garbage collector and not by PartitionAlloc.
-// Requires garbage collection support, so it is only safe to  override in sync
-// with changing garbage collection semantics.
-template <typename T>
-struct IsWeak : std::false_type {};
-
-enum WeakHandlingFlag {
-  kNoWeakHandling,
-  kWeakHandling,
-};
-
-template <typename T>
-struct WeakHandlingTrait
-    : std::integral_constant<WeakHandlingFlag,
-                             IsWeak<T>::value ? kWeakHandling
-                                              : kNoWeakHandling> {};
-
 template <typename T, typename U>
 struct IsSubclass {
  private:
@@ -122,15 +117,24 @@ struct IsSubclassOfTemplateTypenameSizeTypename {
   static const bool value = sizeof(SubclassCheck(t_)) == sizeof(YesType);
 };
 
-}  // namespace WTF
+#if BUILDFLAG(USE_V8_OILPAN)
 
-namespace blink {
+template <typename T>
+struct IsTraceable : cppgc::internal::IsTraceable<T> {};
 
-class Visitor;
+template <typename T>
+struct IsGarbageCollectedType : cppgc::internal::IsGarbageCollectedType<T> {};
 
-}  // namespace blink
+template <typename T>
+struct IsWeak : cppgc::internal::IsWeak<T> {};
 
-namespace WTF {
+template <typename T>
+struct IsMemberOrWeakMemberType
+    : std::integral_constant<bool,
+                             cppgc::IsMemberTypeV<T> ||
+                                 cppgc::IsWeakMemberTypeV<T>> {};
+
+#else  // !USE_V8_OILPAN
 
 namespace internal {
 // IsTraceMethodConst is used to verify that all Trace methods are marked as
@@ -168,33 +172,6 @@ struct IsTraceable<std::pair<T, U>>
     : std::integral_constant<bool,
                              IsTraceable<T>::value || IsTraceable<U>::value> {};
 
-// Convenience template wrapping the IsTraceableInCollection template in
-// Collection Traits. It helps make the code more readable.
-template <typename Traits>
-struct IsTraceableInCollectionTrait
-    : std::integral_constant<
-          bool,
-          Traits::template IsTraceableInCollection<>::value> {};
-
-// This is used to check that DISALLOW_NEW objects are not
-// stored in off-heap Vectors, HashTables etc.
-template <typename T>
-struct IsDisallowNew {
- private:
-  using YesType = char;
-  struct NoType {
-    char padding[8];
-  };
-
-  template <typename U>
-  static YesType CheckMarker(typename U::IsDisallowNewMarker*);
-  template <typename U>
-  static NoType CheckMarker(...);
-
- public:
-  static const bool value = sizeof(CheckMarker<T>(nullptr)) == sizeof(YesType);
-};
-
 template <typename T>
 class IsGarbageCollectedTypeInternal {
   typedef char YesType;
@@ -235,6 +212,60 @@ class IsGarbageCollectedType : public IsGarbageCollectedTypeInternal<T> {
   static_assert(sizeof(T), "T must be fully defined");
 };
 
+// Specifies whether a type should be treated weakly by the memory management
+// system. Only supported by the garbage collector and not by PartitionAlloc.
+// Requires garbage collection support, so it is only safe to  override in sync
+// with changing garbage collection semantics.
+template <typename T>
+struct IsWeak : std::false_type {};
+
+template <typename T>
+struct IsMemberOrWeakMemberType
+    : std::integral_constant<
+          bool,
+          WTF::IsSubclassOfTemplate<T, blink::Member>::value ||
+              WTF::IsSubclassOfTemplate<T, blink::WeakMember>::value> {};
+
+#endif  // !USE_V8_OILPAN
+
+// Convenience template wrapping the IsTraceableInCollection template in
+// Collection Traits. It helps make the code more readable.
+template <typename Traits>
+struct IsTraceableInCollectionTrait
+    : std::integral_constant<
+          bool,
+          Traits::template IsTraceableInCollection<>::value> {};
+
+enum WeakHandlingFlag {
+  kNoWeakHandling,
+  kWeakHandling,
+};
+
+template <typename T>
+struct WeakHandlingTrait
+    : std::integral_constant<WeakHandlingFlag,
+                             IsWeak<T>::value ? kWeakHandling
+                                              : kNoWeakHandling> {};
+
+// This is used to check that DISALLOW_NEW objects are not
+// stored in off-heap Vectors, HashTables etc.
+template <typename T>
+struct IsDisallowNew {
+ private:
+  using YesType = char;
+  struct NoType {
+    char padding[8];
+  };
+
+  template <typename U>
+  static YesType CheckMarker(typename U::IsDisallowNewMarker*);
+  template <typename U>
+  static NoType CheckMarker(...);
+
+ public:
+  static const bool value = sizeof(CheckMarker<T>(nullptr)) == sizeof(YesType);
+};
+
 template <>
 class IsGarbageCollectedType<void> {
  public: