react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/react/renderer/core/RawPropsKeyMap.cpp

@@ -7,6 +7,8 @@
 
 #include "RawPropsKeyMap.h"
 
+#include <react/debug/react_native_assert.h>
+
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
@@ -61,30 +63,30 @@ void RawPropsKeyMap::reindex() noexcept {
   buckets_.resize(kPropNameLengthHardCap);
 
   auto length = RawPropsPropNameLength{0};
-  for (auto i = 0; i < items_.size(); i++) {
+  for (size_t i = 0; i < items_.size(); i++) {
     auto &item = items_[i];
     if (item.length != length) {
       for (auto j = length; j < item.length; j++) {
-        buckets_[j] = i;
+        buckets_[j] = static_cast<RawPropsPropNameLength>(i);
       }
       length = item.length;
     }
   }
 
   for (auto j = length; j < buckets_.size(); j++) {
-    buckets_[j] = items_.size();
+    buckets_[j] = static_cast<RawPropsPropNameLength>(items_.size());
   }
 }
 
 RawPropsValueIndex RawPropsKeyMap::at(
     char const *name,
     RawPropsPropNameLength length) noexcept {
-  assert(length > 0);
-  assert(length < kPropNameLengthHardCap);
+  react_native_assert(length > 0);
+  react_native_assert(length < kPropNameLengthHardCap);
   // 1. Find the bucket.
   auto lower = int{buckets_[length - 1]};
   auto upper = int{buckets_[length]} - 1;
-  assert(lower - 1 <= upper);
+  react_native_assert(lower - 1 <= upper);
 
   // 2. Binary search in the bucket.
   while (lower <= upper) {

package/ReactCommon/react/renderer/core/RawPropsParser.cpp

@@ -8,6 +8,7 @@
 #include "RawPropsParser.h"
 
 #include <folly/Likely.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/RawProps.h>
 
 #include <glog/logging.h>
@@ -40,7 +41,7 @@ RawValue const *RawPropsParser::at(
     // This is not thread-safe part; this happens only during initialization of
     // a `ComponentDescriptor` where it is actually safe.
     keys_.push_back(key);
-    nameToIndex_.insert(key, size_);
+    nameToIndex_.insert(key, static_cast<RawPropsValueIndex>(size_));
     size_++;
     return nullptr;
   }
@@ -62,14 +63,14 @@ RawValue const *RawPropsParser::at(
   // the same order every time. This is trivial if you have a simple Props
   // constructor, but difficult or impossible if you have a shared sub-prop
   // Struct that is used by multiple parent Props.
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
   bool resetLoop = false;
 #endif
   do {
     rawProps.keyIndexCursor_++;
 
     if (UNLIKELY(rawProps.keyIndexCursor_ >= size_)) {
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
       if (resetLoop) {
         LOG(ERROR) << "Looked up RawProps key that does not exist: "
                    << (std::string)key;
@@ -106,20 +107,21 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
       if (!rawProps.value_.isObject()) {
         LOG(ERROR) << "Preparse props: rawProps value is not object";
       }
-      assert(rawProps.value_.isObject());
+      react_native_assert(rawProps.value_.isObject());
       auto object = rawProps.value_.asObject(runtime);
 
       auto names = object.getPropertyNames(runtime);
       auto count = names.size(runtime);
       auto valueIndex = RawPropsValueIndex{0};
 
-      for (auto i = 0; i < count; i++) {
+      for (size_t i = 0; i < count; i++) {
         auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
         auto value = object.getProperty(runtime, nameValue);
 
         auto name = nameValue.utf8(runtime);
 
-        auto keyIndex = nameToIndex_.at(name.data(), name.size());
+        auto keyIndex = nameToIndex_.at(
+            name.data(), static_cast<RawPropsPropNameLength>(name.size()));
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;
         }
@@ -140,7 +142,8 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
       for (auto const &pair : dynamic.items()) {
         auto name = pair.first.getString();
 
-        auto keyIndex = nameToIndex_.at(name.data(), name.size());
+        auto keyIndex = nameToIndex_.at(
+            name.data(), static_cast<RawPropsPropNameLength>(name.size()));
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;
         }

package/ReactCommon/react/renderer/core/RawPropsParser.h

@@ -10,6 +10,7 @@
 #include <better/map.h>
 #include <better/small_vector.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsKeyMap.h>
@@ -40,8 +41,16 @@ class RawPropsParser final {
         std::is_base_of<Props, PropsT>::value,
         "PropsT must be a descendant of Props");
     RawProps emptyRawProps{};
-    emptyRawProps.parse(*this);
-    PropsT({}, emptyRawProps);
+
+    // Create a stub parser context.
+    // Since this prepares the parser by passing in
+    // empty props, no prop parsers should actually reference the
+    // ContextContainer or SurfaceId here.
+    ContextContainer contextContainer{};
+    PropsParserContext parserContext{-1, contextContainer};
+
+    emptyRawProps.parse(*this, parserContext);
+    PropsT(parserContext, {}, emptyRawProps);
     postPrepare();
   }
 

package/ReactCommon/react/renderer/core/RawValue.h

@@ -12,6 +12,8 @@
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
 
+#include <react/debug/react_native_assert.h>
+
 namespace facebook {
 namespace react {
 
@@ -189,7 +191,7 @@ class RawValue {
     }
 
     for (const auto &item : dynamic.items()) {
-      assert(item.first.isString());
+      react_native_assert(item.first.isString());
       if (!checkValueType(item.second, (T *)nullptr)) {
         return false;
       }
@@ -213,7 +215,7 @@ class RawValue {
   }
 
   static int castValue(const folly::dynamic &dynamic, int *type) noexcept {
-    return dynamic.asInt();
+    return static_cast<int>(dynamic.asInt());
   }
 
   static int64_t castValue(
@@ -223,7 +225,7 @@ class RawValue {
   }
 
   static float castValue(const folly::dynamic &dynamic, float *type) noexcept {
-    return dynamic.asDouble();
+    return static_cast<float>(dynamic.asDouble());
   }
 
   static double castValue(
@@ -242,7 +244,7 @@ class RawValue {
   static std::vector<T> castValue(
       const folly::dynamic &dynamic,
       std::vector<T> *type) noexcept {
-    assert(dynamic.isArray());
+    react_native_assert(dynamic.isArray());
     auto result = std::vector<T>{};
     result.reserve(dynamic.size());
     for (const auto &item : dynamic) {
@@ -255,7 +257,7 @@ class RawValue {
   static std::vector<std::vector<T>> castValue(
       const folly::dynamic &dynamic,
       std::vector<std::vector<T>> *type) noexcept {
-    assert(dynamic.isArray());
+    react_native_assert(dynamic.isArray());
     auto result = std::vector<std::vector<T>>{};
     result.reserve(dynamic.size());
     for (const auto &item : dynamic) {
@@ -268,10 +270,10 @@ class RawValue {
   static better::map<std::string, T> castValue(
       const folly::dynamic &dynamic,
       better::map<std::string, T> *type) noexcept {
-    assert(dynamic.isObject());
+    react_native_assert(dynamic.isObject());
     auto result = better::map<std::string, T>{};
     for (const auto &item : dynamic.items()) {
-      assert(item.first.isString());
+      react_native_assert(item.first.isString());
       result[item.first.getString()] = castValue(item.second, (T *)nullptr);
     }
     return result;

package/ReactCommon/react/renderer/core/ReactEventPriority.h

@@ -0,0 +1,43 @@
+/*
+ * 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
+
+namespace facebook {
+namespace react {
+
+/*
+ * An enum that represents React's event priority.
+ * Used to map Fabric events to React.
+ */
+enum class ReactEventPriority {
+  /*
+   * Event priority is unspecified.
+   */
+  Default,
+
+  /*
+   * User events that happen at discrete times, like
+   * input into text field.
+   */
+  Discrete,
+
+  /*
+   * “fluid” user events that happen many times over a short period of time like
+   * scrolling.
+   */
+  Continuous,
+};
+
+static constexpr std::underlying_type<ReactEventPriority>::type serialize(
+    ReactEventPriority reactEventPriority) {
+  return static_cast<std::underlying_type<ReactEventPriority>::type>(
+      reactEventPriority);
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/ReactPrimitives.h

@@ -8,8 +8,6 @@
 #pragma once
 
 #include <folly/dynamic.h>
-#include <react/renderer/core/RawProps.h>
-#include <react/renderer/core/RawValue.h>
 #include <memory>
 #include <string>
 
@@ -42,5 +40,39 @@ using ComponentHandle = int64_t;
  */
 using ComponentName = char const *;
 
+/*
+ * Defines how visual side effects (views, images, text, and so on) are
+ * mounted (on not) on the screen.
+ */
+enum class DisplayMode {
+  /*
+   * The surface is running normally. All visual side-effects will be rendered
+   * on the screen.
+   */
+  Visible = 0,
+
+  /*
+   * The surface is `Suspended`. All new (committed after switching to the
+   * mode) visual side-effects will *not* be mounted on the screen (the screen
+   * will stop updating).
+   *
+   * The mode can be used for preparing a surface for possible future use.
+   * The surface will be prepared without spending computing resources
+   * on mounting, and then can be instantly mounted if needed.
+   */
+  Suspended = 1,
+
+  /*
+   * The surface is `Hidden`. All previously mounted visual side-effects
+   * will be unmounted, and all new (committed after switching to the mode)
+   * visual side-effects will *not* be mounted on the screen until the mode is
+   * switched back to `normal`.
+   *
+   * The mode can be used for temporarily freeing computing resources of
+   * off-the-screen surfaces.
+   */
+  Hidden = 2,
+};
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/Sealable.cpp

@@ -7,7 +7,8 @@
 
 #include "Sealable.h"
 
-#include <cassert>
+#include <react/debug/flags.h>
+#include <react/debug/react_native_assert.h>
 
 namespace facebook {
 namespace react {
@@ -24,7 +25,7 @@ namespace react {
  * http://en.cppreference.com/w/cpp/language/rule_of_three
  */
 
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
 
 Sealable::Sealable() : sealed_(false) {}
 
@@ -56,7 +57,7 @@ bool Sealable::getSealed() const {
 }
 
 void Sealable::ensureUnsealed() const {
-  assert(!sealed_ && "Attempt to mutate a sealed object.");
+  react_native_assert(!sealed_ && "Attempt to mutate a sealed object.");
 }
 
 #endif

package/ReactCommon/react/renderer/core/Sealable.h

@@ -9,6 +9,8 @@
 
 #include <atomic>
 
+#include <react/debug/flags.h>
+
 namespace facebook {
 namespace react {
 
@@ -42,8 +44,9 @@ namespace react {
  *      must be prevented.
  */
 
-#ifdef NDEBUG
+#ifndef REACT_NATIVE_DEBUG
 
+// Release-mode, production version
 class Sealable {
  public:
   inline void seal() const {}
@@ -55,6 +58,7 @@ class Sealable {
 
 #else
 
+// Debug version
 class Sealable {
  public:
   Sealable();

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -6,10 +6,12 @@
  */
 
 #include "ShadowNode.h"
+#include "DynamicPropsUtilities.h"
 #include "ShadowNodeFragment.h"
 
 #include <better/small_vector.h>
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
@@ -24,6 +26,30 @@ SharedShadowNodeSharedList ShadowNode::emptySharedShadowNodeSharedList() {
   return emptySharedShadowNodeSharedList;
 }
 
+/*
+ * On iOS, this method returns `props` if provided, `sourceShadowNode`'s props
+ * otherwise. On Android, we forward props in case `sourceShadowNode` hasn't
+ * been mounted. `Props::rawProps` are merged from `props` to a copy of
+ * `sourceShadowNode.props_` and returned. This is necessary to enable
+ * Background Executor and should be removed once reimplementation of JNI layer
+ * is finished.
+ */
+SharedProps ShadowNode::propsForClonedShadowNode(
+    ShadowNode const &sourceShadowNode,
+    Props::Shared const &props) {
+#ifdef ANDROID
+  bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
+  bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
+  if (!hasBeenMounted && sourceNodeHasRawProps && props) {
+    auto &castedProps = const_cast<Props &>(*props);
+    castedProps.rawProps = mergeDynamicProps(
+        sourceShadowNode.getProps()->rawProps, props->rawProps);
+    return props;
+  }
+#endif
+  return props ? props : sourceShadowNode.getProps();
+}
+
 bool ShadowNode::sameFamily(const ShadowNode &first, const ShadowNode &second) {
   return first.family_ == second.family_;
 }
@@ -46,8 +72,8 @@ ShadowNode::ShadowNode(
       orderIndex_(0),
       family_(family),
       traits_(traits) {
-  assert(props_);
-  assert(children_);
+  react_native_assert(props_);
+  react_native_assert(children_);
 
   traits_.set(ShadowNodeTraits::Trait::ChildrenAreShared);
 
@@ -60,13 +86,13 @@ ShadowNode::ShadowNode(
 }
 
 ShadowNode::ShadowNode(
-    const ShadowNode &sourceShadowNode,
-    const ShadowNodeFragment &fragment)
+    ShadowNode const &sourceShadowNode,
+    ShadowNodeFragment const &fragment)
     :
 #if RN_DEBUG_STRING_CONVERTIBLE
       revision_(sourceShadowNode.revision_ + 1),
 #endif
-      props_(fragment.props ? fragment.props : sourceShadowNode.props_),
+      props_(propsForClonedShadowNode(sourceShadowNode, fragment.props)),
       children_(
           fragment.children ? fragment.children : sourceShadowNode.children_),
       state_(
@@ -76,8 +102,8 @@ ShadowNode::ShadowNode(
       family_(sourceShadowNode.family_),
       traits_(sourceShadowNode.traits_) {
 
-  assert(props_);
-  assert(children_);
+  react_native_assert(props_);
+  react_native_assert(children_);
 
   traits_.set(ShadowNodeTraits::Trait::ChildrenAreShared);
 
@@ -88,7 +114,8 @@ ShadowNode::ShadowNode(
   }
 }
 
-UnsharedShadowNode ShadowNode::clone(const ShadowNodeFragment &fragment) const {
+ShadowNode::Unshared ShadowNode::clone(
+    const ShadowNodeFragment &fragment) const {
   return family_->componentDescriptor_.cloneShadowNode(*this, fragment);
 }
 
@@ -183,7 +210,7 @@ void ShadowNode::replaceChild(
       *std::const_pointer_cast<ShadowNode::ListOfShared>(children_);
   auto size = children.size();
 
-  if (suggestedIndex != -1 && suggestedIndex < size) {
+  if (suggestedIndex != -1 && static_cast<size_t>(suggestedIndex) < size) {
     // If provided `suggestedIndex` is accurate,
     // replacing in place using the index.
     if (children.at(suggestedIndex).get() == &oldChild) {
@@ -192,14 +219,14 @@ void ShadowNode::replaceChild(
     }
   }
 
-  for (auto index = 0; index < size; index++) {
+  for (size_t index = 0; index < size; index++) {
     if (children.at(index).get() == &oldChild) {
       children[index] = newChild;
       return;
     }
   }
 
-  assert(false && "Child to replace was not found.");
+  react_native_assert(false && "Child to replace was not found.");
 }
 
 void ShadowNode::cloneChildrenIfShared() {
@@ -214,6 +241,7 @@ void ShadowNode::cloneChildrenIfShared() {
 void ShadowNode::setMounted(bool mounted) const {
   if (mounted) {
     family_->setMostRecentState(getState());
+    hasBeenMounted_ = mounted;
   }
 
   family_->eventEmitter_->setEnabled(mounted);
@@ -238,7 +266,7 @@ ShadowNode::Unshared ShadowNode::cloneTree(
 
   auto newShadowNode = callback(*oldShadowNode);
 
-  assert(
+  react_native_assert(
       newShadowNode &&
       "`callback` returned `nullptr` which is not allowed value.");
 
@@ -249,7 +277,8 @@ ShadowNode::Unshared ShadowNode::cloneTree(
     auto childIndex = it->second;
 
     auto children = parentNode.getChildren();
-    assert(ShadowNode::sameFamily(*children.at(childIndex), *childNode));
+    react_native_assert(
+        ShadowNode::sameFamily(*children.at(childIndex), *childNode));
     children[childIndex] = childNode;
 
     childNode = parentNode.clone({

package/ReactCommon/react/renderer/core/ShadowNode.h

@@ -33,7 +33,6 @@ class ShadowNode;
 // Deprecated: Use ShadowNode::Shared instead
 using SharedShadowNode = std::shared_ptr<const ShadowNode>;
 using WeakShadowNode = std::weak_ptr<const ShadowNode>;
-using UnsharedShadowNode = std::shared_ptr<ShadowNode>;
 using SharedShadowNodeList =
     better::small_vector<SharedShadowNode, kShadowNodeChildrenSmallVectorSize>;
 using SharedShadowNodeSharedList = std::shared_ptr<const SharedShadowNodeList>;
@@ -46,8 +45,11 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
   using Unshared = std::shared_ptr<ShadowNode>;
   using ListOfShared =
       better::small_vector<Shared, kShadowNodeChildrenSmallVectorSize>;
+  using ListOfWeak =
+      better::small_vector<Weak, kShadowNodeChildrenSmallVectorSize>;
   using SharedListOfShared = std::shared_ptr<ListOfShared const>;
   using UnsharedListOfShared = std::shared_ptr<ListOfShared>;
+  using UnsharedListOfWeak = std::shared_ptr<ListOfWeak>;
 
   using AncestorList = better::small_vector<
       std::pair<
@@ -101,7 +103,7 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
   /*
    * Clones the shadow node using stored `cloneFunction`.
    */
-  UnsharedShadowNode clone(const ShadowNodeFragment &fragment) const;
+  ShadowNode::Unshared clone(const ShadowNodeFragment &fragment) const;
 
   /*
    * Clones the node (and partially the tree starting from the node) by
@@ -176,8 +178,6 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
    */
   void setMounted(bool mounted) const;
 
-  int getStateRevision() const;
-
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE
@@ -214,6 +214,12 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
    */
   ShadowNodeFamily::Shared family_;
 
+  mutable std::atomic<bool> hasBeenMounted_{false};
+
+  static SharedProps propsForClonedShadowNode(
+      ShadowNode const &sourceShadowNode,
+      Props::Shared const &props);
+
  protected:
   /*
    * Traits associated with the particular `ShadowNode` class and an instance of
@@ -234,5 +240,9 @@ ShadowNodeReferenceT traitCast(ShadowNode const &shadowNode);
 template <typename ShadowNodePointerT>
 ShadowNodePointerT traitCast(ShadowNode const *shadowNode);
 
+template <typename ShadowNodePointerT>
+std::shared_ptr<ShadowNodePointerT const> traitCast(
+    std::shared_ptr<ShadowNode const> shadowNode);
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/ShadowNodeFamily.cpp

@@ -8,6 +8,7 @@
 #include "ShadowNodeFamily.h"
 #include "ShadowNode.h"
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/State.h>
 
@@ -29,7 +30,7 @@ ShadowNodeFamily::ShadowNodeFamily(
       componentName_(componentDescriptor.getComponentName()) {}
 
 void ShadowNodeFamily::setParent(ShadowNodeFamily::Shared const &parent) const {
-  assert(parent_.lock() == nullptr || parent_.lock() == parent);
+  react_native_assert(parent_.lock() == nullptr || parent_.lock() == parent);
   if (hasParent_) {
     return;
   }

package/ReactCommon/react/renderer/core/ShadowNodeFamily.h

@@ -10,6 +10,7 @@
 #include <memory>
 
 #include <better/mutex.h>
+#include <better/small_vector.h>
 
 #include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/ReactPrimitives.h>
@@ -26,7 +27,7 @@ class State;
  * Represents all things that shadow nodes from the same family have in common.
  * To be used inside `ShadowNode` class *only*.
  */
-class ShadowNodeFamily {
+class ShadowNodeFamily final {
  public:
   using Shared = std::shared_ptr<ShadowNodeFamily const>;
   using Weak = std::weak_ptr<ShadowNodeFamily const>;

package/ReactCommon/react/renderer/core/ShadowNodeTraits.h

@@ -21,7 +21,7 @@ class ShadowNodeTraits {
  public:
   /*
    * Underlying type for the traits.
-   * The first 16 bits are reserved for Core.
+   * The first 23 bits are reserved for Core.
    */
   enum Trait : int32_t {
     None = 0,
@@ -82,6 +82,22 @@ class ShadowNodeTraits {
     // Indicates that `children` list is shared between nodes and need
     // to be cloned before the first mutation.
     ChildrenAreShared = 1 << 15,
+
+    // Inherits 'RawTextShadowNode'
+    RawText = 1 << 16,
+
+    // Inherits 'TextShadowNode'
+    Text = 1 << 17,
+
+    // Reserved
+    ReservedTrait1 = 1 << 18,
+    ReservedTrait2 = 1 << 19,
+    ReservedTrait3 = 1 << 20,
+    ReservedTrait4 = 1 << 21,
+    ReservedTrait5 = 1 << 22,
+
+    // Unserved - alias these for local usage
+    UnreservedTrait1 = 1 << 23
   };
 
   /*

package/ReactCommon/react/renderer/core/State.h

@@ -9,6 +9,8 @@
 
 #ifdef ANDROID
 #include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
 
 #include <react/renderer/core/ShadowNodeFamily.h>
@@ -65,6 +67,7 @@ class State {
 
 #ifdef ANDROID
   virtual folly::dynamic getDynamic() const = 0;
+  virtual MapBuffer getMapBuffer() const = 0;
   virtual void updateState(folly::dynamic data) const = 0;
 #endif
 

package/ReactCommon/react/renderer/core/StateData.h

@@ -11,6 +11,8 @@
 
 #ifdef ANDROID
 #include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
 
 namespace facebook {
@@ -27,6 +29,7 @@ struct StateData final {
   StateData() = default;
   StateData(StateData const &previousState, folly::dynamic data){};
   folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const;
 #endif
 };