Don't update hidden consoles every second

- Added new API to allow console pages knew whether they are visible or
not.
- Use new IConsole API to schedule console updates only if console page
is visible (top level) in the console view. This prevents multiple
opened consoles in same console view run update tasks every second, even
if no one can see the updated console name.

Fixes #2478

Author: iloveeclipse

debug/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java

@@ -37,10 +37,9 @@
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Pattern;
 
 import org.eclipse.core.resources.IFile;
@@ -143,9 +142,10 @@ public class ProcessConsole extends IOConsole implements IConsole, IDebugEventSe
 
 	private volatile boolean fStreamsClosed;
 	private volatile boolean disposed;
+	private volatile boolean isVisible;
 
-	private final ScheduledExecutorService consoleNameUpdateExecutor;
-	private volatile ScheduledFuture<?> pendingNameUpdate;
+	private final ExecutorService consoleNameUpdateExecutor;
+	private final AtomicBoolean updateRunning;
 
 	/**
 	 * Create process console with default encoding.
@@ -166,11 +166,12 @@ public ProcessConsole(IProcess process, IConsoleColorProvider colorProvider) {
 	 */
 	public ProcessConsole(IProcess process, IConsoleColorProvider colorProvider, String encoding) {
 		super(IInternalDebugCoreConstants.EMPTY_STRING, IDebugUIConstants.ID_PROCESS_CONSOLE_TYPE, null, encoding, true);
+		updateRunning = new AtomicBoolean();
 		fStreamListeners = new ArrayList<>();
 		fAllocateConsole = true;
 		fProcess = process;
 		fUserInput = getInputStream();
-		consoleNameUpdateExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
+		consoleNameUpdateExecutor = Executors.newSingleThreadExecutor(r -> {
 			Thread t = new Thread(r, "Console name updater"); //$NON-NLS-1$
 			t.setDaemon(true);
 			return t;
@@ -309,9 +310,14 @@ public IPageBookViewPage createPage(IConsoleView view) {
 	/**
 	 * Computes and returns the current name of this console.
 	 *
+	 * @param triggerAsyncUpdate if <code>true</code> and process is still running,
+	 *                           triggers asynchronous update of console name every
+	 *                           second to update elapsed time display in console
+	 *                           name
+	 *
 	 * @return a name for this console
 	 */
-	protected String computeName() {
+	protected String computeName(boolean triggerAsyncUpdate) {
 		if (disposed) {
 			return getName();
 		}
@@ -337,7 +343,9 @@ protected String computeName() {
 
 		// Process is still running, so trigger async update of console name every
 		// second to keep elapsed time updated.
-		triggerAsyncConsoleNameUpdate();
+		if (triggerAsyncUpdate) {
+			triggerAsyncConsoleNameUpdate(label);
+		}
 		return label;
 	}
 
@@ -409,22 +417,38 @@ private static String computeProcessLabel(IProcess process, Date launchTime) {
 		return procLabel;
 	}
 
-	private void triggerAsyncConsoleNameUpdate() {
-		if (disposed) {
+	private void triggerAsyncConsoleNameUpdate(String newName) {
+		if (!canUpdateConsoleName()) {
 			return;
 		}
+		// update console name immediately to show elapsed time right after launch and
+		// then start async update every second
+		showName(false, newName);
 
-		// refresh every second, but only if not already scheduled:
-		ScheduledFuture<?> currentPending = pendingNameUpdate;
-		if (currentPending == null || currentPending.isDone()) {
-			currentPending = consoleNameUpdateExecutor.schedule(() -> {
-				pendingNameUpdate = null;
-				if (disposed) {
-					return;
-				}
-				resetName(false);
-			}, 1, TimeUnit.SECONDS);
+		if (!updateRunning.compareAndSet(false, true)) {
+			return;
 		}
+		consoleNameUpdateExecutor.submit(() -> {
+			try {
+				while (!disposed) {
+					try {
+						Thread.sleep(1000);
+					} catch (InterruptedException e) {
+						// ignore and continue to update name
+					}
+					if (!canUpdateConsoleName()) {
+						break;
+					}
+					showName(false, computeName(false));
+				}
+			} finally {
+				updateRunning.set(false);
+			}
+		});
+	}
+
+	private boolean canUpdateConsoleName() {
+		return !disposed && isVisible && !fProcess.isTerminated();
 	}
 
 	private static String computeElapsedTimeLabel(Date launchTime, Date terminateTime) {
@@ -567,14 +591,14 @@ public IProcess getProcess() {
 	@Override
 	protected void dispose() {
 		super.dispose();
+		disposed = true;
 		consoleNameUpdateExecutor.shutdownNow();
 		fColorProvider.disconnect();
 		DebugPlugin.getDefault().removeDebugEventListener(this);
 		DebugUIPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
 		JFaceResources.getFontRegistry().removeListener(this);
 		closeStreams();
 		disposeStreams();
-		disposed = true;
 	}
 
 	/**
@@ -628,7 +652,7 @@ protected void init() {
 		DebugPlugin.getDefault().addDebugEventListener(this);
 		// computeName() after addDebugEventListener()
 		// see https://github.com/eclipse-jdt/eclipse.jdt.debug/issues/390
-		setName(computeName());
+		setName(computeName(false));
 		if (fProcess.isTerminated()) {
 			closeStreams();
 			resetName(true);
@@ -681,20 +705,25 @@ public void handleDebugEvents(DebugEvent[] events) {
 	}
 
 	/**
-	 * Compute & update console name, notify listeners if content has changed. Note,
-	 * the {@link #computeName()} method may call this method again asynchronously
-	 * if process is till running to update elapsed time display
+	 * Compute & update console name, notify listeners if content has changed.
+	 *
+	 * @param contentChanged whether the content of console has changed since last
+	 *                       name update.
 	 */
-	private synchronized void resetName(boolean changed) {
-		final String newName = computeName();
+	private synchronized void resetName(boolean contentChanged) {
+		final String newName = computeName(false);
+		showName(contentChanged, newName);
+	}
+
+	private void showName(boolean contentChanged, final String newName) {
 		String name = getName();
 		if (!name.equals(newName)) {
 			DebugUIPlugin.getStandardDisplay().execute(() -> {
 				if (disposed) {
 					return;
 				}
 				setName(newName);
-				if (changed) {
+				if (contentChanged) {
 					warnOfContentChange();
 				}
 			});
@@ -1215,4 +1244,16 @@ public static String convertElapsedFormat(String humanReadable) {
 
 		return format.toString();
 	}
-}
+
+	@Override
+	public void pageShown() {
+		isVisible = true;
+		computeName(true);
+	}
+
+	@Override
+	public void pageHidden() {
+		isVisible = false;
+		computeName(false);
+	}
+}

debug/org.eclipse.ui.console/.settings/.api_filters

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<component id="org.eclipse.ui.console" version="2">
+    <resource path="src/org/eclipse/ui/console/IConsole.java" type="org.eclipse.ui.console.IConsole">
+        <filter id="404000815">
+            <message_arguments>
+                <message_argument value="org.eclipse.ui.console.IConsole"/>
+                <message_argument value="pageHidden()"/>
+            </message_arguments>
+        </filter>
+        <filter id="404000815">
+            <message_arguments>
+                <message_argument value="org.eclipse.ui.console.IConsole"/>
+                <message_argument value="pageShown()"/>
+            </message_arguments>
+        </filter>
+    </resource>
+</component>

debug/org.eclipse.ui.console/src/org/eclipse/ui/console/IConsole.java

@@ -97,4 +97,40 @@ public interface IConsole {
 	 */
 	String getType();
 
+	/**
+	 * Notifies this console that its page has been shown in the UI. This method is
+	 * called when this console page is shown on top of other console pages in at
+	 * least one <b>visible</b> console view.
+	 * <p>
+	 * Default implementation does nothing.
+	 * </p>
+	 * <p>
+	 * Subclasses may override this method to be notified when the console page for
+	 * this console is visible to user.
+	 * </p>
+	 *
+	 * @since 3.16
+	 */
+	default void pageShown() {
+		// Subclasses may override
+	}
+
+	/**
+	 * Notifies this console that its page has been hidden in the UI. This method is
+	 * called when this console page is not shown on top of other console pages in
+	 * any of <b>visible</b> console views.
+	 * <p>
+	 * Default implementation does nothing.
+	 * </p>
+	 * <p>
+	 * Subclasses may override this method to be notified when the console page for
+	 * this console is not more visible to user.
+	 * </p>
+	 *
+	 * @since 3.16
+	 */
+	default void pageHidden() {
+		// Subclasses may override
+	}
+
 }

debug/org.eclipse.ui.console/src/org/eclipse/ui/console/IConsoleManager.java

@@ -107,4 +107,37 @@ public interface IConsoleManager {
 	 */
 	void refresh(IConsole console);
 
+	/**
+	 * Notifies that given console has been shown in the UI (either the view with
+	 * given console on top has been shown or the console has been switched to the
+	 * top console in at least one view).
+	 *
+	 * <p>
+	 * Note, there could be multiple views showing the same console, so the page
+	 * with given console can be still hidden in some views.
+	 * </p>
+	 *
+	 * @param console the top console from view that has been shown
+	 *
+	 * @since 3.16
+	 */
+	default void consoleShown(IConsole console) {
+	}
+
+	/**
+	 * Notifies that given console that was on top of at least one view has been
+	 * hidden in the UI (either the console is not the top page in the view or the
+	 * view with given console on top has been hidden).
+	 * <p>
+	 * Note, there could be multiple views showing the same console, so the page
+	 * with given console can be still shown in some views.
+	 * </p>
+	 *
+	 * @param console the console that has been hidden
+	 *
+	 * @since 3.16
+	 */
+	default void consoleHidden(IConsole console) {
+	}
+
 }

debug/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsoleManager.java

@@ -484,4 +484,34 @@ public void refresh(final IConsole console) {
 		redrawConsoleJob.schedule(50);
 	}
 
+	@Override
+	public void consoleShown(IConsole console) {
+		console.pageShown();
+	}
+
+	@Override
+	public void consoleHidden(IConsole console) {
+		if (isConsoleVisibleSomewhere(console)) {
+			// if console is still shown in some other view, then there is no need to call
+			// pageHidden() on the console, since user can still see the console
+			return;
+		}
+		console.pageHidden();
+	}
+
+	private boolean isConsoleVisibleSomewhere(IConsole console) {
+		synchronized (fConsoleViews) {
+			for (ConsoleView view : fConsoleViews) {
+				IWorkbenchPartSite site = view.getSite();
+				if (site == null) {
+					continue;
+				}
+				boolean viewVisible = site.getPage().isPartVisible(view);
+				if (viewVisible && view.getConsole() == console) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
 }

debug/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsoleView.java

@@ -194,11 +194,17 @@ protected void showPageRec(PageRec pageRec) {
 			if (fActive && oldActiveConsole != null) {
 				deactivateParticipants(oldActiveConsole);
 			}
+
+			setConsole(recConsole);
+
+			if (oldActiveConsole != null) {
+				getConsoleManager().consoleHidden(oldActiveConsole);
+			}
 			if (recConsole != null) {
 				activateParticipants(recConsole);
+				getConsoleManager().consoleShown(recConsole);
 			}
 		}
-		setConsole(recConsole);
 		// bring active console on top of stack
 		if (recConsole != null && !fStack.isEmpty() && !recConsole.equals(fStack.get(0))) {
 			fStack.remove(recConsole);
@@ -818,10 +824,22 @@ public void partOpened(IWorkbenchPartReference partRef) {
 
 	@Override
 	public void partHidden(IWorkbenchPartReference partRef) {
+		if (isThisPart(partRef)) {
+			IConsole console = getConsole();
+			if (console != null) {
+				getConsoleManager().consoleHidden(console);
+			}
+		}
 	}
 
 	@Override
 	public void partVisible(IWorkbenchPartReference partRef) {
+		if (isThisPart(partRef)) {
+			IConsole console = getConsole();
+			if (console != null) {
+				getConsoleManager().consoleShown(console);
+			}
+		}
 	}
 
 	@Override