Provide MainScope factory method

Fixes #829

Author: qwwdfsad

common/kotlinx-coroutines-core-common/src/CoroutineScope.kt

@@ -216,3 +216,25 @@ public suspend fun <R> coroutineScope(block: suspend CoroutineScope.() -> R): R
 @Suppress("FunctionName")
 public fun CoroutineScope(context: CoroutineContext): CoroutineScope =
     ContextScope(if (context[Job] != null) context else context + Job())
+
+/**
+ * Creates [CoroutineScope] for a UI components.
+ * Resulting scope has [SupervisorJob] and [Dispatchers.Main] and inherits parent
+ * and the rest of context elements from optionally provided [context].
+ * If [context] already had a dispatcher, it will be overwritten by [Dispatchers.Main].
+ *
+ * Example of use:
+ * ```
+ * class MyAndroidActivity: CoroutineScope by MainScope(CoroutineName("MyActivity"))) {
+ *
+ *   override fun onDestroy() {
+ *     super.onDestroy()
+ *     cancel() // CoroutineScope.cancel
+ *   }
+ * }
+ *
+ * ```
+ */
+@Suppress("FunctionName")
+public fun MainScope(context: CoroutineContext = EmptyCoroutineContext): CoroutineScope =
+    ContextScope(context + SupervisorJob(context[Job]) + Dispatchers.Main)

ui/coroutines-guide-ui.md

@@ -472,26 +472,20 @@ The natural solution to this problem is to associate a [Job] object with each UI
 all the coroutines in the context of this job. But passing associated job object to every coroutine builder is error-prone, 
 it is easy to forget it. For this purpose, [CoroutineScope] interface should be implemented by UI owner, and then every
 coroutine builder defined as an extension on [CoroutineScope] inherits UI job without explicitly mentioning it.
+For the sake of simplicity, [MainScope()] factory can be used. It automatically provides `Dispatchers.Main` and parent 
+job.
 
 For example, in Android application an `Activity` is initially _created_ and is _destroyed_ when it is no longer 
 needed and when its memory must be released. A natural solution is to attach an 
 instance of a `Job` to an instance of an `Activity`:
 <!--- CLEAR -->
 
 ```kotlin
-abstract class ScopedAppActivity: AppCompatActivity(), CoroutineScope {
-    protected lateinit var job: Job
-    override val coroutineContext: CoroutineContext 
-        get() = job + Dispatchers.Main
-    
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        job = Job()
-    }
-        
+abstract class ScopedAppActivity: AppCompatActivity(), CoroutineScope by MainScope() {
+ 
     override fun onDestroy() {
         super.onDestroy()
-        job.cancel()
+        cancel() // CoroutineScope.cancel
     } 
 }
 ```

ui/kotlinx-coroutines-swing/test/SwingTest.kt

@@ -6,7 +6,10 @@ package kotlinx.coroutines.swing
 
 import kotlinx.coroutines.*
 import org.junit.*
+import org.junit.Test
 import javax.swing.*
+import kotlin.coroutines.*
+import kotlin.test.*
 
 class SwingTest : TestBase() {
     @Before
@@ -29,4 +32,54 @@ class SwingTest : TestBase() {
         job.join()
         finish(6)
     }
-}
+
+    private class SwingComponent(coroutineContext: CoroutineContext = EmptyCoroutineContext) :
+        CoroutineScope by MainScope(coroutineContext + CoroutineName("SwingComponent")) {
+
+        public var executed = false
+
+        fun testLaunch(): Job = launch {
+            check(SwingUtilities.isEventDispatchThread())
+            executed = true
+        }
+
+        fun testFailure(): Job = launch {
+            check(SwingUtilities.isEventDispatchThread())
+            throw TestException()
+        }
+
+        fun testCancellation() : Job = launch(start = CoroutineStart.ATOMIC) {
+            check(SwingUtilities.isEventDispatchThread())
+            delay(Long.MAX_VALUE)
+        }
+    }
+
+    @Test
+    fun testLaunchInMainScope() = runTest {
+        val component = SwingComponent()
+        val job = component.testLaunch()
+        job.join()
+        assertTrue(component.executed)
+        component.cancel()
+        component.join()
+    }
+
+    @Test
+    fun testFailureInMainScope() = runTest {
+        var exception: Throwable? = null
+        val component = SwingComponent(CoroutineExceptionHandler { ctx, e ->  exception = e})
+        val job = component.testFailure()
+        job.join()
+        assertTrue(exception!! is TestException)
+        component.cancel()
+        component.join()
+    }
+
+    @Test
+    fun testCancellationInMainScope() = runTest {
+        val component = SwingComponent()
+        component.cancel()
+        component.testCancellation().join()
+        component.join()
+    }
+}