OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "platform/scheduler/child/scheduler_helper.h" | 5 #include "platform/scheduler/child/scheduler_helper.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/macros.h" | 8 #include "base/macros.h" |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/single_thread_task_runner.h" | 11 #include "base/single_thread_task_runner.h" |
12 #include "base/test/simple_test_tick_clock.h" | 12 #include "base/test/simple_test_tick_clock.h" |
13 #include "cc/test/ordered_simple_task_runner.h" | 13 #include "cc/test/ordered_simple_task_runner.h" |
14 #include "platform/scheduler/base/lazy_now.h" | 14 #include "platform/scheduler/base/lazy_now.h" |
15 #include "platform/scheduler/base/task_queue.h" | 15 #include "platform/scheduler/base/task_queue.h" |
16 #include "platform/scheduler/base/test_time_source.h" | 16 #include "platform/scheduler/base/test_time_source.h" |
17 #include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h" | 17 #include "platform/scheduler/child/scheduler_tqm_delegate_for_test.h" |
18 #include "testing/gmock/include/gmock/gmock.h" | 18 #include "testing/gmock/include/gmock/gmock.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
20 | 20 |
21 using testing::_; | 21 using ::testing::_; |
22 using testing::AnyNumber; | 22 using ::testing::AnyNumber; |
23 using testing::Invoke; | 23 using ::testing::Invoke; |
24 using testing::Return; | 24 using ::testing::Return; |
25 | 25 |
26 namespace blink { | 26 namespace blink { |
27 namespace scheduler { | 27 namespace scheduler { |
28 | 28 |
29 namespace { | 29 namespace { |
30 void AppendToVectorTestTask(std::vector<std::string>* vector, | 30 void AppendToVectorTestTask(std::vector<std::string>* vector, |
31 std::string value) { | 31 std::string value) { |
32 vector->push_back(value); | 32 vector->push_back(value); |
33 } | 33 } |
34 | 34 |
35 void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner, | 35 void AppendToVectorReentrantTask(base::SingleThreadTaskRunner* task_runner, |
36 std::vector<int>* vector, | 36 std::vector<int>* vector, |
37 int* reentrant_count, | 37 int* reentrant_count, |
38 int max_reentrant_count) { | 38 int max_reentrant_count) { |
39 vector->push_back((*reentrant_count)++); | 39 vector->push_back((*reentrant_count)++); |
40 if (*reentrant_count < max_reentrant_count) { | 40 if (*reentrant_count < max_reentrant_count) { |
41 task_runner->PostTask( | 41 task_runner->PostTask( |
42 FROM_HERE, | 42 FROM_HERE, |
43 base::Bind(AppendToVectorReentrantTask, base::Unretained(task_runner), | 43 base::Bind(AppendToVectorReentrantTask, base::Unretained(task_runner), |
44 vector, reentrant_count, max_reentrant_count)); | 44 vector, reentrant_count, max_reentrant_count)); |
45 } | 45 } |
46 } | 46 } |
47 | 47 |
48 }; // namespace | 48 }; // namespace |
49 | 49 |
50 class SchedulerHelperTest : public testing::Test { | 50 class SchedulerHelperTest : public ::testing::Test { |
51 public: | 51 public: |
52 SchedulerHelperTest() | 52 SchedulerHelperTest() |
53 : clock_(new base::SimpleTestTickClock()), | 53 : clock_(new base::SimpleTestTickClock()), |
54 mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_.get(), false)), | 54 mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_.get(), false)), |
55 main_task_runner_(SchedulerTqmDelegateForTest::Create( | 55 main_task_runner_(SchedulerTqmDelegateForTest::Create( |
56 mock_task_runner_, | 56 mock_task_runner_, |
57 base::WrapUnique(new TestTimeSource(clock_.get())))), | 57 base::WrapUnique(new TestTimeSource(clock_.get())))), |
58 scheduler_helper_(new SchedulerHelper(main_task_runner_)), | 58 scheduler_helper_(new SchedulerHelper(main_task_runner_)), |
59 default_task_runner_(scheduler_helper_->DefaultTaskQueue()) { | 59 default_task_runner_(scheduler_helper_->DefaultTaskQueue()) { |
60 clock_->Advance(base::TimeDelta::FromMicroseconds(5000)); | 60 clock_->Advance(base::TimeDelta::FromMicroseconds(5000)); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
98 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D1")); | 98 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D1")); |
99 default_task_runner_->PostTask( | 99 default_task_runner_->PostTask( |
100 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D2")); | 100 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D2")); |
101 default_task_runner_->PostTask( | 101 default_task_runner_->PostTask( |
102 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D3")); | 102 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D3")); |
103 default_task_runner_->PostTask( | 103 default_task_runner_->PostTask( |
104 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D4")); | 104 FROM_HERE, base::Bind(&AppendToVectorTestTask, &run_order, "D4")); |
105 | 105 |
106 RunUntilIdle(); | 106 RunUntilIdle(); |
107 EXPECT_THAT(run_order, | 107 EXPECT_THAT(run_order, |
108 testing::ElementsAre(std::string("D1"), std::string("D2"), | 108 ::testing::ElementsAre(std::string("D1"), std::string("D2"), |
109 std::string("D3"), std::string("D4"))); | 109 std::string("D3"), std::string("D4"))); |
110 } | 110 } |
111 | 111 |
112 TEST_F(SchedulerHelperTest, TestRentrantTask) { | 112 TEST_F(SchedulerHelperTest, TestRentrantTask) { |
113 int count = 0; | 113 int count = 0; |
114 std::vector<int> run_order; | 114 std::vector<int> run_order; |
115 default_task_runner_->PostTask( | 115 default_task_runner_->PostTask( |
116 FROM_HERE, base::Bind(AppendToVectorReentrantTask, | 116 FROM_HERE, base::Bind(AppendToVectorReentrantTask, |
117 base::RetainedRef(default_task_runner_), &run_order, | 117 base::RetainedRef(default_task_runner_), &run_order, |
118 &count, 5)); | 118 &count, 5)); |
119 RunUntilIdle(); | 119 RunUntilIdle(); |
120 | 120 |
121 EXPECT_THAT(run_order, testing::ElementsAre(0, 1, 2, 3, 4)); | 121 EXPECT_THAT(run_order, ::testing::ElementsAre(0, 1, 2, 3, 4)); |
122 } | 122 } |
123 | 123 |
124 TEST_F(SchedulerHelperTest, IsShutdown) { | 124 TEST_F(SchedulerHelperTest, IsShutdown) { |
125 EXPECT_FALSE(scheduler_helper_->IsShutdown()); | 125 EXPECT_FALSE(scheduler_helper_->IsShutdown()); |
126 | 126 |
127 scheduler_helper_->Shutdown(); | 127 scheduler_helper_->Shutdown(); |
128 EXPECT_TRUE(scheduler_helper_->IsShutdown()); | 128 EXPECT_TRUE(scheduler_helper_->IsShutdown()); |
129 } | 129 } |
130 | 130 |
131 TEST_F(SchedulerHelperTest, DefaultTaskRunnerRegistration) { | 131 TEST_F(SchedulerHelperTest, DefaultTaskRunnerRegistration) { |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
225 voter->SetQueueEnabled(false); | 225 voter->SetQueueEnabled(false); |
226 | 226 |
227 EXPECT_CALL(observer, OnTriedToExecuteBlockedTask(_, _)).Times(1); | 227 EXPECT_CALL(observer, OnTriedToExecuteBlockedTask(_, _)).Times(1); |
228 RunUntilIdle(); | 228 RunUntilIdle(); |
229 | 229 |
230 scheduler_helper_->SetObserver(nullptr); | 230 scheduler_helper_->SetObserver(nullptr); |
231 } | 231 } |
232 | 232 |
233 } // namespace scheduler | 233 } // namespace scheduler |
234 } // namespace blink | 234 } // namespace blink |
OLD | NEW |