[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_)),
+        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()),
         idle_task_runner_(scheduler_->IdleTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
   ~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(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
@@ skipping 36 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_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);
 };
 
@@ skipping 713 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Process the input event with a new BeginMainFrame.
   DoMainFrame();
   clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   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