Replace Closure in TaskRunner::PostTask with OneShotCallback

third_party/WebKit/Source/platform/scheduler/renderer/idle_time_estimator_unittest.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 "platform/scheduler/renderer/idle_time_estimator.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "platform/scheduler/base/task_queue_manager.h"
@@ skipping 39 matching lines @@
         "test.scheduler.debug");
     compositor_task_runner_ =
         manager_->NewTaskQueue(TaskQueue::Spec("compositor_tq"));
     estimator_.reset(new IdleTimeEstimatorForTest(
         compositor_task_runner_, test_time_source_.get(), 10, 50));
   }
 
   void SimulateFrameWithOneCompositorTask(int compositor_time) {
     base::TimeDelta non_idle_time =
         base::TimeDelta::FromMilliseconds(compositor_time);
-    base::PendingTask task(FROM_HERE, base::Closure());
+    base::PendingTask task(FROM_HERE, base::OnceClosure());
     estimator_->WillProcessTask(task);
     clock_->Advance(non_idle_time);
     estimator_->DidCommitFrameToCompositor();
     estimator_->DidProcessTask(task);
     if (non_idle_time < frame_length_)
       clock_->Advance(frame_length_ - non_idle_time);
   }
 
   void SimulateFrameWithTwoCompositorTasks(int compositor_time1,
                                            int compositor_time2) {
     base::TimeDelta non_idle_time1 =
         base::TimeDelta::FromMilliseconds(compositor_time1);
     base::TimeDelta non_idle_time2 =
         base::TimeDelta::FromMilliseconds(compositor_time2);
-    base::PendingTask task(FROM_HERE, base::Closure());
+    base::PendingTask task(FROM_HERE, base::OnceClosure());
     estimator_->WillProcessTask(task);
     clock_->Advance(non_idle_time1);
     estimator_->DidProcessTask(task);
 
     estimator_->WillProcessTask(task);
     clock_->Advance(non_idle_time2);
     estimator_->DidCommitFrameToCompositor();
     estimator_->DidProcessTask(task);
 
     base::TimeDelta idle_time = frame_length_ - non_idle_time1 - non_idle_time2;
@@ skipping 60 matching lines @@
   SimulateFrameWithTwoCompositorTasks(1, 4);
 
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
             estimator_->GetExpectedIdleDuration(frame_length_));
 }
 
 TEST_F(IdleTimeEstimatorTest, IgnoresNestedTasks) {
   SimulateFrameWithOneCompositorTask(5);
   SimulateFrameWithOneCompositorTask(5);
 
-  base::PendingTask task(FROM_HERE, base::Closure());
+  base::PendingTask task(FROM_HERE, base::OnceClosure());
   estimator_->WillProcessTask(task);
   SimulateFrameWithTwoCompositorTasks(4, 4);
   SimulateFrameWithTwoCompositorTasks(4, 4);
   SimulateFrameWithTwoCompositorTasks(4, 4);
   SimulateFrameWithTwoCompositorTasks(4, 4);
   estimator_->DidCommitFrameToCompositor();
   estimator_->DidProcessTask(task);
 
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
             estimator_->GetExpectedIdleDuration(frame_length_));
 }
 
 }  // namespace scheduler
 }  // namespace blink