Parity: URLCache adoption for HTTP and FTP invocations.

 - Store and provide the storage date for cached responses, for internal use only.

 - Implement protocol properties.

 - URLSessionConfiguration now configures the shared and ephemeral sessions with caches of appropriate size and storage setup. Each ephemeral session has a new in-memory-only cache, and the shared session used the shared URLCache.

 - The URLProtocolClient that drives URLSession tasks now asks its delegate for caching, and if a cacheable response is determined, uses the URLSession’s cache to store it. It will also fetch from the cache if appropriate, and will initialize the protocol with that response.

 - Add hooks to _NativeProtocol to affect whether the transfer can be satisfied by the cached response it was initialized with. If it can, the response will be replayed instead.

 - _HTTPURLProtocol implements those hooks to make the URLCache behave as a RFC 7234 private cache.

Note that _FTPURLProtocol uses the default implementation of those hooks, which will cause related responses to be evicted from the cache and no response to be fulfilled from the cache. This is intentional.

Author: millenomi

Foundation/NSURLRequest.swift

@@ -564,6 +564,9 @@ open class NSMutableURLRequest : NSURLRequest {
         get { return super.httpShouldUsePipelining }
         set { super.httpShouldUsePipelining = newValue }
     }
+    
+    // These properties are settable using URLProtocol's class methods.
+    var protocolProperties: [String: Any] = [:]
 }
 
 /// Returns an existing key-value pair inside the header fields if it exists.

Foundation/URLCache.swift

@@ -55,18 +55,21 @@ class StoredCachedURLResponse: NSObject, NSSecureCoding {
         aCoder.encode(cachedURLResponse.data as NSData, forKey: "data")
         aCoder.encode(cachedURLResponse.storagePolicy.rawValue, forKey: "storagePolicy")
         aCoder.encode(cachedURLResponse.userInfo as NSDictionary?, forKey: "userInfo")
+        aCoder.encode(cachedURLResponse.date as NSDate, forKey: "date")
     }
 
     required init?(coder aDecoder: NSCoder) {
         guard let response = aDecoder.decodeObject(of: URLResponse.self, forKey: "response"),
               let data = aDecoder.decodeObject(of: NSData.self, forKey: "data"),
-            let storagePolicy = URLCache.StoragePolicy(rawValue: UInt(aDecoder.decodeInt64(forKey: "storagePolicy"))) else {
+              let storagePolicy = URLCache.StoragePolicy(rawValue: UInt(aDecoder.decodeInt64(forKey: "storagePolicy"))),
+              let date = aDecoder.decodeObject(of: NSDate.self, forKey: "date") else {
                 return nil
         }
 
         let userInfo = aDecoder.decodeObject(of: NSDictionary.self, forKey: "userInfo") as? [AnyHashable: Any]
 
         cachedURLResponse = CachedURLResponse(response: response, data: data as Data, userInfo: userInfo, storagePolicy: storagePolicy)
+        cachedURLResponse.date = date as Date
     }
 
     let cachedURLResponse: CachedURLResponse
@@ -178,6 +181,8 @@ open class CachedURLResponse : NSObject, NSCopying {
                 self.data == other.data &&
                 self.storagePolicy == other.storagePolicy
     }
+    
+    internal fileprivate(set) var date: Date = Date()
 
     open override var hash: Int {
         var hasher = Hasher()
@@ -212,12 +217,14 @@ open class URLCache : NSObject {
     */
     open class var shared: URLCache {
         get {
-            sharedLock.lock(); defer { sharedLock.unlock() }
-            return _shared
+            return sharedLock.performLocked {
+                return _shared
+            }
         }
         set {
-            sharedLock.lock(); defer { sharedLock.unlock() }
-            _shared = newValue
+            sharedLock.performLocked {
+                _shared = newValue
+            }
         }
     }
 
@@ -348,8 +355,22 @@ open class URLCache : NSObject {
     }
 
     private func identifier(for request: URLRequest) -> String? {
-        guard let url = request.url?.absoluteString else { return nil }
-        return Data(url.utf8).base64EncodedString()
+        guard let url = request.url else { return nil }
+        
+        if let host = url.host {
+            var data = Data()
+            data.append(Data(host.lowercased(with: NSLocale.system).utf8))
+            data.append(0)
+            let port = url.port ?? -1
+            data.append(Data("\(port)".utf8))
+            data.append(0)
+            data.append(Data(url.path.utf8))
+            data.append(0)
+        
+            return data.base64EncodedString()
+        } else {
+            return nil
+        }
     }
 
     private struct DiskEntry {

Foundation/URLProtocol.swift

@@ -148,7 +148,11 @@ public protocol URLProtocolClient : NSObjectProtocol {
     func urlProtocol(_ protocol: URLProtocol, didCancel challenge: URLAuthenticationChallenge)
 }
 
-internal class _ProtocolClient : NSObject { }
+internal class _ProtocolClient : NSObject {
+    var cachePolicy: URLCache.StoragePolicy = .notAllowed
+    var cacheableData: [Data]?
+    var cacheableResponse: URLResponse?
+}
 
 /*!
     @class NSURLProtocol
@@ -308,7 +312,9 @@ open class URLProtocol : NSObject {
         @result The property stored with the given key, or nil if no property
         had previously been stored with the given key in the given request.
     */
-    open class func property(forKey key: String, in request: URLRequest) -> Any? { NSUnimplemented() }
+    open class func property(forKey key: String, in request: URLRequest) -> Any? {
+        return request.protocolProperties[key]
+    }
 
     /*! 
         @method setProperty:forKey:inRequest:
@@ -321,7 +327,9 @@ open class URLProtocol : NSObject {
         @param key The string to use for the property storage. 
         @param request The request in which to store the property. 
     */
-    open class func setProperty(_ value: Any, forKey key: String, in request: NSMutableURLRequest) { NSUnimplemented() }
+    open class func setProperty(_ value: Any, forKey key: String, in request: NSMutableURLRequest) {
+        request.protocolProperties[key] = value
+    }
 
     /*!
         @method removePropertyForKey:inRequest:
@@ -332,7 +340,9 @@ open class URLProtocol : NSObject {
         @param key The key whose value should be removed
         @param request The request to be modified
     */
-    open class func removeProperty(forKey key: String, in request: NSMutableURLRequest) { NSUnimplemented() }
+    open class func removeProperty(forKey key: String, in request: NSMutableURLRequest) {
+        request.protocolProperties.removeValue(forKey: key)
+    }
 
     /*! 
         @method registerClass:
@@ -408,7 +418,10 @@ open class URLProtocol : NSObject {
         _classesLock.unlock()
     }
 
-    open class func canInit(with task: URLSessionTask) -> Bool { NSUnimplemented() }
+    open class func canInit(with task: URLSessionTask) -> Bool {
+        guard let request = task.currentRequest else { return false }
+        return canInit(with: request)
+    }
     public required convenience init(task: URLSessionTask, cachedResponse: CachedURLResponse?, client: URLProtocolClient?) {
         let urlRequest = task.originalRequest
         self.init(request: urlRequest!, cachedResponse: cachedResponse, client: client)

Foundation/URLRequest.swift

@@ -240,6 +240,15 @@ public struct URLRequest : ReferenceConvertible, Equatable, Hashable {
     public static func ==(lhs: URLRequest, rhs: URLRequest) -> Bool {
         return lhs._handle._uncopiedReference().isEqual(rhs._handle._uncopiedReference())
     }
+    
+    var protocolProperties: [String: Any] {
+        get {
+            return _handle.map { $0.protocolProperties }
+        }
+        set {
+            _applyMutation { $0.protocolProperties = newValue }
+        }
+    }
 }
 
 extension URLRequest : CustomStringConvertible, CustomDebugStringConvertible, CustomReflectable {

Foundation/URLSession/NativeProtocol.swift

@@ -382,13 +382,44 @@ internal class _NativeProtocol: URLProtocol, _EasyHandleDelegate {
             guard let r = task?.originalRequest else {
                 fatalError("Task has no original request.")
             }
-            startNewTransfer(with: r)
+            
+            // Check if the cached response is good to use:
+            if let cachedResponse = cachedResponse, canRespondFromCache(using: cachedResponse) {
+                self.internalState = .fulfillingFromCache(cachedResponse)
+                task?.workQueue.async {
+                    self.client?.urlProtocol(self, cachedResponseIsValid: cachedResponse)
+                    self.client?.urlProtocol(self, didReceive: cachedResponse.response, cacheStoragePolicy: .notAllowed)
+                    if !cachedResponse.data.isEmpty {
+                        self.client?.urlProtocol(self, didLoad: cachedResponse.data)
+                    }
+                    
+                    self.client?.urlProtocolDidFinishLoading(self)
+                    
+                    self.internalState = .taskCompleted
+                }
+                
+            } else {
+                startNewTransfer(with: r)
+            }
         }
 
         if case .transferReady(let transferState) = self.internalState {
             self.internalState = .transferInProgress(transferState)
         }
     }
+    
+    func canCache(_ response: CachedURLResponse) -> Bool {
+        return false
+    }
+    
+    /// Allows a native protocol to process a cached response. If `true` is returned, the protocol will replay the cached response instead of starting a new transfer. The default implementation invalidates the response in the cache and returns `false`.
+    func canRespondFromCache(using response: CachedURLResponse) -> Bool {
+        // By default, native protocols do not cache. Aggressively remove unexpected cached responses.
+        if let cache = task?.session.configuration.urlCache, let task = task as? URLSessionDataTask {
+            cache.removeCachedResponse(for: task)
+        }
+        return false
+    }
 
     func suspend() {
         if case .transferInProgress(let transferState) =  self.internalState {
@@ -492,6 +523,8 @@ extension _NativeProtocol {
     enum _InternalState {
         /// Task has been created, but nothing has been done, yet
         case initial
+        /// The task is being fulfilled from the cache rather than the network.
+        case fulfillingFromCache(CachedURLResponse)
         /// The easy handle has been fully configured. But it is not added to
         /// the multi handle.
         case transferReady(_TransferState)
@@ -531,6 +564,7 @@ extension _NativeProtocol._InternalState {
     var isEasyHandleAddedToMultiHandle: Bool {
         switch self {
         case .initial:                             return false
+        case .fulfillingFromCache:                 return false
         case .transferReady:                       return false
         case .transferInProgress:                  return true
         case .transferCompleted:                   return false
@@ -544,6 +578,7 @@ extension _NativeProtocol._InternalState {
     var isEasyHandlePaused: Bool {
         switch self {
         case .initial:                             return false
+        case .fulfillingFromCache:                 return false
         case .transferReady:                       return false
         case .transferInProgress:                  return false
         case .transferCompleted:                   return false

Foundation/URLSession/URLSession.swift

@@ -629,6 +629,8 @@ internal protocol URLSessionProtocol: class {
     func add(handle: _EasyHandle)
     func remove(handle: _EasyHandle)
     func behaviour(for: URLSessionTask) -> URLSession._TaskBehaviour
+    var configuration: URLSessionConfiguration { get }
+    var delegate: URLSessionDelegate? { get }
 }
 extension URLSession: URLSessionProtocol {
     func add(handle: _EasyHandle) {
@@ -642,6 +644,12 @@ extension URLSession: URLSessionProtocol {
 ///
 /// - SeeAlso: URLSessionTask.init()
 final internal class _MissingURLSession: URLSessionProtocol {
+    var delegate: URLSessionDelegate? {
+        fatalError()
+    }
+    var configuration: URLSessionConfiguration {
+        fatalError()
+    }
     func add(handle: _EasyHandle) {
         fatalError()
     }

Foundation/URLSession/URLSessionConfiguration.swift

@@ -39,21 +39,21 @@ open class URLSessionConfiguration : NSObject, NSCopying {
     // -init is silently incorrect in URLSessionCofiguration on the desktop. Ensure code that relied on swift-corelibs-foundation's init() being functional is redirected to the appropriate cross-platform class property.
     @available(*, deprecated, message: "Use .default instead.", renamed: "URLSessionConfiguration.default")
     public override init() {
-        self.requestCachePolicy = .useProtocolCachePolicy
-        self.timeoutIntervalForRequest = 60
-        self.timeoutIntervalForResource = 604800
-        self.networkServiceType = .default
-        self.allowsCellularAccess = true
-        self.isDiscretionary = false
-        self.httpShouldUsePipelining = false
-        self.httpShouldSetCookies = true
-        self.httpCookieAcceptPolicy = .onlyFromMainDocumentDomain
-        self.httpMaximumConnectionsPerHost = 6
-        self.httpCookieStorage = HTTPCookieStorage.shared
-        self.urlCredentialStorage = nil
-        self.urlCache = nil
-        self.shouldUseExtendedBackgroundIdleMode = false
-        self.protocolClasses = [_HTTPURLProtocol.self, _FTPURLProtocol.self]
+        self.requestCachePolicy = URLSessionConfiguration.default.requestCachePolicy
+        self.timeoutIntervalForRequest = URLSessionConfiguration.default.timeoutIntervalForRequest
+        self.timeoutIntervalForResource = URLSessionConfiguration.default.timeoutIntervalForResource
+        self.networkServiceType = URLSessionConfiguration.default.networkServiceType
+        self.allowsCellularAccess = URLSessionConfiguration.default.allowsCellularAccess
+        self.isDiscretionary = URLSessionConfiguration.default.isDiscretionary
+        self.httpShouldUsePipelining = URLSessionConfiguration.default.httpShouldUsePipelining
+        self.httpShouldSetCookies = URLSessionConfiguration.default.httpShouldSetCookies
+        self.httpCookieAcceptPolicy = URLSessionConfiguration.default.httpCookieAcceptPolicy
+        self.httpMaximumConnectionsPerHost = URLSessionConfiguration.default.httpMaximumConnectionsPerHost
+        self.httpCookieStorage = URLSessionConfiguration.default.httpCookieStorage
+        self.urlCredentialStorage = URLSessionConfiguration.default.urlCredentialStorage
+        self.urlCache = URLSessionConfiguration.default.urlCache
+        self.shouldUseExtendedBackgroundIdleMode = URLSessionConfiguration.default.shouldUseExtendedBackgroundIdleMode
+        self.protocolClasses = URLSessionConfiguration.default.protocolClasses
         super.init()
     }
 
@@ -73,7 +73,7 @@ open class URLSessionConfiguration : NSObject, NSCopying {
                   httpMaximumConnectionsPerHost: 6,
                   httpCookieStorage: .shared,
                   urlCredentialStorage: nil, // Should be .shared once implemented.
-                  urlCache: nil,
+                  urlCache: .shared,
                   shouldUseExtendedBackgroundIdleMode: false,
                   protocolClasses: [_HTTPURLProtocol.self, _FTPURLProtocol.self])
     }
@@ -149,10 +149,11 @@ open class URLSessionConfiguration : NSObject, NSCopying {
 
     open class var ephemeral: URLSessionConfiguration {
         // Return a new ephemeral URLSessionConfiguration every time this property is invoked
-        // TODO: urlCache and urlCredentialStorage should also be ephemeral/in-memory
-        // URLCache and URLCredentialStorage are still unimplemented
+        // TODO: urlCredentialStorage should also be ephemeral/in-memory
+        // URLCredentialStorage is still unimplemented
         let ephemeralConfiguration = URLSessionConfiguration.default.copy() as! URLSessionConfiguration
         ephemeralConfiguration.httpCookieStorage = .ephemeralStorage()
+        ephemeralConfiguration.urlCache = URLCache(memoryCapacity: 4 * 1024 * 1024, diskCapacity: 0, diskPath: nil)
         return ephemeralConfiguration
     }