OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 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 "hit_test_aggregator.h" | |
6 #include "cc/surfaces/frame_sink_id.h" | |
7 #include "cc/surfaces/local_surface_id.h" | |
8 #include "cc/surfaces/surface_id.h" | |
9 #include "display_hit_test_data_factory_local.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 | |
12 namespace viz { | |
13 namespace hit_test { | |
14 namespace test { | |
15 | |
16 namespace { | |
17 | |
18 constexpr cc::FrameSinkId kDisplayFrameSink(2, 0); | |
19 | |
20 cc::SurfaceId MakeSurfaceId(const cc::FrameSinkId& frame_sink_id, | |
21 uint32_t local_id) { | |
22 return cc::SurfaceId( | |
23 frame_sink_id, | |
24 cc::LocalSurfaceId(local_id, base::UnguessableToken::Deserialize(0, 1u))); | |
25 } | |
26 | |
27 } // namespace | |
28 | |
29 using namespace hit_test::mojom; | |
30 | |
31 class HitTestAggregatorTest : public testing::Test { | |
rjkroege
2017/06/15 21:58:44
more tests will be needed to address web contents
gklassen
2017/06/16 21:49:39
Done.
TODO added.
| |
32 public: | |
33 HitTestAggregatorTest() | |
34 : aggregator_( | |
35 base::MakeUnique<hit_test::DisplayHitTestDataFactoryLocal>()) {} | |
36 ~HitTestAggregatorTest() override {} | |
37 | |
38 void SetUp() override {} | |
39 | |
40 void TearDown() override {} | |
41 | |
42 HitTestAggregator aggregator_; | |
43 | |
44 int count() { | |
45 DisplayHitTestRegion* start = aggregator_.GetCurrentRegions(); | |
46 DisplayHitTestRegion* end = start; | |
47 while (end->child_count != kEndOfList) { | |
48 end++; | |
49 } | |
50 int count = end - start; | |
51 return count; | |
52 } | |
53 | |
54 DisplayHitTestRegion* RegionAtIndex(int i) { | |
55 return aggregator_.GetCurrentRegions() + i; | |
56 } | |
57 | |
58 int GetPendingCount() { return aggregator_.pending_.size(); } | |
59 int GetActiveCount() { return aggregator_.active_.size(); } | |
60 | |
61 int GetPendingRegionCount() { return RegionCount(aggregator_.pending_); } | |
62 int GetActiveRegionCount() { return RegionCount(aggregator_.active_); } | |
63 | |
64 int RegionCount(const HitTestDataMap& map) { | |
65 int size = 0; | |
66 for (auto const& it : map) { | |
67 hit_test::mojom::HitTestData* hit_test_data = it.second.get(); | |
68 size += hit_test_data->regions.size(); | |
69 } | |
70 return size; | |
71 } | |
72 | |
73 void Reset() { | |
74 int size = aggregator_.display_hit_test_data_->length; | |
75 | |
76 aggregator_.display_hit_test_data_->regions[0].child_count = kEndOfList; | |
77 aggregator_.display_hit_test_data_->regions[size >> 1].child_count = | |
78 kEndOfList; | |
79 | |
80 aggregator_.pending_.clear(); | |
81 aggregator_.active_.clear(); | |
82 } | |
83 | |
84 int GetDisplayHitTestDataLength() { | |
85 return aggregator_.display_hit_test_data_->length; | |
86 } | |
87 | |
88 // Creates a hit test data element with 8 children recursively to | |
89 // the specified depth. SurfaceIds are generated in sequential order and | |
90 // the method returns the next unused id ( also matches the count ). | |
91 int CreateAndSubmitHitTestDataWith8Children(int id, int depth) { | |
92 cc::SurfaceId surface_id = MakeSurfaceId(kDisplayFrameSink, id); | |
93 id++; | |
94 | |
95 auto hit_test_data = HitTestData::New(); | |
96 hit_test_data->surface_id = surface_id; | |
97 | |
98 for (int i = 0; i < 8; i++) { | |
99 auto hit_test_region = HitTestRegion::New(); | |
100 hit_test_region->rect.SetRect(100, 100, 100, 100); | |
101 | |
102 if (depth > 0) { | |
103 hit_test_region->flags = kHitTestChildSurface; | |
104 hit_test_region->surface_id = MakeSurfaceId(kDisplayFrameSink, id); | |
105 id = CreateAndSubmitHitTestDataWith8Children(id, depth - 1); | |
106 } else { | |
107 hit_test_region->flags = kHitTestMine; | |
108 } | |
109 hit_test_data->regions.push_back(std::move(hit_test_region)); | |
110 } | |
111 | |
112 aggregator_.SubmitHitTestData(std::move(hit_test_data)); | |
113 return id; | |
114 } | |
115 }; | |
116 | |
117 // One surface. | |
118 // | |
119 // +----------+ | |
120 // | | | |
121 // | | | |
122 // | | | |
123 // +----------+ | |
124 // | |
125 TEST_F(HitTestAggregatorTest, OneSurface) { | |
126 EXPECT_EQ(count(), 0); | |
127 | |
128 cc::SurfaceId display_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
129 | |
130 auto hit_test_data = HitTestData::New(); | |
131 hit_test_data->surface_id = display_surface_id; | |
132 | |
133 auto hit_test_region = HitTestRegion::New(); | |
134 hit_test_region->flags = kHitTestMine; | |
135 hit_test_region->surface_id = display_surface_id; | |
136 hit_test_region->rect.SetRect(0, 0, 1024, 768); | |
137 | |
138 hit_test_data->regions.push_back(std::move(hit_test_region)); | |
139 | |
140 aggregator_.SubmitHitTestData(std::move(hit_test_data)); | |
141 EXPECT_EQ(count(), 0); | |
142 | |
143 EXPECT_EQ(GetPendingCount(), 1); | |
144 EXPECT_EQ(GetActiveCount(), 0); | |
145 | |
146 aggregator_.OnSurfaceWillDraw(display_surface_id); | |
147 | |
148 EXPECT_EQ(GetPendingCount(), 0); | |
149 EXPECT_EQ(GetActiveCount(), 1); | |
150 | |
151 aggregator_.Aggregate(display_surface_id); | |
152 aggregator_.Swap(); | |
153 | |
154 // Expect 1 entry routing all events to the one surface ( display root ). | |
155 EXPECT_EQ(count(), 1); | |
156 | |
157 DisplayHitTestRegion* region; | |
158 | |
159 region = RegionAtIndex(0); | |
160 EXPECT_EQ(region->flags, kHitTestMine); | |
161 EXPECT_EQ(region->frame_sink_id, display_surface_id.frame_sink_id()); | |
162 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 1024, 768)); | |
163 EXPECT_EQ(region->child_count, 0); | |
164 } | |
165 | |
166 // One opaque embedder with two regions. | |
167 // | |
168 // +e------------+ | |
169 // | +r1-+ +r2-+ | | |
170 // | | | | | | | |
171 // | | | | | | | |
172 // | +---+ +---+ | | |
173 // +-------------+ | |
174 // | |
175 TEST_F(HitTestAggregatorTest, OneEmbedderTwoRegions) { | |
176 Reset(); | |
177 EXPECT_EQ(count(), 0); | |
178 | |
179 cc::SurfaceId e_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
180 | |
181 auto e_hit_test_data = HitTestData::New(); | |
182 e_hit_test_data->surface_id = e_surface_id; | |
183 | |
184 auto e_hit_test_region = HitTestRegion::New(); | |
185 e_hit_test_region->flags = kHitTestMine; | |
186 e_hit_test_region->surface_id = e_surface_id; | |
187 e_hit_test_region->rect.SetRect(0, 0, 1024, 768); | |
188 | |
189 auto e_hit_test_region_r1 = HitTestRegion::New(); | |
190 e_hit_test_region_r1->flags = kHitTestMine; | |
191 e_hit_test_region_r1->rect.SetRect(0, 0, 512, 512); | |
192 | |
193 auto e_hit_test_region_r2 = HitTestRegion::New(); | |
194 e_hit_test_region_r2->flags = kHitTestMine; | |
195 e_hit_test_region_r2->rect.SetRect(0, 0, 512, 512); | |
196 | |
197 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_r1)); | |
198 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_r2)); | |
199 e_hit_test_data->regions.push_back(std::move(e_hit_test_region)); | |
200 | |
201 // Submit HitTestData. | |
202 | |
203 EXPECT_EQ(GetPendingCount(), 0); | |
204 | |
205 aggregator_.SubmitHitTestData(std::move(e_hit_test_data)); | |
206 EXPECT_EQ(GetPendingCount(), 1); | |
207 | |
208 // Add Surfaces to DisplayFrame ( in unexpected order ). | |
209 | |
210 EXPECT_EQ(count(), 0); | |
211 EXPECT_EQ(GetActiveCount(), 0); | |
212 | |
213 aggregator_.OnSurfaceWillDraw(e_surface_id); | |
214 EXPECT_EQ(GetActiveCount(), 1); | |
215 | |
216 // Aggregate and swap. | |
217 | |
218 aggregator_.Aggregate(e_surface_id); | |
219 EXPECT_EQ(count(), 0); | |
220 | |
221 aggregator_.Swap(); | |
222 EXPECT_EQ(count(), 3); | |
223 | |
224 DisplayHitTestRegion* region; | |
225 | |
226 region = RegionAtIndex(0); | |
227 EXPECT_EQ(region->flags, kHitTestMine); | |
228 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 512, 512)); | |
229 EXPECT_EQ(region->child_count, 0); | |
230 | |
231 region = RegionAtIndex(1); | |
232 EXPECT_EQ(region->flags, kHitTestMine); | |
233 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 512, 512)); | |
234 EXPECT_EQ(region->child_count, 0); | |
235 | |
236 region = RegionAtIndex(2); | |
237 EXPECT_EQ(region->flags, kHitTestMine); | |
238 EXPECT_EQ(region->frame_sink_id, e_surface_id.frame_sink_id()); | |
239 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 1024, 768)); | |
240 EXPECT_EQ(region->child_count, 0); | |
241 } | |
242 | |
243 // One embedder with two children. | |
244 // | |
245 // +e------------+ | |
246 // | +c1-+ +c2-+ | | |
247 // | | | | | | | |
248 // | | | | | | | |
249 // | +---+ +---+ | | |
250 // +-------------+ | |
251 // | |
252 | |
253 TEST_F(HitTestAggregatorTest, OneEmbedderTwoChildren) { | |
254 Reset(); | |
255 EXPECT_EQ(count(), 0); | |
256 | |
257 cc::SurfaceId e_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
258 cc::SurfaceId c1_surface_id = MakeSurfaceId(kDisplayFrameSink, 2); | |
259 cc::SurfaceId c2_surface_id = MakeSurfaceId(kDisplayFrameSink, 3); | |
260 | |
261 auto e_hit_test_data = HitTestData::New(); | |
262 e_hit_test_data->surface_id = e_surface_id; | |
263 | |
264 auto e_hit_test_region = HitTestRegion::New(); | |
265 e_hit_test_region->flags = kHitTestMine; | |
266 e_hit_test_region->surface_id = e_surface_id; | |
267 e_hit_test_region->rect.SetRect(0, 0, 500, 500); | |
268 | |
269 auto e_hit_test_region_c1 = HitTestRegion::New(); | |
270 e_hit_test_region_c1->flags = kHitTestChildSurface; | |
271 e_hit_test_region_c1->surface_id = c1_surface_id; | |
272 e_hit_test_region_c1->rect.SetRect(100, 100, 200, 200); | |
273 | |
274 auto e_hit_test_region_c2 = HitTestRegion::New(); | |
275 e_hit_test_region_c2->flags = kHitTestChildSurface; | |
276 e_hit_test_region_c2->surface_id = c2_surface_id; | |
277 e_hit_test_region_c2->rect.SetRect(300, 300, 400, 400); | |
278 | |
279 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_c1)); | |
280 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_c2)); | |
281 e_hit_test_data->regions.push_back(std::move(e_hit_test_region)); | |
282 | |
283 auto c1_hit_test_data = HitTestData::New(); | |
284 c1_hit_test_data->surface_id = c1_surface_id; | |
285 | |
286 auto c2_hit_test_data = HitTestData::New(); | |
287 c2_hit_test_data->surface_id = c2_surface_id; | |
288 | |
289 // Submit ( in unexpected order ). | |
290 | |
291 EXPECT_EQ(GetPendingCount(), 0); | |
292 | |
293 aggregator_.SubmitHitTestData(std::move(c1_hit_test_data)); | |
294 EXPECT_EQ(GetPendingCount(), 1); | |
295 | |
296 aggregator_.SubmitHitTestData(std::move(e_hit_test_data)); | |
297 EXPECT_EQ(GetPendingCount(), 2); | |
298 | |
299 aggregator_.SubmitHitTestData(std::move(c2_hit_test_data)); | |
300 EXPECT_EQ(GetPendingCount(), 3); | |
301 | |
302 // Surfaces added to DisplayFrame ( in unexpected order ). | |
303 | |
304 EXPECT_EQ(count(), 0); | |
305 | |
306 EXPECT_EQ(GetActiveCount(), 0); | |
307 | |
308 aggregator_.OnSurfaceWillDraw(c2_surface_id); | |
309 EXPECT_EQ(GetActiveCount(), 1); | |
310 | |
311 aggregator_.OnSurfaceWillDraw(c1_surface_id); | |
312 EXPECT_EQ(GetActiveCount(), 2); | |
313 | |
314 aggregator_.OnSurfaceWillDraw(e_surface_id); | |
315 EXPECT_EQ(GetActiveCount(), 3); | |
316 | |
317 // Aggregate and swap. | |
318 | |
319 aggregator_.Aggregate(e_surface_id); | |
320 EXPECT_EQ(count(), 0); | |
321 | |
322 aggregator_.Swap(); | |
323 | |
324 EXPECT_EQ(count(), 3); | |
325 | |
326 DisplayHitTestRegion* region; | |
327 | |
328 region = RegionAtIndex(0); | |
329 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
rjkroege
2017/06/15 21:58:45
afaik, there are two levels of transform. Do you w
gklassen
2017/06/16 21:49:39
I would prefer to deal with this in a later patch
| |
330 EXPECT_EQ(region->frame_sink_id, c1_surface_id.frame_sink_id()); | |
331 EXPECT_EQ(region->rect, gfx::Rect(100, 100, 200, 200)); | |
332 EXPECT_EQ(region->child_count, 0); | |
333 | |
334 region = RegionAtIndex(1); | |
335 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
336 EXPECT_EQ(region->frame_sink_id, c2_surface_id.frame_sink_id()); | |
337 EXPECT_EQ(region->rect, gfx::Rect(300, 300, 400, 400)); | |
338 EXPECT_EQ(region->child_count, 0); | |
339 | |
340 region = RegionAtIndex(2); | |
341 EXPECT_EQ(region->flags, kHitTestMine); | |
342 EXPECT_EQ(region->frame_sink_id, e_surface_id.frame_sink_id()); | |
343 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 500, 500)); | |
344 EXPECT_EQ(region->child_count, 0); | |
345 } | |
346 | |
347 // Occluded child frame ( OOPIF ). | |
348 // | |
349 // +e-----------+ | |
350 // | +c--+ | | |
351 // | | +div-+ | | |
352 // | | | | | | |
353 // | | +----+ | | |
354 // | +---+ | | |
355 // +------------+ | |
356 // | |
357 | |
358 TEST_F(HitTestAggregatorTest, OccludedChildFrame) { | |
359 Reset(); | |
360 EXPECT_EQ(count(), 0); | |
361 | |
362 cc::SurfaceId e_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
363 cc::SurfaceId c_surface_id = MakeSurfaceId(kDisplayFrameSink, 2); | |
364 | |
365 auto e_hit_test_data = HitTestData::New(); | |
366 e_hit_test_data->surface_id = e_surface_id; | |
367 | |
368 auto e_hit_test_region = HitTestRegion::New(); | |
369 e_hit_test_region->flags = kHitTestMine; | |
370 e_hit_test_region->surface_id = e_surface_id; | |
371 e_hit_test_region->rect.SetRect(0, 0, 500, 500); | |
372 | |
373 auto e_hit_test_region_div = HitTestRegion::New(); | |
374 e_hit_test_region_div->flags = kHitTestMine; | |
375 e_hit_test_region_div->rect.SetRect(100, 100, 400, 400); | |
376 | |
377 auto e_hit_test_region_c = HitTestRegion::New(); | |
378 e_hit_test_region_c->flags = kHitTestChildSurface; | |
379 e_hit_test_region_c->surface_id = c_surface_id; | |
380 e_hit_test_region_c->rect.SetRect(200, 200, 500, 200); | |
381 | |
382 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_div)); | |
383 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_c)); | |
384 e_hit_test_data->regions.push_back(std::move(e_hit_test_region)); | |
385 | |
386 auto c_hit_test_data = HitTestData::New(); | |
387 c_hit_test_data->surface_id = c_surface_id; | |
388 | |
389 auto c_hit_test_region = HitTestRegion::New(); | |
390 c_hit_test_region->flags = kHitTestMine; | |
391 c_hit_test_region->surface_id = c_surface_id; | |
392 c_hit_test_region->rect.SetRect(0, 0, 300, 300); | |
393 | |
394 c_hit_test_data->regions.push_back(std::move(c_hit_test_region)); | |
395 | |
396 // Submit ( in unexpected order ). | |
397 | |
398 EXPECT_EQ(GetPendingCount(), 0); | |
399 | |
400 aggregator_.SubmitHitTestData(std::move(c_hit_test_data)); | |
401 EXPECT_EQ(GetPendingCount(), 1); | |
402 | |
403 aggregator_.SubmitHitTestData(std::move(e_hit_test_data)); | |
404 EXPECT_EQ(GetPendingCount(), 2); | |
405 | |
406 // Surfaces added to DisplayFrame ( in unexpected order ). | |
407 | |
408 EXPECT_EQ(count(), 0); | |
409 | |
410 EXPECT_EQ(GetActiveCount(), 0); | |
411 | |
412 aggregator_.OnSurfaceWillDraw(e_surface_id); | |
413 EXPECT_EQ(GetActiveCount(), 1); | |
414 | |
415 aggregator_.OnSurfaceWillDraw(c_surface_id); | |
416 EXPECT_EQ(GetActiveCount(), 2); | |
417 | |
418 // Aggregate and swap. | |
419 | |
420 aggregator_.Aggregate(e_surface_id); | |
421 EXPECT_EQ(count(), 0); | |
422 | |
423 aggregator_.Swap(); | |
424 | |
425 EXPECT_EQ(count(), 4); | |
426 | |
427 DisplayHitTestRegion* region; | |
428 | |
429 region = RegionAtIndex(0); | |
430 EXPECT_EQ(region->rect, gfx::Rect(100, 100, 400, 400)); | |
431 EXPECT_EQ(region->flags, kHitTestMine); | |
432 EXPECT_EQ(region->child_count, 0); | |
433 | |
434 region = RegionAtIndex(1); | |
435 EXPECT_EQ(region->rect, gfx::Rect(200, 200, 500, 200)); | |
436 EXPECT_EQ(region->frame_sink_id, c_surface_id.frame_sink_id()); | |
437 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
438 EXPECT_EQ(region->child_count, 1); | |
439 | |
440 region = RegionAtIndex(2); | |
441 EXPECT_EQ(region->flags, kHitTestMine); | |
442 EXPECT_EQ(region->frame_sink_id, c_surface_id.frame_sink_id()); | |
443 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 300, 300)); | |
444 EXPECT_EQ(region->child_count, 0); | |
445 | |
446 region = RegionAtIndex(3); | |
447 EXPECT_EQ(region->flags, kHitTestMine); | |
448 EXPECT_EQ(region->frame_sink_id, e_surface_id.frame_sink_id()); | |
449 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 500, 500)); | |
450 EXPECT_EQ(region->child_count, 0); | |
451 } | |
452 | |
453 // One embedder with a clipped child with a tab and transparent background. | |
454 // | |
455 // +e-------------+ | |
456 // | +c---------| Point maps to | |
457 // | 1 |+a--+ | ----- ------- | |
458 // | || 2 | 3 | 1 e | |
459 // | |+b--------| 2 a | |
460 // | || | 3 e ( transparent area in c ) | |
461 // | || 4 | 4 b | |
462 // +--------------+ | |
463 // | |
464 | |
465 TEST_F(HitTestAggregatorTest, ClippedChildWithTabAndTransparentBackground) { | |
466 Reset(); | |
467 EXPECT_EQ(count(), 0); | |
468 | |
469 cc::SurfaceId e_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
470 cc::SurfaceId c_surface_id = MakeSurfaceId(kDisplayFrameSink, 2); | |
471 cc::SurfaceId a_surface_id = MakeSurfaceId(kDisplayFrameSink, 3); | |
472 cc::SurfaceId b_surface_id = MakeSurfaceId(kDisplayFrameSink, 4); | |
473 | |
474 auto e_hit_test_data = HitTestData::New(); | |
475 e_hit_test_data->surface_id = e_surface_id; | |
476 | |
477 auto e_hit_test_region_c = HitTestRegion::New(); | |
478 e_hit_test_region_c->flags = kHitTestChildSurface; | |
479 e_hit_test_region_c->surface_id = c_surface_id; | |
480 e_hit_test_region_c->rect.SetRect(200, 100, 800, 800); | |
481 e_hit_test_region_c->transform.Translate(200, 100); | |
482 | |
483 auto e_hit_test_region = HitTestRegion::New(); | |
484 e_hit_test_region->flags = kHitTestMine; | |
485 e_hit_test_region->surface_id = e_surface_id; | |
486 e_hit_test_region->rect.SetRect(0, 0, 600, 600); | |
487 | |
488 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_c)); | |
489 e_hit_test_data->regions.push_back(std::move(e_hit_test_region)); | |
490 | |
491 auto c_hit_test_data = HitTestData::New(); | |
492 c_hit_test_data->surface_id = c_surface_id; | |
493 | |
494 auto c_hit_test_region_a = HitTestRegion::New(); | |
495 c_hit_test_region_a->flags = kHitTestChildSurface; | |
496 c_hit_test_region_a->surface_id = a_surface_id; | |
497 c_hit_test_region_a->rect.SetRect(0, 0, 200, 100); | |
498 | |
499 auto c_hit_test_region_b = HitTestRegion::New(); | |
500 c_hit_test_region_b->flags = kHitTestChildSurface; | |
501 c_hit_test_region_b->surface_id = b_surface_id; | |
502 c_hit_test_region_b->rect.SetRect(0, 100, 800, 600); | |
503 | |
504 c_hit_test_data->regions.push_back(std::move(c_hit_test_region_a)); | |
505 c_hit_test_data->regions.push_back(std::move(c_hit_test_region_b)); | |
506 | |
507 auto a_hit_test_data = HitTestData::New(); | |
508 a_hit_test_data->surface_id = a_surface_id; | |
509 | |
510 auto a_hit_test_region = HitTestRegion::New(); | |
511 a_hit_test_region->flags = kHitTestMine; | |
512 a_hit_test_region->surface_id = a_surface_id; | |
513 a_hit_test_region->rect.SetRect(0, 0, 200, 100); | |
514 | |
515 a_hit_test_data->regions.push_back(std::move(a_hit_test_region)); | |
516 | |
517 auto b_hit_test_data = HitTestData::New(); | |
518 b_hit_test_data->surface_id = b_surface_id; | |
519 | |
520 auto b_hit_test_region = HitTestRegion::New(); | |
521 b_hit_test_region->flags = kHitTestMine; | |
522 b_hit_test_region->surface_id = b_surface_id; | |
523 b_hit_test_region->rect.SetRect(0, 0, 800, 600); | |
524 | |
525 b_hit_test_data->regions.push_back(std::move(b_hit_test_region)); | |
526 | |
527 // Submit ( in unexpected order ). | |
528 | |
529 EXPECT_EQ(GetPendingCount(), 0); | |
530 | |
531 aggregator_.SubmitHitTestData(std::move(c_hit_test_data)); | |
532 EXPECT_EQ(GetPendingCount(), 1); | |
533 | |
534 aggregator_.SubmitHitTestData(std::move(a_hit_test_data)); | |
535 EXPECT_EQ(GetPendingCount(), 2); | |
536 | |
537 aggregator_.SubmitHitTestData(std::move(b_hit_test_data)); | |
538 EXPECT_EQ(GetPendingCount(), 3); | |
539 | |
540 aggregator_.SubmitHitTestData(std::move(e_hit_test_data)); | |
541 EXPECT_EQ(GetPendingCount(), 4); | |
542 | |
543 // Surfaces added to DisplayFrame ( in unexpected order ). | |
544 | |
545 EXPECT_EQ(count(), 0); | |
546 | |
547 EXPECT_EQ(GetActiveCount(), 0); | |
548 | |
549 aggregator_.OnSurfaceWillDraw(c_surface_id); | |
550 EXPECT_EQ(GetActiveCount(), 1); | |
551 | |
552 aggregator_.OnSurfaceWillDraw(e_surface_id); | |
553 EXPECT_EQ(GetActiveCount(), 2); | |
554 | |
555 aggregator_.OnSurfaceWillDraw(b_surface_id); | |
556 EXPECT_EQ(GetActiveCount(), 3); | |
557 | |
558 aggregator_.OnSurfaceWillDraw(a_surface_id); | |
559 EXPECT_EQ(GetActiveCount(), 4); | |
560 | |
561 // Aggregate and swap. | |
562 | |
563 aggregator_.Aggregate(e_surface_id); | |
564 EXPECT_EQ(count(), 0); | |
565 | |
566 aggregator_.Swap(); | |
567 | |
568 EXPECT_EQ(count(), 6); | |
569 | |
570 DisplayHitTestRegion* region; | |
571 | |
572 region = RegionAtIndex(0); | |
573 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
574 EXPECT_EQ(region->frame_sink_id, c_surface_id.frame_sink_id()); | |
575 EXPECT_EQ(region->rect, gfx::Rect(200, 100, 800, 800)); | |
576 EXPECT_EQ(region->child_count, 4); | |
577 | |
578 gfx::Point point(300, 300); | |
579 region->transform.TransformPointReverse(&point); | |
580 EXPECT_TRUE(point == gfx::Point(100, 200)); | |
581 | |
582 region = RegionAtIndex(1); | |
583 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
584 EXPECT_EQ(region->frame_sink_id, a_surface_id.frame_sink_id()); | |
585 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 200, 100)); | |
586 EXPECT_EQ(region->child_count, 1); | |
587 | |
588 region = RegionAtIndex(2); | |
589 EXPECT_EQ(region->flags, kHitTestMine); | |
590 EXPECT_EQ(region->frame_sink_id, a_surface_id.frame_sink_id()); | |
591 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 200, 100)); | |
592 EXPECT_EQ(region->child_count, 0); | |
593 | |
594 region = RegionAtIndex(3); | |
595 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
596 EXPECT_EQ(region->frame_sink_id, b_surface_id.frame_sink_id()); | |
597 EXPECT_EQ(region->rect, gfx::Rect(0, 100, 800, 600)); | |
598 EXPECT_EQ(region->child_count, 1); | |
599 | |
600 region = RegionAtIndex(4); | |
601 EXPECT_EQ(region->flags, kHitTestMine); | |
602 EXPECT_EQ(region->frame_sink_id, b_surface_id.frame_sink_id()); | |
603 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 800, 600)); | |
604 EXPECT_EQ(region->child_count, 0); | |
605 | |
606 region = RegionAtIndex(5); | |
607 EXPECT_EQ(region->flags, kHitTestMine); | |
608 EXPECT_EQ(region->frame_sink_id, e_surface_id.frame_sink_id()); | |
609 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 600, 600)); | |
rjkroege
2017/06/15 21:58:45
Non-actionable suggestion for future work: squares
gklassen
2017/06/16 21:49:39
Done. Converted all squares to rects.
| |
610 EXPECT_EQ(region->child_count, 0); | |
611 } | |
612 | |
613 // Three children deep. | |
614 // | |
615 // +e------------+ | |
616 // | +c1-------+ | | |
617 // | | +c2---+ | | | |
618 // | | | +c3-| | | | |
619 // | | | | | | | | |
620 // | | | +---| | | | |
621 // | | +-----+ | | | |
622 // | +---------+ | | |
623 // +-------------+ | |
624 // | |
625 | |
626 TEST_F(HitTestAggregatorTest, ThreeChildrenDeep) { | |
627 Reset(); | |
628 EXPECT_EQ(count(), 0); | |
629 | |
630 cc::SurfaceId e_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
631 cc::SurfaceId c1_surface_id = MakeSurfaceId(kDisplayFrameSink, 2); | |
632 cc::SurfaceId c2_surface_id = MakeSurfaceId(kDisplayFrameSink, 3); | |
633 cc::SurfaceId c3_surface_id = MakeSurfaceId(kDisplayFrameSink, 4); | |
634 | |
635 auto e_hit_test_data = HitTestData::New(); | |
636 e_hit_test_data->surface_id = e_surface_id; | |
637 | |
638 auto e_hit_test_region_c1 = HitTestRegion::New(); | |
639 e_hit_test_region_c1->flags = kHitTestChildSurface; | |
640 e_hit_test_region_c1->surface_id = c1_surface_id; | |
641 e_hit_test_region_c1->rect.SetRect(100, 100, 700, 700); | |
642 | |
643 auto e_hit_test_region = HitTestRegion::New(); | |
644 e_hit_test_region->flags = kHitTestMine; | |
645 e_hit_test_region->surface_id = e_surface_id; | |
646 e_hit_test_region->rect.SetRect(0, 0, 800, 800); | |
647 | |
648 e_hit_test_data->regions.push_back(std::move(e_hit_test_region_c1)); | |
649 e_hit_test_data->regions.push_back(std::move(e_hit_test_region)); | |
650 | |
651 auto c1_hit_test_data = HitTestData::New(); | |
652 c1_hit_test_data->surface_id = c1_surface_id; | |
653 | |
654 auto c1_hit_test_region_c2 = HitTestRegion::New(); | |
655 c1_hit_test_region_c2->flags = kHitTestChildSurface; | |
656 c1_hit_test_region_c2->surface_id = c2_surface_id; | |
657 c1_hit_test_region_c2->rect.SetRect(100, 100, 500, 500); | |
658 | |
659 auto c1_hit_test_region = HitTestRegion::New(); | |
660 c1_hit_test_region->flags = kHitTestMine; | |
661 c1_hit_test_region->surface_id = c1_surface_id; | |
662 c1_hit_test_region->rect.SetRect(0, 0, 600, 600); | |
663 | |
664 c1_hit_test_data->regions.push_back(std::move(c1_hit_test_region_c2)); | |
665 c1_hit_test_data->regions.push_back(std::move(c1_hit_test_region)); | |
666 | |
667 auto c2_hit_test_data = HitTestData::New(); | |
668 c2_hit_test_data->surface_id = c2_surface_id; | |
669 | |
670 auto c2_hit_test_region_c3 = HitTestRegion::New(); | |
671 c2_hit_test_region_c3->flags = kHitTestChildSurface; | |
672 c2_hit_test_region_c3->surface_id = c3_surface_id; | |
673 c2_hit_test_region_c3->rect.SetRect(100, 100, 300, 300); | |
674 | |
675 auto c2_hit_test_region = HitTestRegion::New(); | |
676 c2_hit_test_region->flags = kHitTestMine; | |
677 c2_hit_test_region->surface_id = c2_surface_id; | |
678 c2_hit_test_region->rect.SetRect(0, 0, 400, 400); | |
679 | |
680 c2_hit_test_data->regions.push_back(std::move(c2_hit_test_region_c3)); | |
681 c2_hit_test_data->regions.push_back(std::move(c2_hit_test_region)); | |
682 | |
683 auto c3_hit_test_data = HitTestData::New(); | |
684 c3_hit_test_data->surface_id = c3_surface_id; | |
685 | |
686 auto c3_hit_test_region = HitTestRegion::New(); | |
687 c3_hit_test_region->flags = kHitTestMine; | |
688 c3_hit_test_region->surface_id = c3_surface_id; | |
689 c3_hit_test_region->rect.SetRect(0, 0, 200, 200); | |
690 | |
691 c3_hit_test_data->regions.push_back(std::move(c3_hit_test_region)); | |
692 | |
693 // Submit ( in unexpected order ). | |
694 | |
695 EXPECT_EQ(GetPendingCount(), 0); | |
696 | |
697 aggregator_.SubmitHitTestData(std::move(c1_hit_test_data)); | |
698 EXPECT_EQ(GetPendingCount(), 1); | |
699 | |
700 aggregator_.SubmitHitTestData(std::move(c3_hit_test_data)); | |
701 EXPECT_EQ(GetPendingCount(), 2); | |
702 | |
703 aggregator_.SubmitHitTestData(std::move(e_hit_test_data)); | |
704 EXPECT_EQ(GetPendingCount(), 3); | |
705 | |
706 aggregator_.SubmitHitTestData(std::move(c2_hit_test_data)); | |
707 EXPECT_EQ(GetPendingCount(), 4); | |
708 | |
709 // Surfaces added to DisplayFrame ( in unexpected order ). | |
710 | |
711 EXPECT_EQ(count(), 0); | |
712 | |
713 EXPECT_EQ(GetActiveCount(), 0); | |
714 | |
715 aggregator_.OnSurfaceWillDraw(c2_surface_id); | |
716 EXPECT_EQ(GetActiveCount(), 1); | |
717 | |
718 aggregator_.OnSurfaceWillDraw(c1_surface_id); | |
719 EXPECT_EQ(GetActiveCount(), 2); | |
720 | |
721 aggregator_.OnSurfaceWillDraw(e_surface_id); | |
722 EXPECT_EQ(GetActiveCount(), 3); | |
723 | |
724 aggregator_.OnSurfaceWillDraw(c3_surface_id); | |
725 EXPECT_EQ(GetActiveCount(), 4); | |
726 | |
727 // Aggregate and swap. | |
728 | |
729 aggregator_.Aggregate(e_surface_id); | |
730 EXPECT_EQ(count(), 0); | |
731 | |
732 aggregator_.Swap(); | |
733 | |
734 EXPECT_EQ(count(), 7); | |
735 | |
736 DisplayHitTestRegion* region; | |
737 | |
738 region = RegionAtIndex(0); | |
739 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
740 EXPECT_EQ(region->frame_sink_id, c1_surface_id.frame_sink_id()); | |
741 EXPECT_EQ(region->rect, gfx::Rect(100, 100, 700, 700)); | |
742 EXPECT_EQ(region->child_count, 5); | |
743 | |
744 region = RegionAtIndex(1); | |
745 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
746 EXPECT_EQ(region->frame_sink_id, c2_surface_id.frame_sink_id()); | |
747 EXPECT_EQ(region->rect, gfx::Rect(100, 100, 500, 500)); | |
748 EXPECT_EQ(region->child_count, 3); | |
749 | |
750 region = RegionAtIndex(2); | |
751 EXPECT_EQ(region->flags, kHitTestChildSurface); | |
752 EXPECT_EQ(region->frame_sink_id, c3_surface_id.frame_sink_id()); | |
753 EXPECT_EQ(region->rect, gfx::Rect(100, 100, 300, 300)); | |
754 EXPECT_EQ(region->child_count, 1); | |
755 | |
756 region = RegionAtIndex(3); | |
757 EXPECT_EQ(region->flags, kHitTestMine); | |
758 EXPECT_EQ(region->frame_sink_id, c3_surface_id.frame_sink_id()); | |
759 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 200, 200)); | |
760 EXPECT_EQ(region->child_count, 0); | |
761 | |
762 region = RegionAtIndex(4); | |
763 EXPECT_EQ(region->flags, kHitTestMine); | |
764 EXPECT_EQ(region->frame_sink_id, c2_surface_id.frame_sink_id()); | |
765 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 400, 400)); | |
766 EXPECT_EQ(region->child_count, 0); | |
767 | |
768 region = RegionAtIndex(5); | |
769 EXPECT_EQ(region->flags, kHitTestMine); | |
770 EXPECT_EQ(region->frame_sink_id, c1_surface_id.frame_sink_id()); | |
771 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 600, 600)); | |
772 EXPECT_EQ(region->child_count, 0); | |
773 | |
774 region = RegionAtIndex(6); | |
775 EXPECT_EQ(region->flags, kHitTestMine); | |
776 EXPECT_EQ(region->frame_sink_id, e_surface_id.frame_sink_id()); | |
777 EXPECT_EQ(region->rect, gfx::Rect(0, 0, 800, 800)); | |
778 EXPECT_EQ(region->child_count, 0); | |
779 } | |
780 | |
781 // Exceed limits to ensure that bounds and resize work. | |
782 // | |
783 // A tree of embedders each with 8 children and 4 levels deep = 4096 regions. | |
784 // This will exceed initial allocation and force a resize. | |
785 // | |
786 // +e--------------------------------------------------------+ | |
787 // | +c1----------++c2----------++c3----------++c4----------+| | |
788 // | | +c1--------|| +c1--------|| +c1--------|| +c1--------|| | |
789 // | | | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | |
790 // | | | | || || | | || || | | || || | | || || | |
791 // | | | +---++---|| | +---++---|| | +---++---|| | +---++---|| | |
792 // | +------------++------------++------------++------------+| | |
793 // | +c5----------++c6----------++c7----------++c8----------+| | |
794 // | | +c1--------|| +c1--------|| +c1--------|| +c1--------|| | |
795 // | | | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | |
796 // | | | | || || | | || || | | || || | | || || | |
797 // | | | +---++---|| | +---++---|| | +---++---|| | +---++---|| | |
798 // | +------------++------------++------------++------------+| | |
799 // +---------------------------------------------------------+ | |
800 // | |
801 | |
802 TEST_F(HitTestAggregatorTest, ExceedLimits) { | |
803 Reset(); | |
804 EXPECT_EQ(count(), 0); | |
805 | |
806 EXPECT_LT(GetDisplayHitTestDataLength(), 4096); | |
807 | |
808 cc::SurfaceId display_surface_id = MakeSurfaceId(kDisplayFrameSink, 1); | |
809 | |
810 int next_surface_id = CreateAndSubmitHitTestDataWith8Children(1, 3); | |
811 int surface_count = next_surface_id - 1; | |
812 | |
813 int region_count = GetPendingRegionCount(); | |
814 | |
815 // Expect 4680 regions: | |
816 // 8 children 4 levels deep 8*8*8*8 is 4096 | |
817 // 1 region for each embedder/surface + 584 | |
818 // ----- | |
819 // 4680. | |
820 EXPECT_EQ(region_count, 4680); | |
821 | |
822 EXPECT_EQ(GetPendingCount(), surface_count); | |
823 | |
824 // Mark Surfaces as added to DisplayFrame ( in unexpected order ). | |
825 | |
826 EXPECT_EQ(count(), 0); | |
827 EXPECT_EQ(GetActiveCount(), 0); | |
828 | |
829 for (int i = 1; i <= surface_count; i++) { | |
830 cc::SurfaceId surface_id = MakeSurfaceId(kDisplayFrameSink, i); | |
831 aggregator_.OnSurfaceWillDraw(surface_id); | |
832 } | |
833 | |
834 EXPECT_EQ(GetActiveCount(), surface_count); | |
835 | |
836 // Aggregate and swap. | |
837 | |
838 aggregator_.Aggregate(display_surface_id); | |
839 EXPECT_EQ(count(), 0); | |
840 | |
841 aggregator_.Swap(); | |
842 | |
843 EXPECT_EQ(count(), region_count); | |
844 | |
845 EXPECT_GE(GetDisplayHitTestDataLength(), region_count); | |
846 } | |
847 | |
848 } // namespace test | |
849 } // namespace hit_test | |
850 } // namespace viz | |
OLD | NEW |