Migrate RCTImage NativeModules to CoreModules

Summary:
This diff moves RCTImageLoader, RCTImageEditingManager, and RCTImageStoreManager to CoreModules. This is necessary for us to convert all these NativeModules to TurboModules.

**Note:** As a part of this diff, I had to break apart `RCTImageLoader.h`. All the protocols that were in `RCTImageLoader` are now in their own headers. Furthermore, `RCTImageLoader`'s methods are defined in `RCTImageLoaderProtocol`, so that we can call them from classes like `RCTImageViewManager` in `RCTImage`.

Reviewed By: PeteTheHeat

Differential Revision: D16805827

fbshipit-source-id: 89f6728b0766c30b74e25f7af1be8e6b8a7e6397

Libraries/Image/RCTGIFImageDecoder.h

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#import <React/RCTImageLoader.h>
+#import <React/RCTImageDataDecoder.h>
 
 @interface RCTGIFImageDecoder : NSObject <RCTImageDataDecoder>
 

Libraries/Image/RCTImageCache.h

@@ -5,9 +5,38 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#import <UIKit/UIKit.h>
 #import <Foundation/Foundation.h>
 
-#import <React/RCTImageLoader.h>
+#import <React/RCTResizeMode.h>
+
+@interface UIImage (React)
+
+/**
+ * Memory bytes of the image with the default calculation of static image or GIF. Custom calculations of decoded bytes can be assigned manually.
+ */
+@property (nonatomic, assign) NSInteger reactDecodedImageBytes;
+
+@end
+
+/**
+ * Provides an interface to use for providing a image caching strategy.
+ */
+@protocol RCTImageCache <NSObject>
+
+- (UIImage *)imageForUrl:(NSString *)url
+                    size:(CGSize)size
+                   scale:(CGFloat)scale
+              resizeMode:(RCTResizeMode)resizeMode;
+
+- (void)addImageToCache:(UIImage *)image
+                    URL:(NSString *)url
+                   size:(CGSize)size
+                  scale:(CGFloat)scale
+             resizeMode:(RCTResizeMode)resizeMode
+               response:(NSURLResponse *)response;
+
+@end
 
 @interface RCTImageCache : NSObject <RCTImageCache>
 @end

Libraries/Image/RCTImageDataDecoder.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+#import <React/RCTURLRequestHandler.h>
+#import <React/RCTImageURLLoader.h>
+
+/**
+ * Provides the interface needed to register an image decoder. Image decoders
+ * are also bridge modules, so should be registered using RCT_EXPORT_MODULE().
+ */
+@protocol RCTImageDataDecoder <RCTBridgeModule>
+
+/**
+ * Indicates whether this handler is capable of decoding the specified data.
+ * Typically the handler would examine some sort of header data to determine
+ * this.
+ */
+- (BOOL)canDecodeImageData:(NSData *)imageData;
+
+/**
+ * Decode an image from the data object. The method should call the
+ * completionHandler when the decoding operation  has finished. The method
+ * should also return a cancellation block, if applicable.
+ *
+ * If you provide a custom image decoder, you most implement scheduling yourself,
+ * to avoid decoding large amounts of images at the same time.
+ */
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
+
+@optional
+
+/**
+ * If more than one RCTImageDataDecoder responds YES to `-canDecodeImageData:`
+ * then `decoderPriority` is used to determine which one to use. The decoder
+ * with the highest priority will be selected. Default priority is zero.
+ * If two or more valid decoders have the same priority, the selection order is
+ * undefined.
+ */
+- (float)decoderPriority;
+
+@end

Libraries/Image/RCTImageLoader.h

@@ -1,263 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#import <UIKit/UIKit.h>
-
-#import <React/RCTBridge.h>
-#import <React/RCTResizeMode.h>
-#import <React/RCTURLRequestHandler.h>
-
-typedef void (^RCTImageLoaderProgressBlock)(int64_t progress, int64_t total);
-typedef void (^RCTImageLoaderPartialLoadBlock)(UIImage *image);
-typedef void (^RCTImageLoaderCompletionBlock)(NSError *error, UIImage *image);
-typedef dispatch_block_t RCTImageLoaderCancellationBlock;
-
-@protocol RCTImageURLLoader;
-@protocol RCTImageDataDecoder;
-
-/**
- * Provides an interface to use for providing a image caching strategy.
- */
-@protocol RCTImageCache <NSObject>
-
-- (UIImage *)imageForUrl:(NSString *)url
-                    size:(CGSize)size
-                   scale:(CGFloat)scale
-              resizeMode:(RCTResizeMode)resizeMode;
-
-- (void)addImageToCache:(UIImage *)image
-                    URL:(NSString *)url
-                   size:(CGSize)size
-                  scale:(CGFloat)scale
-             resizeMode:(RCTResizeMode)resizeMode
-               response:(NSURLResponse *)response;
-
-@end
-
-/**
- * If available, RCTImageRedirectProtocol is invoked before loading an asset.
- * Implementation should return either a new URL or nil when redirection is
- * not needed.
- */
-
-@protocol RCTImageRedirectProtocol
-
-- (NSURL *)redirectAssetsURL:(NSURL *)URL;
-
-@end
-
-@interface UIImage (React)
-
-/**
- * Memory bytes of the image with the default calculation of static image or GIF. Custom calculations of decoded bytes can be assigned manually.
- */
-@property (nonatomic, assign) NSInteger reactDecodedImageBytes;
-
-@end
-
-@interface RCTImageLoader : NSObject <RCTBridgeModule, RCTURLRequestHandler>
-
-/**
- * The maximum number of concurrent image loading tasks. Loading and decoding
- * images can consume a lot of memory, so setting this to a higher value may
- * cause memory to spike. If you are seeing out-of-memory crashes, try reducing
- * this value.
- */
-@property (nonatomic, assign) NSUInteger maxConcurrentLoadingTasks;
-
-/**
- * The maximum number of concurrent image decoding tasks. Decoding large
- * images can be especially CPU and memory intensive, so if your are decoding a
- * lot of large images in your app, you may wish to adjust this value.
- */
-@property (nonatomic, assign) NSUInteger maxConcurrentDecodingTasks;
-
-/**
- * Decoding large images can use a lot of memory, and potentially cause the app
- * to crash. This value allows you to throttle the amount of memory used by the
- * decoder independently of the number of concurrent threads. This means you can
- * still decode a lot of small images in parallel, without allowing the decoder
- * to try to decompress multiple huge images at once. Note that this value is
- * only a hint, and not an indicator of the total memory used by the app.
- */
-@property (nonatomic, assign) NSUInteger maxConcurrentDecodingBytes;
-
-- (instancetype)init;
-- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate NS_DESIGNATED_INITIALIZER;
-- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate
-                              loadersProvider:(NSArray<id<RCTImageURLLoader>> * (^)(void))getLoaders
-                             decodersProvider:(NSArray<id<RCTImageDataDecoder>> * (^)(void))getDecoders;
-
-/**
- * Loads the specified image at the highest available resolution.
- * Can be called from any thread, will call back on an unspecified thread.
- */
-- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
-                                                  callback:(RCTImageLoaderCompletionBlock)callback;
-
-/**
- * As above, but includes target `size`, `scale` and `resizeMode`, which are used to
- * select the optimal dimensions for the loaded image. The `clipped` option
- * controls whether the image will be clipped to fit the specified size exactly,
- * or if the original aspect ratio should be retained.
- * `partialLoadBlock` is meant for custom image loaders that do not ship with the core RN library.
- * It is meant to be called repeatedly while loading the image as higher quality versions are decoded,
- * for instance with progressive JPEGs.
- */
-- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
-                                                      size:(CGSize)size
-                                                     scale:(CGFloat)scale
-                                                   clipped:(BOOL)clipped
-                                                resizeMode:(RCTResizeMode)resizeMode
-                                             progressBlock:(RCTImageLoaderProgressBlock)progressBlock
-                                          partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
-                                           completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
-
-/**
- * Finds an appropriate image decoder and passes the target `size`, `scale` and
- * `resizeMode` for optimal image decoding.  The `clipped` option controls
- * whether the image will be clipped to fit the specified size exactly, or
- * if the original aspect ratio should be retained. Can be called from any
- * thread, will call callback on an unspecified thread.
- */
-- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
-                                              size:(CGSize)size
-                                             scale:(CGFloat)scale
-                                           clipped:(BOOL)clipped
-                                        resizeMode:(RCTResizeMode)resizeMode
-                                   completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
-
-/**
- * Get image size, in pixels. This method will do the least work possible to get
- * the information, and won't decode the image if it doesn't have to.
- */
-- (RCTImageLoaderCancellationBlock)getImageSizeForURLRequest:(NSURLRequest *)imageURLRequest
-                                                       block:(void(^)(NSError *error, CGSize size))completionBlock;
-/**
- * Determines whether given image URLs are cached locally. The `requests` array is expected
- * to contain objects convertible to NSURLRequest. The return value maps URLs to strings:
- * "disk" for images known to be cached in non-volatile storage, "memory" for images known
- * to be cached in memory. Dictionary items corresponding to images that are not known to be
- * cached are simply missing.
- */
-- (NSDictionary *)getImageCacheStatus:(NSArray *)requests;
-
-/**
- * Allows developers to set their own caching implementation for
- * decoded images as long as it conforms to the RCTImageCache
- * protocol. This method should be called in bridgeDidInitializeModule.
- */
-- (void)setImageCache:(id<RCTImageCache>)cache;
-
-@end
-
-/**
- * DEPRECATED!! DO NOT USE
- * Instead use `[_bridge moduleForClass:[RCTImageLoader class]]`
- */
-@interface RCTBridge (RCTImageLoader)
-
-@property (nonatomic, readonly) RCTImageLoader *imageLoader;
-
-@end
-
-/**
- * Provides the interface needed to register an image loader. Image data
- * loaders are also bridge modules, so should be registered using
- * RCT_EXPORT_MODULE().
- */
-@protocol RCTImageURLLoader <RCTBridgeModule>
-
-/**
- * Indicates whether this data loader is capable of processing the specified
- * request URL. Typically the handler would examine the scheme/protocol of the
- * URL to determine this.
- */
-- (BOOL)canLoadImageURL:(NSURL *)requestURL;
-
-/**
- * Send a network request to load the request URL. The method should call the
- * progressHandler (if applicable) and the completionHandler when the request
- * has finished. The method should also return a cancellation block, if
- * applicable.
- */
-- (RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
-                                              size:(CGSize)size
-                                             scale:(CGFloat)scale
-                                        resizeMode:(RCTResizeMode)resizeMode
-                                   progressHandler:(RCTImageLoaderProgressBlock)progressHandler
-                                partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
-                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
-
-@optional
-
-/**
- * If more than one RCTImageURLLoader responds YES to `-canLoadImageURL:`
- * then `loaderPriority` is used to determine which one to use. The loader
- * with the highest priority will be selected. Default priority is zero. If
- * two or more valid loaders have the same priority, the selection order is
- * undefined.
- */
-- (float)loaderPriority;
-
-/**
- * If the loader must be called on the serial url cache queue, and whether the completion
- * block should be dispatched off the main thread. If this is NO, the loader will be
- * called from the main queue. Defaults to YES.
- *
- * Use with care: disabling scheduling will reduce RCTImageLoader's ability to throttle
- * network requests.
- */
-- (BOOL)requiresScheduling;
-
-/**
- * If images loaded by the loader should be cached in the decoded image cache.
- * Defaults to YES.
- */
-- (BOOL)shouldCacheLoadedImages;
-
-@end
-
-/**
- * Provides the interface needed to register an image decoder. Image decoders
- * are also bridge modules, so should be registered using RCT_EXPORT_MODULE().
- */
-@protocol RCTImageDataDecoder <RCTBridgeModule>
-
-/**
- * Indicates whether this handler is capable of decoding the specified data.
- * Typically the handler would examine some sort of header data to determine
- * this.
- */
-- (BOOL)canDecodeImageData:(NSData *)imageData;
-
-/**
- * Decode an image from the data object. The method should call the
- * completionHandler when the decoding operation  has finished. The method
- * should also return a cancellation block, if applicable.
- *
- * If you provide a custom image decoder, you most implement scheduling yourself,
- * to avoid decoding large amounts of images at the same time.
- */
-- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
-                                              size:(CGSize)size
-                                             scale:(CGFloat)scale
-                                        resizeMode:(RCTResizeMode)resizeMode
-                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
-
-@optional
-
-/**
- * If more than one RCTImageDataDecoder responds YES to `-canDecodeImageData:`
- * then `decoderPriority` is used to determine which one to use. The decoder
- * with the highest priority will be selected. Default priority is zero.
- * If two or more valid decoders have the same priority, the selection order is
- * undefined.
- */
-- (float)decoderPriority;
-
-@end

Libraries/Image/RCTImageLoaderProtocol.h

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+#import <React/RCTURLRequestHandler.h>
+#import <React/RCTImageDataDecoder.h>
+#import <React/RCTImageURLLoader.h>
+#import <React/RCTImageCache.h>
+
+/**
+ * If available, RCTImageRedirectProtocol is invoked before loading an asset.
+ * Implementation should return either a new URL or nil when redirection is
+ * not needed.
+ */
+
+@protocol RCTImageRedirectProtocol
+
+- (NSURL *)redirectAssetsURL:(NSURL *)URL;
+
+@end
+
+@protocol RCTImageLoaderProtocol<RCTURLRequestHandler>
+
+/**
+ * The maximum number of concurrent image loading tasks. Loading and decoding
+ * images can consume a lot of memory, so setting this to a higher value may
+ * cause memory to spike. If you are seeing out-of-memory crashes, try reducing
+ * this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentLoadingTasks;
+
+/**
+ * The maximum number of concurrent image decoding tasks. Decoding large
+ * images can be especially CPU and memory intensive, so if your are decoding a
+ * lot of large images in your app, you may wish to adjust this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingTasks;
+
+/**
+ * Decoding large images can use a lot of memory, and potentially cause the app
+ * to crash. This value allows you to throttle the amount of memory used by the
+ * decoder independently of the number of concurrent threads. This means you can
+ * still decode a lot of small images in parallel, without allowing the decoder
+ * to try to decompress multiple huge images at once. Note that this value is
+ * only a hint, and not an indicator of the total memory used by the app.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingBytes;
+
+/**
+ * Loads the specified image at the highest available resolution.
+ * Can be called from any thread, will call back on an unspecified thread.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                  callback:(RCTImageLoaderCompletionBlock)callback;
+
+/**
+ * As above, but includes target `size`, `scale` and `resizeMode`, which are used to
+ * select the optimal dimensions for the loaded image. The `clipped` option
+ * controls whether the image will be clipped to fit the specified size exactly,
+ * or if the original aspect ratio should be retained.
+ * `partialLoadBlock` is meant for custom image loaders that do not ship with the core RN library.
+ * It is meant to be called repeatedly while loading the image as higher quality versions are decoded,
+ * for instance with progressive JPEGs.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                      size:(CGSize)size
+                                                     scale:(CGFloat)scale
+                                                   clipped:(BOOL)clipped
+                                                resizeMode:(RCTResizeMode)resizeMode
+                                             progressBlock:(RCTImageLoaderProgressBlock)progressBlock
+                                          partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
+                                           completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Finds an appropriate image decoder and passes the target `size`, `scale` and
+ * `resizeMode` for optimal image decoding.  The `clipped` option controls
+ * whether the image will be clipped to fit the specified size exactly, or
+ * if the original aspect ratio should be retained. Can be called from any
+ * thread, will call callback on an unspecified thread.
+ */
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                           clipped:(BOOL)clipped
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Get image size, in pixels. This method will do the least work possible to get
+ * the information, and won't decode the image if it doesn't have to.
+ */
+- (RCTImageLoaderCancellationBlock)getImageSizeForURLRequest:(NSURLRequest *)imageURLRequest
+                                                       block:(void(^)(NSError *error, CGSize size))completionBlock;
+/**
+ * Determines whether given image URLs are cached locally. The `requests` array is expected
+ * to contain objects convertible to NSURLRequest. The return value maps URLs to strings:
+ * "disk" for images known to be cached in non-volatile storage, "memory" for images known
+ * to be cached in memory. Dictionary items corresponding to images that are not known to be
+ * cached are simply missing.
+ */
+- (NSDictionary *)getImageCacheStatus:(NSArray *)requests;
+
+/**
+ * Allows developers to set their own caching implementation for
+ * decoded images as long as it conforms to the RCTImageCache
+ * protocol. This method should be called in bridgeDidInitializeModule.
+ */
+- (void)setImageCache:(id<RCTImageCache>)cache;
+@end

Libraries/Image/RCTImageURLLoader.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+
+typedef void (^RCTImageLoaderProgressBlock)(int64_t progress, int64_t total);
+typedef void (^RCTImageLoaderPartialLoadBlock)(UIImage *image);
+typedef void (^RCTImageLoaderCompletionBlock)(NSError *error, UIImage *image);
+typedef dispatch_block_t RCTImageLoaderCancellationBlock;
+
+/**
+ * Provides the interface needed to register an image loader. Image data
+ * loaders are also bridge modules, so should be registered using
+ * RCT_EXPORT_MODULE().
+ */
+@protocol RCTImageURLLoader <RCTBridgeModule>
+
+/**
+ * Indicates whether this data loader is capable of processing the specified
+ * request URL. Typically the handler would examine the scheme/protocol of the
+ * URL to determine this.
+ */
+- (BOOL)canLoadImageURL:(NSURL *)requestURL;
+
+/**
+ * Send a network request to load the request URL. The method should call the
+ * progressHandler (if applicable) and the completionHandler when the request
+ * has finished. The method should also return a cancellation block, if
+ * applicable.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                                partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
+
+@optional
+
+/**
+ * If more than one RCTImageURLLoader responds YES to `-canLoadImageURL:`
+ * then `loaderPriority` is used to determine which one to use. The loader
+ * with the highest priority will be selected. Default priority is zero. If
+ * two or more valid loaders have the same priority, the selection order is
+ * undefined.
+ */
+- (float)loaderPriority;
+
+/**
+ * If the loader must be called on the serial url cache queue, and whether the completion
+ * block should be dispatched off the main thread. If this is NO, the loader will be
+ * called from the main queue. Defaults to YES.
+ *
+ * Use with care: disabling scheduling will reduce RCTImageLoader's ability to throttle
+ * network requests.
+ */
+- (BOOL)requiresScheduling;
+
+/**
+ * If images loaded by the loader should be cached in the decoded image cache.
+ * Defaults to YES.
+ */
+- (BOOL)shouldCacheLoadedImages;
+
+@end

Libraries/Image/RCTImageView.m

@@ -16,8 +16,8 @@
 
 #import <React/RCTUIImageViewAnimated.h>
 #import <React/RCTImageBlurUtils.h>
-#import <React/RCTImageLoader.h>
 #import <React/RCTImageUtils.h>
+#import <React/RCTImageLoaderProtocol.h>
 
 /**
  * Determines whether an image of `currentSize` should be reloaded for display
@@ -326,7 +326,7 @@ RCT_NOT_IMPLEMENTED(- (instancetype)initWithFrame:(CGRect)frame)
     };
 
     _reloadImageCancellationBlock =
-    [[_bridge moduleForClass:[RCTImageLoader class]] loadImageWithURLRequest:source.request
+    [[_bridge moduleForName:@"ImageLoader"] loadImageWithURLRequest:source.request
                                                                         size:imageSize
                                                                        scale:imageScale
                                                                      clipped:NO

Libraries/Image/RCTImageViewManager.m

@@ -12,9 +12,9 @@
 #import <React/RCTConvert.h>
 #import <React/RCTImageSource.h>
 
-#import <React/RCTImageLoader.h>
 #import <React/RCTImageShadowView.h>
 #import <React/RCTImageView.h>
+#import <React/RCTImageLoaderProtocol.h>
 
 @implementation RCTImageViewManager
 
@@ -54,7 +54,7 @@ RCT_EXPORT_METHOD(getSize:(NSURLRequest *)request
                   successBlock:(RCTResponseSenderBlock)successBlock
                   errorBlock:(RCTResponseErrorBlock)errorBlock)
 {
-  [[self.bridge moduleForClass:[RCTImageLoader class]]
+  [[self.bridge moduleForName:@"ImageLoader"]
    getImageSizeForURLRequest:request
    block:^(NSError *error, CGSize size) {
      if (error) {
@@ -69,7 +69,7 @@ RCT_EXPORT_METHOD(getSizeWithHeaders:(RCTImageSource *)source
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 {
-  [[self.bridge moduleForClass:[RCTImageLoader class]]
+  [[self.bridge moduleForName:@"ImageLoader"]
    getImageSizeForURLRequest:source.request
    block:^(NSError *error, CGSize size) {
      if (error) {
@@ -89,7 +89,7 @@ RCT_EXPORT_METHOD(prefetchImage:(NSURLRequest *)request
     return;
   }
 
-  [[self.bridge moduleForClass:[RCTImageLoader class]]
+  [[self.bridge moduleForName:@"ImageLoader"]
    loadImageWithURLRequest:request
    callback:^(NSError *error, UIImage *image) {
      if (error) {
@@ -104,7 +104,7 @@ RCT_EXPORT_METHOD(queryCache:(NSArray *)requests
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 {
-  resolve([[self.bridge moduleForClass:[RCTImageLoader class]] getImageCacheStatus:requests]);
+  resolve([[self.bridge moduleForName:@"ImageLoader"] getImageCacheStatus:requests]);
 }
 
 @end

Libraries/Image/RCTLocalAssetImageLoader.h

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#import <React/RCTImageLoader.h>
+#import <React/RCTImageURLLoader.h>
 
 @interface RCTLocalAssetImageLoader : NSObject <RCTImageURLLoader>
 

RNTester/Podfile.lock

@@ -377,4 +377,4 @@ SPEC CHECKSUMS:
 
 PODFILE CHECKSUM: 060903e270072f1e192b064848e6c34528af1c87
 
-COCOAPODS: 1.7.1
+COCOAPODS: 1.6.1

React/CoreModules/BUCK

@@ -47,6 +47,7 @@ rn_apple_library(
     reexport_all_header_dependencies = True,
     visibility = ["PUBLIC"],
     exported_deps = [
+        "fbsource//xplat/js:RCTImageApple",
         "fbsource//xplat/js/react-native-github:ReactInternalApple",
         "fbsource//xplat/js/react-native-github/Libraries/FBReactNativeSpec:FBReactNativeSpecApple",
     ],

React/CoreModules/RCTImageEditingManager.m

@@ -16,6 +16,7 @@
 #import <React/RCTImageLoader.h>
 #import <React/RCTImageStoreManager.h>
 #import <React/RCTImageUtils.h>
+#import <React/RCTImageLoaderProtocol.h>
 
 @implementation RCTImageEditingManager
 
@@ -43,7 +44,7 @@ RCT_EXPORT_METHOD(cropImage:(NSURLRequest *)imageRequest
     [RCTConvert CGSize:cropData[@"size"]]
   };
 
-  [[_bridge moduleForClass:[RCTImageLoader class]]
+  [[_bridge moduleForName:@"ImageLoader"]
    loadImageWithURLRequest:imageRequest callback:^(NSError *error, UIImage *image) {
      if (error) {
        errorCallback(error);

React/CoreModules/RCTImageLoader.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+#import <React/RCTURLRequestHandler.h>
+#import <React/RCTImageDataDecoder.h>
+#import <React/RCTImageURLLoader.h>
+#import <React/RCTImageCache.h>
+#import <React/RCTImageLoaderProtocol.h>
+
+@interface RCTImageLoader : NSObject <RCTBridgeModule, RCTImageLoaderProtocol>
+- (instancetype)init;
+- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate
+                              loadersProvider:(NSArray<id<RCTImageURLLoader>> * (^)(void))getLoaders
+                             decodersProvider:(NSArray<id<RCTImageDataDecoder>> * (^)(void))getDecoders;
+@end
+
+/**
+ * DEPRECATED!! DO NOT USE
+ * Instead use `[_bridge moduleForClass:[RCTImageLoader class]]`
+ */
+@interface RCTBridge (RCTImageLoader)
+
+@property (nonatomic, readonly) RCTImageLoader *imageLoader;
+
+@end

React/CoreModules/RCTImageLoader.m

@@ -62,6 +62,9 @@ static NSInteger RCTImageBytesForImage(UIImage *image)
 }
 
 @synthesize bridge = _bridge;
+@synthesize maxConcurrentLoadingTasks = _maxConcurrentLoadingTasks;
+@synthesize maxConcurrentDecodingTasks = _maxConcurrentDecodingTasks;
+@synthesize maxConcurrentDecodingBytes = _maxConcurrentDecodingBytes;
 
 RCT_EXPORT_MODULE()
 

ReactCommon/fabric/imagemanager/BUCK

@@ -59,6 +59,7 @@ rn_xplat_cxx_library(
     ios_deps = [
         "fbsource//xplat/js:RCTImage",
         "fbsource//xplat/js/react-native-github:RCTCxxBridge",
+        "fbsource//xplat/js/react-native-github/React/CoreModules:CoreModules",
     ],
     ios_exported_headers = subdir_glob(
         [