Add constexpr TaskTraits constructor.

base/task_scheduler/task_scheduler_impl_unittest.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/task_scheduler_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 123 matching lines @@
 
   void WaitForAllTasksToRun() { factory_.WaitForAllTasksToRun(); }
 
  private:
   void Run() override {
     EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread());
 
     const size_t kNumTasksPerThread = 150;
     for (size_t i = 0; i < kNumTasksPerThread; ++i) {
       factory_.PostTask(test::TestTaskFactory::PostNestedTask::NO,
-                        Bind(&VerifyTaskEnvironment, traits_));
+                        Bind(&VerifyTaskEnvironment, ConstRef(traits_)));
     }
   }
 
   const TaskTraits traits_;
   test::TestTaskFactory factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
 };
 
 // Returns a vector with a TraitsExecutionModePair for each valid
@@ skipping 57 matching lines @@
 
 // Verifies that a Task posted via PostDelayedTaskWithTraits with parameterized
 // TaskTraits and no delay runs on a thread with the expected priority and I/O
 // restrictions. The ExecutionMode parameter is ignored by this test.
 TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelay) {
   StartTaskScheduler();
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
-               Unretained(&task_ran)),
+      BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
+               ConstRef(GetParam().traits), Unretained(&task_ran)),
       TimeDelta());
   task_ran.Wait();
 }
 
 // Verifies that a Task posted via PostDelayedTaskWithTraits with parameterized
 // TaskTraits and a non-zero delay runs on a thread with the expected priority
 // and I/O restrictions after the delay expires. The ExecutionMode parameter is
 // ignored by this test.
 TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelay) {
   StartTaskScheduler();
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
+      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent,
+               ConstRef(GetParam().traits),
                TimeTicks::Now() + TestTimeouts::tiny_timeout(),
                Unretained(&task_ran)),
       TestTimeouts::tiny_timeout());
   task_ran.Wait();
 }
 
 // Verifies that Tasks posted via a TaskRunner with parameterized TaskTraits and
 // ExecutionMode run on a thread with the expected priority and I/O restrictions
 // and respect the characteristics of their ExecutionMode.
 TEST_P(TaskSchedulerImplTest, PostTasksViaTaskRunner) {
   StartTaskScheduler();
   test::TestTaskFactory factory(
       CreateTaskRunnerWithTraitsAndExecutionMode(&scheduler_, GetParam().traits,
                                                  GetParam().execution_mode),
       GetParam().execution_mode);
   EXPECT_FALSE(factory.task_runner()->RunsTasksOnCurrentThread());
 
   const size_t kNumTasksPerTest = 150;
   for (size_t i = 0; i < kNumTasksPerTest; ++i) {
     factory.PostTask(test::TestTaskFactory::PostNestedTask::NO,
-                     Bind(&VerifyTaskEnvironment, GetParam().traits));
+                     Bind(&VerifyTaskEnvironment, ConstRef(GetParam().traits)));
   }
 
   factory.WaitForAllTasksToRun();
 }
 
 // Verifies that a task posted via PostDelayedTaskWithTraits without a delay
 // doesn't run before Start() is called.
 TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsNoDelayBeforeStart) {
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTaskEnvironmentAndSignalEvent, GetParam().traits,
-               Unretained(&task_running)),
+      BindOnce(&VerifyTaskEnvironmentAndSignalEvent,
+               ConstRef(GetParam().traits), Unretained(&task_running)),
       TimeDelta());
 
   // 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
   // the check and before Start(). However, we expect the test to be flaky if
   // the tested code allows that to happen.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   EXPECT_FALSE(task_running.IsSignaled());
 
   StartTaskScheduler();
   task_running.Wait();
 }
 
 // Verifies that a task posted via PostDelayedTaskWithTraits with a delay
 // doesn't run before Start() is called.
 TEST_P(TaskSchedulerImplTest, PostDelayedTaskWithTraitsWithDelayBeforeStart) {
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   scheduler_.PostDelayedTaskWithTraits(
       FROM_HERE, GetParam().traits,
-      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent, GetParam().traits,
+      BindOnce(&VerifyTimeAndTaskEnvironmentAndSignalEvent,
+               ConstRef(GetParam().traits),
                TimeTicks::Now() + TestTimeouts::tiny_timeout(),
                Unretained(&task_running)),
       TestTimeouts::tiny_timeout());
 
   // 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
   // the check and before Start(). However, we expect the test to be flaky if
   // the tested code allows that to happen.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   EXPECT_FALSE(task_running.IsSignaled());
 
   StartTaskScheduler();
   task_running.Wait();
 }
 
 // Verifies that a task posted via a TaskRunner doesn't run before Start() is
 // called.
 TEST_P(TaskSchedulerImplTest, PostTaskViaTaskRunnerBeforeStart) {
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              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,
+                                     ConstRef(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
   // the check and before Start(). However, we expect the test to be flaky if
   // the tested code allows that to happen.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   EXPECT_FALSE(task_running.IsSignaled());
 
   StartTaskScheduler();
 
@@ skipping 112 matching lines @@
             }
             task_ran->Signal();
           },
           com_sta_task_runner, Unretained(&task_ran)));
   task_ran.Wait();
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base