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

content/renderer/scheduler/task_queue_manager_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/task_queue_manager.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "cc/test/test_now_source.h"
+#include "content/renderer/scheduler/nestable_task_runner_for_test.h"
+#include "content/renderer/scheduler/renderer_scheduler_message_loop_delegate.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 using testing::_;
 
 namespace content {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
@@ skipping 29 matching lines @@
   std::vector<const base::TaskQueue*> work_queues_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectorForTest);
 };
 
 class TaskQueueManagerTest : public testing::Test {
  protected:
   void Initialize(size_t num_queues) {
     test_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner());
     selector_ = make_scoped_ptr(new SelectorForTest);
-    manager_ = make_scoped_ptr(
-        new TaskQueueManager(num_queues, test_task_runner_, selector_.get()));
+    manager_ = make_scoped_ptr(new TaskQueueManager(
+        num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()),
+        selector_.get()));
     EXPECT_EQ(num_queues, selector_->work_queues().size());
   }
 
   void InitializeWithRealMessageLoop(size_t num_queues) {
     message_loop_.reset(new base::MessageLoop());
     selector_ = make_scoped_ptr(new SelectorForTest);
     manager_ = make_scoped_ptr(new TaskQueueManager(
-        num_queues, message_loop_->task_runner(), selector_.get()));
+        num_queues,
+        RendererSchedulerMessageLoopDelegate::Create(message_loop_.get()),
+        selector_.get()));
     EXPECT_EQ(num_queues, selector_->work_queues().size());
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
   scoped_ptr<SelectorForTest> selector_;
   scoped_ptr<TaskQueueManager> manager_;
   scoped_ptr<base::MessageLoop> message_loop_;
 };
 
 void PostFromNestedRunloop(base::MessageLoop* message_loop,
@@ skipping 752 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
   manager_.reset();
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 }
 
 }  // namespace
 }  // namespace content