From fdd133e21432a0e2b649d4645519f45384c0cd78 Mon Sep 17 00:00:00 2001 From: Samuel Susla Date: Thu, 30 Jan 2020 15:28:21 -0800 Subject: [PATCH] Prevent getRelativeLayoutMetrics to measure across ShadowNode which is root Summary: Changelog: [Internal] # Analysis Measure returns following values for `frame.y` when tapping item in bottom sheet. Fabric 412.33331298828125. Paper 49. In Paper, the frame.y returned is the position of tapped item in bottom sheet relative to the bottom sheet itself, which is correct. This can happen in both BottomSheet and Modal. # Why it happens? In [UIManager.getRelativeLayoutMetrics](https://our.intern.facebook.com/intern/diffusion/FBS/browse/master/xplat/js/react-native-github/ReactCommon/fabric/uimanager/UIManager.cpp?commit=a372cf516ba1245ad9462e68376ee759c118a884&lines=172-181) if `ancestorShadowNode` is nullptr we populate `ancestorShadowNode` with `rootShadowNode` for the surface. Problem is that BottomSheet that is presented, is not a separate surface. This means that we climb up the shadow node hierarchy all the way to root shadow node and keep adding offsets. Even though we should stop when we hit shadow node representing BottomSheet. # How could be this fixed? I think we should add a new shadow node trait that would mark node as root node. As we are traversing the shadow node tree upwards and adding offset of that node, once we hit a node that is "anchor", we would immediately stop the traversal. This solution is inspired by Paper where the node representing BottomSheet has a special flag which marks it as "root" node. accepttoship Reviewed By: JoshuaGross, mdvacca Differential Revision: D19640454 fbshipit-source-id: bde623b1f41a9745a41f0aada7221bf924fad453 --- .../core/layout/LayoutableShadowNode.cpp | 5 ++ .../fabric/core/shadownode/ShadowNodeTraits.h | 6 ++ .../core/tests/LayoutableShadowNodeTest.cpp | 55 +++++++++++++++---- 3 files changed, 56 insertions(+), 10 deletions(-) diff --git a/ReactCommon/fabric/core/layout/LayoutableShadowNode.cpp b/ReactCommon/fabric/core/layout/LayoutableShadowNode.cpp index cad2cb7e231..b88582b458f 100644 --- a/ReactCommon/fabric/core/layout/LayoutableShadowNode.cpp +++ b/ReactCommon/fabric/core/layout/LayoutableShadowNode.cpp @@ -43,6 +43,11 @@ static LayoutMetrics calculateOffsetForLayoutMetrics( for (auto it = ancestors.rbegin(); it != ancestors.rend() - 1; ++it) { auto ¤tShadowNode = it->first.get(); + if (currentShadowNode.getTraits().check( + ShadowNodeTraits::Trait::RootNodeKind)) { + break; + } + auto layoutableCurrentShadowNode = dynamic_cast(¤tShadowNode); diff --git a/ReactCommon/fabric/core/shadownode/ShadowNodeTraits.h b/ReactCommon/fabric/core/shadownode/ShadowNodeTraits.h index 5fe7c69c6f2..08f9a6ac3b4 100644 --- a/ReactCommon/fabric/core/shadownode/ShadowNodeTraits.h +++ b/ReactCommon/fabric/core/shadownode/ShadowNodeTraits.h @@ -41,6 +41,12 @@ class ShadowNodeTraits { // Inherits `BaseTextShadowNode`. TextKind = 1 << 3, + // Used when calculating relative layout in + // LayoutableShadowNode::getRelativeLayoutMetrics. This trait marks node as + // root, so when calculating relative layout, the calculation will not + // traverse beyond this node. See T61257516 for details. + RootNodeKind = 1 << 4, + // Inherits `YogaLayoutableShadowNode` and enforces that the `YGNode` is a // leaf. LeafYogaNode = 1 << 10, diff --git a/ReactCommon/fabric/core/tests/LayoutableShadowNodeTest.cpp b/ReactCommon/fabric/core/tests/LayoutableShadowNodeTest.cpp index 3a7b7c4acbc..689f6d16d91 100644 --- a/ReactCommon/fabric/core/tests/LayoutableShadowNodeTest.cpp +++ b/ReactCommon/fabric/core/tests/LayoutableShadowNodeTest.cpp @@ -31,7 +31,7 @@ class LayoutableShadowNodeTest : public ::testing::Test { familyA, ShadowNodeTraits{}); - auto familyB = std::make_shared( + auto familyAA = std::make_shared( ShadowNodeFamilyFragment{ /* .tag = */ 10, /* .surfaceId = */ 1, @@ -39,20 +39,41 @@ class LayoutableShadowNodeTest : public ::testing::Test { }, componentDescriptor_); - nodeB_ = std::make_shared( + auto traits = TestShadowNode::BaseTraits(); + traits.set(ShadowNodeTraits::Trait::RootNodeKind); + + nodeAA_ = std::make_shared( ShadowNodeFragment{ /* .props = */ std::make_shared(), /* .children = */ ShadowNode::emptySharedShadowNodeSharedList(), }, - familyB, + familyAA, + traits); + + auto familyAAA = std::make_shared( + ShadowNodeFamilyFragment{ + /* .tag = */ 11, + /* .surfaceId = */ 1, + /* .eventEmitter = */ nullptr, + }, + componentDescriptor_); + + nodeAAA_ = std::make_shared( + ShadowNodeFragment{ + /* .props = */ std::make_shared(), + /* .children = */ ShadowNode::emptySharedShadowNodeSharedList(), + }, + familyAAA, ShadowNodeTraits{}); - nodeA_->appendChild(nodeB_); + nodeA_->appendChild(nodeAA_); + nodeAA_->appendChild(nodeAAA_); } std::shared_ptr eventDispatcher_; std::shared_ptr nodeA_; - std::shared_ptr nodeB_; + std::shared_ptr nodeAA_; + std::shared_ptr nodeAAA_; TestComponentDescriptor componentDescriptor_; }; @@ -61,9 +82,9 @@ TEST_F(LayoutableShadowNodeTest, relativeLayoutMetrics) { layoutMetrics.frame.origin = {10, 20}; layoutMetrics.frame.size = {100, 200}; nodeA_->setLayoutMetrics(layoutMetrics); - nodeB_->setLayoutMetrics(layoutMetrics); + nodeAA_->setLayoutMetrics(layoutMetrics); - auto relativeLayoutMetrics = nodeB_->getRelativeLayoutMetrics(*nodeA_, {}); + auto relativeLayoutMetrics = nodeAA_->getRelativeLayoutMetrics(*nodeA_, {}); // A is a parent to B, A has origin {10, 10}, B has origin {10, 10}. // B's relative origin to A should be {10, 10}. @@ -89,15 +110,29 @@ TEST_F(LayoutableShadowNodeTest, relativeLayoutMetricsOnSameNode) { TEST_F(LayoutableShadowNodeTest, relativeLayourMetricsOnClonedNode) { // B is cloned and mutated. auto nodeBRevision2 = std::static_pointer_cast( - componentDescriptor_.cloneShadowNode(*nodeB_, ShadowNodeFragment{})); + componentDescriptor_.cloneShadowNode(*nodeAA_, ShadowNodeFragment{})); auto layoutMetrics = EmptyLayoutMetrics; layoutMetrics.frame.size = {500, 600}; nodeBRevision2->setLayoutMetrics(layoutMetrics); - nodeA_->replaceChild(*nodeB_, nodeBRevision2); + nodeA_->replaceChild(*nodeAA_, nodeBRevision2); // Even if we ask old ShadowNode for its relative layoutMetrics, it needs to // return correct, new layoutMetrics. D19433873 has more about the issue. - auto newRelativeLayoutMetrics = nodeB_->getRelativeLayoutMetrics(*nodeA_, {}); + auto newRelativeLayoutMetrics = + nodeAA_->getRelativeLayoutMetrics(*nodeA_, {}); EXPECT_EQ(newRelativeLayoutMetrics.frame.size.width, 500); EXPECT_EQ(newRelativeLayoutMetrics.frame.size.height, 600); } + +TEST_F(LayoutableShadowNodeTest, relativeLayoutMetricsOnSameNode2) { + auto layoutMetrics = EmptyLayoutMetrics; + nodeA_->setLayoutMetrics(layoutMetrics); + layoutMetrics.frame.origin = {10, 10}; + nodeAA_->setLayoutMetrics(layoutMetrics); + nodeAAA_->setLayoutMetrics(layoutMetrics); + + auto relativeLayoutMetrics = nodeAAA_->getRelativeLayoutMetrics(*nodeA_, {}); + + EXPECT_EQ(relativeLayoutMetrics.frame.origin.x, 10); + EXPECT_EQ(relativeLayoutMetrics.frame.origin.y, 10); +}