Add a TaskPriority cap to the SWP redirection to experiment with no redirections at USER_BLOCKING.

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 57 matching lines @@
   POST_TASK_DISABLED,
   USE_WORKER_POOL,
   REDIRECTED_TO_TASK_SCHEDULER,
 };
 
 // TODO(fdoray): Change the initial state to POST_TASK_DISABLED. It is initially
 // USE_WORKER_POOL to avoid a revert of the CL that adds
 // debug::DumpWithoutCrashing() in case of waterfall failures.
 AllPoolsState g_all_pools_state = AllPoolsState::USE_WORKER_POOL;
 
+TaskPriority g_max_task_priority = TaskPriority::HIGHEST;
+
 struct SequencedTask : public TrackingInfo  {
   SequencedTask()
       : sequence_token_id(0),
         trace_id(0),
         sequence_task_number(0),
         shutdown_behavior(SequencedWorkerPool::BLOCK_SHUTDOWN) {}
 
   explicit SequencedTask(const tracked_objects::Location& from_here)
       : base::TrackingInfo(from_here, TimeTicks()),
         sequence_token_id(0),
@@ skipping 549 matching lines @@
       blocking_shutdown_thread_count_(0),
       next_sequence_task_number_(0),
       blocking_shutdown_pending_task_count_(0),
       trace_id_(0),
       shutdown_called_(false),
       max_blocking_tasks_after_shutdown_(0),
       cleanup_state_(CLEANUP_DONE),
       cleanup_idlers_(0),
       cleanup_cv_(&lock_),
       testing_observer_(observer),
-      task_priority_(task_priority) {
+      task_priority_(static_cast<int>(task_priority) <=
+                             static_cast<int>(g_max_task_priority)

[dcheng, 2016/12/15 21:20:49]

Yay, C++.

+                         ? task_priority
+                         : g_max_task_priority) {
   DCHECK_GT(max_threads_, 1U);
 }
 
 SequencedWorkerPool::Inner::~Inner() {
   // You must call Shutdown() before destroying the pool.
   DCHECK(shutdown_called_);
 
   // Need to explicitly join with the threads before they're destroyed or else
   // they will be running when our object is half torn down.
   for (ThreadMap::iterator it = threads_.begin(); it != threads_.end(); ++it)
@@ skipping 757 matching lines @@
 // static
 void SequencedWorkerPool::EnableForProcess() {
   // TODO(fdoray): Uncomment this line. It is initially commented to avoid a
   // revert of the CL that adds debug::DumpWithoutCrashing() in case of
   // waterfall failures.
   // DCHECK_EQ(AllPoolsState::POST_TASK_DISABLED, g_all_pools_state);
   g_all_pools_state = AllPoolsState::USE_WORKER_POOL;
 }
 
 // static
-void SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess() {
+void SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess(
+    TaskPriority max_task_priority) {
   // TODO(fdoray): Uncomment this line. It is initially commented to avoid a
   // revert of the CL that adds debug::DumpWithoutCrashing() in case of
   // waterfall failures.
   // DCHECK_EQ(AllPoolsState::POST_TASK_DISABLED, g_all_pools_state);
   DCHECK(TaskScheduler::GetInstance());
   g_all_pools_state = AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER;
+  g_max_task_priority = max_task_priority;
 }
 
 // static
 void SequencedWorkerPool::DisableForProcessForTesting() {
   g_all_pools_state = AllPoolsState::POST_TASK_DISABLED;
 }
 
 // static
 bool SequencedWorkerPool::IsEnabled() {
   return g_all_pools_state != AllPoolsState::POST_TASK_DISABLED;
@@ skipping 155 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base