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

content/renderer/scheduler/renderer_scheduler_impl_unittest.cc

Index: content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc b/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
index 4a97a0454749f11708d1fdb98d7f81e2202a5354..1b300a71dac8d70c307af30faa69576fe43d8451 100644
--- a/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
+++ b/content/renderer/scheduler/renderer_scheduler_impl_unittest.cc
@@ -7,6 +7,8 @@
 #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"
 
@@ -47,7 +49,20 @@ class RendererSchedulerImplTest : public testing::Test {
   RendererSchedulerImplTest()
       : clock_(cc::TestNowSource::Create(5000)),
         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
-        scheduler_(new RendererSchedulerImpl(mock_task_runner_)),
+        scheduler_(new RendererSchedulerImpl(
+            NestableTaskRunnerForTest::Create(mock_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),
+        scheduler_(new RendererSchedulerImpl(
+            RendererSchedulerMessageLoopDelegate::Create(message_loop))),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
@@ -56,7 +71,14 @@ class RendererSchedulerImplTest : public testing::Test {
   }
   ~RendererSchedulerImplTest() override {}
 
-  void RunUntilIdle() { 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());

[Sami, 2015/03/12 18:53:11]

Missed a golden opportunity to use ^ :)

[rmcilroy, 2015/03/13 10:56:53]

Ahh the seldom used bitwise XOR operator.  I think I will save my XOR allowance
for another time ;).

+    if (mock_task_runner_.get())
+      mock_task_runner_->RunUntilIdle();
+    else
+      message_loop_->RunUntilIdle();
+  }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
@@ -113,7 +135,9 @@ class RendererSchedulerImplTest : public testing::Test {
   }
 
   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_ptr<RendererSchedulerImpl> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
@@ -847,4 +871,64 @@ TEST_F(RendererSchedulerImplTest, InputArrivesAfterBeginFrame) {
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
+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