Remove {WebMain,}ThreadScheduler::{Add,Remove}PendingNavigation().

All overridden implementations of ThreadScheduler's interfaces are
no-op, so they can be removed without breaking any functionalities.

WebMainThreadScheduler's interfaces actually have some implementation.
However, they are not used by any production code, and only a few
tests depend on them.

There functions are perhaps the remnants of past refactoring. Since
nobody seems to rely on them currently, they can be removed entirely.

Bug: 826203
Change-Id: Ic8efe0afe09270c080bc7706287937a6da354ae1
Reviewed-on: https://chromium-review.googlesource.com/1055142Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Cr-Commit-Position: refs/heads/master@{#558226}

third_party/blink/public/platform/scheduler/test/fake_renderer_scheduler.h

@@ -46,8 +46,6 @@ class FakeRendererScheduler : public WebMainThreadScheduler {
   void PauseTimersForAndroidWebView() override;
   void ResumeTimersForAndroidWebView() override;
 #endif
-  void AddPendingNavigation(NavigatingFrameType type) override;
-  void RemovePendingNavigation(NavigatingFrameType type) override;
   bool IsHighPriorityWorkAnticipated() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
   bool ShouldYieldForHighPriorityWork() override;

third_party/blink/public/platform/scheduler/test/mock_renderer_scheduler.h

@@ -52,8 +52,6 @@ class MockRendererScheduler : public WebMainThreadScheduler {
   MOCK_METHOD0(PauseTimersForAndroidWebView, void());
   MOCK_METHOD0(ResumeTimersForAndroidWebView, void());
 #endif
-  MOCK_METHOD1(AddPendingNavigation, void(NavigatingFrameType));
-  MOCK_METHOD1(RemovePendingNavigation, void(NavigatingFrameType));
   MOCK_METHOD0(OnNavigate, void());
   MOCK_METHOD0(IsHighPriorityWorkAnticipated, bool());
   MOCK_CONST_METHOD0(CanExceedIdleDeadlineIfRequired, bool());

third_party/blink/public/platform/scheduler/web_main_thread_scheduler.h

@@ -167,18 +167,6 @@ class BLINK_PLATFORM_EXPORT WebMainThreadScheduler : public WebThreadScheduler {
   virtual std::unique_ptr<RendererPauseHandle> PauseRenderer()
       WARN_UNUSED_RESULT = 0;
 
-  enum class NavigatingFrameType { kMainFrame, kChildFrame };
-
-  // Tells the scheduler that a navigation task is pending. While any main-frame
-  // navigation tasks are pending, the scheduler will ensure that loading tasks
-  // are not blocked even if they are expensive. Must be called on the main
-  // thread.
-  virtual void AddPendingNavigation(NavigatingFrameType type) = 0;
-
-  // Tells the scheduler that a navigation task is no longer pending.
-  // Must be called on the main thread.
-  virtual void RemovePendingNavigation(NavigatingFrameType type) = 0;
-
   // Returns true if the scheduler has reason to believe that high priority work
   // may soon arrive on the main thread, e.g., if gesture events were observed
   // recently.

third_party/blink/renderer/core/dom/idle_deadline_test.cc

@@ -37,10 +37,6 @@ class MockIdleDeadlineScheduler final : public ThreadScheduler {
   std::unique_ptr<RendererPauseHandle> PauseScheduler() override {
     return nullptr;
   }
-  void AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) override {}
-  void RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) override {}
 
   base::TimeTicks MonotonicallyIncreasingVirtualTime() const override {
     return base::TimeTicks();

third_party/blink/renderer/core/dom/scripted_idle_task_controller_test.cc

@@ -44,10 +44,6 @@ class MockScriptedIdleTaskControllerScheduler final : public ThreadScheduler {
   std::unique_ptr<RendererPauseHandle> PauseScheduler() override {
     return nullptr;
   }
-  void AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) override {}
-  void RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) override {}
 
   base::TimeTicks MonotonicallyIncreasingVirtualTime() const override {
     return base::TimeTicks();

third_party/blink/renderer/core/loader/navigation_scheduler.cc

@@ -360,19 +360,9 @@ class ScheduledFormSubmission final : public ScheduledNavigation {
   Member<FormSubmission> submission_;
 };
 
-NavigationScheduler::NavigationScheduler(LocalFrame* frame)
-    : frame_(frame),
-      frame_type_(frame_->IsMainFrame()
-                      ? scheduler::WebMainThreadScheduler::NavigatingFrameType::
-                            kMainFrame
-                      : scheduler::WebMainThreadScheduler::NavigatingFrameType::
-                            kChildFrame) {}
+NavigationScheduler::NavigationScheduler(LocalFrame* frame) : frame_(frame) {}
 
 NavigationScheduler::~NavigationScheduler() {
-  if (navigate_task_handle_.IsActive()) {
-    Platform::Current()->CurrentThread()->Scheduler()->RemovePendingNavigation(
-        frame_type_);
-  }
 }
 
 bool NavigationScheduler::LocationChangePending() {
@@ -501,9 +491,6 @@ void NavigationScheduler::ScheduleReload() {
 }
 
 void NavigationScheduler::NavigateTask() {
-  Platform::Current()->CurrentThread()->Scheduler()->RemovePendingNavigation(
-      frame_type_);
-
   if (!frame_->GetPage())
     return;
   if (frame_->GetPage()->Paused()) {
@@ -550,10 +537,6 @@ void NavigationScheduler::StartTimer() {
   if (!redirect_->ShouldStartTimer(frame_))
     return;
 
-  ThreadScheduler* scheduler =
-      Platform::Current()->CurrentThread()->Scheduler();
-  scheduler->AddPendingNavigation(frame_type_);
-
   // wrapWeakPersistent(this) is safe because a posted task is canceled when the
   // task handle is destroyed on the dtor of this NavigationScheduler.
   navigate_task_handle_ = PostDelayedCancellableTask(
@@ -567,8 +550,6 @@ void NavigationScheduler::StartTimer() {
 
 void NavigationScheduler::Cancel() {
   if (navigate_task_handle_.IsActive()) {
-    Platform::Current()->CurrentThread()->Scheduler()->RemovePendingNavigation(
-        frame_type_);
     probe::frameClearedScheduledNavigation(frame_);
   }
   navigate_task_handle_.Cancel();

third_party/blink/renderer/core/loader/navigation_scheduler.h

@@ -92,9 +92,6 @@ class CORE_EXPORT NavigationScheduler final
   TaskHandle navigate_task_handle_;
   Member<ScheduledNavigation> redirect_;
 
-  // Exists because we can't deref m_frame in destructor.
-  scheduler::WebMainThreadScheduler::NavigatingFrameType frame_type_;
-
   DISALLOW_COPY_AND_ASSIGN(NavigationScheduler);
 };
 

third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h

@@ -43,10 +43,6 @@ class PLATFORM_EXPORT WebSchedulerImpl : public ThreadScheduler {
       PageScheduler::Delegate*) override;
   std::unique_ptr<RendererPauseHandle> PauseScheduler() override
       WARN_UNUSED_RESULT;
-  void AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
-  void RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
 
   // Returns TimeTicks::Now() by default.
   base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -379,11 +379,6 @@ MainThreadSchedulerImpl::MainThreadOnly::MainThreadOnly(
                            "Scheduler.PauseCount",
                            main_thread_scheduler_impl,
                            &main_thread_scheduler_impl->tracing_controller_),
-      navigation_task_expected_count(
-          0,
-          "Scheduler.NavigationTaskExpectedCount",
-          main_thread_scheduler_impl,
-          &main_thread_scheduler_impl->tracing_controller_),
       expensive_task_policy(ExpensiveTaskPolicy::kRun,
                             "Scheduler.ExpensiveTaskPolicy",
                             main_thread_scheduler_impl,
@@ -1513,8 +1508,7 @@ void MainThreadSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
     new_policy.rail_mode() = v8::PERFORMANCE_IDLE;
 
   if (expensive_task_policy == ExpensiveTaskPolicy::kBlock &&
-      (!main_thread_only().have_seen_a_begin_main_frame ||
-       main_thread_only().navigation_task_expected_count > 0)) {
+      !main_thread_only().have_seen_a_begin_main_frame) {
     expensive_task_policy = ExpensiveTaskPolicy::kRun;
   }
 
@@ -2090,8 +2084,6 @@ MainThreadSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
       "fling_compositor_escalation_deadline",
       (any_thread().fling_compositor_escalation_deadline - base::TimeTicks())
           .InMillisecondsF());
-  state->SetInteger("navigation_task_expected_count",
-                    main_thread_only().navigation_task_expected_count);
   state->SetDouble("last_idle_period_end_time",
                    (any_thread().last_idle_period_end_time - base::TimeTicks())
                        .InMillisecondsF());
@@ -2274,25 +2266,6 @@ void MainThreadSchedulerImpl::DispatchRequestBeginMainFrameNotExpected(
   }
 }
 
-void MainThreadSchedulerImpl::AddPendingNavigation(NavigatingFrameType type) {
-  helper_.CheckOnValidThread();
-  if (type == NavigatingFrameType::kMainFrame) {
-    main_thread_only().navigation_task_expected_count++;
-    UpdatePolicy();
-  }
-}
-
-void MainThreadSchedulerImpl::RemovePendingNavigation(
-    NavigatingFrameType type) {
-  helper_.CheckOnValidThread();
-  DCHECK_GT(main_thread_only().navigation_task_expected_count, 0);
-  if (type == NavigatingFrameType::kMainFrame &&
-      main_thread_only().navigation_task_expected_count > 0) {
-    main_thread_only().navigation_task_expected_count--;
-    UpdatePolicy();
-  }
-}
-
 std::unique_ptr<base::SingleSampleMetric>
 MainThreadSchedulerImpl::CreateMaxQueueingTimeMetric() {
   return base::SingleSampleMetricsFactory::Get()->CreateCustomCountsMetric(

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -121,8 +121,6 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
 #endif
   std::unique_ptr<RendererPauseHandle> PauseRenderer() override
       WARN_UNUSED_RESULT;
-  void AddPendingNavigation(NavigatingFrameType type) override;
-  void RemovePendingNavigation(NavigatingFrameType type) override;
   bool IsHighPriorityWorkAnticipated() override;
   bool ShouldYieldForHighPriorityWork() override;
   bool CanExceedIdleDeadlineIfRequired() const override;
@@ -673,8 +671,6 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
         longest_jank_free_task_duration;
     TraceableCounter<int, kTracingCategoryNameInfo>
         renderer_pause_count;  // Renderer is paused if non-zero.
-    TraceableCounter<int, kTracingCategoryNameDebug>
-        navigation_task_expected_count;
     TraceableState<ExpensiveTaskPolicy, kTracingCategoryNameInfo>
         expensive_task_policy;
     TraceableState<v8::RAILMode, kTracingCategoryNameInfo>

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc

@@ -583,10 +583,6 @@ class MainThreadSchedulerImplTest : public testing::Test {
     return scheduler_->main_thread_only().estimated_next_frame_begin;
   }
 
-  int NavigationTaskExpectedCount() {
-    return scheduler_->main_thread_only().navigation_task_expected_count;
-  }
-
   void AdvanceTimeWithTask(double duration) {
     base::TimeTicks start = clock_.NowTicks();
     scheduler_->OnTaskStarted(fake_queue_.get(), fake_task_, start);
@@ -2730,8 +2726,6 @@ TEST_F(MainThreadSchedulerImplTest,
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
-  scheduler_->AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kChildFrame);
 
   PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
@@ -2741,108 +2735,6 @@ TEST_F(MainThreadSchedulerImplTest,
   EXPECT_EQ(v8::PERFORMANCE_RESPONSE, GetRAILMode());
 }
 
-TEST_F(MainThreadSchedulerImplTest,
-       ExpensiveLoadingTasksNotBlockedIfMainFrameNavigationExpected) {
-  std::vector<std::string> run_order;
-
-  DoMainFrame();
-  scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
-  SimulateExpensiveTasks(loading_task_runner_);
-  ForceTouchStartToBeExpectedSoon();
-  scheduler_->AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-
-  PostTestTasks(&run_order, "L1 D1");
-  RunUntilIdle();
-
-  EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
-  EXPECT_TRUE(HaveSeenABeginMainframe());
-  EXPECT_TRUE(LoadingTasksSeemExpensive());
-  EXPECT_FALSE(TimerTasksSeemExpensive());
-  EXPECT_TRUE(TouchStartExpectedSoon());
-  EXPECT_EQ(1, NavigationTaskExpectedCount());
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("D1")));
-
-  // After the nagigation has been cancelled, the expensive loading tasks should
-  // get blocked.
-  scheduler_->RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-  run_order.clear();
-
-  PostTestTasks(&run_order, "L1 D1");
-  RunUntilIdle();
-
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-  EXPECT_TRUE(HaveSeenABeginMainframe());
-  EXPECT_TRUE(LoadingTasksSeemExpensive());
-  EXPECT_FALSE(TimerTasksSeemExpensive());
-  EXPECT_TRUE(TouchStartExpectedSoon());
-  EXPECT_EQ(0, NavigationTaskExpectedCount());
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
-  EXPECT_EQ(v8::PERFORMANCE_RESPONSE, GetRAILMode());
-}
-
-TEST_F(MainThreadSchedulerImplTest,
-       ExpensiveLoadingTasksNotBlockedIfMainFrameNavigationExpected_Multiple) {
-  std::vector<std::string> run_order;
-
-  DoMainFrame();
-  scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
-  SimulateExpensiveTasks(loading_task_runner_);
-  ForceTouchStartToBeExpectedSoon();
-  scheduler_->AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-  scheduler_->AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-
-  PostTestTasks(&run_order, "L1 D1");
-  RunUntilIdle();
-
-  EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
-  EXPECT_TRUE(HaveSeenABeginMainframe());
-  EXPECT_TRUE(LoadingTasksSeemExpensive());
-  EXPECT_FALSE(TimerTasksSeemExpensive());
-  EXPECT_TRUE(TouchStartExpectedSoon());
-  EXPECT_EQ(2, NavigationTaskExpectedCount());
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("D1")));
-
-  run_order.clear();
-  scheduler_->RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-  // Navigation task expected ref count non-zero so expensive tasks still not
-  // blocked.
-  PostTestTasks(&run_order, "L1 D1");
-  RunUntilIdle();
-
-  EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
-  EXPECT_TRUE(HaveSeenABeginMainframe());
-  EXPECT_TRUE(LoadingTasksSeemExpensive());
-  EXPECT_FALSE(TimerTasksSeemExpensive());
-  EXPECT_TRUE(TouchStartExpectedSoon());
-  EXPECT_EQ(1, NavigationTaskExpectedCount());
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("D1")));
-
-  run_order.clear();
-  scheduler_->RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType::kMainFrame);
-  // Navigation task expected ref count is now zero, the expensive loading tasks
-  // should get blocked.
-  PostTestTasks(&run_order, "L1 D1");
-  RunUntilIdle();
-
-  EXPECT_EQ(UseCase::kNone, CurrentUseCase());
-  EXPECT_TRUE(HaveSeenABeginMainframe());
-  EXPECT_TRUE(LoadingTasksSeemExpensive());
-  EXPECT_FALSE(TimerTasksSeemExpensive());
-  EXPECT_TRUE(TouchStartExpectedSoon());
-  EXPECT_EQ(0, NavigationTaskExpectedCount());
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
-  EXPECT_EQ(v8::PERFORMANCE_RESPONSE, GetRAILMode());
-}
-
 TEST_F(MainThreadSchedulerImplTest,
        ExpensiveLoadingTasksNotBlockedDuringMainThreadGestures) {
   std::vector<std::string> run_order;

third_party/blink/renderer/platform/scheduler/public/non_main_thread_scheduler.h

@@ -61,10 +61,6 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler,
       PageScheduler::Delegate*) override;
   std::unique_ptr<RendererPauseHandle> PauseScheduler() override
       WARN_UNUSED_RESULT;
-  void AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
-  void RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
 
   // Returns TimeTicks::Now() by default.
   base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;

third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h

@@ -76,15 +76,6 @@ class PLATFORM_EXPORT ThreadScheduler {
   virtual std::unique_ptr<RendererPauseHandle> PauseScheduler()
       WARN_UNUSED_RESULT = 0;
 
-  // Tells the scheduler that a navigation task is pending.
-  // TODO(alexclarke): Long term should this be a task trait?
-  virtual void AddPendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) = 0;
-
-  // Tells the scheduler that a navigation task is no longer pending.
-  virtual void RemovePendingNavigation(
-      scheduler::WebMainThreadScheduler::NavigatingFrameType) = 0;
-
   // Returns the current time recognized by the scheduler, which may perhaps
   // be based on a real or virtual time domain. Used by Timer.
   virtual base::TimeTicks MonotonicallyIncreasingVirtualTime() const = 0;

third_party/blink/renderer/platform/scheduler/test/fake_renderer_scheduler.cc

@@ -91,10 +91,6 @@ void FakeRendererScheduler::PauseTimersForAndroidWebView() {}
 void FakeRendererScheduler::ResumeTimersForAndroidWebView() {}
 #endif
 
-void FakeRendererScheduler::AddPendingNavigation(NavigatingFrameType type) {}
-
-void FakeRendererScheduler::RemovePendingNavigation(NavigatingFrameType type) {}
-
 bool FakeRendererScheduler::ShouldYieldForHighPriorityWork() {
   return false;
 }