Limited nesting in RunOnMainThread.

RunOnMainThread.Run was unneccessarily nesting task execution
in both batch and interactive modes which - in the worst case -
could lead to a stack overflow if a task is explicitly scheduled
in the future to avoid recurision.

Bug: 150471207
Change-Id: I3c4dc453e0a8fc2eca7c8a33c75237666a4496fb

Author: Stewart Miles

source/VersionHandlerImpl/src/RunOnMainThread.cs

@@ -207,6 +207,11 @@ private static bool OnMainThread {
         get { return mainThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId; }
     }
 
+    /// <summary>
+    /// Set when the current thread is running ExecuteAll().
+    /// </summary>
+    private static bool runningExecuteAll = false;
+
     /// <summary>
     /// Flag which indicates whether any jobs are running on the main thread.
     /// This is set and cleared by RunAction().
@@ -218,7 +223,7 @@ private static bool OnMainThread {
     /// This property is reset to its' default value after each set of jobs is dispatched.
     /// </summary>
     public static bool ExecuteNow {
-        get { return ExecutionEnvironment.InBatchMode && !runningJobs; }
+        get { return ExecutionEnvironment.InBatchMode && !runningJobs && !runningExecuteAll; }
     }
 
     /// <summary>
@@ -302,7 +307,7 @@ public static void PollOnUpdateUntilComplete(Func<bool> condition, bool synchron
         if (ExecuteNow && OnMainThread) {
             RunAction(() => {
                     while (true) {
-                        ExecuteAll();
+                        ExecuteAllUnnested(true);
                         lock (pollingJobs) {
                             if (pollingJobs.Count == 0) break;
                         }
@@ -316,7 +321,7 @@ public static void PollOnUpdateUntilComplete(Func<bool> condition, bool synchron
                     if (!pollingJobs.Contains(condition)) break;
                 }
                 if (OnMainThread) {
-                    ExecuteAll();
+                    ExecuteAllUnnested(true);
                 } else {
                     // Wait 100ms.
                     Thread.Sleep(100);
@@ -409,7 +414,7 @@ public static void Run(Action job, bool runNow = true) {
         // If we're not executing the job right now, the job queue is pumped from the UnityEditor
         // update event.
         if (firstJob && (runNow || ExecuteNow) && OnMainThread) {
-            ExecuteAll();
+            ExecuteAllUnnested(false);
         }
     }
 
@@ -437,7 +442,7 @@ private static bool ExecuteNext() {
     /// <returns>true if the caller is on the main thread, false otherwise.</returns>
     public static bool TryExecuteAll() {
         if (OnMainThread) {
-            ExecuteAll();
+            ExecuteAllUnnested(true);
             return true;
         }
         return false;
@@ -446,22 +451,45 @@ public static bool TryExecuteAll() {
     /// <summary>
     /// Execute all scheduled jobs and remove from the update loop if no jobs are remaining.
     /// </summary>
+    /// <param name="force">Force execution when a re-entrant call of this method is detected.
+    /// This is useful when an application is forcing execution to block the main thread.</param>
     private static void ExecuteAll() {
+        ExecuteAllUnnested(false);
+    }
+
+    /// <summary>
+    /// Execute all scheduled jobs and remove from the update loop if no jobs are remaining.
+    /// </summary>
+    /// <param name="allowNested">Force execution when a re-entrant call of this method is detected.
+    /// This is useful when an application is forcing execution to block the main thread.</param>
+    private static void ExecuteAllUnnested(bool allowNested) {
         if (!OnMainThread) {
             UnityEngine.Debug.LogError("ExecuteAll must be executed from the main thread.");
             return;
         }
 
+        // Don't nest job execution on the main thread, return to the last stack frame
+        // running ExecuteAll().
+        if (runningExecuteAll && !allowNested) return;
+
         RunAction(() => {
-                // Execute jobs.
-                while (ExecuteNext()) {
-                }
+                runningExecuteAll = true;
+                bool jobsRemaining = true;
+                while (jobsRemaining) {
+                    jobsRemaining = false;
+                    // Execute jobs.
+                    while (ExecuteNext()) {
+                        jobsRemaining = true;
+                    }
 
-                // Execute polling jobs.
-                int remainingJobs;
-                do {
-                    remainingJobs = ExecutePollingJobs();
-                } while (remainingJobs > 0 && ExecutionEnvironment.InBatchMode);
+                    // Execute polling jobs.
+                    int remainingJobs = ExecutePollingJobs();
+                    // If we're in batch mode, keep on executing until no polling jobs remain.
+                    if (ExecutionEnvironment.InBatchMode && remainingJobs > 0) {
+                        jobsRemaining = true;
+                    }
+                }
+                runningExecuteAll = false;
             });
     }
 }