Check for intersection earlier when hit-testing.

Simply creating an NGBoxFragmentPainter has a "significant" cost. When
hit-testing, we're typically going to miss most of the elements (in
search of the one to hit (along with its ancestors)), so this needs to
be as cheap as possible. Therefore, check for intersection earlier, and
only create an NGBoxFragmentPainter for hit-testing if it's likely at
all that we're going to hit something inside the fragment.

This fixes most of the performance regression in the following tests:
  perf_tests/events/hit-test-lots-of-layers.html [1]
  perf_tests/layout/hittest-block-children.html [2]

[1] Same, or possibly slightly faster (0.9%)
[2] Still slower (9%)

I suspect that perf_tests/layout/hittest-block-children.html is still
slower because of the overhead of creating NGInlineCursor and
NGInlineBackwardCursor objects without checking if we intersect first.
See crbug.com/1240036

We are also performing duplicate intersection checks in some cases now,
which has a tiny (but I *think* it's measurable) cost. With this change,
we'll check for intersection before creating an NGBoxFragmentPainter,
but, if we intersect, we'll check again nevertheless in e.g.
NGBoxFragmentPainter::NodeAtPoint(). Ideally, we should turn the latter
into a DCHECK, but there are still a few call-sites that would need to
be updated first. Added a couple of TODOs for now. It may be that we
could wait until the legacy layout engine is gone, before following up,
as that would be slightly easier (and the gain isn't huge anyway).

Bug: 1240034, 1240036
Change-Id: I11a91038de180b30d99263038f65c7c8bf6fa923
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3113968
Reviewed-by: Koji Ishii <[email protected]>
Commit-Queue: Morten Stenshorne <[email protected]>
Cr-Commit-Position: refs/heads/main@{#914849}

Author: mstensho

third_party/blink/renderer/core/paint/ng/ng_box_fragment_painter.cc

@@ -306,6 +306,9 @@ bool HitTestAllPhasesInFragment(const NGPhysicalBoxFragment& fragment,
         *result, hit_test_location, accumulated_offset);
   }
 
+  if (!fragment.MayIntersect(*result, hit_test_location, accumulated_offset))
+    return false;
+
   return NGBoxFragmentPainter(To<NGPhysicalBoxFragment>(fragment))
       .HitTestAllPhases(*result, hit_test_location, accumulated_offset);
 }
@@ -320,6 +323,9 @@ bool NodeAtPointInFragment(const NGPhysicalBoxFragment& fragment,
         *result, hit_test_location, accumulated_offset, action);
   }
 
+  if (!fragment.MayIntersect(*result, hit_test_location, accumulated_offset))
+    return false;
+
   return NGBoxFragmentPainter(fragment).NodeAtPoint(*result, hit_test_location,
                                                     accumulated_offset, action);
 }
@@ -1870,6 +1876,8 @@ bool NGBoxFragmentPainter::NodeAtPoint(HitTestResult& result,
 bool NGBoxFragmentPainter::NodeAtPoint(const HitTestContext& hit_test,
                                        const PhysicalOffset& physical_offset) {
   const NGPhysicalBoxFragment& fragment = PhysicalFragment();
+  // TODO(mstensho): Make sure that we never create an NGBoxFragmentPainter for
+  // a fragment that doesn't intersect, and turn this into a DCHECK.
   if (!fragment.MayIntersect(*hit_test.result, hit_test.location,
                              physical_offset))
     return false;
@@ -1985,6 +1993,9 @@ bool NGBoxFragmentPainter::HitTestAllPhases(
     const HitTestLocation& hit_test_location,
     const PhysicalOffset& accumulated_offset,
     HitTestFilter hit_test_filter) {
+  // TODO(mstensho): Make sure that we never create an NGBoxFragmentPainter for
+  // a fragment that doesn't intersect, and DCHECK for that here.
+
   // Logic taken from LayoutObject::HitTestAllPhases().
   HitTestContext hit_test(kHitTestForeground, hit_test_location,
                           accumulated_offset, &result);
@@ -2139,6 +2150,10 @@ bool NGBoxFragmentPainter::HitTestChildBoxFragment(
     const NGFragmentItem* item = cursor.Current().Item();
     DCHECK(item);
     DCHECK_EQ(item->BoxFragment(), &fragment);
+    if (!fragment.MayIntersect(*hit_test.result, hit_test.location,
+                               physical_offset))
+      return false;
+
     if (fragment.IsInlineBox()) {
       return NGBoxFragmentPainter(cursor, *item, fragment)
           .NodeAtPoint(hit_test, physical_offset);
@@ -2416,16 +2431,10 @@ bool NGBoxFragmentPainter::HitTestFloatingChildren(
       // We need to properly visit this fragment for hit-testing, rather than
       // jumping directly to its children (which is what we normally do when
       // looking for floats), in order to set up the clip rectangle.
-      if (child_fragment.CanTraverse()) {
-        if (NGBoxFragmentPainter(To<NGPhysicalBoxFragment>(child_fragment))
-                .NodeAtPoint(*hit_test.result, hit_test.location, child_offset,
-                             kHitTestFloat))
-          return true;
-      } else if (child_fragment.GetMutableLayoutObject()->NodeAtPoint(
-                     *hit_test.result, hit_test.location, child_offset,
-                     kHitTestFloat)) {
+      if (NodeAtPointInFragment(To<NGPhysicalBoxFragment>(child_fragment),
+                                hit_test.location, child_offset, kHitTestFloat,
+                                hit_test.result))
         return true;
-      }
       continue;
     }
 

third_party/blink/renderer/core/paint/paint_layer.cc

@@ -2506,9 +2506,14 @@ bool PaintLayer::HitTestContents(HitTestResult& result,
 
   bool did_hit;
   if (physical_fragment) {
-    did_hit = NGBoxFragmentPainter(*physical_fragment)
-                  .HitTestAllPhases(result, hit_test_location, fragment_offset,
-                                    hit_test_filter);
+    if (!physical_fragment->MayIntersect(result, hit_test_location,
+                                         fragment_offset)) {
+      did_hit = false;
+    } else {
+      did_hit = NGBoxFragmentPainter(*physical_fragment)
+                    .HitTestAllPhases(result, hit_test_location,
+                                      fragment_offset, hit_test_filter);
+    }
   } else {
     did_hit = GetLayoutObject().HitTestAllPhases(
         result, hit_test_location, fragment_offset, hit_test_filter);