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

chrome/browser/memory/tab_manager_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/memory/tab_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
+#include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/memory/tab_manager_web_contents_data.h"
@@ skipping 63 matching lines @@
   WebContents* new_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabStripModelObserver);
 };
 
 // A mock task runner. This isn't directly a TaskRunner as the reference
 // counting confuses gmock.
 class LenientMockTaskRunner {
  public:
   LenientMockTaskRunner() {}
-  MOCK_METHOD3(PostDelayedTask,
-               bool(const tracked_objects::Location&,
-                    const base::Closure&,
-                    base::TimeDelta));
+  MOCK_METHOD2(PostDelayedTask,
+               bool(const tracked_objects::Location&, base::TimeDelta));
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LenientMockTaskRunner);
 };
 using MockTaskRunner = testing::StrictMock<LenientMockTaskRunner>;
 
 // Represents a pending task.
 using Task = std::pair<base::TimeTicks, base::Closure>;
 
 // Comparator used for sorting Task objects. Can't use std::pair's default
 // comparison operators because Closure's are comparable.
 struct TaskComparator {
   bool operator()(const Task& t1, const Task& t2) const {
     // Reverse the sort order so this can be used with a min-heap.
     return t1.first > t2.first;
   }
 };
 
 // A TaskRunner implementation that delegates to a MockTaskRunner for asserting
 // on task insertion order, and which stores tasks for actual later execution.
 class TaskRunnerProxy : public base::TaskRunner {
  public:
   TaskRunnerProxy(MockTaskRunner* mock,
                   base::SimpleTestTickClock* clock)
       : mock_(mock), clock_(clock) {}
   bool RunsTasksOnCurrentThread() const override { return true; }
   bool PostDelayedTask(const tracked_objects::Location& location,
-                       const base::Closure& closure,
+                       base::Closure closure,
                        base::TimeDelta delta) override {
-    mock_->PostDelayedTask(location, closure, delta);
+    mock_->PostDelayedTask(location, delta);
     base::TimeTicks when = clock_->NowTicks() + delta;
-    tasks_.push_back(Task(when, closure));
+    tasks_.push_back(Task(when, std::move(closure)));
     // Use 'greater' comparator to make this a min heap.
     std::push_heap(tasks_.begin(), tasks_.end(), TaskComparator());
     return true;
   }
 
   // Runs tasks up to the current time. Returns the number of tasks executed.
   size_t RunTasks() {
     base::TimeTicks now = clock_->NowTicks();
     size_t count = 0;
     while (!tasks_.empty() && tasks_.front().first <= now) {
-      tasks_.front().second.Run();
+      std::move(tasks_.front().second).Run();

[sky, 2017/03/22 17:34:11]

?

       std::pop_heap(tasks_.begin(), tasks_.end(), TaskComparator());
       tasks_.pop_back();
       ++count;
     }
     return count;
   }
 
   // Advances the clock and runs the next task in the queue. Can run more than
   // one task if multiple tasks have the same scheduled time.
   size_t RunNextTask() {
@@ skipping 438 matching lines @@
   EXPECT_EQ(0u, tm.notified_renderers_.size());
 
   // START OF MEMORY PRESSURE
 
   // Simulate a memory pressure situation that persists. This should cause a
   // task to be scheduled, and a background renderer to be notified.
   tm.get_current_pressure_level_ = base::Bind(
       &ReturnSpecifiedPressure, base::Unretained(&level));
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
       testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer2, level));
   tm.OnMemoryPressure(level);
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
   EXPECT_EQ(1u, tm.notified_renderers_.count(renderer2));
 
   // REPEATED MEMORY PRESSURE SIGNAL
 
   // Simulate another memory pressure event. This should not cause any
   // additional tasks to be scheduled, nor any further renderer notifications.
   tm.OnMemoryPressure(level);
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
 
   // FIRST SCHEDULED NOTIFICATION
 
   // Run the scheduled task. This should cause another notification, but this
   // time to the foreground tab. It should also cause another scheduled event.
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
       testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer1, level));
   EXPECT_EQ(1u, task_runner->RunNextTask());
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(2u, tm.notified_renderers_.size());
   EXPECT_EQ(1u, tm.notified_renderers_.count(renderer1));
 
   // SECOND SCHEDULED NOTIFICATION
 
   // Run the scheduled task. This should cause another notification, to the
   // background tab. It should also cause another scheduled event.
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
       testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer2, level));
   EXPECT_EQ(1u, task_runner->RunNextTask());
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
 
   // Expect that the background tab has been notified. The list of notified
@@ skipping 94 matching lines @@
   // Since tab2 is kept inactive and background for more than time-to-purge,
   // tab2 should be purged.
   EXPECT_TRUE(tab_manager.GetWebContentsData(tab2)->is_purged());
 
   // Activate tab2. Tab2's PurgeAndSuspend state should be NOT_PURGED.
   tabstrip.ActivateTabAt(1, true /* user_gesture */);
   EXPECT_FALSE(tab_manager.GetWebContentsData(tab2)->is_purged());
 }
 
 }  // namespace memory