Remove methods associated with the builder pattern from TaskTraits.

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>
@@ skipping 93 matching lines @@
 //
 // On Windows, join processes asynchronously using base::win::ObjectWatcher.
 //
 // MayBlock() must be specified in conjunction with this trait if and only if
 // removing usage of methods listed above in the labeled tasks would still
 // result in tasks that may block (per MayBlock()'s definition).
 //
 // In doubt, consult with //base/task_scheduler/OWNERS.
 struct WithBaseSyncPrimitives {};
 
 // Describes metadata for a single task or a group of tasks.

[gab, 2017/05/09 18:41:34]

Replace with:

// Immutable metadata for a single task or a group of tasks.

 class BASE_EXPORT TaskTraits {
  private:
   // ValidTrait ensures TaskTraits' constructor only accepts appropriate types.
-  //
-  // TODO(fdoray): Remove base:: prefixes once the TaskTraits::MayBlock() and
-  // TaskTraits::WithBaseSyncPrimitives() methods are gone.
-  // https://crbug.com/713683
   struct ValidTrait {
     ValidTrait(TaskPriority) {}
     ValidTrait(TaskShutdownBehavior) {}
-    ValidTrait(base::MayBlock) {}
-    ValidTrait(base::WithBaseSyncPrimitives) {}
+    ValidTrait(MayBlock) {}
+    ValidTrait(WithBaseSyncPrimitives) {}
   };
 
  public:
   // Invoking this constructor without arguments produces TaskTraits that are
   // appropriate for tasks that
   //     (1) don't block (ref. MayBlock() and WithBaseSyncPrimitives()),
   //     (2) prefer inheriting the current priority to specifying their own, and
   //     (3) can either block shutdown or be skipped on shutdown
   //         (TaskScheduler implementation is free to choose a fitting default).
   //
   // To get TaskTraits for tasks that require stricter guarantees and/or know
   // the specific TaskPriority appropriate for them, provide arguments of type
   // TaskPriority, TaskShutdownBehavior, MayBlock, and/or WithBaseSyncPrimitives
   // in any order to the constructor.
   //
   // E.g.
   // constexpr base::TaskTraits default_traits = {};
   // constexpr base::TaskTraits user_visible_traits =
   //     {base::TaskPriority::USER_VISIBLE};
   // constexpr base::TaskTraits user_visible_may_block_traits = {
   //     base::TaskPriority::USER_VISIBLE, base::MayBlock()};
   // constexpr base::TaskTraits other_user_visible_may_block_traits = {
   //     base::MayBlock(), base::TaskPriority::USER_VISIBLE};
   template <class... ArgTypes,
             class CheckArgumentsAreValid = internal::InitTypes<
                 decltype(ValidTrait(std::declval<ArgTypes>()))...>>
   constexpr TaskTraits(ArgTypes... args)
       : priority_set_explicitly_(
-            internal::HasArgOfType<base::TaskPriority, ArgTypes...>::value),
+            internal::HasArgOfType<TaskPriority, ArgTypes...>::value),
         priority_(internal::GetValueFromArgList(
-            internal::EnumArgGetter<base::TaskPriority,
-                                    base::TaskPriority::USER_VISIBLE>(),
+            internal::EnumArgGetter<TaskPriority, TaskPriority::USER_VISIBLE>(),
             args...)),
         shutdown_behavior_set_explicitly_(
-            internal::HasArgOfType<base::TaskShutdownBehavior,
-                                   ArgTypes...>::value),
+            internal::HasArgOfType<TaskShutdownBehavior, ArgTypes...>::value),
         shutdown_behavior_(internal::GetValueFromArgList(
-            internal::EnumArgGetter<
-                base::TaskShutdownBehavior,
-                base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN>(),
+            internal::EnumArgGetter<TaskShutdownBehavior,
+                                    TaskShutdownBehavior::SKIP_ON_SHUTDOWN>(),
             args...)),
         may_block_(internal::GetValueFromArgList(
-            internal::BooleanArgGetter<base::MayBlock>(),
+            internal::BooleanArgGetter<MayBlock>(),
             args...)),
         with_base_sync_primitives_(internal::GetValueFromArgList(
-            internal::BooleanArgGetter<base::WithBaseSyncPrimitives>(),
+            internal::BooleanArgGetter<WithBaseSyncPrimitives>(),
             args...)) {}
 
   constexpr TaskTraits(const TaskTraits& other) = default;
   TaskTraits& operator=(const TaskTraits& other) = default;
 
   // Returns TaskTraits constructed by combining |left| and |right|. If a trait
   // is specified in both |left| and |right|, the returned TaskTraits will have
   // the value from |right|.
   static constexpr TaskTraits Override(const TaskTraits& left,
                                        const TaskTraits& right) {
     return TaskTraits(left, right);
   }
 
-  // Deprecated.  Prefer constexpr construction to builder paradigm as
-  // documented above.
-  // TODO(fdoray): Remove these methods. https://crbug.com/713683
-  TaskTraits& WithPriority(TaskPriority priority);
-  TaskTraits& WithShutdownBehavior(TaskShutdownBehavior shutdown_behavior);
-  TaskTraits& MayBlock();
-  TaskTraits& WithBaseSyncPrimitives();
-
   // Returns true if the priority was set explicitly.
   constexpr bool priority_set_explicitly() const {
     return priority_set_explicitly_;
   }
 
   // Returns the priority of tasks with these traits.
   constexpr TaskPriority priority() const { return priority_; }
 
   // Returns true if the shutdown behavior was set explicitly.
   constexpr bool shutdown_behavior_set_explicitly() const {
@@ skipping 22 matching lines @@
         shutdown_behavior_set_explicitly_(
             left.shutdown_behavior_set_explicitly_ ||
             right.shutdown_behavior_set_explicitly_),
         shutdown_behavior_(right.shutdown_behavior_set_explicitly_
                                ? right.shutdown_behavior_
                                : left.shutdown_behavior_),
         may_block_(left.may_block_ || right.may_block_),
         with_base_sync_primitives_(left.with_base_sync_primitives_ ||
                                    right.with_base_sync_primitives_) {}
 
-  // TODO(fdoray): Make these const after refactoring away deprecated builder
-  // pattern.
   bool priority_set_explicitly_;
   TaskPriority priority_;
   bool shutdown_behavior_set_explicitly_;
   TaskShutdownBehavior shutdown_behavior_;
   bool may_block_;
   bool with_base_sync_primitives_;
 };
 
 // Returns string literals for the enums defined in this file. These methods
 // should only be used for tracing and debugging.
 BASE_EXPORT const char* TaskPriorityToString(TaskPriority task_priority);
 BASE_EXPORT const char* TaskShutdownBehaviorToString(
     TaskShutdownBehavior task_priority);
 
 // Stream operators so that the enums defined in this file can be used in
 // DCHECK and EXPECT statements.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os,
                                      const TaskPriority& shutdown_behavior);
 BASE_EXPORT std::ostream& operator<<(
     std::ostream& os,
     const TaskShutdownBehavior& shutdown_behavior);
 
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_TASK_TRAITS_H_