scheduler: Remove task observer shenanigans

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 670 matching lines @@
   base::PendingTask previous_task((tracked_objects::Location()),
                                   (base::Closure()));
   for (int i = 0; i < work_batch_size_; i++) {
     size_t queue_index;
     if (!SelectWorkQueueToService(&queue_index))
       return;
     // Note that this function won't post another call to DoWork if one is
     // already pending, so it is safe to call it in a loop.
     MaybePostDoWorkOnMainRunner();
 
-    if (ProcessTaskFromWorkQueue(queue_index, i > 0, &previous_task))
+    if (ProcessTaskFromWorkQueue(queue_index, &previous_task))
       return;  // The TaskQueueManager got deleted, we must bail out.
 
     bool should_trigger_wakeup = Queue(queue_index)->wakeup_policy() ==
                                  WakeupPolicy::CAN_WAKE_OTHER_QUEUES;
     if (!UpdateWorkQueues(should_trigger_wakeup, &previous_task))
       return;
   }
 }
 
 bool TaskQueueManager::SelectWorkQueueToService(size_t* out_queue_index) {
   bool should_run = selector_->SelectWorkQueueToService(out_queue_index);
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       disabled_by_default_tracing_category_, "TaskQueueManager", this,
       AsValueWithSelectorResult(should_run, *out_queue_index));
   return should_run;
 }
 
 void TaskQueueManager::DidQueueTask(const base::PendingTask& pending_task) {
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", pending_task);
 }
 
 bool TaskQueueManager::ProcessTaskFromWorkQueue(
     size_t queue_index,
-    bool has_previous_task,
-    base::PendingTask* previous_task) {
+    base::PendingTask* out_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
   internal::TaskQueueImpl* queue = Queue(queue_index);
   base::PendingTask pending_task = queue->TakeTaskFromWorkQueue();
   task_was_run_bitmap_ |= UINT64_C(1) << queue_index;
   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_,
-                        DidProcessTask(*previous_task));
-      FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
-                        WillProcessTask(pending_task));
-    }
-
     TRACE_TASK_EXECUTION("TaskQueueManager::ProcessTaskFromWorkQueue",
                          pending_task);
+    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;
 
+    FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
+                      DidProcessTask(pending_task));
+
     pending_task.task.Reset();
-    *previous_task = pending_task;
+    *out_task = pending_task;
   }
   return false;
 }
 
 bool TaskQueueManager::RunsTasksOnCurrentThread() const {
   return main_task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool TaskQueueManager::PostDelayedTask(
     const tracked_objects::Location& from_here,
@@ skipping 11 matching lines @@
 
 void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_GE(work_batch_size, 1);
   work_batch_size_ = work_batch_size;
 }
 
 void TaskQueueManager::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  main_task_runner_->AddTaskObserver(task_observer);
   task_observers_.AddObserver(task_observer);
 }
 
 void TaskQueueManager::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  main_task_runner_->RemoveTaskObserver(task_observer);
   task_observers_.RemoveObserver(task_observer);
 }
 
 void TaskQueueManager::SetTimeSourceForTesting(
     scoped_ptr<base::TickClock> time_source) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   time_source_ = time_source.Pass();
 }
 
 uint64 TaskQueueManager::GetAndClearTaskWasRunOnQueueBitmap() {
@@ skipping 57 matching lines @@
       return nullptr;
   }
 }
 
 void TaskQueueManager::OnTaskQueueEnabled() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler