Use Swift2 defer.

Author: inamiy

SwiftTask/_StateMachine.swift

@@ -46,62 +46,64 @@ internal class _StateMachine<Progress, Value, Error>
     internal func addProgressTupleHandler(inout token: _HandlerToken?, _ progressTupleHandler: ProgressTupleHandler) -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         if self.state.rawValue == .Running || self.state.rawValue == .Paused {
             token = self._progressTupleHandlers.append(progressTupleHandler)
-            self._lock.unlock()
             return token != nil
         }
         else {
-            self._lock.unlock()
             return false
         }
     }
 
     internal func removeProgressTupleHandler(handlerToken: _HandlerToken?) -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         if let handlerToken = handlerToken {
             let removedHandler = self._progressTupleHandlers.remove(handlerToken)
-            self._lock.unlock()
             return removedHandler != nil
         }
         else {
-            self._lock.unlock()
             return false
         }
     }
 
     internal func addCompletionHandler(inout token: _HandlerToken?, _ completionHandler: Void -> Void) -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         if self.state.rawValue == .Running || self.state.rawValue == .Paused {
             token = self._completionHandlers.append(completionHandler)
-            self._lock.unlock()
             return token != nil
         }
         else {
-            self._lock.unlock()
             return false
         }
     }
 
     internal func removeCompletionHandler(handlerToken: _HandlerToken?) -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         if let handlerToken = handlerToken {
             let removedHandler = self._completionHandlers.remove(handlerToken)
-            self._lock.unlock()
             return removedHandler != nil
         }
         else {
-            self._lock.unlock()
             return false
         }
     }
 
     internal func handleProgress(progress: Progress)
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         if self.state.rawValue == .Running {
 
             let oldProgress = self.progress.rawValue
@@ -114,60 +116,53 @@ internal class _StateMachine<Progress, Value, Error>
             for handler in self._progressTupleHandlers {
                 handler(oldProgress: oldProgress, newProgress: progress)
             }
-            self._lock.unlock()
-        }
-        else {
-            self._lock.unlock()
         }
     }
 
     internal func handleFulfill(value: Value)
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         let (_, updated) = self.state.tryUpdate { $0 == .Running ? (.Fulfilled, true) : ($0, false) }
         if updated {
             self.value.rawValue = value
             self._finish()
-            self._lock.unlock()
-        }
-        else {
-            self._lock.unlock()
         }
     }
 
     internal func handleRejectInfo(errorInfo: ErrorInfo)
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         let toState = errorInfo.isCancelled ? TaskState.Cancelled : .Rejected
         let (_, updated) = self.state.tryUpdate { $0 == .Running || $0 == .Paused ? (toState, true) : ($0, false) }
         if updated {
             self.errorInfo.rawValue = errorInfo
             self._finish()
-            self._lock.unlock()
-        }
-        else {
-            self._lock.unlock()
         }
     }
 
     internal func handlePause() -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         let (_, updated) = self.state.tryUpdate { $0 == .Running ? (.Paused, true) : ($0, false) }
         if updated {
             self.configuration.pause?()
-            self._lock.unlock()
             return true
         }
         else {
-            self._lock.unlock()
             return false
         }
     }
 
     internal func handleResume() -> Bool
     {
         self._lock.lock()
+        
         if let initResumeClosure = self.initResumeClosure.update({ _ in nil }) {
 
             self.state.rawValue = .Running
@@ -211,15 +206,15 @@ internal class _StateMachine<Progress, Value, Error>
     internal func handleCancel(error: Error? = nil) -> Bool
     {
         self._lock.lock()
+        defer { self._lock.unlock() }
+        
         let (_, updated) = self.state.tryUpdate { $0 == .Running || $0 == .Paused ? (.Cancelled, true) : ($0, false) }
         if updated {
             self.errorInfo.rawValue = ErrorInfo(error: error, isCancelled: true)
             self._finish()
-            self._lock.unlock()
             return true
         }
         else {
-            self._lock.unlock()
             return false
         }
     }