Revert of [heap] Reland "Remove black pages and use black areas instead."

src/heap/spaces-inl.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_INL_H_
 #define V8_HEAP_SPACES_INL_H_
 
 #include "src/heap/incremental-marking.h"
 #include "src/heap/spaces.h"
 #include "src/isolate.h"
@@ skipping 16 matching lines @@
   operator++();
   return tmp;
 }
 
 NewSpacePageRange::NewSpacePageRange(Address start, Address limit)
     : range_(Page::FromAddress(start),
              Page::FromAllocationAreaAddress(limit)->next_page()) {
   SemiSpace::AssertValidRange(start, limit);
 }
 
+
 // -----------------------------------------------------------------------------
 // SemiSpaceIterator
 
 HeapObject* SemiSpaceIterator::Next() {
   while (current_ != limit_) {
     if (Page::IsAlignedToPageSize(current_)) {
       Page* page = Page::FromAllocationAreaAddress(current_);
       page = page->next_page();
       DCHECK(!page->is_anchor());
       current_ = page->area_start();
@@ skipping 187 matching lines @@
 
 void MemoryChunk::ResetLiveBytes() {
   if (FLAG_trace_live_bytes) {
     PrintIsolate(heap()->isolate(), "live-bytes: reset page=%p %d->0\n",
                  static_cast<void*>(this), live_byte_count_);
   }
   live_byte_count_ = 0;
 }
 
 void MemoryChunk::IncrementLiveBytes(int by) {
+  if (IsFlagSet(BLACK_PAGE)) return;
   if (FLAG_trace_live_bytes) {
     PrintIsolate(
         heap()->isolate(), "live-bytes: update page=%p delta=%d %d->%d\n",
         static_cast<void*>(this), by, live_byte_count_, live_byte_count_ + by);
   }
   live_byte_count_ += by;
   DCHECK_GE(live_byte_count_, 0);
   DCHECK_LE(static_cast<size_t>(live_byte_count_), size_);
 }
 
@@ skipping 181 matching lines @@
 // Raw allocation.
 AllocationResult PagedSpace::AllocateRawUnaligned(
     int size_in_bytes, UpdateSkipList update_skip_list) {
   HeapObject* object = AllocateLinearly(size_in_bytes);
 
   if (object == NULL) {
     object = free_list_.Allocate(size_in_bytes);
     if (object == NULL) {
       object = SlowAllocateRaw(size_in_bytes);
     }
-    if (object != NULL) {
-      if (heap()->incremental_marking()->black_allocation()) {
-        Marking::MarkBlack(ObjectMarking::MarkBitFrom(object));
-        MemoryChunk::IncrementLiveBytesFromGC(object, size_in_bytes);
-      }
-    }
   }
 
   if (object != NULL) {
     if (update_skip_list == UPDATE_SKIP_LIST && identity() == CODE_SPACE) {
       SkipList::Update(object->address(), size_in_bytes);
     }
     MSAN_ALLOCATED_UNINITIALIZED_MEMORY(object->address(), size_in_bytes);
     return object;
   }
 
@@ skipping 174 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_