| // 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 "media/midi/task_service.h" | |
| #include <memory> | |
| #include "base/bind.h" | |
| #include "base/bind_helpers.h" | |
| #include "base/callback.h" | |
| #include "base/memory/ref_counted.h" | |
| #include "base/run_loop.h" | |
| #include "base/synchronization/lock.h" | |
| #include "base/test/test_simple_task_runner.h" | |
| #include "base/threading/thread_task_runner_handle.h" | |
| #include "base/time/time.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| namespace midi { | |
| namespace { | |
| enum { | |
| kDefaultRunner = TaskService::kDefaultRunnerId, | |
| kFirstRunner, | |
| kSecondRunner | |
| }; | |
| base::WaitableEvent* GetEvent() { | |
| static base::WaitableEvent* event = | |
| new base::WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL, | |
| base::WaitableEvent::InitialState::NOT_SIGNALED); | |
| return event; | |
| } | |
| void SignalEvent() { | |
| GetEvent()->Signal(); | |
| } | |
| void WaitEvent() { | |
| GetEvent()->Wait(); | |
| } | |
| void ResetEvent() { | |
| GetEvent()->Reset(); | |
| } | |
| class TaskServiceClient { | |
| public: | |
| TaskServiceClient(TaskService* task_service) | |
| : task_service_(task_service), | |
| wait_task_event_(std::make_unique<base::WaitableEvent>( | |
| base::WaitableEvent::ResetPolicy::MANUAL, | |
| base::WaitableEvent::InitialState::NOT_SIGNALED)), | |
| count_(0u) { | |
| DCHECK(task_service); | |
| } | |
| bool Bind() { return task_service()->BindInstance(); } | |
| bool Unbind() { return task_service()->UnbindInstance(); } | |
| void PostBoundTask(TaskService::RunnerId runner_id) { | |
| task_service()->PostBoundTask( | |
| runner_id, base::BindOnce(&TaskServiceClient::IncrementCount, | |
| base::Unretained(this))); | |
| } | |
| void PostBoundSignalTask(TaskService::RunnerId runner_id) { | |
| task_service()->PostBoundTask( | |
| runner_id, base::BindOnce(&TaskServiceClient::SignalEvent, | |
| base::Unretained(this))); | |
| } | |
| void PostBoundWaitTask(TaskService::RunnerId runner_id) { | |
| wait_task_event_->Reset(); | |
| task_service()->PostBoundTask( | |
| runner_id, | |
| base::BindOnce(&TaskServiceClient::WaitEvent, base::Unretained(this))); | |
| } | |
| void PostBoundDelayedSignalTask(TaskService::RunnerId runner_id) { | |
| task_service()->PostBoundDelayedTask( | |
| runner_id, | |
| base::BindOnce(&TaskServiceClient::SignalEvent, base::Unretained(this)), | |
| base::TimeDelta::FromMilliseconds(100)); | |
| } | |
| void WaitTask() { wait_task_event_->Wait(); } | |
| size_t count() { | |
| base::AutoLock lock(lock_); | |
| return count_; | |
| } | |
| private: | |
| TaskService* task_service() { return task_service_; } | |
| void IncrementCount() { | |
| base::AutoLock lock(lock_); | |
| count_++; | |
| } | |
| void SignalEvent() { | |
| IncrementCount(); | |
| midi::SignalEvent(); | |
| } | |
| void WaitEvent() { | |
| IncrementCount(); | |
| wait_task_event_->Signal(); | |
| midi::WaitEvent(); | |
| } | |
| base::Lock lock_; | |
| TaskService* task_service_; | |
| std::unique_ptr<base::WaitableEvent> wait_task_event_; | |
| size_t count_; | |
| DISALLOW_COPY_AND_ASSIGN(TaskServiceClient); | |
| }; | |
| class MidiTaskServiceTest : public ::testing::Test { | |
| public: | |
| MidiTaskServiceTest() = default; | |
| protected: | |
| TaskService* task_service() { return &task_service_; } | |
| void RunUntilIdle() { task_runner_->RunUntilIdle(); } | |
| private: | |
| void SetUp() override { | |
| ResetEvent(); | |
| task_runner_ = new base::TestSimpleTaskRunner(); | |
| thread_task_runner_handle_ = | |
| std::make_unique<base::ThreadTaskRunnerHandle>(task_runner_); | |
| } | |
| void TearDown() override { | |
| thread_task_runner_handle_.reset(); | |
| task_runner_.reset(); | |
| } | |
| scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
| std::unique_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_; | |
| TaskService task_service_; | |
| DISALLOW_COPY_AND_ASSIGN(MidiTaskServiceTest); | |
| }; | |
| // Tests if posted tasks without calling BindInstance() are ignored. | |
| TEST_F(MidiTaskServiceTest, RunUnauthorizedBoundTask) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| client->PostBoundTask(kFirstRunner); | |
| // Destruct |client| immediately, then see if the posted task is just ignored. | |
| // If it isn't, another thread will touch the destructed instance and will | |
| // cause a crash due to a use-after-free. | |
| client = nullptr; | |
| } | |
| // Tests if invalid BindInstance() calls are correctly rejected, and it does not | |
| // make the service insanity. | |
| TEST_F(MidiTaskServiceTest, BindTwice) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Should not be able to call BindInstance() twice before unbinding current | |
| // bound instance. | |
| EXPECT_FALSE(client->Bind()); | |
| // Should be able to unbind only the first instance. | |
| EXPECT_TRUE(client->Unbind()); | |
| EXPECT_FALSE(client->Unbind()); | |
| } | |
| // Tests if posted static tasks can be processed correctly. | |
| TEST_F(MidiTaskServiceTest, RunStaticTask) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Should be able to post a static task while an instance is bound. | |
| task_service()->PostStaticTask(kFirstRunner, base::BindOnce(&SignalEvent)); | |
| WaitEvent(); | |
| EXPECT_TRUE(client->Unbind()); | |
| ResetEvent(); | |
| EXPECT_TRUE(client->Bind()); | |
| task_service()->PostStaticTask(kFirstRunner, base::BindOnce(&SignalEvent)); | |
| // Should be able to unbind the instance to process a static task. | |
| EXPECT_TRUE(client->Unbind()); | |
| WaitEvent(); | |
| ResetEvent(); | |
| // Should be able to post a static task without a bound instance. | |
| task_service()->PostStaticTask(kFirstRunner, base::BindOnce(&SignalEvent)); | |
| WaitEvent(); | |
| } | |
| // Tests functionalities to run bound tasks. | |
| TEST_F(MidiTaskServiceTest, RunBoundTasks) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Tests if a post task run. | |
| EXPECT_EQ(0u, client->count()); | |
| client->PostBoundSignalTask(kFirstRunner); | |
| WaitEvent(); | |
| EXPECT_EQ(1u, client->count()); | |
| // Tests if another posted task is handled correctly even if the instance is | |
| // unbound immediately. The posted task should run safely if it starts before | |
| // UnboundInstance() is call. Otherwise, it should be ignored. It completely | |
| // depends on timing. | |
| client->PostBoundTask(kFirstRunner); | |
| EXPECT_TRUE(client->Unbind()); | |
| client = std::make_unique<TaskServiceClient>(task_service()); | |
| // Tests if an immediate call of another BindInstance() works correctly. | |
| EXPECT_TRUE(client->Bind()); | |
| // Runs two tasks in two runners. | |
| ResetEvent(); | |
| client->PostBoundSignalTask(kFirstRunner); | |
| client->PostBoundTask(kSecondRunner); | |
| // Waits only the first runner completion to see if the second runner handles | |
| // the task correctly even if the bound instance is destructed. | |
| WaitEvent(); | |
| EXPECT_TRUE(client->Unbind()); | |
| client = nullptr; | |
| } | |
| // Tests if a blocking task does not block other task runners. | |
| TEST_F(MidiTaskServiceTest, RunBlockingTask) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Posts a task that waits until the event is signaled. | |
| client->PostBoundWaitTask(kFirstRunner); | |
| // Confirms if the posted task starts. Now, the task should block in the task | |
| // until the second task is invoked. | |
| client->WaitTask(); | |
| // Posts another task to the second runner. The task should be able to run | |
| // even though another posted task is blocking inside a critical section that | |
| // protects running tasks from an instance unbinding. | |
| client->PostBoundSignalTask(kSecondRunner); | |
| // Wait until the second task runs. | |
| WaitEvent(); | |
| // UnbindInstance() should wait until any running task finishes so that the | |
| // instance can be destructed safely. | |
| EXPECT_TRUE(client->Unbind()); | |
| EXPECT_EQ(2u, client->count()); | |
| client = nullptr; | |
| } | |
| // Tests if a bound delayed task runs correctly. | |
| TEST_F(MidiTaskServiceTest, RunBoundDelayedTask) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Posts a delayed task that signals after 100msec. | |
| client->PostBoundDelayedSignalTask(kFirstRunner); | |
| // Wait until the delayed task runs. | |
| WaitEvent(); | |
| EXPECT_TRUE(client->Unbind()); | |
| EXPECT_EQ(1u, client->count()); | |
| client = nullptr; | |
| } | |
| // Tests if a bound task runs on the thread that bound the instance. | |
| TEST_F(MidiTaskServiceTest, RunBoundTaskOnDefaultRunner) { | |
| std::unique_ptr<TaskServiceClient> client = | |
| std::make_unique<TaskServiceClient>(task_service()); | |
| EXPECT_TRUE(client->Bind()); | |
| // Posts a task that increments the count on the caller thread. | |
| client->PostBoundTask(kDefaultRunner); | |
| // The posted task should not run until the current message loop is processed. | |
| EXPECT_EQ(0u, client->count()); | |
| RunUntilIdle(); | |
| EXPECT_EQ(1u, client->count()); | |
| EXPECT_TRUE(client->Unbind()); | |
| } | |
| } // namespace | |
| } // namespace midi |