react-native 0.0.0-e6fc20ee6 → 0.0.0-e9440508e-20211011-2008

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -0,0 +1,462 @@
+/*
+ * 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 "ShadowTree.h"
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/root/RootComponentDescriptor.h>
+#include <react/renderer/components/view/ViewShadowNode.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/LayoutPrimitives.h>
+#include <react/renderer/debug/SystraceSection.h>
+#include <react/renderer/mounting/ShadowTreeRevision.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+#include <react/renderer/telemetry/TransactionTelemetry.h>
+
+#include "ShadowTreeDelegate.h"
+
+namespace facebook {
+namespace react {
+
+using CommitStatus = ShadowTree::CommitStatus;
+using CommitMode = ShadowTree::CommitMode;
+
+/*
+ * Generates (possibly) a new tree where all nodes with non-obsolete `State`
+ * objects. If all `State` objects in the tree are not obsolete for the moment
+ * of calling, the function returns `nullptr` (as an indication that no
+ * additional work is required).
+ */
+static ShadowNode::Unshared progressState(ShadowNode const &shadowNode) {
+  auto isStateChanged = false;
+  auto areChildrenChanged = false;
+
+  auto newState = shadowNode.getState();
+  if (newState) {
+    newState = newState->getMostRecentStateIfObsolete();
+    if (newState) {
+      isStateChanged = true;
+    }
+  }
+
+  auto newChildren = ShadowNode::ListOfShared{};
+  if (!shadowNode.getChildren().empty()) {
+    auto index = size_t{0};
+    for (auto const &childNode : shadowNode.getChildren()) {
+      auto newChildNode = progressState(*childNode);
+      if (newChildNode) {
+        if (!areChildrenChanged) {
+          // Making a copy before the first mutation.
+          newChildren = shadowNode.getChildren();
+        }
+        newChildren[index] = newChildNode;
+        areChildrenChanged = true;
+      }
+      index++;
+    }
+  }
+
+  if (!areChildrenChanged && !isStateChanged) {
+    return nullptr;
+  }
+
+  return shadowNode.clone({
+      ShadowNodeFragment::propsPlaceholder(),
+      areChildrenChanged ? std::make_shared<ShadowNode::ListOfShared const>(
+                               std::move(newChildren))
+                         : ShadowNodeFragment::childrenPlaceholder(),
+      isStateChanged ? newState : ShadowNodeFragment::statePlaceholder(),
+  });
+}
+
+/*
+ * An optimized version of the previous function (and relies on it).
+ * The function uses a given base tree to exclude unchanged (equal) parts
+ * of the three from the traversing.
+ */
+static ShadowNode::Unshared progressState(
+    ShadowNode const &shadowNode,
+    ShadowNode const &baseShadowNode) {
+  // The intuition behind the complexity:
+  // - A very few nodes have associated state, therefore it's mostly reading and
+  //   it only writes when state objects were found obsolete;
+  // - Most before-after trees are aligned, therefore most tree branches will be
+  //   skipped;
+  // - If trees are significantly different, any other algorithm will have
+  //   close to linear complexity.
+
+  auto isStateChanged = false;
+  auto areChildrenChanged = false;
+
+  auto newState = shadowNode.getState();
+  if (newState) {
+    newState = newState->getMostRecentStateIfObsolete();
+    if (newState) {
+      isStateChanged = true;
+    }
+  }
+
+  auto &children = shadowNode.getChildren();
+  auto &baseChildren = baseShadowNode.getChildren();
+  auto newChildren = ShadowNode::ListOfShared{};
+
+  auto childrenSize = children.size();
+  auto baseChildrenSize = baseChildren.size();
+  auto index = size_t{0};
+
+  // Stage 1: Aligned part.
+  for (index = 0; index < childrenSize && index < baseChildrenSize; index++) {
+    const auto &childNode = *children.at(index);
+    const auto &baseChildNode = *baseChildren.at(index);
+
+    if (&childNode == &baseChildNode) {
+      // Nodes are identical, skipping.
+      continue;
+    }
+
+    if (!ShadowNode::sameFamily(childNode, baseChildNode)) {
+      // Totally different nodes, updating is impossible.
+      break;
+    }
+
+    auto newChildNode = progressState(childNode, baseChildNode);
+    if (newChildNode) {
+      if (!areChildrenChanged) {
+        // Making a copy before the first mutation.
+        newChildren = children;
+      }
+      newChildren[index] = newChildNode;
+      areChildrenChanged = true;
+    }
+  }
+
+  // Stage 2: Misaligned part.
+  for (; index < childrenSize; index++) {
+    auto newChildNode = progressState(*children.at(index));
+    if (newChildNode) {
+      if (!areChildrenChanged) {
+        // Making a copy before the first mutation.
+        newChildren = children;
+      }
+      newChildren[index] = newChildNode;
+      areChildrenChanged = true;
+    }
+  }
+
+  if (!areChildrenChanged && !isStateChanged) {
+    return nullptr;
+  }
+
+  return shadowNode.clone({
+      ShadowNodeFragment::propsPlaceholder(),
+      areChildrenChanged ? std::make_shared<ShadowNode::ListOfShared const>(
+                               std::move(newChildren))
+                         : ShadowNodeFragment::childrenPlaceholder(),
+      isStateChanged ? newState : ShadowNodeFragment::statePlaceholder(),
+  });
+}
+
+static void updateMountedFlag(
+    const SharedShadowNodeList &oldChildren,
+    const SharedShadowNodeList &newChildren) {
+  // This is a simplified version of Diffing algorithm that only updates
+  // `mounted` flag on `ShadowNode`s. The algorithm sets "mounted" flag before
+  // "unmounted" to allow `ShadowNode` detect a situation where the node was
+  // remounted.
+
+  if (&oldChildren == &newChildren) {
+    // Lists are identical, nothing to do.
+    return;
+  }
+
+  if (oldChildren.empty() && newChildren.empty()) {
+    // Both lists are empty, nothing to do.
+    return;
+  }
+
+  size_t index;
+
+  // Stage 1: Mount and unmount "updated" children.
+  for (index = 0; index < oldChildren.size() && index < newChildren.size();
+       index++) {
+    const auto &oldChild = oldChildren[index];
+    const auto &newChild = newChildren[index];
+
+    if (oldChild == newChild) {
+      // Nodes are identical, skipping the subtree.
+      continue;
+    }
+
+    if (!ShadowNode::sameFamily(*oldChild, *newChild)) {
+      // Totally different nodes, updating is impossible.
+      break;
+    }
+
+    newChild->setMounted(true);
+    oldChild->setMounted(false);
+
+    updateMountedFlag(oldChild->getChildren(), newChild->getChildren());
+  }
+
+  size_t lastIndexAfterFirstStage = index;
+
+  // State 2: Mount new children.
+  for (index = lastIndexAfterFirstStage; index < newChildren.size(); index++) {
+    const auto &newChild = newChildren[index];
+    newChild->setMounted(true);
+    updateMountedFlag({}, newChild->getChildren());
+  }
+
+  // State 3: Unmount old children.
+  for (index = lastIndexAfterFirstStage; index < oldChildren.size(); index++) {
+    const auto &oldChild = oldChildren[index];
+    oldChild->setMounted(false);
+    updateMountedFlag(oldChild->getChildren(), {});
+  }
+}
+
+ShadowTree::ShadowTree(
+    SurfaceId surfaceId,
+    LayoutConstraints const &layoutConstraints,
+    LayoutContext const &layoutContext,
+    ShadowTreeDelegate const &delegate,
+    ContextContainer const &contextContainer)
+    : surfaceId_(surfaceId), delegate_(delegate) {
+  const auto noopEventEmitter = std::make_shared<const ViewEventEmitter>(
+      nullptr, -1, std::shared_ptr<const EventDispatcher>());
+
+  static auto globalRootComponentDescriptor =
+      std::make_unique<RootComponentDescriptor const>(
+          ComponentDescriptorParameters{
+              EventDispatcher::Shared{}, nullptr, nullptr});
+
+  const auto props = std::make_shared<const RootProps>(
+      PropsParserContext{surfaceId, contextContainer},
+      *RootShadowNode::defaultSharedProps(),
+      layoutConstraints,
+      layoutContext);
+
+  auto const fragment =
+      ShadowNodeFamilyFragment{surfaceId, surfaceId, noopEventEmitter};
+  auto family = globalRootComponentDescriptor->createFamily(fragment, nullptr);
+
+  auto rootShadowNode = std::static_pointer_cast<const RootShadowNode>(
+      globalRootComponentDescriptor->createShadowNode(
+          ShadowNodeFragment{
+              /* .props = */ props,
+          },
+          family));
+
+  currentRevision_ = ShadowTreeRevision{
+      rootShadowNode, INITIAL_REVISION, TransactionTelemetry{}};
+
+  mountingCoordinator_ =
+      std::make_shared<MountingCoordinator const>(currentRevision_);
+}
+
+ShadowTree::~ShadowTree() {
+  mountingCoordinator_->revoke();
+}
+
+Tag ShadowTree::getSurfaceId() const {
+  return surfaceId_;
+}
+
+void ShadowTree::setCommitMode(CommitMode commitMode) const {
+  auto revision = ShadowTreeRevision{};
+
+  {
+    std::unique_lock<better::shared_mutex> lock(commitMutex_);
+    if (commitMode_ == commitMode) {
+      return;
+    }
+
+    commitMode_ = commitMode;
+    revision = currentRevision_;
+  }
+
+  // initial revision never contains any commits so mounting it here is
+  // incorrect
+  if (commitMode == CommitMode::Normal && revision.number != INITIAL_REVISION) {
+    mount(revision);
+  }
+}
+
+CommitMode ShadowTree::getCommitMode() const {
+  std::shared_lock<better::shared_mutex> lock(commitMutex_);
+  return commitMode_;
+}
+
+MountingCoordinator::Shared ShadowTree::getMountingCoordinator() const {
+  return mountingCoordinator_;
+}
+
+CommitStatus ShadowTree::commit(
+    ShadowTreeCommitTransaction transaction,
+    CommitOptions commitOptions) const {
+  SystraceSection s("ShadowTree::commit");
+
+  int attempts = 0;
+
+  while (true) {
+    attempts++;
+
+    auto status = tryCommit(transaction, commitOptions);
+    if (status != CommitStatus::Failed) {
+      return status;
+    }
+
+    // After multiple attempts, we failed to commit the transaction.
+    // Something internally went terribly wrong.
+    react_native_assert(attempts < 1024);
+  }
+}
+
+CommitStatus ShadowTree::tryCommit(
+    ShadowTreeCommitTransaction transaction,
+    CommitOptions commitOptions) const {
+  SystraceSection s("ShadowTree::tryCommit");
+
+  auto telemetry = TransactionTelemetry{};
+  telemetry.willCommit();
+
+  CommitMode commitMode;
+  auto oldRevision = ShadowTreeRevision{};
+  auto newRevision = ShadowTreeRevision{};
+
+  {
+    // Reading `currentRevision_` in shared manner.
+    std::shared_lock<better::shared_mutex> lock(commitMutex_);
+    commitMode = commitMode_;
+    oldRevision = currentRevision_;
+  }
+
+  auto oldRootShadowNode = oldRevision.rootShadowNode;
+  auto newRootShadowNode = transaction(*oldRevision.rootShadowNode);
+
+  if (!newRootShadowNode ||
+      (commitOptions.shouldYield && commitOptions.shouldYield())) {
+    return CommitStatus::Cancelled;
+  }
+
+  if (commitOptions.enableStateReconciliation) {
+    auto updatedNewRootShadowNode =
+        progressState(*newRootShadowNode, *oldRevision.rootShadowNode);
+    if (updatedNewRootShadowNode) {
+      newRootShadowNode =
+          std::static_pointer_cast<RootShadowNode>(updatedNewRootShadowNode);
+    }
+  }
+
+  // Layout nodes.
+  std::vector<LayoutableShadowNode const *> affectedLayoutableNodes{};
+  affectedLayoutableNodes.reserve(1024);
+
+  telemetry.willLayout();
+  telemetry.setAsThreadLocal();
+  newRootShadowNode->layoutIfNeeded(&affectedLayoutableNodes);
+  telemetry.unsetAsThreadLocal();
+  telemetry.didLayout();
+
+  // Seal the shadow node so it can no longer be mutated
+  newRootShadowNode->sealRecursive();
+
+  {
+    // Updating `currentRevision_` in unique manner if it hasn't changed.
+    std::unique_lock<better::shared_mutex> lock(commitMutex_);
+
+    if (currentRevision_.number != oldRevision.number) {
+      return CommitStatus::Failed;
+    }
+
+    auto newRevisionNumber = oldRevision.number + 1;
+
+    newRootShadowNode = delegate_.shadowTreeWillCommit(
+        *this, oldRootShadowNode, newRootShadowNode);
+
+    if (!newRootShadowNode ||
+        (commitOptions.shouldYield && commitOptions.shouldYield())) {
+      return CommitStatus::Cancelled;
+    }
+
+    {
+      std::lock_guard<std::mutex> dispatchLock(EventEmitter::DispatchMutex());
+
+      updateMountedFlag(
+          currentRevision_.rootShadowNode->getChildren(),
+          newRootShadowNode->getChildren());
+    }
+
+    telemetry.didCommit();
+    telemetry.setRevisionNumber(static_cast<int>(newRevisionNumber));
+
+    newRevision =
+        ShadowTreeRevision{newRootShadowNode, newRevisionNumber, telemetry};
+
+    currentRevision_ = newRevision;
+  }
+
+  emitLayoutEvents(affectedLayoutableNodes);
+
+  if (commitMode == CommitMode::Normal) {
+    mount(newRevision);
+  }
+
+  return CommitStatus::Succeeded;
+}
+
+ShadowTreeRevision ShadowTree::getCurrentRevision() const {
+  std::shared_lock<better::shared_mutex> lock(commitMutex_);
+  return currentRevision_;
+}
+
+void ShadowTree::mount(ShadowTreeRevision const &revision) const {
+  mountingCoordinator_->push(revision);
+  delegate_.shadowTreeDidFinishTransaction(*this, mountingCoordinator_);
+}
+
+void ShadowTree::commitEmptyTree() const {
+  commit(
+      [](RootShadowNode const &oldRootShadowNode) -> RootShadowNode::Unshared {
+        return std::make_shared<RootShadowNode>(
+            oldRootShadowNode,
+            ShadowNodeFragment{
+                /* .props = */ ShadowNodeFragment::propsPlaceholder(),
+                /* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
+            });
+      });
+}
+
+void ShadowTree::emitLayoutEvents(
+    std::vector<LayoutableShadowNode const *> &affectedLayoutableNodes) const {
+  SystraceSection s("ShadowTree::emitLayoutEvents");
+
+  for (auto const *layoutableNode : affectedLayoutableNodes) {
+    // Only instances of `ViewShadowNode` (and subclasses) are supported.
+    auto const &viewShadowNode =
+        static_cast<ViewShadowNode const &>(*layoutableNode);
+    auto const &viewEventEmitter = static_cast<ViewEventEmitter const &>(
+        *viewShadowNode.getEventEmitter());
+
+    // Checking if the `onLayout` event was requested for the particular Shadow
+    // Node.
+    auto const &viewProps =
+        static_cast<ViewProps const &>(*viewShadowNode.getProps());
+    if (!viewProps.onLayout) {
+      continue;
+    }
+
+    viewEventEmitter.onLayout(layoutableNode->getLayoutMetrics());
+  }
+}
+
+void ShadowTree::notifyDelegatesOfUpdates() const {
+  delegate_.shadowTreeDidFinishTransaction(*this, mountingCoordinator_);
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -0,0 +1,146 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <better/mutex.h>
+#include <memory>
+
+#include <react/renderer/components/root/RootComponentDescriptor.h>
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/mounting/MountingCoordinator.h>
+#include <react/renderer/mounting/ShadowTreeDelegate.h>
+#include <react/renderer/mounting/ShadowTreeRevision.h>
+#include <react/utils/ContextContainer.h>
+#include "MountingOverrideDelegate.h"
+
+namespace facebook {
+namespace react {
+
+using ShadowTreeCommitTransaction = std::function<RootShadowNode::Unshared(
+    RootShadowNode const &oldRootShadowNode)>;
+
+/*
+ * Represents the shadow tree and its lifecycle.
+ */
+class ShadowTree final {
+ public:
+  using Unique = std::unique_ptr<ShadowTree>;
+
+  /*
+   * Represents a result of a `commit` operation.
+   */
+  enum class CommitStatus {
+    Succeeded,
+    Failed,
+    Cancelled,
+  };
+
+  /*
+   * Represents commits' side-effects propagation mode.
+   */
+  enum class CommitMode {
+    // Commits' side-effects are observable via `MountingCoordinator`.
+    // The rendering pipeline fully works end-to-end.
+    Normal,
+
+    // Commits' side-effects are *not* observable via `MountingCoordinator`.
+    // The mounting phase is skipped in the rendering pipeline.
+    Suspended,
+  };
+
+  struct CommitOptions {
+    bool enableStateReconciliation{false};
+
+    // Called during `tryCommit` phase. Returning true indicates current commit
+    // should yield to the next commit.
+    std::function<bool()> shouldYield;
+  };
+
+  /*
+   * Creates a new shadow tree instance.
+   */
+  ShadowTree(
+      SurfaceId surfaceId,
+      LayoutConstraints const &layoutConstraints,
+      LayoutContext const &layoutContext,
+      ShadowTreeDelegate const &delegate,
+      ContextContainer const &contextContainer);
+
+  ~ShadowTree();
+
+  /*
+   * Returns the `SurfaceId` associated with the shadow tree.
+   */
+  SurfaceId getSurfaceId() const;
+
+  /*
+   * Sets and gets the commit mode.
+   * Changing commit mode from `Suspended` to `Normal` will flush all suspended
+   * changes to `MountingCoordinator`.
+   */
+  void setCommitMode(CommitMode commitMode) const;
+  CommitMode getCommitMode() const;
+
+  /*
+   * Performs commit calling `transaction` function with a `oldRootShadowNode`
+   * and expecting a `newRootShadowNode` as a return value.
+   * The `transaction` function can cancel commit returning `nullptr`.
+   */
+  CommitStatus tryCommit(
+      ShadowTreeCommitTransaction transaction,
+      CommitOptions commitOptions = {false}) const;
+
+  /*
+   * Calls `tryCommit` in a loop until it finishes successfully.
+   */
+  CommitStatus commit(
+      ShadowTreeCommitTransaction transaction,
+      CommitOptions commitOptions = {false}) const;
+
+  /*
+   * Returns a `ShadowTreeRevision` representing the momentary state of
+   * the `ShadowTree`.
+   */
+  ShadowTreeRevision getCurrentRevision() const;
+
+  /*
+   * Commit an empty tree (a new `RootShadowNode` with no children).
+   */
+  void commitEmptyTree() const;
+
+  /**
+   * Forces the ShadowTree to ping its delegate that an update is available.
+   * Useful for animations on Android.
+   * @return
+   */
+  void notifyDelegatesOfUpdates() const;
+
+  MountingCoordinator::Shared getMountingCoordinator() const;
+
+ private:
+  constexpr static ShadowTreeRevision::Number INITIAL_REVISION{0};
+
+  void mount(ShadowTreeRevision const &revision) const;
+
+  void emitLayoutEvents(
+      std::vector<LayoutableShadowNode const *> &affectedLayoutableNodes) const;
+
+  SurfaceId const surfaceId_;
+  ShadowTreeDelegate const &delegate_;
+  mutable better::shared_mutex commitMutex_;
+  mutable CommitMode commitMode_{
+      CommitMode::Normal}; // Protected by `commitMutex_`.
+  mutable ShadowTreeRevision currentRevision_; // Protected by `commitMutex_`.
+  MountingCoordinator::Shared mountingCoordinator_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/mounting/ShadowTreeDelegate.h

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/mounting/MountingCoordinator.h>
+
+namespace facebook {
+namespace react {
+
+class ShadowTree;
+
+/*
+ * Abstract class for ShadowTree's delegate.
+ */
+class ShadowTreeDelegate {
+ public:
+  /*
+   * Called right before a ShadowTree commits a new tree.
+   * The receiver can alter a new (proposed) shadow tree with another tree
+   * by returning the altered tree.
+   * Returning a `nullptr` cancels the commit.
+   */
+  virtual RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode) const = 0;
+
+  /*
+   * Called right after Shadow Tree commit a new state of the tree.
+   */
+  virtual void shadowTreeDidFinishTransaction(
+      ShadowTree const &shadowTree,
+      MountingCoordinator::Shared const &mountingCoordinator) const = 0;
+
+  virtual ~ShadowTreeDelegate() noexcept = default;
+};
+
+} // namespace react
+} // namespace facebook