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 40 matching lines @@
 bool GetIOAllowed() {
   const bool previous_value = ThreadRestrictions::SetIOAllowed(true);
   ThreadRestrictions::SetIOAllowed(previous_value);
   return previous_value;
 }
 #endif
 
 // 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());
 
 #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.
   const std::string current_thread_name(PlatformThread::GetName());
   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);
   EXPECT_LE(expected_time, TimeTicks::Now());
   VerifyTaskEnvironment(traits);
   event->Signal();
 }
 
 scoped_refptr<TaskRunner> CreateTaskRunnerWithTraitsAndExecutionMode(
     TaskScheduler* scheduler,
@@ skipping 27 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, Unretained(&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,
+               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();
 }
 
 // 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,
+               Unretained(&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));
+    factory.PostTask(
+        test::TestTaskFactory::PostNestedTask::NO,
+        Bind(&VerifyTaskEnvironment, Unretained(&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,
+               Unretained(&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,
+               Unretained(&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,
+                                     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
   // 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