     public func getSince(since: Timestamp) -> Deferred<Maybe<StorageResponse<[Record<T>]>>> {
         let deferred = Deferred<Maybe<StorageResponse<[Record<T>]>>>(defaultQueue: client.resultQueue)
 
+        // Fills the Deferred for us.
         if self.client.checkBackoff(deferred) {
             return deferred
         }

             * Returns true if handled.
             */
            func failFromResponse(response: NSHTTPURLResponse?) -> Bool {
                // TODO: Swift 2.0 guards.
                if response == nil {
                    // TODO: better error.
                    log.error("No response")
                    let result = Maybe<T>(failure: RecordParseError())


        req.responsePartialParsedJSON(queue: collectionQueue, completionHandler: self.client.errorWrap(deferred) { (_, response, result) in

            log.debug("Response is \(response).")
            guard let json: JSON = result.value as? JSON else {
                log.warning("Non-JSON response.")
                deferred.fill(Maybe(failure: RecordParseError()))
                return
            }

            guard let arr = json.asArray else {
                log.warning("Non-array response.")
                deferred.fill(Maybe(failure: RecordParseError()))
                return
            }

            func recordify(json: JSON) -> Record<T>? {
                let envelope = EnvelopeJSON(json)
                return Record<T>.fromEnvelope(envelope, payloadFactory: self.encrypter.factory)
            }

            let records = optFilter(arr.map(recordify))
            let response = StorageResponse(value: records, response: response!)
            deferred.fill(Maybe(success: response))
        })

        return deferred
