[content] Add support for Non nestable idle tasks the the RendererScheduler

content/renderer/scheduler/renderer_scheduler_impl_unittest.cc

 // 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.
 
 #include "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
+#include "content/renderer/scheduler/nestable_task_runner_for_test.h"
+#include "content/renderer/scheduler/renderer_scheduler_message_loop_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 class FakeInputEvent : public blink::WebInputEvent {
  public:
   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
       : WebInputEvent(sizeof(FakeInputEvent)) {
@@ skipping 20 matching lines @@
 
 };  // namespace
 
 class RendererSchedulerImplTest : public testing::Test {
  public:
   using Policy = RendererSchedulerImpl::Policy;
 
   RendererSchedulerImplTest()
       : clock_(cc::TestNowSource::Create(5000)),
         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
-        scheduler_(new RendererSchedulerImpl(mock_task_runner_)),
+        nestable_task_runner_(
+            NestableTaskRunnerForTest::Create(mock_task_runner_)),
+        scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
+        idle_task_runner_(scheduler_->IdleTaskRunner()) {
+    scheduler_->SetTimeSourceForTesting(clock_);
+  }
+
+  RendererSchedulerImplTest(base::MessageLoop* message_loop)
+      : clock_(cc::TestNowSource::Create(5000)),
+        message_loop_(message_loop),
+        nestable_task_runner_(
+            RendererSchedulerMessageLoopDelegate::Create(message_loop)),
+        scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),
+        default_task_runner_(scheduler_->DefaultTaskRunner()),
+        compositor_task_runner_(scheduler_->CompositorTaskRunner()),
+        loading_task_runner_(scheduler_->LoadingTaskRunner()),
         idle_task_runner_(scheduler_->IdleTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
   ~RendererSchedulerImplTest() override {}
 
   void TearDown() override {
-    // Check that all tests stop posting tasks.
-    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-    while (RunUntilIdle()) {
+    DCHECK(!mock_task_runner_.get() || !message_loop_.get());
+    if (mock_task_runner_.get()) {
+      // Check that all tests stop posting tasks.
+      mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+      while (mock_task_runner_->RunUntilIdle()) {
+      }
+    } else {
+      message_loop_->RunUntilIdle();
     }
   }
 
-  bool RunUntilIdle() { return mock_task_runner_->RunUntilIdle(); }
+  void RunUntilIdle() {
+    // Only one of mock_task_runner_ or message_loop_ should be set.
+    DCHECK(!mock_task_runner_.get() || !message_loop_.get());
+    if (mock_task_runner_.get())
+      mock_task_runner_->RunUntilIdle();
+    else
+      message_loop_->RunUntilIdle();
+  }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
@@ skipping 46 matching lines @@
     }
   }
 
  protected:
   static base::TimeDelta priority_escalation_after_input_duration() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kPriorityEscalationAfterInputMillis);
   }
 
   scoped_refptr<cc::TestNowSource> clock_;
+  // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
+  scoped_ptr<base::MessageLoop> message_loop_;
 
+  scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   scoped_ptr<RendererSchedulerImpl> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
 };
 
 void NullTask() {
@@ skipping 715 matching lines @@
   // Process the input event with a new BeginMainFrame.
   DoMainFrame();
   clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
 class RendererSchedulerImplForTest : public RendererSchedulerImpl {
  public:
   RendererSchedulerImplForTest(
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+      scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
       : RendererSchedulerImpl(main_task_runner), update_policy_count_(0) {}
 
   void UpdatePolicyLocked() override {
     update_policy_count_++;
     RendererSchedulerImpl::UpdatePolicyLocked();
   }
 
   int update_policy_count_;
 };
 
 TEST_F(RendererSchedulerImplTest, OnlyOnePendingUrgentPolicyUpdatey) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
 
   EnsureUrgentPolicyUpdatePostedOnMainThread();
   EnsureUrgentPolicyUpdatePostedOnMainThread();
   EnsureUrgentPolicyUpdatePostedOnMainThread();
   EnsureUrgentPolicyUpdatePostedOnMainThread();
 
   RunUntilIdle();
 
   EXPECT_EQ(1, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, OnePendingDelayedAndOneUrgentUpdatePolicy) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->SetTimeSourceForTesting(clock_);
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
   EnsureUrgentPolicyUpdatePostedOnMainThread();
 
   RunUntilIdle();
 
   // We expect both the urgent and the delayed updates to run.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, OneUrgentAndOnePendingDelayedUpdatePolicy) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->SetTimeSourceForTesting(clock_);
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   EnsureUrgentPolicyUpdatePostedOnMainThread();
   ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
 
   RunUntilIdle();
 
   // We expect both the urgent and the delayed updates to run.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByOneInputEvent) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->SetTimeSourceForTesting(clock_);
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
 
   RunUntilIdle();
 
   // We expect an urgent policy update followed by a delayed one 100ms later.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByTwoInputEvents) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->SetTimeSourceForTesting(clock_);
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchMove));
 
   RunUntilIdle();
 
   // We expect an urgent policy update followed by a delayed one 100ms later.
   EXPECT_EQ(2, mock_scheduler->update_policy_count_);
 }
 
 TEST_F(RendererSchedulerImplTest, EnsureUpdatePolicyNotTriggeredTooOften) {
   RendererSchedulerImplForTest* mock_scheduler =
-      new RendererSchedulerImplForTest(mock_task_runner_);
+      new RendererSchedulerImplForTest(nestable_task_runner_);
   scheduler_.reset(mock_scheduler);
   scheduler_->SetTimeSourceForTesting(clock_);
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart));
   scheduler_->DidReceiveInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchMove));
 
   // We expect the first call to IsHighPriorityWorkAnticipated to be called
@@ skipping 12 matching lines @@
   scheduler_->ShouldYieldForHighPriorityWork();
 
   EXPECT_EQ(1, mock_scheduler->update_policy_count_);
 
   RunUntilIdle();
   // We expect both the urgent and the delayed updates to run in addition to the
   // earlier updated cause by IsHighPriorityWorkAnticipated.
   EXPECT_EQ(3, mock_scheduler->update_policy_count_);
 }
 
+class RendererSchedulerImplWithMessageLoopTest
+    : public RendererSchedulerImplTest {
+ public:
+  RendererSchedulerImplWithMessageLoopTest()
+      : RendererSchedulerImplTest(new base::MessageLoop()) {}
+  ~RendererSchedulerImplWithMessageLoopTest() override {}
+
+  void PostFromNestedRunloop(std::vector<
+      std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>* tasks) {
+    base::MessageLoop::ScopedNestableTaskAllower allow(message_loop_.get());
+    for (std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>& pair : *tasks) {
+      if (pair.second) {
+        idle_task_runner_->PostIdleTask(FROM_HERE, pair.first);
+      } else {
+        idle_task_runner_->PostNonNestableIdleTask(FROM_HERE, pair.first);
+      }
+    }
+    EnableIdleTasks();
+    message_loop_->RunUntilIdle();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplWithMessageLoopTest);
+};
+
+TEST_F(RendererSchedulerImplWithMessageLoopTest,
+       NonNestableIdleTaskDoesntExecuteInNestedLoop) {
+  std::vector<std::string> order;
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("1")));
+  idle_task_runner_->PostIdleTask(
+      FROM_HERE,
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("2")));
+
+  std::vector<std::pair<SingleThreadIdleTaskRunner::IdleTask, bool>>
+      tasks_to_post_from_nested_loop;
+  tasks_to_post_from_nested_loop.push_back(std::make_pair(
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("3")),
+      false));
+  tasks_to_post_from_nested_loop.push_back(std::make_pair(
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("4")), true));
+  tasks_to_post_from_nested_loop.push_back(std::make_pair(
+      base::Bind(&AppendToVectorIdleTestTask, &order, std::string("5")), true));
+
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &RendererSchedulerImplWithMessageLoopTest::PostFromNestedRunloop,
+          base::Unretained(this),
+          base::Unretained(&tasks_to_post_from_nested_loop)));
+
+  EnableIdleTasks();
+  RunUntilIdle();
+  // Note we expect task 3 to run last because it's non-nestable.
+  EXPECT_THAT(order, testing::ElementsAre(std::string("1"), std::string("2"),
+                                          std::string("4"), std::string("5"),
+                                          std::string("3")));
+}
+
 }  // namespace content