Round node dimensions in double so far-off nodes keep their full size (#2037)

* Round node dimensions in double so far-off nodes keep their full size

A node's rounded width and height are the difference of its two rounded
absolute edges. roundValueToPixelGrid returns float, so that difference was
taken in float; far from the origin a float has fewer bits than a pixel, and
when the two edges fall on either side of a power of two they are quantized
differently. A measured text node spanning y = 2048 on a 3x screen came out
43.9998779 tall instead of 44, one float step short of the two lines it was
measured at, and the text renderer then dropped the last line.

Round in double and subtract before narrowing to float. The public
roundValueToPixelGrid keeps its signature.

* Cover both fractions on either side of 1024, 2048 and 4096 in the rounding test

On the previous rounding each of these came out off by a float step
(44.00006, 43.99994, 43.99988, 43.99988 and 43.99976); all are exactly 44
now.

* Remove comments

---------

Co-authored-by: nishan (o^▽^o) <nishanbende@gmail.com>

Author: ybelakov

tests/YGRoundingLargeOffsetTest.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+#include <yoga/Yoga.h>
+
+static YGSize _measureTwoLines(
+    YGNodeConstRef /*node*/,
+    float /*width*/,
+    YGMeasureMode /*widthMode*/,
+    float /*height*/,
+    YGMeasureMode /*heightMode*/) {
+  return YGSize{292.0f, 44.0f};
+}
+
+TEST(YogaTest, rounding_measured_height_is_exact_across_float_steps) {
+  for (const float spacer :
+       {1012.0f + 1.0f / 3.0f,
+        1012.0f + 2.0f / 3.0f,
+        2004.0f + 1.0f / 3.0f,
+        2028.0f + 2.0f / 3.0f,
+        4052.0f + 2.0f / 3.0f}) {
+    YGConfigRef config = YGConfigNew();
+    YGConfigSetPointScaleFactor(config, 3.0f);
+
+    YGNodeRef root = YGNodeNewWithConfig(config);
+    YGNodeStyleSetWidth(root, 300);
+
+    YGNodeRef spacerNode = YGNodeNewWithConfig(config);
+    YGNodeStyleSetHeight(spacerNode, spacer);
+    YGNodeInsertChild(root, spacerNode, 0);
+
+    YGNodeRef text = YGNodeNewWithConfig(config);
+    YGNodeSetMeasureFunc(text, _measureTwoLines);
+    YGNodeInsertChild(root, text, 1);
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+
+    ASSERT_EQ(44.0f, YGNodeLayoutGetHeight(text)) << "spacer " << spacer;
+
+    YGNodeFreeRecursive(root);
+    YGConfigFree(config);
+  }
+}

yoga/algorithm/PixelGrid.cpp

@@ -12,7 +12,9 @@
 
 namespace facebook::yoga {
 
-float roundValueToPixelGrid(
+namespace {
+
+double roundValueToPixelGridDouble(
     const double value,
     const double pointScaleFactor,
     const bool forceCeil,
@@ -60,7 +62,18 @@ float roundValueToPixelGrid(
   }
   return (std::isnan(scaledValue) || std::isnan(pointScaleFactor))
       ? YGUndefined
-      : (float)(scaledValue / pointScaleFactor);
+      : scaledValue / pointScaleFactor;
+}
+
+} // namespace
+
+float roundValueToPixelGrid(
+    const double value,
+    const double pointScaleFactor,
+    const bool forceCeil,
+    const bool forceFloor) {
+  return static_cast<float>(roundValueToPixelGridDouble(
+      value, pointScaleFactor, forceCeil, forceFloor));
 }
 
 void roundLayoutResultsToPixelGrid(
@@ -109,23 +122,25 @@ void roundLayoutResultsToPixelGrid(
 
     node->getLayout().setDimension(
         Dimension::Width,
-        roundValueToPixelGrid(
-            absoluteNodeRight,
-            pointScaleFactor,
-            (textRounding && hasFractionalWidth),
-            (textRounding && !hasFractionalWidth)) -
-            roundValueToPixelGrid(
-                absoluteNodeLeft, pointScaleFactor, false, textRounding));
+        static_cast<float>(
+            roundValueToPixelGridDouble(
+                absoluteNodeRight,
+                pointScaleFactor,
+                (textRounding && hasFractionalWidth),
+                (textRounding && !hasFractionalWidth)) -
+            roundValueToPixelGridDouble(
+                absoluteNodeLeft, pointScaleFactor, false, textRounding)));
 
     node->getLayout().setDimension(
         Dimension::Height,
-        roundValueToPixelGrid(
-            absoluteNodeBottom,
-            pointScaleFactor,
-            (textRounding && hasFractionalHeight),
-            (textRounding && !hasFractionalHeight)) -
-            roundValueToPixelGrid(
-                absoluteNodeTop, pointScaleFactor, false, textRounding));
+        static_cast<float>(
+            roundValueToPixelGridDouble(
+                absoluteNodeBottom,
+                pointScaleFactor,
+                (textRounding && hasFractionalHeight),
+                (textRounding && !hasFractionalHeight)) -
+            roundValueToPixelGridDouble(
+                absoluteNodeTop, pointScaleFactor, false, textRounding)));
   }
 
   for (yoga::Node* child : node->getChildren()) {