Implement URLSessionConfiguration.ephemeral

The difference between `default` and `ephemeral` `URLSessionConfiguration`s
is in the storage aspect. There are three kinds of stores related to a `URLSession`
 - a `URLCache`
 - a `URLCredentialStorage`
 - an `HTTPCookieStorage`

While the `default` configuration mandates persistent stores, the `ephemeral`
configuration mandates only in-memory, ephemeral stores. As of today, `URLCache`
and `URLCredentialStorage` are unimplemented and not configured in the `default`
configuration. `HTTPCookieStorage` is implemented and we use the `shared` storage
in the `default` configuration.

This commit includes:
 - an ephemeral `HTTPCookieStorage` that does not read from, and write to, a persistent
   store
 - an initial `URLSessionConfiguration.ephemeral` implementation which configures an
   ephmeral `HTTPCookieStorage`, but no `URLCache` and `URLCredentialStorage`

Author: Pushkar N Kulkarni

Foundation/HTTPCookieStorage.swift

@@ -42,7 +42,7 @@ open class HTTPCookieStorage: NSObject {
     private static let sharedSyncQ = DispatchQueue(label: "org.swift.HTTPCookieStorage.sharedSyncQ")
 
     /* only modified in init */
-    private var cookieFilePath: String!
+    private var cookieFilePath: String?
 
     /* synchronized on syncQ, please don't use _allCookies directly outside of init/deinit */
     private var _allCookies: [String: HTTPCookie]
@@ -62,22 +62,27 @@ open class HTTPCookieStorage: NSObject {
     }
     private let syncQ = DispatchQueue(label: "org.swift.HTTPCookieStorage.syncQ")
 
-    private init(cookieStorageName: String) {
+    private let isEphemeral: Bool
+
+    private init(cookieStorageName: String, isEphemeral: Bool = false) {
         _allCookies = [:]
         cookieAcceptPolicy = .always
+        self.isEphemeral = isEphemeral
         super.init()
-        let bundlePath = Bundle.main.bundlePath
-        var bundleName = bundlePath.components(separatedBy: "/").last!
-        if let range = bundleName.range(of: ".", options: .backwards, range: nil, locale: nil) {
-            bundleName = String(bundleName[..<range.lowerBound])
+        if !isEphemeral {
+            let bundlePath = Bundle.main.bundlePath
+            var bundleName = bundlePath.components(separatedBy: "/").last!
+            if let range = bundleName.range(of: ".", options: .backwards, range: nil, locale: nil) {
+                bundleName = String(bundleName[..<range.lowerBound])
+            }
+            let cookieFolderPath = _CFXDGCreateDataHomePath()._swiftObject + "/" + bundleName
+            cookieFilePath = filePath(path: cookieFolderPath, fileName: "/.cookies." + cookieStorageName, bundleName: bundleName)
+            loadPersistedCookies()
         }
-        let cookieFolderPath = _CFXDGCreateDataHomePath()._swiftObject + "/" + bundleName
-        cookieFilePath = filePath(path: cookieFolderPath, fileName: "/.cookies." + cookieStorageName, bundleName: bundleName)
-        loadPersistedCookies()
     }
 
     private func loadPersistedCookies() {
-        guard let cookiesData = try? Data(contentsOf: URL(fileURLWithPath: cookieFilePath)) else { return }
+        guard let cookieFilePath = self.cookieFilePath, let cookiesData = try? Data(contentsOf: URL(fileURLWithPath: cookieFilePath)) else { return }
         guard let cookies = try? PropertyListSerialization.propertyList(from: cookiesData, format: nil) else { return }
         var cookies0 = cookies as? [String: [String: Any]] ?? [:]
         self.syncQ.sync {
@@ -109,6 +114,12 @@ open class HTTPCookieStorage: NSObject {
         return FileManager.default.currentDirectoryPath + "/" + bundleName + fileName
     }
 
+    // `URLSessionConfiguration.ephemeral` needs an ephemeral cookie storage.
+    // Ephemeral cookie storage is an in-memory store and does not load from, and store to, a persistent store.
+    internal class func ephemeralStorage() -> HTTPCookieStorage {
+        return HTTPCookieStorage(cookieStorageName: "Ephemeral", isEphemeral: true)
+    }
+
     open var cookies: [HTTPCookie]? {
         return Array(self.syncQ.sync { self.allCookies.values })
     }
@@ -130,7 +141,7 @@ open class HTTPCookieStorage: NSObject {
             }
         }
     }
-    
+
     /*!
         @method sharedCookieStorageForGroupContainerIdentifier:
         @abstract Get the cookie storage for the container associated with the specified application group identifier
@@ -183,7 +194,7 @@ open class HTTPCookieStorage: NSObject {
     }
 
     open override var description: String {
-        return "<NSHTTPCookieStorage cookies count:\(cookies?.count ?? 0)>"
+        return "\(self.isEphemeral ? "Ephemeral" : "")<NSHTTPCookieStorage cookies count:\(cookies?.count ?? 0)>"
     }
 
     private func createCookie(_ properties: [String: Any]) -> HTTPCookie? {
@@ -200,6 +211,11 @@ open class HTTPCookieStorage: NSObject {
     }
 
     private func updatePersistentStore() {
+        // No persistence if this is an ephemeral storage
+        if self.isEphemeral { return }
+
+        guard let cookieFilePath = self.cookieFilePath else { return }
+
         if #available(macOS 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *) {
             dispatchPrecondition(condition: DispatchPredicate.onQueue(self.syncQ))
         }

Foundation/URLSession/URLSessionConfiguration.swift

@@ -119,7 +119,15 @@ open class URLSessionConfiguration : NSObject, NSCopying {
     open class var `default`: URLSessionConfiguration {
         return URLSessionConfiguration()
     }
-    open class var ephemeral: URLSessionConfiguration { NSUnimplemented() }
+
+    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
+        let ephemeralConfiguration = URLSessionConfiguration()
+        ephemeralConfiguration.httpCookieStorage = HTTPCookieStorage.ephemeralStorage()
+        return ephemeralConfiguration
+    }
 
     open class func background(withIdentifier identifier: String) -> URLSessionConfiguration { NSUnimplemented() }
 

TestFoundation/TestURLSession.swift

@@ -43,6 +43,7 @@ class TestURLSession : LoopbackServerTest {
             ("test_concurrentRequests", test_concurrentRequests),
             ("test_disableCookiesStorage", test_disableCookiesStorage),
             ("test_cookiesStorage", test_cookiesStorage),
+            ("test_cookieStorageForEphmeralConfiguration", test_cookieStorageForEphmeralConfiguration),
             ("test_setCookies", test_setCookies),
             ("test_dontSetCookies", test_dontSetCookies),
             ("test_initURLSessionConfiguration", test_initURLSessionConfiguration),
@@ -707,6 +708,29 @@ class TestURLSession : LoopbackServerTest {
         waitForExpectations(timeout: 30)
     }
 
+    func test_cookieStorageForEphmeralConfiguration() {
+        let config = URLSessionConfiguration.ephemeral
+        config.timeoutIntervalForRequest = 5
+        let urlString = "http://127.0.0.1:\(TestURLSession.serverPort)/requestCookies"
+        let session = URLSession(configuration: config, delegate: nil, delegateQueue: nil)
+        var expect = expectation(description: "POST \(urlString)")
+        var req = URLRequest(url: URL(string: urlString)!)
+        req.httpMethod = "POST"
+        var task = session.dataTask(with: req) { (data, _, error) -> Void in
+            defer { expect.fulfill() }
+            XCTAssertNotNil(data)
+            XCTAssertNil(error as? URLError, "error = \(error as! URLError)")
+        }
+        task.resume()
+        waitForExpectations(timeout: 30)
+        let cookies = config.httpCookieStorage?.cookies
+        XCTAssertEqual(cookies?.count, 1)
+
+        let config2 = URLSessionConfiguration.ephemeral
+        let cookies2 = config2.httpCookieStorage?.cookies
+        XCTAssertEqual(cookies2?.count, 0)
+    }
+
     func test_dontSetCookies() {
         let config = URLSessionConfiguration.default
         config.timeoutIntervalForRequest = 5