scheduler: Detect load RAIL mode

third_party/WebKit/Source/platform/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 THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
 
 #include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
@@ skipping 45 matching lines @@
     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.
+    // A 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);
@@ skipping 94 matching lines @@
   RealTimeDomain* real_time_domain() const {
     return helper_.real_time_domain();
   }
 
   AutoAdvancingVirtualTimeDomain* GetVirtualTimeDomain();
 
   TaskQueueThrottler* task_queue_throttler() const {
     return task_queue_throttler_.get();
   }
 
+  void OnFirstMeaningfulPaint();
+
  private:
   friend class RendererSchedulerImplTest;
   friend class RendererSchedulerImplForTest;
   friend class RenderWidgetSchedulingState;
 
   enum class ExpensiveTaskPolicy { RUN, BLOCK, THROTTLE };
 
   enum class TimeDomainType {
     REAL,
     THROTTLED,
@@ skipping 66 matching lines @@
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValueLocked(
       base::TimeTicks optional_now) const;
   void CreateTraceEventObjectSnapshotLocked() const;
 
   static bool ShouldPrioritizeInputEvent(const WebInputEvent& web_input_event);
 
   // 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;
-
   // The amount of time in milliseconds we have to respond to user input as
   // defined by RAILS.
   static const int kRailsResponseTimeMillis = 50;
 
   // The amount of time to wait before suspending shared timers after the
   // renderer has been backgrounded. This is used only if background suspension
   // of shared timers is enabled.
   static const int kSuspendTimersWhenBackgroundedDelayMillis = 5 * 60 * 1000;
 
   // The time we should stay in a priority-escalated mode after a call to
@@ skipping 126 matching lines @@
     bool use_virtual_time;
     std::set<WebViewSchedulerImpl*> web_view_schedulers;  // Not owned.
     RAILModeObserver* rail_mode_observer;                 // 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;
     bool awaiting_touch_start_response;
     bool in_idle_period;
     bool begin_main_frame_on_critical_path;
     bool last_gesture_was_compositor_driven;
     bool default_gesture_prevented;
     bool have_seen_touchstart;
+    bool waiting_for_meaningful_paint;
   };
 
   struct CompositorThreadOnly {
     CompositorThreadOnly();
     ~CompositorThreadOnly();
 
     WebInputEvent::Type last_input_type;
     std::unique_ptr<base::ThreadChecker> compositor_thread_checker;
 
     void CheckOnValidThread() {
@@ skipping 40 matching lines @@
   PollableThreadSafeFlag policy_may_need_update_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_