Revert of [scheduler] Split suspendable tq from unthrottled tq. (patchset #4...

Revert of [scheduler] Split suspendable tq from unthrottled tq. (patchset #4 id:60001 of https://codereview.chromium.org/2754673002/ )

Reason for revert:
Causing failures in perf tests. Reverting to confirm it is the culprit.

crbug.com/706108
crbug.com/706104

Original issue's description:
> [scheduler] Add suspendable task queue.
>
> Add suspendable task queue to avoid running (and cancelling) callbacks
> when execution context is suspended.
>
> R=skyostil@chromium.org,alexclarke@chromium.org,haraken@chromium.org
> CC=nhiroki@chromium.org,tzik@chromium.org
> BUG=700792
>
> Review-Url: https://codereview.chromium.org/2754673002
> Cr-Commit-Position: refs/heads/master@{#459787}
> Committed: https://chromium.googlesource.com/chromium/src/+/12e16766adec5bb1e5cdd73d3cd8f5016b59ce18

TBR=alexclarke@chromium.org,haraken@chromium.org,skyostil@chromium.org,altimin@chromium.org
# Not skipping CQ checks because original CL landed more than 1 days ago.
BUG=700792

Review-Url: https://codereview.chromium.org/2780233002
Cr-Commit-Position: refs/heads/master@{#460519}

third_party/WebKit/Source/core/dom/TaskRunnerHelper.cpp

@@ -47,8 +47,6 @@ RefPtr<WebTaskRunner> TaskRunnerHelper::get(TaskType type, LocalFrame* frame) {
     case TaskType::WebGL:
     case TaskType::UnspecedTimer:
     case TaskType::MiscPlatformAPI:
-      return frame ? frame->frameScheduler()->suspendableTaskRunner()
-                   : Platform::current()->currentThread()->getWebTaskRunner();
     case TaskType::Unthrottled:
       return frame ? frame->frameScheduler()->unthrottledTaskRunner()
                    : Platform::current()->currentThread()->getWebTaskRunner();

third_party/WebKit/Source/core/loader/EmptyClients.cpp

@@ -75,7 +75,6 @@ class EmptyFrameScheduler : public WebFrameScheduler {
   RefPtr<WebTaskRunner> loadingTaskRunner() override;
   RefPtr<WebTaskRunner> timerTaskRunner() override;
   RefPtr<WebTaskRunner> unthrottledTaskRunner() override;
-  RefPtr<WebTaskRunner> suspendableTaskRunner() override;
 };
 
 RefPtr<WebTaskRunner> EmptyFrameScheduler::loadingTaskRunner() {
@@ -90,10 +89,6 @@ RefPtr<WebTaskRunner> EmptyFrameScheduler::unthrottledTaskRunner() {
   return Platform::current()->mainThread()->getWebTaskRunner();
 }
 
-RefPtr<WebTaskRunner> EmptyFrameScheduler::suspendableTaskRunner() {
-  return Platform::current()->mainThread()->getWebTaskRunner();
-}
-
 PopupMenu* EmptyChromeClient::openPopupMenu(LocalFrame&, HTMLSelectElement&) {
   return new EmptyPopupMenu();
 }

third_party/WebKit/Source/platform/WebFrameScheduler.h

@@ -51,13 +51,6 @@ class WebFrameScheduler {
   // WebFrameScheduler owns the returned WebTaskRunner.
   virtual RefPtr<WebTaskRunner> timerTaskRunner() = 0;
 
-  // Returns the WebTaskRunner for tasks which shouldn't get throttled,
-  // but can be suspended.
-  // TODO(altimin): This is a transitional task runner. Unthrottled task runner
-  // would become suspendable in the nearest future and a new unsuspended
-  // task runner will be added.
-  virtual RefPtr<WebTaskRunner> suspendableTaskRunner() = 0;
-
   // Returns the WebTaskRunner for tasks which should never get throttled.
   // This is generally used for executing internal browser tasks which should
   // never be throttled. Ideally only tasks whose performance characteristics

third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.cc

@@ -74,11 +74,6 @@ WebFrameSchedulerImpl::~WebFrameSchedulerImpl() {
     unthrottled_task_queue_->SetBlameContext(nullptr);
   }
 
-  if (suspendable_task_queue_) {
-    suspendable_task_queue_->UnregisterTaskQueue();
-    suspendable_task_queue_->SetBlameContext(nullptr);
-  }
-
   if (parent_web_view_scheduler_) {
     parent_web_view_scheduler_->Unregister(this);
 
@@ -167,23 +162,6 @@ RefPtr<blink::WebTaskRunner> WebFrameSchedulerImpl::timerTaskRunner() {
   return timer_web_task_runner_;
 }
 
-RefPtr<blink::WebTaskRunner> WebFrameSchedulerImpl::suspendableTaskRunner() {
-  DCHECK(parent_web_view_scheduler_);
-  if (!suspendable_web_task_runner_) {
-    // TODO(altimin): Split FRAME_UNTHROTTLED into FRAME_UNTHROTTLED and
-    // FRAME_UNSUSPENDED.
-    suspendable_task_queue_ = renderer_scheduler_->NewTimerTaskRunner(
-        TaskQueue::QueueType::FRAME_UNTHROTTLED);
-    suspendable_task_queue_->SetBlameContext(blame_context_);
-    suspendable_web_task_runner_ =
-        WebTaskRunnerImpl::create(suspendable_task_queue_);
-    suspendable_queue_enabled_voter_ =
-        suspendable_task_queue_->CreateQueueEnabledVoter();
-    suspendable_queue_enabled_voter_->SetQueueEnabled(!frame_suspended_);
-  }
-  return suspendable_web_task_runner_;
-}
-
 RefPtr<blink::WebTaskRunner> WebFrameSchedulerImpl::unthrottledTaskRunner() {
   DCHECK(parent_web_view_scheduler_);
   if (!unthrottled_web_task_runner_) {
@@ -246,10 +224,6 @@ void WebFrameSchedulerImpl::AsValueInto(
     state->SetString("unthrottled_task_queue",
                      PointerToId(unthrottled_task_queue_.get()));
   }
-  if (suspendable_task_queue_) {
-    state->SetString("suspendable_task_queue",
-                     PointerToId(suspendable_task_queue_.get()));
-  }
   if (blame_context_) {
     state->BeginDictionary("blame_context");
     state->SetString(
@@ -278,8 +252,6 @@ void WebFrameSchedulerImpl::setSuspended(bool frame_suspended) {
     loading_queue_enabled_voter_->SetQueueEnabled(!frame_suspended);
   if (timer_queue_enabled_voter_)
     timer_queue_enabled_voter_->SetQueueEnabled(!frame_suspended);
-  if (suspendable_queue_enabled_voter_)
-    suspendable_queue_enabled_voter_->SetQueueEnabled(!frame_suspended);
 }
 
 void WebFrameSchedulerImpl::onFirstMeaningfulPaint() {

third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.h

@@ -45,7 +45,6 @@ class WebFrameSchedulerImpl : public WebFrameScheduler {
   void setCrossOrigin(bool cross_origin) override;
   RefPtr<WebTaskRunner> loadingTaskRunner() override;
   RefPtr<WebTaskRunner> timerTaskRunner() override;
-  RefPtr<WebTaskRunner> suspendableTaskRunner() override;
   RefPtr<WebTaskRunner> unthrottledTaskRunner() override;
   WebViewScheduler* webViewScheduler() override;
   void didStartLoading(unsigned long identifier) override;
@@ -86,15 +85,11 @@ class WebFrameSchedulerImpl : public WebFrameScheduler {
   scoped_refptr<TaskQueue> loading_task_queue_;
   scoped_refptr<TaskQueue> timer_task_queue_;
   scoped_refptr<TaskQueue> unthrottled_task_queue_;
-  scoped_refptr<TaskQueue> suspendable_task_queue_;
   std::unique_ptr<TaskQueue::QueueEnabledVoter> loading_queue_enabled_voter_;
   std::unique_ptr<TaskQueue::QueueEnabledVoter> timer_queue_enabled_voter_;
-  std::unique_ptr<TaskQueue::QueueEnabledVoter>
-      suspendable_queue_enabled_voter_;
   RefPtr<WebTaskRunnerImpl> loading_web_task_runner_;
   RefPtr<WebTaskRunnerImpl> timer_web_task_runner_;
   RefPtr<WebTaskRunnerImpl> unthrottled_web_task_runner_;
-  RefPtr<WebTaskRunnerImpl> suspendable_web_task_runner_;
   RendererSchedulerImpl* renderer_scheduler_;        // NOT OWNED
   WebViewSchedulerImpl* parent_web_view_scheduler_;  // NOT OWNED
   base::trace_event::BlameContext* blame_context_;   // NOT OWNED

third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl_unittest.cc

@@ -207,8 +207,6 @@ TEST_F(WebFrameSchedulerImplTest, SuspendAndResume) {
       BLINK_FROM_HERE, WTF::bind(&IncrementCounter, WTF::unretained(&counter)));
   web_frame_scheduler_->unthrottledTaskRunner()->postTask(
       BLINK_FROM_HERE, WTF::bind(&IncrementCounter, WTF::unretained(&counter)));
-  web_frame_scheduler_->suspendableTaskRunner()->postTask(
-      BLINK_FROM_HERE, WTF::bind(&IncrementCounter, WTF::unretained(&counter)));
 
   web_frame_scheduler_->setSuspended(true);
 
@@ -220,7 +218,7 @@ TEST_F(WebFrameSchedulerImplTest, SuspendAndResume) {
 
   EXPECT_EQ(1, counter);
   mock_task_runner_->RunUntilIdle();
-  EXPECT_EQ(4, counter);
+  EXPECT_EQ(3, counter);
 }
 
 }  // namespace scheduler