Exempt the Service Thread from BLOCK_SHUTDOWN DCHECKs

base/task_scheduler/task_tracker.cc

 // Copyright 2016 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 "base/task_scheduler/task_tracker.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
 #include "base/debug/task_annotator.h"
 #include "base/json/json_writer.h"
-#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequence_token.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 348 matching lines @@
     // posted during shutdown. Otherwise, the histogram has already been
     // recorded in BeforePostTask().
     if (num_block_shutdown_tasks_posted_during_shutdown_ <
         kMaxBlockShutdownTasksPostedDuringShutdown) {
       RecordNumBlockShutdownTasksPostedDuringShutdown(
           num_block_shutdown_tasks_posted_during_shutdown_);
     }
   }
 }
 
+#if DCHECK_IS_ON()
+bool TaskTracker::IsExemptFromBlockingShutdownChecks() {
+  return false;
+}
+#endif
+
 bool TaskTracker::BeforePostTask(TaskShutdownBehavior shutdown_behavior) {
   if (shutdown_behavior == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
     // BLOCK_SHUTDOWN tasks block shutdown between the moment they are posted
     // and the moment they complete their execution.
     const bool shutdown_started = state_->IncrementNumTasksBlockingShutdown();
 
     if (shutdown_started) {
       AutoSchedulerLock auto_lock(shutdown_lock_);
 
       // A BLOCK_SHUTDOWN task posted after shutdown has completed is an
       // ordering bug. This aims to catch those early.
       DCHECK(shutdown_event_);
-      DCHECK(!shutdown_event_->IsSignaled());
+      if (shutdown_event_->IsSignaled()) {
+        // TODO(robliao): http://crbug.com/698140. Since the service thread
+        // doesn't stop processing its own tasks at shutdown, we may still
+        // attempt to post a BLOCK_SHUTDOWN task in response to a
+        // FileDescriptorWatcher. Delayed tasks are fine because they're marked

[fdoray, 2017/05/03 20:34:33]

Delayed tasks go through TaskTracker::BeforePostTask() when they are posted, not
when their delay expires on the service thread. Therefore, I'm not sure it is
necessary to comment on delayed tasks here.

[robliao, 2017/05/03 21:11:17]

Indeed. I was thinking of the general case. Removed.

+        // as SKIP_ON_SHUTDOWN and are accounted for shutdown purposes.
+        DCHECK(IsExemptFromBlockingShutdownChecks());
+        state_->DecrementNumTasksBlockingShutdown();
+        return false;
+      }
 
       ++num_block_shutdown_tasks_posted_during_shutdown_;
 
       if (num_block_shutdown_tasks_posted_during_shutdown_ ==
           kMaxBlockShutdownTasksPostedDuringShutdown) {
         // Record the TaskScheduler.BlockShutdownTasksPostedDuringShutdown
         // histogram as soon as its upper bound is hit. That way, a value will
         // be recorded even if an infinite number of BLOCK_SHUTDOWN tasks are
         // posted, preventing shutdown to complete.
         RecordNumBlockShutdownTasksPostedDuringShutdown(
@@ skipping 88 matching lines @@
   task_latency_histograms_[static_cast<int>(task->traits.priority())]
                           [task->traits.may_block() ||
                                    task->traits.with_base_sync_primitives()
                                ? 1
                                : 0]
                               ->AddTime(task_latency);
 }
 
 }  // namespace internal
 }  // namespace base