Allow BLOCK_SHUTDOWN tasks during shutdown with SequencedWorkerPool redirected to TaskScheduler.

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 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/threading/sequenced_worker_pool.h"
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
@@ skipping 906 matching lines @@
     int max_new_blocking_tasks_after_shutdown) {
   DCHECK_GE(max_new_blocking_tasks_after_shutdown, 0);
   {
     AutoLock lock(lock_);
     // Cleanup and Shutdown should not be called concurrently.
     CHECK_EQ(CLEANUP_DONE, cleanup_state_);
     if (shutdown_called_)
       return;
     shutdown_called_ = true;
 
+    max_blocking_tasks_after_shutdown_ = max_new_blocking_tasks_after_shutdown;
+
     if (subtle::NoBarrier_Load(&g_all_pools_state) !=
-        AllPoolsState::WORKER_CREATED)
+        AllPoolsState::WORKER_CREATED) {
       return;
-
-    max_blocking_tasks_after_shutdown_ = max_new_blocking_tasks_after_shutdown;
+    }
 
     // Tickle the threads. This will wake up a waiting one so it will know that
     // it can exit, which in turn will wake up any other waiting ones.
     SignalHasWork();
 
     // There are no pending or running tasks blocking shutdown, we're done.
     if (CanShutdown())
       return;
   }
 
   // If we're here, then something is blocking shutdown.  So wait for
   // CanShutdown() to go to true.
 
   if (testing_observer_)
     testing_observer_->WillWaitForShutdown();
 
 #if !defined(OS_NACL)
   TimeTicks shutdown_wait_begin = TimeTicks::Now();
 #endif
 
   {
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     AutoLock lock(lock_);
     while (!CanShutdown())
       can_shutdown_cv_.Wait();
   }
 #if !defined(OS_NACL)
   UMA_HISTOGRAM_TIMES("SequencedWorkerPool.ShutdownDelayTime",

[robliao, 2016/10/03 19:58:35]

Not required for this CL: Do we care that this histogram doesn't make it when
redirection is on?

[fdoray, 2016/10/03 20:13:41]

If we care about this, we should have a similar histogram in TaskScheduler (one
that we would track even after SequencedWorkerPool is deprecated).

[gab, 2016/10/03 20:16:43]

I think it makes more sense that it doesn't make it as it wouldn't mean
anything.

[gab, 2016/10/03 20:17:16]

That I think we indeed should.

                       TimeTicks::Now() - shutdown_wait_begin);
 #endif
 }
 
 bool SequencedWorkerPool::Inner::IsShutdownInProgress() {
     AutoLock lock(lock_);
     return shutdown_called_;
 }
 
 void SequencedWorkerPool::Inner::ThreadLoop(Worker* this_worker) {
@@ skipping 650 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base