      The manager holds a strong reference to the task until it is either completes or get cancelled.
      */
     public func taskWith(request: ImageRequest) -> ImageTask {
-        return ImageTaskInternal(manager: self, request: request, identifier: self.nextTaskIdentifier)
+        return ImageTaskInternal(manager: self, request: request, identifier: nextTaskIdentifier)
     }
     
     // MARK: FSM (ImageTaskState)
     
     private func setState(state: ImageTaskState, forTask task: ImageTaskInternal)  {
         if task.isValidNextState(state) {
-            self.transitionStateAction(task.state, toState: state, task: task)
+            transitionStateAction(task.state, toState: state, task: task)
             task.state = state
-            self.enterStateAction(state, task: task)
+            enterStateAction(state, task: task)
         }
     }
     
     private func transitionStateAction(fromState: ImageTaskState, toState: ImageTaskState, task: ImageTaskInternal) {
         if fromState == .Running && toState == .Suspended {
-            self.loader.suspendLoadingFor(task)
+            loader.suspendLoadingFor(task)
         }
     }
     

        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 {

    When you call this method, ImageManager starts to load and cache images for the given requests. ImageManager caches images with the exact target size, content mode, and filters. At any time afterward, you can create tasks with equivalent requests.
    */
    public func startPreheatingImages(requests: [ImageRequest]) {
        perform {
            for request in requests {
                let key = ImageRequestKey(request, owner: self)
                if preheatingTasks[key] == nil {
                    preheatingTasks[key] = ImageTaskInternal(manager: self, request: request, identifier: nextTaskIdentifier).completion { [weak self] _ in
                        self?.preheatingTasks[key] = nil
                    }
                }
            }
            setNeedsExecutePreheatingTasks()
        }
    }
    
    /** Stop preheating for the given requests. The request parameters should match the parameters used in startPreheatingImages method.
     */
    public func stopPreheatingImages(requests: [ImageRequest]) {
        perform {
            cancelTasks(requests.flatMap {
                return preheatingTasks[ImageRequestKey($0, owner: self)]
            })
        }
    }
