Use WTF::Deque instead of std::queue in the blink scheduler

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/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/blame_context.h"
@@ skipping 159 matching lines @@
     main_thread_only().time_domain->UnregisterQueue(this);
   if (!any_thread().task_queue_manager)
     return;
   any_thread().time_domain = nullptr;
   main_thread_only().time_domain = nullptr;
   any_thread().task_queue_manager->UnregisterTaskQueue(this);
 
   any_thread().task_queue_manager = nullptr;
   main_thread_only().task_queue_manager = nullptr;
   main_thread_only().delayed_incoming_queue = std::priority_queue<Task>();
-  any_thread().immediate_incoming_queue = std::queue<Task>();
+  any_thread().immediate_incoming_queue.clear();
   main_thread_only().immediate_work_queue.reset();
   main_thread_only().delayed_work_queue.reset();
 }
 
 bool TaskQueueImpl::RunsTasksOnCurrentThread() const {
   base::AutoLock lock(any_thread_lock_);
   return base::PlatformThread::CurrentId() == thread_id_;
 }
 
 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
@@ skipping 141 matching lines @@
   if (any_thread().immediate_incoming_queue.empty()) {
     // There's no point posting a DoWork for a disabled queue, however we can
     // only tell if it's disabled from the main thread.
     if (base::PlatformThread::CurrentId() == thread_id_) {
       if (IsQueueEnabled() && !BlockedByFenceLocked())
         any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     } else {
       any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     }
   }
-  any_thread().immediate_incoming_queue.emplace(
-      posted_from, task, desired_run_time, sequence_number, nestable, sequence_number);
-  any_thread().task_queue_manager->DidQueueTask( any_thread().immediate_incoming_queue.back());
+  any_thread().immediate_incoming_queue.emplace_back(
+      posted_from, task, desired_run_time, sequence_number, nestable,
+      sequence_number);
+  any_thread().task_queue_manager->DidQueueTask(
+      any_thread().immediate_incoming_queue.back());
   TraceQueueSize(true);
 }
 
 bool TaskQueueImpl::IsEmpty() const {
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().delayed_incoming_queue.empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return false;
   }
 
@@ skipping 329 matching lines @@
 
   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,
+void TaskQueueImpl::QueueAsValueInto(const WTF::Deque<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()));
-    mutable_queue->pop();
+  for (const Task& task : queue) {
+    TaskAsValueInto(task, state);
   }
-  *mutable_queue = std::move(visited);
 }
 
 // static
 void TaskQueueImpl::QueueAsValueInto(const std::priority_queue<Task>& queue,
                                      base::trace_event::TracedValue* state) {
   // Remove const to search |queue| in the destructive manner. Restore the
   // content from |visited| later.
   std::priority_queue<Task>* mutable_queue =
       const_cast<std::priority_queue<Task>*>(&queue);
   std::priority_queue<Task> visited;
@@ skipping 99 matching lines @@
 std::unique_ptr<TaskQueueImpl::QueueEnabledVoter>
 TaskQueueImpl::CreateQueueEnabledVoter() {
   main_thread_only().voter_refcount++;
   main_thread_only().is_enabled_refcount++;
   return base::MakeUnique<QueueEnabledVoterImpl>(this);
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink