1 files changed, 119 insertions, 4 deletions

diff --git a/deps/v8/src/heap/cppgc/heap.h b/deps/v8/src/heap/cppgc/heap.h
index baf70d8f4e4..fa19b74be53 100644
--- a/deps/v8/src/heap/cppgc/heap.h
+++ b/deps/v8/src/heap/cppgc/heap.h
@@ -5,28 +5,143 @@
 #ifndef V8_HEAP_CPPGC_HEAP_H_
 #define V8_HEAP_CPPGC_HEAP_H_
 
+#include <memory>
 #include <vector>
 
-#include "include/cppgc/gc-info.h"
 #include "include/cppgc/heap.h"
+#include "include/cppgc/internal/gc-info.h"
+#include "include/cppgc/internal/persistent-node.h"
+#include "include/cppgc/liveness-broker.h"
+#include "src/base/page-allocator.h"
 #include "src/heap/cppgc/heap-object-header.h"
+#include "src/heap/cppgc/marker.h"
+#include "src/heap/cppgc/object-allocator.h"
+#include "src/heap/cppgc/page-memory.h"
+#include "src/heap/cppgc/prefinalizer-handler.h"
+#include "src/heap/cppgc/raw-heap.h"
+#include "src/heap/cppgc/sweeper.h"
 
 namespace cppgc {
 namespace internal {
 
+class Stack;
+
+class V8_EXPORT_PRIVATE LivenessBrokerFactory {
+ public:
+  static LivenessBroker Create();
+};
+
 class V8_EXPORT_PRIVATE Heap final : public cppgc::Heap {
  public:
+  // NoGCScope allows going over limits and avoids triggering garbage
+  // collection triggered through allocations or even explicitly.
+  class V8_EXPORT_PRIVATE NoGCScope final {
+    CPPGC_STACK_ALLOCATED();
+
+   public:
+    explicit NoGCScope(Heap* heap);
+    ~NoGCScope();
+
+    NoGCScope(const NoGCScope&) = delete;
+    NoGCScope& operator=(const NoGCScope&) = delete;
+
+   private:
+    Heap* const heap_;
+  };
+
+  // NoAllocationScope is used in debug mode to catch unwanted allocations. E.g.
+  // allocations during GC.
+  class V8_EXPORT_PRIVATE NoAllocationScope final {
+    CPPGC_STACK_ALLOCATED();
+
+   public:
+    explicit NoAllocationScope(Heap* heap);
+    ~NoAllocationScope();
+
+    NoAllocationScope(const NoAllocationScope&) = delete;
+    NoAllocationScope& operator=(const NoAllocationScope&) = delete;
+
+   private:
+    Heap* const heap_;
+  };
+
+  struct GCConfig {
+    using StackState = Heap::StackState;
+
+    static GCConfig Default() { return {StackState::kMayContainHeapPointers}; }
+
+    StackState stack_state = StackState::kMayContainHeapPointers;
+  };
+
   static Heap* From(cppgc::Heap* heap) { return static_cast<Heap*>(heap); }
 
-  Heap() = default;
-  ~Heap() final = default;
+  explicit Heap(size_t custom_spaces);
+  ~Heap() final;
 
   inline void* Allocate(size_t size, GCInfoIndex index);
+  inline void* Allocate(size_t size, GCInfoIndex index,
+                        CustomSpaceIndex space_index);
 
-  void CollectGarbage();
+  void CollectGarbage(GCConfig config = GCConfig::Default());
+
+  PreFinalizerHandler* prefinalizer_handler() {
+    return prefinalizer_handler_.get();
+  }
+
+  PersistentRegion& GetStrongPersistentRegion() {
+    return strong_persistent_region_;
+  }
+  const PersistentRegion& GetStrongPersistentRegion() const {
+    return strong_persistent_region_;
+  }
+  PersistentRegion& GetWeakPersistentRegion() {
+    return weak_persistent_region_;
+  }
+  const PersistentRegion& GetWeakPersistentRegion() const {
+    return weak_persistent_region_;
+  }
+
+  RawHeap& raw_heap() { return raw_heap_; }
+  const RawHeap& raw_heap() const { return raw_heap_; }
+
+  Stack* stack() { return stack_.get(); }
+
+  PageBackend* page_backend() { return page_backend_.get(); }
+  const PageBackend* page_backend() const { return page_backend_.get(); }
+
+  Sweeper& sweeper() { return sweeper_; }
+
+  size_t epoch() const { return epoch_; }
+
+  size_t ObjectPayloadSize() const;
+
+  // Temporary getter until proper visitation of on-stack objects is
+  // implemented.
+  std::vector<HeapObjectHeader*>& objects() { return objects_; }
 
  private:
+  bool in_no_gc_scope() const { return no_gc_scope_ > 0; }
+  bool is_allocation_allowed() const { return no_allocation_scope_ == 0; }
+
+  RawHeap raw_heap_;
+
+  v8::base::PageAllocator system_allocator_;
+  std::unique_ptr<PageBackend> page_backend_;
+  ObjectAllocator object_allocator_;
+  Sweeper sweeper_;
+
+  std::unique_ptr<Stack> stack_;
+  std::unique_ptr<PreFinalizerHandler> prefinalizer_handler_;
+  std::unique_ptr<Marker> marker_;
   std::vector<HeapObjectHeader*> objects_;
+
+  PersistentRegion strong_persistent_region_;
+  PersistentRegion weak_persistent_region_;
+
+  size_t epoch_ = 0;
+
+  size_t no_gc_scope_ = 0;
+  size_t no_allocation_scope_ = 0;
 };
 
 }  // namespace internal