react-native 0.68.1 → 0.69.0-rc.1

package/ReactCommon/react/renderer/components/view/primitives.h

@@ -7,17 +7,67 @@
 
 #pragma once
 
-#include <butter/optional.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
+
 #include <array>
+#include <bitset>
 #include <cmath>
+#include <optional>
 
 namespace facebook {
 namespace react {
 
 enum class PointerEventsMode { Auto, None, BoxNone, BoxOnly };
 
+struct ViewEvents {
+  std::bitset<32> bits{};
+
+  enum class Offset : std::size_t {
+    // Pointer events
+    PointerEnter = 0,
+    PointerMove = 1,
+    PointerLeave = 2,
+
+    // PanResponder callbacks
+    MoveShouldSetResponder = 3,
+    MoveShouldSetResponderCapture = 4,
+    StartShouldSetResponder = 5,
+    StartShouldSetResponderCapture = 6,
+    ResponderGrant = 7,
+    ResponderReject = 8,
+    ResponderStart = 9,
+    ResponderEnd = 10,
+    ResponderRelease = 11,
+    ResponderMove = 12,
+    ResponderTerminate = 13,
+    ResponderTerminationRequest = 14,
+    ShouldBlockNativeResponder = 15,
+
+    // Touch events
+    TouchStart = 16,
+    TouchMove = 17,
+    TouchEnd = 18,
+    TouchCancel = 19,
+  };
+
+  constexpr bool operator[](const Offset offset) const {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  std::bitset<32>::reference operator[](const Offset offset) {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+};
+
+inline static bool operator==(ViewEvents const &lhs, ViewEvents const &rhs) {
+  return lhs.bits == rhs.bits;
+}
+
+inline static bool operator!=(ViewEvents const &lhs, ViewEvents const &rhs) {
+  return lhs.bits != rhs.bits;
+}
+
 enum class BackfaceVisibility { Auto, Visible, Hidden };
 
 enum class BorderStyle { Solid, Dotted, Dashed };
@@ -25,7 +75,7 @@ enum class BorderStyle { Solid, Dotted, Dashed };
 template <typename T>
 struct CascadedRectangleEdges {
   using Counterpart = RectangleEdges<T>;
-  using OptionalT = butter::optional<T>;
+  using OptionalT = std::optional<T>;
 
   OptionalT left{};
   OptionalT top{};
@@ -86,7 +136,7 @@ struct CascadedRectangleEdges {
 template <typename T>
 struct CascadedRectangleCorners {
   using Counterpart = RectangleCorners<T>;
-  using OptionalT = butter::optional<T>;
+  using OptionalT = std::optional<T>;
 
   OptionalT topLeft{};
   OptionalT topRight{};
@@ -178,5 +228,48 @@ struct BorderMetrics {
   }
 };
 
+#ifdef ANDROID
+
+struct NativeDrawable {
+  enum class Kind {
+    Ripple,
+    ThemeAttr,
+  };
+
+  struct Ripple {
+    std::optional<int32_t> color{};
+    bool borderless{false};
+    std::optional<Float> rippleRadius{};
+
+    bool operator==(const Ripple &rhs) const {
+      return std::tie(this->color, this->borderless, this->rippleRadius) ==
+          std::tie(rhs.color, rhs.borderless, rhs.rippleRadius);
+    }
+  };
+
+  Kind kind;
+  std::string themeAttr;
+  Ripple ripple;
+
+  bool operator==(const NativeDrawable &rhs) const {
+    if (this->kind != rhs.kind)
+      return false;
+    switch (this->kind) {
+      case Kind::ThemeAttr:
+        return this->themeAttr == rhs.themeAttr;
+      case Kind::Ripple:
+        return this->ripple == rhs.ripple;
+    }
+  }
+
+  bool operator!=(const NativeDrawable &rhs) const {
+    return !(*this == rhs);
+  }
+
+  ~NativeDrawable() = default;
+};
+
+#endif
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/components/view/propsConversions.h

@@ -11,6 +11,8 @@
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/propsConversions.h>
 
+#include <optional>
+
 namespace facebook {
 namespace react {
 
@@ -463,5 +465,194 @@ static inline CascadedRectangleEdges<T> convertRawProp(
   return result;
 }
 
+static inline ViewEvents convertRawProp(
+    const PropsParserContext &context,
+    RawProps const &rawProps,
+    ViewEvents const &sourceValue,
+    ViewEvents const &defaultValue) {
+  ViewEvents result{};
+  using Offset = ViewEvents::Offset;
+
+  result[Offset::PointerEnter] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerEnter",
+      sourceValue[Offset::PointerEnter],
+      defaultValue[Offset::PointerEnter]);
+  result[Offset::PointerMove] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerMove",
+      sourceValue[Offset::PointerMove],
+      defaultValue[Offset::PointerMove]);
+  result[Offset::PointerLeave] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerLeave",
+      sourceValue[Offset::PointerLeave],
+      defaultValue[Offset::PointerLeave]);
+
+  // PanResponder callbacks
+  result[Offset::MoveShouldSetResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onMoveShouldSetResponder",
+      sourceValue[Offset::MoveShouldSetResponder],
+      defaultValue[Offset::MoveShouldSetResponder]);
+  result[Offset::MoveShouldSetResponderCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onMoveShouldSetResponderCapture",
+      sourceValue[Offset::MoveShouldSetResponderCapture],
+      defaultValue[Offset::MoveShouldSetResponderCapture]);
+  result[Offset::StartShouldSetResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onStartShouldSetResponder",
+      sourceValue[Offset::StartShouldSetResponder],
+      defaultValue[Offset::StartShouldSetResponder]);
+  result[Offset::StartShouldSetResponderCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onStartShouldSetResponderCapture",
+      sourceValue[Offset::StartShouldSetResponderCapture],
+      defaultValue[Offset::StartShouldSetResponderCapture]);
+  result[Offset::ResponderGrant] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderGrant",
+      sourceValue[Offset::ResponderGrant],
+      defaultValue[Offset::ResponderGrant]);
+  result[Offset::ResponderReject] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderReject",
+      sourceValue[Offset::ResponderReject],
+      defaultValue[Offset::ResponderReject]);
+  result[Offset::ResponderStart] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderStart",
+      sourceValue[Offset::ResponderStart],
+      defaultValue[Offset::ResponderStart]);
+  result[Offset::ResponderEnd] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderEnd",
+      sourceValue[Offset::ResponderEnd],
+      defaultValue[Offset::ResponderEnd]);
+  result[Offset::ResponderRelease] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderRelease",
+      sourceValue[Offset::ResponderRelease],
+      defaultValue[Offset::ResponderRelease]);
+  result[Offset::ResponderMove] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderMove",
+      sourceValue[Offset::ResponderMove],
+      defaultValue[Offset::ResponderMove]);
+  result[Offset::ResponderTerminate] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderTerminate",
+      sourceValue[Offset::ResponderTerminate],
+      defaultValue[Offset::ResponderTerminate]);
+  result[Offset::ResponderTerminationRequest] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderTerminationRequest",
+      sourceValue[Offset::ResponderTerminationRequest],
+      defaultValue[Offset::ResponderTerminationRequest]);
+  result[Offset::ShouldBlockNativeResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onShouldBlockNativeResponder",
+      sourceValue[Offset::ShouldBlockNativeResponder],
+      defaultValue[Offset::ShouldBlockNativeResponder]);
+
+  // Touch events
+  result[Offset::TouchStart] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchStart",
+      sourceValue[Offset::TouchStart],
+      defaultValue[Offset::TouchStart]);
+  result[Offset::TouchMove] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchMove",
+      sourceValue[Offset::TouchMove],
+      defaultValue[Offset::TouchMove]);
+  result[Offset::TouchEnd] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchEnd",
+      sourceValue[Offset::TouchEnd],
+      defaultValue[Offset::TouchEnd]);
+  result[Offset::TouchCancel] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchCancel",
+      sourceValue[Offset::TouchCancel],
+      defaultValue[Offset::TouchCancel]);
+
+  return result;
+}
+
+#ifdef ANDROID
+
+static inline void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    NativeDrawable &result) {
+  auto map = (butter::map<std::string, RawValue>)rawValue;
+
+  auto typeIterator = map.find("type");
+  react_native_assert(
+      typeIterator != map.end() && typeIterator->second.hasType<std::string>());
+  std::string type = (std::string)typeIterator->second;
+
+  if (type == "ThemeAttrAndroid") {
+    auto attrIterator = map.find("attribute");
+    react_native_assert(
+        attrIterator != map.end() &&
+        attrIterator->second.hasType<std::string>());
+
+    result = NativeDrawable{
+        .kind = NativeDrawable::Kind::ThemeAttr,
+        .themeAttr = (std::string)attrIterator->second,
+    };
+  } else if (type == "RippleAndroid") {
+    auto color = map.find("color");
+    auto borderless = map.find("borderless");
+    auto rippleRadius = map.find("rippleRadius");
+
+    result = NativeDrawable{
+        .kind = NativeDrawable::Kind::Ripple,
+        .ripple =
+            NativeDrawable::Ripple{
+                .color = color != map.end() && color->second.hasType<int32_t>()
+                    ? (int32_t)color->second
+                    : std::optional<int32_t>{},
+                .borderless = borderless != map.end() &&
+                        borderless->second.hasType<bool>()
+                    ? (bool)borderless->second
+                    : false,
+                .rippleRadius = rippleRadius != map.end() &&
+                        rippleRadius->second.hasType<Float>()
+                    ? (Float)rippleRadius->second
+                    : std::optional<Float>{},
+            },
+    };
+  } else {
+    LOG(ERROR) << "Unknown native drawable type: " << type;
+    react_native_assert(false);
+  }
+}
+
+#endif
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/components/view/tests/LayoutTest.cpp

@@ -17,6 +17,9 @@
 namespace facebook {
 namespace react {
 
+// Note: the (x, y) origin is always relative to the parent node. You may use
+// P482342650 to re-create this test case in playground.
+
 //  *******************************************************┌─ABCD:────┐****
 //  *******************************************************│ {70,-50} │****
 //  *******************************************************│ {30,60}  │****
@@ -43,6 +46,8 @@ namespace react {
 //  ***********************│          │************************************
 //  ***********************└──────────┘************************************
 
+enum TestCase { AS_IS, CLIPPING, TRANSFORM_SCALE, TRANSFORM_TRANSLATE };
+
 class LayoutTest : public ::testing::Test {
  protected:
   ComponentBuilder builder_;
@@ -55,7 +60,7 @@ class LayoutTest : public ::testing::Test {
 
   LayoutTest() : builder_(simpleComponentBuilder()) {}
 
-  void initialize(bool enforceClippingForABC) {
+  void initialize(TestCase testCase) {
     // clang-format off
     auto element =
         Element<RootShadowNode>()
@@ -73,8 +78,9 @@ class LayoutTest : public ::testing::Test {
           .children({
             Element<ViewShadowNode>()
               .reference(viewShadowNodeA_)
+              .tag(2)
               .props([] {
-                auto sharedProps = std::make_shared<ViewProps>();
+                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                 auto &props = *sharedProps;
                 auto &yogaStyle = props.yogaStyle;
                 yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -85,8 +91,9 @@ class LayoutTest : public ::testing::Test {
               .children({
                 Element<ViewShadowNode>()
                   .reference(viewShadowNodeAB_)
-                  .props([] {
-                    auto sharedProps = std::make_shared<ViewProps>();
+                  .tag(3)
+                  .props([=] {
+                    auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                     auto &props = *sharedProps;
                     auto &yogaStyle = props.yogaStyle;
                     yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -94,17 +101,26 @@ class LayoutTest : public ::testing::Test {
                     yogaStyle.position()[YGEdgeTop] = YGValue{10, YGUnitPoint};
                     yogaStyle.dimensions()[YGDimensionWidth] = YGValue{30, YGUnitPoint};
                     yogaStyle.dimensions()[YGDimensionHeight] = YGValue{90, YGUnitPoint};
+
+                    if (testCase == TRANSFORM_SCALE) {
+                      props.transform = props.transform * Transform::Scale(2, 2, 1);
+                    }
+
+                    if (testCase == TRANSFORM_TRANSLATE) {
+                      props.transform = props.transform * Transform::Translate(10, 10, 0);
+                    }
                     return sharedProps;
                   })
                   .children({
                     Element<ViewShadowNode>()
                       .reference(viewShadowNodeABC_)
+                      .tag(4)
                       .props([=] {
-                        auto sharedProps = std::make_shared<ViewProps>();
+                        auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                         auto &props = *sharedProps;
                         auto &yogaStyle = props.yogaStyle;
 
-                        if (enforceClippingForABC) {
+                        if (testCase == CLIPPING) {
                           yogaStyle.overflow() = YGOverflowHidden;
                         }
 
@@ -118,8 +134,9 @@ class LayoutTest : public ::testing::Test {
                       .children({
                         Element<ViewShadowNode>()
                           .reference(viewShadowNodeABCD_)
+                          .tag(5)
                           .props([] {
-                            auto sharedProps = std::make_shared<ViewProps>();
+                            auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                             auto &props = *sharedProps;
                             auto &yogaStyle = props.yogaStyle;
                             yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -132,8 +149,9 @@ class LayoutTest : public ::testing::Test {
                       }),
                     Element<ViewShadowNode>()
                       .reference(viewShadowNodeABE_)
+                      .tag(6)
                       .props([] {
-                        auto sharedProps = std::make_shared<ViewProps>();
+                        auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                         auto &props = *sharedProps;
                         auto &yogaStyle = props.yogaStyle;
                         yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -154,32 +172,191 @@ class LayoutTest : public ::testing::Test {
   }
 };
 
+// Test the layout as described above with no extra changes
 TEST_F(LayoutTest, overflowInsetTest) {
-  initialize(false);
+  initialize(AS_IS);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
 
-  auto layoutMetrics = viewShadowNodeA_->getLayoutMetrics();
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
 
-  EXPECT_EQ(layoutMetrics.frame.size.width, 50);
-  EXPECT_EQ(layoutMetrics.frame.size.height, 50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -30);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -80);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -50);
 
-  EXPECT_EQ(layoutMetrics.overflowInset.left, -50);
-  EXPECT_EQ(layoutMetrics.overflowInset.top, -30);
-  EXPECT_EQ(layoutMetrics.overflowInset.right, -80);
-  EXPECT_EQ(layoutMetrics.overflowInset.bottom, -50);
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
 }
 
+// Test when box ABC has clipping (aka overflow hidden)
 TEST_F(LayoutTest, overflowInsetWithClippingTest) {
-  initialize(true);
+  initialize(CLIPPING);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, 0);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -80);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -50);
+
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
+}
+
+// Test when box AB translate (10, 10, 0) in transform. The parent node's
+// overflowInset will be affected, but the transformed node and its child nodes
+// are not affected. Here is an example:
+//
+//      ┌────────────────┐                  ┌────────────────┐
+//      │Original Layout │                  │  Translate AB  │
+//      └────────────────┘                  └────────────────┘
+//                                                          ─────▶
+// ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ┐      ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ─ ┐
+//         │ A        │                       │ A        │
+// │       │          │        │      │       │          │          │
+//  ─ ─ ─ ─│─ ─ ─┌───┐┼ ─ ─ ─ ─               │          │
+// │       │     │AB ││        │      │ ┌ ─ ─ ┼ ─ ─ ─ ┬──┴┬ ─ ─ ─ ─ ┤
+//         └─────┤   ├┘                       └───────┤AB │
+// │             │┌──┴─────────┤      │ │             │   │         │
+//               ││ABC         │                      │┌──┴─────────┐
+// │             │└──┬─────────┤    │ │ │             ││ABC         │
+// ┌───ABD───────┴─┐ │              │                 │└──┬─────────┘
+// ├─────────────┬─┘ │         │    │ │ ├───ABD───────┴─┐ │         │
+//  ─ ─ ─ ─ ─ ─ ─└───┘─ ─ ─ ─ ─     ▼   └─────────────┬─┘ │
+//                                    └ ┴ ─ ─ ─ ─ ─ ─ ┴───┴ ─ ─ ─ ─ ┘
+
+TEST_F(LayoutTest, overflowInsetTransformTranslateTest) {
+  initialize(TRANSFORM_TRANSLATE);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node
+  // The top/left values are NOT changing as overflowInset is union of before
+  // and after transform layout. In this case, we move to the right and bottom,
+  // so the left and top is not changing, while right and bottom values are
+  // increased.
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -30);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -60);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node with translate transform
+  EXPECT_EQ(layoutMetricsAB.overflowInset.left, -60);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.bottom, 0);
+
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  // No change on child node
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
+}
+
+// Test when box AB scaled 2X in transform. The parent node's overflowInset will
+// be affected. However, the transformed node and its child nodes only appears
+// to be affected (dashed arrow). Since all transform is cosmetic only, the
+// actual values are NOT changed. It will be converted later when mapping the
+// values to pixels during rendering. Here is an example:
+//
+//      ┌────────────────┐                    ┌────────────────┐
+//      │Original Layout │                    │    Scale AB    │
+//      └────────────────┘                    └────────────────┘
+//                                                             ─────▶
+// ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ┐     ┌ ─ ─ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ─ ┐
+//         │ A        │                          │ A        │
+// │       │          │        │     ├ ─ ─ ─ ─ ─ ┼ ─ ─┌─────┤─ ─ ─ ─ ─ ┤
+//  ─ ─ ─ ─│─ ─ ─┌───┐┼ ─ ─ ─ ─                  │    │AB   │  ─ ─ ─▶
+// │       │     │AB ││        │     │           │    │     │          │
+//         └─────┤   ├┘                          └────┤     │
+// │             │┌──┴─────────┤     │                │ ┌───┴──────────┤
+//               ││ABC         │                      │ │ABC           │
+// │             │└──┬─────────┤   │ │                │ │              │
+// ┌───ABD───────┴─┐ │             │                  │ └───┬──────────┘
+// ├─────────────┬─┘ │         │   │ ├────────────────┴──┐  │          │
+//  ─ ─ ─ ─ ─ ─ ─└───┘─ ─ ─ ─ ─    ▼ │      ABD          │  │
+//                                   ├────────────────┬──┘  │          │
+//                                    ─ ─ ─ ─ ─ ─ ─ ─ ┴─────┴ ─ ─ ─ ─ ─
+
+TEST_F(LayoutTest, overflowInsetTransformScaleTest) {
+  initialize(TRANSFORM_SCALE);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node when a child view scale up
+  // Note that AB scale up from its center point. The numbers are calculated
+  // assuming AB's center point is not moving.
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -125);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -115);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -185);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -95);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  // The frame of box AB won't actually scale up. The transform matrix is
+  // purely cosmetic and should apply later in mounting phase.
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node with scale transform. This may sound a bit
+  // surprising, but the overflowInset values will be scaled up via pixel
+  // density ratio along with width/height of the view. When we do hit-testing,
+  // the overflowInset value will appears to be doubled as expected.
+  EXPECT_EQ(layoutMetricsAB.overflowInset.left, -60);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.bottom, 0);
 
-  auto layoutMetrics = viewShadowNodeA_->getLayoutMetrics();
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
 
-  EXPECT_EQ(layoutMetrics.frame.size.width, 50);
-  EXPECT_EQ(layoutMetrics.frame.size.height, 50);
+  // The frame of box ABC won't actually scale up. The transform matrix is
+  // purely cosmatic and should apply later in mounting phase.
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
 
-  EXPECT_EQ(layoutMetrics.overflowInset.left, -50);
-  EXPECT_EQ(layoutMetrics.overflowInset.top, 0);
-  EXPECT_EQ(layoutMetrics.overflowInset.right, -80);
-  EXPECT_EQ(layoutMetrics.overflowInset.bottom, -50);
+  // The overflowInset of ABC won't change either. This may sound a bit
+  // surprising, but the overflowInset values will be scaled up via pixel
+  // density ratio along with width/height of the view. When we do hit-testing,
+  // the overflowInset value will appears to be doubled as expected.
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
 }
 
 } // namespace react

package/ReactCommon/react/renderer/components/view/tests/ViewTest.cpp

@@ -49,7 +49,7 @@ class YogaDirtyFlagTest : public ::testing::Test {
                     /*
                      * Some non-default props.
                      */
-                    auto mutableViewProps = std::make_shared<ViewProps>();
+                    auto mutableViewProps = std::make_shared<ViewShadowNodeProps>();
                     auto &props = *mutableViewProps;
                     props.nativeId = "native Id";
                     props.opacity = 0.5;
@@ -111,7 +111,7 @@ TEST_F(YogaDirtyFlagTest, changingNonLayoutSubPropsMustNotDirtyYogaNode) {
    */
   auto newRootShadowNode = rootShadowNode_->cloneTree(
       innerShadowNode_->getFamily(), [](ShadowNode const &oldShadowNode) {
-        auto viewProps = std::make_shared<ViewProps>();
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
         auto &props = *viewProps;
 
         props.nativeId = "some new native Id";
@@ -135,7 +135,7 @@ TEST_F(YogaDirtyFlagTest, changingLayoutSubPropsMustDirtyYogaNode) {
    */
   auto newRootShadowNode = rootShadowNode_->cloneTree(
       innerShadowNode_->getFamily(), [](ShadowNode const &oldShadowNode) {
-        auto viewProps = std::make_shared<ViewProps>();
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
         auto &props = *viewProps;
 
         props.yogaStyle.alignContent() = YGAlignBaseline;

package/ReactCommon/react/renderer/core/Android.mk

@@ -12,12 +12,12 @@ LOCAL_MODULE := react_render_core
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../
 
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
+LOCAL_SRC_FILES := $(subst $(LOCAL_PATH)/,,$(LOCAL_SRC_FILES))
 
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../
 
 LOCAL_SHARED_LIBRARIES := \
-  libfolly_futures \
-  libfolly_json \
+  libfolly_runtime \
   libglog \
   libjsi \
   libreact_debug \