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

This reverts commit d22a4cef.

Reason for revert: build failure:

https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket.appspot.com/8863899624870692272/+/steps/compile/0/stdout

Original change's description:
> 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}

TBR=haraken@chromium.org,mlippautz@chromium.org

Change-Id: Ifaf0414b054fd37de410acfd8ced1a5814e04232
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:1056170
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2532729Reviewed-by: James MacLean <wjmaclean@chromium.org>
Commit-Queue: James MacLean <wjmaclean@chromium.org>
Cr-Commit-Position: refs/heads/master@{#826406}

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

@@ -346,6 +346,11 @@ 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,
@@ -375,11 +380,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(WTF::IsMemberOrWeakMemberType<KeyArg>::value ||
+    static_assert(internal::IsMemberOrWeakMemberType<KeyArg> ||
                       !WTF::IsTraceable<KeyArg>::value,
                   "HeapHashMap supports only Member, WeakMember and "
                   "non-traceable types as keys.");
-    static_assert(WTF::IsMemberOrWeakMemberType<MappedArg>::value ||
+    static_assert(internal::IsMemberOrWeakMemberType<MappedArg> ||
                       !WTF::IsTraceable<MappedArg>::value ||
                       WTF::IsSubclassOfTemplate<MappedArg,
                                                 TraceWrapperV8Reference>::value,
@@ -412,7 +417,7 @@ class HeapHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
+    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
                   "HeapHashSet supports only Member and WeakMember.");
     static_assert(std::is_trivially_destructible<HeapHashSet>::value,
                   "HeapHashSet must be trivially destructible.");
@@ -445,7 +450,7 @@ class HeapLinkedHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
+    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
                   "HeapLinkedHashSet supports only Member and WeakMember.");
     // If not trivially destructible, we have to add a destructor which will
     // hinder performance.
@@ -485,7 +490,7 @@ class HeapListHashSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(WTF::IsMemberOrWeakMemberType<ValueArg>::value,
+    static_assert(internal::IsMemberOrWeakMemberType<ValueArg>,
                   "HeapListHashSet supports only Member and WeakMember.");
     static_assert(std::is_trivially_destructible<HeapListHashSet>::value,
                   "HeapListHashSet must be trivially destructible.");
@@ -524,7 +529,7 @@ class HeapHashCountedSet
   DISALLOW_NEW();
 
   static void CheckType() {
-    static_assert(WTF::IsMemberOrWeakMemberType<Value>::value,
+    static_assert(internal::IsMemberOrWeakMemberType<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,19 +4,10 @@
 
 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/*",
@@ -210,12 +201,8 @@ component("wtf") {
     "//third_party/blink/renderer:features",
   ]
 
-  deps = [
-    ":buildflags",
-
-    # TODO(tkent): WTF should not depend on it.
-    "//third_party/blink/public/common:headers",
-  ]
+  # TODO(tkent): WTF should not depend on it.
+  deps = [ "//third_party/blink/public/common:headers" ]
 
   public_deps = [
     "//base",
@@ -224,10 +211,6 @@ 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,6 +32,4 @@ 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,6 +36,13 @@
 #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
@@ -193,7 +200,8 @@ struct CheckGCedTypeRestriction {
                 "it with either WrapPersistent, WrapWeakPersistent, "
                 "WrapCrossThreadPersistent, WrapCrossThreadWeakPersistent, "
                 "RefPtr or unretained.");
-  static_assert(!WTF::IsMemberOrWeakMemberType<T>::value,
+  static_assert(!IsSubclassOfTemplate<T, blink::Member>::value &&
+                    !IsSubclassOfTemplate<T, blink::WeakMember>::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,19 +28,6 @@
 #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 {
 
@@ -50,6 +37,24 @@ 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:
@@ -117,24 +122,15 @@ struct IsSubclassOfTemplateTypenameSizeTypename {
   static const bool value = sizeof(SubclassCheck(t_)) == sizeof(YesType);
 };
 
-#if BUILDFLAG(USE_V8_OILPAN)
-
-template <typename T>
-struct IsTraceable : cppgc::internal::IsTraceable<T> {};
+}  // namespace WTF
 
-template <typename T>
-struct IsGarbageCollectedType : cppgc::internal::IsGarbageCollectedType<T> {};
+namespace blink {
 
-template <typename T>
-struct IsWeak : cppgc::internal::IsWeak<T> {};
+class Visitor;
 
-template <typename T>
-struct IsMemberOrWeakMemberType
-    : std::integral_constant<bool,
-                             cppgc::IsMemberTypeV<T> ||
-                                 cppgc::IsWeakMemberTypeV<T>> {};
+}  // namespace blink
 
-#else  // !USE_V8_OILPAN
+namespace WTF {
 
 namespace internal {
 // IsTraceMethodConst is used to verify that all Trace methods are marked as
@@ -172,6 +168,33 @@ 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;
@@ -212,60 +235,6 @@ 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: