 // MARK: - ImageLoader
 
 /**
-Performs the actual loading of images for the image tasks using objects conforming to `ImageDataLoading`, `ImageDecoding` and `ImageProcessing` protocols. Works in conjunction with the `ImageManager`.
+Performs loading of images for the image tasks using objects conforming to `ImageDataLoading`, `ImageDecoding` and `ImageProcessing` protocols. Works in conjunction with the `ImageManager`.
 
 - Provides a transparent loading, decoding and processing with a single completion signal
-- Reuses data tasks for multiple equivalent image tasks
-- Offloads work to the background queue
+- Reuses data tasks for equivalent image tasks
 */
 public class ImageLoader: ImageLoading {
     public weak var manager: ImageLoadingManager?
     public let configuration: ImageLoaderConfiguration
+    
+    /** Delegate that the receiver was initialized with. Image loader holds a strong reference to its delegate!
+     */
     public let delegate: ImageLoaderDelegate
-
+    
     private var dataLoader: ImageDataLoading {
         return self.configuration.dataLoader
     }
     private var executingTasks = [ImageTask : ImageLoadState]()
     private var sessionTasks = [ImageRequestKey : ImageSessionTask]()
     private let queue = dispatch_queue_create("ImageLoader.SerialQueue", DISPATCH_QUEUE_SERIAL)
-
+    
     /**
      Initializes image loader with a configuration and a delegate.
-
-     - parameter delegate: Instance of `ImageLoaderDefaultDelegate` created if the parameter is omitted.
+     
+     - parameter delegate: Instance of `ImageLoaderDefaultDelegate` created if the parameter is omitted. Image loader holds a strong reference to its delegate!
      */
     public init(configuration: ImageLoaderConfiguration, delegate: ImageLoaderDelegate = ImageLoaderDefaultDelegate()) {
         self.configuration = configuration
         self.delegate = delegate
     }
-
+    
     public func resumeLoadingFor(task: ImageTask) {
         dispatch_async(self.queue) {
             let key = ImageRequestKey(task.request, owner: self)

            return ImageDecompressor(targetSize: request.targetSize, contentMode: request.contentMode)
        #endif
    }

    private func isEquivalent(lhs: ImageProcessing?, rhs: ImageProcessing?) -> Bool {
        switch (lhs, rhs) {
        case let (l?, r?): return l.isEquivalent(r)

            }
        }
    }
    
    public func cancelLoadingFor(task: ImageTask) {
        dispatch_async(self.queue) {
            if let state = self.executingTasks[task] {
                switch state {
                case .Loading(let sessionTask):
                    if sessionTask.cancel(task) {
                        self.remove(sessionTask)
                    }
                case .Processing(let operation):
                    operation.cancel()
