scheduler: Implement task observers

content/renderer/scheduler/task_queue_manager_unittest.cc

 // Copyright 2014 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 "content/renderer/scheduler/task_queue_manager.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "cc/test/test_now_source.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
@@ skipping 564 matching lines @@
   // the work batch is interrupted by the pending delayed task.
   EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 2u);
   test_task_runner_->RunPendingTasks();
   EXPECT_THAT(run_order, ElementsAre(2));
 
   // Running all remaining tasks should execute both pending tasks.
   test_task_runner_->RunUntilIdle();
   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 {
+    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);

[rmcilroy, 2015/02/13 12:53:22]

nit - could you add a test where the observer is removed from within a task, and
ensure CallsToWillProcess incremented by CallsToDidProcess didn't (no idea if we
care about this, but seems like an edge case).

[Sami, 2015/02/13 14:27:26]

Good idea, done.

+
+  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());
+}
+
 }  // namespace
 }  // namespace content