react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactCommon/react/renderer/leakchecker/LeakChecker.cpp

@@ -8,15 +8,13 @@
 #include "LeakChecker.h"
 
 #include <glog/logging.h>
+#include <jsi/instrumentation.h>
 
 namespace facebook {
 namespace react {
 
-LeakChecker::LeakChecker(
-    RuntimeExecutor const &runtimeExecutor,
-    GarbageCollectionTrigger const &garbageCollectionTrigger)
-    : runtimeExecutor_(runtimeExecutor),
-      garbageCollectionTrigger_(garbageCollectionTrigger) {}
+LeakChecker::LeakChecker(RuntimeExecutor const &runtimeExecutor)
+    : runtimeExecutor_(runtimeExecutor) {}
 
 void LeakChecker::uiManagerDidCreateShadowNodeFamily(
     ShadowNodeFamily::Shared const &shadowNodeFamily) const {
@@ -24,13 +22,12 @@ void LeakChecker::uiManagerDidCreateShadowNodeFamily(
 }
 
 void LeakChecker::stopSurface(SurfaceId surfaceId) {
-  garbageCollectionTrigger_();
-
   if (previouslyStoppedSurface_ > 0) {
     // Dispatch the check onto JavaScript thread to make sure all other
     // cleanup code has had chance to run.
     runtimeExecutor_([previouslySoppedSurface = previouslyStoppedSurface_,
-                      this](jsi::Runtime &) {
+                      this](jsi::Runtime &runtime) {
+      runtime.instrumentation().collectGarbage("LeakChecker");
       // For now check the previous surface because React uses double
       // buffering which keeps the surface that was just stopped in
       // memory. This is a documented problem in the last point of
@@ -44,7 +41,7 @@ void LeakChecker::stopSurface(SurfaceId surfaceId) {
 
 void LeakChecker::checkSurfaceForLeaks(SurfaceId surfaceId) const {
   auto weakFamilies = registry_.weakFamiliesForSurfaceId(surfaceId);
-  uint numberOfLeaks = 0;
+  unsigned int numberOfLeaks = 0;
   for (auto const &weakFamily : weakFamilies) {
     auto strong = weakFamily.lock();
     if (strong) {

package/ReactCommon/react/renderer/leakchecker/LeakChecker.h

@@ -20,9 +20,7 @@ using GarbageCollectionTrigger = std::function<void()>;
 
 class LeakChecker final {
  public:
-  LeakChecker(
-      RuntimeExecutor const &runtimeExecutor,
-      GarbageCollectionTrigger const &garbageCollectionTrigger);
+  LeakChecker(RuntimeExecutor const &runtimeExecutor);
 
   void uiManagerDidCreateShadowNodeFamily(
       ShadowNodeFamily::Shared const &shadowNodeFamily) const;
@@ -32,7 +30,6 @@ class LeakChecker final {
   void checkSurfaceForLeaks(SurfaceId surfaceId) const;
 
   RuntimeExecutor const runtimeExecutor_{};
-  GarbageCollectionTrigger const garbageCollectionTrigger_{};
 
   WeakFamilyRegistry registry_{};
   SurfaceId previouslyStoppedSurface_;

package/ReactCommon/react/renderer/mapbuffer/BUCK

@@ -40,7 +40,7 @@ rn_xplat_cxx_library(
     force_static = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
     macosx_tests_override = [],
-    platforms = (ANDROID),
+    platforms = ANDROID,
     preprocessor_flags = [
         "-DLOG_TAG=\"ReactNative\"",
         "-DWITH_FBSYSTRACE=1",
@@ -67,7 +67,7 @@ fb_xplat_cxx_test(
         "-Wall",
     ],
     contacts = ["oncall+react_native@xmail.facebook.com"],
-    platforms = (ANDROID),
+    platforms = ANDROID,
     deps = [
         "//xplat/folly:molly",
         "//xplat/third-party/gmock:gtest",

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp

@@ -12,7 +12,12 @@ using namespace facebook::react;
 namespace facebook {
 namespace react {
 
-MapBuffer::MapBuffer(uint8_t *const data, uint16_t dataSize) {
+// TODO T83483191: Extend MapBuffer C++ implementation to support basic random
+// access
+MapBuffer::MapBuffer(uint8_t *const data, int32_t dataSize) {
+  react_native_assert(
+      (data != nullptr) && "Error trying to build an invalid MapBuffer");
+
   // Should we move the memory here or document it?
   data_ = data;
 
@@ -22,12 +27,13 @@ MapBuffer::MapBuffer(uint8_t *const data, uint16_t dataSize) {
       reinterpret_cast<const uint8_t *>(data_ + HEADER_COUNT_OFFSET),
       UINT16_SIZE);
 
-  // TODO: extract memcpy calls into an inline function to simplify the code
+  // TODO T83483191: extract memcpy calls into an inline function to simplify
+  // the code
   dataSize_ = 0;
   memcpy(
       reinterpret_cast<uint8_t *>(&dataSize_),
       reinterpret_cast<const uint8_t *>(data_ + HEADER_BUFFER_SIZE_OFFSET),
-      UINT16_SIZE);
+      INT_SIZE);
 
   if (dataSize != dataSize_) {
     LOG(ERROR) << "Error: Data size does not match, expected " << dataSize
@@ -36,8 +42,8 @@ MapBuffer::MapBuffer(uint8_t *const data, uint16_t dataSize) {
   }
 }
 
-int MapBuffer::getInt(Key key) const {
-  int value = 0;
+int32_t MapBuffer::getInt(Key key) const {
+  int32_t value = 0;
   memcpy(
       reinterpret_cast<uint8_t *>(&value),
       reinterpret_cast<const uint8_t *>(data_ + getValueOffset(key)),
@@ -50,8 +56,8 @@ bool MapBuffer::getBool(Key key) const {
 }
 
 double MapBuffer::getDouble(Key key) const {
-  // TODO: extract this code into a "template method" and reuse it for other
-  // types
+  // TODO T83483191: extract this code into a "template method" and reuse it for
+  // other types
   double value = 0;
   memcpy(
       reinterpret_cast<uint8_t *>(&value),
@@ -60,54 +66,52 @@ double MapBuffer::getDouble(Key key) const {
   return value;
 }
 
-int MapBuffer::getDynamicDataOffset() const {
+int32_t MapBuffer::getDynamicDataOffset() const {
   // The begininig of dynamic data can be calculated as the offset of the next
   // key in the map
   return getKeyOffset(count_);
 }
 
 std::string MapBuffer::getString(Key key) const {
-  // TODO Add checks to verify that offsets are under the boundaries of the map
-  // buffer
-  int dynamicDataOffset = getDynamicDataOffset();
-  int stringLength = 0;
+  // TODO T83483191:Add checks to verify that offsets are under the boundaries
+  // of the map buffer
+  int32_t dynamicDataOffset = getDynamicDataOffset();
+  int32_t stringLength = 0;
+  int32_t offset = getInt(key);
   memcpy(
       reinterpret_cast<uint8_t *>(&stringLength),
-      reinterpret_cast<const uint8_t *>(data_ + dynamicDataOffset),
+      reinterpret_cast<const uint8_t *>(data_ + dynamicDataOffset + offset),
       INT_SIZE);
 
-  int valueOffset = getInt(key) + sizeof(stringLength);
-
   char *value = new char[stringLength];
 
   memcpy(
       reinterpret_cast<char *>(value),
-      reinterpret_cast<const char *>(data_ + dynamicDataOffset + valueOffset),
+      reinterpret_cast<const char *>(
+          data_ + dynamicDataOffset + offset + INT_SIZE),
       stringLength);
 
-  return std::string(value);
+  return std::string(value, 0, stringLength);
 }
 
 MapBuffer MapBuffer::getMapBuffer(Key key) const {
-  // TODO Add checks to verify that offsets are under the boundaries of the map
-  // buffer
-  int dynamicDataOffset = getDynamicDataOffset();
-
-  uint16_t mapBufferLength = 0;
+  // TODO T83483191: Add checks to verify that offsets are under the boundaries
+  // of the map buffer
+  int32_t dynamicDataOffset = getDynamicDataOffset();
 
+  int32_t mapBufferLength = 0;
+  int32_t offset = getInt(key);
   memcpy(
       reinterpret_cast<uint8_t *>(&mapBufferLength),
-      reinterpret_cast<const uint8_t *>(data_ + dynamicDataOffset),
-      UINT16_SIZE);
-
-  int valueOffset = getInt(key) + UINT16_SIZE;
+      reinterpret_cast<const uint8_t *>(data_ + dynamicDataOffset + offset),
+      INT_SIZE);
 
   uint8_t *value = new Byte[mapBufferLength];
 
   memcpy(
       reinterpret_cast<uint8_t *>(value),
       reinterpret_cast<const uint8_t *>(
-          data_ + dynamicDataOffset + valueOffset),
+          data_ + dynamicDataOffset + offset + INT_SIZE),
       mapBufferLength);
 
   return MapBuffer(value, mapBufferLength);
@@ -117,7 +121,7 @@ bool MapBuffer::isNull(Key key) const {
   return getInt(key) == NULL_VALUE;
 }
 
-uint16_t MapBuffer::getBufferSize() const {
+int32_t MapBuffer::getBufferSize() const {
   return dataSize_;
 }
 
@@ -130,9 +134,8 @@ uint16_t MapBuffer::getCount() const {
 
   memcpy(
       reinterpret_cast<uint16_t *>(&size),
-      reinterpret_cast<const uint16_t *>(
-          data_ + UINT16_SIZE), // TODO refactor this: + UINT16_SIZE describes
-                                // the position in the header
+      reinterpret_cast<const uint16_t *>(data_ + HEADER_COUNT_OFFSET),
+
       UINT16_SIZE);
 
   return size;

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/mapbuffer/primitives.h>
 
 #include <stdlib.h>
@@ -33,23 +34,23 @@ namespace react {
 class MapBuffer {
  private:
   // Buffer and its size
-  const uint8_t *data_;
+  const uint8_t *data_ = nullptr;
 
   // amount of bytes in the MapBuffer
-  uint16_t dataSize_;
+  int32_t dataSize_ = 0;
 
   // amount of items in the MapBuffer
-  uint16_t count_;
+  uint16_t count_ = 0;
 
   // returns the relative offset of the first byte of dynamic data
-  int getDynamicDataOffset() const;
+  int32_t getDynamicDataOffset() const;
 
  public:
-  MapBuffer(uint8_t *const data, uint16_t dataSize);
+  MapBuffer(uint8_t *const data, int32_t dataSize);
 
   ~MapBuffer();
 
-  int getInt(Key key) const;
+  int32_t getInt(Key key) const;
 
   bool getBool(Key key) const;
 
@@ -57,12 +58,12 @@ class MapBuffer {
 
   std::string getString(Key key) const;
 
-  // TODO: review this declaration
+  // TODO T83483191: review this declaration
   MapBuffer getMapBuffer(Key key) const;
 
-  uint16_t getBufferSize() const;
+  int32_t getBufferSize() const;
 
-  // TODO: review parameters of copy method
+  // TODO T83483191: review parameters of copy method
   void copy(uint8_t *output) const;
 
   bool isNull(Key key) const;

package/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp

@@ -12,6 +12,7 @@ using namespace facebook::react;
 namespace facebook {
 namespace react {
 
+// TODO T83483191: Add asserts to check overflowing on additions
 MapBufferBuilder::MapBufferBuilder()
     : MapBufferBuilder::MapBufferBuilder(INITIAL_KEY_VALUE_SIZE) {}
 
@@ -32,10 +33,10 @@ MapBufferBuilder::MapBufferBuilder(uint16_t initialSize) {
 }
 
 void MapBufferBuilder::ensureKeyValueSpace() {
-  int oldKeyValuesSize = keyValuesSize_;
+  int32_t oldKeyValuesSize = keyValuesSize_;
   react_native_assert(
-      (keyValuesSize_ >= std::numeric_limits<uint16_t>::max() / 2) &&
-      "Error trying to assign a value beyond the capacity of uint16_t");
+      (keyValuesSize_ < std::numeric_limits<uint16_t>::max() / 2) &&
+      "Error trying to assign a value beyond the capacity of uint16_t: ");
   keyValuesSize_ *= 2;
   uint8_t *newKeyValues = new Byte[keyValuesSize_];
   uint8_t *oldKeyValues = keyValues_;
@@ -44,7 +45,10 @@ void MapBufferBuilder::ensureKeyValueSpace() {
   delete[] oldKeyValues;
 }
 
-void MapBufferBuilder::storeKeyValue(Key key, uint8_t *value, int valueSize) {
+void MapBufferBuilder::storeKeyValue(
+    Key key,
+    uint8_t *value,
+    int32_t valueSize) {
   if (key < minKeyToStore_) {
     LOG(ERROR) << "Error: key out of order - key: " << key;
     abort();
@@ -54,12 +58,13 @@ void MapBufferBuilder::storeKeyValue(Key key, uint8_t *value, int valueSize) {
                << valueSize;
     abort();
   }
-  // TODO: header.count points to the next index
-  // TODO: add test to verify storage of sparse keys
-  int keyOffset = getKeyOffset(_header.count);
-  int valueOffset = keyOffset + KEY_SIZE;
 
-  int nextKeyValueOffset = keyOffset + BUCKET_SIZE;
+  // TODO T83483191: header.count points to the next index
+  // TODO T83483191: add test to verify storage of sparse keys
+  int32_t keyOffset = getKeyOffset(_header.count);
+  int32_t valueOffset = keyOffset + KEY_SIZE;
+
+  int32_t nextKeyValueOffset = keyOffset + BUCKET_SIZE;
   if (nextKeyValueOffset >= keyValuesSize_) {
     ensureKeyValueSpace();
   }
@@ -87,28 +92,32 @@ void MapBufferBuilder::putNull(Key key) {
   putInt(key, NULL_VALUE);
 }
 
-void MapBufferBuilder::putInt(Key key, int value) {
+void MapBufferBuilder::putInt(Key key, int32_t value) {
   uint8_t *bytePointer = reinterpret_cast<uint8_t *>(&(value));
   storeKeyValue(key, bytePointer, INT_SIZE);
 }
 
-void MapBufferBuilder::ensureDynamicDataSpace(int size) {
+void MapBufferBuilder::ensureDynamicDataSpace(int32_t size) {
   if (dynamicDataValues_ == nullptr) {
-    dynamicDataSize_ = std::max(INITIAL_DYNAMIC_DATA_SIZE, size);
+    dynamicDataSize_ = size;
     dynamicDataValues_ = new Byte[dynamicDataSize_];
     dynamicDataOffset_ = 0;
     return;
   }
 
   if (dynamicDataOffset_ + size >= dynamicDataSize_) {
-    int oldDynamicDataSize = dynamicDataSize_;
-    if (dynamicDataSize_ >= std::numeric_limits<uint16_t>::max() / 2) {
-      LOG(ERROR)
-          << "Error: trying to assign a value beyond the capacity of uint16_t"
-          << static_cast<uint32_t>(dynamicDataSize_) * 2;
-      abort();
-    }
-    dynamicDataSize_ *= 2;
+    int32_t oldDynamicDataSize = dynamicDataSize_;
+    react_native_assert(
+        (dynamicDataSize_ < std::numeric_limits<int32_t>::max() / 2) &&
+        "Error: trying to assign a value beyond the capacity of int");
+    dynamicDataSize_ *= dynamicDataSize_;
+
+    react_native_assert(
+        (dynamicDataSize_ < std::numeric_limits<int32_t>::max() - size) &&
+        "Error: trying to assign a value beyond the capacity of int");
+
+    // sum size to ensure that the size always fit into newDynamicDataValues
+    dynamicDataSize_ += size;
     uint8_t *newDynamicDataValues = new Byte[dynamicDataSize_];
     uint8_t *oldDynamicDataValues = dynamicDataValues_;
     memcpy(newDynamicDataValues, dynamicDataValues_, oldDynamicDataSize);
@@ -118,15 +127,15 @@ void MapBufferBuilder::ensureDynamicDataSpace(int size) {
 }
 
 void MapBufferBuilder::putString(Key key, std::string value) {
-  int strLength = value.length();
+  int32_t strLength = static_cast<int32_t>(value.length());
   const char *cstring = getCstring(&value);
 
   // format [lenght of string (int)] + [Array of Characters in the string]
-  int sizeOfLength = INT_SIZE;
-  // TODO : review if map.getBufferSize() should be an int or long instead of an
-  // int16 (because strings can be longer than int16);
+  int32_t sizeOfLength = INT_SIZE;
+  // TODO T83483191: review if map.getBufferSize() should be an int32_t or long
+  // instead of an int16 (because strings can be longer than int16);
 
-  int sizeOfDynamicData = sizeOfLength + strLength;
+  int32_t sizeOfDynamicData = sizeOfLength + strLength;
   ensureDynamicDataSpace(sizeOfDynamicData);
   memcpy(dynamicDataValues_ + dynamicDataOffset_, &strLength, sizeOfLength);
   memcpy(
@@ -141,17 +150,17 @@ void MapBufferBuilder::putString(Key key, std::string value) {
 }
 
 void MapBufferBuilder::putMapBuffer(Key key, MapBuffer &map) {
-  uint16_t mapBufferSize = map.getBufferSize();
+  int32_t mapBufferSize = map.getBufferSize();
 
-  // format [lenght of buffer (short)] + [Array of Characters in the string]
-  int sizeOfDynamicData = mapBufferSize + UINT16_SIZE;
+  // format [lenght of buffer (int)] + [bytes of MapBuffer]
+  int32_t sizeOfDynamicData = mapBufferSize + INT_SIZE;
 
   // format [Array of bytes of the mapBuffer]
   ensureDynamicDataSpace(sizeOfDynamicData);
 
-  memcpy(dynamicDataValues_ + dynamicDataOffset_, &mapBufferSize, UINT16_SIZE);
+  memcpy(dynamicDataValues_ + dynamicDataOffset_, &mapBufferSize, INT_SIZE);
   // Copy the content of the map into dynamicDataValues_
-  map.copy(dynamicDataValues_ + dynamicDataOffset_ + UINT16_SIZE);
+  map.copy(dynamicDataValues_ + dynamicDataOffset_ + INT_SIZE);
 
   // Store Key and pointer to the string
   putInt(key, dynamicDataOffset_);
@@ -160,8 +169,12 @@ void MapBufferBuilder::putMapBuffer(Key key, MapBuffer &map) {
 }
 
 MapBuffer MapBufferBuilder::build() {
+  react_native_assert(
+      (keyValues_ != nullptr) &&
+      "Error when building mapbuffer with invalid datastructures.");
+
   // Create buffer: [header] + [key, values] + [dynamic data]
-  int bufferSize = keyValuesOffset_ + dynamicDataOffset_;
+  int32_t bufferSize = keyValuesOffset_ + dynamicDataOffset_;
 
   _header.bufferSize = bufferSize;
 
@@ -176,14 +189,15 @@ MapBuffer MapBufferBuilder::build() {
     memcpy(buffer + keyValuesOffset_, dynamicDataValues_, dynamicDataOffset_);
   }
 
-  // TODO: should we use std::move here?
+  // TODO T83483191: should we use std::move here?
   auto map = MapBuffer(buffer, bufferSize);
 
-  // TODO: we should invalidate the class once the build() method is
+  // TODO T83483191: we should invalidate the class once the build() method is
   // called.
 
-  // Reset internal data
-  delete[] keyValues_;
+  if (keyValues_ != nullptr) {
+    delete[] keyValues_;
+  }
   keyValues_ = nullptr;
   keyValuesSize_ = 0;
   keyValuesOffset_ = 0;
@@ -194,6 +208,7 @@ MapBuffer MapBufferBuilder::build() {
   }
   dynamicDataSize_ = 0;
   dynamicDataOffset_ = 0;
+  _header = {ALIGNMENT, 0, 0};
 
   return map;
 }

package/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h

@@ -16,11 +16,11 @@ namespace facebook {
 namespace react {
 
 // Default initial size for _keyValues array
-// 106 = 10 entries = 10*10 + 6 sizeof(header)
-constexpr uint16_t INITIAL_KEY_VALUE_SIZE = 106;
+// 108 = 10 entries = 10*10 + 8 sizeof(header)
+constexpr uint16_t INITIAL_KEY_VALUE_SIZE = 108;
 
 // Default initial size for _dynamicDataValues array
-constexpr int INITIAL_DYNAMIC_DATA_SIZE = 200;
+constexpr int32_t INITIAL_DYNAMIC_DATA_SIZE = 200;
 
 /**
  * MapBufferBuilder is a builder class for MapBuffer
@@ -31,35 +31,35 @@ class MapBufferBuilder {
 
   void ensureKeyValueSpace();
 
-  void ensureDynamicDataSpace(int size);
+  void ensureDynamicDataSpace(int32_t size);
 
-  void storeKeyValue(Key key, uint8_t *value, int valueSize);
+  void storeKeyValue(Key key, uint8_t *value, int32_t valueSize);
 
   // Array of [key,value] map entries:
   // - Key is represented in 2 bytes
   // - Value is stored into 8 bytes. The 8 bytes of the value will contain the
   // actual value for the key or a pointer to the actual value (based on the
   // type)
-  uint8_t *keyValues_;
+  uint8_t *keyValues_ = nullptr;
 
   // Amount of bytes allocated on _keyValues
-  uint16_t keyValuesSize_;
+  uint16_t keyValuesSize_ = 0;
 
   // Relative offset on the _keyValues array.
   // This represents the first byte that can be written in _keyValues array
-  int keyValuesOffset_;
+  int32_t keyValuesOffset_ = 0;
 
   // This array contains data for dynamic values in the MapBuffer.
   // A dynamic value is a String or another MapBuffer.
-  uint8_t *dynamicDataValues_;
+  uint8_t *dynamicDataValues_ = nullptr;
 
   // Amount of bytes allocated on _dynamicDataValues
-  uint16_t dynamicDataSize_;
+  int32_t dynamicDataSize_ = 0;
 
   // Relative offset on the _dynamicDataValues array.
   // This represents the first byte that can be written in _dynamicDataValues
   // array
-  int dynamicDataOffset_;
+  int32_t dynamicDataOffset_ = 0;
 
   // Minimmum key to store in the MapBuffer (this is used to guarantee
   // consistency)
@@ -74,7 +74,7 @@ class MapBufferBuilder {
 
   static MapBuffer EMPTY();
 
-  void putInt(Key key, int value);
+  void putInt(Key key, int32_t value);
 
   void putBool(Key key, bool value);
 
@@ -86,7 +86,7 @@ class MapBufferBuilder {
 
   void putMapBuffer(Key key, MapBuffer &map);
 
-  // TODO This should return MapBuffer!
+  // TODO T83483191: This should return MapBuffer!
   MapBuffer build();
 };
 

package/ReactCommon/react/renderer/mapbuffer/primitives.h

@@ -9,11 +9,10 @@
 
 #include <glog/logging.h>
 
-// TODO: Enable CHECK_CONSISTENCY only in debug mode or test environments (or
-// just in demand)
-// #define CHECK_CONSISTENCY 1
+// TODO T83483191: Enable CHECK_CONSISTENCY only in debug mode or test
+// environments (or just in demand) #define CHECK_CONSISTENCY 1
 
-constexpr static int NULL_VALUE = 0;
+constexpr static int32_t NULL_VALUE = 0;
 
 // Value used to verify if the data is serialized with LittleEndian order
 constexpr static uint16_t ALIGNMENT = 0xFE;
@@ -28,36 +27,36 @@ namespace react {
 struct Header {
   uint16_t alignment; // alignment of serialization
   uint16_t count; // amount of items in the map
-  uint16_t bufferSize; // Amount of bytes used to store the map in memory
+  int32_t bufferSize; // Amount of bytes used to store the map in memory
 };
 
-constexpr static int KEY_SIZE = sizeof(Key);
-constexpr static int HEADER_SIZE = sizeof(Header);
-constexpr static int INT_SIZE = sizeof(int);
-constexpr static int DOUBLE_SIZE = sizeof(double);
-constexpr static int UINT8_SIZE = sizeof(uint8_t);
-constexpr static int UINT16_SIZE = sizeof(uint16_t);
-constexpr static int UINT64_SIZE = sizeof(uint64_t);
-constexpr static int HEADER_ALIGNMENT_OFFSET = 0;
-constexpr static int HEADER_COUNT_OFFSET = UINT16_SIZE;
-constexpr static int HEADER_BUFFER_SIZE_OFFSET = UINT16_SIZE * 2;
+constexpr static int32_t KEY_SIZE = sizeof(Key);
+constexpr static int32_t HEADER_SIZE = sizeof(Header);
+constexpr static int32_t INT_SIZE = sizeof(int32_t);
+constexpr static int32_t DOUBLE_SIZE = sizeof(double);
+constexpr static int32_t UINT8_SIZE = sizeof(uint8_t);
+constexpr static int32_t UINT16_SIZE = sizeof(uint16_t);
+constexpr static int32_t UINT64_SIZE = sizeof(uint64_t);
+constexpr static int32_t HEADER_ALIGNMENT_OFFSET = 0;
+constexpr static int32_t HEADER_COUNT_OFFSET = UINT16_SIZE;
+constexpr static int32_t HEADER_BUFFER_SIZE_OFFSET = UINT16_SIZE * 2;
 
-constexpr static int MAX_VALUE_SIZE = UINT64_SIZE;
+constexpr static int32_t MAX_VALUE_SIZE = UINT64_SIZE;
 
 // 10 bytes : 2 key + 8 value
-constexpr static int BUCKET_SIZE = KEY_SIZE + UINT64_SIZE;
+constexpr static int32_t BUCKET_SIZE = KEY_SIZE + UINT64_SIZE;
 
 /**
  * Returns the offset of the key received by parameter.
  */
-inline int getKeyOffset(Key key) {
+inline int32_t getKeyOffset(Key key) {
   return HEADER_SIZE + BUCKET_SIZE * key;
 }
 
 /**
  * Returns the offset of the value associated to the key received by parameter.
  */
-inline int getValueOffset(Key key) {
+inline int32_t getValueOffset(Key key) {
   return getKeyOffset(key) + KEY_SIZE;
 }
 

package/ReactCommon/react/renderer/mapbuffer/tests/MapBufferTest.cpp

@@ -70,7 +70,8 @@ TEST(MapBufferTest, testNullEntries) {
   EXPECT_EQ(map.getCount(), 2);
   EXPECT_EQ(map.isNull(0), true);
   EXPECT_EQ(map.isNull(1), false);
-  // TODO: serialize null values to be distinguishable from '0' values
+  // TODO T83483191: serialize null values to be distinguishable from '0'
+  // values
   // EXPECT_EQ(map.isNull(1),  false);
   // EXPECT_EQ(map.getBool(1),  false);
 }
@@ -98,13 +99,24 @@ TEST(MapBufferTest, testStringEntries) {
   EXPECT_EQ(map.getString(0), "This is a test");
 }
 
+TEST(MapBufferTest, testUTFStringEntry) {
+  auto builder = MapBufferBuilder();
+
+  builder.putString(0, "Let's count: 的, 一, 是");
+  auto map = builder.build();
+
+  EXPECT_EQ(map.getString(0), "Let's count: 的, 一, 是");
+}
+
 TEST(MapBufferTest, testUTFStringEntries) {
   auto builder = MapBufferBuilder();
 
   builder.putString(0, "Let's count: 的, 一, 是");
+  builder.putString(1, "This is a test");
   auto map = builder.build();
 
   EXPECT_EQ(map.getString(0), "Let's count: 的, 一, 是");
+  EXPECT_EQ(map.getString(1), "This is a test");
 }
 
 TEST(MapBufferTest, testEmptyMap) {

package/ReactCommon/react/renderer/mounting/Android.mk

@@ -21,7 +21,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 
 LOCAL_STATIC_LIBRARIES :=
 
-LOCAL_SHARED_LIBRARIES := libbetter libyoga libfolly_futures glog libfolly_json libglog_init libreact_render_core libreact_render_debug librrc_view librrc_root libreact_utils libreact_debug libreact_render_telemetry
+LOCAL_SHARED_LIBRARIES := libjsi libbetter libyoga libfolly_futures glog libfolly_json libglog_init libreact_render_core libreact_render_debug librrc_view librrc_root libreact_utils libreact_debug libreact_render_graphics libreact_render_telemetry
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -36,4 +36,5 @@ $(call import-module,react/renderer/debug)
 $(call import-module,react/utils)
 $(call import-module,react/debug)
 $(call import-module,yogajni)
+$(call import-module,react/renderer/graphics)
 $(call import-module,react/renderer/telemetry)

package/ReactCommon/react/renderer/mounting/BUCK

@@ -88,5 +88,6 @@ fb_xplat_cxx_test(
         react_native_xplat_target("react/renderer/components/root:root"),
         react_native_xplat_target("react/renderer/components/view:view"),
         react_native_xplat_target("react/renderer/components/scrollview:scrollview"),
+        react_native_xplat_target("react/test_utils:test_utils"),
     ],
 )