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

content/renderer/scheduler/task_queue_manager.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 <queue>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/test/test_now_source.h"
+#include "content/renderer/scheduler/nestable_single_thread_task_runner.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
 
 namespace {
 const int64_t kMaxTimeTicks = std::numeric_limits<int64>::max();
 }
 
 namespace content {
 namespace internal {
 
 class TaskQueue : public base::SingleThreadTaskRunner {
@@ skipping 311 matching lines @@
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 
 TaskQueueManager::TaskQueueManager(
     size_t task_queue_count,
-    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     TaskQueueSelector* selector)
     : main_task_runner_(main_task_runner),
       selector_(selector),
       pending_dowork_count_(0),
       work_batch_size_(1),
       time_source_(nullptr),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "TaskQueueManager",
@@ skipping 133 matching lines @@
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", *pending_task);
 }
 
 void TaskQueueManager::ProcessTaskFromWorkQueue(
     size_t queue_index,
     bool has_previous_task,
     base::PendingTask* previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   internal::TaskQueue* queue = Queue(queue_index);
   base::PendingTask pending_task = queue->TakeTaskFromWorkQueue();
-  if (!pending_task.nestable) {
+  if (!pending_task.nestable && main_task_runner_->IsNested()) {
     // Defer non-nestable work to the main task runner.  NOTE these tasks can be
     // arbitrarily delayed so the additional delay should not be a problem.
     main_task_runner_->PostNonNestableTask(pending_task.posted_from,
                                            pending_task.task);
   } else {
     // Suppress "will" task observer notifications for the first and "did"
     // notifications for the last task in the batch to avoid duplicate
     // notifications.
     if (has_previous_task) {
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
@@ skipping 68 matching lines @@
   state->EndArray();
   state->BeginDictionary("selector");
   selector_->AsValueInto(state.get());
   state->EndDictionary();
   if (should_run)
     state->SetInteger("selected_queue", selected_queue);
   return state;
 }
 
 }  // namespace content