[scheduler] Add options to TaskQueue::InsertFence

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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/task_queue_impl.h"
 
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
@@ skipping 587 matching lines @@
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().time_domain;
 }
 
 void TaskQueueImpl::SetBlameContext(
     base::trace_event::BlameContext* blame_context) {
   main_thread_only().blame_context = blame_context;
 }
 
-void TaskQueueImpl::InsertFence() {
+void TaskQueueImpl::InsertFence(TaskQueue::InsertFencePosition position) {
   if (!main_thread_only().task_queue_manager)
     return;
 
   EnqueueOrder previous_fence = main_thread_only().current_fence;
   main_thread_only().current_fence =
-      main_thread_only().task_queue_manager->GetNextSequenceNumber();
+      position == TaskQueue::InsertFencePosition::NOW
+          ? main_thread_only().task_queue_manager->GetNextSequenceNumber()
+          : static_cast<EnqueueOrder>(EnqueueOrderValues::BLOCKING_FENCE);
 
   // Tasks posted after this point will have a strictly higher enqueue order
   // and will be blocked from running.
   bool task_unblocked = main_thread_only().immediate_work_queue->InsertFence(
       main_thread_only().current_fence);
   task_unblocked |= main_thread_only().delayed_work_queue->InsertFence(
       main_thread_only().current_fence);
 
-  if (!task_unblocked && previous_fence) {
+  if (!task_unblocked && previous_fence &&
+      previous_fence < main_thread_only().current_fence) {
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().immediate_incoming_queue.empty() &&
         any_thread().immediate_incoming_queue.front().enqueue_order() >
             previous_fence &&
         any_thread().immediate_incoming_queue.front().enqueue_order() <
             main_thread_only().current_fence) {
       task_unblocked = true;
     }
   }
 
@@ skipping 54 matching lines @@
     return false;
   }
 
   if (any_thread().immediate_incoming_queue.empty())
     return true;
 
   return any_thread().immediate_incoming_queue.front().enqueue_order() >
          main_thread_only().current_fence;
 }
 
+EnqueueOrder TaskQueueImpl::GetFenceForTest() const {
+  return main_thread_only().current_fence;
+}
+
 // static
 void TaskQueueImpl::QueueAsValueInto(const std::queue<Task>& queue,
                                      base::trace_event::TracedValue* state) {
   // Remove const to search |queue| in the destructive manner. Restore the
   // content from |visited| later.
   std::queue<Task>* mutable_queue = const_cast<std::queue<Task>*>(&queue);
   std::queue<Task> visited;
   while (!mutable_queue->empty()) {
     TaskAsValueInto(mutable_queue->front(), state);
     visited.push(std::move(mutable_queue->front()));
@@ skipping 35 matching lines @@
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink