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 670 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
873 } | 866 } |
874 | 867 |
875 // The boolean parameterized test varies whether rAF aligned input | 868 // The boolean parameterized test varies whether rAF aligned input |
876 // is enabled or not. | 869 // is enabled or not. |
877 INSTANTIATE_TEST_CASE_P( | 870 INSTANTIATE_TEST_CASE_P( |
878 MainThreadEventQueueTests, | 871 MainThreadEventQueueTests, |
879 MainThreadEventQueueTest, | 872 MainThreadEventQueueTest, |
880 testing::Range(0u, | 873 testing::Range(0u, |
881 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); | 874 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); |
882 | 875 |
883 class DummyMainThreadEventQueueClient : public MainThreadEventQueueClient { | |
884 void HandleEventOnMainThread(int routing_id, | |
885 const blink::WebCoalescedInputEvent* event, | |
886 const ui::LatencyInfo& latency, | |
887 InputEventDispatchType dispatch_type) override {} | |
888 | |
889 void SendInputEventAck(int routing_id, | |
890 blink::WebInputEvent::Type type, | |
891 InputEventAckState ack_result, | |
892 uint32_t touch_event_id) override {} | |
893 | |
894 void NeedsMainFrame(int routing_id) override {} | |
895 }; | |
896 | |
897 class MainThreadEventQueueInitializationTest | 876 class MainThreadEventQueueInitializationTest |
898 : public testing::Test { | 877 : public testing::Test, |
| 878 public MainThreadEventQueueClient { |
899 public: | 879 public: |
900 MainThreadEventQueueInitializationTest() | 880 MainThreadEventQueueInitializationTest() |
901 : field_trial_list_(new base::FieldTrialList(nullptr)) {} | 881 : field_trial_list_(new base::FieldTrialList(nullptr)) {} |
902 | 882 |
903 base::TimeDelta main_thread_responsiveness_threshold() { | 883 base::TimeDelta main_thread_responsiveness_threshold() { |
904 return queue_->main_thread_responsiveness_threshold_; | 884 return queue_->main_thread_responsiveness_threshold_; |
905 } | 885 } |
906 | 886 |
907 bool enable_non_blocking_due_to_main_thread_responsiveness_flag() { | 887 bool enable_non_blocking_due_to_main_thread_responsiveness_flag() { |
908 return queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_; | 888 return queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_; |
909 } | 889 } |
910 | 890 |
| 891 InputEventAckState HandleInputEvent( |
| 892 const blink::WebCoalescedInputEvent& event, |
| 893 const ui::LatencyInfo& latency, |
| 894 InputEventDispatchType dispatch_type) override { |
| 895 return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; |
| 896 } |
| 897 |
| 898 void SendInputEventAck(blink::WebInputEvent::Type type, |
| 899 InputEventAckState ack_result, |
| 900 uint32_t touch_event_id) override {} |
| 901 |
| 902 void SetNeedsMainFrame() override {} |
| 903 |
911 protected: | 904 protected: |
912 scoped_refptr<MainThreadEventQueue> queue_; | 905 scoped_refptr<MainThreadEventQueue> queue_; |
913 base::test::ScopedFeatureList feature_list_; | 906 base::test::ScopedFeatureList feature_list_; |
914 blink::scheduler::MockRendererScheduler renderer_scheduler_; | 907 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
915 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 908 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
916 std::unique_ptr<base::FieldTrialList> field_trial_list_; | 909 std::unique_ptr<base::FieldTrialList> field_trial_list_; |
917 DummyMainThreadEventQueueClient dummy_main_thread_event_queue_client_; | |
918 }; | 910 }; |
919 | 911 |
920 TEST_F(MainThreadEventQueueInitializationTest, | 912 TEST_F(MainThreadEventQueueInitializationTest, |
921 MainThreadResponsivenessThresholdEnabled) { | 913 MainThreadResponsivenessThresholdEnabled) { |
922 feature_list_.InitFromCommandLine( | 914 feature_list_.InitFromCommandLine( |
923 features::kMainThreadBusyScrollIntervention.name, ""); | 915 features::kMainThreadBusyScrollIntervention.name, ""); |
924 | 916 |
925 base::FieldTrialList::CreateFieldTrial( | 917 base::FieldTrialList::CreateFieldTrial( |
926 "MainThreadResponsivenessScrollIntervention", "Enabled123"); | 918 "MainThreadResponsivenessScrollIntervention", "Enabled123"); |
927 queue_ = new MainThreadEventQueue(kTestRoutingID, | 919 queue_ = |
928 &dummy_main_thread_event_queue_client_, | 920 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); |
929 main_task_runner_, &renderer_scheduler_); | |
930 EXPECT_TRUE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); | 921 EXPECT_TRUE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); |
931 EXPECT_EQ(base::TimeDelta::FromMilliseconds(123), | 922 EXPECT_EQ(base::TimeDelta::FromMilliseconds(123), |
932 main_thread_responsiveness_threshold()); | 923 main_thread_responsiveness_threshold()); |
933 } | 924 } |
934 | 925 |
935 TEST_F(MainThreadEventQueueInitializationTest, | 926 TEST_F(MainThreadEventQueueInitializationTest, |
936 MainThreadResponsivenessThresholdDisabled) { | 927 MainThreadResponsivenessThresholdDisabled) { |
937 base::FieldTrialList::CreateFieldTrial( | 928 base::FieldTrialList::CreateFieldTrial( |
938 "MainThreadResponsivenessScrollIntervention", "Control"); | 929 "MainThreadResponsivenessScrollIntervention", "Control"); |
939 queue_ = new MainThreadEventQueue(kTestRoutingID, | 930 queue_ = |
940 &dummy_main_thread_event_queue_client_, | 931 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); |
941 main_task_runner_, &renderer_scheduler_); | |
942 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); | 932 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); |
943 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), | 933 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), |
944 main_thread_responsiveness_threshold()); | 934 main_thread_responsiveness_threshold()); |
945 } | 935 } |
946 | 936 |
947 TEST_P(MainThreadEventQueueTest, QueuingTwoClosures) { | 937 TEST_P(MainThreadEventQueueTest, QueuingTwoClosures) { |
948 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 938 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
949 EXPECT_EQ(0u, event_queue().size()); | 939 EXPECT_EQ(0u, event_queue().size()); |
950 | 940 |
951 QueueClosure(); | 941 QueueClosure(); |
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1097 static_cast<const WebTouchEvent&>( | 1087 static_cast<const WebTouchEvent&>( |
1098 handled_tasks_.at(0)->taskAsEvent()->Event()) | 1088 handled_tasks_.at(0)->taskAsEvent()->Event()) |
1099 .dispatch_type); | 1089 .dispatch_type); |
1100 EXPECT_EQ(WebInputEvent::kBlocking, | 1090 EXPECT_EQ(WebInputEvent::kBlocking, |
1101 static_cast<const WebTouchEvent&>( | 1091 static_cast<const WebTouchEvent&>( |
1102 handled_tasks_.at(1)->taskAsEvent()->Event()) | 1092 handled_tasks_.at(1)->taskAsEvent()->Event()) |
1103 .dispatch_type); | 1093 .dispatch_type); |
1104 } | 1094 } |
1105 | 1095 |
1106 } // namespace content | 1096 } // namespace content |
OLD | NEW |