Remove after wakeup logic and replace PumpTask with Fences

third_party/WebKit/Source/platform/scheduler/child/idle_helper.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 THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_CHILD_IDLE_HELPER_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_CHILD_IDLE_HELPER_H_
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "platform/scheduler/base/cancelable_closure_holder.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 #include "platform/scheduler/child/scheduler_helper.h"
 #include "public/platform/scheduler/child/single_thread_idle_task_runner.h"
 #include "public/platform/WebCommon.h"
 
 namespace blink {
 namespace scheduler {
 
 class SchedulerHelper;
 
-// Common scheduler functionality for Idle tasks.
+// The job of the IdleHelper is to run idle tasks when the system is otherwise
+// idle. Idle tasks should be optional work, with no guarantee they will be run
+// at all. Idle tasks are subject to three levels of throttling:
+//
+//   1. Both idle queues are run a BEST_EFFORT priority (i.e. only selected if
+//      there is noting else to do.

[Sami, 2016/08/25 15:54:13]

typo: nothing

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

Done.

+//   2. The idle queues are only enabled during an idle period.
+//   3. Idle tasks posted from within an idle task run in the next idle period.
+//      This is achieved by posting DisableIdleTaskQueueTask or
+//      DisableNonNestableIdleTaskQueueTask before enabling the queues.
+//
+// There are two types of idle periods:
+//   1. Short idle period - typically less than 10ms run after begin main frame
+//      has finished, with the idle period ending at the compositor provided
+//      deadline.
+//   2. Long idle periods - typically more than 50ms when no frames are being

[Sami, 2016/08/25 15:54:13]

s/more than/up to/

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

Done.

+//      produced.
+//
+// Idle tasks are supplied a deadline, and should endeavor to finished before it
+// ends to avoid jank.
 class BLINK_PLATFORM_EXPORT IdleHelper
     : public base::MessageLoop::TaskObserver,
       public SingleThreadIdleTaskRunner::Delegate {
  public:
   // Used to by scheduler implementations to customize idle behaviour.
   class BLINK_PLATFORM_EXPORT Delegate {
    public:
     Delegate();
     virtual ~Delegate();
 
@@ skipping 153 matching lines @@
       base::TimeDelta* next_long_idle_period_delay_out);
 
   bool ShouldWaitForQuiescence();
   void OnIdleTaskPostedOnMainThread();
   void UpdateLongIdlePeriodStateAfterIdleTask();
 
   void SetIdlePeriodState(IdlePeriodState new_state,
                           base::TimeTicks new_deadline,
                           base::TimeTicks optional_now);
 
+  void DisableIdleTaskQueueTask();
+  void DisableNonNestableIdleTaskQueueTask();
+
   // Returns true if |state| represents being within an idle period state.
   static bool IsInIdlePeriod(IdlePeriodState state);
   // Returns true if |state| represents being within a long idle period state.
   static bool IsInLongIdlePeriod(IdlePeriodState state);
 
   SchedulerHelper* helper_;  // NOT OWNED
   Delegate* delegate_;       // NOT OWNED
+
+  // We want to ensure idle tasks run in the next idle period. This necessitates
+  // two idle queues because we do this via posting a task to disable the queue
+  // and non-nestable tasks execution can be deferred, meaning we end up with
+  // the situation where we don't want any more nestable tasks to run but the
+  // non-nestable ones have yet to run.
   scoped_refptr<TaskQueue> idle_queue_;
+  scoped_refptr<TaskQueue> non_nestable_idle_queue_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
   CancelableClosureHolder enable_next_long_idle_period_closure_;
   CancelableClosureHolder on_idle_task_posted_closure_;
+  CancelableClosureHolder disable_idle_queue_closure_;
+  CancelableClosureHolder disable_non_nestable_idle_queue_closure_;
 
   State state_;
 
   base::TimeDelta required_quiescence_duration_before_long_idle_period_;
 
   const char* disabled_by_default_tracing_category_;
 
   base::WeakPtr<IdleHelper> weak_idle_helper_ptr_;
   base::WeakPtrFactory<IdleHelper> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IdleHelper);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_CHILD_IDLE_HELPER_H_