Index: base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc |
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc b/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc |
deleted file mode 100644 |
index 6db240a743cd85b0f84978cb1483d41075131c66..0000000000000000000000000000000000000000 |
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc |
+++ /dev/null |
@@ -1,254 +0,0 @@ |
-// Copyright 2017 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/scheduler_single_thread_task_runner_manager.h" |
- |
-#include "base/bind.h" |
-#include "base/memory/ptr_util.h" |
-#include "base/synchronization/lock.h" |
-#include "base/synchronization/waitable_event.h" |
-#include "base/task_scheduler/delayed_task_manager.h" |
-#include "base/task_scheduler/post_task.h" |
-#include "base/task_scheduler/scheduler_worker_pool_params.h" |
-#include "base/task_scheduler/task_tracker.h" |
-#include "base/task_scheduler/task_traits.h" |
-#include "base/test/test_timeouts.h" |
-#include "base/threading/thread.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-namespace base { |
-namespace internal { |
- |
-namespace { |
- |
-enum WorkerPoolType { |
- BACKGROUND_WORKER_POOL = 0, |
- FOREGROUND_WORKER_POOL, |
-}; |
- |
-static size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) { |
- return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL |
- : FOREGROUND_WORKER_POOL; |
-} |
- |
-class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test { |
- public: |
- TaskSchedulerSingleThreadTaskRunnerManagerTest() |
- : service_thread_("TaskSchedulerServiceThread") {} |
- |
- void SetUp() override { |
- service_thread_.Start(); |
- |
- using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy; |
- |
- std::vector<SchedulerWorkerPoolParams> params_vector; |
- |
- ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size()); |
- params_vector.emplace_back("Background", ThreadPriority::BACKGROUND, |
- StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); |
- |
- ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size()); |
- params_vector.emplace_back("Foreground", ThreadPriority::NORMAL, |
- StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); |
- |
- delayed_task_manager_ = |
- MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); |
- single_thread_task_runner_manager_ = |
- MakeUnique<SchedulerSingleThreadTaskRunnerManager>( |
- params_vector, Bind(&GetThreadPoolIndexForTraits), &task_tracker_, |
- delayed_task_manager_.get()); |
- } |
- |
- void TearDown() override { |
- single_thread_task_runner_manager_->JoinForTesting(); |
- single_thread_task_runner_manager_.reset(); |
- delayed_task_manager_.reset(); |
- service_thread_.Stop(); |
- } |
- |
- protected: |
- std::unique_ptr<SchedulerSingleThreadTaskRunnerManager> |
- single_thread_task_runner_manager_; |
- TaskTracker task_tracker_; |
- |
- private: |
- Thread service_thread_; |
- std::unique_ptr<DelayedTaskManager> delayed_task_manager_; |
- |
- DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTest); |
-}; |
- |
-void CaptureThreadRef(PlatformThreadRef* thread_ref) { |
- ASSERT_TRUE(thread_ref); |
- *thread_ref = PlatformThread::CurrentRef(); |
-} |
- |
-void CaptureThreadPriority(ThreadPriority* thread_priority) { |
- ASSERT_TRUE(thread_priority); |
- *thread_priority = PlatformThread::GetCurrentThreadPriority(); |
-} |
- |
-void ShouldNotRun() { |
- ADD_FAILURE() << "Ran a task that shouldn't run."; |
-} |
- |
-} // namespace |
- |
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) { |
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithShutdownBehavior( |
- TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithShutdownBehavior( |
- TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
- |
- PlatformThreadRef thread_ref_1; |
- task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_1)); |
- PlatformThreadRef thread_ref_2; |
- task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_2)); |
- |
- task_tracker_.Shutdown(); |
- |
- ASSERT_FALSE(thread_ref_1.is_null()); |
- ASSERT_FALSE(thread_ref_2.is_null()); |
- EXPECT_NE(thread_ref_1, thread_ref_2); |
-} |
- |
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) { |
- // Why are events used here instead of the task tracker? |
- // Shutting down can cause priorities to get raised. This means we have to use |
- // events to determine when a task is run. |
- scoped_refptr<SingleThreadTaskRunner> task_runner_background = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithPriority(TaskPriority::BACKGROUND)); |
- scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)); |
- scoped_refptr<SingleThreadTaskRunner> task_runner_user_blocking = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits() |
- .WithPriority(TaskPriority::USER_BLOCKING) |
- .WithShutdownBehavior(TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
- |
- ThreadPriority thread_priority_background; |
- task_runner_background->PostTask( |
- FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_background)); |
- WaitableEvent waitable_event_background( |
- WaitableEvent::ResetPolicy::MANUAL, |
- WaitableEvent::InitialState::NOT_SIGNALED); |
- task_runner_background->PostTask( |
- FROM_HERE, |
- Bind(&WaitableEvent::Signal, Unretained(&waitable_event_background))); |
- |
- ThreadPriority thread_priority_user_visible; |
- task_runner_user_visible->PostTask( |
- FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_visible)); |
- WaitableEvent waitable_event_user_visible( |
- WaitableEvent::ResetPolicy::MANUAL, |
- WaitableEvent::InitialState::NOT_SIGNALED); |
- task_runner_user_visible->PostTask( |
- FROM_HERE, |
- Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_visible))); |
- |
- ThreadPriority thread_priority_user_blocking; |
- task_runner_user_blocking->PostTask( |
- FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_blocking)); |
- WaitableEvent waitable_event_user_blocking( |
- WaitableEvent::ResetPolicy::MANUAL, |
- WaitableEvent::InitialState::NOT_SIGNALED); |
- task_runner_user_blocking->PostTask( |
- FROM_HERE, |
- Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_blocking))); |
- |
- waitable_event_background.Wait(); |
- waitable_event_user_visible.Wait(); |
- waitable_event_user_blocking.Wait(); |
- |
- if (Lock::HandlesMultipleThreadPriorities()) |
- EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background); |
- else |
- EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background); |
- EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible); |
- EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking); |
-} |
- |
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) { |
- auto task_runner = single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); |
- task_tracker_.Shutdown(); |
- EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRun))); |
-} |
- |
-// Verify that a Task runs shortly after its delay expires. |
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) { |
- TimeTicks start_time = TimeTicks::Now(); |
- |
- // Post a task with a short delay. |
- WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, |
- WaitableEvent::InitialState::NOT_SIGNALED); |
- auto task_runner = single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); |
- EXPECT_TRUE(task_runner->PostDelayedTask( |
- FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)), |
- TestTimeouts::tiny_timeout())); |
- |
- // Wait until the task runs. |
- task_ran.Wait(); |
- |
- // Expect the task to run after its delay expires, but not more than 250 ms |
- // after that. |
- const TimeDelta actual_delay = TimeTicks::Now() - start_time; |
- EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout()); |
- EXPECT_LT(actual_delay, |
- TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout()); |
-} |
- |
-TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, |
- RunsTasksOnCurrentThread) { |
- scoped_refptr<SingleThreadTaskRunner> task_runner_1 = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithShutdownBehavior( |
- TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
- scoped_refptr<SingleThreadTaskRunner> task_runner_2 = |
- single_thread_task_runner_manager_ |
- ->CreateSingleThreadTaskRunnerWithTraits( |
- TaskTraits().WithShutdownBehavior( |
- TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
- |
- EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread()); |
- EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread()); |
- |
- task_runner_1->PostTask( |
- FROM_HERE, |
- Bind( |
- [](scoped_refptr<SingleThreadTaskRunner> task_runner_1, |
- scoped_refptr<SingleThreadTaskRunner> task_runner_2) { |
- EXPECT_TRUE(task_runner_1->RunsTasksOnCurrentThread()); |
- EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread()); |
- }, |
- task_runner_1, task_runner_2)); |
- |
- task_runner_2->PostTask( |
- FROM_HERE, |
- Bind( |
- [](scoped_refptr<SingleThreadTaskRunner> task_runner_1, |
- scoped_refptr<SingleThreadTaskRunner> task_runner_2) { |
- EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread()); |
- EXPECT_TRUE(task_runner_2->RunsTasksOnCurrentThread()); |
- }, |
- task_runner_1, task_runner_2)); |
- |
- task_tracker_.Shutdown(); |
-} |
- |
-} // namespace internal |
-} // namespace base |