Add constexpr TaskTraits constructor.

base/task_scheduler/task_scheduler_impl_unittest.cc

Index: base/task_scheduler/task_scheduler_impl_unittest.cc
diff --git a/base/task_scheduler/task_scheduler_impl_unittest.cc b/base/task_scheduler/task_scheduler_impl_unittest.cc
index b8d8fad8343808296bff8dd7acedba946bdf8e4e..1f363639039584da95339e7adb77bb284d571b03 100644
--- a/base/task_scheduler/task_scheduler_impl_unittest.cc
+++ b/base/task_scheduler/task_scheduler_impl_unittest.cc
@@ -58,13 +58,13 @@ bool GetIOAllowed() {
 // Verify that the current thread priority and I/O restrictions are appropriate
 // to run a Task with |traits|.
 // Note: ExecutionMode is verified inside TestTaskFactory.
-void VerifyTaskEnvironment(const TaskTraits& traits) {
+void VerifyTaskEnvironment(const TaskTraits* traits) {
   const bool supports_background_priority =
       Lock::HandlesMultipleThreadPriorities() &&
       PlatformThread::CanIncreaseCurrentThreadPriority();
 
   EXPECT_EQ(supports_background_priority &&
-                    traits.priority() == TaskPriority::BACKGROUND
+                    traits->priority() == TaskPriority::BACKGROUND
                 ? ThreadPriority::BACKGROUND
                 : ThreadPriority::NORMAL,
             PlatformThread::GetCurrentThreadPriority());
@@ -72,7 +72,7 @@ void VerifyTaskEnvironment(const TaskTraits& traits) {
 #if DCHECK_IS_ON()
   // The #if above is required because GetIOAllowed() always returns true when
   // !DCHECK_IS_ON(), even when |traits| don't allow file I/O.
-  EXPECT_EQ(traits.may_block(), GetIOAllowed());
+  EXPECT_EQ(traits->may_block(), GetIOAllowed());
 #endif
 
   // Verify that the thread the task is running on is named as expected.
@@ -80,20 +80,20 @@ void VerifyTaskEnvironment(const TaskTraits& traits) {
   EXPECT_NE(std::string::npos, current_thread_name.find("TaskScheduler"));
   EXPECT_NE(std::string::npos,
             current_thread_name.find(
-                traits.priority() == TaskPriority::BACKGROUND ? "Background"
-                                                              : "Foreground"));
-  EXPECT_EQ(traits.may_block(),
+                traits->priority() == TaskPriority::BACKGROUND ? "Background"
+                                                               : "Foreground"));
+  EXPECT_EQ(traits->may_block(),
             current_thread_name.find("Blocking") != std::string::npos);
 }
 
-void VerifyTaskEnvironmentAndSignalEvent(const TaskTraits& traits,
+void VerifyTaskEnvironmentAndSignalEvent(const TaskTraits* traits,
                                          WaitableEvent* event) {
   DCHECK(event);
   VerifyTaskEnvironment(traits);
   event->Signal();
 }
 
-void VerifyTimeAndTaskEnvironmentAndSignalEvent(const TaskTraits& traits,
+void VerifyTimeAndTaskEnvironmentAndSignalEvent(const TaskTraits* traits,
                                                 TimeTicks expected_time,
                                                 WaitableEvent* event) {
   DCHECK(event);
@@ -141,7 +141,7 @@ class ThreadPostingTasks : public SimpleThread {
     const size_t kNumTasksPerThread = 150;
     for (size_t i = 0; i < kNumTasksPerThread; ++i) {
       factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO,
-                        Bind(&VerifyTaskEnvironment, traits_));
+                        Bind(&VerifyTaskEnvironment, Unretained(&traits_)));
     }
   }
 
@@ -219,8 +219,8 @@ TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelay) {
                          WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
-               Unretained(&task_ran)),
+      BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
+               Unretained(&GetParam().traits), Unretained(&task_ran)),

[gab, 2017/04/28 18:15:42]

Bring back old Bind?

[fdoray, 2017/04/28 18:40:36]

Done.

       TimeDelta());
   task_ran.Wait();
 }
@@ -235,7 +235,8 @@ TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelay) {
                          WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
+      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent,
+               Unretained(&GetParam().traits),
                TimeTicks::Now() + TestTimeouts::tiny_timeout(),
                Unretained(&task_ran)),
       TestTimeouts::tiny_timeout());
@@ -255,8 +256,9 @@ TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) {
 
   const size_t kNumTasksPerTest = 150;
   for (size_t i = 0; i < kNumTasksPerTest; ++i) {
-    factory.PostTask(test::TestTaskFactory::PostNestedTask::NO,
-                     Bind(&VerifyTaskEnvironment, GetParam().traits));
+    factory.PostTask(
+        test::TestTaskFactory::PostNestedTask::NO,
+        Bind(&VerifyTaskEnvironment, Unretained(&GetParam().traits)));
   }
 
   factory.WaitForAllTasksToRun();
@@ -269,8 +271,8 @@ TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelayBeforeStart) {
                              WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
-               Unretained(&task_running)),
+      BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
+               Unretained(&GetParam().traits), Unretained(&task_running)),
       TimeDelta());
 
   // Wait a little bit to make sure that the task isn't scheduled before
@@ -291,7 +293,8 @@ TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelayBeforeStart) {
                              WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
+      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent,
+               Unretained(&GetParam().traits),
                TimeTicks::Now() + TestTimeouts::tiny_timeout(),
                Unretained(&task_running)),
       TestTimeouts::tiny_timeout());
@@ -314,9 +317,9 @@ TEST_P(TaskSchedulerImplTest, PostTaskViaTaskRunnerBeforeStart) {
                              WaitableEvent::InitialState::NOT_SIGNALED);
   CreateTaskRunnerWithTraitsAndExecutionMode(&scheduler_, GetParam().traits,
                                              GetParam().execution_mode)
-      ->PostTask(FROM_HERE,
-                 BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
-                          GetParam().traits, Unretained(&task_running)));
+      ->PostTask(FROM_HERE, BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
+                                     Unretained(&GetParam().traits),
+                                     Unretained(&task_running)));
 
   // Wait a little bit to make sure that the task isn't scheduled before
   // Start(). Note: This test won't catch a case where the task runs just after