scheduler: Tell v8 about the current RAIL mode

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/macros.h"
 #include "base/synchronization/lock.h"
 #include "components/scheduler/base/pollable_thread_safe_flag.h"
 #include "components/scheduler/child/idle_helper.h"
 #include "components/scheduler/child/scheduler_helper.h"
 #include "components/scheduler/renderer/deadline_task_runner.h"
 #include "components/scheduler/renderer/idle_time_estimator.h"
 #include "components/scheduler/renderer/render_widget_signals.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "components/scheduler/renderer/task_cost_estimator.h"
 #include "components/scheduler/renderer/throttling_helper.h"
 #include "components/scheduler/renderer/user_model.h"
 #include "components/scheduler/renderer/web_view_scheduler_impl.h"
 #include "components/scheduler/scheduler_export.h"
+#include "v8/include/v8.h"
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
 }
 }
 
 namespace scheduler {
 class RenderWidgetSchedulingState;
 class WebViewSchedulerImpl;
 class ThrottlingHelper;
 
 class SCHEDULER_EXPORT RendererSchedulerImpl
     : public RendererScheduler,
       public IdleHelper::Delegate,
       public SchedulerHelper::Observer,
       public RenderWidgetSignals::Observer {
  public:
+  // Keep RendererScheduler::UseCaseToString in sync with this enum.
+  enum class UseCase {
+    // No active use case detected.
+    NONE,
+    // A continuous gesture (e.g., scroll, pinch) which is being driven by the
+    // compositor thread.
+    COMPOSITOR_GESTURE,
+    // An unspecified touch gesture which is being handled by the main thread.
+    // Note that since we don't have a full view of the use case, we should be
+    // careful to prioritize all work equally.
+    MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+    // A continuous gesture (e.g., scroll, pinch) which is being driven by the
+    // compositor thread but also observed by the main thread. An example is
+    // synchronized scrolling where a scroll listener on the main thread changes
+    // page layout based on the current scroll position.
+    SYNCHRONIZED_GESTURE,
+    // A gesture has recently started and we are about to run main thread touch
+    // listeners to find out the actual gesture type. To minimize touch latency,
+    // only input handling work should run in this state.
+    TOUCHSTART,
+    // The page is loading.
+    LOADING,
+    // A continuous gesture (e.g., scroll) which is being handled by the main
+    // thread.
+    MAIN_THREAD_GESTURE,
+    // Must be the last entry.
+    USE_CASE_COUNT,
+    FIRST_USE_CASE = NONE,
+  };
+  static const char* UseCaseToString(UseCase use_case);
+  static const char* RAILModeToString(v8::RAILMode rail_mode);
+
   RendererSchedulerImpl(scoped_refptr<SchedulerTqmDelegate> main_task_runner);
   ~RendererSchedulerImpl() override;
 
   // RendererScheduler implementation:
   std::unique_ptr<blink::WebThread> CreateMainThread() override;
   scoped_refptr<TaskQueue> DefaultTaskRunner() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
   scoped_refptr<TaskQueue> CompositorTaskRunner() override;
   scoped_refptr<TaskQueue> LoadingTaskRunner() override;
   scoped_refptr<TaskQueue> TimerTaskRunner() override;
@@ skipping 23 matching lines @@
   bool CanExceedIdleDeadlineIfRequired() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
   void Shutdown() override;
   void SuspendTimerQueue() override;
   void ResumeTimerQueue() override;
   void SetTimerQueueSuspensionWhenBackgroundedEnabled(bool enabled) override;
   void SetTopLevelBlameContext(
       base::trace_event::BlameContext* blame_context) override;
+  void SetMainThreadIsolate(v8::Isolate* isolate) override;
 
   // RenderWidgetSignals::Observer implementation:
   void SetAllRenderWidgetsHidden(bool hidden) override;
   void SetHasVisibleRenderWidgetWithTouchHandler(
       bool has_visible_render_widget_with_touch_handler) override;
 
   // SchedulerHelper::Observer implementation:
   void OnUnregisterTaskQueue(const scoped_refptr<TaskQueue>& queue) override;
   void OnTriedToExecuteBlockedTask(const TaskQueue& queue,
                                    const base::PendingTask& task) override;
@@ skipping 54 matching lines @@
       return is_enabled == other.is_enabled && priority == other.priority &&
              time_domain_type == other.time_domain_type;
     }
   };
 
   struct Policy {
     TaskQueuePolicy compositor_queue_policy;
     TaskQueuePolicy loading_queue_policy;
     TaskQueuePolicy timer_queue_policy;
     TaskQueuePolicy default_queue_policy;
+    v8::RAILMode rail_mode = v8::PERFORMANCE_DEFAULT;
 
     bool operator==(const Policy& other) const {
       return compositor_queue_policy == other.compositor_queue_policy &&
              loading_queue_policy == other.loading_queue_policy &&
              timer_queue_policy == other.timer_queue_policy &&
-             default_queue_policy == other.default_queue_policy;
+             default_queue_policy == other.default_queue_policy &&
+             rail_mode == other.rail_mode;
     }
   };
 
   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 167 matching lines @@
     bool loading_tasks_seem_expensive;
     bool timer_tasks_seem_expensive;
     bool touchstart_expected_soon;
     bool have_seen_a_begin_main_frame;
     bool have_reported_blocking_intervention_in_current_policy;
     bool have_reported_blocking_intervention_since_navigation;
     bool has_visible_render_widget_with_touch_handler;
     bool begin_frame_not_expected_soon;
     bool expensive_task_blocking_allowed;
     bool in_idle_period_for_testing;
-    std::set<WebViewSchedulerImpl*> web_view_schedulers_;  // Not owned.
+    std::set<WebViewSchedulerImpl*> web_view_schedulers;  // Not owned.
+    v8::Isolate* isolate;                                 // Not owned.
   };
 
   struct AnyThread {
     AnyThread();
     ~AnyThread();
 
     base::TimeTicks last_idle_period_end_time;
     base::TimeTicks rails_loading_priority_deadline;
     base::TimeTicks fling_compositor_escalation_deadline;
     UserModel user_model;
@@ skipping 55 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_