         return Int(OSAtomicIncrement32(&taskIdentifier))
     }
     private var loader: ImageLoading {
-        return self.configuration.loader
+        return configuration.loader
     }
     private var cache: ImageMemoryCaching? {
-        return self.configuration.cache
+        return configuration.cache
     }
     
     // MARK: Configuring Manager

    // MARK: ImageManager: ImageTaskManaging
    
    private func resume(task: ImageTaskInternal) {
        self.perform { self.setState(.Running, forTask: task) }
    }
    
    private func suspend(task: ImageTaskInternal) {
        self.perform { self.setState(.Suspended, forTask: task) }
    }
    
    private func cancel(task: ImageTaskInternal) {
        self.perform { self.setState(.Cancelled, forTask: task) }
    }
    
    private func addCompletion(completion: ImageTaskCompletion, forTask task: ImageTaskInternal) {
        self.perform {
            switch task.state {
            case .Completed, .Cancelled:
                dispathOnMainThread {

        case .Running:
            switch task.request.memoryCachePolicy {
            case .ReturnCachedImageElseLoad:
                if let response = responseForRequest(task.request) {
                    // FIXME: Should ImageResponse contain a `fastResponse` property?
                    task.response = ImageResponse.Success(response.image, ImageResponseInfo(fastResponse: true, userInfo: response.userInfo))
                    setState(.Completed, forTask: task)
                    return
                }
            default: break
            }
            executingTasks.insert(task)
            loader.resumeLoadingFor(task)
        case .Cancelled:
            loader.cancelLoadingFor(task)
            task.response = ImageResponse.Failure(errorWithCode(.Cancelled))
            fallthrough
        case .Completed:
            executingTasks.remove(task)
            setNeedsExecutePreheatingTasks()
            
            let completions = task.completions
            dispathOnMainThread {
