Make PendingTask move-only and pass it by value on retaining params

components/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 "components/scheduler/base/work_queue.h"
 
 #include "components/scheduler/base/work_queue_sets.h"
 
 namespace scheduler {
 namespace internal {
 
 WorkQueue::WorkQueue(TaskQueueImpl* task_queue, const char* name)
     : work_queue_sets_(nullptr),
       task_queue_(task_queue),
       work_queue_set_index_(0),
       name_(name) {}
 
 void WorkQueue::AsValueInto(base::trace_event::TracedValue* state) const {
-  std::queue<TaskQueueImpl::Task> queue_copy(work_queue_);
-  while (!queue_copy.empty()) {
-    TaskQueueImpl::TaskAsValueInto(queue_copy.front(), state);
-    queue_copy.pop();
+  // Remove const to search |work_queue_| in the destructive manner. Restore the
+  // content from |visited| later.
+  std::queue<TaskQueueImpl::Task>& mutable_queue =

[Sami, 2016/04/13 11:33:00]

Ditto.

[tzik, 2016/04/13 14:35:37]

Done.

+      const_cast<std::queue<TaskQueueImpl::Task>&>(work_queue_);
+  std::queue<TaskQueueImpl::Task> visited;
+  while (!mutable_queue.empty()) {
+    TaskQueueImpl::TaskAsValueInto(mutable_queue.front(), state);
+    visited.push(std::move(mutable_queue.front()));
+    mutable_queue.pop();
   }
+  mutable_queue = std::move(visited);
 }
 
 WorkQueue::~WorkQueue() {
   DCHECK(!work_queue_sets_) << task_queue_ ->GetName() << " : "
       << work_queue_sets_->name() << " : " << name_;
 }
 
 const TaskQueueImpl::Task* WorkQueue::GetFrontTask() const {
   if (work_queue_.empty())
     return nullptr;
   return &work_queue_.front();
 }
 
 bool WorkQueue::GetFrontTaskEnqueueOrder(EnqueueOrder* enqueue_order) const {
   if (work_queue_.empty())
     return false;
   *enqueue_order = work_queue_.front().enqueue_order();
   return true;
 }
 
-void WorkQueue::Push(const TaskQueueImpl::Task& task) {
+void WorkQueue::Push(TaskQueueImpl::Task task) {
   bool was_empty = work_queue_.empty();
-  work_queue_.push(task);
+  work_queue_.push(std::move(task));
   if (was_empty && work_queue_sets_)
     work_queue_sets_->OnPushQueue(this);
 }
 
-void WorkQueue::PushAndSetEnqueueOrder(const TaskQueueImpl::Task& task,
+void WorkQueue::PushAndSetEnqueueOrder(TaskQueueImpl::Task task,
                                        EnqueueOrder enqueue_order) {
   bool was_empty = work_queue_.empty();
-  work_queue_.push(task);
+  work_queue_.push(std::move(task));
   work_queue_.back().set_enqueue_order(enqueue_order);
 
   if (was_empty && work_queue_sets_)
     work_queue_sets_->OnPushQueue(this);
 }
 
 void WorkQueue::PopTaskForTest() {
   work_queue_.pop();
 }
 
@@ skipping 31 matching lines @@
   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