react-native-tvos 0.79.3-0 → 0.80.0-0

package/Libraries/AppDelegate/RCTDefaultReactNativeFactoryDelegate.mm

@@ -94,6 +94,11 @@
 {
 }
 
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup
+{
+  return self.dependencyProvider ? RCTAppSetupUnstableModulesRequiringMainQueueSetup(self.dependencyProvider) : @[];
+}
+
 - (nullable id<RCTModuleProvider>)getModuleProvider:(const char *)name
 {
   NSString *providerName = [NSString stringWithCString:name encoding:NSUTF8StringEncoding];
@@ -110,11 +115,7 @@
 
 - (BOOL)newArchEnabled
 {
-#if RCT_NEW_ARCH_ENABLED
-  return YES;
-#else
-  return NO;
-#endif
+  return RCTIsNewArchEnabled();
 }
 
 - (BOOL)bridgelessEnabled

package/Libraries/AppDelegate/RCTDependencyProvider.h

@@ -20,6 +20,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (NSArray<NSString *> *)URLRequestHandlerClassNames;
 
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup;
+
 - (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents;
 
 - (nonnull NSDictionary<NSString *, id<RCTModuleProvider>> *)moduleProviders;

package/Libraries/AppDelegate/RCTReactNativeFactory.h

@@ -27,6 +27,8 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+typedef NS_ENUM(NSInteger, RCTReleaseLevel) { Canary, Experimental, Stable };
+
 @protocol RCTReactNativeFactoryDelegate <
     RCTBridgeDelegate,
     RCTUIConfiguratorProtocol,
@@ -86,6 +88,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate;
 
+- (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate releaseLevel:(RCTReleaseLevel)releaseLevel;
+
 - (void)startReactNativeWithModuleName:(NSString *)moduleName inWindow:(UIWindow *_Nullable)window;
 
 - (void)startReactNativeWithModuleName:(NSString *)moduleName

package/Libraries/AppDelegate/RCTReactNativeFactory.mm

@@ -13,8 +13,9 @@
 #import <React/RCTUtils.h>
 #import <ReactCommon/RCTHost.h>
 #import <objc/runtime.h>
-#import <react/featureflags/ReactNativeFeatureFlags.h>
-#import <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#import <react/featureflags/ReactNativeFeatureFlagsOverridesOSSCanary.h>
+#import <react/featureflags/ReactNativeFeatureFlagsOverridesOSSExperimental.h>
+#import <react/featureflags/ReactNativeFeatureFlagsOverridesOSSStable.h>
 #import <react/renderer/graphics/ColorComponents.h>
 #import "RCTAppSetupUtils.h"
 
@@ -41,15 +42,19 @@ using namespace facebook::react;
 @implementation RCTReactNativeFactory
 
 - (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate
+{
+  return [self initWithDelegate:delegate releaseLevel:Stable];
+}
+
+- (instancetype)initWithDelegate:(id<RCTReactNativeFactoryDelegate>)delegate releaseLevel:(RCTReleaseLevel)releaseLevel
 {
   if (self = [super init]) {
     self.delegate = delegate;
-    [self _setUpFeatureFlags];
+    [self _setUpFeatureFlags:releaseLevel];
 
     auto newArchEnabled = [self newArchEnabled];
     auto fabricEnabled = [self fabricEnabled];
 
-    RCTSetNewArchEnabled(newArchEnabled);
     [RCTColorSpaceUtils applyDefaultColorSpace:[self defaultColorSpace]];
     RCTEnableTurboModule([self turboModuleEnabled]);
 
@@ -124,12 +129,7 @@ using namespace facebook::react;
   if ([_delegate respondsToSelector:@selector(newArchEnabled)]) {
     return _delegate.newArchEnabled;
   }
-
-#if RCT_NEW_ARCH_ENABLED
-  return YES;
-#else
-  return NO;
-#endif
+  return RCTIsNewArchEnabled();
 }
 
 - (BOOL)fabricEnabled
@@ -190,6 +190,13 @@ using namespace facebook::react;
 
 - (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
 {
+#if USE_OSS_CODEGEN
+  if (self.delegate.dependencyProvider == nil) {
+    [NSException raise:@"ReactNativeFactoryDelegate dependencyProvider is nil"
+                format:@"Delegate must provide a valid dependencyProvider"];
+  }
+#endif
+
   return RCTAppSetupDefaultModuleFromClass(moduleClass, self.delegate.dependencyProvider);
 }
 
@@ -222,6 +229,17 @@ using namespace facebook::react;
   }
 }
 
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup
+{
+#if RN_DISABLE_OSS_PLUGIN_HEADER
+  return RCTTurboModulePluginUnstableModulesRequiringMainQueueSetup();
+#else
+  return self.delegate.dependencyProvider
+      ? RCTAppSetupUnstableModulesRequiringMainQueueSetup(self.delegate.dependencyProvider)
+      : @[];
+#endif
+}
+
 - (RCTRootViewFactory *)createRCTRootViewFactory
 {
   __weak __typeof(self) weakSelf = self;
@@ -296,40 +314,36 @@ using namespace facebook::react;
 
 #pragma mark - Feature Flags
 
-class RCTAppDelegateBridgelessFeatureFlags : public ReactNativeFeatureFlagsDefaults {
- public:
-  bool enableBridgelessArchitecture() override
-  {
-    return true;
-  }
-  bool enableFabricRenderer() override
-  {
-    return true;
-  }
-  bool useTurboModules() override
-  {
-    return true;
-  }
-  bool useNativeViewConfigsInBridgelessMode() override
-  {
-    return true;
-  }
-  bool updateRuntimeShadowNodeReferencesOnCommit() override
-  {
-    return true;
-  }
-  bool useShadowNodeStateOnClone() override
-  {
-    return true;
+- (void)_setUpFeatureFlags:(RCTReleaseLevel)releaseLevel
+{
+  static BOOL initialized = NO;
+  static RCTReleaseLevel chosenReleaseLevel;
+  NSLog(@"_setUpFeatureFlags called with release level %li", releaseLevel);
+  if (!initialized) {
+    chosenReleaseLevel = releaseLevel;
+    initialized = YES;
+  } else if (chosenReleaseLevel != releaseLevel) {
+    [NSException
+         raise:@"RCTReactNativeFactory::_setUpFeatureFlags releaseLevel mismatch between React Native instances"
+        format:@"The releaseLevel (%li) of the new instance does not match the previous instance's releaseLevel (%li)",
+               releaseLevel,
+               chosenReleaseLevel];
   }
-};
 
-- (void)_setUpFeatureFlags
-{
   static dispatch_once_t setupFeatureFlagsToken;
   dispatch_once(&setupFeatureFlagsToken, ^{
-    if ([self bridgelessEnabled]) {
-      ReactNativeFeatureFlags::override(std::make_unique<RCTAppDelegateBridgelessFeatureFlags>());
+    switch (releaseLevel) {
+      case Stable:
+        if ([self bridgelessEnabled]) {
+          ReactNativeFeatureFlags::override(std::make_unique<ReactNativeFeatureFlagsOverridesOSSStable>());
+        }
+        break;
+      case Canary:
+        ReactNativeFeatureFlags::override(std::make_unique<ReactNativeFeatureFlagsOverridesOSSCanary>());
+        break;
+      case Experimental:
+        ReactNativeFeatureFlags::override(std::make_unique<ReactNativeFeatureFlagsOverridesOSSExperimental>());
+        break;
     }
   });
 }

package/Libraries/AppDelegate/RCTRootViewFactory.h

@@ -212,6 +212,15 @@ typedef void (^RCTLoadSourceForBridgeBlock)(RCTBridge *bridge, RCTSourceLoadBloc
 
 #pragma mark - RCTRootViewFactory Helpers
 
+/**
+ * Initialize React Host/Bridge without creating a view.
+ *
+ * Use it to speed up later viewWithModuleName: calls.
+ *
+ * @parameter: launchOptions  - a dictionary with a set of options.
+ */
+- (void)initializeReactHostWithLaunchOptions:(NSDictionary *__nullable)launchOptions;
+
 - (RCTHost *)createReactHost:(NSDictionary *__nullable)launchOptions;
 
 @end

package/Libraries/AppDelegate/RCTRootViewFactory.mm

@@ -133,9 +133,7 @@
   return [self viewWithModuleName:moduleName initialProperties:nil launchOptions:nil];
 }
 
-- (UIView *)viewWithModuleName:(NSString *)moduleName
-             initialProperties:(NSDictionary *)initProps
-                 launchOptions:(NSDictionary *)launchOptions
+- (void)initializeReactHostWithLaunchOptions:(NSDictionary *)launchOptions
 {
   if (_configuration.bridgelessEnabled) {
     // Enable TurboModule interop by default in Bridgeless mode
@@ -143,7 +141,20 @@
     RCTEnableTurboModuleInteropBridgeProxy(YES);
 
     [self createReactHostIfNeeded:launchOptions];
+    return;
+  }
+
+  [self createBridgeIfNeeded:launchOptions];
+  [self createBridgeAdapterIfNeeded];
+}
 
+- (UIView *)viewWithModuleName:(NSString *)moduleName
+             initialProperties:(NSDictionary *)initProps
+                 launchOptions:(NSDictionary *)launchOptions
+{
+  [self initializeReactHostWithLaunchOptions:launchOptions];
+
+  if (_configuration.bridgelessEnabled) {
     RCTFabricSurface *surface = [self.reactHost createSurfaceWithModuleName:moduleName initialProperties:initProps];
 
     RCTSurfaceHostingProxyRootView *surfaceHostingProxyRootView =
@@ -158,9 +169,6 @@
     return surfaceHostingProxyRootView;
   }
 
-  [self createBridgeIfNeeded:launchOptions];
-  [self createBridgeAdapterIfNeeded];
-
   UIView *rootView;
   if (_configuration.createRootViewWithBridge != nil) {
     rootView = _configuration.createRootViewWithBridge(self.bridge, moduleName, initProps);

package/Libraries/AppDelegate/React-RCTAppDelegate.podspec

@@ -16,26 +16,17 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-
 is_new_arch_enabled = ENV["RCT_NEW_ARCH_ENABLED"] != "0"
 use_hermes = ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == '1'
 
 new_arch_enabled_flag = (is_new_arch_enabled ? " -DRCT_NEW_ARCH_ENABLED=1" : "")
 hermes_flag = (use_hermes ? " -DUSE_HERMES=1" : "")
 use_third_party_jsc_flag = ENV['USE_THIRD_PARTY_JSC'] == '1' ? " -DUSE_THIRD_PARTY_JSC=1" : ""
-other_cflags = "$(inherited) " + folly_compiler_flags + new_arch_enabled_flag + hermes_flag  + use_third_party_jsc_flag
+other_cflags = "$(inherited) " + new_arch_enabled_flag + hermes_flag + use_third_party_jsc_flag
 
 header_search_paths = [
   "$(PODS_TARGET_SRCROOT)/../../ReactCommon",
   "$(PODS_ROOT)/Headers/Private/React-Core",
-  "$(PODS_ROOT)/boost",
-  "$(PODS_ROOT)/DoubleConversion",
-  "$(PODS_ROOT)/fast_float/include",
-  "$(PODS_ROOT)/fmt/include",
-  "$(PODS_ROOT)/RCT-Folly",
   "${PODS_ROOT}/Headers/Public/FlipperKit",
   "$(PODS_ROOT)/Headers/Public/ReactCommon",
   "$(PODS_ROOT)/Headers/Public/React-RCTFabric",
@@ -68,7 +59,6 @@ Pod::Spec.new do |s|
   s.user_target_xcconfig   = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/Headers/Private/React-Core\" \"$(PODS_ROOT)/Headers/Private/Yoga\""}
 
   s.dependency "React-Core"
-  s.dependency "RCT-Folly", folly_version
   s.dependency "RCTRequired"
   s.dependency "RCTTypeSafety"
   s.dependency "React-RCTNetwork"
@@ -93,4 +83,5 @@ Pod::Spec.new do |s|
   add_dependency(s, "React-RCTRuntime", :framework_name => "RCTRuntime")
 
   depend_on_js_engine(s)
+  add_rn_third_party_dependencies(s)
 end

package/Libraries/AppState/AppState.js

@@ -22,7 +22,12 @@ import NativeAppState from './NativeAppState';
  *   - @platform android - on another Activity (even if it was launched by your app)
  * @platform ios - inactive - This is a state that occurs when transitioning between foreground & background, and during periods of inactivity such as entering the multitasking view, opening the Notification Center or in the event of an incoming call.
  */
-export type AppStateStatus = 'inactive' | 'background' | 'active';
+export type AppStateStatus =
+  | 'inactive'
+  | 'background'
+  | 'active'
+  | 'extension'
+  | 'unknown';
 
 /**
  * change - This even is received when the app state has changed.
@@ -107,7 +112,7 @@ class AppStateImpl {
    */
   addEventListener<K: AppStateEvent>(
     type: K,
-    handler: (...$ElementType<AppStateEventDefinitions, K>) => void,
+    handler: (...AppStateEventDefinitions[K]) => void,
   ): EventSubscription {
     const emitter = this._emitter;
     if (emitter == null) {

package/Libraries/BatchedBridge/MessageQueue.js

@@ -35,7 +35,7 @@ const PARAMS = 2;
 const MIN_TIME_BETWEEN_FLUSHES_MS = 5;
 
 // eslint-disable-next-line no-bitwise
-const TRACE_TAG_REACT_APPS = 1 << 17;
+const TRACE_TAG_REACT = 1 << 13;
 
 const DEBUG_INFO_LIMIT = 32;
 
@@ -228,7 +228,7 @@ class MessageQueue {
     if (__DEV__) {
       global.nativeTraceBeginAsyncFlow &&
         global.nativeTraceBeginAsyncFlow(
-          TRACE_TAG_REACT_APPS,
+          TRACE_TAG_REACT,
           'native',
           this._callID,
         );

package/Libraries/BatchedBridge/NativeModules.js

@@ -65,6 +65,7 @@ function genModule(
       module[methodName] = genMethod(moduleID, methodID, methodType);
     });
 
+  // $FlowFixMe[unsafe-object-assign]
   Object.assign(module, constants);
 
   if (module.getConstants == null) {
@@ -173,6 +174,7 @@ function updateErrorWithErrorData(
   /* $FlowFixMe[class-object-subtyping] added when improving typing for this
    * parameters */
   // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[unsafe-object-assign]
   return Object.assign(error, errorData || {});
 }
 

package/Libraries/Blob/BlobManager.js

@@ -110,6 +110,7 @@ class BlobManager {
   static createFromOptions(options: BlobData): Blob {
     BlobRegistry.register(options.blobId);
     // $FlowFixMe[prop-missing]
+    // $FlowFixMe[unsafe-object-assign]
     return Object.assign(Object.create(Blob.prototype), {
       data:
         // Reuse the collector instance when creating from an existing blob.

package/Libraries/Blob/FileReader.js

@@ -8,13 +8,224 @@
  * @format
  */
 
-import typeof FileReader from './FileReader_old';
+import type {EventCallback} from '../../src/private/webapis/dom/events/EventTarget';
+import type Blob from './Blob';
 
-// Use a global instead of a flag from ReactNativeFeatureFlags because this will
-// be read before apps have a chance to set overrides.
-const useBuiltInEventTarget = global.RN$useBuiltInEventTarget?.();
+import Event from '../../src/private/webapis/dom/events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../../src/private/webapis/dom/events/EventHandlerAttributes';
+import EventTarget from '../../src/private/webapis/dom/events/EventTarget';
+import NativeFileReaderModule from './NativeFileReaderModule';
+import {toByteArray} from 'base64-js';
 
-export default (useBuiltInEventTarget
-  ? // $FlowExpectedError[incompatible-cast]
-    require('./FileReader_new').default
-  : require('./FileReader_old').default) as FileReader;
+type ReadyState =
+  | 0 // EMPTY
+  | 1 // LOADING
+  | 2; // DONE
+
+type ReaderResult = string | ArrayBuffer;
+
+const EMPTY = 0;
+const LOADING = 1;
+const DONE = 2;
+
+class FileReader extends EventTarget {
+  static EMPTY: number = EMPTY;
+  static LOADING: number = LOADING;
+  static DONE: number = DONE;
+
+  EMPTY: number = EMPTY;
+  LOADING: number = LOADING;
+  DONE: number = DONE;
+
+  _readyState: ReadyState;
+  _error: ?Error;
+  _result: ?ReaderResult;
+  _aborted: boolean = false;
+
+  constructor() {
+    super();
+    this._reset();
+  }
+
+  _reset(): void {
+    this._readyState = EMPTY;
+    this._error = null;
+    this._result = null;
+  }
+
+  _setReadyState(newState: ReadyState) {
+    this._readyState = newState;
+    this.dispatchEvent(new Event('readystatechange'));
+    if (newState === DONE) {
+      if (this._aborted) {
+        this.dispatchEvent(new Event('abort'));
+      } else if (this._error) {
+        this.dispatchEvent(new Event('error'));
+      } else {
+        this.dispatchEvent(new Event('load'));
+      }
+      this.dispatchEvent(new Event('loadend'));
+    }
+  }
+
+  readAsArrayBuffer(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+
+        const base64 = text.split(',')[1];
+        const typedArray = toByteArray(base64);
+
+        this._result = typedArray.buffer;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsDataURL(blob: ?Blob): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsDataURL(blob.data).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  readAsText(blob: ?Blob, encoding: string = 'UTF-8'): void {
+    this._aborted = false;
+
+    if (blob == null) {
+      throw new TypeError(
+        "Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'",
+      );
+    }
+
+    NativeFileReaderModule.readAsText(blob.data, encoding).then(
+      (text: string) => {
+        if (this._aborted) {
+          return;
+        }
+        this._result = text;
+        this._setReadyState(DONE);
+      },
+      error => {
+        if (this._aborted) {
+          return;
+        }
+        this._error = error;
+        this._setReadyState(DONE);
+      },
+    );
+  }
+
+  abort() {
+    this._aborted = true;
+    // only call onreadystatechange if there is something to abort, as per spec
+    if (this._readyState !== EMPTY && this._readyState !== DONE) {
+      this._reset();
+      this._setReadyState(DONE);
+    }
+    // Reset again after, in case modified in handler
+    this._reset();
+  }
+
+  get readyState(): ReadyState {
+    return this._readyState;
+  }
+
+  get error(): ?Error {
+    return this._error;
+  }
+
+  get result(): ?ReaderResult {
+    return this._result;
+  }
+
+  get onabort(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'abort');
+  }
+
+  set onabort(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'abort', listener);
+  }
+
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+
+  get onload(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'load');
+  }
+
+  set onload(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'load', listener);
+  }
+
+  get onloadstart(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadstart');
+  }
+
+  set onloadstart(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadstart', listener);
+  }
+
+  get onloadend(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'loadend');
+  }
+
+  set onloadend(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'loadend', listener);
+  }
+
+  get onprogress(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'progress');
+  }
+
+  set onprogress(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'progress', listener);
+  }
+}
+
+export default FileReader;

package/Libraries/Blob/RCTBlobCollector.mm

@@ -21,7 +21,7 @@ RCTBlobCollector::~RCTBlobCollector()
 {
   RCTBlobManager *blobManager = blobManager_;
   NSString *blobId = [NSString stringWithUTF8String:blobId_.c_str()];
-  dispatch_async([blobManager_ executionQueue], ^{
+  dispatch_async(blobManager_.methodQueue, ^{
     [blobManager remove:blobId];
   });
 }

package/Libraries/Blob/RCTBlobManager.h

@@ -10,8 +10,6 @@
 #import <React/RCTInitializing.h>
 #import <React/RCTURLRequestHandler.h>
 
-RCT_EXTERN void RCTEnableBlobManagerProcessingQueue(BOOL enabled);
-
 @interface RCTBlobManager : NSObject <RCTBridgeModule, RCTURLRequestHandler, RCTInitializing>
 
 - (NSString *)store:(NSData *)data;
@@ -30,6 +28,4 @@ RCT_EXTERN void RCTEnableBlobManagerProcessingQueue(BOOL enabled);
 
 - (void)createFromParts:(NSArray<NSDictionary<NSString *, id> *> *)parts withId:(NSString *)blobId;
 
-- (dispatch_queue_t)executionQueue;
-
 @end

package/Libraries/Blob/RCTBlobManager.mm

@@ -22,13 +22,6 @@
 RCT_MOCK_DEF(RCTBlobManager, dispatch_async);
 #define dispatch_async RCT_MOCK_USE(RCTBlobManager, dispatch_async)
 
-static BOOL gBlobManagerProcessingQueueEnabled = NO;
-
-RCT_EXTERN void RCTEnableBlobManagerProcessingQueue(BOOL enabled)
-{
-  gBlobManagerProcessingQueueEnabled = enabled;
-}
-
 static NSString *const kBlobURIScheme = @"blob";
 
 @interface RCTBlobManager () <
@@ -59,11 +52,6 @@ RCT_EXPORT_MODULE(BlobModule)
 {
   std::lock_guard<std::mutex> lock(_blobsMutex);
   _blobs = [NSMutableDictionary new];
-
-  if (gBlobManagerProcessingQueueEnabled) {
-    _processingQueue = dispatch_queue_create("com.facebook.react.blobmanager.processing", DISPATCH_QUEUE_SERIAL);
-  }
-
   facebook::react::RCTBlobCollector::install(self);
 }
 
@@ -165,11 +153,11 @@ RCT_EXPORT_METHOD(addNetworkingHandler)
 
   // TODO(T63516227): Why can methodQueue be nil here?
   // We don't want to do anything when methodQueue is nil.
-  if (![networking requestQueue]) {
+  if (!networking.methodQueue) {
     return;
   }
 
-  dispatch_async([networking requestQueue], ^{
+  dispatch_async(networking.methodQueue, ^{
     [networking addRequestHandler:self];
     [networking addResponseHandler:self];
   });
@@ -217,23 +205,18 @@ RCT_EXPORT_METHOD(createFromParts : (NSArray<NSDictionary<NSString *, id> *> *)p
     }
   }
 
-  dispatch_async([self executionQueue], ^{
+  dispatch_async(_methodQueue, ^{
     [self store:data withId:blobId];
   });
 }
 
 RCT_EXPORT_METHOD(release : (NSString *)blobId)
 {
-  dispatch_async([self executionQueue], ^{
+  dispatch_async(_methodQueue, ^{
     [self remove:blobId];
   });
 }
 
-- (dispatch_queue_t)executionQueue
-{
-  return gBlobManagerProcessingQueueEnabled ? _processingQueue : _methodQueue;
-}
-
 #pragma mark - RCTURLRequestHandler methods
 
 - (BOOL)canHandleRequest:(NSURLRequest *)request