Override getClipBounds to expose overflow clipping to the framework (#56606)

Summary:
Pull Request resolved: #56606

Override `getClipBounds()` on ReactViewGroup to return the padding box rect when
`overflow` is hidden or scroll, gated behind the `syncAndroidClipBoundsWithOverflow`
feature flag.

This exposes the view's clipping behavior to the Android framework via the standard
`View.getClipBounds()` API:
- `getClipBounds(Rect): Boolean` returns `true` and populates the rect with the
  padding box when overflow is hidden/scroll, or `false` when overflow is visible
- `getClipBounds(): Rect?` returns the padding box rect or `null` respectively

This allows framework-level systems to inspect a view and determine whether it clips
its children by checking `getClipBounds() != null`, and to obtain the actual clipping
region for `getGlobalVisibleRect()` calculations.

## Why not `setClipBounds()`?

An alternative approach would be to call `View.setClipBounds(Rect)` which sets the
`mClipBounds` field directly. This has the advantage of being picked up by AOSP's
`ViewGroup.getChildVisibleRect()` (which reads `mClipBounds` via direct field access
rather than calling `getClipBounds()`). However, `setClipBounds()` also propagates
the clip rect to the RenderNode via `mRenderNode.setClipRect()`, which clips the
view's own rendering — including its borders. It also requires maintaining a Rect
that must be kept in sync across size changes, border width changes, and overflow
changes.

For now, the `getClipBounds()` override is sufficient because harvesting systems
query the method rather than the field. If we find that AOSP's field-based path is
also needed, we can switch to `setClipBounds()` in the future.

Adds `BackgroundStyleApplicator.getPaddingBoxRect()` (internal via buck friend_paths)
which computes the padding box (view bounds minus border insets) reusing the same
border inset resolution logic as `clipToPaddingBox()`.

Changelog: [Internal]

Reviewed By: twasilczyk, javache

Differential Revision: D102353840

fbshipit-source-id: fe1d52e3c000ba1b5e2d21eac75928be24a86645

Author: fabriziocucci

packages/react-native/ReactAndroid/api/ReactAndroid.api

@@ -6457,6 +6457,8 @@ public class com/facebook/react/views/view/ReactViewGroup : android/view/ViewGro
 	protected fun drawChild (Landroid/graphics/Canvas;Landroid/view/View;J)Z
 	public fun endViewTransition (Landroid/view/View;)V
 	public final fun getAxOrderList ()Ljava/util/List;
+	public fun getClipBounds ()Landroid/graphics/Rect;
+	public fun getClipBounds (Landroid/graphics/Rect;)Z
 	public fun getClippingRect (Landroid/graphics/Rect;)V
 	public fun getHitSlopRect ()Landroid/graphics/Rect;
 	public fun getOverflow ()Ljava/lang/String;

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/uimanager/BackgroundStyleApplicator.kt

@@ -465,6 +465,35 @@ public object BackgroundStyleApplicator {
     clipToPaddingBoxWithAntiAliasing(view, canvas, null)
   }
 
+  /**
+   * Populates [outRect] with the padding box rect of the view.
+   *
+   * The padding box is the area within the borders of the view. For views without a
+   * [CompositeBackgroundDrawable] or without borders, this returns the full view bounds.
+   *
+   * This is useful for overriding [View.getClipBounds] to communicate the view's clipping region to
+   * the Android framework (e.g. for [View.getGlobalVisibleRect] calculations).
+   *
+   * @param view The view whose padding box to compute
+   * @param outRect The rect to populate with the padding box bounds
+   */
+  internal fun getPaddingBoxRect(view: View, outRect: Rect) {
+    val composite = getCompositeBackgroundDrawable(view)
+    val computedBorderInsets =
+        composite?.borderInsets?.resolve(composite.layoutDirection, view.context)
+    if (computedBorderInsets == null) {
+      outRect.set(0, 0, view.width, view.height)
+      return
+    }
+
+    val left = (computedBorderInsets.left.dpToPx()).toInt()
+    val top = (computedBorderInsets.top.dpToPx()).toInt()
+    val right = (view.width.toFloat() - computedBorderInsets.right.dpToPx()).toInt()
+    val bottom = (view.height.toFloat() - computedBorderInsets.bottom.dpToPx()).toInt()
+
+    outRect.set(left, top, right, bottom)
+  }
+
   /**
    * Clips the canvas to the padding box of the view.
    *

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.kt

@@ -37,6 +37,7 @@ import com.facebook.react.touch.OnInterceptTouchEventListener
 import com.facebook.react.touch.ReactHitSlopView
 import com.facebook.react.touch.ReactInterceptingViewGroup
 import com.facebook.react.uimanager.BackgroundStyleApplicator.clipToPaddingBox
+import com.facebook.react.uimanager.BackgroundStyleApplicator.getPaddingBoxRect
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBackgroundColor
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderColor
 import com.facebook.react.uimanager.BackgroundStyleApplicator.setBorderRadius
@@ -820,6 +821,39 @@ public open class ReactViewGroup public constructor(context: Context?) :
       invalidate()
     }
 
+  /**
+   * Returns the clip bounds for this view based on the overflow property.
+   *
+   * When overflow is hidden or scroll, returns the padding box rect (the area inside the borders)
+   * so that systems querying [View.getClipBounds] can determine the view's clipping region. Returns
+   * null when overflow is visible (no clipping).
+   */
+  override fun getClipBounds(): Rect? {
+    if (
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
+            _overflow != null &&
+            _overflow != Overflow.VISIBLE
+    ) {
+      val rect = Rect()
+      getPaddingBoxRect(this, rect)
+      return rect
+    }
+    return super.getClipBounds()
+  }
+
+  /** See [getClipBounds]. */
+  override fun getClipBounds(outRect: Rect): Boolean {
+    if (
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
+            _overflow != null &&
+            _overflow != Overflow.VISIBLE
+    ) {
+      getPaddingBoxRect(this, outRect)
+      return true
+    }
+    return super.getClipBounds(outRect)
+  }
+
   override fun setOverflowInset(left: Int, top: Int, right: Int, bottom: Int) {
     if (
         needsIsolatedLayer(this) &&