base: Remove a copy of and copy ctor from SequenceAndSortKey.

base/task_scheduler/scheduler_thread_pool.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/scheduler_thread_pool.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 220 matching lines @@
 void SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::OnMainEntry() {
   DCHECK(!tls_current_thread_pool.Get().Get());
   tls_current_thread_pool.Get().Set(outer_);
 }
 
 scoped_refptr<Sequence>
 SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::GetWork(
     SchedulerWorkerThread* worker_thread) {
   std::unique_ptr<PriorityQueue::Transaction> transaction(
       outer_->shared_priority_queue_.BeginTransaction());
-  const auto sequence_and_sort_key = transaction->Peek();
+  const auto& sequence_and_sort_key = transaction->Peek();
 
   if (sequence_and_sort_key.is_null()) {
     // |transaction| is kept alive while |worker_thread| is added to
     // |idle_worker_threads_stack_| to avoid this race:
     // 1. This thread creates a Transaction, finds |shared_priority_queue_|
     //    empty and ends the Transaction.
     // 2. Other thread creates a Transaction, inserts a Sequence into
     //    |shared_priority_queue_| and ends the Transaction. This can't happen
     //    if the Transaction of step 1 is still active because because there can
     //    only be one active Transaction per PriorityQueue at a time.
     // 3. Other thread calls WakeUpOneThread(). No thread is woken up because
     //    |idle_worker_threads_stack_| is empty.
     // 4. This thread adds itself to |idle_worker_threads_stack_| and goes to
     //    sleep. No thread runs the Sequence inserted in step 2.
     outer_->AddToIdleWorkerThreadsStack(worker_thread);
     return nullptr;
   }
 
+  scoped_refptr<Sequence> sequence = sequence_and_sort_key.sequence;
   transaction->Pop();
-  return sequence_and_sort_key.sequence;
+  return sequence;
 }
 
 void SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::EnqueueSequence(
     scoped_refptr<Sequence> sequence) {
   enqueue_sequence_callback_.Run(std::move(sequence));
 }
 
 SchedulerThreadPool::SchedulerThreadPool(
     const EnqueueSequenceCallback& enqueue_sequence_callback,
     TaskTracker* task_tracker)
@@ skipping 49 matching lines @@
   if (idle_worker_threads_stack_.empty())
     return nullptr;
 
   auto worker_thread = idle_worker_threads_stack_.top();
   idle_worker_threads_stack_.pop();
   return worker_thread;
 }
 
 }  // namespace internal
 }  // namespace base