Analysis: Resolve synchronized on suspend coroutines warning

Warning Messages: "@synchronized annotation is not applicable to suspend
functions and lambdas"

It turns out that this '@synchronized' solution were already replacing
the previous (d5b9948) 'Mutex'
solution, and this, due to the fact that the existing (back then)
'Mutex' solution were causing crashes on Samsung devices running
Android 5 (API Level 21). However, this repo, and thus both, the
WordPress and Jetpack apps, are no longer supporting these devices as
the current 'minSdkVersion' is '24' (Android 7). Thus, this
'@synchronized' annotation can be now safely removed and the
'Mutex' solution reverting back.

For more info see:
- Fix crash in UploadStarter on Samsung devices with Android 5 #10877
(Introduced In): https://github.com/wordpress-mobile/WordPress-Android/
pull/10877/
- ExceptionInInitializerError #10827 (Crash Report):
#10827
- NoSuchFieldException with AtomicReferenceFieldUpdater on Samsung
Android 5.0.x devices #490 (Coroutines Issue):
Kotlin/kotlinx.coroutines#490

Author: ParaskP7

WordPress/src/main/java/org/wordpress/android/ui/uploads/UploadStarter.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
 import org.wordpress.android.analytics.AnalyticsTracker.Stat
 import org.wordpress.android.fluxc.Dispatcher
 import org.wordpress.android.fluxc.generated.UploadActionBuilder
@@ -65,6 +66,13 @@ class UploadStarter @Inject constructor(
 ) : CoroutineScope {
     private val job = Job()
 
+    /**
+     * When the app comes to foreground both `queueUploadFromAllSites` and `queueUploadFromSite` are invoked.
+     * The problem is that they can run in parallel and `uploadServiceFacade.isPostUploadingOrQueued(it)` might return
+     * out-of-date result and a same post is added twice.
+     */
+    private val mutex = Mutex()
+
     override val coroutineContext: CoroutineContext get() = job + bgDispatcher
 
     /**
@@ -136,45 +144,44 @@ class UploadStarter @Inject constructor(
 
     /**
      * This is meant to be used by [checkConnectionAndUpload] only.
-     *
-     * The method needs to be synchronized from the following reasons. When the app comes to foreground both
-     * `queueUploadFromAllSites` and `queueUploadFromSite` are invoked. The problem is that they can run in parallel
-     * and `uploadServiceFacade.isPostUploadingOrQueued(it)` might return out-of-date result and a same post is added
-     * twice.
      */
-    @Suppress("SYNCHRONIZED_ON_SUSPEND")
-    @Synchronized
     private suspend fun upload(site: SiteModel) = coroutineScope {
-        val posts = async { postStore.getPostsWithLocalChanges(site) }
-        val pages = async { pageStore.getPagesWithLocalChanges(site) }
-        val list = posts.await() + pages.await()
+        try {
+            mutex.lock()
+
+            val posts = async { postStore.getPostsWithLocalChanges(site) }
+            val pages = async { pageStore.getPagesWithLocalChanges(site) }
+            val list = posts.await() + pages.await()
 
-        list.asSequence()
-                .map { post ->
-                    val action = uploadActionUseCase.getAutoUploadAction(post, site)
-                    Pair(post, action)
-                }
-                .filter { (_, action) ->
-                    action != DO_NOTHING
-                }
-                .toList()
-                .forEach { (post, action) ->
-                    trackAutoUploadAction(action, post.status, post.isPage)
-                    AppLog.d(
-                            AppLog.T.POSTS,
-                            "UploadStarter for post (isPage: ${post.isPage}) title: ${post.title}, action: $action"
-                    )
-                    dispatcher.dispatch(
-                            UploadActionBuilder.newIncrementNumberOfAutoUploadAttemptsAction(
-                                    post
-                            )
-                    )
-                    uploadServiceFacade.uploadPost(
-                            context = context,
-                            post = post,
-                            trackAnalytics = false
-                    )
-                }
+            list.asSequence()
+                    .map { post ->
+                        val action = uploadActionUseCase.getAutoUploadAction(post, site)
+                        Pair(post, action)
+                    }
+                    .filter { (_, action) ->
+                        action != DO_NOTHING
+                    }
+                    .toList()
+                    .forEach { (post, action) ->
+                        trackAutoUploadAction(action, post.status, post.isPage)
+                        AppLog.d(
+                                AppLog.T.POSTS,
+                                "UploadStarter for post (isPage: ${post.isPage}) title: ${post.title}, action: $action"
+                        )
+                        dispatcher.dispatch(
+                                UploadActionBuilder.newIncrementNumberOfAutoUploadAttemptsAction(
+                                        post
+                                )
+                        )
+                        uploadServiceFacade.uploadPost(
+                                context = context,
+                                post = post,
+                                trackAnalytics = false
+                        )
+                    }
+        } finally {
+            mutex.unlock()
+        }
     }
 
     private fun trackAutoUploadAction(