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

base/message_loop/incoming_task_queue.cc

 // Copyright 2013 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 "base/message_loop/incoming_task_queue.h"
 
 #include <limits>
 
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 137 matching lines @@
 
   // Initialize the sequence number. The sequence number is used for delayed
   // tasks (to facilitate FIFO sorting when two tasks have the same
   // delayed_run_time value) and for identifying the task in about:tracing.
   pending_task->sequence_num = next_sequence_num_++;
 
   message_loop_->task_annotator()->DidQueueTask("MessageLoop::PostTask",
                                                 *pending_task);
 
   bool was_empty = incoming_queue_.empty();
-  incoming_queue_.push(*pending_task);
-  pending_task->task.Reset();
+  incoming_queue_.push(std::move(*pending_task));
+  DCHECK(pending_task->task.is_null());

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

Is this a valid assumption? I thought we should treat the moved-from object as
undefined after the move.

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

Done.

[Sami, 2016/04/13 15:17:32]

I'm not sure we need to even do this. We've moved pending_task to the incoming
queue so it's no longer our concern :)

[tzik, 2016/04/14 19:44:30]

Right, it's redundant since we know the move construction on Callback clears the
object. I added it just for readability and for making sure, since it's legal to
leave something non-null there as WTF containers do.

 
   if (is_ready_for_scheduling_ &&
       (always_schedule_work_ || (!message_loop_scheduled_ && was_empty))) {
     ScheduleWork();
   }
 
   return true;
 }
 
 void IncomingTaskQueue::ScheduleWork() {
   DCHECK(is_ready_for_scheduling_);
   // Wake up the message loop.
   message_loop_->ScheduleWork();
   // After we've scheduled the message loop, we do not need to do so again
   // until we know it has processed all of the work in our queue and is
   // waiting for more work again. The message loop will always attempt to
   // reload from the incoming queue before waiting again so we clear this flag
   // in ReloadWorkQueue().
   message_loop_scheduled_ = true;
 }
 
 }  // namespace internal
 }  // namespace base