Add TaskPriority as a parameter to SequencedWorkerPool in preparation for TaskScheduler experiment.

base/threading/sequenced_worker_pool.h

 // 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.
 
 #ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <memory>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
+#include "base/task_scheduler/task_traits.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace base {
 
 class SingleThreadTaskRunner;
 
 template <class T> class DeleteHelper;
@@ skipping 149 matching lines @@
 
   // Returns the SequencedWorkerPool that owns this thread, or null if the
   // current thread is not a SequencedWorkerPool worker thread.
   static scoped_refptr<SequencedWorkerPool> GetWorkerPoolForCurrentThread();
 
   // When constructing a SequencedWorkerPool, there must be a
   // ThreadTaskRunnerHandle on the current thread unless you plan to
   // deliberately leak it.
 
   // Pass the maximum number of threads (they will be lazily created as needed)
-  // and a prefix for the thread name to aid in debugging.
+  // and a prefix for the thread name to aid in debugging. |task_priority| will
+  // be used to hint base::TaskScheduler for an experiment in which all
+  // SequencedWorkerPool tasks will be redirected to it in processes where a
+  // base::TaskScheduler was instantiated.
+  SequencedWorkerPool(size_t max_threads,
+                      const std::string& thread_name_prefix,
+                      base::TaskPriority task_priority);
+
+  // Deprecated, use the above constructor with |task_priority| instead.
+  // TODO(gab): Cleanup last few use cases of this before running the
+  // aforementioned base::TaskScheduler experiment (or make sure this
+  // constructor results in callers being opted out of the experiment).
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // Like above, but with |observer| for testing.  Does not take ownership of
   // |observer|.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
+                      base::TaskPriority task_priority,
                       TestingObserver* observer);
 
   // Returns the sequence token associated with the given name. Calling this
   // function multiple times with the same string will always produce the
   // same sequence token. If the name has not been used before, a new token
   // will be created.
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
   // Returns a SequencedTaskRunner wrapper which posts to this
   // SequencedWorkerPool using the given sequence token. Tasks with nonzero
@@ skipping 168 matching lines @@
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const std::unique_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_