[Performance] Remove redundant image scheduler hop

AsyncImageView/AsyncImageLoader.swift

@@ -27,11 +27,9 @@ Renderer.RenderResult == PlaceholderRenderer.RenderResult {
         requestsSignal: Signal<Data?, Never>,
         renderer: Renderer,
         placeholderRenderer: PlaceholderRenderer?,
-        uiScheduler: ReactiveSwift.Scheduler,
-        imageCreationScheduler: ReactiveSwift.Scheduler
+        uiScheduler: ReactiveSwift.Scheduler
     ) -> Signal<Renderer.RenderResult?, Never> {
         return requestsSignal.skipRepeats(==)
-            .observe(on: imageCreationScheduler)
             .flatMap(.latest) { data -> SignalProducer<Renderer.RenderResult?, Never> in
                 let prefixSignal: SignalProducer<Renderer.RenderResult?, Never> = .init(value: nil)
 

AsyncImageView/AsyncImageView.swift

@@ -59,8 +59,7 @@ open class AsyncImageView<
 			requestsSignal: self.requestsSignal,
 			renderer: renderer,
 			placeholderRenderer: placeholderRenderer,
-			uiScheduler: uiScheduler,
-			imageCreationScheduler: imageCreationScheduler
+			uiScheduler: uiScheduler
 		)
 		.observeValues { [weak self] result in
 			self?.updateImage(result)

AsyncImageView/AsyncSwiftUIImageView.swift

@@ -178,8 +178,7 @@ private final class AsyncSwiftUIImageViewModel<
             requestsSignal: self.requestsSignal,
             renderer: self.renderer,
             placeholderRenderer: self.placeholderRenderer,
-            uiScheduler: self.uiScheduler,
-            imageCreationScheduler: self.imageCreationScheduler
+            uiScheduler: self.uiScheduler
         )
         .observeValues { [weak self] result in
             self?.renderResult = result

AsyncImageViewTests/AsyncImageSchedulerSpec.swift

@@ -0,0 +1,71 @@
+import Quick
+import Nimble
+import UIKit
+
+import ReactiveSwift
+
+import AsyncImageView
+
+class AsyncImageSchedulerSpec: QuickSpec {
+	override class func spec() {
+		describe("AsyncImageView scheduling") {
+			it("schedules image creation once per request") {
+				let imageCreationScheduler = CountingScheduler()
+				let renderer = SchedulerCheckingRenderer(scheduler: imageCreationScheduler)
+				let view = AsyncImageView<
+					TestRenderData,
+					TestData,
+					SchedulerCheckingRenderer,
+					SchedulerCheckingRenderer
+				>(
+					initialFrame: CGRect(origin: .zero, size: CGSize(width: 10, height: 10)),
+					renderer: renderer,
+					placeholderRenderer: nil,
+					uiScheduler: ImmediateScheduler(),
+					imageCreationScheduler: imageCreationScheduler
+				)
+				let window = UIWindow()
+				window.addSubview(view)
+				imageCreationScheduler.reset()
+
+				view.data = .a
+
+				expect(imageCreationScheduler.scheduleCount.value) == 1
+				expect(renderer.startedOnScheduler.value) == true
+			}
+		}
+	}
+}
+
+private final class CountingScheduler: Scheduler {
+	let scheduleCount = Atomic(0)
+	let isExecuting = Atomic(false)
+
+	func schedule(_ action: @escaping () -> Void) -> Disposable? {
+		self.scheduleCount.modify { $0 += 1 }
+		self.isExecuting.modify { $0 = true }
+		action()
+		self.isExecuting.modify { $0 = false }
+
+		return nil
+	}
+
+	func reset() {
+		self.scheduleCount.modify { $0 = 0 }
+	}
+}
+
+private final class SchedulerCheckingRenderer: RendererType {
+	let startedOnScheduler = Atomic(false)
+	private let scheduler: CountingScheduler
+
+	init(scheduler: CountingScheduler) {
+		self.scheduler = scheduler
+	}
+
+	func renderImageWithData(_ data: TestRenderData) -> SignalProducer<UIImage, Never> {
+		self.startedOnScheduler.modify { $0 = self.scheduler.isExecuting.value }
+
+		return SignalProducer(value: UIImage())
+	}
+}