Do not inherit TaskPriority in TaskTraits.

base/task_scheduler/post_task.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/post_task.h"
 
 #include <utility>
 
 #include "base/logging.h"
+#include "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/post_task_and_reply_impl.h"
 
 namespace base {
 
 namespace {
 
 class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl {
  public:
   explicit PostTaskAndReplyTaskRunner(const TaskTraits& traits)
       : traits_(traits) {}
 
  private:
   bool PostTask(const tracked_objects::Location& from_here,
                 OnceClosure task) override {
     PostTaskWithTraits(from_here, traits_, std::move(task));
     return true;
   }
 
   const TaskTraits traits_;
 };
 
+// Returns TaskTraits based on |traits|. If TaskPriority hasn't been set
+// explicitly in |traits|, the returned TaskTraits have the current
+// TaskPriority.
+TaskTraits CreateTaskTraitsWithExplicitPriority(const TaskTraits& traits) {

[gab, 2017/04/25 17:16:41]

I prefer GetTaskTraitsWithExplicitPriority() since TaskTraits is effectively a
POD return, it's not "creating" much IMO.

[fdoray, 2017/04/25 17:57:48]

Done.

+  return traits.priority_set_explicitly()
+             ? traits
+             : TaskTraits(traits).WithPriority(
+                   internal::GetTaskPriorityForCurrentThread());
+}
 
 }  // namespace
 
 void PostTask(const tracked_objects::Location& from_here, OnceClosure task) {
   PostDelayedTask(from_here, std::move(task), TimeDelta());
 }
 
 void PostDelayedTask(const tracked_objects::Location& from_here,
                      OnceClosure task,
                      TimeDelta delay) {
@@ skipping 13 matching lines @@
   PostDelayedTaskWithTraits(from_here, traits, std::move(task), TimeDelta());
 }
 
 void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
                                const TaskTraits& traits,
                                OnceClosure task,
                                TimeDelta delay) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
   TaskScheduler::GetInstance()->PostDelayedTaskWithTraits(
-      from_here, traits, std::move(task), std::move(delay));
+      from_here, CreateTaskTraitsWithExplicitPriority(traits), std::move(task),
+      std::move(delay));
 }
 
 void PostTaskWithTraitsAndReply(const tracked_objects::Location& from_here,
                                 const TaskTraits& traits,
                                 OnceClosure task,
                                 OnceClosure reply) {
   PostTaskAndReplyTaskRunner(traits).PostTaskAndReply(
       from_here, std::move(task), std::move(reply));
 }
 
 scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
-  return TaskScheduler::GetInstance()->CreateTaskRunnerWithTraits(traits);
+  return TaskScheduler::GetInstance()->CreateTaskRunnerWithTraits(
+      CreateTaskTraitsWithExplicitPriority(traits));
 }
 
 scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
     const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
   return TaskScheduler::GetInstance()->CreateSequencedTaskRunnerWithTraits(
-      traits);
+      CreateTaskTraitsWithExplicitPriority(traits));
 }
 
 scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
   return TaskScheduler::GetInstance()->CreateSingleThreadTaskRunnerWithTraits(
-      traits);
+      CreateTaskTraitsWithExplicitPriority(traits));
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
     const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
-  return TaskScheduler::GetInstance()->CreateCOMSTATaskRunnerWithTraits(traits);
+  return TaskScheduler::GetInstance()->CreateCOMSTATaskRunnerWithTraits(
+      CreateTaskTraitsWithExplicitPriority(traits));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace base