OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <new> | 7 #include <new> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 28 matching lines...) Expand all Loading... |
39 | 39 |
40 namespace content { | 40 namespace content { |
41 namespace { | 41 namespace { |
42 | 42 |
43 const unsigned kRafAlignedEnabledTouch = 1; | 43 const unsigned kRafAlignedEnabledTouch = 1; |
44 const unsigned kRafAlignedEnabledMouse = 1 << 1; | 44 const unsigned kRafAlignedEnabledMouse = 1 << 1; |
45 | 45 |
46 // Simulate a 16ms frame signal. | 46 // Simulate a 16ms frame signal. |
47 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); | 47 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); |
48 | 48 |
49 const int kTestRoutingID = 13; | |
50 const char* kCoalescedCountHistogram = | 49 const char* kCoalescedCountHistogram = |
51 "Event.MainThreadEventQueue.CoalescedCount"; | 50 "Event.MainThreadEventQueue.CoalescedCount"; |
52 | 51 |
53 } // namespace | 52 } // namespace |
54 | 53 |
55 class HandledTask { | 54 class HandledTask { |
56 public: | 55 public: |
57 virtual ~HandledTask() {} | 56 virtual ~HandledTask() {} |
58 | 57 |
59 virtual blink::WebCoalescedInputEvent* taskAsEvent() = 0; | 58 virtual blink::WebCoalescedInputEvent* taskAsEvent() = 0; |
60 virtual unsigned taskAsClosure() const = 0; | 59 virtual unsigned taskAsClosure() const = 0; |
61 }; | 60 }; |
62 | 61 |
63 class HandledEvent : public HandledTask { | 62 class HandledEvent : public HandledTask { |
64 public: | 63 public: |
65 explicit HandledEvent(const blink::WebCoalescedInputEvent* event) | 64 explicit HandledEvent(const blink::WebCoalescedInputEvent& event) |
66 : event_(event->Event(), event->GetCoalescedEventsPointers()) {} | 65 : event_(event.Event(), event.GetCoalescedEventsPointers()) {} |
67 ~HandledEvent() override {} | 66 ~HandledEvent() override {} |
68 | 67 |
69 blink::WebCoalescedInputEvent* taskAsEvent() override { return &event_; } | 68 blink::WebCoalescedInputEvent* taskAsEvent() override { return &event_; } |
70 unsigned taskAsClosure() const override { | 69 unsigned taskAsClosure() const override { |
71 NOTREACHED(); | 70 NOTREACHED(); |
72 return 0; | 71 return 0; |
73 } | 72 } |
74 | 73 |
75 private: | 74 private: |
76 blink::WebCoalescedInputEvent event_; | 75 blink::WebCoalescedInputEvent event_; |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
110 features.push_back(features::kRafAlignedMouseInputEvents.name); | 109 features.push_back(features::kRafAlignedMouseInputEvents.name); |
111 } else { | 110 } else { |
112 disabled_features.push_back(features::kRafAlignedMouseInputEvents.name); | 111 disabled_features.push_back(features::kRafAlignedMouseInputEvents.name); |
113 } | 112 } |
114 | 113 |
115 feature_list_.InitFromCommandLine(base::JoinString(features, ","), | 114 feature_list_.InitFromCommandLine(base::JoinString(features, ","), |
116 base::JoinString(disabled_features, ",")); | 115 base::JoinString(disabled_features, ",")); |
117 } | 116 } |
118 | 117 |
119 void SetUp() override { | 118 void SetUp() override { |
120 queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_, | 119 queue_ = |
121 &renderer_scheduler_); | 120 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); |
122 } | |
123 | |
124 void HandleEventOnMainThread(int routing_id, | |
125 const blink::WebCoalescedInputEvent* event, | |
126 const ui::LatencyInfo& latency, | |
127 InputEventDispatchType type) override { | |
128 EXPECT_EQ(kTestRoutingID, routing_id); | |
129 | |
130 std::unique_ptr<HandledTask> handled_event(new HandledEvent(event)); | |
131 handled_tasks_.push_back(std::move(handled_event)); | |
132 | |
133 queue_->EventHandled(event->Event().GetType(), | |
134 blink::WebInputEventResult::kHandledApplication, | |
135 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
136 } | |
137 | |
138 void SendInputEventAck(int routing_id, | |
139 blink::WebInputEvent::Type type, | |
140 InputEventAckState ack_result, | |
141 uint32_t touch_event_id) override { | |
142 additional_acked_events_.push_back(touch_event_id); | |
143 } | 121 } |
144 | 122 |
145 bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { | 123 bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { |
146 return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), | 124 return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), |
147 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 125 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
148 ack_result); | 126 ack_result); |
149 } | 127 } |
150 | 128 |
151 void RunClosure(unsigned closure_id) { | 129 void RunClosure(unsigned closure_id) { |
152 std::unique_ptr<HandledTask> closure(new HandledClosure(closure_id)); | 130 std::unique_ptr<HandledTask> closure(new HandledClosure(closure_id)); |
153 handled_tasks_.push_back(std::move(closure)); | 131 handled_tasks_.push_back(std::move(closure)); |
154 } | 132 } |
155 | 133 |
156 void QueueClosure() { | 134 void QueueClosure() { |
157 unsigned closure_id = ++closure_count_; | 135 unsigned closure_id = ++closure_count_; |
158 queue_->QueueClosure(base::Bind(&MainThreadEventQueueTest::RunClosure, | 136 queue_->QueueClosure(base::Bind(&MainThreadEventQueueTest::RunClosure, |
159 base::Unretained(this), closure_id)); | 137 base::Unretained(this), closure_id)); |
160 } | 138 } |
161 | 139 |
162 void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; } | |
163 | |
164 MainThreadEventQueueTaskList& event_queue() { | 140 MainThreadEventQueueTaskList& event_queue() { |
165 return queue_->shared_state_.events_; | 141 return queue_->shared_state_.events_; |
166 } | 142 } |
167 | 143 |
168 bool last_touch_start_forced_nonblocking_due_to_fling() { | 144 bool last_touch_start_forced_nonblocking_due_to_fling() { |
169 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; | 145 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; |
170 } | 146 } |
171 | 147 |
172 void set_enable_fling_passive_listener_flag(bool enable_flag) { | 148 void set_enable_fling_passive_listener_flag(bool enable_flag) { |
173 queue_->enable_fling_passive_listener_flag_ = enable_flag; | 149 queue_->enable_fling_passive_listener_flag_ = enable_flag; |
174 } | 150 } |
175 | 151 |
176 void RunPendingTasksWithSimulatedRaf() { | 152 void RunPendingTasksWithSimulatedRaf() { |
177 while (needs_main_frame_ || main_task_runner_->HasPendingTask()) { | 153 while (needs_main_frame_ || main_task_runner_->HasPendingTask()) { |
178 main_task_runner_->RunUntilIdle(); | 154 main_task_runner_->RunUntilIdle(); |
179 needs_main_frame_ = false; | 155 needs_main_frame_ = false; |
180 frame_time_ += kFrameInterval; | 156 frame_time_ += kFrameInterval; |
181 queue_->DispatchRafAlignedInput(frame_time_); | 157 queue_->DispatchRafAlignedInput(frame_time_); |
182 } | 158 } |
183 } | 159 } |
184 | 160 |
185 void RunSimulatedRafOnce() { | 161 void RunSimulatedRafOnce() { |
186 if (needs_main_frame_) { | 162 if (needs_main_frame_) { |
187 needs_main_frame_ = false; | 163 needs_main_frame_ = false; |
188 frame_time_ += kFrameInterval; | 164 frame_time_ += kFrameInterval; |
189 queue_->DispatchRafAlignedInput(frame_time_); | 165 queue_->DispatchRafAlignedInput(frame_time_); |
190 } | 166 } |
191 } | 167 } |
192 | 168 |
| 169 InputEventAckState HandleInputEvent( |
| 170 const blink::WebCoalescedInputEvent& event, |
| 171 const ui::LatencyInfo& latency, |
| 172 InputEventDispatchType dispatch_type) override { |
| 173 std::unique_ptr<HandledTask> handled_event(new HandledEvent(event)); |
| 174 handled_tasks_.push_back(std::move(handled_event)); |
| 175 return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; |
| 176 } |
| 177 |
| 178 void SendInputEventAck(blink::WebInputEvent::Type type, |
| 179 InputEventAckState ack_result, |
| 180 uint32_t touch_event_id) override { |
| 181 additional_acked_events_.push_back(touch_event_id); |
| 182 } |
| 183 |
| 184 void SetNeedsMainFrame() override { needs_main_frame_ = true; } |
| 185 |
193 protected: | 186 protected: |
194 base::test::ScopedFeatureList feature_list_; | 187 base::test::ScopedFeatureList feature_list_; |
195 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 188 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
196 blink::scheduler::MockRendererScheduler renderer_scheduler_; | 189 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
197 scoped_refptr<MainThreadEventQueue> queue_; | 190 scoped_refptr<MainThreadEventQueue> queue_; |
198 std::vector<std::unique_ptr<HandledTask>> handled_tasks_; | 191 std::vector<std::unique_ptr<HandledTask>> handled_tasks_; |
199 | 192 |
200 std::vector<uint32_t> additional_acked_events_; | 193 std::vector<uint32_t> additional_acked_events_; |
201 int raf_aligned_input_setting_; | 194 int raf_aligned_input_setting_; |
202 bool needs_main_frame_; | 195 bool needs_main_frame_; |
(...skipping 669 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
872 } | 865 } |
873 | 866 |
874 // The boolean parameterized test varies whether rAF aligned input | 867 // The boolean parameterized test varies whether rAF aligned input |
875 // is enabled or not. | 868 // is enabled or not. |
876 INSTANTIATE_TEST_CASE_P( | 869 INSTANTIATE_TEST_CASE_P( |
877 MainThreadEventQueueTests, | 870 MainThreadEventQueueTests, |
878 MainThreadEventQueueTest, | 871 MainThreadEventQueueTest, |
879 testing::Range(0u, | 872 testing::Range(0u, |
880 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); | 873 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); |
881 | 874 |
882 class DummyMainThreadEventQueueClient : public MainThreadEventQueueClient { | |
883 void HandleEventOnMainThread(int routing_id, | |
884 const blink::WebCoalescedInputEvent* event, | |
885 const ui::LatencyInfo& latency, | |
886 InputEventDispatchType dispatch_type) override {} | |
887 | |
888 void SendInputEventAck(int routing_id, | |
889 blink::WebInputEvent::Type type, | |
890 InputEventAckState ack_result, | |
891 uint32_t touch_event_id) override {} | |
892 | |
893 void NeedsMainFrame(int routing_id) override {} | |
894 }; | |
895 | |
896 class MainThreadEventQueueInitializationTest | 875 class MainThreadEventQueueInitializationTest |
897 : public testing::Test { | 876 : public testing::Test, |
| 877 public MainThreadEventQueueClient { |
898 public: | 878 public: |
899 MainThreadEventQueueInitializationTest() | 879 MainThreadEventQueueInitializationTest() |
900 : field_trial_list_(new base::FieldTrialList(nullptr)) {} | 880 : field_trial_list_(new base::FieldTrialList(nullptr)) {} |
901 | 881 |
902 base::TimeDelta main_thread_responsiveness_threshold() { | 882 base::TimeDelta main_thread_responsiveness_threshold() { |
903 return queue_->main_thread_responsiveness_threshold_; | 883 return queue_->main_thread_responsiveness_threshold_; |
904 } | 884 } |
905 | 885 |
906 bool enable_non_blocking_due_to_main_thread_responsiveness_flag() { | 886 bool enable_non_blocking_due_to_main_thread_responsiveness_flag() { |
907 return queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_; | 887 return queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_; |
908 } | 888 } |
909 | 889 |
| 890 InputEventAckState HandleInputEvent( |
| 891 const blink::WebCoalescedInputEvent& event, |
| 892 const ui::LatencyInfo& latency, |
| 893 InputEventDispatchType dispatch_type) override { |
| 894 return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; |
| 895 } |
| 896 |
| 897 void SendInputEventAck(blink::WebInputEvent::Type type, |
| 898 InputEventAckState ack_result, |
| 899 uint32_t touch_event_id) override {} |
| 900 |
| 901 void SetNeedsMainFrame() override {} |
| 902 |
910 protected: | 903 protected: |
911 scoped_refptr<MainThreadEventQueue> queue_; | 904 scoped_refptr<MainThreadEventQueue> queue_; |
912 base::test::ScopedFeatureList feature_list_; | 905 base::test::ScopedFeatureList feature_list_; |
913 blink::scheduler::MockRendererScheduler renderer_scheduler_; | 906 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
914 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 907 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
915 std::unique_ptr<base::FieldTrialList> field_trial_list_; | 908 std::unique_ptr<base::FieldTrialList> field_trial_list_; |
916 DummyMainThreadEventQueueClient dummy_main_thread_event_queue_client_; | |
917 }; | 909 }; |
918 | 910 |
919 TEST_F(MainThreadEventQueueInitializationTest, | 911 TEST_F(MainThreadEventQueueInitializationTest, |
920 MainThreadResponsivenessThresholdEnabled) { | 912 MainThreadResponsivenessThresholdEnabled) { |
921 feature_list_.InitFromCommandLine( | 913 feature_list_.InitFromCommandLine( |
922 features::kMainThreadBusyScrollIntervention.name, ""); | 914 features::kMainThreadBusyScrollIntervention.name, ""); |
923 | 915 |
924 base::FieldTrialList::CreateFieldTrial( | 916 base::FieldTrialList::CreateFieldTrial( |
925 "MainThreadResponsivenessScrollIntervention", "Enabled123"); | 917 "MainThreadResponsivenessScrollIntervention", "Enabled123"); |
926 queue_ = new MainThreadEventQueue(kTestRoutingID, | 918 queue_ = |
927 &dummy_main_thread_event_queue_client_, | 919 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); |
928 main_task_runner_, &renderer_scheduler_); | |
929 EXPECT_TRUE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); | 920 EXPECT_TRUE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); |
930 EXPECT_EQ(base::TimeDelta::FromMilliseconds(123), | 921 EXPECT_EQ(base::TimeDelta::FromMilliseconds(123), |
931 main_thread_responsiveness_threshold()); | 922 main_thread_responsiveness_threshold()); |
932 } | 923 } |
933 | 924 |
934 TEST_F(MainThreadEventQueueInitializationTest, | 925 TEST_F(MainThreadEventQueueInitializationTest, |
935 MainThreadResponsivenessThresholdDisabled) { | 926 MainThreadResponsivenessThresholdDisabled) { |
936 base::FieldTrialList::CreateFieldTrial( | 927 base::FieldTrialList::CreateFieldTrial( |
937 "MainThreadResponsivenessScrollIntervention", "Control"); | 928 "MainThreadResponsivenessScrollIntervention", "Control"); |
938 queue_ = new MainThreadEventQueue(kTestRoutingID, | 929 queue_ = |
939 &dummy_main_thread_event_queue_client_, | 930 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); |
940 main_task_runner_, &renderer_scheduler_); | |
941 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); | 931 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); |
942 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), | 932 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), |
943 main_thread_responsiveness_threshold()); | 933 main_thread_responsiveness_threshold()); |
944 } | 934 } |
945 | 935 |
946 TEST_P(MainThreadEventQueueTest, QueuingTwoClosures) { | 936 TEST_P(MainThreadEventQueueTest, QueuingTwoClosures) { |
947 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 937 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
948 EXPECT_EQ(0u, event_queue().size()); | 938 EXPECT_EQ(0u, event_queue().size()); |
949 | 939 |
950 QueueClosure(); | 940 QueueClosure(); |
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1096 static_cast<const WebTouchEvent&>( | 1086 static_cast<const WebTouchEvent&>( |
1097 handled_tasks_.at(0)->taskAsEvent()->Event()) | 1087 handled_tasks_.at(0)->taskAsEvent()->Event()) |
1098 .dispatch_type); | 1088 .dispatch_type); |
1099 EXPECT_EQ(WebInputEvent::kBlocking, | 1089 EXPECT_EQ(WebInputEvent::kBlocking, |
1100 static_cast<const WebTouchEvent&>( | 1090 static_cast<const WebTouchEvent&>( |
1101 handled_tasks_.at(1)->taskAsEvent()->Event()) | 1091 handled_tasks_.at(1)->taskAsEvent()->Event()) |
1102 .dispatch_type); | 1092 .dispatch_type); |
1103 } | 1093 } |
1104 | 1094 |
1105 } // namespace content | 1095 } // namespace content |
OLD | NEW |