Address ThreadHeap::willObjectBeLazilySwept() corner case.

third_party/WebKit/Source/platform/heap/HeapPage.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 476 matching lines @@
 #endif
     size_t size() override { return blinkPageSize; }
     static size_t pageHeaderSize()
     {
         // Compute the amount of padding we have to add to a header to make
         // the size of the header plus the padding a multiple of 8 bytes.
         size_t paddingSize = (sizeof(NormalPage) + allocationGranularity - (sizeof(HeapObjectHeader) % allocationGranularity)) % allocationGranularity;
         return sizeof(NormalPage) + paddingSize;
     }
 
-
     NormalPageArena* arenaForNormalPage();
 
 private:
     HeapObjectHeader* findHeaderFromAddress(Address);
     void populateObjectStartBitMap();
 
     bool m_objectStartBitMapComputed;
     uint8_t m_objectStartBitMap[reservedForObjectBitMap];
 };
 
@@ skipping 181 matching lines @@
     // Returns true if we have swept all pages within the deadline.
     // Returns false otherwise.
     bool lazySweepWithDeadline(double deadlineSeconds);
     void completeSweep();
 
     ThreadState* getThreadState() { return m_threadState; }
     int arenaIndex() const { return m_index; }
 
     Address allocateLargeObject(size_t allocationSize, size_t gcInfoIndex);
 
+    bool willObjectBeLazilySwept(BasePage*, void*) const;
+
 protected:
     BasePage* m_firstPage;
     BasePage* m_firstUnsweptPage;
 
 private:
     virtual Address lazySweepPages(size_t, size_t gcInfoIndex) = 0;
 
     ThreadState* m_threadState;
 
     // Index into the page pools.  This is used to ensure that the pages of the
@@ skipping 25 matching lines @@
     void promptlyFreeObject(HeapObjectHeader*);
     bool expandObject(HeapObjectHeader*, size_t);
     bool shrinkObject(HeapObjectHeader*, size_t);
     void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
     bool isObjectAllocatedAtAllocationPoint(HeapObjectHeader* header)
     {
         return header->payloadEnd() == m_currentAllocationPoint;
     }
 
+    bool isLazySweeping() const { return m_isLazySweeping; }
+    void setIsLazySweeping(bool flag) { m_isLazySweeping = flag; }
+
 private:
     void allocatePage();
     Address outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex);
     Address allocateFromFreeList(size_t, size_t gcInfoIndex);
 
     Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     bool hasCurrentAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     void setAllocationPoint(Address, size_t);
 
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     void setRemainingAllocationSize(size_t);
     void updateRemainingAllocationSize();
 
     FreeList m_freeList;
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
+
+    bool m_isLazySweeping;
 };
 
 class LargeObjectArena final : public BaseArena {
 public:
     LargeObjectArena(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     bool isConsistentForGC() override { return true; }
 #endif
@@ skipping 139 matching lines @@
         SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
         ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
         return result;
     }
     return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 } // namespace blink
 
 #endif // HeapPage_h