Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(75)

Side by Side Diff: components/scheduler/base/task_queue_manager_unittest.cc

Issue 1424053002: Adds a flag to support "Virtual Time" to the blink scheduler (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Helps if I upload the right files ;) Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 "components/scheduler/base/task_queue_manager.h" 5 #include "components/scheduler/base/task_queue_manager.h"
6 6
7 #include "base/location.h" 7 #include "base/location.h"
8 #include "base/run_loop.h" 8 #include "base/run_loop.h"
9 #include "base/single_thread_task_runner.h" 9 #include "base/single_thread_task_runner.h"
10 #include "base/test/simple_test_tick_clock.h" 10 #include "base/test/simple_test_tick_clock.h"
11 #include "base/threading/thread.h" 11 #include "base/threading/thread.h"
12 #include "cc/test/ordered_simple_task_runner.h" 12 #include "cc/test/ordered_simple_task_runner.h"
13 #include "components/scheduler/base/nestable_task_runner_for_test.h"
14 #include "components/scheduler/base/task_queue_impl.h" 13 #include "components/scheduler/base/task_queue_impl.h"
14 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h"
15 #include "components/scheduler/base/task_queue_selector.h" 15 #include "components/scheduler/base/task_queue_selector.h"
16 #include "components/scheduler/base/task_queue_sets.h" 16 #include "components/scheduler/base/task_queue_sets.h"
17 #include "components/scheduler/base/test_always_fail_time_source.h" 17 #include "components/scheduler/base/test_always_fail_time_source.h"
18 #include "components/scheduler/base/test_time_source.h" 18 #include "components/scheduler/base/test_time_source.h"
19 #include "testing/gmock/include/gmock/gmock.h" 19 #include "testing/gmock/include/gmock/gmock.h"
20 20
21 using testing::ElementsAre; 21 using testing::ElementsAre;
22 using testing::_; 22 using testing::_;
23 23
24 namespace scheduler { 24 namespace scheduler {
25 25
26 class MessageLoopTaskRunner : public NestableTaskRunnerForTest { 26 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest {
27 public: 27 public:
28 static scoped_refptr<MessageLoopTaskRunner> Create() { 28 static scoped_refptr<MessageLoopTaskRunner> Create(
29 return make_scoped_refptr(new MessageLoopTaskRunner()); 29 scoped_ptr<base::TickClock> tick_clock) {
30 return make_scoped_refptr(new MessageLoopTaskRunner(tick_clock.Pass()));
30 } 31 }
31 32
32 // NestableTaskRunner implementation. 33 // NestableTaskRunner implementation.
33 bool IsNested() const override { 34 bool IsNested() const override {
34 return base::MessageLoop::current()->IsNested(); 35 return base::MessageLoop::current()->IsNested();
35 } 36 }
36 37
37 private: 38 private:
38 MessageLoopTaskRunner() 39 explicit MessageLoopTaskRunner(scoped_ptr<base::TickClock> tick_clock)
39 : NestableTaskRunnerForTest(base::MessageLoop::current()->task_runner()) { 40 : TaskQueueManagerDelegateForTest(base::MessageLoop::current()
40 } 41 ->task_runner(),
42 tick_clock.Pass()) {}
41 ~MessageLoopTaskRunner() override {} 43 ~MessageLoopTaskRunner() override {}
42 }; 44 };
43 45
44 class TaskQueueManagerTest : public testing::Test { 46 class TaskQueueManagerTest : public testing::Test {
45 public: 47 public:
46 void DeleteTaskQueueManager() { manager_.reset(); } 48 void DeleteTaskQueueManager() { manager_.reset(); }
47 49
48 protected: 50 protected:
49 void Initialize(size_t num_queues) { 51 void InitializeWithClock(size_t num_queues,
50 now_src_.reset(new base::SimpleTestTickClock()); 52 scoped_ptr<base::TickClock> test_time_source) {
51 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
52 test_task_runner_ = make_scoped_refptr( 53 test_task_runner_ = make_scoped_refptr(
53 new cc::OrderedSimpleTaskRunner(now_src_.get(), false)); 54 new cc::OrderedSimpleTaskRunner(now_src_.get(), false));
54 main_task_runner_ = 55 main_task_runner_ = TaskQueueManagerDelegateForTest::Create(
55 NestableTaskRunnerForTest::Create(test_task_runner_.get()); 56 test_task_runner_.get(),
57 make_scoped_ptr(new TestTimeSource(now_src_.get())));
56 manager_ = make_scoped_ptr(new TaskQueueManager( 58 manager_ = make_scoped_ptr(new TaskQueueManager(
57 main_task_runner_, "test.scheduler", "test.scheduler", 59 main_task_runner_, "test.scheduler", "test.scheduler",
58 "test.scheduler.debug")); 60 "test.scheduler.debug"));
59 manager_->SetTimeSourceForTesting(
60 make_scoped_ptr(new TestTimeSource(now_src_.get())));
61 61
62 for (size_t i = 0; i < num_queues; i++) 62 for (size_t i = 0; i < num_queues; i++)
63 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); 63 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue")));
64 } 64 }
65 65
66 void Initialize(size_t num_queues) {
67 now_src_.reset(new base::SimpleTestTickClock());
68 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
69 InitializeWithClock(num_queues,
70 make_scoped_ptr(new TestTimeSource(now_src_.get())));
71 }
72
66 void InitializeWithRealMessageLoop(size_t num_queues) { 73 void InitializeWithRealMessageLoop(size_t num_queues) {
67 message_loop_.reset(new base::MessageLoop()); 74 message_loop_.reset(new base::MessageLoop());
68 manager_ = make_scoped_ptr( 75 manager_ = make_scoped_ptr(new TaskQueueManager(
69 new TaskQueueManager(MessageLoopTaskRunner::Create(), "test.scheduler", 76 MessageLoopTaskRunner::Create(
70 "test.scheduler", "test.scheduler.debug")); 77 make_scoped_ptr(new TestTimeSource(now_src_.get()))),
78 "test.scheduler", "test.scheduler", "test.scheduler.debug"));
71 79
72 for (size_t i = 0; i < num_queues; i++) 80 for (size_t i = 0; i < num_queues; i++)
73 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue"))); 81 runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue")));
74 } 82 }
75 83
76 scoped_ptr<base::MessageLoop> message_loop_; 84 scoped_ptr<base::MessageLoop> message_loop_;
77 scoped_ptr<base::SimpleTestTickClock> now_src_; 85 scoped_ptr<base::SimpleTestTickClock> now_src_;
78 scoped_refptr<NestableTaskRunnerForTest> main_task_runner_; 86 scoped_refptr<TaskQueueManagerDelegateForTest> main_task_runner_;
79 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_; 87 scoped_refptr<cc::OrderedSimpleTaskRunner> test_task_runner_;
80 scoped_ptr<TaskQueueManager> manager_; 88 scoped_ptr<TaskQueueManager> manager_;
81 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_; 89 std::vector<scoped_refptr<internal::TaskQueueImpl>> runners_;
82 }; 90 };
83 91
84 void PostFromNestedRunloop(base::MessageLoop* message_loop, 92 void PostFromNestedRunloop(base::MessageLoop* message_loop,
85 base::SingleThreadTaskRunner* runner, 93 base::SingleThreadTaskRunner* runner,
86 std::vector<std::pair<base::Closure, bool>>* tasks) { 94 std::vector<std::pair<base::Closure, bool>>* tasks) {
87 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop); 95 base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
88 for (std::pair<base::Closure, bool>& pair : *tasks) { 96 for (std::pair<base::Closure, bool>& pair : *tasks) {
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
121 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order)); 129 runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
122 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order)); 130 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
123 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order)); 131 runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
124 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order)); 132 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 5, &run_order));
125 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order)); 133 runners_[2]->PostTask(FROM_HERE, base::Bind(&TestTask, 6, &run_order));
126 134
127 test_task_runner_->RunUntilIdle(); 135 test_task_runner_->RunUntilIdle();
128 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6)); 136 EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6));
129 } 137 }
130 138
131 void NopTask() {}
132
133 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) {
134 Initialize(3u);
135
136 manager_->SetTimeSourceForTesting(
137 make_scoped_ptr(new TestAlwaysFailTimeSource()));
138
139 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
140 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
141 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
142 runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
143 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
144 runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
145
146 test_task_runner_->RunUntilIdle();
147 }
148
149 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) { 139 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) {
150 InitializeWithRealMessageLoop(1u); 140 InitializeWithRealMessageLoop(1u);
151 141
152 std::vector<int> run_order; 142 std::vector<int> run_order;
153 runners_[0]->PostNonNestableTask(FROM_HERE, 143 runners_[0]->PostNonNestableTask(FROM_HERE,
154 base::Bind(&TestTask, 1, &run_order)); 144 base::Bind(&TestTask, 1, &run_order));
155 145
156 message_loop_->RunUntilIdle(); 146 message_loop_->RunUntilIdle();
157 EXPECT_THAT(run_order, ElementsAre(1)); 147 EXPECT_THAT(run_order, ElementsAre(1));
158 } 148 }
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
227 // After the delay has completed, the task runs normally. 217 // After the delay has completed, the task runs normally.
228 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1)); 218 test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(1));
229 EXPECT_THAT(run_order, ElementsAre(1)); 219 EXPECT_THAT(run_order, ElementsAre(1));
230 } 220 }
231 221
232 bool MessageLoopTaskCounter(size_t* count) { 222 bool MessageLoopTaskCounter(size_t* count) {
233 *count = *count + 1; 223 *count = *count + 1;
234 return true; 224 return true;
235 } 225 }
236 226
227 void NopTask() {}
228
237 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) { 229 TEST_F(TaskQueueManagerTest, DelayedTaskExecutedInOneMessageLoopTask) {
238 Initialize(1u); 230 Initialize(1u);
239 231
240 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10)); 232 base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
241 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay); 233 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay);
242 234
243 size_t task_count = 0; 235 size_t task_count = 0;
244 test_task_runner_->RunTasksWhile( 236 test_task_runner_->RunTasksWhile(
245 base::Bind(&MessageLoopTaskCounter, &task_count)); 237 base::Bind(&MessageLoopTaskCounter, &task_count));
246 EXPECT_EQ(1u, task_count); 238 EXPECT_EQ(1u, task_count);
(...skipping 632 matching lines...) Expand 10 before | Expand all | Expand 10 after
879 } 871 }
880 872
881 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) { 873 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) {
882 Initialize(1u); 874 Initialize(1u);
883 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); 875 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
884 manager_.reset(); 876 manager_.reset();
885 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread()); 877 EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
886 } 878 }
887 879
888 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) { 880 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) {
889 scoped_ptr<base::SimpleTestTickClock> clock(new base::SimpleTestTickClock());
890 clock->Advance(base::TimeDelta::FromMicroseconds(10000));
891 Initialize(2u); 881 Initialize(2u);
892 manager_->SetTimeSourceForTesting( 882 now_src_->Advance(base::TimeDelta::FromMicroseconds(10000));
893 make_scoped_ptr(new TestTimeSource(clock.get())));
894 883
895 // With no delayed tasks. 884 // With no delayed tasks.
896 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); 885 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
897 886
898 // With a non-delayed task. 887 // With a non-delayed task.
899 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); 888 runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
900 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null()); 889 EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
901 890
902 // With a delayed task. 891 // With a delayed task.
903 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50); 892 base::TimeDelta expected_delay = base::TimeDelta::FromMilliseconds(50);
904 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); 893 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
905 EXPECT_EQ(clock->NowTicks() + expected_delay, 894 EXPECT_EQ(now_src_->NowTicks() + expected_delay,
906 manager_->NextPendingDelayedTaskRunTime()); 895 manager_->NextPendingDelayedTaskRunTime());
907 896
908 // With another delayed task in the same queue with a longer delay. 897 // With another delayed task in the same queue with a longer delay.
909 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), 898 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
910 base::TimeDelta::FromMilliseconds(100)); 899 base::TimeDelta::FromMilliseconds(100));
911 EXPECT_EQ(clock->NowTicks() + expected_delay, 900 EXPECT_EQ(now_src_->NowTicks() + expected_delay,
912 manager_->NextPendingDelayedTaskRunTime()); 901 manager_->NextPendingDelayedTaskRunTime());
913 902
914 // With another delayed task in the same queue with a shorter delay. 903 // With another delayed task in the same queue with a shorter delay.
915 expected_delay = base::TimeDelta::FromMilliseconds(20); 904 expected_delay = base::TimeDelta::FromMilliseconds(20);
916 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); 905 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
917 EXPECT_EQ(clock->NowTicks() + expected_delay, 906 EXPECT_EQ(now_src_->NowTicks() + expected_delay,
918 manager_->NextPendingDelayedTaskRunTime()); 907 manager_->NextPendingDelayedTaskRunTime());
919 908
920 // With another delayed task in a different queue with a shorter delay. 909 // With another delayed task in a different queue with a shorter delay.
921 expected_delay = base::TimeDelta::FromMilliseconds(10); 910 expected_delay = base::TimeDelta::FromMilliseconds(10);
922 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay); 911 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), expected_delay);
923 EXPECT_EQ(clock->NowTicks() + expected_delay, 912 EXPECT_EQ(now_src_->NowTicks() + expected_delay,
924 manager_->NextPendingDelayedTaskRunTime()); 913 manager_->NextPendingDelayedTaskRunTime());
925 914
926 // Test it updates as time progresses 915 // Test it updates as time progresses
927 clock->Advance(expected_delay); 916 now_src_->Advance(expected_delay);
928 EXPECT_EQ(clock->NowTicks(), manager_->NextPendingDelayedTaskRunTime()); 917 EXPECT_EQ(now_src_->NowTicks(), manager_->NextPendingDelayedTaskRunTime());
929 } 918 }
930 919
931 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) { 920 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime_MultipleQueues) {
932 Initialize(3u); 921 Initialize(3u);
933 922
934 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50); 923 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50);
935 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5); 924 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(5);
936 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10); 925 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(10);
937 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1); 926 runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay1);
938 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2); 927 runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), delay2);
(...skipping 422 matching lines...) Expand 10 before | Expand all | Expand 10 after
1361 // release its reference, and checks that it has. 1350 // release its reference, and checks that it has.
1362 runners_[0]->PostTask(FROM_HERE, 1351 runners_[0]->PostTask(FROM_HERE,
1363 base::Bind(&HasOneRefTask, base::Unretained(&log), 1352 base::Bind(&HasOneRefTask, base::Unretained(&log),
1364 base::Unretained(task_queue.get()))); 1353 base::Unretained(task_queue.get())));
1365 message_loop_->RunUntilIdle(); 1354 message_loop_->RunUntilIdle();
1366 1355
1367 EXPECT_THAT(log, ElementsAre(false, false, true)); 1356 EXPECT_THAT(log, ElementsAre(false, false, true));
1368 } 1357 }
1369 1358
1370 } // namespace scheduler 1359 } // namespace scheduler
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698