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 "components/viz/service/hit_test/hit_test_aggregator.h"
6
7 #include <map>
8 #include <memory>
9
10 #include "components/viz/common/hit_test/hit_test_region_list.h"
11 #include "components/viz/common/surfaces/frame_sink_id.h"
12 #include "components/viz/common/surfaces/surface_id.h"
13 #include "components/viz/host/host_frame_sink_manager.h"
14 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
15 #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
16 #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
17 #include "components/viz/service/hit_test/hit_test_aggregator_delegate.h"
18 #include "components/viz/service/surfaces/surface_manager.h"
19 #include "components/viz/test/compositor_frame_helpers.h"
20 #include "components/viz/test/surface_id_allocator_set.h"
21 #include "components/viz/test/test_latest_local_surface_id_lookup_delegate.h"
22 #include "testing/gtest/include/gtest/gtest.h"
23
24 namespace viz {
25 namespace {
26
27 constexpr uint32_t kDisplayClientId = 2;
28 constexpr FrameSinkId kDisplayFrameSink(kDisplayClientId, 0);
29
30 class TestHostFrameSinkManager : public HostFrameSinkManager {
31 public:
32 TestHostFrameSinkManager() = default;
33 ~TestHostFrameSinkManager() override = default;
34
OnAggregatedHitTestRegionListUpdated(const FrameSinkId & frame_sink_id,const std::vector<AggregatedHitTestRegion> & hit_test_data)35 void OnAggregatedHitTestRegionListUpdated(
36 const FrameSinkId& frame_sink_id,
37 const std::vector<AggregatedHitTestRegion>& hit_test_data) override {
38 buffer_frame_sink_id_ = frame_sink_id;
39 active_list_ = hit_test_data;
40 }
41
regions()42 const std::vector<AggregatedHitTestRegion>& regions() { return active_list_; }
43
buffer_frame_sink_id()44 const FrameSinkId& buffer_frame_sink_id() { return buffer_frame_sink_id_; }
45
46 private:
47 FrameSinkId buffer_frame_sink_id_;
48 std::vector<AggregatedHitTestRegion> active_list_;
49
50 DISALLOW_COPY_AND_ASSIGN(TestHostFrameSinkManager);
51 };
52
53 class TestFrameSinkManagerImpl : public FrameSinkManagerImpl {
54 public:
TestFrameSinkManagerImpl(SharedBitmapManager * shared_bitmap_manager)55 explicit TestFrameSinkManagerImpl(SharedBitmapManager* shared_bitmap_manager)
56 : FrameSinkManagerImpl(shared_bitmap_manager) {}
57 ~TestFrameSinkManagerImpl() override = default;
58
SetLocalClient(TestHostFrameSinkManager * client)59 void SetLocalClient(TestHostFrameSinkManager* client) {
60 host_client_ = client;
61 }
62
OnAggregatedHitTestRegionListUpdated(const FrameSinkId & frame_sink_id,const std::vector<AggregatedHitTestRegion> & hit_test_data)63 void OnAggregatedHitTestRegionListUpdated(
64 const FrameSinkId& frame_sink_id,
65 const std::vector<AggregatedHitTestRegion>& hit_test_data) override {
66 // Do not check if it's on valid thread for tests.
67 if (host_client_) {
68 host_client_->OnAggregatedHitTestRegionListUpdated(frame_sink_id,
69 hit_test_data);
70 }
71 }
72
73 private:
74 TestHostFrameSinkManager* host_client_ = nullptr;
75
76 DISALLOW_COPY_AND_ASSIGN(TestFrameSinkManagerImpl);
77 };
78
79 } // namespace
80
81 class TestHitTestAggregator final : public HitTestAggregator {
82 public:
TestHitTestAggregator(const HitTestManager * manager,HitTestAggregatorDelegate * delegate,LatestLocalSurfaceIdLookupDelegate * local_surface_id_lookup_delegate,const FrameSinkId & frame_sink_id)83 TestHitTestAggregator(
84 const HitTestManager* manager,
85 HitTestAggregatorDelegate* delegate,
86 LatestLocalSurfaceIdLookupDelegate* local_surface_id_lookup_delegate,
87 const FrameSinkId& frame_sink_id)
88 : HitTestAggregator(manager,
89 delegate,
90 local_surface_id_lookup_delegate,
91 frame_sink_id),
92 frame_sink_id_(frame_sink_id) {}
93 ~TestHitTestAggregator() = default;
94
GetRegionCount() const95 int GetRegionCount() const { return hit_test_data_size_; }
GetHitTestRegionListCapacity()96 int GetHitTestRegionListCapacity() { return hit_test_data_capacity_; }
GetLastSubmitHitTestRegionListIndex() const97 uint64_t GetLastSubmitHitTestRegionListIndex() const {
98 return last_submit_hit_test_region_list_index_;
99 }
100
101 private:
102 const FrameSinkId frame_sink_id_;
103 };
104
105 class HitTestAggregatorTest : public testing::Test {
106 public:
107 HitTestAggregatorTest() = default;
108 ~HitTestAggregatorTest() override = default;
109
110 // testing::Test:
SetUp()111 void SetUp() override {
112 frame_sink_manager_ =
113 std::make_unique<TestFrameSinkManagerImpl>(&shared_bitmap_manager_);
114 host_frame_sink_manager_ = std::make_unique<TestHostFrameSinkManager>();
115 local_surface_id_lookup_delegate_ =
116 std::make_unique<TestLatestLocalSurfaceIdLookupDelegate>();
117 frame_sink_manager_->SetLocalClient(host_frame_sink_manager_.get());
118 support_ = std::make_unique<CompositorFrameSinkSupport>(
119 nullptr /* client */, frame_sink_manager_.get(), kDisplayFrameSink,
120 true /* is_root */);
121 hit_test_aggregator_ = std::make_unique<TestHitTestAggregator>(
122 hit_test_manager(), frame_sink_manager(),
123 local_surface_id_lookup_delegate(), kDisplayFrameSink);
124 }
TearDown()125 void TearDown() override {
126 support_.reset();
127 frame_sink_manager_.reset();
128 host_frame_sink_manager_.reset();
129 }
130
ExpireAllTemporaryReferencesAndGarbageCollect()131 void ExpireAllTemporaryReferencesAndGarbageCollect() {
132 frame_sink_manager_->surface_manager()->ExpireOldTemporaryReferences();
133 frame_sink_manager_->surface_manager()->ExpireOldTemporaryReferences();
134 frame_sink_manager_->surface_manager()->GarbageCollectSurfaces();
135 }
136
137 // Creates a hit test data element with 8 children recursively to
138 // the specified depth. SurfaceIds are generated in sequential order and
139 // the method returns the next unused id.
CreateAndSubmitHitTestRegionListWith8Children(uint32_t client_id,int depth)140 int CreateAndSubmitHitTestRegionListWith8Children(uint32_t client_id,
141 int depth) {
142 SurfaceId surface_id = MakeSurfaceId(client_id);
143 client_id++;
144
145 HitTestRegionList hit_test_region_list;
146 hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
147 hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
148
149 for (int i = 0; i < 8; i++) {
150 HitTestRegion hit_test_region;
151 hit_test_region.rect.SetRect(100, 100, 100, 100);
152 SurfaceId child_surface_id = MakeSurfaceId(client_id);
153 hit_test_region.frame_sink_id = child_surface_id.frame_sink_id();
154
155 if (depth > 0) {
156 hit_test_region.flags = HitTestRegionFlags::kHitTestChildSurface;
157 client_id =
158 CreateAndSubmitHitTestRegionListWith8Children(client_id, depth - 1);
159 } else {
160 hit_test_region.flags = HitTestRegionFlags::kHitTestMine;
161 }
162 hit_test_region_list.regions.push_back(std::move(hit_test_region));
163 }
164
165 if (surface_id.frame_sink_id() == kDisplayFrameSink) {
166 support()->SubmitCompositorFrame(surface_id.local_surface_id(),
167 MakeDefaultCompositorFrame(),
168 std::move(hit_test_region_list));
169 local_surface_id_lookup_delegate()->SetSurfaceIdMap(surface_id);
170 } else {
171 auto support = std::make_unique<CompositorFrameSinkSupport>(
172 nullptr, frame_sink_manager(), surface_id.frame_sink_id(),
173 false /* is_root */);
174 support->SubmitCompositorFrame(surface_id.local_surface_id(),
175 MakeDefaultCompositorFrame(),
176 std::move(hit_test_region_list));
177 local_surface_id_lookup_delegate()->SetSurfaceIdMap(surface_id);
178 }
179 return client_id;
180 }
181
MakeSurfaceId(uint32_t frame_sink_id_client_id)182 SurfaceId MakeSurfaceId(uint32_t frame_sink_id_client_id) {
183 return allocator_set_.MakeSurfaceId(FrameSinkId(frame_sink_id_client_id, 0),
184 1);
185 }
186
187 protected:
hit_test_aggregator()188 TestHitTestAggregator* hit_test_aggregator() {
189 return hit_test_aggregator_.get();
190 }
191
host_regions()192 const std::vector<AggregatedHitTestRegion>& host_regions() {
193 return host_frame_sink_manager_->regions();
194 }
195
host_buffer_frame_sink_id()196 const FrameSinkId& host_buffer_frame_sink_id() {
197 return host_frame_sink_manager_->buffer_frame_sink_id();
198 }
199
hit_test_manager() const200 const HitTestManager* hit_test_manager() const {
201 return frame_sink_manager_->hit_test_manager();
202 }
203
support() const204 CompositorFrameSinkSupport* support() const { return support_.get(); }
205
frame_sink_manager() const206 FrameSinkManagerImpl* frame_sink_manager() const {
207 return frame_sink_manager_.get();
208 }
209
surface_manager() const210 SurfaceManager* surface_manager() const {
211 return frame_sink_manager_->surface_manager();
212 }
213
local_surface_id_lookup_delegate() const214 TestLatestLocalSurfaceIdLookupDelegate* local_surface_id_lookup_delegate()
215 const {
216 return local_surface_id_lookup_delegate_.get();
217 }
218
219 private:
220 ServerSharedBitmapManager shared_bitmap_manager_;
221 std::unique_ptr<TestHitTestAggregator> hit_test_aggregator_;
222 std::unique_ptr<TestFrameSinkManagerImpl> frame_sink_manager_;
223 std::unique_ptr<TestHostFrameSinkManager> host_frame_sink_manager_;
224 std::unique_ptr<TestLatestLocalSurfaceIdLookupDelegate>
225 local_surface_id_lookup_delegate_;
226 std::unique_ptr<CompositorFrameSinkSupport> support_;
227 SurfaceIdAllocatorSet allocator_set_;
228
229 DISALLOW_COPY_AND_ASSIGN(HitTestAggregatorTest);
230 };
231
232 // TODO(gklassen): Add tests for 3D use cases as suggested by and with
233 // input from rjkroege.
234
235 // One surface.
236 //
237 // +----------+
238 // | |
239 // | |
240 // | |
241 // +----------+
242 //
TEST_F(HitTestAggregatorTest,OneSurface)243 TEST_F(HitTestAggregatorTest, OneSurface) {
244 TestHitTestAggregator* aggregator = hit_test_aggregator();
245 EXPECT_EQ(aggregator->GetRegionCount(), 0);
246
247 SurfaceId display_surface_id = MakeSurfaceId(kDisplayClientId);
248
249 HitTestRegionList hit_test_region_list;
250 hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
251 hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
252
253 support()->SubmitCompositorFrame(display_surface_id.local_surface_id(),
254 MakeDefaultCompositorFrame(),
255 std::move(hit_test_region_list));
256 local_surface_id_lookup_delegate()->SetSurfaceIdMap(display_surface_id);
257 aggregator->Aggregate(display_surface_id);
258
259 // Expect 1 entry routing all events to the one surface (display root).
260 EXPECT_EQ(aggregator->GetRegionCount(), 1);
261
262 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
263
264 AggregatedHitTestRegion region = host_regions()[0];
265 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
266 EXPECT_EQ(region.frame_sink_id, display_surface_id.frame_sink_id());
267 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
268 EXPECT_EQ(region.child_count, 0);
269 }
270
271 // One opaque embedder with two regions.
272 //
273 // +e-------------+
274 // | +r1-+ +r2--+ |
275 // | | | | | |
276 // | | | | | |
277 // | +---+ +----+ |
278 // +--------------+
279 //
TEST_F(HitTestAggregatorTest,OneEmbedderTwoRegions)280 TEST_F(HitTestAggregatorTest, OneEmbedderTwoRegions) {
281 TestHitTestAggregator* aggregator = hit_test_aggregator();
282 EXPECT_EQ(aggregator->GetRegionCount(), 0);
283
284 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
285
286 HitTestRegionList e_hit_test_region_list;
287 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
288 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
289
290 HitTestRegion e_hit_test_region_r1;
291 e_hit_test_region_r1.frame_sink_id = e_surface_id.frame_sink_id();
292 e_hit_test_region_r1.flags = HitTestRegionFlags::kHitTestMine;
293 e_hit_test_region_r1.rect.SetRect(100, 100, 200, 400);
294
295 HitTestRegion e_hit_test_region_r2;
296 e_hit_test_region_r2.frame_sink_id = e_surface_id.frame_sink_id();
297 e_hit_test_region_r2.flags = HitTestRegionFlags::kHitTestMine;
298 e_hit_test_region_r2.rect.SetRect(400, 100, 300, 400);
299
300 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_r1));
301 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_r2));
302
303 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
304 MakeDefaultCompositorFrame(),
305 std::move(e_hit_test_region_list));
306 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
307
308 aggregator->Aggregate(e_surface_id);
309
310 EXPECT_EQ(aggregator->GetRegionCount(), 3);
311
312 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
313
314 AggregatedHitTestRegion region = host_regions()[0];
315 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
316 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
317 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
318 EXPECT_EQ(region.child_count, 2);
319
320 region = host_regions()[1];
321 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
322 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 200, 400));
323 EXPECT_EQ(region.child_count, 0);
324
325 region = host_regions()[2];
326 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
327 EXPECT_EQ(region.rect, gfx::Rect(400, 100, 300, 400));
328 EXPECT_EQ(region.child_count, 0);
329 }
330
331 // One embedder with two children.
332 //
333 // +e-------------+
334 // | +c1-+ +c2--+ |
335 // | | | | | |
336 // | | | | | |
337 // | +---+ +----+ |
338 // +--------------+
339 //
340
TEST_F(HitTestAggregatorTest,OneEmbedderTwoChildren)341 TEST_F(HitTestAggregatorTest, OneEmbedderTwoChildren) {
342 TestHitTestAggregator* aggregator = hit_test_aggregator();
343 EXPECT_EQ(aggregator->GetRegionCount(), 0);
344
345 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
346 SurfaceId c1_surface_id = MakeSurfaceId(kDisplayClientId + 1);
347 SurfaceId c2_surface_id = MakeSurfaceId(kDisplayClientId + 2);
348
349 HitTestRegionList e_hit_test_region_list;
350 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
351 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
352
353 HitTestRegion e_hit_test_region_c1;
354 e_hit_test_region_c1.flags = HitTestRegionFlags::kHitTestChildSurface;
355 e_hit_test_region_c1.frame_sink_id = c1_surface_id.frame_sink_id();
356 e_hit_test_region_c1.rect.SetRect(100, 100, 200, 300);
357
358 HitTestRegion e_hit_test_region_c2;
359 e_hit_test_region_c2.flags = HitTestRegionFlags::kHitTestChildSurface;
360 e_hit_test_region_c2.frame_sink_id = c2_surface_id.frame_sink_id();
361 e_hit_test_region_c2.rect.SetRect(400, 100, 400, 300);
362
363 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c1));
364 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c2));
365
366 HitTestRegionList c1_hit_test_region_list;
367
368 HitTestRegionList c2_hit_test_region_list;
369
370 // Submit in unexpected order.
371
372 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
373 nullptr, frame_sink_manager(), c1_surface_id.frame_sink_id(),
374 false /* is_root */);
375 support2->SubmitCompositorFrame(c1_surface_id.local_surface_id(),
376 MakeDefaultCompositorFrame(),
377 std::move(c1_hit_test_region_list));
378 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c1_surface_id);
379 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
380 MakeDefaultCompositorFrame(),
381 std::move(e_hit_test_region_list));
382 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
383 auto support3 = std::make_unique<CompositorFrameSinkSupport>(
384 nullptr, frame_sink_manager(), c2_surface_id.frame_sink_id(),
385 false /* is_root */);
386 support3->SubmitCompositorFrame(c2_surface_id.local_surface_id(),
387 MakeDefaultCompositorFrame(),
388 std::move(c2_hit_test_region_list));
389 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c2_surface_id);
390
391 aggregator->Aggregate(e_surface_id);
392
393 EXPECT_EQ(aggregator->GetRegionCount(), 3);
394
395 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
396
397 AggregatedHitTestRegion region = host_regions()[0];
398 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
399 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
400 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
401 EXPECT_EQ(region.child_count, 2);
402
403 region = host_regions()[1];
404 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestChildSurface);
405 EXPECT_EQ(region.frame_sink_id, c1_surface_id.frame_sink_id());
406 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 200, 300));
407 EXPECT_EQ(region.child_count, 0);
408
409 region = host_regions()[2];
410 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestChildSurface);
411 EXPECT_EQ(region.frame_sink_id, c2_surface_id.frame_sink_id());
412 EXPECT_EQ(region.rect, gfx::Rect(400, 100, 400, 300));
413 EXPECT_EQ(region.child_count, 0);
414 }
415
416 // Occluded child frame (OOPIF).
417 //
418 // +e-----------+
419 // | +c--+ |
420 // | | +div-+ |
421 // | | | | |
422 // | | +----+ |
423 // | +---+ |
424 // +------------+
425 //
426
TEST_F(HitTestAggregatorTest,OccludedChildFrame)427 TEST_F(HitTestAggregatorTest, OccludedChildFrame) {
428 TestHitTestAggregator* aggregator = hit_test_aggregator();
429 EXPECT_EQ(aggregator->GetRegionCount(), 0);
430
431 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
432 SurfaceId c_surface_id = MakeSurfaceId(kDisplayClientId + 1);
433
434 HitTestRegionList e_hit_test_region_list;
435 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
436 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
437
438 HitTestRegion e_hit_test_region_div;
439 e_hit_test_region_div.flags = HitTestRegionFlags::kHitTestMine;
440 e_hit_test_region_div.frame_sink_id = e_surface_id.frame_sink_id();
441 e_hit_test_region_div.rect.SetRect(200, 200, 300, 200);
442
443 HitTestRegion e_hit_test_region_c;
444 e_hit_test_region_c.flags = HitTestRegionFlags::kHitTestChildSurface;
445 e_hit_test_region_c.frame_sink_id = c_surface_id.frame_sink_id();
446 e_hit_test_region_c.rect.SetRect(100, 100, 200, 500);
447
448 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_div));
449 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c));
450
451 HitTestRegionList c_hit_test_region_list;
452 c_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
453 c_hit_test_region_list.bounds.SetRect(0, 0, 200, 500);
454
455 // Submit in unexpected order.
456 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
457 nullptr, frame_sink_manager(), c_surface_id.frame_sink_id(),
458 false /* is_root */);
459 support2->SubmitCompositorFrame(c_surface_id.local_surface_id(),
460 MakeDefaultCompositorFrame(),
461 std::move(c_hit_test_region_list));
462 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c_surface_id);
463 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
464 MakeDefaultCompositorFrame(),
465 std::move(e_hit_test_region_list));
466 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
467
468 aggregator->Aggregate(e_surface_id);
469
470 EXPECT_EQ(aggregator->GetRegionCount(), 3);
471
472 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
473
474 AggregatedHitTestRegion region = host_regions()[0];
475 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
476 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
477 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
478 EXPECT_EQ(region.child_count, 2);
479
480 region = host_regions()[1];
481 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
482 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
483 EXPECT_EQ(region.rect, gfx::Rect(200, 200, 300, 200));
484 EXPECT_EQ(region.child_count, 0);
485
486 region = host_regions()[2];
487 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
488 HitTestRegionFlags::kHitTestMine,
489 region.flags);
490 EXPECT_EQ(region.frame_sink_id, c_surface_id.frame_sink_id());
491 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 200, 500));
492 EXPECT_EQ(region.child_count, 0);
493 }
494
495 // Foreground child frame (OOPIF).
496 // Same as the previous test except the child is foreground.
497 //
498 // +e-----------+
499 // | +c--+ |
500 // | | |div-+ |
501 // | | | | |
502 // | | |----+ |
503 // | +---+ |
504 // +------------+
505 //
506
TEST_F(HitTestAggregatorTest,ForegroundChildFrame)507 TEST_F(HitTestAggregatorTest, ForegroundChildFrame) {
508 TestHitTestAggregator* aggregator = hit_test_aggregator();
509 EXPECT_EQ(aggregator->GetRegionCount(), 0);
510
511 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
512 SurfaceId c_surface_id = MakeSurfaceId(kDisplayClientId + 1);
513
514 HitTestRegionList e_hit_test_region_list;
515 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
516 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
517
518 HitTestRegion e_hit_test_region_div;
519 e_hit_test_region_div.flags = HitTestRegionFlags::kHitTestMine;
520 e_hit_test_region_div.frame_sink_id = e_surface_id.frame_sink_id();
521 e_hit_test_region_div.rect.SetRect(200, 200, 300, 200);
522
523 HitTestRegion e_hit_test_region_c;
524 e_hit_test_region_c.flags = HitTestRegionFlags::kHitTestChildSurface;
525 e_hit_test_region_c.frame_sink_id = c_surface_id.frame_sink_id();
526 e_hit_test_region_c.rect.SetRect(100, 100, 200, 500);
527
528 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c));
529 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_div));
530
531 HitTestRegionList c_hit_test_region_list;
532 c_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
533 c_hit_test_region_list.bounds.SetRect(0, 0, 200, 500);
534
535 // Submit in unexpected order.
536
537 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
538 nullptr, frame_sink_manager(), c_surface_id.frame_sink_id(),
539 false /* is_root */);
540 support2->SubmitCompositorFrame(c_surface_id.local_surface_id(),
541 MakeDefaultCompositorFrame(),
542 std::move(c_hit_test_region_list));
543 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c_surface_id);
544 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
545 MakeDefaultCompositorFrame(),
546 std::move(e_hit_test_region_list));
547 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
548
549 aggregator->Aggregate(e_surface_id);
550
551 EXPECT_EQ(aggregator->GetRegionCount(), 3);
552
553 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
554
555 AggregatedHitTestRegion region = host_regions()[0];
556 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
557 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
558 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
559 EXPECT_EQ(region.child_count, 2);
560
561 region = host_regions()[1];
562 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
563 HitTestRegionFlags::kHitTestMine,
564 region.flags);
565 EXPECT_EQ(region.frame_sink_id, c_surface_id.frame_sink_id());
566 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 200, 500));
567 EXPECT_EQ(region.child_count, 0);
568
569 region = host_regions()[2];
570 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
571 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
572 EXPECT_EQ(region.rect, gfx::Rect(200, 200, 300, 200));
573 EXPECT_EQ(region.child_count, 0);
574 }
575
576 // One embedder with a clipped child with a tab and transparent background.
577 //
578 // +e-------------+
579 // | +c---------| Point maps to
580 // | 1 |+a--+ | ----- -------
581 // | || 2 | 3 | 1 e
582 // | |+b--------| 2 a
583 // | || | 3 e (transparent area in c)
584 // | || 4 | 4 b
585 // +--------------+
586 //
587
TEST_F(HitTestAggregatorTest,ClippedChildWithTabAndTransparentBackground)588 TEST_F(HitTestAggregatorTest, ClippedChildWithTabAndTransparentBackground) {
589 TestHitTestAggregator* aggregator = hit_test_aggregator();
590 EXPECT_EQ(aggregator->GetRegionCount(), 0);
591
592 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
593 SurfaceId c_surface_id = MakeSurfaceId(kDisplayClientId + 1);
594 SurfaceId a_surface_id = MakeSurfaceId(kDisplayClientId + 2);
595 SurfaceId b_surface_id = MakeSurfaceId(kDisplayClientId + 3);
596
597 HitTestRegionList e_hit_test_region_list;
598 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
599 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
600
601 HitTestRegion e_hit_test_region_c;
602 e_hit_test_region_c.flags = HitTestRegionFlags::kHitTestChildSurface;
603 e_hit_test_region_c.frame_sink_id = c_surface_id.frame_sink_id();
604 e_hit_test_region_c.rect.SetRect(300, 100, 1600, 800);
605 e_hit_test_region_c.transform.Translate(200, 100);
606
607 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c));
608
609 HitTestRegionList c_hit_test_region_list;
610 c_hit_test_region_list.flags = HitTestRegionFlags::kHitTestIgnore;
611 c_hit_test_region_list.bounds.SetRect(0, 0, 1600, 800);
612
613 HitTestRegion c_hit_test_region_a;
614 c_hit_test_region_a.flags = HitTestRegionFlags::kHitTestChildSurface;
615 c_hit_test_region_a.frame_sink_id = a_surface_id.frame_sink_id();
616 c_hit_test_region_a.rect.SetRect(0, 0, 200, 100);
617
618 HitTestRegion c_hit_test_region_b;
619 c_hit_test_region_b.flags = HitTestRegionFlags::kHitTestChildSurface;
620 c_hit_test_region_b.frame_sink_id = b_surface_id.frame_sink_id();
621 c_hit_test_region_b.rect.SetRect(0, 100, 800, 600);
622
623 c_hit_test_region_list.regions.push_back(std::move(c_hit_test_region_a));
624 c_hit_test_region_list.regions.push_back(std::move(c_hit_test_region_b));
625
626 HitTestRegionList a_hit_test_region_list;
627 a_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
628 a_hit_test_region_list.bounds.SetRect(0, 0, 200, 100);
629
630 HitTestRegionList b_hit_test_region_list;
631 b_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
632 b_hit_test_region_list.bounds.SetRect(0, 100, 800, 600);
633
634 // Submit in unexpected order.
635
636 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
637 nullptr, frame_sink_manager(), c_surface_id.frame_sink_id(),
638 false /* is_root */);
639 support2->SubmitCompositorFrame(c_surface_id.local_surface_id(),
640 MakeDefaultCompositorFrame(),
641 std::move(c_hit_test_region_list));
642 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c_surface_id);
643 auto support3 = std::make_unique<CompositorFrameSinkSupport>(
644 nullptr, frame_sink_manager(), a_surface_id.frame_sink_id(),
645 false /* is_root */);
646 support3->SubmitCompositorFrame(a_surface_id.local_surface_id(),
647 MakeDefaultCompositorFrame(),
648 std::move(a_hit_test_region_list));
649 local_surface_id_lookup_delegate()->SetSurfaceIdMap(a_surface_id);
650 auto support4 = std::make_unique<CompositorFrameSinkSupport>(
651 nullptr, frame_sink_manager(), b_surface_id.frame_sink_id(),
652 false /* is_root */);
653 support4->SubmitCompositorFrame(b_surface_id.local_surface_id(),
654 MakeDefaultCompositorFrame(),
655 std::move(b_hit_test_region_list));
656 local_surface_id_lookup_delegate()->SetSurfaceIdMap(b_surface_id);
657 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
658 MakeDefaultCompositorFrame(),
659 std::move(e_hit_test_region_list));
660 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
661
662 aggregator->Aggregate(e_surface_id);
663
664 EXPECT_EQ(aggregator->GetRegionCount(), 4);
665
666 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
667
668 AggregatedHitTestRegion region = host_regions()[0];
669 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
670 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
671 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
672 EXPECT_EQ(region.child_count, 3);
673
674 region = host_regions()[1];
675 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
676 HitTestRegionFlags::kHitTestIgnore,
677 region.flags);
678 EXPECT_EQ(region.frame_sink_id, c_surface_id.frame_sink_id());
679 EXPECT_EQ(region.rect, gfx::Rect(300, 100, 1600, 800));
680 EXPECT_EQ(region.child_count, 2);
681
682 gfx::Point point(300, 300);
683 gfx::Transform transform(region.transform());
684 transform.TransformPointReverse(&point);
685 EXPECT_TRUE(point == gfx::Point(100, 200));
686
687 region = host_regions()[2];
688 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
689 HitTestRegionFlags::kHitTestMine,
690 region.flags);
691 EXPECT_EQ(region.frame_sink_id, a_surface_id.frame_sink_id());
692 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 200, 100));
693 EXPECT_EQ(region.child_count, 0);
694
695 region = host_regions()[3];
696 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
697 HitTestRegionFlags::kHitTestMine,
698 region.flags);
699 EXPECT_EQ(region.frame_sink_id, b_surface_id.frame_sink_id());
700 EXPECT_EQ(region.rect, gfx::Rect(0, 100, 800, 600));
701 EXPECT_EQ(region.child_count, 0);
702 }
703
704 // Three children deep.
705 //
706 // +e------------+
707 // | +c1-------+ |
708 // | | +c2---+ | |
709 // | | | +c3-| | |
710 // | | | | | | |
711 // | | | +---| | |
712 // | | +-----+ | |
713 // | +---------+ |
714 // +-------------+
715 //
716
TEST_F(HitTestAggregatorTest,ThreeChildrenDeep)717 TEST_F(HitTestAggregatorTest, ThreeChildrenDeep) {
718 TestHitTestAggregator* aggregator = hit_test_aggregator();
719 EXPECT_EQ(aggregator->GetRegionCount(), 0);
720
721 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
722 SurfaceId c1_surface_id = MakeSurfaceId(kDisplayClientId + 1);
723 SurfaceId c2_surface_id = MakeSurfaceId(kDisplayClientId + 2);
724 SurfaceId c3_surface_id = MakeSurfaceId(kDisplayClientId + 3);
725
726 HitTestRegionList e_hit_test_region_list;
727 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
728 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
729
730 HitTestRegion e_hit_test_region_c1;
731 e_hit_test_region_c1.flags = HitTestRegionFlags::kHitTestChildSurface;
732 e_hit_test_region_c1.frame_sink_id = c1_surface_id.frame_sink_id();
733 e_hit_test_region_c1.rect.SetRect(100, 100, 700, 700);
734
735 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c1));
736
737 HitTestRegionList c1_hit_test_region_list;
738 c1_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
739 c1_hit_test_region_list.bounds.SetRect(0, 0, 600, 600);
740
741 HitTestRegion c1_hit_test_region_c2;
742 c1_hit_test_region_c2.flags = HitTestRegionFlags::kHitTestChildSurface;
743 c1_hit_test_region_c2.frame_sink_id = c2_surface_id.frame_sink_id();
744 c1_hit_test_region_c2.rect.SetRect(100, 100, 500, 500);
745
746 c1_hit_test_region_list.regions.push_back(std::move(c1_hit_test_region_c2));
747
748 HitTestRegionList c2_hit_test_region_list;
749 c2_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
750 c2_hit_test_region_list.bounds.SetRect(0, 0, 400, 400);
751
752 HitTestRegion c2_hit_test_region_c3;
753 c2_hit_test_region_c3.flags = HitTestRegionFlags::kHitTestChildSurface;
754 c2_hit_test_region_c3.frame_sink_id = c3_surface_id.frame_sink_id();
755 c2_hit_test_region_c3.rect.SetRect(100, 100, 300, 300);
756
757 c2_hit_test_region_list.regions.push_back(std::move(c2_hit_test_region_c3));
758
759 HitTestRegionList c3_hit_test_region_list;
760 c3_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
761 c3_hit_test_region_list.bounds.SetRect(0, 0, 200, 200);
762
763 // Submit in unexpected order.
764
765 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
766 nullptr, frame_sink_manager(), c1_surface_id.frame_sink_id(),
767 false /* is_root */);
768 support2->SubmitCompositorFrame(c1_surface_id.local_surface_id(),
769 MakeDefaultCompositorFrame(),
770 std::move(c1_hit_test_region_list));
771 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c1_surface_id);
772 auto support3 = std::make_unique<CompositorFrameSinkSupport>(
773 nullptr, frame_sink_manager(), c3_surface_id.frame_sink_id(),
774 false /* is_root */);
775 support3->SubmitCompositorFrame(c3_surface_id.local_surface_id(),
776 MakeDefaultCompositorFrame(),
777 std::move(c3_hit_test_region_list));
778 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c3_surface_id);
779 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
780 MakeDefaultCompositorFrame(),
781 std::move(e_hit_test_region_list));
782 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
783 auto support4 = std::make_unique<CompositorFrameSinkSupport>(
784 nullptr, frame_sink_manager(), c2_surface_id.frame_sink_id(),
785 false /* is_root */);
786 support4->SubmitCompositorFrame(c2_surface_id.local_surface_id(),
787 MakeDefaultCompositorFrame(),
788 std::move(c2_hit_test_region_list));
789 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c2_surface_id);
790
791 aggregator->Aggregate(e_surface_id);
792
793 EXPECT_EQ(aggregator->GetRegionCount(), 4);
794
795 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
796
797 AggregatedHitTestRegion region = host_regions()[0];
798 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
799 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
800 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
801 EXPECT_EQ(region.child_count, 3);
802
803 region = host_regions()[1];
804 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
805 HitTestRegionFlags::kHitTestMine,
806 region.flags);
807 EXPECT_EQ(region.frame_sink_id, c1_surface_id.frame_sink_id());
808 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 700, 700));
809 EXPECT_EQ(region.child_count, 2);
810
811 region = host_regions()[2];
812 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
813 HitTestRegionFlags::kHitTestMine,
814 region.flags);
815 EXPECT_EQ(region.frame_sink_id, c2_surface_id.frame_sink_id());
816 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 500, 500));
817 EXPECT_EQ(region.child_count, 1);
818
819 region = host_regions()[3];
820 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
821 HitTestRegionFlags::kHitTestMine,
822 region.flags);
823 EXPECT_EQ(region.frame_sink_id, c3_surface_id.frame_sink_id());
824 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 300, 300));
825 EXPECT_EQ(region.child_count, 0);
826 }
827
828 // Missing / late child.
829 //
830 // +e-----------+
831 // | +c--+ |
832 // | | |div-+ |
833 // | | | | |
834 // | | |----+ |
835 // | +---+ |
836 // +------------+
837 //
838
TEST_F(HitTestAggregatorTest,MissingChildFrame)839 TEST_F(HitTestAggregatorTest, MissingChildFrame) {
840 TestHitTestAggregator* aggregator = hit_test_aggregator();
841 EXPECT_EQ(aggregator->GetRegionCount(), 0);
842
843 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
844 SurfaceId c_surface_id = MakeSurfaceId(kDisplayClientId + 1);
845
846 HitTestRegionList e_hit_test_region_list;
847 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
848 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
849
850 HitTestRegion e_hit_test_region_div;
851 e_hit_test_region_div.flags = HitTestRegionFlags::kHitTestMine;
852 e_hit_test_region_div.frame_sink_id = e_surface_id.frame_sink_id();
853 e_hit_test_region_div.rect.SetRect(200, 200, 300, 200);
854
855 HitTestRegion e_hit_test_region_c;
856 e_hit_test_region_c.flags = HitTestRegionFlags::kHitTestChildSurface;
857 e_hit_test_region_c.frame_sink_id = c_surface_id.frame_sink_id();
858 e_hit_test_region_c.rect.SetRect(100, 100, 200, 500);
859
860 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c));
861 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_div));
862
863 HitTestRegionList c_hit_test_region_list;
864 c_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
865 c_hit_test_region_list.bounds.SetRect(0, 0, 200, 500);
866
867 // Submit in unexpected order.
868
869 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
870 MakeDefaultCompositorFrame(),
871 std::move(e_hit_test_region_list));
872 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
873
874 aggregator->Aggregate(e_surface_id);
875
876 EXPECT_EQ(aggregator->GetRegionCount(), 3);
877
878 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
879
880 AggregatedHitTestRegion region = host_regions()[0];
881 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
882 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
883 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
884 EXPECT_EQ(region.child_count, 2);
885
886 // |c_hit_test_region_list| was not submitted on time, so we should do
887 // async targeting with |e_hit_test_region_c|.
888 region = host_regions()[1];
889 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestChildSurface |
890 HitTestRegionFlags::kHitTestAsk |
891 HitTestRegionFlags::kHitTestNotActive);
892 EXPECT_EQ(region.frame_sink_id, c_surface_id.frame_sink_id());
893 EXPECT_EQ(region.rect, gfx::Rect(100, 100, 200, 500));
894 EXPECT_EQ(region.child_count, 0);
895
896 region = host_regions()[2];
897 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
898 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
899 EXPECT_EQ(region.rect, gfx::Rect(200, 200, 300, 200));
900 EXPECT_EQ(region.child_count, 0);
901 }
902
903 // Exceed limits to ensure that bounds and resize work.
904 //
905 // A tree of embedders each with 8 children and 4 levels deep = 4096 regions.
906 // This will exceed initial allocation and force a resize.
907 //
908 // +e--------------------------------------------------------+
909 // | +c1----------++c2----------++c3----------++c4----------+|
910 // | | +c1--------|| +c1--------|| +c1--------|| +c1--------||
911 // | | | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-||
912 // | | | | || || | | || || | | || || | | || ||
913 // | | | +---++---|| | +---++---|| | +---++---|| | +---++---||
914 // | +------------++------------++------------++------------+|
915 // | +c5----------++c6----------++c7----------++c8----------+|
916 // | | +c1--------|| +c1--------|| +c1--------|| +c1--------||
917 // | | | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-|| | +c1-++c2-||
918 // | | | | || || | | || || | | || || | | || ||
919 // | | | +---++---|| | +---++---|| | +---++---|| | +---++---||
920 // | +------------++------------++------------++------------+|
921 // +---------------------------------------------------------+
922 //
923
TEST_F(HitTestAggregatorTest,ExceedLimits)924 TEST_F(HitTestAggregatorTest, ExceedLimits) {
925 TestHitTestAggregator* aggregator = hit_test_aggregator();
926 EXPECT_EQ(aggregator->GetRegionCount(), 0);
927
928 EXPECT_LT(aggregator->GetHitTestRegionListCapacity(), 4096);
929
930 SurfaceId display_surface_id = MakeSurfaceId(kDisplayClientId);
931
932 CreateAndSubmitHitTestRegionListWith8Children(kDisplayClientId, 3);
933
934 aggregator->Aggregate(display_surface_id);
935
936 // Expect 4680 regions:
937 // 8 children 4 levels deep 8*8*8*8 is 4096
938 // 1 region for each embedder/surface + 584
939 // 1 root + 1
940 // -----
941 // 4681.
942 EXPECT_GE(aggregator->GetHitTestRegionListCapacity(), 4681);
943
944 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
945 EXPECT_EQ(host_regions().size(), 4681u);
946 }
947
TEST_F(HitTestAggregatorTest,DiscardedSurfaces)948 TEST_F(HitTestAggregatorTest, DiscardedSurfaces) {
949 TestHitTestAggregator* aggregator = hit_test_aggregator();
950
951 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
952 SurfaceId c_surface_id = MakeSurfaceId(kDisplayClientId + 1);
953
954 HitTestRegionList e_hit_test_region_list;
955 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
956 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
957
958 HitTestRegion e_hit_test_region_div;
959 e_hit_test_region_div.flags = HitTestRegionFlags::kHitTestMine;
960 e_hit_test_region_div.frame_sink_id = e_surface_id.frame_sink_id();
961 e_hit_test_region_div.rect.SetRect(200, 200, 300, 200);
962
963 HitTestRegion e_hit_test_region_c;
964 e_hit_test_region_c.flags = HitTestRegionFlags::kHitTestChildSurface;
965 e_hit_test_region_c.frame_sink_id = c_surface_id.frame_sink_id();
966 e_hit_test_region_c.rect.SetRect(100, 100, 200, 500);
967
968 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c));
969 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_div));
970
971 HitTestRegionList c_hit_test_region_list;
972 c_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
973 c_hit_test_region_list.bounds.SetRect(0, 0, 200, 500);
974
975 EXPECT_FALSE(hit_test_manager()->GetActiveHitTestRegionList(
976 local_surface_id_lookup_delegate(), e_surface_id.frame_sink_id()));
977 EXPECT_FALSE(hit_test_manager()->GetActiveHitTestRegionList(
978 local_surface_id_lookup_delegate(), c_surface_id.frame_sink_id()));
979
980 // Submit in unexpected order.
981
982 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
983 nullptr, frame_sink_manager(), c_surface_id.frame_sink_id(),
984 false /* is_root */);
985 support2->SubmitCompositorFrame(c_surface_id.local_surface_id(),
986 MakeDefaultCompositorFrame(),
987 std::move(c_hit_test_region_list));
988 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c_surface_id);
989 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
990 MakeDefaultCompositorFrame(),
991 std::move(e_hit_test_region_list));
992 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
993
994 aggregator->Aggregate(e_surface_id);
995
996 EXPECT_TRUE(hit_test_manager()->GetActiveHitTestRegionList(
997 local_surface_id_lookup_delegate(), e_surface_id.frame_sink_id()));
998 EXPECT_TRUE(hit_test_manager()->GetActiveHitTestRegionList(
999 local_surface_id_lookup_delegate(), c_surface_id.frame_sink_id()));
1000
1001 // Discard Surface and ensure active count goes down.
1002 support2->EvictSurface(c_surface_id.local_surface_id());
1003 ExpireAllTemporaryReferencesAndGarbageCollect();
1004 EXPECT_TRUE(hit_test_manager()->GetActiveHitTestRegionList(
1005 local_surface_id_lookup_delegate(), e_surface_id.frame_sink_id()));
1006 EXPECT_FALSE(hit_test_manager()->GetActiveHitTestRegionList(
1007 local_surface_id_lookup_delegate(), c_surface_id.frame_sink_id()));
1008
1009 support()->EvictSurface(e_surface_id.local_surface_id());
1010 ExpireAllTemporaryReferencesAndGarbageCollect();
1011 EXPECT_FALSE(hit_test_manager()->GetActiveHitTestRegionList(
1012 local_surface_id_lookup_delegate(), e_surface_id.frame_sink_id()));
1013 EXPECT_FALSE(hit_test_manager()->GetActiveHitTestRegionList(
1014 local_surface_id_lookup_delegate(), c_surface_id.frame_sink_id()));
1015 }
1016
1017 // Region c1 is transparent and on top of e, c2 is a child of e, d1 is a
1018 // child of c1.
1019 //
1020 // +e/c1----------+
1021 // | | Point maps to
1022 // | +c2-+ | ----- -------
1023 // | | 1 | | 1 c2
1024 // | +d1--------|
1025 // | | |
1026 // | | |
1027 // +--------------+
1028 //
1029
TEST_F(HitTestAggregatorTest,TransparentOverlayRegions)1030 TEST_F(HitTestAggregatorTest, TransparentOverlayRegions) {
1031 TestHitTestAggregator* aggregator = hit_test_aggregator();
1032 EXPECT_EQ(aggregator->GetRegionCount(), 0);
1033
1034 SurfaceId e_surface_id = MakeSurfaceId(kDisplayClientId);
1035 SurfaceId c1_surface_id = MakeSurfaceId(kDisplayClientId + 1);
1036 SurfaceId c2_surface_id = MakeSurfaceId(kDisplayClientId + 2);
1037 SurfaceId d1_surface_id = MakeSurfaceId(kDisplayClientId + 3);
1038
1039 HitTestRegionList e_hit_test_region_list;
1040 e_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
1041 e_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
1042
1043 HitTestRegion e_hit_test_region_c1;
1044 e_hit_test_region_c1.flags = HitTestRegionFlags::kHitTestChildSurface;
1045 e_hit_test_region_c1.frame_sink_id = c1_surface_id.frame_sink_id();
1046 e_hit_test_region_c1.rect.SetRect(0, 0, 1024, 768);
1047
1048 HitTestRegion e_hit_test_region_c2;
1049 e_hit_test_region_c2.flags = HitTestRegionFlags::kHitTestChildSurface;
1050 e_hit_test_region_c2.frame_sink_id = c2_surface_id.frame_sink_id();
1051 e_hit_test_region_c2.rect.SetRect(0, 0, 200, 100);
1052 e_hit_test_region_c2.transform.Translate(200, 100);
1053
1054 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c1));
1055 e_hit_test_region_list.regions.push_back(std::move(e_hit_test_region_c2));
1056
1057 HitTestRegionList c1_hit_test_region_list;
1058 c1_hit_test_region_list.flags = HitTestRegionFlags::kHitTestIgnore;
1059 c1_hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
1060
1061 HitTestRegion c1_hit_test_region_d1;
1062 c1_hit_test_region_d1.flags = HitTestRegionFlags::kHitTestChildSurface;
1063 c1_hit_test_region_d1.frame_sink_id = d1_surface_id.frame_sink_id();
1064 c1_hit_test_region_d1.rect.SetRect(0, 100, 800, 600);
1065 c1_hit_test_region_d1.transform.Translate(200, 100);
1066
1067 c1_hit_test_region_list.regions.push_back(std::move(c1_hit_test_region_d1));
1068
1069 HitTestRegionList d1_hit_test_region_list;
1070 d1_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
1071 d1_hit_test_region_list.bounds.SetRect(0, 100, 800, 600);
1072
1073 HitTestRegionList c2_hit_test_region_list;
1074 c2_hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
1075 c2_hit_test_region_list.bounds.SetRect(0, 0, 200, 100);
1076
1077 // Submit in unexpected order.
1078
1079 auto support2 = std::make_unique<CompositorFrameSinkSupport>(
1080 nullptr, frame_sink_manager(), c1_surface_id.frame_sink_id(),
1081 false /* is_root */);
1082 support2->SubmitCompositorFrame(c1_surface_id.local_surface_id(),
1083 MakeDefaultCompositorFrame(),
1084 std::move(c1_hit_test_region_list));
1085 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c1_surface_id);
1086 auto support3 = std::make_unique<CompositorFrameSinkSupport>(
1087 nullptr, frame_sink_manager(), c2_surface_id.frame_sink_id(),
1088 false /* is_root */);
1089 support3->SubmitCompositorFrame(c2_surface_id.local_surface_id(),
1090 MakeDefaultCompositorFrame(),
1091 std::move(c2_hit_test_region_list));
1092 local_surface_id_lookup_delegate()->SetSurfaceIdMap(c2_surface_id);
1093 auto support4 = std::make_unique<CompositorFrameSinkSupport>(
1094 nullptr, frame_sink_manager(), d1_surface_id.frame_sink_id(),
1095 false /* is_root */);
1096 support4->SubmitCompositorFrame(d1_surface_id.local_surface_id(),
1097 MakeDefaultCompositorFrame(),
1098 std::move(d1_hit_test_region_list));
1099 local_surface_id_lookup_delegate()->SetSurfaceIdMap(d1_surface_id);
1100 support()->SubmitCompositorFrame(e_surface_id.local_surface_id(),
1101 MakeDefaultCompositorFrame(),
1102 std::move(e_hit_test_region_list));
1103 local_surface_id_lookup_delegate()->SetSurfaceIdMap(e_surface_id);
1104
1105 aggregator->Aggregate(e_surface_id);
1106
1107 EXPECT_EQ(aggregator->GetRegionCount(), 4);
1108
1109 EXPECT_EQ(host_buffer_frame_sink_id(), kDisplayFrameSink);
1110
1111 AggregatedHitTestRegion region = host_regions()[0];
1112 EXPECT_EQ(region.flags, HitTestRegionFlags::kHitTestMine);
1113 EXPECT_EQ(region.frame_sink_id, e_surface_id.frame_sink_id());
1114 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
1115 EXPECT_EQ(region.child_count, 3);
1116
1117 region = host_regions()[1];
1118 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
1119 HitTestRegionFlags::kHitTestIgnore,
1120 region.flags);
1121 EXPECT_EQ(region.frame_sink_id, c1_surface_id.frame_sink_id());
1122 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 1024, 768));
1123 EXPECT_EQ(region.child_count, 1);
1124
1125 region = host_regions()[2];
1126 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
1127 HitTestRegionFlags::kHitTestMine,
1128 region.flags);
1129 EXPECT_EQ(region.frame_sink_id, d1_surface_id.frame_sink_id());
1130 EXPECT_EQ(region.rect, gfx::Rect(0, 100, 800, 600));
1131 EXPECT_EQ(region.child_count, 0);
1132
1133 region = host_regions()[3];
1134 EXPECT_EQ(HitTestRegionFlags::kHitTestChildSurface |
1135 HitTestRegionFlags::kHitTestMine,
1136 region.flags);
1137 EXPECT_EQ(region.frame_sink_id, c2_surface_id.frame_sink_id());
1138 EXPECT_EQ(region.rect, gfx::Rect(0, 0, 200, 100));
1139 EXPECT_EQ(region.child_count, 0);
1140 }
1141
TEST_F(HitTestAggregatorTest,HitTestDataNotUpdated)1142 TEST_F(HitTestAggregatorTest, HitTestDataNotUpdated) {
1143 TestHitTestAggregator* aggregator = hit_test_aggregator();
1144 EXPECT_EQ(aggregator->GetRegionCount(), 0);
1145
1146 SurfaceId surface_id = MakeSurfaceId(kDisplayClientId);
1147 HitTestRegionList hit_test_region_list;
1148 hit_test_region_list.flags = HitTestRegionFlags::kHitTestMine;
1149 hit_test_region_list.bounds.SetRect(0, 0, 1024, 768);
1150 HitTestRegionList hit_test_region_list_copy = hit_test_region_list;
1151
1152 support()->SubmitCompositorFrame(surface_id.local_surface_id(),
1153 MakeDefaultCompositorFrame(),
1154 std::move(hit_test_region_list));
1155 aggregator->Aggregate(surface_id);
1156 uint64_t last_index = aggregator->GetLastSubmitHitTestRegionListIndex();
1157
1158 // We did not update the hit-test data. Expect the index from Aggregator /
1159 // Manager to remain unchanged.
1160 support()->SubmitCompositorFrame(surface_id.local_surface_id(),
1161 MakeDefaultCompositorFrame(), base::nullopt);
1162 aggregator->Aggregate(surface_id);
1163 EXPECT_EQ(last_index, aggregator->GetLastSubmitHitTestRegionListIndex());
1164
1165 // We updated hit-test data. Expect the index to have changed.
1166 support()->SubmitCompositorFrame(surface_id.local_surface_id(),
1167 MakeDefaultCompositorFrame(),
1168 std::move(hit_test_region_list));
1169 aggregator->Aggregate(surface_id);
1170 EXPECT_NE(last_index, aggregator->GetLastSubmitHitTestRegionListIndex());
1171 }
1172
1173 } // namespace viz
1174