[heap] Fix computation of marking progress in incremental finalization.

src/heap/sequential-marking-deque.h

 // Copyright 2017 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_SEQUENTIAL_MARKING_DEQUE_
 #define V8_HEAP_SEQUENTIAL_MARKING_DEQUE_
 
 #include <deque>
 
 #include "src/base/platform/mutex.h"
@@ skipping 29 matching lines @@
   // Ensures that the marking deque is committed and will stay committed until
   // StopUsing() is called.
   void StartUsing();
   void StopUsing();
   void Clear();
 
   inline bool IsFull() { return ((top_ + 1) & mask_) == bottom_; }
 
   inline bool IsEmpty() { return top_ == bottom_; }
 
+  int Size() {
+    // Return (top - bottom + capacity) % capacity, where capacity = mask + 1.
+    return (top_ - bottom_ + mask_ + 1) & mask_;
+  }
+
   bool overflowed() const { return overflowed_; }
 
   void ClearOverflowed() { overflowed_ = false; }
 
   void SetOverflowed() { overflowed_ = true; }
 
   // Push the object on the marking stack if there is room, otherwise mark the
   // deque as overflowed and wait for a rescan of the heap.
   INLINE(bool Push(HeapObject* object)) {
     if (IsFull()) {
@@ skipping 47 matching lines @@
       HeapObject* object = callback(array_[i]);
       if (object) {
         array_[new_top] = object;
         new_top = (new_top + 1) & mask_;
       }
       i = (i + 1) & mask_;
     }
     top_ = new_top;
   }
 
-  int top() { return top_; }
-
  private:
   // This task uncommits the marking_deque backing store if
   // markin_deque->in_use_ is false.
   class UncommitTask : public CancelableTask {
    public:
     explicit UncommitTask(Isolate* isolate,
                           SequentialMarkingDeque* marking_deque)
         : CancelableTask(isolate), marking_deque_(marking_deque) {}
 
    private:
@@ skipping 40 matching lines @@
   bool uncommit_task_pending_;
   Heap* heap_;
 
   DISALLOW_COPY_AND_ASSIGN(SequentialMarkingDeque);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SEQUENTIAL_MARKING_DEQUE_