heap: Separate out tests for the Oilpan library

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

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

@@ -193,10 +193,19 @@ blink_platform_sources("heap") {
 source_set("test_support") {
   testonly = true
 
-  sources = [
-    "heap_test_utilities.cc",
-    "heap_test_utilities.h",
-  ]
+  sources = [ "heap_test_utilities.h" ]
+
+  if (enable_blink_heap_use_v8_oilpan) {
+    sources += [
+      "v8_wrapper/heap_test_utilities.cc",
+      "v8_wrapper/heap_test_utilities.h",
+    ]
+  } else {
+    sources += [
+      "impl/heap_test_utilities.cc",
+      "impl/heap_test_utilities.h",
+    ]
+  }
 
   deps = [
     ":blink_heap_buildflags",
@@ -223,32 +232,36 @@ test("blink_heap_unittests") {
 
 source_set("blink_heap_unittests_sources") {
   testonly = true
-  sources = [
-    "../testing/run_all_tests.cc",
-    "test/blink_gc_memory_dump_provider_test.cc",
-    "test/card_table_test.cc",
-    "test/concurrent_marking_test.cc",
-    "test/gc_info_test.cc",
-    "test/heap_compact_test.cc",
-    "test/heap_linked_stack_test.cc",
-    "test/heap_stats_collector_test.cc",
-    "test/heap_test.cc",
-    "test/heap_thread_test.cc",
-    "test/heap_traits_test.cc",
-    "test/incremental_marking_test.cc",
-    "test/marking_scheduling_oracle_test.cc",
-    "test/marking_verifier_test.cc",
-    "test/name_trait_test.cc",
-    "test/object_start_bitmap_test.cc",
-    "test/persistent_test.cc",
-    "test/thread_state_scheduling_test.cc",
-    "test/weakness_marking_test.cc",
-    "test/worklist_test.cc",
-    "test/write_barrier_perftest.cc",
-  ]
 
-  if (enable_blink_heap_young_generation) {
-    sources += [ "test/minor_gc_test.cc" ]
+  sources = [ "../testing/run_all_tests.cc" ]
+
+  if (!enable_blink_heap_use_v8_oilpan) {
+    sources += [
+      "test/blink_gc_memory_dump_provider_test.cc",
+      "test/card_table_test.cc",
+      "test/concurrent_marking_test.cc",
+      "test/gc_info_test.cc",
+      "test/heap_compact_test.cc",
+      "test/heap_linked_stack_test.cc",
+      "test/heap_stats_collector_test.cc",
+      "test/heap_test.cc",
+      "test/heap_thread_test.cc",
+      "test/heap_traits_test.cc",
+      "test/incremental_marking_test.cc",
+      "test/marking_scheduling_oracle_test.cc",
+      "test/marking_verifier_test.cc",
+      "test/name_trait_test.cc",
+      "test/object_start_bitmap_test.cc",
+      "test/persistent_test.cc",
+      "test/thread_state_scheduling_test.cc",
+      "test/weakness_marking_test.cc",
+      "test/worklist_test.cc",
+      "test/write_barrier_perftest.cc",
+    ]
+
+    if (enable_blink_heap_young_generation) {
+      sources += [ "test/minor_gc_test.cc" ]
+    }
   }
 
   configs += [

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

-/*
- * Copyright 2017 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.
- */
+// Copyright 2021 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.
 
 #ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_UTILITIES_H_
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_UTILITIES_H_
 
-#include "base/callback.h"
-#include "base/test/task_environment.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/renderer/platform/heap/blink_gc.h"
-#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
-#include "third_party/blink/renderer/platform/heap/handle.h"
-#include "third_party/blink/renderer/platform/heap/heap.h"
-#include "third_party/blink/renderer/platform/heap/impl/trace_traits.h"
-#include "third_party/blink/renderer/platform/heap/visitor.h"
+#include "third_party/blink/renderer/platform/wtf/buildflags.h"
 
-namespace blink {
-
-class TestSupportingGC : public testing::Test {
- public:
-  // Performs a precise garbage collection with eager sweeping.
-  static void PreciselyCollectGarbage(
-      BlinkGC::SweepingType sweeping_type = BlinkGC::kEagerSweeping);
-
-  // Performs a conservative garbage collection.
-  static void ConservativelyCollectGarbage(
-      BlinkGC::SweepingType sweeping_type = BlinkGC::kEagerSweeping);
-
-  ~TestSupportingGC() override;
-
-  // Performs multiple rounds of garbage collections until no more memory can be
-  // freed. This is useful to avoid other garbage collections having to deal
-  // with stale memory.
-  void ClearOutOldGarbage();
-
-  // Completes sweeping if it is currently running.
-  void CompleteSweepingIfNeeded();
-
- protected:
-  base::test::TaskEnvironment task_environment_;
-};
-
-template <typename T>
-class ObjectWithCallbackBeforeInitializer
-    : public GarbageCollected<ObjectWithCallbackBeforeInitializer<T>> {
- public:
-  ObjectWithCallbackBeforeInitializer(
-      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb,
-      T* value)
-      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
-
-  ObjectWithCallbackBeforeInitializer(
-      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb)
-      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
-
-  virtual void Trace(Visitor* visitor) const { visitor->Trace(value_); }
-
-  T* value() const { return value_.Get(); }
-
- private:
-  static bool ExecuteCallbackReturnTrue(
-      ObjectWithCallbackBeforeInitializer* thiz,
-      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb) {
-    std::move(cb).Run(thiz);
-    return true;
-  }
-
-  bool bool_;
-  Member<T> value_;
-};
-
-template <typename T>
-class MixinWithCallbackBeforeInitializer : public GarbageCollectedMixin {
- public:
-  MixinWithCallbackBeforeInitializer(
-      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb,
-      T* value)
-      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
-
-  MixinWithCallbackBeforeInitializer(
-      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb)
-      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
-
-  void Trace(Visitor* visitor) const override { visitor->Trace(value_); }
-
-  T* value() const { return value_.Get(); }
-
- private:
-  static bool ExecuteCallbackReturnTrue(
-      MixinWithCallbackBeforeInitializer* thiz,
-      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb) {
-    std::move(cb).Run(thiz);
-    return true;
-  }
-
-  bool bool_;
-  Member<T> value_;
-};
-
-class BoolMixin {
- protected:
-  bool bool_ = false;
-};
-
-template <typename T>
-class ObjectWithMixinWithCallbackBeforeInitializer
-    : public GarbageCollected<ObjectWithMixinWithCallbackBeforeInitializer<T>>,
-      public BoolMixin,
-      public MixinWithCallbackBeforeInitializer<T> {
- public:
-  using Mixin = MixinWithCallbackBeforeInitializer<T>;
-
-  ObjectWithMixinWithCallbackBeforeInitializer(
-      base::OnceCallback<void(Mixin*)>&& cb,
-      T* value)
-      : Mixin(std::move(cb), value) {}
-
-  ObjectWithMixinWithCallbackBeforeInitializer(
-      base::OnceCallback<void(Mixin*)>&& cb)
-      : Mixin(std::move(cb)) {}
-
-  void Trace(Visitor* visitor) const override { Mixin::Trace(visitor); }
-};
-
-// Simple linked object to be used in tests.
-class LinkedObject : public GarbageCollected<LinkedObject> {
- public:
-  LinkedObject() = default;
-  explicit LinkedObject(LinkedObject* next) : next_(next) {}
-
-  void set_next(LinkedObject* next) { next_ = next; }
-  LinkedObject* next() const { return next_; }
-  Member<LinkedObject>& next_ref() { return next_; }
-
-  virtual void Trace(Visitor* visitor) const { visitor->Trace(next_); }
-
- private:
-  Member<LinkedObject> next_;
-};
-
-// Test driver for incremental marking. Assumes that no stack handling is
-// required.
-class IncrementalMarkingTestDriver {
- public:
-  explicit IncrementalMarkingTestDriver(ThreadState* thread_state)
-      : thread_state_(thread_state) {}
-  ~IncrementalMarkingTestDriver();
-
-  void Start();
-  bool SingleStep(BlinkGC::StackState stack_state =
-                      BlinkGC::StackState::kNoHeapPointersOnStack);
-  void FinishSteps(BlinkGC::StackState stack_state =
-                       BlinkGC::StackState::kNoHeapPointersOnStack);
-  void FinishGC(bool complete_sweep = true);
-
-  // Methods for forcing a concurrent marking step without any assistance from
-  // mutator thread (i.e. without incremental marking on the mutator thread).
-  bool SingleConcurrentStep(BlinkGC::StackState stack_state =
-                                BlinkGC::StackState::kNoHeapPointersOnStack);
-  void FinishConcurrentSteps(BlinkGC::StackState stack_state =
-                                 BlinkGC::StackState::kNoHeapPointersOnStack);
-
-  size_t GetHeapCompactLastFixupCount() const;
-
- private:
-  ThreadState* const thread_state_;
-};
-
-class IntegerObject : public GarbageCollected<IntegerObject> {
- public:
-  static std::atomic_int destructor_calls;
-
-  explicit IntegerObject(int x) : x_(x) {}
-
-  virtual ~IntegerObject() {
-    destructor_calls.fetch_add(1, std::memory_order_relaxed);
-  }
-
-  virtual void Trace(Visitor* visitor) const {}
-
-  int Value() const { return x_; }
-
-  bool operator==(const IntegerObject& other) const {
-    return other.Value() == Value();
-  }
-
-  unsigned GetHash() { return IntHash<int>::GetHash(x_); }
-
- private:
-  int x_;
-};
-
-struct IntegerObjectHash {
-  static unsigned GetHash(const IntegerObject& key) {
-    return WTF::HashInt(static_cast<uint32_t>(key.Value()));
-  }
-
-  static bool Equal(const IntegerObject& a, const IntegerObject& b) {
-    return a == b;
-  }
-};
-
-}  // namespace blink
+#if BUILDFLAG(USE_V8_OILPAN)
+#include "third_party/blink/renderer/platform/heap/v8_wrapper/heap_test_utilities.h"
+#else  // !USE_V8_OILPAN
+#include "third_party/blink/renderer/platform/heap/impl/heap_test_utilities.h"
+#endif  // !USE_V8_OILPAN
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_UTILITIES_H_

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

+/*
+ * Copyright 2017 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.
+ */
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_HEAP_TEST_UTILITIES_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_HEAP_TEST_UTILITIES_H_
+
+#include "base/callback.h"
+#include "base/test/task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/platform/heap/blink_gc.h"
+#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
+#include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/heap/heap.h"
+#include "third_party/blink/renderer/platform/heap/impl/trace_traits.h"
+#include "third_party/blink/renderer/platform/heap/visitor.h"
+
+namespace blink {
+
+class TestSupportingGC : public testing::Test {
+ public:
+  // Performs a precise garbage collection with eager sweeping.
+  static void PreciselyCollectGarbage(
+      BlinkGC::SweepingType sweeping_type = BlinkGC::kEagerSweeping);
+
+  // Performs a conservative garbage collection.
+  static void ConservativelyCollectGarbage(
+      BlinkGC::SweepingType sweeping_type = BlinkGC::kEagerSweeping);
+
+  ~TestSupportingGC() override;
+
+  // Performs multiple rounds of garbage collections until no more memory can be
+  // freed. This is useful to avoid other garbage collections having to deal
+  // with stale memory.
+  void ClearOutOldGarbage();
+
+  // Completes sweeping if it is currently running.
+  void CompleteSweepingIfNeeded();
+
+ protected:
+  base::test::TaskEnvironment task_environment_;
+};
+
+template <typename T>
+class ObjectWithCallbackBeforeInitializer
+    : public GarbageCollected<ObjectWithCallbackBeforeInitializer<T>> {
+ public:
+  ObjectWithCallbackBeforeInitializer(
+      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb,
+      T* value)
+      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
+
+  ObjectWithCallbackBeforeInitializer(  // NOLINT
+      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb)
+      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
+
+  virtual void Trace(Visitor* visitor) const { visitor->Trace(value_); }
+
+  T* value() const { return value_.Get(); }
+
+ private:
+  static bool ExecuteCallbackReturnTrue(
+      ObjectWithCallbackBeforeInitializer* thiz,
+      base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb) {
+    std::move(cb).Run(thiz);
+    return true;
+  }
+
+  bool bool_;
+  Member<T> value_;
+};
+
+template <typename T>
+class MixinWithCallbackBeforeInitializer : public GarbageCollectedMixin {
+ public:
+  MixinWithCallbackBeforeInitializer(
+      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb,
+      T* value)
+      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
+
+  MixinWithCallbackBeforeInitializer(  // NOLINT
+      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb)
+      : bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
+
+  void Trace(Visitor* visitor) const override { visitor->Trace(value_); }
+
+  T* value() const { return value_.Get(); }
+
+ private:
+  static bool ExecuteCallbackReturnTrue(
+      MixinWithCallbackBeforeInitializer* thiz,
+      base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb) {
+    std::move(cb).Run(thiz);
+    return true;
+  }
+
+  bool bool_;
+  Member<T> value_;
+};
+
+class BoolMixin {
+ protected:
+  bool bool_ = false;
+};
+
+template <typename T>
+class ObjectWithMixinWithCallbackBeforeInitializer
+    : public GarbageCollected<ObjectWithMixinWithCallbackBeforeInitializer<T>>,
+      public BoolMixin,
+      public MixinWithCallbackBeforeInitializer<T> {
+ public:
+  using Mixin = MixinWithCallbackBeforeInitializer<T>;
+
+  ObjectWithMixinWithCallbackBeforeInitializer(
+      base::OnceCallback<void(Mixin*)>&& cb,
+      T* value)
+      : Mixin(std::move(cb), value) {}
+
+  ObjectWithMixinWithCallbackBeforeInitializer(  // NOLINT
+      base::OnceCallback<void(Mixin*)>&& cb)
+      : Mixin(std::move(cb)) {}
+
+  void Trace(Visitor* visitor) const override { Mixin::Trace(visitor); }
+};
+
+// Simple linked object to be used in tests.
+class LinkedObject : public GarbageCollected<LinkedObject> {
+ public:
+  LinkedObject() = default;
+  explicit LinkedObject(LinkedObject* next) : next_(next) {}
+
+  void set_next(LinkedObject* next) { next_ = next; }
+  LinkedObject* next() const { return next_; }
+  Member<LinkedObject>& next_ref() { return next_; }
+
+  virtual void Trace(Visitor* visitor) const { visitor->Trace(next_); }
+
+ private:
+  Member<LinkedObject> next_;
+};
+
+// Test driver for incremental marking. Assumes that no stack handling is
+// required.
+class IncrementalMarkingTestDriver {
+ public:
+  explicit IncrementalMarkingTestDriver(ThreadState* thread_state)
+      : thread_state_(thread_state) {}
+  ~IncrementalMarkingTestDriver();
+
+  void Start();
+  bool SingleStep(BlinkGC::StackState stack_state =
+                      BlinkGC::StackState::kNoHeapPointersOnStack);
+  void FinishSteps(BlinkGC::StackState stack_state =
+                       BlinkGC::StackState::kNoHeapPointersOnStack);
+  void FinishGC(bool complete_sweep = true);
+
+  // Methods for forcing a concurrent marking step without any assistance from
+  // mutator thread (i.e. without incremental marking on the mutator thread).
+  bool SingleConcurrentStep(BlinkGC::StackState stack_state =
+                                BlinkGC::StackState::kNoHeapPointersOnStack);
+  void FinishConcurrentSteps(BlinkGC::StackState stack_state =
+                                 BlinkGC::StackState::kNoHeapPointersOnStack);
+
+  size_t GetHeapCompactLastFixupCount() const;
+
+ private:
+  ThreadState* const thread_state_;
+};
+
+class IntegerObject : public GarbageCollected<IntegerObject> {
+ public:
+  static std::atomic_int destructor_calls;
+
+  explicit IntegerObject(int x) : x_(x) {}
+
+  virtual ~IntegerObject() {
+    destructor_calls.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  virtual void Trace(Visitor* visitor) const {}
+
+  int Value() const { return x_; }
+
+  bool operator==(const IntegerObject& other) const {
+    return other.Value() == Value();
+  }
+
+  unsigned GetHash() { return IntHash<int>::GetHash(x_); }
+
+ private:
+  int x_;
+};
+
+struct IntegerObjectHash {
+  static unsigned GetHash(const IntegerObject& key) {
+    return WTF::HashInt(static_cast<uint32_t>(key.Value()));
+  }
+
+  static bool Equal(const IntegerObject& a, const IntegerObject& b) {
+    return a == b;
+  }
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_HEAP_TEST_UTILITIES_H_

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

+// Copyright 2021 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_V8_WRAPPER_HEAP_TEST_UTILITIES_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_V8_WRAPPER_HEAP_TEST_UTILITIES_H_
+
+// TODO(chromium:1056170): Implement wrapper.
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_V8_WRAPPER_HEAP_TEST_UTILITIES_H_