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

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

    }
    
    override func resume() -> Self {
        manager.resume(self)
        return self
    }
    
    override func suspend() -> Self {
        manager.suspend(self)
        return self
    }
    
    override func cancel() -> Self {
        manager.cancel(self)
        return self
    }
    
    override func completion(completion: ImageTaskCompletion) -> Self {
        manager.addCompletion(completion, forTask: self)
        return self
    }
    
