OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "athena/home/home_card_gesture_manager.h" | |
6 | |
7 #include "athena/home/home_card_constants.h" | |
8 #include "athena/home/public/home_card.h" | |
9 #include "athena/test/base/athena_test_base.h" | |
10 #include "base/time/time.h" | |
11 #include "ui/events/event.h" | |
12 #include "ui/events/event_constants.h" | |
13 | |
14 namespace athena { | |
15 | |
16 class HomeCardGestureManagerTest : public test::AthenaTestBase, | |
17 public HomeCardGestureManager::Delegate { | |
18 public: | |
19 HomeCardGestureManagerTest() | |
20 : final_state_(HomeCard::HIDDEN), | |
21 last_from_state_(HomeCard::HIDDEN), | |
22 last_to_state_(HomeCard::HIDDEN), | |
23 last_progress_(0.0f), | |
24 was_fling_(false), | |
25 last_y_(0), | |
26 progress_count_(0), | |
27 end_count_(0) {} | |
28 ~HomeCardGestureManagerTest() override {} | |
29 | |
30 // testing::Test: | |
31 void SetUp() override { | |
32 test::AthenaTestBase::SetUp(); | |
33 gesture_manager_.reset(new HomeCardGestureManager(this, screen_bounds())); | |
34 } | |
35 | |
36 protected: | |
37 int GetEndCountAndReset() { | |
38 int result = end_count_; | |
39 end_count_ = 0; | |
40 return result; | |
41 } | |
42 int GetProgressCountAndReset() { | |
43 int result = progress_count_; | |
44 progress_count_ = 0; | |
45 return result; | |
46 } | |
47 | |
48 // Process a gesture event for our use case. | |
49 bool ProcessGestureEvent(ui::EventType type, int y) { | |
50 ui::GestureEventDetails details; | |
51 if (type == ui::ET_GESTURE_SCROLL_BEGIN || | |
52 type == ui::ET_GESTURE_SCROLL_UPDATE) | |
53 details = ui::GestureEventDetails(type, 0, (y - last_y_)); | |
54 else | |
55 details = ui::GestureEventDetails(type); | |
56 ui::GestureEvent event(0, y, ui::EF_NONE, base::TimeDelta(), details); | |
57 if (type == ui::ET_GESTURE_SCROLL_BEGIN) { | |
58 // Compute the position that the home card would have wrt to the top of | |
59 // the screen if the screen had screen_bounds(). | |
60 HomeCard::State state = HomeCard::Get()->GetState(); | |
61 int home_card_top = 0; | |
62 if (state == HomeCard::VISIBLE_BOTTOM) | |
63 home_card_top = screen_bounds().height() - kHomeCardHeight; | |
64 else if (state == HomeCard::VISIBLE_MINIMIZED) | |
65 home_card_top = screen_bounds().height() - kHomeCardMinimizedHeight; | |
66 | |
67 gfx::Point location = event.location(); | |
68 location.set_y(location.y() - home_card_top); | |
69 event.set_location(location); | |
70 } | |
71 gesture_manager_->ProcessGestureEvent(&event); | |
72 last_y_ = y; | |
73 return event.handled(); | |
74 } | |
75 | |
76 void ProcessFlingGesture(float velocity) { | |
77 ui::GestureEvent event(0, last_y_, ui::EF_NONE, base::TimeDelta(), | |
78 ui::GestureEventDetails( | |
79 ui::ET_SCROLL_FLING_START, 0, velocity)); | |
80 gesture_manager_->ProcessGestureEvent(&event); | |
81 } | |
82 | |
83 int screen_height() const { | |
84 return screen_bounds().height(); | |
85 } | |
86 | |
87 HomeCard::State final_state_; | |
88 HomeCard::State last_from_state_; | |
89 HomeCard::State last_to_state_; | |
90 float last_progress_; | |
91 bool was_fling_; | |
92 | |
93 private: | |
94 gfx::Rect screen_bounds() const { | |
95 return gfx::Rect(0, 0, 1280, 1024); | |
96 } | |
97 | |
98 // HomeCardGestureManager::Delegate: | |
99 void OnGestureEnded(HomeCard::State final_state, bool is_fling) override { | |
100 final_state_ = final_state; | |
101 was_fling_ = is_fling; | |
102 ++end_count_; | |
103 } | |
104 | |
105 void OnGestureProgressed(HomeCard::State from_state, | |
106 HomeCard::State to_state, | |
107 float progress) override { | |
108 last_from_state_ = from_state; | |
109 last_to_state_ = to_state; | |
110 last_progress_ = progress; | |
111 ++progress_count_; | |
112 } | |
113 | |
114 int last_y_; | |
115 int progress_count_; | |
116 int end_count_; | |
117 scoped_ptr<HomeCardGestureManager> gesture_manager_; | |
118 | |
119 DISALLOW_COPY_AND_ASSIGN(HomeCardGestureManagerTest); | |
120 }; | |
121 | |
122 TEST_F(HomeCardGestureManagerTest, Basic) { | |
123 ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState()); | |
124 | |
125 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020)); | |
126 EXPECT_EQ(0, GetEndCountAndReset()); | |
127 EXPECT_EQ(0, GetProgressCountAndReset()); | |
128 | |
129 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1019); | |
130 EXPECT_EQ(1, GetProgressCountAndReset()); | |
131 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, last_from_state_); | |
132 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_to_state_); | |
133 EXPECT_GT(1.0f, last_progress_); | |
134 | |
135 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1020); | |
136 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1022); | |
137 EXPECT_EQ(2, GetProgressCountAndReset()); | |
138 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
139 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, last_to_state_); | |
140 EXPECT_EQ(1.0f, last_progress_); | |
141 | |
142 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1010); | |
143 float progress_1010 = last_progress_; | |
144 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1008); | |
145 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1000); | |
146 EXPECT_EQ(3, GetProgressCountAndReset()); | |
147 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, last_from_state_); | |
148 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_to_state_); | |
149 EXPECT_LT(progress_1010, last_progress_); | |
150 | |
151 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 900); | |
152 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 800); | |
153 EXPECT_EQ(2, GetProgressCountAndReset()); | |
154 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
155 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_); | |
156 float progress_800 = last_progress_; | |
157 EXPECT_GT(1.0f, last_progress_); | |
158 EXPECT_LT(0.0f, last_progress_); | |
159 | |
160 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 790); | |
161 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
162 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_); | |
163 EXPECT_LT(progress_800, last_progress_); | |
164 | |
165 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 810); | |
166 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
167 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_); | |
168 EXPECT_GT(progress_800, last_progress_); | |
169 | |
170 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 810)); | |
171 EXPECT_EQ(1, GetEndCountAndReset()); | |
172 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
173 EXPECT_FALSE(was_fling_); | |
174 } | |
175 | |
176 // Test gesture progress when the gesture is initiated when the home card is in | |
177 // the centered state. | |
178 TEST_F(HomeCardGestureManagerTest, StartCentered) { | |
179 HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED); | |
180 | |
181 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 20)); | |
182 | |
183 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 10); | |
184 EXPECT_EQ(1, GetProgressCountAndReset()); | |
185 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
186 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_); | |
187 EXPECT_EQ(1.0f, last_progress_); | |
188 | |
189 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 700); | |
190 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 710); | |
191 EXPECT_EQ(2, GetProgressCountAndReset()); | |
192 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_); | |
193 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_); | |
194 EXPECT_GT(1.0f, last_progress_); | |
195 EXPECT_LT(0.0f, last_progress_); | |
196 | |
197 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 960); | |
198 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 960)); | |
199 EXPECT_EQ(1, GetEndCountAndReset()); | |
200 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, final_state_); | |
201 } | |
202 | |
203 // Test gesture progress when the gesture is initiated when the home card is in | |
204 // the centered state. | |
205 TEST_F(HomeCardGestureManagerTest, StartBottom) { | |
206 HomeCard::Get()->SetState(HomeCard::VISIBLE_BOTTOM); | |
207 | |
208 // No changes for slight moves. | |
209 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 950)); | |
210 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 960); | |
211 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 960)); | |
212 EXPECT_EQ(1, GetEndCountAndReset()); | |
213 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
214 | |
215 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 950)); | |
216 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 800)); | |
217 EXPECT_EQ(1, GetEndCountAndReset()); | |
218 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
219 | |
220 // State change for the bigger moves. | |
221 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 850)); | |
222 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1000); | |
223 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 1000)); | |
224 EXPECT_EQ(1, GetEndCountAndReset()); | |
225 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, final_state_); | |
226 | |
227 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 850)); | |
228 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 300); | |
229 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 300)); | |
230 EXPECT_EQ(1, GetEndCountAndReset()); | |
231 EXPECT_EQ(HomeCard::VISIBLE_CENTERED, final_state_); | |
232 EXPECT_FALSE(was_fling_); | |
233 } | |
234 | |
235 TEST_F(HomeCardGestureManagerTest, FlingUpAtEnd) { | |
236 ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState()); | |
237 | |
238 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020)); | |
239 EXPECT_EQ(0, GetEndCountAndReset()); | |
240 EXPECT_EQ(0, GetProgressCountAndReset()); | |
241 | |
242 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1010); | |
243 ProcessFlingGesture(-150.0f); | |
244 EXPECT_EQ(1, GetEndCountAndReset()); | |
245 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
246 EXPECT_TRUE(was_fling_); | |
247 } | |
248 | |
249 TEST_F(HomeCardGestureManagerTest, FlingDownAtEnd) { | |
250 HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED); | |
251 | |
252 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 20)); | |
253 EXPECT_EQ(0, GetEndCountAndReset()); | |
254 EXPECT_EQ(0, GetProgressCountAndReset()); | |
255 | |
256 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 30); | |
257 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 100); | |
258 ProcessFlingGesture(150.0f); | |
259 EXPECT_EQ(1, GetEndCountAndReset()); | |
260 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
261 EXPECT_TRUE(was_fling_); | |
262 } | |
263 | |
264 TEST_F(HomeCardGestureManagerTest, WeakFling) { | |
265 ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState()); | |
266 | |
267 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020)); | |
268 EXPECT_EQ(0, GetEndCountAndReset()); | |
269 EXPECT_EQ(0, GetProgressCountAndReset()); | |
270 | |
271 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1010); | |
272 ProcessFlingGesture(-30.0f); | |
273 EXPECT_EQ(1, GetEndCountAndReset()); | |
274 EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, final_state_); | |
275 EXPECT_FALSE(was_fling_); | |
276 } | |
277 | |
278 // Test the situation where the user intends a single fling but the finger | |
279 // touches the screen long enough, so that the home card becomes bigger than the | |
280 // height of VISIBLE_BOTTOM state due to the scroll events. | |
281 // In this case the fling event should not change the final state from | |
282 // VISIBLE_BOTTOM to VISIBLE_CENTERED because the user's intention was a single | |
283 // fling. See http://crbug.com/415211 | |
284 TEST_F(HomeCardGestureManagerTest, FastFling) { | |
285 ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState()); | |
286 | |
287 EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020)); | |
288 EXPECT_EQ(0, GetEndCountAndReset()); | |
289 EXPECT_EQ(0, GetProgressCountAndReset()); | |
290 | |
291 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1010); | |
292 ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, | |
293 screen_height() - kHomeCardHeight); | |
294 ProcessFlingGesture(-150.0f); | |
295 EXPECT_EQ(1, GetEndCountAndReset()); | |
296 EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_); | |
297 EXPECT_TRUE(was_fling_); | |
298 } | |
299 | |
300 } // namespace athena | |
OLD | NEW |