scheduler: Move the Blink scheduler into Blink

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 COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
-#define COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
+#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"
-#include "components/scheduler/base/pollable_thread_safe_flag.h"
-#include "components/scheduler/base/queueing_time_estimator.h"
-#include "components/scheduler/base/task_time_tracker.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 "platform/scheduler/base/pollable_thread_safe_flag.h"
+#include "platform/scheduler/base/queueing_time_estimator.h"
+#include "platform/scheduler/base/task_time_tracker.h"
+#include "platform/scheduler/child/idle_helper.h"
+#include "platform/scheduler/child/scheduler_helper.h"
+#include "platform/scheduler/renderer/deadline_task_runner.h"
+#include "platform/scheduler/renderer/idle_time_estimator.h"
+#include "platform/scheduler/renderer/render_widget_signals.h"
+#include "public/platform/scheduler/renderer/renderer_scheduler.h"
+#include "platform/scheduler/renderer/task_cost_estimator.h"
+#include "platform/scheduler/renderer/throttling_helper.h"
+#include "platform/scheduler/renderer/user_model.h"
+#include "platform/scheduler/renderer/web_view_scheduler_impl.h"
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
 }
 }
 
+namespace blink {
 namespace scheduler {
 class RenderWidgetSchedulingState;
 class WebViewSchedulerImpl;
 class ThrottlingHelper;
 
-class SCHEDULER_EXPORT RendererSchedulerImpl
+class BLINK_PLATFORM_EXPORT RendererSchedulerImpl
     : public RendererScheduler,
       public IdleHelper::Delegate,
       public SchedulerHelper::Observer,
       public RenderWidgetSignals::Observer,
       public TaskTimeTracker,
       public QueueingTimeEstimator::Client {
  public:
   // Keep RendererScheduler::UseCaseToString in sync with this enum.
   enum class UseCase {
     // No active use case detected.
@@ skipping 23 matching lines @@
     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;
+  std::unique_ptr<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;
   scoped_refptr<TaskQueue> NewLoadingTaskRunner(const char* name) override;
   scoped_refptr<TaskQueue> NewTimerTaskRunner(const char* name) override;
   scoped_refptr<TaskQueue> NewUnthrottledTaskRunner(const char* name) override;
   std::unique_ptr<RenderWidgetSchedulingState> NewRenderWidgetSchedulingState()
       override;
   void WillBeginFrame(const cc::BeginFrameArgs& args) override;
   void BeginFrameNotExpectedSoon() override;
   void DidCommitFrameToCompositor() override;
   void DidHandleInputEventOnCompositorThread(
-      const blink::WebInputEvent& web_input_event,
+      const WebInputEvent& web_input_event,
       InputEventState event_state) override;
   void DidHandleInputEventOnMainThread(
-      const blink::WebInputEvent& web_input_event) override;
+      const WebInputEvent& web_input_event) override;
   void DidAnimateForInputOnCompositorThread() override;
   void OnRendererBackgrounded() override;
   void OnRendererForegrounded() override;
   void SuspendRenderer() override;
-  void AddPendingNavigation(
-      blink::WebScheduler::NavigatingFrameType type) override;
-  void RemovePendingNavigation(
-      blink::WebScheduler::NavigatingFrameType type) override;
+  void AddPendingNavigation(WebScheduler::NavigatingFrameType type) override;
+  void RemovePendingNavigation(WebScheduler::NavigatingFrameType type) override;
   void OnNavigationStarted() override;
   bool IsHighPriorityWorkAnticipated() override;
   bool ShouldYieldForHighPriorityWork() override;
   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;
@@ skipping 120 matching lines @@
   void OnIdlePeriodEnded() override;
 
   void EndIdlePeriod();
 
   // Returns the serialized scheduler state for tracing.
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValue(
       base::TimeTicks optional_now) const;
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> AsValueLocked(
       base::TimeTicks optional_now) const;
 
-  static bool ShouldPrioritizeInputEvent(
-      const blink::WebInputEvent& web_input_event);
+  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
@@ skipping 45 matching lines @@
   // 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;
 
   // An input event of some sort happened, the policy may need updating.
-  void UpdateForInputEventOnCompositorThread(blink::WebInputEvent::Type type,
+  void UpdateForInputEventOnCompositorThread(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();
@@ skipping 88 matching lines @@
     bool begin_main_frame_on_critical_path;
     bool last_gesture_was_compositor_driven;
     bool default_gesture_prevented;
     bool have_seen_touchstart;
   };
 
   struct CompositorThreadOnly {
     CompositorThreadOnly();
     ~CompositorThreadOnly();
 
-    blink::WebInputEvent::Type last_input_type;
+    WebInputEvent::Type last_input_type;
     std::unique_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());
 #endif
@@ skipping 30 matching lines @@
     return compositor_thread_only_;
   }
 
   PollableThreadSafeFlag policy_may_need_update_;
   base::WeakPtrFactory<RendererSchedulerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImpl);
 };
 
 }  // namespace scheduler
+}  // namespace blink
 
-#endif  // COMPONENTS_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_
+#endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_SCHEDULER_IMPL_H_