scheduler: Maintain a constant enqueue order for every task

third_party/WebKit/Source/platform/scheduler/base/work_queue.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scheduler/base/work_queue.h"
 
 #include "platform/scheduler/base/work_queue_sets.h"
 
 namespace blink {
 namespace scheduler {
@@ skipping 32 matching lines @@
   return &work_queue_.back();
 }
 
 bool WorkQueue::BlockedByFence() const {
   if (!fence_)
     return false;
 
   // If the queue is empty then any future tasks will have a higher enqueue
   // order and will be blocked. The queue is also blocked if the head is past
   // the fence.
-  return work_queue_.empty() || work_queue_.front().enqueue_order() > fence_;
+  return work_queue_.empty() ||
+         work_queue_.front().enqueue_order().sequence_num > fence_;
 }
 
 bool WorkQueue::GetFrontTaskEnqueueOrder(EnqueueOrder* enqueue_order) const {
   if (work_queue_.empty() || BlockedByFence())
     return false;
   // Quick sanity check.
   DCHECK_LE(work_queue_.front().enqueue_order(),
             work_queue_.back().enqueue_order())
       << task_queue_->GetName() << " : " << work_queue_sets_->GetName() << " : "
       << name_;
   *enqueue_order = work_queue_.front().enqueue_order();
   return true;
 }
 
 void WorkQueue::Push(TaskQueueImpl::Task task) {
   bool was_empty = work_queue_.empty();
-#ifndef NDEBUG
-  DCHECK(task.enqueue_order_set());
-#endif
 
   // Amoritized O(1).
   work_queue_.push_back(std::move(task));
 
   if (!was_empty)
     return;
 
   // If we hit the fence, pretend to WorkQueueSets that we're empty.
   if (work_queue_sets_ && !BlockedByFence())
     work_queue_sets_->OnTaskPushedToEmptyQueue(this);
@@ skipping 41 matching lines @@
 }
 
 void WorkQueue::AssignToWorkQueueSets(WorkQueueSets* work_queue_sets) {
   work_queue_sets_ = work_queue_sets;
 }
 
 void WorkQueue::AssignSetIndex(size_t work_queue_set_index) {
   work_queue_set_index_ = work_queue_set_index;
 }
 
-bool WorkQueue::InsertFence(EnqueueOrder fence) {
+bool WorkQueue::InsertFence(SequenceNumber fence) {
   DCHECK_NE(fence, 0u);
-  DCHECK(fence >= fence_ || fence == 1u);
+  DCHECK(fence >= fence_ ||
+         fence == static_cast<SequenceNumber>(
+                      EnqueueOrderSequenceNumberValues::BLOCKING_FENCE));
   bool was_blocked_by_fence = BlockedByFence();
   fence_ = fence;
   // Moving the fence forward may unblock some tasks.
   if (work_queue_sets_ && !work_queue_.empty() && was_blocked_by_fence &&
       !BlockedByFence()) {
     work_queue_sets_->OnTaskPushedToEmptyQueue(this);
     return true;
   }
   // Fence insertion may have blocked all tasks in this work queue.
   if (BlockedByFence())
     work_queue_sets_->OnQueueBlocked(this);
   return false;
 }
 
 bool WorkQueue::RemoveFence() {
   bool was_blocked_by_fence = BlockedByFence();
   fence_ = 0;
   if (work_queue_sets_ && !work_queue_.empty() && was_blocked_by_fence) {
     work_queue_sets_->OnTaskPushedToEmptyQueue(this);
     return true;
   }
   return false;
 }
 
 bool WorkQueue::ShouldRunBefore(const WorkQueue* other_queue) const {
   DCHECK(!work_queue_.empty());
   DCHECK(!other_queue->work_queue_.empty());
-  EnqueueOrder enqueue_order = 0;
-  EnqueueOrder other_enqueue_order = 0;
+  EnqueueOrder enqueue_order;
+  EnqueueOrder other_enqueue_order;
   bool have_task = GetFrontTaskEnqueueOrder(&enqueue_order);
   bool have_other_task =
       other_queue->GetFrontTaskEnqueueOrder(&other_enqueue_order);
   DCHECK(have_task);
   DCHECK(have_other_task);
   return enqueue_order < other_enqueue_order;
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink