react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactCommon/reactperflogger/CMakeLists.txt

@@ -21,4 +21,7 @@ add_library(reactperflogger OBJECT ${reactperflogger_SRC})
 
 target_include_directories(reactperflogger PUBLIC .)
 
-target_link_libraries(reactperflogger folly_runtime)
+target_link_libraries(reactperflogger
+        react_timing
+        folly_runtime
+)

package/ReactCommon/reactperflogger/React-perflogger.podspec

@@ -24,6 +24,7 @@ header_search_paths = [
   "\"$(PODS_TARGET_SRCROOT)/..\"",
   "\"$(PODS_ROOT)/RCT-Folly\"",
   "\"$(PODS_ROOT)/DoubleConversion\"",
+  "\"$(PODS_ROOT)/fast_float/include\"",
   "\"$(PODS_ROOT)/fmt/include\""
 ]
 

package/ReactCommon/reactperflogger/reactperflogger/FuseboxPerfettoDataSource.cpp

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifdef WITH_PERFETTO
+
+#include <android/log.h>
+#include <folly/json.h>
+#include <hermes/hermes.h>
+#include <perfetto.h>
+#include <iostream>
+
+#include <reactperflogger/fusebox/FuseboxTracer.h>
+#include "FuseboxPerfettoDataSource.h"
+#include "ReactPerfetto.h"
+
+namespace facebook::react {
+
+namespace {
+
+const std::string JS_SAMPLING_TRACK = "JS Sampling";
+
+const int SAMPLING_HZ = 1000;
+
+using perfetto::TrackEvent;
+
+std::string getApplicationId() {
+  pid_t pid = getpid();
+  char path[64] = {0};
+  snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
+  FILE* cmdline = fopen(path, "r");
+  if (cmdline) {
+    char application_id[64] = {0};
+    fread(application_id, sizeof(application_id), 1, cmdline);
+    fclose(cmdline);
+    return application_id;
+  }
+  return "";
+}
+
+uint64_t hermesToPerfettoTime(int64_t hermesTs) {
+  return (hermesTs / 1000);
+}
+
+std::vector<folly::dynamic> getStack(
+    const folly::dynamic& trace,
+    const folly::dynamic& sample) {
+  std::vector<folly::dynamic> stack;
+
+  auto stackFrameId = sample["sf"];
+  auto stackFrame = trace["stackFrames"][stackFrameId.asString()];
+
+  while (!stackFrame.isNull()) {
+    stack.push_back(stackFrame);
+    auto parentStackFrameId = stackFrame["parent"];
+    if (parentStackFrameId.isNull()) {
+      break; // No more parents, we're done with this stack frame
+    }
+    stackFrame = trace["stackFrames"][parentStackFrameId.asString()];
+  }
+  std::reverse(stack.begin(), stack.end());
+  return stack;
+}
+
+void flushSample(
+    const std::vector<folly::dynamic>& stack,
+    uint64_t start,
+    uint64_t end) {
+  for (size_t i = 0; i < stack.size(); i++) {
+    const auto& frame = stack[i];
+    // Omit elements that are not the first 25 or the last 25
+    if (i > 25 && i < stack.size() - 25) {
+      if (i == 26) {
+        FuseboxTracer::getFuseboxTracer().addEvent(
+            "...", start, end, JS_SAMPLING_TRACK);
+      }
+      continue;
+    }
+    std::string name = frame["name"].asString();
+    FuseboxTracer::getFuseboxTracer().addEvent(
+        name, start, end, JS_SAMPLING_TRACK);
+  }
+}
+
+void logHermesProfileToFusebox(const std::string& traceStr) {
+  auto trace = folly::parseJson(traceStr);
+  auto samples = trace["samples"];
+
+  std::vector previousStack = std::vector<folly::dynamic>();
+  uint64_t previousStartTS = 0;
+  uint64_t previousEndTS = 0;
+  for (const auto& sample : samples) {
+    auto perfettoTS = hermesToPerfettoTime(sample["ts"].asInt());
+
+    // Flush previous sample
+    if (previousStack.size() > 0) {
+      flushSample(
+          previousStack,
+          previousStartTS,
+          std::min(previousEndTS, perfettoTS - 1));
+    }
+
+    previousStack = getStack(trace, sample);
+    previousStartTS = perfettoTS;
+    previousEndTS = previousStartTS + 1000000000 / SAMPLING_HZ;
+  }
+  if (previousStack.size() > 0) {
+    flushSample(previousStack, previousStartTS, previousEndTS);
+  }
+}
+} // namespace
+
+void FuseboxPerfettoDataSource::OnStart(const StartArgs&) {
+  FuseboxTracer::getFuseboxTracer().startTracing();
+  facebook::hermes::HermesRuntime::enableSamplingProfiler(SAMPLING_HZ);
+}
+
+void FuseboxPerfettoDataSource::OnFlush(const FlushArgs&) {}
+
+void FuseboxPerfettoDataSource::OnStop(const StopArgs& a) {
+  std::stringstream stream;
+  facebook::hermes::HermesRuntime::dumpSampledTraceToStream(stream);
+  std::string trace = stream.str();
+  logHermesProfileToFusebox(trace);
+
+  // XXX: Adjust the package ID. Writing to other global tmp directories
+  // seems to fail.
+  std::string appId = getApplicationId();
+  __android_log_print(
+      ANDROID_LOG_INFO, "FuseboxTracer", "Application ID: %s", appId.c_str());
+  FuseboxTracer::getFuseboxTracer().stopTracingAndWriteToFile(
+      "/data/data/" + appId + "/cache/hermes_trace.json");
+}
+
+} // namespace facebook::react
+
+PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(
+    facebook::react::FuseboxPerfettoDataSource);
+
+#endif // WITH_PERFETTO

package/ReactCommon/reactperflogger/reactperflogger/FuseboxPerfettoDataSource.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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
+
+#ifdef WITH_PERFETTO
+
+#include <perfetto.h>
+
+namespace facebook::react {
+
+/**
+ * This is a special datasource that will use Perfetto to start/stop
+ * a FuseboxTracer trace (which will be saved to disk, not to the Perfetto
+ * trace) while we wait for Fusebox to be supported in release builds.
+ * Once it's supported we'll probably want to deprecate this data source.
+ */
+class FuseboxPerfettoDataSource
+    : public perfetto::DataSource<FuseboxPerfettoDataSource> {
+ public:
+  void OnSetup(const SetupArgs&) override {}
+
+  void OnStart(const StartArgs&) override;
+
+  void OnFlush(const FlushArgs&) override;
+
+  void OnStop(const StopArgs& a) override;
+
+  static void RegisterDataSource() {
+    perfetto::DataSourceDescriptor dsd;
+    dsd.set_name("com.facebook.react.fusebox.profiler");
+    FuseboxPerfettoDataSource::Register(dsd);
+  }
+
+  constexpr static perfetto::BufferExhaustedPolicy kBufferExhaustedPolicy =
+      perfetto::BufferExhaustedPolicy::kStall;
+};
+
+} // namespace facebook::react
+
+PERFETTO_DECLARE_DATA_SOURCE_STATIC_MEMBERS(
+    facebook::react::FuseboxPerfettoDataSource);
+
+#endif // WITH_PERFETTO

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfLogger.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "ReactPerfLogger.h"
+
+#include <react/timing/primitives.h>
+#if __has_include(<reactperflogger/fusebox/FuseboxTracer.h>)
+#include <reactperflogger/fusebox/FuseboxTracer.h>
+#define HAS_FUSEBOX
+#endif
+#include <chrono>
+
+#include "ReactPerfetto.h"
+
+namespace facebook::react {
+
+/* static */ void ReactPerfLogger::measure(
+    const std::string_view& eventName,
+    double startTime,
+    double endTime,
+    const std::string_view& trackName) {
+#ifdef HAS_FUSEBOX
+  FuseboxTracer::getFuseboxTracer().addEvent(
+      eventName, (uint64_t)startTime, (uint64_t)endTime, trackName);
+#endif
+
+#ifdef WITH_PERFETTO
+  if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
+    auto track = getPerfettoWebPerfTrackAsync(std::string(trackName));
+    TRACE_EVENT_BEGIN(
+        "react-native",
+        perfetto::DynamicString(eventName.data(), eventName.size()),
+        track,
+        performanceNowToPerfettoTraceTime(startTime));
+    TRACE_EVENT_END(
+        "react-native", track, performanceNowToPerfettoTraceTime(endTime));
+  }
+#endif
+}
+
+/* static */ void ReactPerfLogger::mark(
+    const std::string_view& eventName,
+    double startTime,
+    const std::string_view& trackName) {
+  // TODO(T203046480) Support mark in FuseboxTracer
+
+#ifdef WITH_PERFETTO
+  if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
+    TRACE_EVENT_INSTANT(
+        "react-native",
+        perfetto::DynamicString(eventName.data(), eventName.size()),
+        getPerfettoWebPerfTrackSync(std::string(trackName)),
+        performanceNowToPerfettoTraceTime(startTime));
+  }
+#endif
+}
+
+/* static */ double ReactPerfLogger::performanceNow() {
+  return chronoToDOMHighResTimeStamp(std::chrono::steady_clock::now());
+}
+} // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfLogger.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and 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 <reactperflogger/ReactPerfettoCategories.h>
+#include <string>
+
+namespace facebook::react {
+
+class ReactPerfLogger {
+ public:
+  static void mark(
+      const std::string_view& eventName,
+      double startTime,
+      const std::string_view& trackName);
+
+  /**
+   * This accepts performance events that should go to internal tracing
+   * frameworks like Perfetto, and should go to DevTools like Fusebox.
+   */
+  static void measure(
+      const std::string_view& eventName,
+      double startTime,
+      double endTime,
+      const std::string_view& trackName);
+
+  static double performanceNow();
+};
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfetto.cpp

@@ -12,6 +12,7 @@
 #include <perfetto.h>
 #include <unordered_map>
 
+#include "FuseboxPerfettoDataSource.h"
 #include "HermesPerfettoDataSource.h"
 #include "ReactPerfettoCategories.h"
 
@@ -32,6 +33,7 @@ void initializePerfetto() {
   });
 
   HermesPerfettoDataSource::RegisterDataSource();
+  FuseboxPerfettoDataSource::RegisterDataSource();
 }
 
 static perfetto::Track createTrack(const std::string& trackName) {

package/ReactCommon/runtimeexecutor/React-runtimeexecutor.podspec

@@ -19,7 +19,8 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags] 
 
 Pod::Spec.new do |s|
   s.name                   = "React-runtimeexecutor"

package/ReactCommon/yoga/yoga/YGEnums.cpp

@@ -33,6 +33,16 @@ const char* YGAlignToString(const YGAlign value) {
   return "unknown";
 }
 
+const char* YGBoxSizingToString(const YGBoxSizing value) {
+  switch (value) {
+    case YGBoxSizingBorderBox:
+      return "border-box";
+    case YGBoxSizingContentBox:
+      return "content-box";
+  }
+  return "unknown";
+}
+
 const char* YGDimensionToString(const YGDimension value) {
   switch (value) {
     case YGDimensionWidth:
@@ -61,6 +71,8 @@ const char* YGDisplayToString(const YGDisplay value) {
       return "flex";
     case YGDisplayNone:
       return "none";
+    case YGDisplayContents:
+      return "contents";
   }
   return "unknown";
 }
@@ -95,8 +107,8 @@ const char* YGErrataToString(const YGErrata value) {
       return "none";
     case YGErrataStretchFlexBasis:
       return "stretch-flex-basis";
-    case YGErrataAbsolutePositioningIncorrect:
-      return "absolute-positioning-incorrect";
+    case YGErrataAbsolutePositionWithoutInsetsExcludesPadding:
+      return "absolute-position-without-insets-excludes-padding";
     case YGErrataAbsolutePercentAgainstInnerSize:
       return "absolute-percent-against-inner-size";
     case YGErrataAll:

package/ReactCommon/yoga/yoga/YGEnums.h

@@ -24,6 +24,11 @@ YG_ENUM_DECL(
     YGAlignSpaceAround,
     YGAlignSpaceEvenly)
 
+YG_ENUM_DECL(
+    YGBoxSizing,
+    YGBoxSizingBorderBox,
+    YGBoxSizingContentBox)
+
 YG_ENUM_DECL(
     YGDimension,
     YGDimensionWidth,
@@ -38,7 +43,8 @@ YG_ENUM_DECL(
 YG_ENUM_DECL(
     YGDisplay,
     YGDisplayFlex,
-    YGDisplayNone)
+    YGDisplayNone,
+    YGDisplayContents)
 
 YG_ENUM_DECL(
     YGEdge,
@@ -56,7 +62,7 @@ YG_ENUM_DECL(
     YGErrata,
     YGErrataNone = 0,
     YGErrataStretchFlexBasis = 1,
-    YGErrataAbsolutePositioningIncorrect = 2,
+    YGErrataAbsolutePositionWithoutInsetsExcludesPadding = 2,
     YGErrataAbsolutePercentAgainstInnerSize = 4,
     YGErrataAll = 2147483647,
     YGErrataClassic = 2147483646)

package/ReactCommon/yoga/yoga/YGNodeStyle.cpp

@@ -177,18 +177,19 @@ float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) {
 
 void YGNodeStyleSetFlexBasis(const YGNodeRef node, const float flexBasis) {
   updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, value::points(flexBasis));
+      node, StyleLength::points(flexBasis));
 }
 
 void YGNodeStyleSetFlexBasisPercent(
     const YGNodeRef node,
     const float flexBasisPercent) {
   updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, value::percent(flexBasisPercent));
+      node, StyleLength::percent(flexBasisPercent));
 }
 
 void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) {
-  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(node, value::ofAuto());
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleLength::ofAuto());
 }
 
 YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
@@ -197,17 +198,17 @@ YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
 
 void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
   updateStyle<&Style::position, &Style::setPosition>(
-      node, scopedEnum(edge), value::points(points));
+      node, scopedEnum(edge), StyleLength::points(points));
 }
 
 void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
   updateStyle<&Style::position, &Style::setPosition>(
-      node, scopedEnum(edge), value::percent(percent));
+      node, scopedEnum(edge), StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge) {
   updateStyle<&Style::position, &Style::setPosition>(
-      node, scopedEnum(edge), value::ofAuto());
+      node, scopedEnum(edge), StyleLength::ofAuto());
 }
 
 YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
@@ -216,17 +217,17 @@ YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
 
 void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
   updateStyle<&Style::margin, &Style::setMargin>(
-      node, scopedEnum(edge), value::points(points));
+      node, scopedEnum(edge), StyleLength::points(points));
 }
 
 void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
   updateStyle<&Style::margin, &Style::setMargin>(
-      node, scopedEnum(edge), value::percent(percent));
+      node, scopedEnum(edge), StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
   updateStyle<&Style::margin, &Style::setMargin>(
-      node, scopedEnum(edge), value::ofAuto());
+      node, scopedEnum(edge), StyleLength::ofAuto());
 }
 
 YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
@@ -235,12 +236,12 @@ YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
 
 void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
   updateStyle<&Style::padding, &Style::setPadding>(
-      node, scopedEnum(edge), value::points(points));
+      node, scopedEnum(edge), StyleLength::points(points));
 }
 
 void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
   updateStyle<&Style::padding, &Style::setPadding>(
-      node, scopedEnum(edge), value::percent(percent));
+      node, scopedEnum(edge), StyleLength::percent(percent));
 }
 
 YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
@@ -252,7 +253,7 @@ void YGNodeStyleSetBorder(
     const YGEdge edge,
     const float border) {
   updateStyle<&Style::border, &Style::setBorder>(
-      node, scopedEnum(edge), value::points(border));
+      node, scopedEnum(edge), StyleLength::points(border));
 }
 
 float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) {
@@ -269,12 +270,12 @@ void YGNodeStyleSetGap(
     const YGGutter gutter,
     const float gapLength) {
   updateStyle<&Style::gap, &Style::setGap>(
-      node, scopedEnum(gutter), value::points(gapLength));
+      node, scopedEnum(gutter), StyleLength::points(gapLength));
 }
 
 void YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float percent) {
   updateStyle<&Style::gap, &Style::setGap>(
-      node, scopedEnum(gutter), value::percent(percent));
+      node, scopedEnum(gutter), StyleLength::percent(percent));
 }
 
 float YGNodeStyleGetGap(const YGNodeConstRef node, const YGGutter gutter) {
@@ -296,19 +297,28 @@ float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) {
   return op.isUndefined() ? YGUndefined : op.unwrap();
 }
 
+void YGNodeStyleSetBoxSizing(YGNodeRef node, YGBoxSizing boxSizing) {
+  updateStyle<&Style::boxSizing, &Style::setBoxSizing>(
+      node, scopedEnum(boxSizing));
+}
+
+YGBoxSizing YGNodeStyleGetBoxSizing(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().boxSizing());
+}
+
 void YGNodeStyleSetWidth(YGNodeRef node, float points) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, value::points(points));
+      node, Dimension::Width, StyleLength::points(points));
 }
 
 void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, value::percent(percent));
+      node, Dimension::Width, StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetWidthAuto(YGNodeRef node) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, value::ofAuto());
+      node, Dimension::Width, StyleLength::ofAuto());
 }
 
 YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
@@ -317,17 +327,17 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
 
 void YGNodeStyleSetHeight(YGNodeRef node, float points) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, value::points(points));
+      node, Dimension::Height, StyleLength::points(points));
 }
 
 void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, value::percent(percent));
+      node, Dimension::Height, StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetHeightAuto(YGNodeRef node) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, value::ofAuto());
+      node, Dimension::Height, StyleLength::ofAuto());
 }
 
 YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
@@ -336,12 +346,12 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
 
 void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, value::points(minWidth));
+      node, Dimension::Width, StyleLength::points(minWidth));
 }
 
 void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, value::percent(minWidth));
+      node, Dimension::Width, StyleLength::percent(minWidth));
 }
 
 YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
@@ -350,14 +360,14 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, value::points(minHeight));
+      node, Dimension::Height, StyleLength::points(minHeight));
 }
 
 void YGNodeStyleSetMinHeightPercent(
     const YGNodeRef node,
     const float minHeight) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, value::percent(minHeight));
+      node, Dimension::Height, StyleLength::percent(minHeight));
 }
 
 YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
@@ -366,12 +376,12 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, value::points(maxWidth));
+      node, Dimension::Width, StyleLength::points(maxWidth));
 }
 
 void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, value::percent(maxWidth));
+      node, Dimension::Width, StyleLength::percent(maxWidth));
 }
 
 YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
@@ -380,14 +390,14 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, value::points(maxHeight));
+      node, Dimension::Height, StyleLength::points(maxHeight));
 }
 
 void YGNodeStyleSetMaxHeightPercent(
     const YGNodeRef node,
     const float maxHeight) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, value::percent(maxHeight));
+      node, Dimension::Height, StyleLength::percent(maxHeight));
 }
 
 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {

package/ReactCommon/yoga/yoga/YGNodeStyle.h

@@ -95,6 +95,9 @@ YG_EXPORT void
 YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float gapLength);
 YG_EXPORT float YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter);
 
+YG_EXPORT void YGNodeStyleSetBoxSizing(YGNodeRef node, YGBoxSizing boxSizing);
+YG_EXPORT YGBoxSizing YGNodeStyleGetBoxSizing(YGNodeConstRef node);
+
 YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width);
 YG_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width);
 YG_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node);