scheduler: Implement task observers

content/renderer/scheduler/task_queue_manager_unittest.cc

Index: content/renderer/scheduler/task_queue_manager_unittest.cc
diff --git a/content/renderer/scheduler/task_queue_manager_unittest.cc b/content/renderer/scheduler/task_queue_manager_unittest.cc
index 62e6c349c372dd16a92bd74488a27f23eaf3743a..f8a80b66b7bc5a4a6b238c061788f100e6972584 100644
--- a/content/renderer/scheduler/task_queue_manager_unittest.cc
+++ b/content/renderer/scheduler/task_queue_manager_unittest.cc
@@ -582,5 +582,87 @@ TEST_F(TaskQueueManagerTest, InterruptWorkBatchForDelayedTask) {
   EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
 }
 
+class TestTaskObserver : public base::MessageLoop::TaskObserver {
+ public:
+  TestTaskObserver() : will_count_(0), did_count_(0) {}
+
+  void DidProcessTask(const base::PendingTask& task) override { did_count_++; }
+
+  void WillProcessTask(const base::PendingTask& task) override {

[alex clarke (OOO till 29th), 2015/02/13 14:42:18]

This is OK however gmock does have native support for this kind of thing which
we should probably prefer.

class MockTaskObserver : public base::MessageLoop::TaskObserver {
  MOCK_METHOD1(DidProcessTask, void(const base::PendingTask& task));
  MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task));
};

...

TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
  MockTaskObserver observer;
  ....

  EXPECT_CALL(observer, DidProcessTask(_)).times(2);
  EXPECT_CALL(observer, WillProcessTask(_)).times(2);
}

[Sami, 2015/02/13 15:54:31]

Thanks for the suggestion. It's a bit neater this way.

+    will_count_++;
+  }
+
+  int CallsToWillProcess() const { return will_count_; }
+  int CallsToDidProcess() const { return did_count_; }
+
+ private:
+  int will_count_;
+  int did_count_;
+};
+
+TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
+  Initialize(1u);
+  TestTaskObserver observer;
+
+  EXPECT_EQ(0, observer.CallsToWillProcess());
+  EXPECT_EQ(0, observer.CallsToDidProcess());
+  manager_->AddTaskObserver(&observer);
+
+  std::vector<int> run_order;
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
+
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+  test_task_runner_->RunUntilIdle();
+
+  EXPECT_EQ(2, observer.CallsToWillProcess());
+  EXPECT_EQ(2, observer.CallsToDidProcess());
+}
+
+TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
+  Initialize(1u);
+  TestTaskObserver observer;
+  manager_->AddTaskObserver(&observer);
+  manager_->RemoveTaskObserver(&observer);
+
+  std::vector<int> run_order;
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
+
+  selector_->AppendQueueToService(0);
+  test_task_runner_->RunUntilIdle();
+
+  EXPECT_EQ(0, observer.CallsToWillProcess());
+  EXPECT_EQ(0, observer.CallsToDidProcess());
+}
+
+void RemoveObserverTask(TaskQueueManager* manager,
+                        base::MessageLoop::TaskObserver* observer) {
+  manager->RemoveTaskObserver(observer);
+}
+
+TEST_F(TaskQueueManagerTest, TaskObserverRemovingInsideTask) {
+  Initialize(1u);
+  TestTaskObserver observer;
+  manager_->AddTaskObserver(&observer);
+
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+  runner->PostTask(FROM_HERE,
+                   base::Bind(&RemoveObserverTask, manager_.get(), &observer));
+
+  selector_->AppendQueueToService(0);
+  test_task_runner_->RunUntilIdle();
+
+  EXPECT_EQ(1, observer.CallsToWillProcess());
+  EXPECT_EQ(0, observer.CallsToDidProcess());
+}
+
 }  // namespace
 }  // namespace content