scheduler: Disable expensive timers during main thread user input

components/scheduler/child/task_queue_impl.h

 // Copyright 2015 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.
 
 #ifndef CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_
 #define CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_
 
 #include <set>
 
 #include "base/pending_task.h"
@@ skipping 60 matching lines @@
                                   base::TimeDelta delay) override;
   bool PostDelayedTaskAt(const tracked_objects::Location& from_here,
                          const base::Closure& task,
                          base::TimeTicks desired_run_time) override;
 
   bool IsQueueEnabled() const override;
   QueueState GetQueueState() const override;
   void SetQueuePriority(QueuePriority priority) override;
   void PumpQueue() override;
   void SetPumpPolicy(PumpPolicy pump_policy) override;
+  void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
+  void RemoveTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) override;
 
   bool NextPendingDelayedTaskRunTime(
       base::TimeTicks* next_pending_delayed_task);
 
   void UpdateWorkQueue(LazyNow* lazy_now,
                        bool should_trigger_wakeup,
                        const Task* previous_task);
   Task TakeTaskFromWorkQueue();
 
   std::queue<Task>& work_queue() { return work_queue_; }
@@ skipping 12 matching lines @@
   void set_task_queue_set_index(size_t set_index) { set_index_ = set_index; }
 
   // If the work queue isn't empty, |enqueue_order| gets set to the enqueue
   // order of the front task and the function returns true.  Otherwise the
   // function returns false.
   bool GetWorkQueueFrontTaskEnqueueOrder(int* enqueue_order) const;
 
   bool GetQuiescenceMonitored() const { return should_monitor_quiescence_; }
   bool GetShouldNotifyObservers() const { return should_notify_observers_; }
 
+  void NotifyWillProcessTask(const base::PendingTask& pending_task);
+  void NotifyDidProcessTask(const base::PendingTask& pending_task);
+
   // Delayed task posted to the underlying run loop, which locks |lock_| and
   // calls MoveReadyDelayedTasksToIncomingQueueLocked to process dealyed tasks
   // that need to be run now.  Thread safe, but in practice it's always called
   // from the main thread.
   void MoveReadyDelayedTasksToIncomingQueue(LazyNow* lazy_now);
 
   // Test support functions.  These should not be used in production code.
   void PushTaskOntoWorkQueueForTest(const Task& task);
   void PopTaskFromWorkQueueForTest();
   size_t WorkQueueSizeForTest() const { return work_queue_.size(); }
@@ skipping 61 matching lines @@
   std::queue<Task> incoming_queue_;
   PumpPolicy pump_policy_;
   std::priority_queue<Task> delayed_task_queue_;
 
   const char* name_;
   const char* disabled_by_default_tracing_category_;
   const char* disabled_by_default_verbose_tracing_category_;
 
   base::ThreadChecker main_thread_checker_;
   std::queue<Task> work_queue_;
+  base::ObserverList<base::MessageLoop::TaskObserver> task_observers_;
   WakeupPolicy wakeup_policy_;
   size_t set_index_;
   bool should_monitor_quiescence_;
   bool should_notify_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 
 #endif  // CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_