Attachment #120102 for bug #258352

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 217-229 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/progress/ProgressViewUpdater.java (-2 / +10 lines)
217	}	217	}
218	}	218	}
219		219
		220	/** keep track of how often we schedule the job to avoid overloading the JobManager */
		221	private long lastUpdateJobScheduleRequest = 0;
		222
220	/**	223	/**
221	* Schedule an update.	224	* Schedule an update.
222	*/	225	*/
223	void scheduleUpdate() {	226	void scheduleUpdate() {
224	if (PlatformUI.isWorkbenchRunning()) {	227	if (PlatformUI.isWorkbenchRunning()) {
225	//Add in a 100ms delay so as to keep priority low	228	// make sure we don't schedule too often
226	updateJob.schedule(100);	229	long now = System.currentTimeMillis();
		230	if (now - lastUpdateJobScheduleRequest >= 100) {
		231	//Add in a 100ms delay so as to keep priority low
		232	updateJob.schedule(100);
		233	lastUpdateJobScheduleRequest = now;
		234	}
227	}	235	}
228	}	236	}
229		237





	final Object familyKey = new Object();

	/** 
	 * Access to the listeners array is only protected by the listenersKey during modifications.
	 * As such, when iterating through the listeners array, a temporary variable should be used to
	 * hold the reference to the array, see #sleepJobInfo(JobInfo) for an example.
	 */
	private IJobProgressManagerListener[] listeners = new IJobProgressManagerListener[0];

	final Object listenersKey = new Object();

		if (group != null) {
			sleepGroup(group,info);
		}
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			IJobProgressManagerListener listener = listenersTemp[i];
			// Is this one the user never sees?
			if (isNeverDisplaying(info.getJob(), listener.showsDebug()))
				continue;
			if (listener.showsDebug())
				listener.refreshJobInfo(info);
			else
				listener.removeJob(info);
					listener.removeJob(info);

			}
		}

	}

	 * @param group
	 */
	private void sleepGroup(GroupInfo group, JobInfo info) {
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			IJobProgressManagerListener listener = listenersTemp[i];
			if (isNeverDisplaying(info.getJob(), listener.showsDebug()))
				continue;
					continue;
		
			if (listener.showsDebug() || group.isActive())
				listener.refreshGroup(group);
			else
				listener.removeGroup(group);
			}
		}
		
	}

	 * @param listener
	 */
	void addListener(IJobProgressManagerListener listener) {
		// if the listener is already held, ignore
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			if (listenersTemp[i].equals(listener)) return;
		}
		// add the new listener
		synchronized (listenersKey) {
			IJobProgressManagerListener[] newListeners = new IJobProgressManagerListener[listeners.length+1];
			for (int i = 0; i < listeners.length; i++) {
				newListeners[i] = listeners[i];
			}
			newListeners[listeners.length] = listener;
			listeners = newListeners;
			newListeners.toArray(listeners);
		}

	}

	/**

	 * @param listener
	 */
	void removeListener(IJobProgressManagerListener listener) {
		// if the listener is not held, ignore
		boolean listenerHeld = false;
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			if (listenersTemp[i].equals(listener)) {
				listenerHeld = true;
				break;
			}
		}
		if (!listenerHeld) return;
		// remove the listener
		synchronized (listenersKey) {
			IJobProgressManagerListener[] newListeners = new IJobProgressManagerListener[listeners.length-1];
			for (int i=0,j=0; i < listeners.length; i++) {
				if (listeners[i].equals(listener)) {
					continue;
				}
				newListeners[j++] = listeners[i];
			}
			listeners = listenersTemp;
			newListeners.toArray(listeners);
		}
	}


			refreshGroup(group);
		}

		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			IJobProgressManagerListener listener = listenersTemp[i];
			if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
				listener.refreshJobInfo(info);
				}
			}
		}
	}

	 * @param info
	 */
	public void refreshGroup(GroupInfo info) {
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			listenersTemp[i].refreshGroup(info);
				listeners[i].refreshGroup(info);
			}
		}
	}


	public void refreshAll() {

		pruneStaleJobs();
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			listenersTemp[i].refreshAll();
			}
		}

	}

			}
		}

		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			IJobProgressManagerListener listener = listenersTemp[i];
			if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
				listener.removeJob(info);
				}
			}
		}


	 *            GroupInfo
	 */
	public void removeGroup(GroupInfo group) {
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			listenersTemp[i].removeGroup(group);
				listeners[i].removeGroup(group);
			}
		}
	}


		}

		jobs.put(info.getJob(), info);
		IJobProgressManagerListener[] listenersTemp = listeners;
		for (int i = 0; i < listenersTemp.length; i++) {
			IJobProgressManagerListener listener = listenersTemp[i];
			if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
				listener.addJob(info);
				}
			}
		}
	}

Return to bug 258352

Lines 96-101 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/progress/ProgressManager.java (-68 / +73 lines)
96		96
97	final Object familyKey = new Object();	97	final Object familyKey = new Object();
98		98
		99	/**
		100	* Access to the listeners array is only protected by the listenersKey during modifications.
		101	* As such, when iterating through the listeners array, a temporary variable should be used to
		102	* hold the reference to the array, see #sleepJobInfo(JobInfo) for an example.
		103	*/
99	private IJobProgressManagerListener[] listeners = new IJobProgressManagerListener[0];	104	private IJobProgressManagerListener[] listeners = new IJobProgressManagerListener[0];
100		105
101	final Object listenersKey = new Object();	106	final Object listenersKey = new Object();
Lines 534-552 Link Here
534	if (group != null) {	539	if (group != null) {
535	sleepGroup(group,info);	540	sleepGroup(group,info);
536	}	541	}
537		542	IJobProgressManagerListener[] listenersTemp = listeners;
538	synchronized (listenersKey) {	543	for (int i = 0; i < listenersTemp.length; i++) {
539	for (int i = 0; i < listeners.length; i++) {	544	IJobProgressManagerListener listener = listenersTemp[i];
540	IJobProgressManagerListener listener = listeners[i];	545	// Is this one the user never sees?
541	// Is this one the user never sees?	546	if (isNeverDisplaying(info.getJob(), listener.showsDebug()))
542	if (isNeverDisplaying(info.getJob(), listener.showsDebug()))	547	continue;
543	continue;	548	if (listener.showsDebug())
544	if (listener.showsDebug())	549	listener.refreshJobInfo(info);
545	listener.refreshJobInfo(info);	550	else
546	else	551	listener.removeJob(info);
547	listener.removeJob(info);
548
549	}
550	}	552	}
551		553
552	}	554	}
Lines 556-573 Link Here
556	* @param group	558	* @param group
557	*/	559	*/
558	private void sleepGroup(GroupInfo group, JobInfo info) {	560	private void sleepGroup(GroupInfo group, JobInfo info) {
559	synchronized (listenersKey) {	561	IJobProgressManagerListener[] listenersTemp = listeners;
560	for (int i = 0; i < listeners.length; i++) {	562	for (int i = 0; i < listenersTemp.length; i++) {
561		563	IJobProgressManagerListener listener = listenersTemp[i];
562	IJobProgressManagerListener listener = listeners[i];	564	if (isNeverDisplaying(info.getJob(), listener.showsDebug()))
563	if (isNeverDisplaying(info.getJob(), listener.showsDebug()))	565	continue;
564	continue;
565		566
566	if (listener.showsDebug() \|\| group.isActive())	567	if (listener.showsDebug() \|\| group.isActive())
567	listener.refreshGroup(group);	568	listener.refreshGroup(group);
568	else	569	else
569	listener.removeGroup(group);	570	listener.removeGroup(group);
570	}
571	}	571	}
572		572
573	}	573	}
Lines 641-657 Link Here
641	* @param listener	641	* @param listener
642	*/	642	*/
643	void addListener(IJobProgressManagerListener listener) {	643	void addListener(IJobProgressManagerListener listener) {
644		644	// if the listener is already held, ignore
		645	IJobProgressManagerListener[] listenersTemp = listeners;
		646	for (int i = 0; i < listenersTemp.length; i++) {
		647	if (listenersTemp[i].equals(listener)) return;
		648	}
		649	// add the new listener
645	synchronized (listenersKey) {	650	synchronized (listenersKey) {
646	ArrayList newListeners = new ArrayList(listeners.length + 1);	651	IJobProgressManagerListener[] newListeners = new IJobProgressManagerListener[listeners.length+1];
647	for (int i = 0; i < listeners.length; i++) {	652	for (int i = 0; i < listeners.length; i++) {
648	newListeners.add(listeners[i]);	653	newListeners[i] = listeners[i];
649	}	654	}
650	newListeners.add(listener);	655	newListeners[listeners.length] = listener;
651	listeners = new IJobProgressManagerListener[newListeners.size()];	656	listeners = newListeners;
652	newListeners.toArray(listeners);
653	}	657	}
654
655	}	658	}
656		659
657	/**	660	/**
Lines 661-676 Link Here
661	* @param listener	664	* @param listener
662	*/	665	*/
663	void removeListener(IJobProgressManagerListener listener) {	666	void removeListener(IJobProgressManagerListener listener) {
		667	// if the listener is not held, ignore
		668	boolean listenerHeld = false;
		669	IJobProgressManagerListener[] listenersTemp = listeners;
		670	for (int i = 0; i < listenersTemp.length; i++) {
		671	if (listenersTemp[i].equals(listener)) {
		672	listenerHeld = true;
		673	break;
		674	}
		675	}
		676	if (!listenerHeld) return;
		677	// remove the listener
664	synchronized (listenersKey) {	678	synchronized (listenersKey) {
665	ArrayList newListeners = new ArrayList();	679	IJobProgressManagerListener[] newListeners = new IJobProgressManagerListener[listeners.length-1];
666	for (int i = 0; i < listeners.length; i++) {	680	for (int i=0,j=0; i < listeners.length; i++) {
667	if (listeners[i].equals(listener)) {	681	if (listeners[i].equals(listener)) {
668	continue;	682	continue;
669	}	683	}
670	newListeners.add(listeners[i]);	684	newListeners[j++] = listeners[i];
671	}	685	}
672	listeners = new IJobProgressManagerListener[newListeners.size()];	686	listeners = listenersTemp;
673	newListeners.toArray(listeners);
674	}	687	}
675	}	688	}
676		689
Lines 711-722 Link Here
711	refreshGroup(group);	724	refreshGroup(group);
712	}	725	}
713		726
714	synchronized (listenersKey) {	727	IJobProgressManagerListener[] listenersTemp = listeners;
715	for (int i = 0; i < listeners.length; i++) {	728	for (int i = 0; i < listenersTemp.length; i++) {
716	IJobProgressManagerListener listener = listeners[i];	729	IJobProgressManagerListener listener = listenersTemp[i];
717	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {	730	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
718	listener.refreshJobInfo(info);	731	listener.refreshJobInfo(info);
719	}
720	}	732	}
721	}	733	}
722	}	734	}
Lines 727-737 Link Here
727	* @param info	739	* @param info
728	*/	740	*/
729	public void refreshGroup(GroupInfo info) {	741	public void refreshGroup(GroupInfo info) {
730		742	IJobProgressManagerListener[] listenersTemp = listeners;
731	synchronized (listenersKey) {	743	for (int i = 0; i < listenersTemp.length; i++) {
732	for (int i = 0; i < listeners.length; i++) {	744	listenersTemp[i].refreshGroup(info);
733	listeners[i].refreshGroup(info);
734	}
735	}	745	}
736	}	746	}
737		747
Lines 742-751 Link Here
742	public void refreshAll() {	752	public void refreshAll() {
743		753
744	pruneStaleJobs();	754	pruneStaleJobs();
745	synchronized (listenersKey) {	755	IJobProgressManagerListener[] listenersTemp = listeners;
746	for (int i = 0; i < listeners.length; i++) {	756	for (int i = 0; i < listenersTemp.length; i++) {
747	listeners[i].refreshAll();	757	listenersTemp[i].refreshAll();
748	}
749	}	758	}
750		759
751	}	760	}
Lines 766-777 Link Here
766	}	775	}
767	}	776	}
768		777
769	synchronized (listenersKey) {	778	IJobProgressManagerListener[] listenersTemp = listeners;
770	for (int i = 0; i < listeners.length; i++) {	779	for (int i = 0; i < listenersTemp.length; i++) {
771	IJobProgressManagerListener listener = listeners[i];	780	IJobProgressManagerListener listener = listenersTemp[i];
772	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {	781	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
773	listener.removeJob(info);	782	listener.removeJob(info);
774	}
775	}	783	}
776	}	784	}
777		785
Lines 784-794 Link Here
784	* GroupInfo	792	* GroupInfo
785	*/	793	*/
786	public void removeGroup(GroupInfo group) {	794	public void removeGroup(GroupInfo group) {
787		795	IJobProgressManagerListener[] listenersTemp = listeners;
788	synchronized (listenersKey) {	796	for (int i = 0; i < listenersTemp.length; i++) {
789	for (int i = 0; i < listeners.length; i++) {	797	listenersTemp[i].removeGroup(group);
790	listeners[i].removeGroup(group);
791	}
792	}	798	}
793	}	799	}
794		800
Lines 804-815 Link Here
804	}	810	}
805		811
806	jobs.put(info.getJob(), info);	812	jobs.put(info.getJob(), info);
807	synchronized (listenersKey) {	813	IJobProgressManagerListener[] listenersTemp = listeners;
808	for (int i = 0; i < listeners.length; i++) {	814	for (int i = 0; i < listenersTemp.length; i++) {
809	IJobProgressManagerListener listener = listeners[i];	815	IJobProgressManagerListener listener = listenersTemp[i];
810	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {	816	if (!isCurrentDisplaying(info.getJob(), listener.showsDebug())) {
811	listener.addJob(info);	817	listener.addJob(info);
812	}
813	}	818	}
814	}	819	}
815	}	820	}