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_copy));
1169   aggregator->Aggregate(surface_id);
1170   EXPECT_NE(last_index, aggregator->GetLastSubmitHitTestRegionListIndex());
1171 }
1172 
1173 }  // namespace viz
1174