Updating PR 299 (NSURLSession) to work with the latest Foundation (#426)

Also includes support for downloadTask and uploadTask with Data and a completion handler.
The original PR 299 doesn't build on Ubuntu 14.04, due to an older level of libcurl. This
rework removes some of that code (it does not affect any functionality). Updated to use the
Dispatch 3.0 API. Includes basic tests with external URLs.

Author: Pushkar N Kulkarni

CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h

@@ -23,6 +23,7 @@
 #include <CoreFoundation/CFXMLInterface.h>
 #include <CoreFoundation/CFRegularExpression.h>
 #include <CoreFoundation/CFLogUtilities.h>
+#include <CoreFoundation/CFURLSessionInterface.h>
 #include <CoreFoundation/ForFoundationOnly.h>
 #include <fts.h>
 #include <pthread.h>

CoreFoundation/URL.subproj/CFURLSessionInterface.c

@@ -164,11 +164,11 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         if url.isFileURL {
             try self.init(contentsOfFile: url.path, options: readOptionsMask)
         } else {
-            let session = URLSession(configuration: URLSessionConfiguration.defaultSessionConfiguration())
+            let session = URLSession(configuration: URLSessionConfiguration.default)
             let cond = NSCondition()
             var resError: NSError?
             var resData: Data?
-            let task = session.dataTaskWithURL(url, completionHandler: { (data: Data?, response: URLResponse?, error: NSError?) -> Void in
+            let task = session.dataTask(with: url, completionHandler: { (data: Data?, response: URLResponse?, error: NSError?) -> Void in
                 resData = data
                 resError = error
                 cond.broadcast()

CoreFoundation/URL.subproj/CFURLSessionInterface.h

@@ -0,0 +1,137 @@
+// Foundation/NSURLSession/Configuration.swift - NSURLSession & libcurl
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+// -----------------------------------------------------------------------------
+///
+/// These are libcurl helpers for the URLSession API code.
+/// - SeeAlso: https://curl.haxx.se/libcurl/c/
+/// - SeeAlso: NSURLSession.swift
+///
+// -----------------------------------------------------------------------------
+
+
+internal extension URLSession {
+    /// This is an immutable / `struct` version of `URLSessionConfiguration`.
+    struct _Configuration {
+        /// identifier for the background session configuration
+        let identifier: String?
+        
+        /// default cache policy for requests
+        let requestCachePolicy: NSURLRequest.CachePolicy
+        
+        /// default timeout for requests.  This will cause a timeout if no data is transmitted for the given timeout value, and is reset whenever data is transmitted.
+        let timeoutIntervalForRequest: TimeInterval
+        
+        /// default timeout for requests.  This will cause a timeout if a resource is not able to be retrieved within a given timeout.
+        let timeoutIntervalForResource: TimeInterval
+        
+        /// type of service for requests.
+        let networkServiceType: NSURLRequest.NetworkServiceType
+        
+        /// allow request to route over cellular.
+        let allowsCellularAccess: Bool
+        
+        /// allows background tasks to be scheduled at the discretion of the system for optimal performance.
+        let discretionary: Bool
+        
+        /// The proxy dictionary, as described by <CFNetwork/CFHTTPStream.h>
+        let connectionProxyDictionary: [AnyHashable : Any]?
+        
+        /// Allow the use of HTTP pipelining
+        let httpShouldUsePipelining: Bool
+        
+        /// Allow the session to set cookies on requests
+        let httpShouldSetCookies: Bool
+        
+        /// Policy for accepting cookies.  This overrides the policy otherwise specified by the cookie storage.
+        let httpCookieAcceptPolicy: HTTPCookie.AcceptPolicy
+        
+        /// Specifies additional headers which will be set on outgoing requests.
+        /// Note that these headers are added to the request only if not already present.
+        
+        let httpAdditionalHeaders: [String : String]?
+        /// The maximum number of simultanous persistent connections per host
+        let httpMaximumConnectionsPerHost: Int
+        
+        /// The cookie storage object to use, or nil to indicate that no cookies should be handled
+        let httpCookieStorage: HTTPCookieStorage?
+        
+        /// The credential storage object, or nil to indicate that no credential storage is to be used
+        let urlCredentialStorage: URLCredentialStorage?
+        
+        /// The URL resource cache, or nil to indicate that no caching is to be performed
+        let urlCache: URLCache?
+        
+        /// Enable extended background idle mode for any tcp sockets created.
+        let shouldUseExtendedBackgroundIdleMode: Bool
+        
+        let protocolClasses: [AnyClass]?
+    }
+}
+internal extension URLSession._Configuration {
+    init(URLSessionConfiguration config: URLSessionConfiguration) {
+        identifier = config.identifier
+        requestCachePolicy = config.requestCachePolicy
+        timeoutIntervalForRequest = config.timeoutIntervalForRequest
+        timeoutIntervalForResource = config.timeoutIntervalForResource
+        networkServiceType = config.networkServiceType
+        allowsCellularAccess = config.allowsCellularAccess
+        discretionary = config.discretionary
+        connectionProxyDictionary = config.connectionProxyDictionary
+        httpShouldUsePipelining = config.httpShouldUsePipelining
+        httpShouldSetCookies = config.httpShouldSetCookies
+        httpCookieAcceptPolicy = config.httpCookieAcceptPolicy
+        httpAdditionalHeaders = config.httpAdditionalHeaders.map { convertToStringString(dictionary: $0) }
+        httpMaximumConnectionsPerHost = config.httpMaximumConnectionsPerHost
+        httpCookieStorage = config.httpCookieStorage
+        urlCredentialStorage = config.urlCredentialStorage
+        urlCache = config.urlCache
+        shouldUseExtendedBackgroundIdleMode = config.shouldUseExtendedBackgroundIdleMode
+        protocolClasses = config.protocolClasses
+    }
+}
+
+// Configure NSURLRequests
+internal extension URLSession._Configuration {
+    func configure(request: NSMutableURLRequest) {
+        httpAdditionalHeaders?.forEach {
+            guard request.value(forHTTPHeaderField: $0.0) == nil else { return }
+            request.setValue($0.1, forHTTPHeaderField: $0.0)
+        }
+    }
+    func setCookies(on request: NSMutableURLRequest) {
+        if httpShouldSetCookies {
+            //TODO: Ask the cookie storage what cookie to set.
+        }
+    }
+}
+// Cache Management
+private extension URLSession._Configuration {
+    func cachedResponse(forRequest request: NSURLRequest) -> CachedURLResponse? {
+        //TODO: Check the policy & consult the cache.
+        // There's more detail on how this should work here:
+        // <https://developer.apple.com/library/prerelease/ios/documentation/Cocoa/Reference/Foundation/Classes/NSURLRequest_Class/index.html#//apple_ref/swift/enum/c:@E@URLRequestCachePolicy>
+        switch requestCachePolicy {
+        default: return nil
+        }
+    }
+}
+
+private func convertToStringString(dictionary: [AnyHashable:Any]) -> [String: String] {
+    //TODO: There's some confusion about [NSObject:AnyObject] vs. [String:String] for headers.
+    // C.f. <https://github.com/apple/swift-corelibs-foundation/pull/287>
+    var r: [String: String] = [:]
+    dictionary.forEach {
+        let k = String(describing: $0.key as! NSString)
+        let v = String(describing: $0.value as! NSString)
+        r[k] = v
+    }
+    return r
+}