react-native-tvos 0.85.3-0 → 0.86.0-0

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

@@ -59,6 +59,11 @@ struct LayoutContext {
    * If React Native takes up entire screen, it will be {0, 0}.
    */
   Point viewportOffset{};
+
+  /*
+   * Viewport size is size of the React Native's root view.
+   */
+  Size viewportSize{};
 };
 
 inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
@@ -68,13 +73,15 @@ inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
              lhs.affectedNodes,
              lhs.swapLeftAndRightInRTL,
              lhs.fontSizeMultiplier,
-             lhs.viewportOffset) ==
+             lhs.viewportOffset,
+             lhs.viewportSize) ==
       std::tie(
              rhs.pointScaleFactor,
              rhs.affectedNodes,
              rhs.swapLeftAndRightInRTL,
              rhs.fontSizeMultiplier,
-             rhs.viewportOffset);
+             rhs.viewportOffset,
+             rhs.viewportSize);
 }
 
 } // namespace facebook::react

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

@@ -44,9 +44,11 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
            ",bottom:" + getDebugDescription(object.overflowInset.bottom, {}) +
            ",left:" + getDebugDescription(object.overflowInset.left, {}) + "}"},
       {.name = "displayType",
-       .value = object.displayType == DisplayType::None
-           ? "None"
-           : (object.displayType == DisplayType::Flex ? "Flex" : "Inline")},
+       .value = object.displayType == DisplayType::None  ? "None"
+           : object.displayType == DisplayType::Flex     ? "Flex"
+           : object.displayType == DisplayType::Grid     ? "Grid"
+           : object.displayType == DisplayType::Contents ? "Contents"
+                                                         : "Unknown"},
       {.name = "layoutDirection",
        .value = object.layoutDirection == LayoutDirection::Undefined
            ? "Undefined"

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

@@ -20,6 +20,7 @@ enum class DisplayType {
   None = 0,
   Flex = 1,
   Contents = 2,
+  Grid = 3,
 };
 
 enum class PositionType {

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

@@ -32,6 +32,20 @@ void Props::initialize(
   nativeId = ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
       ? sourceProps.nativeId
       : convertRawProp(context, rawProps, "nativeID", sourceProps.nativeId, {});
+
+  if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
+    if (ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
+      // id -> nativeId
+      auto* idValue = rawProps.at("id", nullptr, nullptr);
+      if (idValue != nullptr) {
+        if (idValue->hasValue()) {
+          fromRawValue(context, *idValue, nativeId);
+        } else {
+          nativeId = {};
+        }
+      }
+    }
+  }
 #ifdef RN_SERIALIZABLE_STATE
   if (!ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid()) {
     initializeDynamicProps(sourceProps, rawProps, filterObjectKeys);
@@ -48,6 +62,12 @@ void Props::setProp(
     case CONSTEXPR_RAW_PROPS_KEY_HASH("nativeID"):
       fromRawValue(context, value, nativeId, {});
       return;
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("id"):
+      if (!ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
+        return;
+      }
+      fromRawValue(context, value, nativeId, {});
+      return;
   }
 }
 

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

@@ -15,12 +15,14 @@ RawEvent::RawEvent(
     SharedEventTarget eventTarget,
     std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
     Category category,
-    bool isUnique)
+    bool isUnique,
+    HighResTimeStamp eventStartTimeStamp)
     : type(std::move(type)),
       eventPayload(std::move(eventPayload)),
       eventTarget(std::move(eventTarget)),
       shadowNodeFamily(std::move(shadowNodeFamily)),
       category(category),
-      isUnique(isUnique) {}
+      isUnique(isUnique),
+      eventStartTimeStamp(eventStartTimeStamp) {}
 
 } // namespace facebook::react

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

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <memory>
-#include <optional>
 #include <string>
 
 #include <react/renderer/core/EventLogger.h>
@@ -74,7 +73,8 @@ struct RawEvent {
       SharedEventTarget eventTarget,
       std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
       Category category = Category::Unspecified,
-      bool isUnique = false);
+      bool isUnique = false,
+      HighResTimeStamp eventStartTimeStamp = HighResTimeStamp::now());
 
   std::string type;
   SharedEventPayload eventPayload;
@@ -84,10 +84,10 @@ struct RawEvent {
   EventTag loggingTag{0};
   bool isUnique{false};
 
-  // The client may specify a platform-specific timestamp for the event start
-  // time, for example when MotionEvent was triggered on the Android native
-  // side.
-  std::optional<HighResTimeStamp> eventStartTimeStamp = std::nullopt;
+  // The timestamp for the event start time. This defaults to the current
+  // time if not specified by the client (e.g., when MotionEvent was triggered
+  // on the Android native side).
+  HighResTimeStamp eventStartTimeStamp;
 };
 
 } // namespace facebook::react

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

@@ -83,7 +83,7 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
   ShadowNode(const ShadowNode &shadowNode) noexcept = delete;
   ShadowNode &operator=(const ShadowNode &other) noexcept = delete;
 
-  virtual ~ShadowNode() override = default;
+  ~ShadowNode() override = default;
 
   /*
    * Clones the shadow node using the ShadowNode's ComponentDescriptor.
@@ -118,7 +118,7 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
    * Called, once a fully derived ShadowNode clone has been created via
    * ComponentDescriptor::cloneShadowNode.
    */
-  virtual void completeClone(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment) {}
+  virtual void completeClone(const ShadowNode & /* sourceShadowNode */, const ShadowNodeFragment & /* fragment */) {}
 
 #pragma mark - Getters
 

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

@@ -44,6 +44,8 @@ inline int toInt(const DisplayType &displayType)
       return 1;
     case DisplayType::Contents:
       return 2;
+    case DisplayType::Grid:
+      return 3;
   }
 }
 
@@ -56,6 +58,8 @@ inline std::string toString(const DisplayType &displayType)
       return "flex";
     case DisplayType::Contents:
       return "contents";
+    case DisplayType::Grid:
+      return "grid";
   }
 }
 

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

@@ -83,7 +83,7 @@ inline folly::dynamic toDynamic(const Point &point)
 }
 #endif
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Point &result)
+inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, Point &result)
 {
   if (value.hasType<std::unordered_map<std::string, Float>>()) {
     auto map = (std::unordered_map<std::string, Float>)value;
@@ -112,7 +112,7 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
   }
 }
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Size &result)
+inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, Size &result)
 {
   if (value.hasType<std::unordered_map<std::string, Float>>()) {
     auto map = (std::unordered_map<std::string, Float>)value;
@@ -144,7 +144,7 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
   }
 }
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, EdgeInsets &result)
+inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, EdgeInsets &result)
 {
   if (value.hasType<Float>()) {
     auto number = (Float)value;
@@ -198,7 +198,7 @@ inline folly::dynamic toDynamic(const EdgeInsets &edgeInsets)
 }
 #endif
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, CornerInsets &result)
+inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, CornerInsets &result)
 {
   if (value.hasType<Float>()) {
     auto number = (Float)value;

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

@@ -101,7 +101,7 @@ void fromRawValue(const PropsParserContext &context, const RawValue &rawValue, T
 }
 
 template <typename T>
-void fromRawValue(const PropsParserContext &context, const RawValue &rawValue, T &result)
+void fromRawValue(const PropsParserContext & /* context */, const RawValue &rawValue, T &result)
 {
   result = (T)rawValue;
 }

package/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp

@@ -12,11 +12,13 @@
 #include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/EventTarget.h>
+#include <react/renderer/core/InstanceHandle.h>
 #include <react/renderer/core/ShadowNodeFamily.h>
 #include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/ValueFactoryEventPayload.h>
 
 #include <memory>
+#include <stdexcept>
 #include <string_view>
 
 namespace facebook::react {
@@ -42,13 +44,14 @@ class EventQueueProcessorTest : public testing::Test {
                          const EventTarget* /*eventTarget*/,
                          const std::string& type,
                          ReactEventPriority priority,
-                         const EventPayload& /*payload*/) {
+                         const EventPayload& /*payload*/,
+                         HighResTimeStamp /*eventTimestamp*/) {
       eventTypes_.push_back(type);
       eventPriorities_.push_back(priority);
     };
 
-    auto dummyEventPipeConclusion = [](jsi::Runtime& runtime) {};
-    auto dummyStatePipe = [](const StateUpdate& stateUpdate) {};
+    auto dummyEventPipeConclusion = [](jsi::Runtime&) {};
+    auto dummyStatePipe = [](const StateUpdate&) {};
     auto mockEventLogger = std::make_shared<MockEventLogger>();
 
     eventProcessor_ = std::make_unique<EventQueueProcessor>(
@@ -156,4 +159,50 @@ TEST_F(EventQueueProcessorTest, alwaysDiscreteEvent) {
   EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
 }
 
+TEST_F(EventQueueProcessorTest, releasesEventTargetsWhenDispatchThrows) {
+  // Set up an enabled EventTarget so that flushEvents() will retain a strong
+  // JSI reference to its instance handle.
+  auto object = jsi::Object(*runtime_);
+  auto instanceHandle = std::make_shared<InstanceHandle>(
+      *runtime_, jsi::Value(*runtime_, object), 1);
+  auto eventTarget =
+      std::make_shared<EventTarget>(std::move(instanceHandle), 41);
+  eventTarget->setEnabled(true);
+
+  // An event pipe that throws, simulating a JS exception during dispatch.
+  auto throwingEventPipe = [](jsi::Runtime& /*runtime*/,
+                              const EventTarget* /*eventTarget*/,
+                              const std::string& /*type*/,
+                              ReactEventPriority /*priority*/,
+                              const EventPayload& /*payload*/,
+                              HighResTimeStamp /*eventTimestamp*/) {
+    throw std::runtime_error("dispatch failed");
+  };
+  auto dummyEventPipeConclusion = [](jsi::Runtime& /*runtime*/) {};
+  auto dummyStatePipe = [](const StateUpdate& /*stateUpdate*/) {};
+  auto mockEventLogger = std::make_shared<MockEventLogger>();
+
+  auto processor = EventQueueProcessor(
+      throwingEventPipe,
+      dummyEventPipeConclusion,
+      dummyStatePipe,
+      mockEventLogger);
+
+  EXPECT_THROW(
+      processor.flushEvents(
+          *runtime_,
+          {RawEvent(
+              "onThrow",
+              std::make_shared<ValueFactoryEventPayload>(dummyValueFactory_),
+              eventTarget,
+              {},
+              RawEvent::Category::Discrete)}),
+      std::runtime_error);
+
+  // The strong JSI reference acquired by retain() must have been released even
+  // though dispatch threw, so the instance handle is no longer reachable
+  // through the EventTarget.
+  EXPECT_TRUE(eventTarget->getInstanceHandle(*runtime_).isNull());
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/tests/EventTargetTests.cpp

@@ -43,3 +43,29 @@ TEST(EventTargetTests, getInstanceHandle) {
 
   EXPECT_TRUE(eventTarget.getInstanceHandle(*runtime).isNull());
 }
+
+TEST(EventTargetTests, releaseWhileDisabledDoesNotCorruptRetainCount) {
+  // retain() is a no-op while the target is disabled, but the matching
+  // release() still runs. release() must tolerate a zero retain count without
+  // underflowing, so that a later enable + retain still populates the strong
+  // instance handle.
+  auto runtime = facebook::hermes::makeHermesRuntime();
+  auto object = jsi::Object(*runtime);
+  auto instanceHandle = std::make_shared<InstanceHandle>(
+      *runtime, jsi::Value(*runtime, object), 1);
+
+  auto eventTarget = EventTarget(std::move(instanceHandle), 41);
+
+  // Disabled by default: retain is a no-op, release sees a zero count.
+  eventTarget.retain(*runtime);
+  eventTarget.release(*runtime);
+
+  // After enabling, a fresh retain must succeed in acquiring the handle.
+  eventTarget.setEnabled(true);
+  eventTarget.retain(*runtime);
+  EXPECT_FALSE(eventTarget.getInstanceHandle(*runtime).isNull());
+
+  // And the matching release must drop it again.
+  eventTarget.release(*runtime);
+  EXPECT_TRUE(eventTarget.getInstanceHandle(*runtime).isNull());
+}

package/ReactCommon/react/renderer/css/tests/CSSValueParserTest.cpp

@@ -33,7 +33,7 @@ struct CSSDataTypeParser<ConsumeDataType> {
 
 static_assert(CSSDataType<ConsumeDataType>);
 
-TEST(CSSValueParser, consume_multiple_with_delimeter) {
+TEST(CSSValueParser, consume_multiple_with_delimiter) {
   CSSSyntaxParser syntaxParser{"1 2, 3, 4 / 5"};
   CSSValueParser parser{syntaxParser};
 

package/ReactCommon/react/renderer/debug/DebugStringConvertible.cpp

@@ -7,11 +7,10 @@
 
 #include "DebugStringConvertible.h"
 
-#include <array>
-#include <cinttypes>
-#include <cstdio>
-
-#include <double-conversion/double-conversion.h>
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <sstream>
 
 namespace facebook::react {
 
@@ -125,37 +124,54 @@ SharedDebugStringConvertibleList DebugStringConvertible::getDebugProps() const {
   return {};
 }
 
+#endif
+
 /*
  * `toString`-family implementation.
  */
 std::string toString(const double& value) {
-  // Format taken from folly's toString
-  static double_conversion::DoubleToStringConverter conv(
-      0,
-      "Infinity",
-      "NaN",
-      'E',
-      -6, // detail::kConvMaxDecimalInShortestLow,
-      21, // detail::kConvMaxDecimalInShortestHigh,
-      6, // max leading padding zeros
-      1); // max trailing padding zeros
-  std::array<char, 256> buffer{};
-  double_conversion::StringBuilder builder(buffer.data(), buffer.size());
-  conv.ToShortest(value, &builder);
-  return builder.Finalize();
+  // Handle special floating-point values with prettier output
+  if (std::isnan(value)) {
+    return "NaN";
+  }
+  if (std::isinf(value)) {
+    return value < 0 ? "-Infinity" : "Infinity";
+  }
+
+  std::ostringstream stream;
+  stream << std::fixed << std::setprecision(4) << value;
+  std::string result = stream.str();
+
+  // Strip trailing zeros and unnecessary decimal point
+  if (auto dotPos = result.find('.'); dotPos != std::string::npos) {
+    auto lastNonZero = result.find_last_not_of('0');
+    if (lastNonZero == dotPos) {
+      result.erase(dotPos);
+    } else {
+      result.erase(lastNonZero + 1);
+    }
+  }
+  return result;
+}
+
+std::string toString(const double doubleValue, char suffix) {
+  auto result = toString(doubleValue);
+  if (suffix != '\0') {
+    result += suffix;
+  }
+  return result;
 }
 
+#if RN_DEBUG_STRING_CONVERTIBLE
+
 std::string toString(const void* value) {
   if (value == nullptr) {
     return "null";
   }
-  std::array<char, 20> buffer{};
-  std::snprintf(
-      buffer.data(),
-      buffer.size(),
-      "0x%" PRIXPTR,
-      reinterpret_cast<uintptr_t>(value));
-  return buffer.data();
+  std::ostringstream stream;
+  stream << "0x" << std::uppercase << std::hex
+         << reinterpret_cast<uintptr_t>(value);
+  return stream.str();
 }
 
 #endif

package/ReactCommon/react/renderer/debug/DebugStringConvertible.h

@@ -81,13 +81,15 @@ class DebugStringConvertible {};
 
 #endif
 
-#if RN_DEBUG_STRING_CONVERTIBLE
-
 /*
  * Set of particular-format-opinionated functions that convert base types to
  * `std::string`
  */
 std::string toString(const double &value);
+std::string toString(double doubleValue, char suffix);
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+
 std::string toString(const void *value);
 
 inline std::string toString(const std::string &value)

package/ReactCommon/react/renderer/debug/tests/DebugStringConvertibleTest.cpp

@@ -5,14 +5,44 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#if RN_DEBUG_STRING_CONVERTIBLE
-#include <memory>
+#include <limits>
 
 #include <gtest/gtest.h>
-#include <react/renderer/debug/DebugStringConvertibleItem.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
 
 using namespace facebook::react;
 
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffix) {
+  EXPECT_EQ(toString(3.14, '%'), "3.14%");
+  EXPECT_EQ(toString(100.0, 'x'), "100x");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithNullSuffix) {
+  auto result = toString(42.0, '\0');
+  EXPECT_EQ(result, "42");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixZeroValue) {
+  EXPECT_EQ(toString(0.0, '%'), "0%");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixNegativeValue) {
+  EXPECT_EQ(toString(-2.75, '%'), "-2.75%");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixSpecialValues) {
+  EXPECT_EQ(
+      toString(std::numeric_limits<double>::infinity(), '%'), "Infinity%");
+  EXPECT_EQ(
+      toString(-std::numeric_limits<double>::infinity(), '%'), "-Infinity%");
+  EXPECT_EQ(toString(std::numeric_limits<double>::quiet_NaN(), 'x'), "NaNx");
+}
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+#include <memory>
+
+#include <react/renderer/debug/DebugStringConvertibleItem.h>
+
 TEST(DebugStringConvertibleTest, handleSimpleNode) {
   SharedDebugStringConvertibleList empty;
   auto item = std::make_shared<DebugStringConvertibleItem>(
@@ -83,4 +113,5 @@ TEST(DebugStringConvertibleTest, handleNodeWithComplexProps) {
       item->getDebugDescription().c_str(),
       "<View=hello x=1(height=100 width=200)/>");
 }
+
 #endif

package/ReactCommon/react/renderer/graphics/BlendMode.h

@@ -29,6 +29,7 @@ enum class BlendMode {
   Saturation,
   Color,
   Luminosity,
+  PlusLighter,
 };
 
 inline std::optional<BlendMode> blendModeFromString(std::string_view blendModeName)
@@ -65,6 +66,8 @@ inline std::optional<BlendMode> blendModeFromString(std::string_view blendModeNa
     return BlendMode::Color;
   } else if (blendModeName == "luminosity") {
     return BlendMode::Luminosity;
+  } else if (blendModeName == "plus-lighter") {
+    return BlendMode::PlusLighter;
   } else {
     return std::nullopt;
   }
@@ -105,6 +108,8 @@ inline std::string toString(const BlendMode &blendMode)
       return "color";
     case BlendMode::Luminosity:
       return "luminosity";
+    case BlendMode::PlusLighter:
+      return "plus-lighter";
     default:
       abort();
   }

package/ReactCommon/react/renderer/graphics/CMakeLists.txt

@@ -30,6 +30,7 @@ target_link_libraries(react_renderer_graphics
         ${fbjni}
         folly_runtime
         react_debug
+        react_renderer_debug
         react_utils
 )
 target_compile_reactnative_options(react_renderer_graphics PRIVATE)

package/ReactCommon/react/renderer/graphics/ColorStop.h

@@ -12,7 +12,10 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 #include <optional>
+
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/graphics/LinearGradient.h

@@ -12,7 +12,10 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
+
 #include <variant>
 #include <vector>
 

package/ReactCommon/react/renderer/graphics/RadialGradient.h

@@ -12,7 +12,11 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 #include <optional>
+
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
+
 #include <variant>
 #include <vector>
 

package/ReactCommon/react/renderer/graphics/React-graphics.podspec

@@ -49,6 +49,7 @@ Pod::Spec.new do |s|
   s.dependency "React-jsiexecutor"
   s.dependency "React-featureflags"
   s.dependency "React-utils"
+  s.dependency "React-rendererdebug"
 
   depend_on_js_engine(s)
   add_rn_third_party_dependencies(s)

package/ReactCommon/react/renderer/graphics/ValueUnit.cpp

@@ -7,7 +7,7 @@
 
 #include "ValueUnit.h"
 
-#include "DoubleConversions.h"
+#include <react/renderer/debug/DebugStringConvertible.h>
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/imagemanager/platform/android/react/renderer/imagemanager/ImageFetcher.cpp

@@ -8,7 +8,6 @@
 #include "ImageFetcher.h"
 
 #include <react/common/mapbuffer/JReadableMapBuffer.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/imagemanager/conversions.h>
 
 namespace facebook::react {
@@ -35,10 +34,6 @@ ImageRequest ImageFetcher::requestImage(
 
   auto telemetry = std::make_shared<ImageTelemetry>(surfaceId);
 
-  if (!ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
-    flushImageRequests();
-  }
-
   return ImageRequest{imageSource, telemetry};
 }
 

package/ReactCommon/react/renderer/imagemanager/platform/android/react/renderer/imagemanager/ImageManager.cpp

@@ -25,7 +25,7 @@ ImageManager::ImageManager(
     : contextContainer_(contextContainer),
       self_(new std::shared_ptr<ImageFetcher>(
           std::make_shared<ImageFetcher>(contextContainer))) {
-  if (ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
     std::weak_ptr<ImageFetcher> weakImageFetcher =
         *static_cast<std::shared_ptr<ImageFetcher>*>(self_);
     contextContainer->insert(ImageFetcherKey, weakImageFetcher);
@@ -33,7 +33,7 @@ ImageManager::ImageManager(
 }
 
 ImageManager::~ImageManager() {
-  if (ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
     contextContainer_->erase(ImageFetcherKey);
   }
   delete static_cast<std::shared_ptr<ImageFetcher>*>(self_);

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTImagePrimitivesConversions.h

@@ -55,16 +55,12 @@ inline static NSURLRequestCachePolicy NSURLRequestCachePolicyFromImageSource(
   switch (imageSource.cache) {
     case facebook::react::ImageSource::CacheStategy::Reload:
       return NSURLRequestReloadIgnoringLocalCacheData;
-      break;
     case facebook::react::ImageSource::CacheStategy::ForceCache:
       return NSURLRequestReturnCacheDataElseLoad;
-      break;
     case facebook::react::ImageSource::CacheStategy::OnlyIfCached:
       return NSURLRequestReturnCacheDataDontLoad;
-      break;
     default:
       return NSURLRequestUseProtocolCachePolicy;
-      break;
   }
 }