TaskScheduler [6] SchedulerWorkerThread

base/task_scheduler/priority_queue.cc

 // Copyright 2016 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/task_scheduler/priority_queue.h"
 
 #include <utility>
 
 #include "base/logging.h"
 
 namespace base {
 namespace internal {
 
-PriorityQueue::SequenceAndSortKey::SequenceAndSortKey()
-    : sort_key(TaskPriority::LOWEST, TimeTicks()) {}
+PriorityQueue::SequenceAndSortKey::SequenceAndSortKey() = default;
 
 PriorityQueue::SequenceAndSortKey::SequenceAndSortKey(
     scoped_refptr<Sequence> sequence,
     SequenceSortKey sort_key)
     : sequence(sequence), sort_key(sort_key) {}

[gab, 2016/03/21 19:11:53]

std::move(sequence)

(I know it already landed but just spotted this one while looking for more
instances of other missing moves I find in this file)

Not sure if compiler can figure out by itself that this can be moved as it's not
referenced after..?

[robliao, 2016/03/21 19:15:40]

scoped_ptr now points to std::unique_ptr which does not satisfy
CopyConstructable, so I think the compiler figures it out.

[gab, 2016/03/21 19:55:19]

Yes, but here |sequence| is scoped_refptr.

I'm not worried about scoped_ptr because either it works without move or it
doesn't, whereas scoped_refptr can result in hidden thread-safe refbumps.

[robliao, 2016/03/21 19:59:54]

Oops! My mistake. scoped_refptr is CopyConstructable so yes, we'll need
std::move here to be explicit about moving. 

Yeah, I'm not sure if the move constructor is a legal optimization for variables
no longer referenced after the transfer statement.

[robliao, 2016/03/21 20:06:13]

So far I'm reading this as move constructor optimizations are currently not
allowed per overloading:

http://en.cppreference.com/w/cpp/language/move_constructor

If both copy and move constructors are provided, overload resolution selects the
move constructor if the argument is an rvalue (either a prvalue such as a
nameless temporary or an xvalue such as the result of std::move), and selects
the copy constructor if the argument is an lvalue (named object or a
function/operator returning lvalue reference). If only the copy constructor is
provided, all argument categories select it (as long as it takes a reference to
const, since rvalues can bind to const references), which makes copying the
fallback for moving, when moving is unavailable.

 
 PriorityQueue::SequenceAndSortKey::~SequenceAndSortKey() = default;
 
 bool PriorityQueue::SequenceAndSortKey::is_null() const {
   return sequence.get() == nullptr;
 }
 
 PriorityQueue::PriorityQueue(const Closure& sequence_inserted_callback)
     : sequence_inserted_callback_(sequence_inserted_callback) {
   DCHECK(!sequence_inserted_callback_.is_null());
@@ skipping 57 matching lines @@
 }
 
 bool PriorityQueue::SequenceAndSortKeyComparator::operator()(
     const scoped_ptr<SequenceAndSortKey>& left,
     const scoped_ptr<SequenceAndSortKey>& right) const {
   return left->sort_key < right->sort_key;
 }
 
 }  // namespace internal
 }  // namespace base