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 {
 
+TaskTraits SetExplicitPriorityInTaskTraits(const TaskTraits& traits) {
+  TaskTraits traits_with_explicit_priority(traits);

[fdoray, 2017/04/21 15:22:51]

I'm aware that this is not tested. Instead of writing new tests, I'm thinking of
changing task_scheduler_impl_unittest.cc to post_task_unittest.cc (i.e. same
tests but going through the post_task.h API) and adding TaskPriority::INHERITED
to the set of tested TraitsExecutionModePair. WDYT?

+  if (traits.priority() == TaskPriority::INHERITED) {
+    traits_with_explicit_priority.WithPriority(
+        internal::GetTaskPriorityForCurrentThread());
+  }
+  return traits_with_explicit_priority;
+}
+
 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;
@@ skipping 28 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, SetExplicitPriorityInTaskTraits(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(
+      SetExplicitPriorityInTaskTraits(traits));
 }
 
 scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
     const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
   return TaskScheduler::GetInstance()->CreateSequencedTaskRunnerWithTraits(
-      traits);
+      SetExplicitPriorityInTaskTraits(traits));
 }
 
 scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
   DCHECK(TaskScheduler::GetInstance())
       << "Ref. Prerequisite section of post_task.h";
   return TaskScheduler::GetInstance()->CreateSingleThreadTaskRunnerWithTraits(
-      traits);
+      SetExplicitPriorityInTaskTraits(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(
+      SetExplicitPriorityInTaskTraits(traits));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace base