Fixed RunOnMainThread behavior in batch mode vs. executeMethod mode.

When the Unity editor is launched in batch mode,
EditorApplication.update is called periodically just like in
interactive mode. The EditorApplication.update is not called if
the editor is launched with the -executeMethod argument.

This changes RunOnMainThread to only execute jobs in serial if
the editor is launched with the -executeMethod flag. This makes
it possible to get notifications of an asset database refresh
in batch mode without -executeMethod set.

Bug: 150471207
Change-Id: I5878e1f5ff6dc3ee6a8bafd998c54b100ab9f2c5

Author: Stewart Miles

source/VersionHandlerImpl/src/ExecutionEnvironment.cs

@@ -32,11 +32,21 @@ public static bool InBatchMode {
         get { return Environment.CommandLine.Contains("-batchmode"); }
     }
 
+    /// <summary>
+    /// Whether the editor was started with a method to executed.
+    /// </summary>
+    public static bool ExecuteMethodEnabled {
+        get { return Environment.CommandLine.Contains("-executeMethod"); }
+    }
+
     /// <summary>
     /// Whether the UI should be treated as interactive.
     /// </summary>
     internal static bool InteractiveMode {
-        get { return !Environment.CommandLine.Contains("-gvh_noninteractive"); }
+        get {
+            return !(Environment.CommandLine.Contains("-gvh_noninteractive") ||
+                     ExecutionEnvironment.InBatchMode);
+        }
     }
 
     /// <summary>

source/VersionHandlerImpl/src/RunOnMainThread.cs

@@ -78,7 +78,7 @@ public static int Schedule(Action job, double delayInMilliseconds) {
                 scheduledJob = new ScheduledJob {
                     Job = job,
                     JobId = nextJobId,
-                    DelayInMilliseconds = ExecutionEnvironment.InBatchMode ? 0.0 :
+                    DelayInMilliseconds = ExecutionEnvironment.ExecuteMethodEnabled ? 0.0 :
                         delayInMilliseconds
                 };
                 scheduledJobs[nextJobId++] = scheduledJob;
@@ -208,9 +208,9 @@ private static bool OnMainThread {
     }
 
     /// <summary>
-    /// Set when the current thread is running ExecuteAll().
+    /// Number of times ExecuteAll() has been called on the current thread.
     /// </summary>
-    private static bool runningExecuteAll = false;
+    private static int runningExecuteAllCount = 0;
 
     /// <summary>
     /// Flag which indicates whether any jobs are running on the main thread.
@@ -223,7 +223,10 @@ 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 && !runningExecuteAll; }
+        get {
+            return ExecutionEnvironment.ExecuteMethodEnabled && !runningJobs &&
+                runningExecuteAllCount == 0;
+        }
     }
 
     /// <summary>
@@ -234,7 +237,7 @@ static RunOnMainThread() {
         mainThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
         // NOTE: This hooks ExecuteAll on the main thread here and never unregisters as we can't
         // register event handlers on any thread except for the main thread.
-        if (!ExecutionEnvironment.InBatchMode) OnUpdate += ExecuteAll;
+        OnUpdate += ExecuteAll;
     }
 
     /// <summary>
@@ -261,9 +264,9 @@ private static void AddOnUpdateCallback(EditorApplication.CallbackFunction callb
         Run(() => {
                 EditorApplication.update -= callback;
                 EditorApplication.update += callback;
-                // If we're in batch mode, execute the callback now as EditorApplication.update
-                // will not be signaled if Unity was launched to execute a single method.
-                if (ExecutionEnvironment.InBatchMode) callback();
+                // If we're in running a single method, execute the callback now as
+                // EditorApplication.update will not be signaled.
+                if (ExecutionEnvironment.ExecuteMethodEnabled) callback();
             });
     }
 
@@ -470,10 +473,10 @@ private static void ExecuteAllUnnested(bool allowNested) {
 
         // Don't nest job execution on the main thread, return to the last stack frame
         // running ExecuteAll().
-        if (runningExecuteAll && !allowNested) return;
+        if (runningExecuteAllCount > 0 && !allowNested) return;
 
         RunAction(() => {
-                runningExecuteAll = true;
+                runningExecuteAllCount ++;
                 bool jobsRemaining = true;
                 while (jobsRemaining) {
                     jobsRemaining = false;
@@ -484,12 +487,13 @@ private static void ExecuteAllUnnested(bool allowNested) {
 
                     // 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) {
+                    // If we're in running a single method, keep on executing until no polling jobs
+                    // remain.
+                    if (ExecutionEnvironment.ExecuteMethodEnabled && remainingJobs > 0) {
                         jobsRemaining = true;
                     }
                 }
-                runningExecuteAll = false;
+                runningExecuteAllCount --;
             });
     }
 }