mirror of
https://github.com/facebook/react-native.git
synced 2025-11-01 09:14:26 +00:00
Joshua Gross
03390d7c87
Summary: During earlier testing I didn't fully realize that Android disables a core bit of View Flattening: Views can be concrete or non-concrete; and their children can be flattened or not. None of these properties are mutually exclusive with each other. Except on Android - that functionality is currently disabled. A View can be either flattened and non-concrete, or non-flat and concrete. So there are some flattening edge-cases hit on iOS but not Android, due to the larger state-space on iOS. To test, I forced Android to align with iOS and tested; and then tested on iOS; and ensured no mounting errors, assertions, or crashes were hit during some specific tests. Changelog: [Internal] Differential Revision: D26298872 fbshipit-source-id: 2f0f78127a7bf057c7cf109005f1dae74f0ff6ba
1520 lines
59 KiB
C++
1520 lines
59 KiB
C++
/*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#include "Differentiator.h"
|
|
|
|
#include <better/map.h>
|
|
#include <better/small_vector.h>
|
|
#include <react/renderer/core/LayoutableShadowNode.h>
|
|
#include <react/renderer/debug/SystraceSection.h>
|
|
#include <algorithm>
|
|
#include "ShadowView.h"
|
|
|
|
// Uncomment this to enable verbose diffing logs, which can be useful for
|
|
// debugging.
|
|
// #define DEBUG_LOGS_DIFFER
|
|
|
|
#ifdef DEBUG_LOGS_DIFFER
|
|
#include <glog/logging.h>
|
|
#define DEBUG_LOGS(code) code
|
|
#else
|
|
#define DEBUG_LOGS(code)
|
|
#endif
|
|
|
|
namespace facebook {
|
|
namespace react {
|
|
|
|
/*
|
|
* Extremely simple and naive implementation of a map.
|
|
* The map is simple but it's optimized for particular constraints that we have
|
|
* here.
|
|
*
|
|
* A regular map implementation (e.g. `std::unordered_map`) has some basic
|
|
* performance guarantees like constant average insertion and lookup complexity.
|
|
* This is nice, but it's *average* complexity measured on a non-trivial amount
|
|
* of data. The regular map is a very complex data structure that using hashing,
|
|
* buckets, multiple comprising operations, multiple allocations and so on.
|
|
*
|
|
* In our particular case, we need a map for `int` to `void *` with a dozen
|
|
* values. In these conditions, nothing can beat a naive implementation using a
|
|
* stack-allocated vector. And this implementation is exactly this: no
|
|
* allocation, no hashing, no complex branching, no buckets, no iterators, no
|
|
* rehashing, no other guarantees. It's crazy limited, unsafe, and performant on
|
|
* a trivial amount of data.
|
|
*
|
|
* Besides that, we also need to optimize for insertion performance (the case
|
|
* where a bunch of views appears on the screen first time); in this
|
|
* implementation, this is as performant as vector `push_back`.
|
|
*/
|
|
template <typename KeyT, typename ValueT, int DefaultSize = 16>
|
|
class TinyMap final {
|
|
public:
|
|
using Pair = std::pair<KeyT, ValueT>;
|
|
using Iterator = Pair *;
|
|
|
|
/**
|
|
* This must strictly only be called from outside of this class.
|
|
*/
|
|
inline Iterator begin() {
|
|
// Force a clean so that iterating over this TinyMap doesn't iterate over
|
|
// erased elements. If all elements erased are at the front of the vector,
|
|
// then we don't need to clean.
|
|
cleanVector(erasedAtFront_ != numErased_);
|
|
|
|
Iterator it = begin_();
|
|
|
|
if (it != nullptr) {
|
|
return it + erasedAtFront_;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
inline Iterator end() {
|
|
// `back()` asserts on the vector being non-empty
|
|
if (vector_.empty() || numErased_ == vector_.size()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return &vector_.back() + 1;
|
|
}
|
|
|
|
inline Iterator find(KeyT key) {
|
|
cleanVector();
|
|
|
|
assert(key != 0);
|
|
|
|
if (begin_() == nullptr) {
|
|
return end();
|
|
}
|
|
|
|
for (auto it = begin_() + erasedAtFront_; it != end(); it++) {
|
|
if (it->first == key) {
|
|
return it;
|
|
}
|
|
}
|
|
|
|
return end();
|
|
}
|
|
|
|
inline void insert(Pair pair) {
|
|
assert(pair.first != 0);
|
|
vector_.push_back(pair);
|
|
}
|
|
|
|
inline void erase(Iterator iterator) {
|
|
// Invalidate tag.
|
|
iterator->first = 0;
|
|
|
|
if (iterator == begin_() + erasedAtFront_) {
|
|
erasedAtFront_++;
|
|
}
|
|
|
|
numErased_++;
|
|
}
|
|
|
|
private:
|
|
/**
|
|
* Same as begin() but doesn't call cleanVector at the beginning.
|
|
*/
|
|
inline Iterator begin_() {
|
|
// `front()` asserts on the vector being non-empty
|
|
if (vector_.empty() || vector_.size() == numErased_) {
|
|
return nullptr;
|
|
}
|
|
|
|
return &vector_.front();
|
|
}
|
|
|
|
/**
|
|
* Remove erased elements from internal vector.
|
|
* We only modify the vector if erased elements are at least half of the
|
|
* vector.
|
|
*/
|
|
inline void cleanVector(bool forceClean = false) {
|
|
if ((numErased_ < (vector_.size() / 2) && !forceClean) || vector_.empty() ||
|
|
numErased_ == 0 || numErased_ == erasedAtFront_) {
|
|
return;
|
|
}
|
|
|
|
if (numErased_ == vector_.size()) {
|
|
vector_.clear();
|
|
} else {
|
|
vector_.erase(
|
|
std::remove_if(
|
|
vector_.begin(),
|
|
vector_.end(),
|
|
[](auto const &item) { return item.first == 0; }),
|
|
vector_.end());
|
|
}
|
|
numErased_ = 0;
|
|
erasedAtFront_ = 0;
|
|
}
|
|
|
|
better::small_vector<Pair, DefaultSize> vector_;
|
|
int numErased_{0};
|
|
int erasedAtFront_{0};
|
|
};
|
|
|
|
/*
|
|
* Sorting comparator for `reorderInPlaceIfNeeded`.
|
|
*/
|
|
static bool shouldFirstPairComesBeforeSecondOne(
|
|
ShadowViewNodePair const &lhs,
|
|
ShadowViewNodePair const &rhs) noexcept {
|
|
return lhs.shadowNode->getOrderIndex() < rhs.shadowNode->getOrderIndex();
|
|
}
|
|
|
|
/*
|
|
* Reorders pairs in-place based on `orderIndex` using a stable sort algorithm.
|
|
*/
|
|
static void reorderInPlaceIfNeeded(ShadowViewNodePair::List &pairs) noexcept {
|
|
if (pairs.size() < 2) {
|
|
return;
|
|
}
|
|
|
|
auto isReorderNeeded = false;
|
|
for (auto const &pair : pairs) {
|
|
if (pair.shadowNode->getOrderIndex() != 0) {
|
|
isReorderNeeded = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isReorderNeeded) {
|
|
return;
|
|
}
|
|
|
|
std::stable_sort(
|
|
pairs.begin(), pairs.end(), &shouldFirstPairComesBeforeSecondOne);
|
|
}
|
|
|
|
static void sliceChildShadowNodeViewPairsRecursivelyV2(
|
|
ShadowViewNodePair::List &pairList,
|
|
Point layoutOffset,
|
|
ShadowNode const &shadowNode) {
|
|
for (auto const &sharedChildShadowNode : shadowNode.getChildren()) {
|
|
auto &childShadowNode = *sharedChildShadowNode;
|
|
|
|
#ifndef ANDROID
|
|
// Temporary disabled on Android because the mounting infrastructure
|
|
// is not fully ready yet.
|
|
if (childShadowNode.getTraits().check(ShadowNodeTraits::Trait::Hidden)) {
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
auto shadowView = ShadowView(childShadowNode);
|
|
auto origin = layoutOffset;
|
|
if (shadowView.layoutMetrics != EmptyLayoutMetrics) {
|
|
origin += shadowView.layoutMetrics.frame.origin;
|
|
shadowView.layoutMetrics.frame.origin += layoutOffset;
|
|
}
|
|
|
|
// This might not be a FormsView, or a FormsStackingContext. We let the
|
|
// differ handle removal of flattened views from the Mounting layer and
|
|
// shuffling their children around.
|
|
bool isConcreteView =
|
|
childShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView);
|
|
bool areChildrenFlattened = !childShadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsStackingContext);
|
|
pairList.push_back(
|
|
{shadowView, &childShadowNode, areChildrenFlattened, isConcreteView});
|
|
|
|
if (!childShadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsStackingContext)) {
|
|
sliceChildShadowNodeViewPairsRecursivelyV2(
|
|
pairList, origin, childShadowNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
ShadowViewNodePair::List sliceChildShadowNodeViewPairsV2(
|
|
ShadowNode const &shadowNode,
|
|
bool allowFlattened) {
|
|
auto pairList = ShadowViewNodePair::List{};
|
|
|
|
if (!shadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsStackingContext) &&
|
|
shadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView) &&
|
|
!allowFlattened) {
|
|
return pairList;
|
|
}
|
|
|
|
sliceChildShadowNodeViewPairsRecursivelyV2(pairList, {0, 0}, shadowNode);
|
|
|
|
// Sorting pairs based on `orderIndex` if needed.
|
|
reorderInPlaceIfNeeded(pairList);
|
|
|
|
// Set list and mountIndex for each after reordering
|
|
size_t mountIndex = 0;
|
|
for (auto &child : pairList) {
|
|
child.mountIndex = (child.isConcreteView ? mountIndex++ : -1);
|
|
}
|
|
|
|
return pairList;
|
|
}
|
|
|
|
/*
|
|
* Before we start to diff, let's make sure all our core data structures are in
|
|
* good shape to deliver the best performance.
|
|
*/
|
|
static_assert(
|
|
std::is_move_constructible<ShadowViewMutation>::value,
|
|
"`ShadowViewMutation` must be `move constructible`.");
|
|
static_assert(
|
|
std::is_move_constructible<ShadowView>::value,
|
|
"`ShadowView` must be `move constructible`.");
|
|
static_assert(
|
|
std::is_move_constructible<ShadowViewNodePair>::value,
|
|
"`ShadowViewNodePair` must be `move constructible`.");
|
|
static_assert(
|
|
std::is_move_constructible<ShadowViewNodePair::List>::value,
|
|
"`ShadowViewNodePair::List` must be `move constructible`.");
|
|
|
|
static_assert(
|
|
std::is_move_assignable<ShadowViewMutation>::value,
|
|
"`ShadowViewMutation` must be `move assignable`.");
|
|
static_assert(
|
|
std::is_move_assignable<ShadowView>::value,
|
|
"`ShadowView` must be `move assignable`.");
|
|
static_assert(
|
|
std::is_move_assignable<ShadowViewNodePair>::value,
|
|
"`ShadowViewNodePair` must be `move assignable`.");
|
|
static_assert(
|
|
std::is_move_assignable<ShadowViewNodePair::List>::value,
|
|
"`ShadowViewNodePair::List` must be `move assignable`.");
|
|
|
|
// Forward declaration
|
|
static void calculateShadowViewMutationsV2(
|
|
ShadowViewMutation::List &mutations,
|
|
ShadowView const &parentShadowView,
|
|
ShadowViewNodePair::List &&oldChildPairs,
|
|
ShadowViewNodePair::List &&newChildPairs);
|
|
|
|
struct OrderedMutationInstructionContainer {
|
|
ShadowViewMutation::List &createMutations;
|
|
ShadowViewMutation::List &deleteMutations;
|
|
ShadowViewMutation::List &insertMutations;
|
|
ShadowViewMutation::List &removeMutations;
|
|
ShadowViewMutation::List &updateMutations;
|
|
ShadowViewMutation::List &downwardMutations;
|
|
ShadowViewMutation::List &destructiveDownwardMutations;
|
|
};
|
|
|
|
static void calculateShadowViewMutationsFlattener(
|
|
ReparentMode reparentMode,
|
|
OrderedMutationInstructionContainer &mutationInstructionContainer,
|
|
ShadowView const &parentShadowView,
|
|
TinyMap<Tag, ShadowViewNodePair *> &unvisitedFlattenedNodes,
|
|
ShadowViewNodePair const &node,
|
|
TinyMap<Tag, ShadowViewNodePair *> *parentSubVisitedOtherNewNodes = nullptr,
|
|
TinyMap<Tag, ShadowViewNodePair *> *parentSubVisitedOtherOldNodes =
|
|
nullptr);
|
|
|
|
/**
|
|
* Here we flatten or unflatten a subtree, given an unflattened node in either
|
|
* the old or new tree, and a list of flattened nodes in the other tree.
|
|
*
|
|
* For example: if you are Flattening, the node will be in the old tree and the
|
|
* list will be from the new tree. If you are Unflattening, the opposite is
|
|
true.
|
|
|
|
* It is currently not possible for ReactJS, and therefore React Native, to move
|
|
* a node *from* one parent to another without an entirely new subtree being
|
|
* created. When we "reparent" in React Native here it is only because
|
|
intermediate
|
|
* ShadowNodes/ShadowViews, which *always* exist, are flattened or unflattened
|
|
away.
|
|
* Thus, this algorithm handles the very specialized cases of the tree
|
|
collapsing or
|
|
* expanding vertically in that way.
|
|
|
|
* Sketch of algorithm:
|
|
* 0. Create a map of nodes in the flattened list. This should be done *before*
|
|
* calling this function.
|
|
* 1. Traverse the Node Subtree; remove elements from the map as they are
|
|
* visited in the tree.
|
|
* Perform a Remove/Insert depending on if we're flattening or unflattening
|
|
* If Tree node is not in Map/List, perform Delete/Create.
|
|
* 2. Traverse the list.
|
|
* Perform linear remove from the old View, or insert into the new parent
|
|
* View if we're flattening.
|
|
* If a node is in the list but not the map, it means it's been visited and
|
|
* Update has already been
|
|
* performed in the subtree. If it *is* in the map, it means the node is not
|
|
* * in the Tree, and should be Deleted/Created
|
|
* **after this function is called**, by the caller.
|
|
*/
|
|
static void calculateShadowViewMutationsFlattener(
|
|
ReparentMode reparentMode,
|
|
OrderedMutationInstructionContainer &mutationInstructionContainer,
|
|
ShadowView const &parentShadowView,
|
|
TinyMap<Tag, ShadowViewNodePair *> &unvisitedOtherNodes,
|
|
ShadowViewNodePair const &node,
|
|
TinyMap<Tag, ShadowViewNodePair *> *parentSubVisitedOtherNewNodes,
|
|
TinyMap<Tag, ShadowViewNodePair *> *parentSubVisitedOtherOldNodes) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Flattener 1: "
|
|
<< (reparentMode == ReparentMode::Unflatten ? "Unflattening"
|
|
: "Flattening")
|
|
<< " [" << node.shadowView.tag << "]";
|
|
});
|
|
|
|
// Step 1: iterate through entire tree
|
|
ShadowViewNodePair::List treeChildren =
|
|
sliceChildShadowNodeViewPairsV2(*node.shadowNode);
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Flattener 1.4: "
|
|
<< (reparentMode == ReparentMode::Unflatten ? "Unflattening"
|
|
: "Flattening")
|
|
<< " [" << node.shadowView.tag << "]";
|
|
LOG(ERROR) << "Differ Flattener Entry: Child Pairs: ";
|
|
std::string strTreeChildPairs;
|
|
for (size_t k = 0; k < treeChildren.size(); k++) {
|
|
strTreeChildPairs.append(std::to_string(treeChildren[k].shadowView.tag));
|
|
strTreeChildPairs.append(treeChildren[k].isConcreteView ? "" : "'");
|
|
strTreeChildPairs.append(treeChildren[k].flattened ? "*" : "");
|
|
strTreeChildPairs.append(", ");
|
|
}
|
|
std::string strListChildPairs;
|
|
for (auto &unvisitedNode : unvisitedOtherNodes) {
|
|
strListChildPairs.append(
|
|
std::to_string(unvisitedNode.second->shadowView.tag));
|
|
strListChildPairs.append(unvisitedNode.second->isConcreteView ? "" : "'");
|
|
strListChildPairs.append(unvisitedNode.second->flattened ? "*" : "");
|
|
strListChildPairs.append(", ");
|
|
}
|
|
LOG(ERROR) << "Differ Flattener Entry: Tree Child Pairs: "
|
|
<< strTreeChildPairs;
|
|
LOG(ERROR) << "Differ Flattener Entry: List Child Pairs: "
|
|
<< strListChildPairs;
|
|
});
|
|
|
|
// Views in other tree that are visited by sub-flattening or sub-unflattening
|
|
TinyMap<Tag, ShadowViewNodePair *> subVisitedOtherNewNodes{};
|
|
TinyMap<Tag, ShadowViewNodePair *> subVisitedOtherOldNodes{};
|
|
auto subVisitedNewMap =
|
|
(parentSubVisitedOtherNewNodes != nullptr ? parentSubVisitedOtherNewNodes
|
|
: &subVisitedOtherNewNodes);
|
|
auto subVisitedOldMap =
|
|
(parentSubVisitedOtherOldNodes != nullptr ? parentSubVisitedOtherOldNodes
|
|
: &subVisitedOtherOldNodes);
|
|
|
|
// Candidates for full tree creation or deletion at the end of this function
|
|
auto deletionCreationCandidatePairs =
|
|
TinyMap<Tag, ShadowViewNodePair const *>{};
|
|
|
|
for (size_t index = 0;
|
|
index < treeChildren.size() && index < treeChildren.size();
|
|
index++) {
|
|
// First, remove all children of the tree being flattened, or insert
|
|
// children into parent tree if they're being unflattened. Then, look up
|
|
// each node in the "unvisited" list and update the nodes and subtrees if
|
|
// appropriate.
|
|
auto &treeChildPair = treeChildren[index];
|
|
|
|
// Caller will take care of the corresponding action in the other tree.
|
|
if (treeChildPair.isConcreteView) {
|
|
if (reparentMode == ReparentMode::Flatten) {
|
|
mutationInstructionContainer.removeMutations.push_back(
|
|
ShadowViewMutation::RemoveMutation(
|
|
node.shadowView,
|
|
treeChildPair.shadowView,
|
|
treeChildPair.mountIndex));
|
|
} else {
|
|
mutationInstructionContainer.insertMutations.push_back(
|
|
ShadowViewMutation::InsertMutation(
|
|
node.shadowView,
|
|
treeChildPair.shadowView,
|
|
treeChildPair.mountIndex));
|
|
}
|
|
}
|
|
|
|
// Try to find node in other tree
|
|
auto unvisitedIt = unvisitedOtherNodes.find(treeChildPair.shadowView.tag);
|
|
auto subVisitedOtherNewIt =
|
|
(unvisitedIt == unvisitedOtherNodes.end()
|
|
? subVisitedNewMap->find(treeChildPair.shadowView.tag)
|
|
: subVisitedNewMap->end());
|
|
auto subVisitedOtherOldIt =
|
|
(unvisitedIt == unvisitedOtherNodes.end()
|
|
? subVisitedOldMap->find(treeChildPair.shadowView.tag)
|
|
: subVisitedOldMap->end());
|
|
|
|
// Find in other tree
|
|
if (unvisitedIt != unvisitedOtherNodes.end() ||
|
|
subVisitedOtherNewIt != subVisitedNewMap->end() ||
|
|
subVisitedOtherOldIt != subVisitedOldMap->end()) {
|
|
// If we've already done updates on this node, don't repeat.
|
|
if (reparentMode == ReparentMode::Flatten &&
|
|
unvisitedIt == unvisitedOtherNodes.end() &&
|
|
subVisitedOtherOldIt != subVisitedOldMap->end()) {
|
|
continue;
|
|
} else if (
|
|
reparentMode == ReparentMode::Unflatten &&
|
|
unvisitedIt == unvisitedOtherNodes.end() &&
|
|
subVisitedOtherNewIt != subVisitedNewMap->end()) {
|
|
continue;
|
|
}
|
|
|
|
auto &otherTreeNodePair =
|
|
*(unvisitedIt != unvisitedOtherNodes.end()
|
|
? unvisitedIt->second
|
|
: (subVisitedOtherNewIt != subVisitedNewMap->end()
|
|
? subVisitedOtherNewIt->second
|
|
: subVisitedOtherOldIt->second));
|
|
|
|
// If we've already done updates, don't repeat it.
|
|
if (treeChildPair.inOtherTree || otherTreeNodePair.inOtherTree) {
|
|
continue;
|
|
}
|
|
|
|
auto &newTreeNodePair =
|
|
(reparentMode == ReparentMode::Flatten ? otherTreeNodePair
|
|
: treeChildPair);
|
|
auto &oldTreeNodePair =
|
|
(reparentMode == ReparentMode::Flatten ? treeChildPair
|
|
: otherTreeNodePair);
|
|
|
|
if (newTreeNodePair.shadowView != oldTreeNodePair.shadowView &&
|
|
newTreeNodePair.isConcreteView && oldTreeNodePair.isConcreteView) {
|
|
mutationInstructionContainer.updateMutations.push_back(
|
|
ShadowViewMutation::UpdateMutation(
|
|
oldTreeNodePair.shadowView, newTreeNodePair.shadowView));
|
|
}
|
|
|
|
// Update children if appropriate.
|
|
if (!oldTreeNodePair.flattened && !newTreeNodePair.flattened) {
|
|
if (oldTreeNodePair.shadowNode != newTreeNodePair.shadowNode) {
|
|
calculateShadowViewMutationsV2(
|
|
mutationInstructionContainer.downwardMutations,
|
|
newTreeNodePair.shadowView,
|
|
sliceChildShadowNodeViewPairsV2(*oldTreeNodePair.shadowNode),
|
|
sliceChildShadowNodeViewPairsV2(*newTreeNodePair.shadowNode));
|
|
}
|
|
} else if (oldTreeNodePair.flattened != newTreeNodePair.flattened) {
|
|
// We need to handle one of the children being flattened or unflattened,
|
|
// in the context of a parent flattening or unflattening.
|
|
ReparentMode childReparentMode =
|
|
(oldTreeNodePair.flattened ? ReparentMode::Unflatten
|
|
: ReparentMode::Flatten);
|
|
|
|
// Case 1: child mode is the same as parent.
|
|
// This is a flatten-flatten, or unflatten-unflatten.
|
|
if (childReparentMode == reparentMode) {
|
|
calculateShadowViewMutationsFlattener(
|
|
childReparentMode,
|
|
mutationInstructionContainer,
|
|
(reparentMode == ReparentMode::Flatten
|
|
? parentShadowView
|
|
: newTreeNodePair.shadowView),
|
|
unvisitedOtherNodes,
|
|
treeChildPair,
|
|
subVisitedNewMap,
|
|
subVisitedOldMap);
|
|
} else {
|
|
// Unflatten parent, flatten child
|
|
if (childReparentMode == ReparentMode::Flatten) {
|
|
// Construct unvisited nodes map
|
|
auto unvisitedNewChildPairs = TinyMap<Tag, ShadowViewNodePair *>{};
|
|
// Memory note: these oldFlattenedNodes all disappear at the end of
|
|
// this "else" block, including any annotations we put on them.
|
|
auto newFlattenedNodes = sliceChildShadowNodeViewPairsV2(
|
|
*newTreeNodePair.shadowNode, true);
|
|
for (size_t i = 0; i < newFlattenedNodes.size(); i++) {
|
|
auto &newChild = newFlattenedNodes[i];
|
|
|
|
auto unvisitedOtherNodesIt =
|
|
unvisitedOtherNodes.find(newChild.shadowView.tag);
|
|
if (unvisitedOtherNodesIt != unvisitedOtherNodes.end()) {
|
|
auto &unvisitedItPair = *unvisitedOtherNodesIt->second;
|
|
unvisitedNewChildPairs.insert(
|
|
{unvisitedItPair.shadowView.tag, &unvisitedItPair});
|
|
} else {
|
|
unvisitedNewChildPairs.insert(
|
|
{newChild.shadowView.tag, &newChild});
|
|
}
|
|
}
|
|
|
|
// Flatten old tree into new list
|
|
// At the end of this loop we still want to know which of these
|
|
// children are visited, so we reuse the `newRemainingPairs` map.
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Flatten,
|
|
mutationInstructionContainer,
|
|
(reparentMode == ReparentMode::Flatten
|
|
? parentShadowView
|
|
: newTreeNodePair.shadowView),
|
|
unvisitedNewChildPairs,
|
|
oldTreeNodePair,
|
|
subVisitedNewMap,
|
|
subVisitedOldMap);
|
|
|
|
for (auto &newFlattenedNode : newFlattenedNodes) {
|
|
auto unvisitedOldChildPairIt =
|
|
unvisitedNewChildPairs.find(newFlattenedNode.shadowView.tag);
|
|
|
|
if (unvisitedOldChildPairIt == unvisitedNewChildPairs.end()) {
|
|
// Node was visited.
|
|
|
|
auto deleteCreateIt = deletionCreationCandidatePairs.find(
|
|
newFlattenedNode.shadowView.tag);
|
|
if (deleteCreateIt != deletionCreationCandidatePairs.end()) {
|
|
deletionCreationCandidatePairs.erase(deleteCreateIt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Flatten parent, unflatten child
|
|
else {
|
|
// Construct unvisited nodes map
|
|
auto unvisitedOldChildPairs = TinyMap<Tag, ShadowViewNodePair *>{};
|
|
// Memory note: these oldFlattenedNodes all disappear at the end of
|
|
// this "else" block, including any annotations we put on them.
|
|
auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
|
|
*oldTreeNodePair.shadowNode, true);
|
|
for (size_t i = 0; i < oldFlattenedNodes.size(); i++) {
|
|
auto &oldChild = oldFlattenedNodes[i];
|
|
|
|
auto unvisitedOtherNodesIt =
|
|
unvisitedOtherNodes.find(oldChild.shadowView.tag);
|
|
if (unvisitedOtherNodesIt != unvisitedOtherNodes.end()) {
|
|
auto &unvisitedItPair = *unvisitedOtherNodesIt->second;
|
|
unvisitedOldChildPairs.insert(
|
|
{unvisitedItPair.shadowView.tag, &unvisitedItPair});
|
|
} else {
|
|
unvisitedOldChildPairs.insert(
|
|
{oldChild.shadowView.tag, &oldChild});
|
|
}
|
|
}
|
|
|
|
// Unflatten old list into new tree
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Unflatten,
|
|
mutationInstructionContainer,
|
|
(reparentMode == ReparentMode::Flatten
|
|
? parentShadowView
|
|
: newTreeNodePair.shadowView),
|
|
unvisitedOldChildPairs,
|
|
newTreeNodePair,
|
|
subVisitedNewMap,
|
|
subVisitedOldMap);
|
|
|
|
// If old nodes were not visited, we know that we can delete them
|
|
// now. They will be removed from the hierarchy by the outermost
|
|
// loop of this function.
|
|
for (auto &oldFlattenedNode : oldFlattenedNodes) {
|
|
auto unvisitedOldChildPairIt =
|
|
unvisitedOldChildPairs.find(oldFlattenedNode.shadowView.tag);
|
|
if (unvisitedOldChildPairIt != unvisitedOldChildPairs.end()) {
|
|
// Node unvisited - mark the entire subtree for deletion
|
|
if (oldFlattenedNode.isConcreteView) {
|
|
auto tag = oldFlattenedNode.shadowView.tag;
|
|
auto oldRemainingChildInListIt = std::find_if(
|
|
treeChildren.begin(),
|
|
treeChildren.end(),
|
|
[&tag](ShadowViewNodePair &nodePair) {
|
|
return nodePair.shadowView.tag == tag;
|
|
});
|
|
if (oldRemainingChildInListIt != treeChildren.end()) {
|
|
auto deleteCreateIt = deletionCreationCandidatePairs.find(
|
|
oldFlattenedNode.shadowView.tag);
|
|
if (deleteCreateIt ==
|
|
deletionCreationCandidatePairs.end()) {
|
|
deletionCreationCandidatePairs.insert(
|
|
{tag, &*oldRemainingChildInListIt});
|
|
}
|
|
} else {
|
|
// TODO: we might want to remove this block. It seems
|
|
// impossible to hit this logically (and empirically, after
|
|
// testing on lots of randomized and pathologically
|
|
// constructed trees) but I'm leaving this here out of an
|
|
// abundance of caution.
|
|
mutationInstructionContainer.deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(
|
|
oldFlattenedNode.shadowView));
|
|
|
|
calculateShadowViewMutationsV2(
|
|
mutationInstructionContainer
|
|
.destructiveDownwardMutations,
|
|
oldFlattenedNode.shadowView,
|
|
sliceChildShadowNodeViewPairsV2(
|
|
*oldFlattenedNode.shadowNode),
|
|
{});
|
|
}
|
|
}
|
|
} else {
|
|
// Node was visited - make sure to remove it from
|
|
// "newRemainingPairs" map
|
|
auto newRemainingIt =
|
|
unvisitedOtherNodes.find(oldFlattenedNode.shadowView.tag);
|
|
if (newRemainingIt != unvisitedOtherNodes.end()) {
|
|
unvisitedOtherNodes.erase(newRemainingIt);
|
|
}
|
|
|
|
// We also remove it from delete/creation candidates
|
|
auto deleteCreateIt = deletionCreationCandidatePairs.find(
|
|
oldFlattenedNode.shadowView.tag);
|
|
if (deleteCreateIt != deletionCreationCandidatePairs.end()) {
|
|
deletionCreationCandidatePairs.erase(deleteCreateIt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mark that node exists in another tree, but only if the tree node is a
|
|
// concrete view. Removing the node from the unvisited list prevents the
|
|
// caller from taking further action on this node, so make sure to
|
|
// delete/create if the Concreteness of the node has changed.
|
|
if (newTreeNodePair.isConcreteView != oldTreeNodePair.isConcreteView &&
|
|
!newTreeNodePair.inOtherTree) {
|
|
if (newTreeNodePair.isConcreteView) {
|
|
mutationInstructionContainer.createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(newTreeNodePair.shadowView));
|
|
} else {
|
|
mutationInstructionContainer.deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(newTreeNodePair.shadowView));
|
|
}
|
|
}
|
|
|
|
treeChildPair.inOtherTree = true;
|
|
otherTreeNodePair.inOtherTree = true;
|
|
|
|
if (parentSubVisitedOtherNewNodes != nullptr) {
|
|
parentSubVisitedOtherNewNodes->insert(
|
|
{newTreeNodePair.shadowView.tag, &newTreeNodePair});
|
|
}
|
|
if (parentSubVisitedOtherOldNodes != nullptr) {
|
|
parentSubVisitedOtherOldNodes->insert(
|
|
{oldTreeNodePair.shadowView.tag, &oldTreeNodePair});
|
|
}
|
|
|
|
if (unvisitedIt != unvisitedOtherNodes.end()) {
|
|
unvisitedOtherNodes.erase(unvisitedIt);
|
|
}
|
|
} else {
|
|
// Node does not in exist in other tree.
|
|
if (treeChildPair.isConcreteView && !treeChildPair.inOtherTree) {
|
|
auto deletionCreationIt =
|
|
deletionCreationCandidatePairs.find(treeChildPair.shadowView.tag);
|
|
if (deletionCreationIt == deletionCreationCandidatePairs.end()) {
|
|
deletionCreationCandidatePairs.insert(
|
|
{treeChildPair.shadowView.tag, &treeChildPair});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Final step: go through creation/deletion candidates and delete/create
|
|
// subtrees if they were never visited during the execution of the above loop
|
|
// and recursions.
|
|
for (auto it = deletionCreationCandidatePairs.begin();
|
|
it != deletionCreationCandidatePairs.end();
|
|
it++) {
|
|
if (it->first == 0) {
|
|
continue;
|
|
}
|
|
auto &treeChildPair = *it->second;
|
|
|
|
// If node was visited during a flattening/unflattening recursion.
|
|
if (treeChildPair.inOtherTree) {
|
|
continue;
|
|
}
|
|
|
|
if (reparentMode == ReparentMode::Flatten) {
|
|
mutationInstructionContainer.deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(treeChildPair.shadowView));
|
|
|
|
if (!treeChildPair.flattened) {
|
|
calculateShadowViewMutationsV2(
|
|
mutationInstructionContainer.destructiveDownwardMutations,
|
|
treeChildPair.shadowView,
|
|
sliceChildShadowNodeViewPairsV2(*treeChildPair.shadowNode),
|
|
{});
|
|
}
|
|
} else {
|
|
mutationInstructionContainer.createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(treeChildPair.shadowView));
|
|
|
|
if (!treeChildPair.flattened) {
|
|
calculateShadowViewMutationsV2(
|
|
mutationInstructionContainer.downwardMutations,
|
|
treeChildPair.shadowView,
|
|
{},
|
|
sliceChildShadowNodeViewPairsV2(*treeChildPair.shadowNode));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void calculateShadowViewMutationsV2(
|
|
ShadowViewMutation::List &mutations,
|
|
ShadowView const &parentShadowView,
|
|
ShadowViewNodePair::List &&oldChildPairs,
|
|
ShadowViewNodePair::List &&newChildPairs) {
|
|
if (oldChildPairs.empty() && newChildPairs.empty()) {
|
|
return;
|
|
}
|
|
|
|
size_t index = 0;
|
|
|
|
// Lists of mutations
|
|
auto createMutations = ShadowViewMutation::List{};
|
|
auto deleteMutations = ShadowViewMutation::List{};
|
|
auto insertMutations = ShadowViewMutation::List{};
|
|
auto removeMutations = ShadowViewMutation::List{};
|
|
auto updateMutations = ShadowViewMutation::List{};
|
|
auto downwardMutations = ShadowViewMutation::List{};
|
|
auto destructiveDownwardMutations = ShadowViewMutation::List{};
|
|
auto mutationInstructionContainer = OrderedMutationInstructionContainer{
|
|
createMutations,
|
|
deleteMutations,
|
|
insertMutations,
|
|
removeMutations,
|
|
updateMutations,
|
|
downwardMutations,
|
|
destructiveDownwardMutations};
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Entry: Child Pairs of node: [" << parentShadowView.tag
|
|
<< "]";
|
|
std::string strOldChildPairs;
|
|
for (size_t oldIndex = 0; oldIndex < oldChildPairs.size(); oldIndex++) {
|
|
strOldChildPairs.append(
|
|
std::to_string(oldChildPairs[oldIndex].shadowView.tag));
|
|
strOldChildPairs.append(
|
|
oldChildPairs[oldIndex].isConcreteView ? "" : "'");
|
|
strOldChildPairs.append(oldChildPairs[oldIndex].flattened ? "*" : "");
|
|
strOldChildPairs.append(", ");
|
|
}
|
|
std::string strNewChildPairs;
|
|
for (size_t newIndex = 0; newIndex < newChildPairs.size(); newIndex++) {
|
|
strNewChildPairs.append(
|
|
std::to_string(newChildPairs[newIndex].shadowView.tag));
|
|
strNewChildPairs.append(
|
|
newChildPairs[newIndex].isConcreteView ? "" : "'");
|
|
strNewChildPairs.append(newChildPairs[newIndex].flattened ? "*" : "");
|
|
strNewChildPairs.append(", ");
|
|
}
|
|
LOG(ERROR) << "Differ Entry: Old Child Pairs: " << strOldChildPairs;
|
|
LOG(ERROR) << "Differ Entry: New Child Pairs: " << strNewChildPairs;
|
|
});
|
|
|
|
// Stage 1: Collecting `Update` mutations
|
|
for (index = 0; index < oldChildPairs.size() && index < newChildPairs.size();
|
|
index++) {
|
|
auto &oldChildPair = oldChildPairs[index];
|
|
auto &newChildPair = newChildPairs[index];
|
|
|
|
if (oldChildPair.shadowView.tag != newChildPair.shadowView.tag) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Branch 1.1: Tags Different: ["
|
|
<< oldChildPair.shadowView.tag << "] ["
|
|
<< newChildPair.shadowView.tag << "]"
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
// Totally different nodes, updating is impossible.
|
|
break;
|
|
}
|
|
|
|
// If either view was flattened, and that has changed this frame, don't try
|
|
// to update
|
|
if (oldChildPair.flattened != newChildPair.flattened ||
|
|
oldChildPair.isConcreteView != newChildPair.isConcreteView) {
|
|
break;
|
|
}
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Branch 1.2: Same tags, update and recurse: ["
|
|
<< oldChildPair.shadowView.tag << "]"
|
|
<< (oldChildPair.flattened ? " (flattened)" : "")
|
|
<< (oldChildPair.isConcreteView ? " (concrete)" : "") << "["
|
|
<< newChildPair.shadowView.tag << "]"
|
|
<< (newChildPair.flattened ? " (flattened)" : "")
|
|
<< (newChildPair.isConcreteView ? " (concrete)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
if (newChildPair.isConcreteView &&
|
|
oldChildPair.shadowView != newChildPair.shadowView) {
|
|
updateMutations.push_back(ShadowViewMutation::UpdateMutation(
|
|
oldChildPair.shadowView, newChildPair.shadowView));
|
|
}
|
|
|
|
// Recursively update tree if ShadowNode pointers are not equal
|
|
if (!oldChildPair.flattened &&
|
|
oldChildPair.shadowNode != newChildPair.shadowNode) {
|
|
auto oldGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
|
|
auto newGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
|
|
calculateShadowViewMutationsV2(
|
|
*(newGrandChildPairs.size() ? &downwardMutations
|
|
: &destructiveDownwardMutations),
|
|
oldChildPair.shadowView,
|
|
std::move(oldGrandChildPairs),
|
|
std::move(newGrandChildPairs));
|
|
}
|
|
}
|
|
|
|
size_t lastIndexAfterFirstStage = index;
|
|
|
|
if (index == newChildPairs.size()) {
|
|
// We've reached the end of the new children. We can delete+remove the
|
|
// rest.
|
|
for (; index < oldChildPairs.size(); index++) {
|
|
auto const &oldChildPair = oldChildPairs[index];
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Branch 2: Deleting Tag/Tree: ["
|
|
<< oldChildPair.shadowView.tag << "]"
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
if (!oldChildPair.isConcreteView) {
|
|
continue;
|
|
}
|
|
|
|
deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
|
|
removeMutations.push_back(ShadowViewMutation::RemoveMutation(
|
|
parentShadowView, oldChildPair.shadowView, oldChildPair.mountIndex));
|
|
|
|
// We also have to call the algorithm recursively to clean up the entire
|
|
// subtree starting from the removed view.
|
|
calculateShadowViewMutationsV2(
|
|
destructiveDownwardMutations,
|
|
oldChildPair.shadowView,
|
|
sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode),
|
|
{});
|
|
}
|
|
} else if (index == oldChildPairs.size()) {
|
|
// If we don't have any more existing children we can choose a fast path
|
|
// since the rest will all be create+insert.
|
|
for (; index < newChildPairs.size(); index++) {
|
|
auto const &newChildPair = newChildPairs[index];
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Branch 3: Creating Tag/Tree: ["
|
|
<< newChildPair.shadowView.tag << "]"
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
if (!newChildPair.isConcreteView) {
|
|
continue;
|
|
}
|
|
|
|
insertMutations.push_back(ShadowViewMutation::InsertMutation(
|
|
parentShadowView, newChildPair.shadowView, newChildPair.mountIndex));
|
|
createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(newChildPair.shadowView));
|
|
|
|
calculateShadowViewMutationsV2(
|
|
downwardMutations,
|
|
newChildPair.shadowView,
|
|
{},
|
|
sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode));
|
|
}
|
|
} else {
|
|
// Collect map of tags in the new list
|
|
auto newRemainingPairs = TinyMap<Tag, ShadowViewNodePair *>{};
|
|
auto newInsertedPairs = TinyMap<Tag, ShadowViewNodePair *>{};
|
|
auto deletionCandidatePairs = TinyMap<Tag, ShadowViewNodePair const *>{};
|
|
for (; index < newChildPairs.size(); index++) {
|
|
auto &newChildPair = newChildPairs[index];
|
|
newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
|
|
}
|
|
|
|
// Walk through both lists at the same time
|
|
// We will perform updates, create+insert, remove+delete, remove+insert
|
|
// (move) here.
|
|
size_t oldIndex = lastIndexAfterFirstStage,
|
|
newIndex = lastIndexAfterFirstStage, newSize = newChildPairs.size(),
|
|
oldSize = oldChildPairs.size();
|
|
while (newIndex < newSize || oldIndex < oldSize) {
|
|
bool haveNewPair = newIndex < newSize;
|
|
bool haveOldPair = oldIndex < oldSize;
|
|
|
|
// Advance both pointers if pointing to the same element
|
|
if (haveNewPair && haveOldPair) {
|
|
auto const &oldChildPair = oldChildPairs[oldIndex];
|
|
auto const &newChildPair = newChildPairs[newIndex];
|
|
|
|
Tag newTag = newChildPair.shadowView.tag;
|
|
Tag oldTag = oldChildPair.shadowView.tag;
|
|
|
|
if (newTag == oldTag) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ Branch 5: Matched Tags at indices: "
|
|
<< oldIndex << " " << newIndex << ": ["
|
|
<< oldChildPair.shadowView.tag << "]"
|
|
<< (oldChildPair.flattened ? "(flattened)" : "")
|
|
<< (oldChildPair.isConcreteView ? "(concrete)" : "")
|
|
<< " [" << newChildPair.shadowView.tag << "]"
|
|
<< (newChildPair.flattened ? "(flattened)" : "")
|
|
<< (newChildPair.isConcreteView ? "(concrete)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
// Check concrete-ness of views
|
|
// Create/Delete and Insert/Remove if necessary
|
|
if (oldChildPair.isConcreteView != newChildPair.isConcreteView) {
|
|
if (newChildPair.isConcreteView) {
|
|
insertMutations.push_back(ShadowViewMutation::InsertMutation(
|
|
parentShadowView,
|
|
newChildPair.shadowView,
|
|
newChildPair.mountIndex));
|
|
createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(newChildPair.shadowView));
|
|
} else {
|
|
removeMutations.push_back(ShadowViewMutation::RemoveMutation(
|
|
parentShadowView,
|
|
oldChildPair.shadowView,
|
|
oldChildPair.mountIndex));
|
|
deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
|
|
}
|
|
} else if (
|
|
oldChildPair.isConcreteView && newChildPair.isConcreteView) {
|
|
// Even if node's children are flattened, it might still be a
|
|
// concrete view. The case where they're different is handled above.
|
|
if (oldChildPair.shadowView != newChildPair.shadowView) {
|
|
updateMutations.push_back(ShadowViewMutation::UpdateMutation(
|
|
oldChildPair.shadowView, newChildPair.shadowView));
|
|
}
|
|
|
|
// Remove from newRemainingPairs
|
|
auto newRemainingPairIt = newRemainingPairs.find(oldTag);
|
|
if (newRemainingPairIt != newRemainingPairs.end()) {
|
|
newRemainingPairs.erase(newRemainingPairIt);
|
|
}
|
|
}
|
|
|
|
// Are we flattening or unflattening either one? If node was flattened
|
|
// in both trees, there's no change, just continue.
|
|
if (oldChildPair.flattened && newChildPair.flattened) {
|
|
newIndex++;
|
|
oldIndex++;
|
|
continue;
|
|
}
|
|
// We are either flattening or unflattening this node.
|
|
if (oldChildPair.flattened != newChildPair.flattened) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR) << "Differ: flattening or unflattening at branch 6: ["
|
|
<< oldChildPair.shadowView.tag << "] ["
|
|
<< newChildPair.shadowView.tag << "] "
|
|
<< oldChildPair.flattened << " "
|
|
<< newChildPair.flattened << " with parent: ["
|
|
<< parentShadowView.tag << "]";
|
|
});
|
|
|
|
// Flattening
|
|
if (!oldChildPair.flattened) {
|
|
// Flatten old tree into new list
|
|
// At the end of this loop we still want to know which of these
|
|
// children are visited, so we reuse the `newRemainingPairs` map.
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Flatten,
|
|
mutationInstructionContainer,
|
|
parentShadowView,
|
|
newRemainingPairs,
|
|
oldChildPair);
|
|
}
|
|
// Unflattening
|
|
else {
|
|
// Construct unvisited nodes map
|
|
auto unvisitedOldChildPairs =
|
|
TinyMap<Tag, ShadowViewNodePair *>{};
|
|
// We don't know where all the children of oldChildPair are within
|
|
// oldChildPairs, but we know that they're in the same relative
|
|
// order. The reason for this is because of flattening + zIndex:
|
|
// the children could be listed before the parent, interwoven with
|
|
// children from other nodes, etc.
|
|
auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
|
|
*oldChildPair.shadowNode, true);
|
|
for (size_t i = 0, j = 0;
|
|
i < oldChildPairs.size() && j < oldFlattenedNodes.size();
|
|
i++) {
|
|
auto &oldChild = oldChildPairs[i];
|
|
if (oldChild.shadowView.tag ==
|
|
oldFlattenedNodes[j].shadowView.tag) {
|
|
unvisitedOldChildPairs.insert(
|
|
{oldChild.shadowView.tag, &oldChild});
|
|
j++;
|
|
}
|
|
}
|
|
|
|
// Unflatten old list into new tree
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Unflatten,
|
|
mutationInstructionContainer,
|
|
parentShadowView,
|
|
unvisitedOldChildPairs,
|
|
newChildPair);
|
|
|
|
// If old nodes were not visited, we know that we can delete them
|
|
// now. They will be removed from the hierarchy by the outermost
|
|
// loop of this function.
|
|
for (auto &oldFlattenedNode : oldFlattenedNodes) {
|
|
auto unvisitedOldChildPairIt = unvisitedOldChildPairs.find(
|
|
oldFlattenedNode.shadowView.tag);
|
|
if (unvisitedOldChildPairIt == unvisitedOldChildPairs.end()) {
|
|
// Node was visited - make sure to remove it from
|
|
// "newRemainingPairs" map
|
|
auto newRemainingIt =
|
|
newRemainingPairs.find(oldFlattenedNode.shadowView.tag);
|
|
if (newRemainingIt != newRemainingPairs.end()) {
|
|
newRemainingPairs.erase(newRemainingIt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
newIndex++;
|
|
oldIndex++;
|
|
continue;
|
|
}
|
|
|
|
// Update subtrees if View is not flattened, and if node addresses are
|
|
// not equal
|
|
if (oldChildPair.shadowNode != newChildPair.shadowNode) {
|
|
auto oldGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
|
|
auto newGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
|
|
calculateShadowViewMutationsV2(
|
|
*(newGrandChildPairs.size() ? &downwardMutations
|
|
: &destructiveDownwardMutations),
|
|
oldChildPair.shadowView,
|
|
std::move(oldGrandChildPairs),
|
|
std::move(newGrandChildPairs));
|
|
}
|
|
|
|
newIndex++;
|
|
oldIndex++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// We have an old pair, but we either don't have any remaining new pairs
|
|
// or we have one but it's not matched up with the old pair
|
|
if (haveOldPair) {
|
|
auto const &oldChildPair = oldChildPairs[oldIndex];
|
|
|
|
Tag oldTag = oldChildPair.shadowView.tag;
|
|
|
|
// Was oldTag already inserted? This indicates a reordering, not just
|
|
// a move. The new node has already been inserted, we just need to
|
|
// remove the node from its old position now, and update the node's
|
|
// subtree.
|
|
auto const insertedIt = newInsertedPairs.find(oldTag);
|
|
if (insertedIt != newInsertedPairs.end()) {
|
|
auto const &newChildPair = *insertedIt->second;
|
|
|
|
// The node has been reordered and we are also flattening or
|
|
// unflattening
|
|
if (oldChildPair.flattened != newChildPair.flattened) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR)
|
|
<< "Differ: branch 7: Flattening or unflattening already-inserted node upon remove (move/reorder operation)."
|
|
<< oldChildPair.shadowView.tag << " "
|
|
<< oldChildPair.flattened << " // "
|
|
<< newChildPair.shadowView.tag << " "
|
|
<< newChildPair.flattened;
|
|
});
|
|
|
|
// Unflattening.
|
|
// The node in question was already inserted and we are
|
|
// *unflattening* it, so we just need to update the subtree nodes
|
|
// and remove them from the view hierarchy. Any of the unvisited
|
|
// nodes in the old tree will be deleted.
|
|
// TODO: can we consolidate this code? It's identical to the first
|
|
// block above.
|
|
if (!oldChildPair.flattened) {
|
|
// Flatten old tree into new list
|
|
// At the end of this loop we still want to know which of these
|
|
// children are visited, so we reuse the `newRemainingPairs` map.
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Flatten,
|
|
mutationInstructionContainer,
|
|
parentShadowView,
|
|
newRemainingPairs,
|
|
oldChildPair);
|
|
}
|
|
// Unflattening
|
|
else {
|
|
// Construct unvisited nodes map
|
|
auto unvisitedOldChildPairs =
|
|
TinyMap<Tag, ShadowViewNodePair *>{};
|
|
// We don't know where all the children of oldChildPair are within
|
|
// oldChildPairs, but we know that they're in the same relative
|
|
// order. The reason for this is because of flattening + zIndex:
|
|
// the children could be listed before the parent, interwoven with
|
|
// children from other nodes, etc.
|
|
auto oldFlattenedNodes = sliceChildShadowNodeViewPairsV2(
|
|
*oldChildPair.shadowNode, true);
|
|
for (size_t i = 0, j = 0;
|
|
i < oldChildPairs.size() && j < oldFlattenedNodes.size();
|
|
i++) {
|
|
auto &oldChild = oldChildPairs[i];
|
|
if (oldChild.shadowView.tag ==
|
|
oldFlattenedNodes[j].shadowView.tag) {
|
|
unvisitedOldChildPairs.insert(
|
|
{oldChild.shadowView.tag, &oldChild});
|
|
j++;
|
|
}
|
|
}
|
|
|
|
// Unflatten old list into new tree
|
|
calculateShadowViewMutationsFlattener(
|
|
ReparentMode::Unflatten,
|
|
mutationInstructionContainer,
|
|
parentShadowView,
|
|
unvisitedOldChildPairs,
|
|
newChildPair);
|
|
|
|
// If old nodes were not visited, we know that we can delete them
|
|
// now. They will be removed from the hierarchy by the outermost
|
|
// loop of this function. TODO: delete recursively? create
|
|
// recursively?
|
|
for (auto &oldFlattenedNode : oldFlattenedNodes) {
|
|
auto unvisitedOldChildPairIt = unvisitedOldChildPairs.find(
|
|
oldFlattenedNode.shadowView.tag);
|
|
if (unvisitedOldChildPairIt == unvisitedOldChildPairs.end()) {
|
|
// Node was visited - make sure to remove it from
|
|
// "newRemainingPairs" map
|
|
auto newRemainingIt =
|
|
newRemainingPairs.find(oldFlattenedNode.shadowView.tag);
|
|
if (newRemainingIt != newRemainingPairs.end()) {
|
|
newRemainingPairs.erase(newRemainingIt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check concrete-ness of views
|
|
// Create/Delete and Insert/Remove if necessary
|
|
// TODO: document: Insert should already be handled by outermost loop,
|
|
// but not Remove
|
|
if (oldChildPair.isConcreteView != newChildPair.isConcreteView) {
|
|
if (newChildPair.isConcreteView) {
|
|
createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(newChildPair.shadowView));
|
|
} else {
|
|
removeMutations.push_back(ShadowViewMutation::RemoveMutation(
|
|
parentShadowView,
|
|
oldChildPair.shadowView,
|
|
oldChildPair.mountIndex));
|
|
deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
|
|
}
|
|
}
|
|
|
|
// old and new child pairs are both either flattened or unflattened at
|
|
// this point. If they're not views, we don't need to update subtrees.
|
|
if (oldChildPair.isConcreteView && newChildPair.isConcreteView) {
|
|
// TODO: do we always want to remove here? There are cases where we
|
|
// might be able to remove this to prevent unnecessary
|
|
// removes/inserts in cases of (un)flattening + reorders?
|
|
removeMutations.push_back(ShadowViewMutation::RemoveMutation(
|
|
parentShadowView,
|
|
oldChildPair.shadowView,
|
|
oldChildPair.mountIndex));
|
|
|
|
if (oldChildPair.shadowView != newChildPair.shadowView) {
|
|
updateMutations.push_back(ShadowViewMutation::UpdateMutation(
|
|
oldChildPair.shadowView, newChildPair.shadowView));
|
|
}
|
|
}
|
|
|
|
if (!oldChildPair.flattened && !newChildPair.flattened &&
|
|
oldChildPair.shadowNode != newChildPair.shadowNode) {
|
|
// Update subtrees
|
|
auto oldGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode);
|
|
auto newGrandChildPairs =
|
|
sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode);
|
|
calculateShadowViewMutationsV2(
|
|
*(newGrandChildPairs.size() ? &downwardMutations
|
|
: &destructiveDownwardMutations),
|
|
oldChildPair.shadowView,
|
|
std::move(oldGrandChildPairs),
|
|
std::move(newGrandChildPairs));
|
|
}
|
|
|
|
newInsertedPairs.erase(insertedIt);
|
|
oldIndex++;
|
|
continue;
|
|
}
|
|
|
|
// Should we generate a delete+remove instruction for the old node?
|
|
// If there's an old node and it's not found in the "new" list, we
|
|
// generate remove+delete for this node and its subtree.
|
|
auto const newIt = newRemainingPairs.find(oldTag);
|
|
if (newIt == newRemainingPairs.end()) {
|
|
DEBUG_LOGS({
|
|
LOG(ERROR)
|
|
<< "Differ Branch 9: Removing tag that was not reinserted: "
|
|
<< oldIndex << ": [" << oldChildPair.shadowView.tag << "]"
|
|
<< (oldChildPair.flattened ? " (flattened)" : "")
|
|
<< (oldChildPair.isConcreteView ? " (concrete)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
if (oldChildPair.isConcreteView) {
|
|
removeMutations.push_back(ShadowViewMutation::RemoveMutation(
|
|
parentShadowView,
|
|
oldChildPair.shadowView,
|
|
oldChildPair.mountIndex));
|
|
|
|
deletionCandidatePairs.insert(
|
|
{oldChildPair.shadowView.tag, &oldChildPair});
|
|
}
|
|
|
|
oldIndex++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// At this point, oldTag is -1 or is in the new list, and hasn't been
|
|
// inserted or matched yet. We're not sure yet if the new node is in the
|
|
// old list - generate an insert instruction for the new node.
|
|
auto &newChildPair = newChildPairs[newIndex];
|
|
DEBUG_LOGS({
|
|
LOG(ERROR)
|
|
<< "Differ Branch 10: Inserting tag/tree that was not (yet?) removed from hierarchy: "
|
|
<< newIndex << "/" << newSize << ": ["
|
|
<< newChildPair.shadowView.tag << "]"
|
|
<< (newChildPair.flattened ? " (flattened)" : "")
|
|
<< (newChildPair.isConcreteView ? " (concrete)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
if (newChildPair.isConcreteView) {
|
|
insertMutations.push_back(ShadowViewMutation::InsertMutation(
|
|
parentShadowView,
|
|
newChildPair.shadowView,
|
|
newChildPair.mountIndex));
|
|
}
|
|
|
|
// `inOtherTree` is only set to true during flattening/unflattening of
|
|
// parent. If the parent isn't (un)flattened, this will always be `false`,
|
|
// even if the node is in the other (old) tree. In this case, we expect
|
|
// the node to be removed from `newInsertedPairs` when we later encounter
|
|
// it in this loop.
|
|
if (!newChildPair.inOtherTree) {
|
|
newInsertedPairs.insert({newChildPair.shadowView.tag, &newChildPair});
|
|
}
|
|
|
|
newIndex++;
|
|
}
|
|
|
|
// Penultimate step: generate Delete instructions for entirely deleted
|
|
// subtrees/nodes. We do this here because we need to traverse the entire
|
|
// list to make sure that a node was not reparented into an unflattened node
|
|
// that occurs *after* it in the hierarchy, due to zIndex ordering.
|
|
for (auto it = deletionCandidatePairs.begin();
|
|
it != deletionCandidatePairs.end();
|
|
it++) {
|
|
if (it->first == 0) {
|
|
continue;
|
|
}
|
|
|
|
auto const &oldChildPair = *it->second;
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR)
|
|
<< "Differ Branch 11: Deleting tag/tree that was not in new hierarchy: "
|
|
<< "[" << oldChildPair.shadowView.tag << "]"
|
|
<< (oldChildPair.flattened ? "(flattened)" : "")
|
|
<< (oldChildPair.isConcreteView ? "(concrete)" : "")
|
|
<< (oldChildPair.inOtherTree ? "(in other tree)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
// This can happen when the parent is unflattened
|
|
if (!oldChildPair.inOtherTree) {
|
|
deleteMutations.push_back(
|
|
ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
|
|
|
|
// We also have to call the algorithm recursively to clean up the
|
|
// entire subtree starting from the removed view.
|
|
calculateShadowViewMutationsV2(
|
|
destructiveDownwardMutations,
|
|
oldChildPair.shadowView,
|
|
sliceChildShadowNodeViewPairsV2(*oldChildPair.shadowNode),
|
|
{});
|
|
}
|
|
}
|
|
|
|
// Final step: generate Create instructions for entirely new subtrees/nodes
|
|
// that are not the result of flattening or unflattening.
|
|
for (auto it = newInsertedPairs.begin(); it != newInsertedPairs.end();
|
|
it++) {
|
|
// Erased elements of a TinyMap will have a Tag/key of 0 - skip those
|
|
// These *should* be removed by the map; there are currently no KNOWN
|
|
// cases where TinyMap will do the wrong thing, but there are not yet
|
|
// any unit tests explicitly for TinyMap, so this is safer for now.
|
|
if (it->first == 0) {
|
|
continue;
|
|
}
|
|
|
|
auto const &newChildPair = *it->second;
|
|
|
|
DEBUG_LOGS({
|
|
LOG(ERROR)
|
|
<< "Differ Branch 12: Inserting tag/tree that was not in old hierarchy: "
|
|
<< "[" << newChildPair.shadowView.tag << "]"
|
|
<< (newChildPair.flattened ? "(flattened)" : "")
|
|
<< (newChildPair.isConcreteView ? "(concrete)" : "")
|
|
<< (newChildPair.inOtherTree ? "(in other tree)" : "")
|
|
<< " with parent: [" << parentShadowView.tag << "]";
|
|
});
|
|
|
|
if (!newChildPair.isConcreteView) {
|
|
continue;
|
|
}
|
|
if (newChildPair.inOtherTree) {
|
|
continue;
|
|
}
|
|
|
|
createMutations.push_back(
|
|
ShadowViewMutation::CreateMutation(newChildPair.shadowView));
|
|
|
|
calculateShadowViewMutationsV2(
|
|
downwardMutations,
|
|
newChildPair.shadowView,
|
|
{},
|
|
sliceChildShadowNodeViewPairsV2(*newChildPair.shadowNode));
|
|
}
|
|
}
|
|
|
|
// All mutations in an optimal order:
|
|
std::move(
|
|
destructiveDownwardMutations.begin(),
|
|
destructiveDownwardMutations.end(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
updateMutations.begin(),
|
|
updateMutations.end(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
removeMutations.rbegin(),
|
|
removeMutations.rend(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
deleteMutations.begin(),
|
|
deleteMutations.end(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
createMutations.begin(),
|
|
createMutations.end(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
downwardMutations.begin(),
|
|
downwardMutations.end(),
|
|
std::back_inserter(mutations));
|
|
std::move(
|
|
insertMutations.begin(),
|
|
insertMutations.end(),
|
|
std::back_inserter(mutations));
|
|
}
|
|
|
|
/**
|
|
* Only used by unit tests currently.
|
|
*/
|
|
static void sliceChildShadowNodeViewPairsRecursivelyLegacy(
|
|
ShadowViewNodePair::List &pairList,
|
|
Point layoutOffset,
|
|
ShadowNode const &shadowNode) {
|
|
for (auto const &sharedChildShadowNode : shadowNode.getChildren()) {
|
|
auto &childShadowNode = *sharedChildShadowNode;
|
|
|
|
#ifndef ANDROID
|
|
// Temporary disabled on Android because the mounting infrastructure
|
|
// is not fully ready yet.
|
|
if (childShadowNode.getTraits().check(ShadowNodeTraits::Trait::Hidden)) {
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
auto shadowView = ShadowView(childShadowNode);
|
|
auto origin = layoutOffset;
|
|
if (shadowView.layoutMetrics != EmptyLayoutMetrics) {
|
|
origin += shadowView.layoutMetrics.frame.origin;
|
|
shadowView.layoutMetrics.frame.origin += layoutOffset;
|
|
}
|
|
|
|
if (childShadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsStackingContext)) {
|
|
pairList.push_back({shadowView, &childShadowNode});
|
|
} else {
|
|
if (childShadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsView)) {
|
|
pairList.push_back({shadowView, &childShadowNode});
|
|
}
|
|
|
|
sliceChildShadowNodeViewPairsRecursivelyLegacy(
|
|
pairList, origin, childShadowNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Only used by unit tests currently.
|
|
*/
|
|
ShadowViewNodePair::List sliceChildShadowNodeViewPairsLegacy(
|
|
ShadowNode const &shadowNode) {
|
|
auto pairList = ShadowViewNodePair::List{};
|
|
|
|
if (!shadowNode.getTraits().check(
|
|
ShadowNodeTraits::Trait::FormsStackingContext) &&
|
|
shadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView)) {
|
|
return pairList;
|
|
}
|
|
|
|
sliceChildShadowNodeViewPairsRecursivelyLegacy(pairList, {0, 0}, shadowNode);
|
|
|
|
return pairList;
|
|
}
|
|
|
|
ShadowViewMutation::List calculateShadowViewMutations(
|
|
ShadowNode const &oldRootShadowNode,
|
|
ShadowNode const &newRootShadowNode) {
|
|
SystraceSection s("calculateShadowViewMutations");
|
|
|
|
// Root shadow nodes must be belong the same family.
|
|
assert(ShadowNode::sameFamily(oldRootShadowNode, newRootShadowNode));
|
|
|
|
auto mutations = ShadowViewMutation::List{};
|
|
mutations.reserve(256);
|
|
|
|
auto oldRootShadowView = ShadowView(oldRootShadowNode);
|
|
auto newRootShadowView = ShadowView(newRootShadowNode);
|
|
|
|
if (oldRootShadowView != newRootShadowView) {
|
|
mutations.push_back(ShadowViewMutation::UpdateMutation(
|
|
oldRootShadowView, newRootShadowView));
|
|
}
|
|
|
|
calculateShadowViewMutationsV2(
|
|
mutations,
|
|
ShadowView(oldRootShadowNode),
|
|
sliceChildShadowNodeViewPairsV2(oldRootShadowNode),
|
|
sliceChildShadowNodeViewPairsV2(newRootShadowNode));
|
|
|
|
return mutations;
|
|
}
|
|
|
|
} // namespace react
|
|
} // namespace facebook
|