Optimize for TouchStart responsiveness

components/scheduler/renderer/renderer_scheduler_impl.h

 // 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.
 
 #ifndef COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 #define COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 
 #include "base/atomicops.h"
 #include "base/synchronization/lock.h"
 #include "components/scheduler/child/idle_helper.h"
 #include "components/scheduler/child/pollable_thread_safe_flag.h"
 #include "components/scheduler/child/scheduler_helper.h"
 #include "components/scheduler/renderer/deadline_task_runner.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "components/scheduler/renderer/task_cost_estimator.h"
+#include "components/scheduler/renderer/user_model.h"
 #include "components/scheduler/scheduler_export.h"
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
 }
 }
 
 namespace scheduler {
 
@@ skipping 35 matching lines @@
   void ResumeTimerQueue() override;
   void SetTimerQueueSuspensionWhenBackgroundedEnabled(bool enabled) override;
 
   SchedulerHelper* GetSchedulerHelperForTesting();
   base::TimeTicks CurrentIdleTaskDeadlineForTesting() const;
 
  private:
   friend class RendererSchedulerImplTest;
   friend class RendererSchedulerImplForTest;
 
-  // Keep RendererSchedulerImpl::PolicyToString in sync with this enum.
-  enum class Policy {
-    NORMAL,
-    COMPOSITOR_PRIORITY,
-    COMPOSITOR_CRITICAL_PATH_PRIORITY,
-    TOUCHSTART_PRIORITY,
-    LOADING_PRIORITY,
-    // Must be the last entry.
-    POLICY_COUNT,
-    FIRST_POLICY = NORMAL,
+  struct Policy {
+    Policy();
+
+    TaskQueue::QueuePriority compositor_queue_priority;
+    TaskQueue::QueuePriority loading_queue_priority;
+    TaskQueue::QueuePriority timer_queue_priority;
+    TaskQueue::QueuePriority default_queue_priority;
+
+    bool operator==(const Policy& other) const {
+      return compositor_queue_priority == other.compositor_queue_priority &&
+             loading_queue_priority == other.loading_queue_priority &&
+             timer_queue_priority == other.timer_queue_priority &&
+             default_queue_priority == other.default_queue_priority;
+    }
   };
 
   class PollableNeedsUpdateFlag {
    public:
     PollableNeedsUpdateFlag(base::Lock* write_lock);
     ~PollableNeedsUpdateFlag();
 
     // Set the flag. May only be called if |write_lock| is held.
     void SetWhileLocked(bool value);
 
@@ skipping 15 matching lines @@
   void OnIdlePeriodStarted() override;
   void OnIdlePeriodEnded() override;
 
   void EndIdlePeriod();
 
   // Returns the serialized scheduler state for tracing.
   scoped_refptr<base::trace_event::ConvertableToTraceFormat> AsValue(
       base::TimeTicks optional_now) const;
   scoped_refptr<base::trace_event::ConvertableToTraceFormat> AsValueLocked(
       base::TimeTicks optional_now) const;
-  static const char* PolicyToString(Policy policy);
 
   static bool ShouldPrioritizeInputEvent(
       const blink::WebInputEvent& web_input_event);
 
-  // The time we should stay in a priority-escalated mode after an input event.
-  static const int kPriorityEscalationAfterInputMillis = 100;
-
   // The amount of time which idle periods can continue being scheduled when the
   // renderer has been hidden, before going to sleep for good.
   static const int kEndIdleWhenHiddenDelayMillis = 10000;
 
   // The amount of time for which loading tasks will be prioritized over
   // other tasks during the initial page load.
   static const int kRailsInitialLoadingPrioritizationMillis = 1000;
 
   // For the purposes of deciding whether or not it's safe to turn timers and
   // loading tasks on only in idle periods, we regard the system as being as
   // being "idle period" starved if there hasn't been an idle period in the last
   // 10 seconds. This was chosen to be long enough to cover most anticipated
   // user gestures.
   static const int kIdlePeriodStarvationThresholdMillis = 10000;
 
   // The amount of time to wait before suspending shared timers after the
-  // renderer has been backgrounded. This is use donly if background suspension
+  // renderer has been backgrounded. This is used only if background suspension
   // of shared timers is enabled.
   static const int kSuspendTimersWhenBackgroundedDelayMillis = 5 * 60 * 1000;
 
   // Schedules an immediate PolicyUpdate, if there isn't one already pending and
   // sets |policy_may_need_update_|. Note |any_thread_lock_| must be
   // locked.
   void EnsureUrgentPolicyUpdatePostedOnMainThread(
       const tracked_objects::Location& from_here);
 
   // Update the policy if a new signal has arrived. Must be called from the main
   // thread.
   void MaybeUpdatePolicy();
 
   // Locks |any_thread_lock_| and updates the scheduler policy.  May early
   // out if the policy is unchanged. Must be called from the main thread.
   void UpdatePolicy();
 
   // Like UpdatePolicy, except it doesn't early out.
   void ForceUpdatePolicy();
 
   enum class UpdateType {
     MAY_EARLY_OUT_IF_POLICY_UNCHANGED,
     FORCE_UPDATE,
   };
 
   // The implelemtation of UpdatePolicy & ForceUpdatePolicy.  It is allowed to
   // early out if |update_type| is MAY_EARLY_OUT_IF_POLICY_UNCHANGED.
   virtual void UpdatePolicyLocked(UpdateType update_type);
 
-  // Returns the amount of time left in the current input escalated priority
-  // policy.  Can be called from any thread.
-  base::TimeDelta TimeLeftInInputEscalatedPolicy(base::TimeTicks now) const;
+  // Helper for computing the use case. |expected_usecase_duration| will be
+  // filled with the amount of time after which the use case should be updated
+  // again. If the duration is zero, a new use case update should not be
+  // scheduled. Must be called with |any_thread_lock_| held. Can be called from
+  // any thread.
+  UseCase ComputeCurrentUseCase(
+      base::TimeTicks now,
+      base::TimeDelta* expected_use_case_duration) const;
 
-  // Helper for computing the new policy. |new_policy_duration| will be filled
-  // with the amount of time after which the policy should be updated again. If
-  // the duration is zero, a new policy update will not be scheduled. Must be
-  // called with |any_thread_lock_| held. Can be called from any thread.
-  Policy ComputeNewPolicy(base::TimeTicks now,
-                          base::TimeDelta* new_policy_duration) const;
-
-  // Works out if compositor tasks would be prioritized based on the current
-  // input signals.  Can be called from any thread.
-  bool InputSignalsSuggestCompositorPriority(base::TimeTicks now) const;
+  // Works out if a gesture appears to be in progress based on the current
+  // input signals. Can be called from any thread.
+  bool InputSignalsSuggestGestureInProgress(base::TimeTicks now) const;
 
   // An input event of some sort happened, the policy may need updating.
   void UpdateForInputEventOnCompositorThread(blink::WebInputEvent::Type type,
                                              InputEventState input_event_state);
 
   // Returns true if there has been at least one idle period in the last
   // |kIdlePeriodStarvationThresholdMillis|.
   bool HadAnIdlePeriodRecently(base::TimeTicks now) const;
 
   // Helpers for safely suspending/resuming the timer queue after a
   // background/foreground signal.
   void SuspendTimerQueueWhenBackgrounded();
   void ResumeTimerQueueWhenForegrounded();
 
+  // The task cost estimators and the UserModel need to be reset upon page
+  // nagigation. This function does that. Must be called from the main thread.
+  void ResetForNavigationLocked();
+
   SchedulerHelper helper_;
   IdleHelper idle_helper_;
 
   const scoped_refptr<TaskQueue> control_task_runner_;
   const scoped_refptr<TaskQueue> compositor_task_runner_;
   const scoped_refptr<TaskQueue> loading_task_runner_;
   const scoped_refptr<TaskQueue> timer_task_runner_;
 
   base::Closure update_policy_closure_;
   DeadlineTaskRunner delayed_update_policy_runner_;
   CancelableClosureHolder end_renderer_hidden_idle_period_closure_;
   CancelableClosureHolder suspend_timers_when_backgrounded_closure_;
 
   // We have decided to improve thread safety at the cost of some boilerplate
   // (the accessors) for the following data members.
 
   struct MainThreadOnly {
     MainThreadOnly();
     ~MainThreadOnly();
 
-    TaskCostEstimator timer_task_cost_estimator_;
-    cc::RollingTimeDeltaHistory short_idle_period_duration_;
-    Policy current_policy_;
-    base::TimeTicks current_policy_expiration_time_;
-    base::TimeTicks estimated_next_frame_begin_;
-    base::TimeDelta expected_short_idle_period_duration_;
-    int timer_queue_suspend_count_;  // TIMER_TASK_QUEUE suspended if non-zero.
-    bool renderer_hidden_;
-    bool renderer_backgrounded_;
-    bool timer_queue_suspension_when_backgrounded_enabled_;
-    bool timer_queue_suspended_when_backgrounded_;
-    bool was_shutdown_;
+    TaskCostEstimator loading_task_cost_estimator;
+    TaskCostEstimator timer_task_cost_estimator;
+    cc::RollingTimeDeltaHistory short_idle_period_duration;
+    UseCase current_use_case;
+    Policy current_policy;
+    base::TimeTicks current_policy_expiration_time;
+    base::TimeTicks estimated_next_frame_begin;
+    base::TimeDelta expected_short_idle_period_duration;
+    int timer_queue_suspend_count;  // TIMER_TASK_QUEUE suspended if non-zero.
+    bool renderer_hidden;
+    bool renderer_backgrounded;
+    bool timer_queue_suspension_when_backgrounded_enabled;
+    bool timer_queue_suspended_when_backgrounded;
+    bool was_shutdown;
+    bool loading_tasks_seem_expensive;
+    bool timer_tasks_seem_expensive;
+    bool touchstart_expected_soon;
+    bool have_seen_a_begin_main_frame;
   };
 
   struct AnyThread {
     AnyThread();
 
-    base::TimeTicks last_input_signal_time_;
-    base::TimeTicks last_idle_period_end_time_;
-    base::TimeTicks rails_loading_priority_deadline_;
-    int pending_main_thread_input_event_count_;
-    bool awaiting_touch_start_response_;
-    bool in_idle_period_;
-    bool begin_main_frame_on_critical_path_;
-    bool timer_tasks_seem_expensive_;
+    base::TimeTicks last_idle_period_end_time;
+    base::TimeTicks rails_loading_priority_deadline;
+    UserModel user_model;
+    bool awaiting_touch_start_response;
+    bool in_idle_period;
+    bool begin_main_frame_on_critical_path;
   };
 
   struct CompositorThreadOnly {
     CompositorThreadOnly();
     ~CompositorThreadOnly();
 
-    blink::WebInputEvent::Type last_input_type_;
-    scoped_ptr<base::ThreadChecker> compositor_thread_checker_;
+    blink::WebInputEvent::Type last_input_type;
+    scoped_ptr<base::ThreadChecker> compositor_thread_checker;
 
     void CheckOnValidThread() {
 #if DCHECK_IS_ON()
       // We don't actually care which thread this called from, just so long as
       // its consistent.
-      if (!compositor_thread_checker_)
-        compositor_thread_checker_.reset(new base::ThreadChecker());
-      DCHECK(compositor_thread_checker_->CalledOnValidThread());
+      if (!compositor_thread_checker)
+        compositor_thread_checker.reset(new base::ThreadChecker());
+      DCHECK(compositor_thread_checker->CalledOnValidThread());
 #endif
     }
   };
 
   // Don't access main_thread_only_, instead use MainThreadOnly().
   MainThreadOnly main_thread_only_;
   MainThreadOnly& MainThreadOnly() {
     helper_.CheckOnValidThread();
     return main_thread_only_;
   }
@@ skipping 23 matching lines @@
 
   PollableThreadSafeFlag policy_may_need_update_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace scheduler
 
 #endif  // COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_