Fix memory leaks

Basically, the operations were retained by the completion blocks.

They are now unowned, but to ensure that, I had to redesign a few things:

- Operations are systematically enqueued to ensure that they are retained for their lifetime. I had to create dedicated queues for that.

- The operation knows on which queue to dispatch the completion handler. This saves one level of indirection, thus avoiding a few references and above all ensuring consistency. The queue is most of the time the main queue, except for the offline sync.

- Ensure that `finish()` is always called for every code path. (Otherwise the operation is never dequeued.)

Author: Clément Le Provost

Source/Client.swift

@@ -136,6 +136,15 @@ public let ErrorDomain = "AlgoliaSearch"
     // NOTE: Not constant only for the sake of mocking during unit tests.
     var session: URLSession
 
+    /// Operation queue used to keep track of requests.
+    /// `Request` instances are inherently asynchronous, since they are merely wrappers around `NSURLSessionTask`.
+    /// The sole purpose of the queue is to retain them for the duration of their execution!
+    ///
+    let requestQueue: NSOperationQueue
+    
+    /// Dispatch queue used to run completion handlers.
+    private var completionQueue = dispatch_get_main_queue()
+    
     // MARK: Initialization
 
     /// Create a new Algolia Search client.
@@ -172,6 +181,9 @@ public let ErrorDomain = "AlgoliaSearch"
         configuration.HTTPAdditionalHeaders = fixedHTTPHeaders
         session = NSURLSession(configuration: configuration)
 
+        requestQueue = NSOperationQueue()
+        requestQueue.maxConcurrentOperationCount = 8
+        
         super.init()
 
         // Add this library's version to the user agents.
@@ -376,18 +388,9 @@ public let ErrorDomain = "AlgoliaSearch"
     /// Perform an HTTP Query.
     func performHTTPQuery(path: String, method: HTTPMethod, body: [String: AnyObject]?, hostnames: [String], isSearchQuery: Bool = false, completionHandler: CompletionHandler? = nil) -> NSOperation {
         var request: Request!
-        request = newRequest(method, path: path, body: body, hostnames: hostnames, isSearchQuery: isSearchQuery) {
-            (content: [String: AnyObject]?, error: NSError?) -> Void in
-            if completionHandler != nil {
-                dispatch_async(dispatch_get_main_queue()) {
-                    // WARNING: Because of the asynchronous dispatch, the request could have been cancelled in the meantime.
-                    if !request.cancelled {
-                        completionHandler!(content: content, error: error)
-                    }
-                }
-            }
-        }
-        request.start()
+        request = newRequest(method, path: path, body: body, hostnames: hostnames, isSearchQuery: isSearchQuery, completion: completionHandler)
+        request.completionQueue = self.completionQueue
+        requestQueue.addOperation(request)
         return request
     }
 

Source/Offline/MirroredIndex.swift

@@ -513,8 +513,13 @@ import Foundation
             if index.requestStrategy == .FallbackOnTimeout && mayRunOfflineRequest {
                 // Schedule an offline request to start after a certain delay.
                 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(index.offlineFallbackTimeout * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
-                    if self.mayRunOfflineRequest {
-                        self.startOffline()
+                    [weak self] in
+                    // WARNING: Because dispatched blocks cannot be cancelled, and to avoid increasing the lifetime of
+                    // the operation by the timeout delay, we do not retain self. => Gracefully fail if the operation
+                    // has already finished.
+                    guard let this = self else { return }
+                    if this.mayRunOfflineRequest {
+                        this.startOffline()
                     }
                 }
             }
@@ -526,6 +531,7 @@ import Foundation
                 return
             }
             onlineRequest = startOnlineRequest({
+                [unowned self] // works because the operation is enqueued and retained by the queue
                 (content, error) in
                 // In case of transient error, run an offline request.
                 if error != nil && error!.isTransient() && self.mayRunOfflineRequest {
@@ -547,6 +553,7 @@ import Foundation
                 return
             }
             offlineRequest = startOfflineRequest({
+                [unowned self] // works because the operation is enqueued and retained by the queue
                 (content, error) in
                 self.onlineRequest?.cancel()
                 self.callCompletion(content, error: error)
@@ -600,8 +607,7 @@ import Foundation
         else {
             let queryCopy = Query(copy: query)
             let operation = OnlineOfflineSearchOperation(index: self, query: queryCopy, completionHandler: completionHandler)
-            // NOTE: This operation is just an aggregate, so it does not need to be enqueued.
-            operation.start()
+            offlineClient.mixedRequestQueue.addOperation(operation)
             return operation
         }
     }
@@ -693,7 +699,7 @@ import Foundation
         // A mirrored index launches a mixed offline/online request.
         else {
             let operation = OnlineOfflineMultipleQueriesOperation(index: self, queries: queries, completionHandler: completionHandler)
-            operation.start()
+            offlineClient.mixedRequestQueue.addOperation(operation)
             return operation
         }
     }

Source/Offline/OfflineClient.swift

@@ -43,8 +43,10 @@ import Foundation
         buildQueue.maxConcurrentOperationCount = 1
         searchQueue.name = "AlgoliaSearch-Search"
         searchQueue.maxConcurrentOperationCount = 1
+        mixedRequestQueue.name = "AlgoliaSearch-Mixed"
         rootDataDir = NSSearchPathForDirectoriesInDomains(.ApplicationSupportDirectory, .UserDomainMask, true).first! + "/algolia"
         super.init(appID: appID, apiKey: apiKey)
+        mixedRequestQueue.maxConcurrentOperationCount = super.requestQueue.maxConcurrentOperationCount
         userAgents.append(LibraryVersion(name: "AlgoliaSearchOfflineCore-iOS", version: sdk.versionString))
     }
 
@@ -69,6 +71,13 @@ import Foundation
 
     /// Queue used to search local indices in the background.
     let searchQueue = NSOperationQueue()
+    
+    /// Queue for mixed online/offline operations.
+    ///
+    /// + Note: We could use `Client.requestQueue`, but since mixed operations are essentially aggregations of
+    ///   individual operations, we wish to avoid deadlocks.
+    ///
+    let mixedRequestQueue = NSOperationQueue()
 
     /// Enable the offline mode.
     ///

Source/Request.swift

@@ -65,6 +65,9 @@ class Request: AsyncOperation {
     /// User completion block to be called.
     let completion: CompletionHandler?
 
+    /// Dispatch queue used to execute the completion handler.
+    var completionQueue: dispatch_queue_t?
+    
     // MARK: - Initialization
 
     init(session: URLSession, method: HTTPMethod, hosts: [String], firstHostIndex: Int, path: String, headers: [String: String]?, jsonBody: [String: AnyObject]?, timeout: NSTimeInterval, completion: CompletionHandler?) {
@@ -193,10 +196,27 @@ class Request: AsyncOperation {
     /// Finish this operation.
     /// This method should be called exactly once per operation.
     private func callCompletion(content: [String: AnyObject]?, error: NSError?) {
-        if completion != nil && !_cancelled {
-            completion!(content: content, error: error)
+        if _cancelled {
+            return
+        }
+        if let completionQueue = completionQueue {
+            dispatch_async(completionQueue) {
+                self._callCompletion(content, error: error)
+            }
+        } else {
+            _callCompletion(content, error: error)
+        }
+    }
+    
+    private func _callCompletion(content: [String: AnyObject]?, error: NSError?) {
+        // WARNING: In case of asynchronous dispatch, the request could have been cancelled in the meantime
+        // => check again.
+        if !_cancelled {
+            if let completion = completion {
+                completion(content: content, error: error)
+            }
+            finish()
         }
-        finish()
     }
 
     // ----------------------------------------------------------------------