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 12 matching lines @@
 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::Closure*,
                     base::TimeDelta));
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       base::Closure task,
+                       base::TimeDelta delay) {
+    return PostDelayedTask(from_here, &task, delay);

[gab, 2017/03/24 15:56:08]

Passing a pointer to a local variable to a mock method is unexpected IMO.

Why can't we move it? The only EXPECT_CALL entry below that cares about
PostDelayedTask() doesn't verify what's passed in anyways, we could even drop
the param and it would work I think.

[tzik, 2017/03/28 05:59:15]

Removed the Closure parameter.

This couldn't move since MOCK_METHODs don't support move only types. I think
passing the pointer of a local variable was safe as far as the handler doesn't
save the pointee, as I do in startup_task_runner_unittest.cc too.

+  }
 };
 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, std::move(closure), delta);
   }
 
  private:
   MockTaskRunner* mock_;
   ~TaskRunnerProxy() override {}
 };
 
 class TestMemoryPressureMonitor : public MemoryPressureMonitor {
  public:
   // Expose the callback that is used for scheduled checks.
@@ skipping 316 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