OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "components/scheduler/base/delayed_task_delegate.h" |
| 6 |
| 7 #include "base/test/simple_test_tick_clock.h" |
| 8 #include "cc/test/ordered_simple_task_runner.h" |
| 9 #include "components/scheduler/base/task_queue_impl.h" |
| 10 #include "components/scheduler/base/task_queue_manager.h" |
| 11 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" |
| 12 #include "components/scheduler/base/test_time_source.h" |
| 13 #include "testing/gmock/include/gmock/gmock.h" |
| 14 |
| 15 using testing::_; |
| 16 |
| 17 namespace scheduler { |
| 18 |
| 19 class MockDelayedTaskDelegate : public DelayedTaskDelegate { |
| 20 public: |
| 21 MockDelayedTaskDelegate() : belongs_to_current_thread_(true) {} |
| 22 |
| 23 // TimeSource implementation: |
| 24 base::TimeTicks CachedNow() override { |
| 25 return now_; |
| 26 } |
| 27 void InvalidateNowCache() override { |
| 28 } |
| 29 |
| 30 bool BelongsToCurrentThread() const override { |
| 31 return belongs_to_current_thread_; |
| 32 } |
| 33 |
| 34 MOCK_METHOD2(PostScheduleDelayedWorkTaskOnMainThread, |
| 35 void(internal::TaskQueueImpl* queue, |
| 36 base::TimeTicks delayed_run_time)); |
| 37 MOCK_METHOD1(ScheduleDoWork, void(base::TimeDelta delay)); |
| 38 |
| 39 void SetNow(base::TimeTicks now) { |
| 40 now_ = now; |
| 41 } |
| 42 |
| 43 void SetBelongsToCurrentThread(bool belongs_to_current_thread) { |
| 44 belongs_to_current_thread_ = belongs_to_current_thread; |
| 45 } |
| 46 |
| 47 const DelayedWakeupMultimap& delayed_wakeup_multimap() const { |
| 48 return delayed_wakeup_multimap_; |
| 49 } |
| 50 |
| 51 private: |
| 52 base::TimeTicks now_; |
| 53 bool belongs_to_current_thread_; |
| 54 |
| 55 ~MockDelayedTaskDelegate() override {} |
| 56 |
| 57 DISALLOW_COPY_AND_ASSIGN(MockDelayedTaskDelegate); |
| 58 }; |
| 59 |
| 60 class DelayedTaskDelegateTest : public testing::Test { |
| 61 public: |
| 62 |
| 63 void SetUp() final { |
| 64 delegate_= make_scoped_refptr(new MockDelayedTaskDelegate); |
| 65 task_queue_ = make_scoped_refptr( |
| 66 new internal::TaskQueueImpl(nullptr, |
| 67 delegate_, |
| 68 TaskQueue::Spec("test_queue"), |
| 69 "test.category", |
| 70 "test.category")); |
| 71 } |
| 72 |
| 73 scoped_refptr<MockDelayedTaskDelegate> delegate_; |
| 74 scoped_refptr<internal::TaskQueueImpl> task_queue_; |
| 75 }; |
| 76 |
| 77 TEST_F(DelayedTaskDelegateTest, ScheduleDelayedWork_SameThread) { |
| 78 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
| 79 base::TimeTicks delayed_runtime = delegate_->CachedNow() + delay; |
| 80 EXPECT_CALL(*delegate_.get(), ScheduleDoWork(delay)); |
| 81 delegate_->ScheduleDelayedWork(task_queue_.get(), |
| 82 delegate_->CachedNow() + delay); |
| 83 |
| 84 EXPECT_EQ(delayed_runtime, |
| 85 delegate_->delayed_wakeup_multimap().begin()->first); |
| 86 EXPECT_EQ(task_queue_.get(), |
| 87 delegate_->delayed_wakeup_multimap().begin()->second); |
| 88 } |
| 89 |
| 90 TEST_F(DelayedTaskDelegateTest, ScheduleDelayedWork_DifferentThread) { |
| 91 delegate_->SetBelongsToCurrentThread(false); |
| 92 |
| 93 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
| 94 base::TimeTicks delayed_runtime = delegate_->CachedNow() + delay; |
| 95 EXPECT_CALL(*delegate_.get(), |
| 96 PostScheduleDelayedWorkTaskOnMainThread(task_queue_.get(), |
| 97 delayed_runtime)); |
| 98 delegate_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime); |
| 99 EXPECT_TRUE(delegate_->delayed_wakeup_multimap().empty()); |
| 100 } |
| 101 |
| 102 TEST_F(DelayedTaskDelegateTest, CancelDelayedWork) { |
| 103 scoped_refptr<internal::TaskQueueImpl> task_queue2_ = |
| 104 make_scoped_refptr( |
| 105 new internal::TaskQueueImpl(nullptr, |
| 106 delegate_, |
| 107 TaskQueue::Spec("test_queue2"), |
| 108 "test.category", |
| 109 "test.category")); |
| 110 |
| 111 EXPECT_CALL(*delegate_.get(), ScheduleDoWork(_)).Times(2); |
| 112 delegate_->ScheduleDelayedWork( |
| 113 task_queue_.get(), |
| 114 delegate_->CachedNow() + base::TimeDelta::FromMilliseconds(10)); |
| 115 delegate_->ScheduleDelayedWork( |
| 116 task_queue2_.get(), |
| 117 delegate_->CachedNow() + base::TimeDelta::FromMilliseconds(100)); |
| 118 |
| 119 EXPECT_EQ(task_queue_.get(), |
| 120 delegate_->delayed_wakeup_multimap().begin()->second); |
| 121 |
| 122 delegate_->CancelDelayedWork(task_queue_.get()); |
| 123 EXPECT_EQ(task_queue2_.get(), |
| 124 delegate_->delayed_wakeup_multimap().begin()->second); |
| 125 |
| 126 delegate_->CancelDelayedWork(task_queue2_.get()); |
| 127 EXPECT_TRUE(delegate_->delayed_wakeup_multimap().empty()); |
| 128 } |
| 129 |
| 130 TEST_F(DelayedTaskDelegateTest, WakeupReadyDelayedQueues) { |
| 131 scoped_refptr<MockDelayedTaskDelegate> dummy_delegate( |
| 132 new MockDelayedTaskDelegate); |
| 133 base::SimpleTestTickClock dummy_time_source; |
| 134 scoped_refptr<cc::OrderedSimpleTaskRunner> dummy_task_runner( |
| 135 new cc::OrderedSimpleTaskRunner(&dummy_time_source, false)); |
| 136 TaskQueueManager task_queue_manager( |
| 137 TaskQueueManagerDelegateForTest::Create( |
| 138 dummy_task_runner, |
| 139 make_scoped_ptr(new TestTimeSource(&dummy_time_source))), |
| 140 "test.scheduler", "test.scheduler", "scheduler.debug"); |
| 141 scoped_refptr<internal::TaskQueueImpl> dummy_queue = |
| 142 task_queue_manager.NewTaskQueue(TaskQueue::Spec("test_queue")); |
| 143 |
| 144 // Post a delayed task on |dummy_queue| and advance the queue's clock so that |
| 145 // next time MoveReadyDelayedTasksToIncomingQueue is called, the task will |
| 146 // get moved onto the incomming queue. |
| 147 base::TimeDelta dummy_delay = base::TimeDelta::FromMilliseconds(10); |
| 148 dummy_queue->PostDelayedTask(FROM_HERE, base::Closure(), dummy_delay); |
| 149 dummy_time_source.Advance(dummy_delay); |
| 150 |
| 151 // Now we can test that WakeupReadyDelayedQueues triggers calls to |
| 152 // MoveReadyDelayedTasksToIncomingQueue as expected. |
| 153 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50); |
| 154 base::TimeTicks delayed_runtime = delegate_->CachedNow() + delay; |
| 155 EXPECT_CALL(*delegate_.get(), ScheduleDoWork(delay)); |
| 156 delegate_->ScheduleDelayedWork(dummy_queue.get(), delayed_runtime); |
| 157 |
| 158 delegate_->WakeupReadyDelayedQueues(); |
| 159 EXPECT_EQ(0UL, dummy_queue->IncommingQueueSizeForTest()); |
| 160 |
| 161 delegate_->SetNow(delayed_runtime); |
| 162 delegate_->WakeupReadyDelayedQueues(); |
| 163 EXPECT_EQ(1UL, dummy_queue->IncommingQueueSizeForTest()); |
| 164 } |
| 165 |
| 166 } // namespace scheduler |
OLD | NEW |