Change const TimeDelta& to TimeDelta in base/task_scheduler/.

base/task_scheduler/scheduler_worker_unittest.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_worker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 28 matching lines @@
 class SchedulerWorkerDefaultDelegate : public SchedulerWorker::Delegate {
  public:
   SchedulerWorkerDefaultDelegate() = default;
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker) override {}
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
     return nullptr;
   }
   void DidRunTaskWithPriority(TaskPriority task_priority,
-                              const TimeDelta& task_latency) override {
+                              TimeDelta task_latency) override {
     ADD_FAILURE() << "Unexpected call to DidRunTaskWithPriority()";
   }
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
     ADD_FAILURE() << "Unexpected call to ReEnqueueSequence()";
   }
   TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
   bool CanDetach(SchedulerWorker* worker) override { return false; }
   void OnDetach() override { ADD_FAILURE() << "Unexpected call to OnDetach()"; }
 
  private:
@@ skipping 119 matching lines @@
       {
         // Add the Sequence to the vector of created Sequences.
         AutoSchedulerLock auto_lock(outer_->lock_);
         outer_->created_sequences_.push_back(sequence);
       }
 
       return sequence;
     }
 
     void DidRunTaskWithPriority(TaskPriority task_priority,
-                                const TimeDelta& task_latency) override {
+                                TimeDelta task_latency) override {
       AutoSchedulerLock auto_lock(expect_did_run_task_with_priority_lock_);
       EXPECT_TRUE(expect_did_run_task_with_priority_);
       EXPECT_EQ(expected_task_priority_, task_priority);
       EXPECT_FALSE(task_latency.is_max());
       expect_did_run_task_with_priority_ = false;
     }
 
     // This override verifies that |sequence| contains the expected number of
     // Tasks and adds it to |enqueued_sequences_|. Unlike a normal
     // EnqueueSequence implementation, it doesn't reinsert |sequence| into a
@@ skipping 184 matching lines @@
     scoped_refptr<Sequence> sequence(new Sequence);
     std::unique_ptr<Task> task(new Task(
         FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&work_processed_)),
         TaskTraits(), TimeDelta()));
     EXPECT_TRUE(task_tracker_->WillPostTask(task.get()));
     sequence->PushTask(std::move(task));
     return sequence;
   }
 
   void DidRunTaskWithPriority(TaskPriority task,
-                              const TimeDelta& task_latency) override {}
+                              TimeDelta task_latency) override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     detach_requested_.Signal();
     return can_detach_;
   }
 
   void OnDetach() override {
     EXPECT_TRUE(can_detach_);
     EXPECT_TRUE(detach_requested_.IsSignaled());
     detached_.Signal();
@@ skipping 196 matching lines @@
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base