Fix progress overshoot >100% in Synchronize refresh jobs

In RefreshSubscriberParticipantJob.doRefresh and the sibling
RefreshModelParticipantJob.doRefresh, the same IProgressMonitor was
passed sequentially to two consumers (subscriber.refresh +
SubscriberSyncInfoCollector.waitForCollector, and context.refresh +
JobManager.join respectively). Each consumer treated the monitor as
exclusively its own and reported its full budget against the parent,
which is how the JobManager group ends up displaying 115-160 % for
Synchronize jobs (reproducible with Subversive and other team providers).

Wrap the parent monitor with SubMonitor.convert(monitor, 100) and split
80/20 between the two consumers, mirroring the existing 80/20 split
already used in RefreshParticipantJob.initialize between
setProgressGroup(group, 80) and handleProgressGroupSet(group, 20).

To keep the production class shape unchanged and avoid touching
SubscriberSyncInfoCollector, the SubscriberJob exposes the existing
collector handoff as a small protected seam:

    protected void waitForCollector(IProgressMonitor monitor) {
        getCollector().waitForCollector(monitor);
    }

The regression test (RefreshSubscriberParticipantJobProgressTests in
org.eclipse.team.tests.core, wired into AllTeamTests) overrides this
seam in a TestableJob to imitate a greedy collector. With the previous
code the parent monitor records ~2000 ticks; with the fix it records
~1000, well below the 1500 threshold the test asserts.

Fixes #2645

Signed-off-by: boa <foxyboa@gmail.com>

Author: FoxyBOA

team/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/RefreshModelParticipantJob.java

@@ -22,6 +22,7 @@
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.team.core.diff.IDiff;
 import org.eclipse.team.core.diff.IDiffChangeEvent;
@@ -77,11 +78,12 @@ protected void doRefresh(IChangeDescription changeListener,
 		ISynchronizationContext context = ((ModelSynchronizeParticipant)getParticipant()).getContext();
 		try {
 			context.getDiffTree().addDiffChangeListener((ChangeDescription)changeListener);
+			SubMonitor sub = SubMonitor.convert(monitor, 100);
 			// TODO: finer grained refresh
-			context.refresh(mappings, monitor);
+			context.refresh(mappings, sub.split(80));
 			// Wait for any asynchronous updating to complete
 			try {
-				Job.getJobManager().join(context, monitor);
+				Job.getJobManager().join(context, sub.split(20));
 			} catch (InterruptedException e) {
 				// Ignore
 			}

team/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/RefreshSubscriberParticipantJob.java

@@ -16,6 +16,7 @@
 
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.subscribers.Subscriber;
 import org.eclipse.team.core.synchronize.SyncInfo;
@@ -119,11 +120,16 @@ protected void doRefresh(IChangeDescription changeListener, IProgressMonitor mon
 		if (subscriber != null) {
 			try {
 				subscriber.addListener((RefreshChangeListener)changeListener);
-				subscriber.refresh(resources, IResource.DEPTH_INFINITE, monitor);
-				getCollector().waitForCollector(monitor);
+				SubMonitor sub = SubMonitor.convert(monitor, 100);
+				subscriber.refresh(resources, IResource.DEPTH_INFINITE, sub.split(80));
+				waitForCollector(sub.split(20));
 			} finally {
 				subscriber.removeListener((RefreshChangeListener)changeListener);
 			}
 		}
 	}
+
+	protected void waitForCollector(IProgressMonitor monitor) {
+		getCollector().waitForCollector(monitor);
+	}
 }

team/tests/org.eclipse.team.tests.core/src/org/eclipse/team/internal/ui/synchronize/RefreshSubscriberParticipantJobProgressTests.java

@@ -0,0 +1,113 @@
+/*******************************************************************************
+ * Copyright (c) 2026 Foxy BOA and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Foxy BOA - initial implementation, issue #2645
+ *******************************************************************************/
+package org.eclipse.team.internal.ui.synchronize;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.team.core.TeamException;
+import org.eclipse.team.core.subscribers.Subscriber;
+import org.eclipse.team.tests.core.mapping.ScopeTestSubscriber;
+import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
+import org.eclipse.team.ui.synchronize.SubscriberParticipant;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Regression test for issue #2645: {@link RefreshSubscriberParticipantJob#doRefresh
+ * RefreshSubscriberParticipantJob.doRefresh} must split its progress monitor between
+ * {@code subscriber.refresh} and {@code waitForCollector} instead of handing the same
+ * monitor to both.
+ */
+public class RefreshSubscriberParticipantJobProgressTests {
+
+	private static class CountingMonitor extends NullProgressMonitor {
+		volatile double total;
+
+		@Override
+		public void worked(int work) {
+			total += work;
+		}
+
+		@Override
+		public void internalWorked(double work) {
+			total += work;
+		}
+	}
+
+	private static class ConsumingSubscriber extends ScopeTestSubscriber {
+		@Override
+		public void refresh(IResource[] resources, int depth, IProgressMonitor monitor) {
+			SubMonitor sm = SubMonitor.convert(monitor, 100);
+			sm.worked(100);
+			sm.done();
+		}
+	}
+
+	private static class TestableJob extends RefreshSubscriberParticipantJob {
+		private final Subscriber subscriberOverride;
+
+		TestableJob(SubscriberParticipant participant, IResource[] resources, Subscriber subscriber) {
+			super(participant, "test-job", "test-task", resources, null);
+			this.subscriberOverride = subscriber;
+		}
+
+		@Override
+		protected Subscriber getSubscriber() {
+			return subscriberOverride;
+		}
+
+		@Override
+		protected void waitForCollector(IProgressMonitor monitor) {
+			SubMonitor sm = SubMonitor.convert(monitor, 100);
+			sm.worked(100);
+			sm.done();
+		}
+
+		void invokeDoRefresh(RefreshChangeListener changeDescription, IProgressMonitor monitor) throws TeamException {
+			doRefresh(changeDescription, monitor);
+		}
+	}
+
+	@Test
+	public void doRefreshDoesNotOverConsumeParentMonitor() throws Exception {
+		ConsumingSubscriber subscriber = new ConsumingSubscriber();
+		SubscriberParticipant participant = new SubscriberParticipant() {
+			@Override
+			public Subscriber getSubscriber() {
+				return subscriber;
+			}
+
+			@Override
+			protected void initializeConfiguration(ISynchronizePageConfiguration configuration) {
+				// not needed for this test
+			}
+		};
+
+		TestableJob job = new TestableJob(participant, new IResource[0], subscriber);
+		RefreshChangeListener changeDescription = new RefreshChangeListener(new IResource[0], null);
+
+		CountingMonitor parent = new CountingMonitor();
+		parent.beginTask("test", 100);
+		job.invokeDoRefresh(changeDescription, parent);
+		parent.done();
+
+		// Without the fix, both consumers receive the same monitor and parent.total ~= 2000.
+		// With the fix, doRefresh splits the parent 80/20 and parent.total ~= 1000.
+		assertTrue(parent.total <= 1500,
+				"Parent monitor over-consumed: total=" + parent.total + " (expected <= 1500)");
+	}
+}

team/tests/org.eclipse.team.tests.core/src/org/eclipse/team/tests/core/AllTeamTests.java

@@ -13,13 +13,15 @@
  *******************************************************************************/
 package org.eclipse.team.tests.core;
 
+import org.eclipse.team.internal.ui.synchronize.RefreshSubscriberParticipantJobProgressTests;
 import org.eclipse.team.tests.core.regression.AllTeamRegressionTests;
 import org.junit.platform.suite.api.SelectClasses;
 import org.junit.platform.suite.api.Suite;
 
 @Suite
 @SelectClasses({ //
 		AllTeamRegressionTests.class, //
+		RefreshSubscriberParticipantJobProgressTests.class, //
 		RepositoryProviderTests.class, //
 		StorageMergerTests.class, //
 		StreamTests.class, //