Aligned Operation cancel behavior with Darwin Foundation

Foundation/Operation.swift

@@ -43,13 +43,15 @@ open class Operation : NSObject {
     }
 
     open func start() {
-        lock.lock()
-        _executing = true
-        lock.unlock()
-        main()
-        lock.lock()
-        _executing = false
-        lock.unlock()
+        if !isCancelled {
+            lock.lock()
+            _executing = true
+            lock.unlock()
+            main()
+            lock.lock()
+            _executing = false
+            lock.unlock()
+        }
         finish()
     }
 
@@ -79,9 +81,13 @@ open class Operation : NSObject {
     }
 
     open func cancel() {
+        // Note that calling cancel() is advisory. It is up to the main() function to
+        // call isCancelled at appropriate points in its execution flow and to do the
+        // actual canceling work. Eventually main() will invoke finish() and this is
+        // where we then leave the groups and unblock other operations that might
+        // depend on us.
         lock.lock()
         _cancelled = true
-        _leaveGroups()
         lock.unlock()
     }
 

TestFoundation/TestOperationQueue.swift

@@ -28,6 +28,7 @@ class TestOperationQueue : XCTestCase {
             ("test_MainQueueGetter", test_MainQueueGetter),
             ("test_CurrentQueueOnMainQueue", test_CurrentQueueOnMainQueue),
             ("test_CurrentQueueOnBackgroundQueue", test_CurrentQueueOnBackgroundQueue),
+            ("test_CurrentQueueOnBackgroundQueueWithSelfCancel", test_CurrentQueueOnBackgroundQueueWithSelfCancel),
             ("test_CurrentQueueWithCustomUnderlyingQueue", test_CurrentQueueWithCustomUnderlyingQueue),
             ("test_CurrentQueueWithUnderlyingQueueResetToNil", test_CurrentQueueWithUnderlyingQueueResetToNil),
         ]
@@ -135,6 +136,20 @@ class TestOperationQueue : XCTestCase {
         waitForExpectations(timeout: 1)
     }
 
+    func test_CurrentQueueOnBackgroundQueueWithSelfCancel() {
+        let operationQueue = OperationQueue()
+        operationQueue.maxConcurrentOperationCount = 1
+        let expectation = self.expectation(description: "Background execution")
+        operationQueue.addOperation {
+            XCTAssertEqual(operationQueue, OperationQueue.current)
+            expectation.fulfill()
+            // Canceling operation X from inside operation X should not cause the app to a crash
+            operationQueue.cancelAllOperations()
+        }
+
+        waitForExpectations(timeout: 1)
+    }
+
     func test_CurrentQueueWithCustomUnderlyingQueue() {
         let expectation = self.expectation(description: "Background execution")