[heap] Do not wait for marking deque uncommit task on tear down.

src/heap/mark-compact.h

 // Copyright 2012 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_MARK_COMPACT_H_
 #define V8_HEAP_MARK_COMPACT_H_
 
 #include <deque>
 
 #include "src/base/bits.h"
@@ skipping 46 matching lines @@
   explicit MarkingDeque(Heap* heap)
       : backing_store_(nullptr),
         backing_store_committed_size_(0),
         array_(nullptr),
         top_(0),
         bottom_(0),
         mask_(0),
         overflowed_(false),
         in_use_(false),
         uncommit_task_pending_(false),
-        uncommit_task_id_(0),
         heap_(heap) {}
 
   void SetUp();
   void TearDown();
 
   // Ensures that the marking deque is committed and will stay committed until
   // StopUsing() is called.
   void StartUsing();
   void StopUsing();
   void Clear();
@@ skipping 59 matching lines @@
         : CancelableTask(isolate), marking_deque_(marking_deque) {}
 
    private:
     // CancelableTask override.
     void RunInternal() override {
       base::LockGuard<base::Mutex> guard(&marking_deque_->mutex_);
       if (!marking_deque_->in_use_) {
         marking_deque_->Uncommit();
       }
       marking_deque_->uncommit_task_pending_ = false;
-      marking_deque_->uncommit_task_barrier_.NotifyOne();
     }
 
     MarkingDeque* marking_deque_;
     DISALLOW_COPY_AND_ASSIGN(UncommitTask);
   };
 
   static const size_t kMaxSize = 4 * MB;
   static const size_t kMinSize = 256 * KB;
 
   // Must be called with mutex lock.
   void EnsureCommitted();
 
   // Must be called with mutex lock.
   void Uncommit();
 
   // Must be called with mutex lock.
   void StartUncommitTask();
 
-  void CancelOrWaitForUncommitTask();
-
   base::Mutex mutex_;
-  base::ConditionVariable uncommit_task_barrier_;
 
   base::VirtualMemory* backing_store_;
   size_t backing_store_committed_size_;
   HeapObject** array_;
   // array_[(top - 1) & mask_] is the top element in the deque.  The Deque is
   // empty when top_ == bottom_.  It is full when top_ + 1 == bottom
   // (mod mask + 1).
   int top_;
   int bottom_;
   int mask_;
   bool overflowed_;
   // in_use_ == true after taking mutex lock implies that the marking deque is
   // committed and will stay committed at least until in_use_ == false.
   bool in_use_;
   bool uncommit_task_pending_;
-  uint32_t uncommit_task_id_;
   Heap* heap_;
 
   DISALLOW_COPY_AND_ASSIGN(MarkingDeque);
 };
 
 
 // CodeFlusher collects candidates for code flushing during marking and
 // processes those candidates after marking has completed in order to
 // reset those functions referencing code objects that would otherwise
 // be unreachable. Code objects can be referenced in two ways:
@@ skipping 579 matching lines @@
 
  private:
   MarkCompactCollector* collector_;
 };
 
 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_MARK_COMPACT_H_