scheduler: Disable expensive timers during main thread user input

components/scheduler/child/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 "components/scheduler/child/task_queue_manager.h"
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 794 matching lines @@
   manager_->AddTaskObserver(&observer);
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&RemoveObserverTask, manager_.get(), &observer));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
   message_loop_->RunUntilIdle();
 }
 
+TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) {
+  InitializeWithRealMessageLoop(2u);
+  MockTaskObserver observer;
+
+  manager_->SetWorkBatchSize(2);
+  runners_[0]->AddTaskObserver(&observer);
+
+  std::vector<int> run_order;
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
+  runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
+
+  EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
+  message_loop_->RunUntilIdle();
+}
+
+TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) {
+  InitializeWithRealMessageLoop(1u);
+  MockTaskObserver observer;
+  manager_->SetWorkBatchSize(2);
+  runners_[0]->AddTaskObserver(&observer);
+  runners_[0]->RemoveTaskObserver(&observer);
+
+  std::vector<int> run_order;
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
+
+  EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
+
+  message_loop_->RunUntilIdle();
+}
+
+void RemoveQueueObserverTask(scoped_refptr<TaskQueue> queue,
+                             base::MessageLoop::TaskObserver* observer) {
+  queue->RemoveTaskObserver(observer);
+}
+
+TEST_F(TaskQueueManagerTest, QueueTaskObserverRemovingInsideTask) {
+  InitializeWithRealMessageLoop(1u);
+  MockTaskObserver observer;
+  runners_[0]->AddTaskObserver(&observer);
+
+  runners_[0]->PostTask(
+      FROM_HERE, base::Bind(&RemoveQueueObserverTask, runners_[0], &observer));
+
+  EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
+  EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
+  message_loop_->RunUntilIdle();
+}
+
 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) {
   Initialize(1u);
   EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
   manager_.reset();
   EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
 }
 
 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) {
   scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock());
   clock->Advance(base::TimeDelta::FromMicroseconds(10000));
@@ skipping 356 matching lines @@
                                base::TimeDelta::FromMilliseconds(30));
 
   runners_[1]->UnregisterTaskQueue();
   test_task_runner_->RunUntilIdle();
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(40));
   ASSERT_THAT(run_order, ElementsAre(1, 3));
 }
 
 }  // namespace scheduler