[cctest] Add tests for aborting compaction of pages

src/heap/spaces.h

 // Copyright 2011 the V8 project 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 V8_HEAP_SPACES_H_
 #define V8_HEAP_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/atomic-utils.h"
 #include "src/base/atomicops.h"
@@ skipping 2112 matching lines @@
 
   // If sweeping is still in progress try to sweep unswept pages. If that is
   // not successful, wait for the sweeper threads and re-try free-list
   // allocation.
   MUST_USE_RESULT virtual HeapObject* SweepAndRetryAllocation(
       int size_in_bytes);
 
   // Slow path of AllocateRaw.  This function is space-dependent.
   MUST_USE_RESULT HeapObject* SlowAllocateRaw(int size_in_bytes);
 
+  virtual bool ShouldForceOOM() { return force_oom_; }
+
+  void SetForcedOOM(bool value) { force_oom_ = value; }
+
   int area_size_;
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   FreeList free_list_;
 
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
   // The sweeper threads iterate over the list of pointer and data space pages
   // and sweep these pages concurrently. They will stop sweeping after the
   // end_of_unswept_pages_ page.
   Page* end_of_unswept_pages_;
 
   // Mutex guarding any concurrent access to the space.
   base::Mutex space_mutex_;
 
+  bool force_oom_;
+
+  friend class CompactionSpace;
   friend class MarkCompactCollector;
   friend class PageIterator;
 
   // Used in cctest.
   friend class HeapTester;
 };
 
 
 class NumberAndSizeInfo BASE_EMBEDDED {
  public:
@@ skipping 750 matching lines @@
   bool is_local() override { return true; }
 
   void RefillFreeList() override;
 
  protected:
   // The space is temporary and not included in any snapshots.
   bool snapshotable() override { return false; }
 
   MUST_USE_RESULT HeapObject* SweepAndRetryAllocation(
       int size_in_bytes) override;
+
+  bool ShouldForceOOM() override;
 };
 
 
 // A collection of |CompactionSpace|s used by a single compaction task.
 class CompactionSpaceCollection : public Malloced {
  public:
   explicit CompactionSpaceCollection(Heap* heap)
       : old_space_(heap, OLD_SPACE, Executability::NOT_EXECUTABLE),
         code_space_(heap, CODE_SPACE, Executability::EXECUTABLE),
         duration_(0.0),
@@ skipping 220 matching lines @@
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_H_