TaskScheduler [3/9] Task and Sequence

base/task_scheduler/task_traits.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_TASK_TRAITS_H_
 #define BASE_TASK_SCHEDULER_TASK_TRAITS_H_
 
+#include <stdint.h>
+
+#include <iosfwd>
+
 #include "base/base_export.h"
 #include "build/build_config.h"
 
 namespace base {
 
-using TaskPriorityUnderlyingType = char;
-
-// Valid priorities supported by the task scheduler.
-// A higher value means a higher priority in the scheduler.
-enum class TaskPriority : TaskPriorityUnderlyingType {
-  // This task affects UI immediately after a user interaction.
-  // Example: Generating data shown in the UI immediately after a click.
-  USER_BLOCKING = 2,
+// Valid priorities supported by the task scheduler. Note: internal algorithms
+// depend on priorities being expressed as a continuous zero-based list from
+// lowest to highest priority. Users of this API shouldn't otherwise care about
+// nor use the underlying values.
+enum class TaskPriority {
+  // This will always be equal to the lowest priority available.
+  LOWEST = 0,
+  // User won't notice if this task takes an arbitrarily long time to complete.
+  BACKGROUND = LOWEST,
   // This task affects UI or responsiveness of future user interactions. It is
   // not an immediate response to a user interaction.
   // Examples:
   // - Updating the UI to reflect progress on a long task.
   // - Loading data that might be shown in the UI after a future user
   //   interaction.
-  USER_VISIBLE = 1,
-  // Everything else (user won't notice if this takes an arbitrarily long time
-  // to complete).
-  BACKGROUND = 0,
+  USER_VISIBLE,
+  // This task affects UI immediately after a user interaction.
+  // Example: Generating data shown in the UI immediately after a click.
+  USER_BLOCKING,
+  // This will always be equal to the highest priority available.
+  HIGHEST = USER_BLOCKING,
 };
 
-static_assert(TaskPriority::BACKGROUND < TaskPriority::USER_VISIBLE &&
-                  TaskPriority::USER_VISIBLE < TaskPriority::USER_BLOCKING,
-              "Higher priorities must correspond to higher underlying values.");
-
-const TaskPriorityUnderlyingType kNumTaskPriorities = 3;
-
 // Valid shutdown behaviors supported by the task scheduler.
 enum class TaskShutdownBehavior {
   // Tasks posted with this mode which have not started executing before
   // shutdown is initiated will never run. Tasks with this mode running at
   // shutdown will be ignored (the worker thread will not be joined).
   //
   // This option provides a nice way to post stuff you don't want blocking
   // shutdown. For example, you might be doing a slow DNS lookup and if it's
   // blocked on the OS, you may not want to stop shutdown, since the result
   // doesn't really matter at that point.
@@ skipping 19 matching lines @@
   // Tasks posted with this mode before shutdown is complete will block shutdown
   // until they're executed. Generally, this should be used only to save
   // critical user data.
   //
   // Note: Tasks with BACKGROUND priority that block shutdown will be promoted
   // to USER_VISIBLE priority during shutdown.
   BLOCK_SHUTDOWN,
 };
 
 // Describes metadata for a single task or a group of tasks.
 class BASE_EXPORT TaskTraits {

[gab, 2016/03/16 22:18:50]

Since classes should typically have DISALLOW_COPY_AND_ASSIGN and this one is
intentionally copyable I think it makes sense to highlight that this was an
intentional decision by declaring the use of the default copy constructor below.

TaskTraits(const TaskTraits& other) = default;

And also declare:

TaskTraits& operator=(const TaskTraits& other) = default;

per the style rule that if one is defined the other one also should be:

"If you define a copy or move constructor, define the corresponding assignment
operator, and vice-versa. If your type is copyable"
@
https://google.github.io/styleguide/cppguide.html#Copyable_Movable_Types

[fdoray, 2016/03/17 00:42:33]

Done.

+ public:
   // Constructs a default TaskTraits for tasks with
   //     (1) no I/O,
   //     (2) low priority, and
   //     (3) may block shutdown or be skipped on shutdown.
   // Tasks that require stricter guarantees should highlight those by requesting
   // explicit traits below.
   TaskTraits();
   ~TaskTraits();
 
   // Allows tasks with these traits to do file I/O.
@@ skipping 26 matching lines @@
   PARALLEL,
 
   // Executes one task at a time in posting order. The sequence’s priority is
   // equivalent to the highest priority pending task in the sequence.
   SEQUENCED,
 
   // Executes one task at a time on a single thread in posting order.
   SINGLE_THREADED,
 };
 
+// Pretty Printer for Google Test.
+void BASE_EXPORT PrintTo(const TaskPriority& task_priority, std::ostream* os);
+
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_TASK_TRAITS_H_