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"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
+using testing::_;
 
 namespace content {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
  public:
   SelectorForTest() {}
 
   void RegisterWorkQueues(
       const std::vector<const base::TaskQueue*>& work_queues) override {
@@ skipping 551 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 MockTaskObserver : public base::MessageLoop::TaskObserver {
+ public:
+  MOCK_METHOD1(DidProcessTask, void(const base::PendingTask& task));
+  MOCK_METHOD1(WillProcessTask, void(const base::PendingTask& task));
+};
+
+TEST_F(TaskQueueManagerTest, TaskObserverAdding) {
+  Initialize(1u);
+  MockTaskObserver observer;
+
+  manager_->SetWorkBatchSize(2);
+  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);
+
+  // The observer should be called once because the first and last
+  // notifications are filtered out.

[rmcilroy, 2015/02/23 22:41:43]

These test results now look a bit strange - looking at them I think it might
confuse people that to get all task observer messages they need to register a
task observer on both the TQM and the underlying message loop.  Could we have
the TQM register the task observer on the underlying message loop as well, thus
allowing observation of all tasks just by registering on the TQM?

[Sami, 2015/02/24 14:39:20]

Yeah, I suppose that would be clearer because generally you want both types of
notifications. Done.

+  EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
+  test_task_runner_->RunUntilIdle();
+}
+
+TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
+  Initialize(1u);
+  MockTaskObserver observer;
+  manager_->SetWorkBatchSize(2);
+  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));
+
+  EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
+
+  selector_->AppendQueueToService(0);
+  test_task_runner_->RunUntilIdle();
+}
+
+void RemoveObserverTask(TaskQueueManager* manager,
+                        base::MessageLoop::TaskObserver* observer) {
+  manager->RemoveTaskObserver(observer);
+}
+
+void NoOpTask() {
+}
+
+TEST_F(TaskQueueManagerTest, TaskObserverRemovingInsideTask) {
+  Initialize(1u);
+  MockTaskObserver observer;
+  manager_->SetWorkBatchSize(3);
+  manager_->AddTaskObserver(&observer);
+
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+  runner->PostTask(FROM_HERE, base::Bind(&NoOpTask));
+  runner->PostTask(FROM_HERE,
+                   base::Bind(&RemoveObserverTask, manager_.get(), &observer));
+  runner->PostTask(FROM_HERE, base::Bind(&NoOpTask));
+
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+
+  // One call to DidProcessTask from the first no-op task and once call to
+  // WillProcessTask before the RemoveObserverTask.
+  EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
+  test_task_runner_->RunUntilIdle();
+}
+
 }  // namespace
 }  // namespace content