     }
     
     // A single key may have multiple callbacks. Only download once.
-    func setup(progressBlock: ImageDownloaderProgressBlock?, with completionHandler: ImageDownloaderCompletionHandler?, for url: URL, started: ((URLSession, ImageFetchLoad) -> Void)) {
+    func setup(progressBlock: ImageDownloaderProgressBlock?, with completionHandler: ImageDownloaderCompletionHandler?, for url: URL, options: KingfisherOptionsInfo?, started: ((URLSession, ImageFetchLoad) -> Void)) {
 
         barrierQueue.sync(flags: .barrier) {
             let loadObjectForURL = fetchLoads[url] ?? ImageFetchLoad()
-            let callbackPair = (progressBlock: progressBlock, completionHander: completionHandler)
-            
-            loadObjectForURL.callbacks.append(callbackPair)
+            let callbackPair = (progressBlock: progressBlock, completionHandler: completionHandler)
+            
+            loadObjectForURL.contents.append((callbackPair, options ?? KingfisherEmptyOptionsInfo))
+            
             fetchLoads[url] = loadObjectForURL
             
             if let session = session {

        downloader.processQueue.async {
            
            guard let fetchLoad = downloader.fetchLoad(for: url) else {
                self.callback(with: nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.badData.rawValue, userInfo: nil), url: url, originalData: nil)
                return
            }

            let options = fetchLoad.options ?? KingfisherEmptyOptionsInfo
            let data = fetchLoad.responseData as Data
            
            if let image = options.processor.process(item: .data(data), options: options) {
    
                downloader.delegate?.imageDownloader(downloader, didDownload: image, for: url, with: task.response)
                
                if options.backgroundDecode {
                    self.callback(with: image.kf.decoded(scale: options.scaleFactor), error: nil, url: url, originalData: data)
                } else {
                    self.callback(with: image, error: nil, url: url, originalData: data)
                }
                
            } else {
                // If server response is 304 (Not Modified), inform the callback handler with NotModified error.
                // It should be handled to get an image from cache, which is response of a manager object.
                if let res = task.response as? HTTPURLResponse , res.statusCode == 304 {
                    self.callback(with: nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.notModified.rawValue, userInfo: nil), url: url, originalData: nil)
                    return
                }
                
                self.callback(with: nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.badData.rawValue, userInfo: nil), url: url, originalData: nil)
            }
        }
    }

           let url = dataTask.originalRequest?.url,
            !(downloader.delegate ?? downloader).isValidStatusCode(statusCode, for: downloader)
        {
            let error = NSError(domain: KingfisherErrorDomain,
                                code: KingfisherError.invalidStatusCode.rawValue,
                                userInfo: [KingfisherErrorStatusCodeKey: statusCode, NSLocalizedDescriptionKey: HTTPURLResponse.localizedString(forStatusCode: statusCode)])
            callCompletionHandlerFailure(error: error, url: url)
        }
        
        completionHandler(.allow)
