Rename TouchActionRect to HitTestRect

We are going to implement wheel event handler region computation in
ScrollingCoordinator and painting, since wheel event regions share many
similarities to touch action rects, we want to use the same code path
for wheel events. As a result, TouchActionRect will store wheel data as
well and they should be renamed to HitTestRect.

Bug: 841364
Cq-Include-Trybots: luci.chromium.try:linux_layout_tests_layout_ng;luci.chromium.try:linux_layout_tests_slimming_paint_v2;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I1d9c967033846d1945163192a437f11cbebdf641
Reviewed-on: https://chromium-review.googlesource.com/1239490Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Xianda Sun <sunxd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595330}

third_party/blink/renderer/core/layout/layout_object.cc

@@ -2895,9 +2895,9 @@ void LayoutObject::AddLayerHitTestRects(
   const size_t kMaxRectsPerLayer = 100;
 
   LayerHitTestRects::iterator iter = layer_rects.find(current_layer);
-  Vector<TouchActionRect>* iter_value;
+  Vector<HitTestRect>* iter_value;
   if (iter == layer_rects.end()) {
-    iter_value = &layer_rects.insert(current_layer, Vector<TouchActionRect>())
+    iter_value = &layer_rects.insert(current_layer, Vector<HitTestRect>())
                       .stored_value->value;
   } else {
     iter_value = &iter->value;
@@ -2910,7 +2910,7 @@ void LayoutObject::AddLayerHitTestRects(
     if (whitelisted_touch_action != container_whitelisted_touch_action ||
         !container_rect.Contains(own_rects[i])) {
       iter_value->push_back(
-          TouchActionRect(own_rects[i], whitelisted_touch_action));
+          HitTestRect(own_rects[i], whitelisted_touch_action));
       if (iter_value->size() > kMaxRectsPerLayer) {
         // Just mark the entire layer instead, and switch to walking the layer
         // tree instead of the layout tree.

third_party/blink/renderer/core/layout/layout_object.h

@@ -51,11 +51,11 @@
 #include "third_party/blink/renderer/platform/geometry/float_quad.h"
 #include "third_party/blink/renderer/platform/geometry/layout_rect.h"
 #include "third_party/blink/renderer/platform/graphics/compositing_reasons.h"
+#include "third_party/blink/renderer/platform/graphics/hit_test_rect.h"
 #include "third_party/blink/renderer/platform/graphics/image_orientation.h"
 #include "third_party/blink/renderer/platform/graphics/paint/display_item_client.h"
 #include "third_party/blink/renderer/platform/graphics/paint_invalidation_reason.h"
 #include "third_party/blink/renderer/platform/graphics/subtree_paint_property_update_reason.h"
-#include "third_party/blink/renderer/platform/graphics/touch_action_rect.h"
 #include "third_party/blink/renderer/platform/transforms/transform_state.h"
 #include "third_party/blink/renderer/platform/transforms/transformation_matrix.h"
 

third_party/blink/renderer/core/page/scrolling/scrolling_coordinator.cc

@@ -265,10 +265,10 @@ static void UpdateLayerTouchActionRects(GraphicsLayer& layer) {
     return;
 
   const auto& layer_state = layer.GetPropertyTreeState();
-  Vector<TouchActionRect> touch_action_rects_in_layer_space;
+  Vector<HitTestRect> touch_action_rects_in_layer_space;
   if (layer.Client().ShouldThrottleRendering()) {
     layer.CcLayer()->SetTouchActionRegion(
-        TouchActionRect::BuildRegion(touch_action_rects_in_layer_space));
+        HitTestRect::BuildRegion(touch_action_rects_in_layer_space));
     return;
   }
   for (const auto& chunk : layer.GetPaintController().PaintChunks()) {
@@ -286,12 +286,12 @@ static void UpdateLayerTouchActionRects(GraphicsLayer& layer) {
       }
       LayoutRect layout_rect = LayoutRect(rect.Rect());
       layout_rect.MoveBy(-layer.GetOffsetFromTransformNode());
-      touch_action_rects_in_layer_space.emplace_back(TouchActionRect(
-          layout_rect, touch_action_rect.whitelisted_touch_action));
+      touch_action_rects_in_layer_space.emplace_back(
+          HitTestRect(layout_rect, touch_action_rect.whitelisted_touch_action));
     }
   }
   layer.CcLayer()->SetTouchActionRegion(
-      TouchActionRect::BuildRegion(touch_action_rects_in_layer_space));
+      HitTestRect::BuildRegion(touch_action_rects_in_layer_space));
 }
 
 static void ClearPositionConstraintExceptForLayer(GraphicsLayer* layer,
@@ -630,7 +630,7 @@ void ScrollingCoordinator::ScrollableAreaScrollLayerDidChange(
 }
 
 using GraphicsLayerHitTestRects =
-    WTF::HashMap<const GraphicsLayer*, Vector<TouchActionRect>>;
+    WTF::HashMap<const GraphicsLayer*, Vector<HitTestRect>>;
 
 // In order to do a DFS cross-frame walk of the Layer tree, we need to know
 // which Layers have child frames inside of them. This computes a mapping for
@@ -685,18 +685,17 @@ static void ProjectRectsToGraphicsLayerSpaceRecursive(
 
     GraphicsLayerHitTestRects::iterator gl_iter =
         graphics_rects.find(graphics_layer);
-    Vector<TouchActionRect>* gl_rects;
+    Vector<HitTestRect>* gl_rects;
     if (gl_iter == graphics_rects.end()) {
-      gl_rects =
-          &graphics_rects.insert(graphics_layer, Vector<TouchActionRect>())
-               .stored_value->value;
+      gl_rects = &graphics_rects.insert(graphics_layer, Vector<HitTestRect>())
+                      .stored_value->value;
     } else {
       gl_rects = &gl_iter->value;
     }
 
     // Transform each rect to the co-ordinate space of the graphicsLayer.
     for (wtf_size_t i = 0; i < layer_iter->value.size(); ++i) {
-      TouchActionRect rect = layer_iter->value[i];
+      HitTestRect rect = layer_iter->value[i];
       if (composited_layer != cur_layer) {
         FloatQuad compositor_quad = geometry_map.MapToAncestor(
             FloatRect(rect.rect), &composited_layer->GetLayoutObject());
@@ -873,14 +872,13 @@ void ScrollingCoordinator::SetTouchEventTargetRects(
     GraphicsLayer* main_graphics_layer =
         layer->GraphicsLayerBacking(&layer->GetLayoutObject());
     if (main_graphics_layer) {
-      graphics_layer_rects.insert(main_graphics_layer,
-                                  Vector<TouchActionRect>());
+      graphics_layer_rects.insert(main_graphics_layer, Vector<HitTestRect>());
     }
     GraphicsLayer* scrolling_contents_layer = layer->GraphicsLayerBacking();
     if (scrolling_contents_layer &&
         scrolling_contents_layer != main_graphics_layer) {
       graphics_layer_rects.insert(scrolling_contents_layer,
-                                  Vector<TouchActionRect>());
+                                  Vector<HitTestRect>());
     }
   }
 
@@ -905,7 +903,7 @@ void ScrollingCoordinator::SetTouchEventTargetRects(
   for (const auto& layer_rect : graphics_layer_rects) {
     const GraphicsLayer* graphics_layer = layer_rect.key;
     graphics_layer->CcLayer()->SetTouchActionRegion(
-        TouchActionRect::BuildRegion(layer_rect.value));
+        HitTestRect::BuildRegion(layer_rect.value));
   }
 }
 

third_party/blink/renderer/core/page/scrolling/scrolling_coordinator.h

@@ -32,7 +32,7 @@
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/platform/geometry/int_rect.h"
 #include "third_party/blink/renderer/platform/graphics/compositor_element_id.h"
-#include "third_party/blink/renderer/platform/graphics/touch_action_rect.h"
+#include "third_party/blink/renderer/platform/graphics/hit_test_rect.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/scroll/main_thread_scrolling_reason.h"
 #include "third_party/blink/renderer/platform/scroll/scroll_types.h"

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

@@ -173,13 +173,13 @@ void BlockPainter::RecordHitTestData(const PaintInfo& paint_info,
 
   // TODO(pdr): If we are painting the background into the scrolling contents
   // layer, we need to use the overflow rect instead of the border box rect. We
-  // may want to move the call to RecordTouchActionRect into
+  // may want to move the call to RecordHitTestRect into
   // BoxPainter::PaintBoxDecorationBackgroundWithRect and share the logic
   // the background painting code already uses.
   auto rect = layout_block_.BorderBoxRect();
   rect.MoveBy(paint_offset);
-  HitTestData::RecordTouchActionRect(paint_info.context, layout_block_,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_block_,
+                                 HitTestRect(rect, touch_action));
 }
 
 DISABLE_CFI_PERF

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

@@ -341,9 +341,9 @@ void InlineFlowBoxPainter::RecordHitTestData(const PaintInfo& paint_info,
   if (touch_action == TouchAction::kTouchActionAuto)
     return;
 
-  HitTestData::RecordTouchActionRect(
+  HitTestData::RecordHitTestRect(
       paint_info.context, inline_flow_box_,
-      TouchActionRect(AdjustedPaintRect(paint_offset), touch_action));
+      HitTestRect(AdjustedPaintRect(paint_offset), touch_action));
 }
 
 void InlineFlowBoxPainter::PaintNormalBoxShadow(const PaintInfo& info,

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

@@ -205,16 +205,16 @@ void NGBoxFragmentPainter::RecordHitTestData(const PaintInfo& paint_info,
 
   // TODO(pdr): If we are painting the background into the scrolling contents
   // layer, we need to use the overflow rect instead of the border box rect. We
-  // may want to move the call to RecordTouchActionRect into
+  // may want to move the call to RecordHitTestRect into
   // BoxPainter::PaintBoxDecorationBackgroundWithRect and share the logic
   // the background painting code already uses.
   NGPhysicalOffsetRect border_box = physical_fragment.LocalRect();
   if (physical_fragment.IsInline())
     border_box.offset += box_fragment_.InlineOffsetToContainerBox();
   border_box.offset += NGPhysicalOffset(paint_offset);
-  HitTestData::RecordTouchActionRect(
+  HitTestData::RecordHitTestRect(
       paint_info.context, box_fragment_,
-      TouchActionRect(border_box.ToLayoutRect(), touch_action));
+      HitTestRect(border_box.ToLayoutRect(), touch_action));
 }
 
 void NGBoxFragmentPainter::PaintObject(

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

@@ -3375,7 +3375,7 @@ void PaintLayer::ComputeSelfHitTestRects(
     LayerHitTestRects& rects,
     TouchAction supported_fast_actions) const {
   if (!Size().IsEmpty()) {
-    Vector<TouchActionRect> rect;
+    Vector<HitTestRect> rect;
     TouchAction whitelisted_touch_action =
         GetLayoutObject().StyleRef().GetEffectiveTouchAction() &
         supported_fast_actions;
@@ -3388,25 +3388,25 @@ void PaintLayer::ComputeSelfHitTestRects(
       // composited layer. Skip reporting contents for non-composited layers as
       // they'll get projected to the same layer as the bounding box.
       if (GetCompositingState() != kNotComposited && scrollable_area_) {
-        rect.push_back(TouchActionRect(scrollable_area_->OverflowRect(),
-                                       whitelisted_touch_action));
+        rect.push_back(HitTestRect(scrollable_area_->OverflowRect(),
+                                   whitelisted_touch_action));
       }
 
       rects.Set(this, rect);
       if (const PaintLayer* parent_layer = Parent()) {
         LayerHitTestRects::iterator iter = rects.find(parent_layer);
         if (iter == rects.end()) {
-          rects.insert(parent_layer, Vector<TouchActionRect>())
-              .stored_value->value.push_back(TouchActionRect(
+          rects.insert(parent_layer, Vector<HitTestRect>())
+              .stored_value->value.push_back(HitTestRect(
                   PhysicalBoundingBox(parent_layer), whitelisted_touch_action));
         } else {
-          iter->value.push_back(TouchActionRect(
-              PhysicalBoundingBox(parent_layer), whitelisted_touch_action));
+          iter->value.push_back(HitTestRect(PhysicalBoundingBox(parent_layer),
+                                            whitelisted_touch_action));
         }
       }
     } else {
       rect.push_back(
-          TouchActionRect(LogicalBoundingBox(), whitelisted_touch_action));
+          HitTestRect(LogicalBoundingBox(), whitelisted_touch_action));
       rects.Set(this, rect);
     }
   }

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

@@ -200,8 +200,8 @@ void ReplacedPainter::RecordHitTestData(const PaintInfo& paint_info,
 
   auto rect = layout_replaced_.VisualOverflowRect();
   rect.MoveBy(paint_offset);
-  HitTestData::RecordTouchActionRect(paint_info.context, layout_replaced_,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_replaced_,
+                                 HitTestRect(rect, touch_action));
 }
 
 bool ReplacedPainter::ShouldPaint(const ScopedPaintState& paint_state) const {

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

@@ -44,9 +44,8 @@ void SVGModelObjectPainter::RecordHitTestData(
 
   auto rect =
       LayoutRect(layout_svg_model_object.VisualRectInLocalSVGCoordinates());
-  HitTestData::RecordTouchActionRect(paint_info.context,
-                                     layout_svg_model_object,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_svg_model_object,
+                                 HitTestRect(rect, touch_action));
 }
 
 void SVGModelObjectPainter::PaintOutline(const PaintInfo& paint_info) {

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

@@ -47,8 +47,8 @@ void SVGTextPainter::RecordHitTestData(const PaintInfo& paint_info) {
     return;
 
   auto rect = LayoutRect(layout_svg_text_.VisualRectInLocalSVGCoordinates());
-  HitTestData::RecordTouchActionRect(paint_info.context, layout_svg_text_,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_svg_text_,
+                                 HitTestRect(rect, touch_action));
 }
 
 }  // namespace blink

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

@@ -65,8 +65,8 @@ void TablePainter::RecordHitTestData(const PaintInfo& paint_info,
 
   auto rect = layout_table_.BorderBoxRect();
   rect.MoveBy(paint_offset);
-  HitTestData::RecordTouchActionRect(paint_info.context, layout_table_,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_table_,
+                                 HitTestRect(rect, touch_action));
 }
 
 void TablePainter::PaintBoxDecorationBackground(

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

@@ -80,8 +80,8 @@ void TableRowPainter::RecordHitTestData(const PaintInfo& paint_info,
 
   auto rect = layout_table_row_.BorderBoxRect();
   rect.MoveBy(paint_offset);
-  HitTestData::RecordTouchActionRect(paint_info.context, layout_table_row_,
-                                     TouchActionRect(rect, touch_action));
+  HitTestData::RecordHitTestRect(paint_info.context, layout_table_row_,
+                                 HitTestRect(rect, touch_action));
 }
 
 void TableRowPainter::PaintBoxDecorationBackground(

third_party/blink/renderer/platform/BUILD.gn

@@ -966,6 +966,8 @@ jumbo_component("platform") {
     "graphics/high_contrast_settings.h",
     "graphics/highcontrast/highcontrast_classifier.cc",
     "graphics/highcontrast/highcontrast_classifier.h",
+    "graphics/hit_test_rect.cc",
+    "graphics/hit_test_rect.h",
     "graphics/image.cc",
     "graphics/image.h",
     "graphics/image_animation_policy.h",
@@ -1104,8 +1106,6 @@ jumbo_component("platform") {
     "graphics/surface_layer_bridge.h",
     "graphics/texture_holder.h",
     "graphics/touch_action.h",
-    "graphics/touch_action_rect.cc",
-    "graphics/touch_action_rect.h",
     "graphics/unaccelerated_static_bitmap_image.cc",
     "graphics/unaccelerated_static_bitmap_image.h",
     "graphics/video_frame_resource_provider.cc",

third_party/blink/renderer/platform/graphics/touch_action_rect.cc → third_party/blink/renderer/platform/graphics/hit_test_rect.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "third_party/blink/renderer/platform/graphics/touch_action_rect.h"
+#include "third_party/blink/renderer/platform/graphics/hit_test_rect.h"
 
 #include "base/containers/flat_map.h"
 #include "cc/base/region.h"
@@ -11,16 +11,27 @@
 namespace blink {
 
 // static
-cc::TouchActionRegion TouchActionRect::BuildRegion(
-    const Vector<TouchActionRect>& touch_action_rects) {
+cc::TouchActionRegion HitTestRect::BuildRegion(
+    const Vector<HitTestRect>& hit_test_rects) {
   base::flat_map<TouchAction, cc::Region> region_map;
-  region_map.reserve(touch_action_rects.size());
-  for (const TouchActionRect& touch_action_rect : touch_action_rects) {
-    TouchAction action = touch_action_rect.whitelisted_touch_action;
-    const LayoutRect& rect = touch_action_rect.rect;
+  region_map.reserve(hit_test_rects.size());
+  for (const HitTestRect& hit_test_rect : hit_test_rects) {
+    const TouchAction& action = hit_test_rect.whitelisted_touch_action;
+    const LayoutRect& rect = hit_test_rect.rect;
     region_map[action].Union(EnclosingIntRect(rect));
   }
   return cc::TouchActionRegion(std::move(region_map));
 }
 
+// static
+LayoutRect HitTestRect::GetBounds(const Vector<HitTestRect>& hit_test_rects) {
+  cc::Region region;
+  for (const HitTestRect& hit_test_rect : hit_test_rects) {
+    const LayoutRect& rect = hit_test_rect.rect;
+    region.Union(EnclosingIntRect(rect));
+  }
+  const auto& rect = region.bounds();
+  return LayoutRect(IntRect(rect));
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/graphics/touch_action_rect.h → third_party/blink/renderer/platform/graphics/hit_test_rect.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_TOUCH_ACTION_RECT_H_
-#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_TOUCH_ACTION_RECT_H_
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_HIT_TEST_RECT_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_HIT_TEST_RECT_H_
 
 #include "third_party/blink/renderer/platform/geometry/layout_rect.h"
 #include "third_party/blink/renderer/platform/graphics/touch_action.h"
@@ -19,26 +19,31 @@ namespace blink {
 
 class PaintLayer;
 
-struct PLATFORM_EXPORT TouchActionRect {
+struct PLATFORM_EXPORT HitTestRect {
+  // HitTestRect is a class shared by touch action region, wheel event handler
+  // region and non fast scrollable region. Wheel event handler region and
+  // non-fast scrollable rects use a |whitelisted_touch_action| of none.
   LayoutRect rect;
   TouchAction whitelisted_touch_action;
 
-  TouchActionRect(const LayoutRect& layout_rect, TouchAction action)
+  HitTestRect(const LayoutRect& layout_rect)
+      : HitTestRect(layout_rect, TouchAction::kTouchActionNone) {}
+  HitTestRect(const LayoutRect& layout_rect, TouchAction action)
       : rect(layout_rect), whitelisted_touch_action(action) {}
 
-  static cc::TouchActionRegion BuildRegion(const Vector<TouchActionRect>&);
+  static cc::TouchActionRegion BuildRegion(const Vector<HitTestRect>&);
+  static LayoutRect GetBounds(const Vector<HitTestRect>&);
 
-  bool operator==(const TouchActionRect& rhs) const {
+  bool operator==(const HitTestRect& rhs) const {
     return rect == rhs.rect &&
            whitelisted_touch_action == rhs.whitelisted_touch_action;
   }
 
-  bool operator!=(const TouchActionRect& rhs) const { return !(*this == rhs); }
+  bool operator!=(const HitTestRect& rhs) const { return !(*this == rhs); }
 };
 
-using LayerHitTestRects =
-    WTF::HashMap<const PaintLayer*, Vector<TouchActionRect>>;
+using LayerHitTestRects = WTF::HashMap<const PaintLayer*, Vector<HitTestRect>>;
 
 }  // namespace blink
 
-#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_TOUCH_ACTION_RECT_H_
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_HIT_TEST_RECT_H_

third_party/blink/renderer/platform/graphics/paint/hit_test_data.cc

@@ -10,9 +10,9 @@
 
 namespace blink {
 
-void HitTestData::RecordTouchActionRect(GraphicsContext& context,
-                                        const DisplayItemClient& client,
-                                        const TouchActionRect& action) {
+void HitTestData::RecordHitTestRect(GraphicsContext& context,
+                                    const DisplayItemClient& client,
+                                    const HitTestRect& action) {
   DCHECK(RuntimeEnabledFeatures::PaintTouchActionRectsEnabled());
 
   PaintController& paint_controller = context.GetPaintController();

third_party/blink/renderer/platform/graphics/paint/hit_test_data.h

@@ -6,7 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_PAINT_HIT_TEST_DATA_H_
 
 #include "third_party/blink/renderer/platform/geometry/region.h"
-#include "third_party/blink/renderer/platform/graphics/touch_action_rect.h"
+#include "third_party/blink/renderer/platform/graphics/hit_test_rect.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 
 namespace blink {
@@ -14,12 +14,12 @@ namespace blink {
 class DisplayItemClient;
 class GraphicsContext;
 
-using TouchActionRects = Vector<TouchActionRect>;
+using HitTestRects = Vector<HitTestRect>;
 
 struct PLATFORM_EXPORT HitTestData {
-  TouchActionRects touch_action_rects;
-  Region wheel_event_handler_region;
-  Region non_fast_scrollable_region;
+  HitTestRects touch_action_rects;
+  HitTestRects wheel_event_handler_region;
+  HitTestRects non_fast_scrollable_region;
 
   HitTestData() = default;
   HitTestData(const HitTestData& other)
@@ -36,11 +36,11 @@ struct PLATFORM_EXPORT HitTestData {
   bool operator!=(const HitTestData& rhs) const { return !(*this == rhs); }
 
   // Records a display item for hit testing to ensure a paint chunk exists and
-  // is sized to include touch action rects, then adds the touch action rect to
+  // is sized to include hit test rects, then adds the hit test rect to
   // |HitTestData.touch_action_rects|.
-  static void RecordTouchActionRect(GraphicsContext&,
-                                    const DisplayItemClient&,
-                                    const TouchActionRect&);
+  static void RecordHitTestRect(GraphicsContext&,
+                                const DisplayItemClient&,
+                                const HitTestRect&);
 };
 
 }  // namespace blink

third_party/blink/renderer/platform/graphics/paint/paint_chunk.cc

@@ -30,19 +30,25 @@ String PaintChunk::ToString() const {
       properties.ToString().Ascii().data(), bounds.ToString().Ascii().data(),
       known_to_be_opaque);
   if (hit_test_data) {
-    ret_val.append(
-        String::Format(", touch_action_rects=(%u), "
-                       "wheel_event_handler_region=(%s) "
-                       "non_fast_scrollable_region=(%s))",
-                       hit_test_data->touch_action_rects.size(),
-                       hit_test_data->wheel_event_handler_region.Bounds()
-                           .ToString()
-                           .Ascii()
-                           .data(),
-                       hit_test_data->non_fast_scrollable_region.Bounds()
-                           .ToString()
-                           .Ascii()
-                           .data()));
+    ret_val.append(String::Format(
+        ", touch_action_rects=(rects: %u, bounds: %s), "
+        "wheel_event_handler_region=(rects: %u, bounds: %s), "
+        "non_fast_scrollable_region=(rects: %u, bounds: %s))",
+        hit_test_data->touch_action_rects.size(),
+        HitTestRect::GetBounds(hit_test_data->touch_action_rects)
+            .ToString()
+            .Ascii()
+            .data(),
+        hit_test_data->wheel_event_handler_region.size(),
+        HitTestRect::GetBounds(hit_test_data->wheel_event_handler_region)
+            .ToString()
+            .Ascii()
+            .data(),
+        hit_test_data->non_fast_scrollable_region.size(),
+        HitTestRect::GetBounds(hit_test_data->non_fast_scrollable_region)
+            .ToString()
+            .Ascii()
+            .data()));
   } else {
     ret_val.append(")");
   }

third_party/blink/renderer/platform/graphics/paint/paint_chunk.h

@@ -78,8 +78,8 @@ struct PLATFORM_EXPORT PaintChunk {
     size_t total_size = sizeof(*this);
     if (hit_test_data) {
       total_size += sizeof(*hit_test_data);
-      total_size += hit_test_data->touch_action_rects.capacity() *
-                    sizeof(TouchActionRect);
+      total_size +=
+          hit_test_data->touch_action_rects.capacity() * sizeof(HitTestRect);
     }
     return total_size;
   }