Pass Callback to TaskRunner by value and consume it on invocation (1)

components/memory_pressure/memory_pressure_monitor_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 "components/memory_pressure/memory_pressure_monitor.h"
 
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/tracked_objects.h"
 #include "components/memory_pressure/memory_pressure_stats_collector.h"
 #include "components/memory_pressure/test_memory_pressure_calculator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 10 matching lines @@
     MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
 
 using testing::_;
 
 }  // namespace
 
 // A mock task runner. This isn't directly a TaskRunner as the reference
 // counting confuses gmock.
 class LenientMockTaskRunner {
  public:
-  MOCK_METHOD3(PostDelayedTask,
-               bool(const tracked_objects::Location&,
-                    const base::Closure&,
-                    base::TimeDelta));
+  MOCK_METHOD2(PostDelayedTask,
+               bool(const tracked_objects::Location&, base::TimeDelta));
 };
 using MockTaskRunner = testing::StrictMock<LenientMockTaskRunner>;
 
 // A TaskRunner implementation that wraps a MockTaskRunner.
 class TaskRunnerProxy : public base::TaskRunner {
  public:
   // The provided |mock| must outlive this object.
   explicit TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {}
   bool RunsTasksOnCurrentThread() const override { return true; }
   bool PostDelayedTask(const tracked_objects::Location& location,
-                       const base::Closure& closure,
+                       base::Closure closure,
                        base::TimeDelta delta) override {
-    return mock_->PostDelayedTask(location, closure, delta);
+    return mock_->PostDelayedTask(location, delta);
   }
 
  private:
   MockTaskRunner* mock_;
   ~TaskRunnerProxy() override {}
 };
 
 class TestMemoryPressureMonitor : public MemoryPressureMonitor {
  public:
   // Expose the callback that is used for scheduled checks.
@@ skipping 97 matching lines @@
 #endif  // !MEMORY_PRESSURE_IS_POLLING
 
   // Advances the tick clock by the given number of milliseconds.
   void Tick(int ms) {
     tick_clock_.Advance(base::TimeDelta::FromMilliseconds(ms));
   }
 
   // Sets expectations for tasks scheduled via |mock_task_runner_|.
   void ExpectTaskPosted(int delay_ms) {
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(delay_ms);
-    EXPECT_CALL(mock_task_runner_, PostDelayedTask(_, _, delay))
+    EXPECT_CALL(mock_task_runner_, PostDelayedTask(_, delay))
         .WillOnce(testing::Return(true));
   }
 
   // Sets up expectations for calls to |mock_dispatch_|.
   void ExpectDispatch(MemoryPressureLevel level) {
     EXPECT_CALL(mock_dispatch_, Dispatch(level));
   }
   void ExpectDispatchModerate() {
     EXPECT_CALL(mock_dispatch_, Dispatch(MEMORY_PRESSURE_LEVEL_MODERATE));
   }
@@ skipping 198 matching lines @@
   ExpectDispatchCritical();
   monitor_->OnMemoryPressureChanged(MEMORY_PRESSURE_LEVEL_CRITICAL);
   VerifyAndClearExpectations();
   ExpectCritical();
   EXPECT_EQ(2u, monitor_->scheduled_checks().size());
 }
 
 #endif  // !MEMORY_PRESSURE_IS_POLLING
 
 }  // namespace memory_pressure