DCHECK tasks posted by TaskRunner::PostTask

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

 // Copyright 2015 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 "platform/scheduler/base/task_queue_impl.h"
 
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 200 matching lines @@
                                  TaskType::NON_NESTABLE);
 
   return PostDelayedTaskImpl(from_here, std::move(task), delay,
                              TaskType::NON_NESTABLE);
 }
 
 bool TaskQueueImpl::PostImmediateTaskImpl(
     const tracked_objects::Location& from_here,
     base::Closure task,
     TaskType task_type) {
   base::AutoLock lock(any_thread_lock_);

[Sami, 2017/03/31 14:08:55]

I think we just need to instrument PostImmediateTaskImpl and PostDelayedTaskImpl
-- everything else is downstream from them.

[tzik, 2017/04/03 13:57:22]

Done.

   if (!any_thread().task_queue_manager)
     return false;
 
   EnqueueOrder sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
 
   PushOntoImmediateIncomingQueueLocked(from_here, std::move(task),
                                        base::TimeTicks(), sequence_number,
                                        task_type != TaskType::NON_NESTABLE);
   return true;
@@ skipping 35 matching lines @@
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueLocked(
         Task(from_here, std::move(task), time_domain_delayed_run_time,
              sequence_number, task_type != TaskType::NON_NESTABLE));
   }
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task pending_task, base::TimeTicks now) {
+  CHECK(pending_task.task);
+
   base::TimeTicks delayed_run_time = pending_task.delayed_run_time;
   main_thread_only().task_queue_manager->DidQueueTask(pending_task);
   main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
 
   // If |pending_task| is at the head of the queue, then make sure a wakeup
   // is requested if the queue is enabled.  Note we still want to schedule a
   // wakeup even if blocked by a fence, because we'd break throttling logic
   // otherwise.
   base::TimeTicks next_delayed_task =
       main_thread_only().delayed_incoming_queue.top().delayed_run_time;
   if (next_delayed_task == delayed_run_time && IsQueueEnabled()) {
     main_thread_only().time_domain->ScheduleDelayedWork(
         this, {delayed_run_time, pending_task.sequence_num}, now);
   }
 
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueLocked(Task pending_task) {
+  CHECK(pending_task.task);
+
   any_thread().task_queue_manager->DidQueueTask(pending_task);
 
   int thread_hop_task_sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
   PushOntoImmediateIncomingQueueLocked(
      FROM_HERE,
      base::Bind(&TaskQueueImpl::ScheduleDelayedWorkTask, this,
                 base::Passed(&pending_task)),
      base::TimeTicks(),
      thread_hop_task_sequence_number,
@@ skipping 20 matching lines @@
   }
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     const tracked_objects::Location& posted_from,
     base::Closure task,
     base::TimeTicks desired_run_time,
     EnqueueOrder sequence_number,
     bool nestable) {
+  CHECK(task);
+
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
     // However there's no point posting a DoWork for a blocked queue. NB we can
     // only tell if it's disabled from the main thread.
     bool queue_is_blocked =
         RunsTasksOnCurrentThread() &&
         (!IsQueueEnabled() || main_thread_only().current_fence);
     any_thread().task_queue_manager->OnQueueHasIncomingImmediateWork(
         this, sequence_number, queue_is_blocked);
@@ skipping 536 matching lines @@
 
 void TaskQueueImpl::PushImmediateIncomingTaskForTest(
     TaskQueueImpl::Task&& task) {
   base::AutoLock lock(any_thread_lock_);
   any_thread().immediate_incoming_queue.push_back(std::move(task));
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink