Change the SDCallbackQueue to allows easier usage. Only main queue use SafeAsyncMainQueue, others revert back to default value

The implementation don't need complicated check, using object compare is enough

Author: dreampiggy

SDWebImage/Core/SDCallbackQueue.h

@@ -27,23 +27,24 @@ typedef NS_ENUM(NSUInteger, SDCallbackPolicy) {
 /// Useful when you call SDWebImage in non-main queue and want to avoid it callback into main queue, which may cause issue.
 @interface SDCallbackQueue : NSObject
 
-/// The shared main queue. This is the default value, has the same effect when passing `nil` to `SDWebImageContextCallbackQueue`
+/// The main queue. This is the default value, has the same effect when passing `nil` to `SDWebImageContextCallbackQueue`
+/// The policy defaults to `SDCallbackPolicySafeAsyncMainQueue`
 @property (nonnull, class, readonly) SDCallbackQueue *mainQueue;
 
 /// The caller current queue. Using `dispatch_get_current_queue`. This is not a dynamic value and only keep the first call time queue.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
 @property (nonnull, class, readonly) SDCallbackQueue *currentQueue;
 
 /// The global concurrent queue (user-initiated QoS). Using `dispatch_get_global_queue`.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
 @property (nonnull, class, readonly) SDCallbackQueue *globalQueue;
 
 /// The current queue's callback policy.
-/// defaults to `SDCallbackPolicySafeAsyncMainQueue` from v5.20.1, which behaves like the old macro  `dispatch_main_async_safe`
-/// @note old 5.x version use `SDCallbackPolicySafeExecute`, which may behave incorrectly when you sync the block into global queue.
-@property (assign, readwrite) SDCallbackPolicy policy;
+@property (nonatomic, assign, readwrite) SDCallbackPolicy policy;
 
 - (nonnull instancetype)init NS_UNAVAILABLE;
 + (nonnull instancetype)new  NS_UNAVAILABLE;
-/// Create the callback queue with a GCD queue
+/// Create the callback queue with a GCD queue. The policy defaults to `SDCallbackPolicySafeExecute`
 /// - Parameter queue: The GCD queue, should not be NULL
 - (nonnull instancetype)initWithDispatchQueue:(nonnull dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER;
 

SDWebImage/Core/SDCallbackQueue.m

@@ -12,15 +12,9 @@
 @interface SDCallbackQueue ()
 
 @property (nonatomic, strong, nonnull) dispatch_queue_t queue;
-@property (nonatomic, strong, nonnull) NSThread *thread;
 
 @end
 
-static void * SDCallbackQueueKey = &SDCallbackQueueKey;
-static void SDReleaseBlock(void *context) {
-    CFRelease(context);
-}
-
 static inline void SDSafeMainQueueAsync(dispatch_block_t _Nonnull block) {
     if (NSThread.isMainThread) {
         // Match exists `dispatch_main_async_safe` behavior
@@ -42,26 +36,19 @@ static inline void SDSafeMainThreadAsync(dispatch_block_t _Nonnull block) {
     }
 }
 
-static void SDSafeExecute(SDCallbackQueue *callbackQueue, dispatch_block_t _Nonnull block, BOOL async) {
-    // Extend gcd queue's life cycle
-    dispatch_queue_t queue = callbackQueue.queue;
-    // Special handle for main queue label only (custom queue can have the same label)
-    const char *label = dispatch_queue_get_label(queue);
-    if (label && label == dispatch_queue_get_label(dispatch_get_main_queue())) {
-        const char *currentLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
-        if (label == currentLabel) {
-            block();
-            return;
-        }
+static void SDSafeExecute(dispatch_queue_t queue, dispatch_block_t _Nonnull block, BOOL async) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    dispatch_queue_t currentQueue = dispatch_get_current_queue();
+#pragma clang diagnostic pop
+    if (queue == currentQueue) {
+        block();
+        return;
     }
-    // Check specific to detect queue equal
-    void *specific = dispatch_queue_get_specific(queue, SDCallbackQueueKey);
-    if (specific && CFGetTypeID(specific) == CFUUIDGetTypeID()) {
-        void *currentSpecific = dispatch_get_specific(SDCallbackQueueKey);
-        if (currentSpecific && CFGetTypeID(currentSpecific) == CFUUIDGetTypeID() && CFEqual(specific, currentSpecific)) {
-            block();
-            return;
-        }
+    // Special handle for main queue only
+    if (NSThread.isMainThread && queue == dispatch_get_main_queue()) {
+        block();
+        return;
     }
     if (async) {
         dispatch_async(queue, block);
@@ -76,22 +63,15 @@ - (instancetype)initWithDispatchQueue:(dispatch_queue_t)queue {
     self = [super init];
     if (self) {
         NSCParameterAssert(queue);
-        CFUUIDRef UUID = CFUUIDCreate(kCFAllocatorDefault);
-        dispatch_queue_set_specific(queue, SDCallbackQueueKey, (void *)UUID, SDReleaseBlock);
         _queue = queue;
-        _policy = SDCallbackPolicySafeAsyncMainQueue;
-        // global queue can execute on main thread, like call `dispatch_sync(globalQueue)` in main thread
-        _thread = NSThread.currentThread;
+        _policy = SDCallbackPolicySafeExecute;
     }
     return self;
 }
 
 + (SDCallbackQueue *)mainQueue {
-    static dispatch_once_t onceToken;
-    static SDCallbackQueue *queue;
-    dispatch_once(&onceToken, ^{
-        queue = [[SDCallbackQueue alloc] initWithDispatchQueue:dispatch_get_main_queue()];
-    });
+    SDCallbackQueue *queue = [[SDCallbackQueue alloc] initWithDispatchQueue:dispatch_get_main_queue()];
+    queue->_policy = SDCallbackPolicySafeAsyncMainQueue;
     return queue;
 }
 
@@ -111,7 +91,7 @@ + (SDCallbackQueue *)globalQueue {
 - (void)sync:(nonnull dispatch_block_t)block {
     switch (self.policy) {
         case SDCallbackPolicySafeExecute:
-            SDSafeExecute(self, block, NO);
+            SDSafeExecute(self.queue, block, NO);
             break;
         case SDCallbackPolicyDispatch:
             dispatch_sync(self.queue, block);
@@ -126,15 +106,15 @@ - (void)sync:(nonnull dispatch_block_t)block {
             SDSafeMainThreadAsync(block);
             break;
         default:
-            SDSafeExecute(self, block, NO);
+            NSCAssert(NO, @"unexpected policy %tu", self.policy);
             break;
     }
 }
 
 - (void)async:(nonnull dispatch_block_t)block {
     switch (self.policy) {
         case SDCallbackPolicySafeExecute:
-            SDSafeExecute(self, block, YES);
+            SDSafeExecute(self.queue, block, YES);
             break;
         case SDCallbackPolicyDispatch:
             dispatch_async(self.queue, block);
@@ -149,7 +129,7 @@ - (void)async:(nonnull dispatch_block_t)block {
             SDSafeMainThreadAsync(block);
             break;
         default:
-            SDSafeExecute(self, block, YES);
+            NSCAssert(NO, @"unexpected policy %tu", self.policy);
             break;
     }
 }