[scheduler]: Fix a bug with non-nestable tasks.

components/scheduler/child/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 "components/scheduler/child/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 265 matching lines @@
   internal::TaskQueueImpl::Task pending_task = queue->TakeTaskFromWorkQueue();
 
   if (queue->GetQuiescenceMonitored())
     task_was_run_on_quiescence_monitored_queue_ = true;
 
   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);
+    // Even although we haven't actually run this task yet, we do set it as
+    // the out_previous_task below because it might be our only chance to
+    // wake up an after-wakeup queue.
   } else {
     TRACE_TASK_EXECUTION("TaskQueueManager::ProcessTaskFromWorkQueue",
                          pending_task);
     if (queue->GetShouldNotifyObservers()) {
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                         WillProcessTask(pending_task));
     }
     task_annotator_.RunTask("TaskQueueManager::PostTask", pending_task);
 
     // Detect if the TaskQueueManager just got deleted.  If this happens we must
     // not access any member variables after this point.
     if (protect->HasOneRef())
       return true;
 
     if (queue->GetShouldNotifyObservers()) {
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                         DidProcessTask(pending_task));
     }
+  }
 
-    pending_task.task.Reset();
-    *out_previous_task = pending_task;
-  }
+  pending_task.task.Reset();
+  *out_previous_task = pending_task;
   return false;
 }
 
 bool TaskQueueManager::RunsTasksOnCurrentThread() const {
   return main_task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool TaskQueueManager::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
@@ skipping 65 matching lines @@
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
   if (!queue->work_queue().empty())
     MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler