Merge branch 'eclipse-platform:master' into master

Author: fedejeanne

ant/org.eclipse.ant.launching/build.properties

@@ -34,9 +34,7 @@ extra.lib/loggers.jar = lib/antdebug.jar
 #output.lib/antdebug.jar = common_bin/
 #source.lib/remote.jar = remote/
 #output.lib/remote.jar = remote_bin/
-src.includes = about.html,\
-               remote/,\
-               common/
+src.includes = about.html
 javacWarnings..=-unavoidableGenericProblems
 
 # Maven properties, see https://github.com/eclipse/tycho/wiki/Tycho-Pomless

ant/org.eclipse.ant.ui/build.properties

@@ -21,9 +21,7 @@ output.lib/antrunner.jar = ant_runner_support_bin/
 #source.lib/remoteAnt.jar = Remote Ant Support/
 #output.lib/remoteAnt.jar = remote_support_bin/
 src.includes = about.html,\
-               about_files/,\
-               Remote Ant Support/
-
+               about_files/
 bin.includes = icons/,\
                plugin.properties,\
                plugin.xml,\

debug/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/breakpoints/BreakpointEnablement.java

@@ -13,11 +13,15 @@
  *******************************************************************************/
 package org.eclipse.debug.internal.ui.views.breakpoints;
 
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+
 import org.eclipse.core.resources.IMarkerDelta;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.debug.core.DebugPlugin;
-import org.eclipse.debug.core.IBreakpointListener;
+import org.eclipse.debug.core.IBreakpointsListener;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.ui.AbstractBreakpointOrganizerDelegate;
 import org.eclipse.debug.ui.BreakpointTypeCategory;
@@ -26,18 +30,22 @@
  * Breakpoint organizers for breakpoint types based on breakpoint enablement
  * state.
  */
-public class BreakpointEnablement extends AbstractBreakpointOrganizerDelegate implements IBreakpointListener {
+public class BreakpointEnablement extends AbstractBreakpointOrganizerDelegate implements IBreakpointsListener {
 
 	private final BreakpointTypeCategory ENABLED = new BreakpointTypeCategory("Enabled", 0); //$NON-NLS-1$
 	private final BreakpointTypeCategory DISABLED = new BreakpointTypeCategory("Disabled", 1); //$NON-NLS-1$
 
+	private final Map<IBreakpoint, Boolean> breakpointCache;
+
 	public BreakpointEnablement() {
 		DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
+		breakpointCache = Collections.synchronizedMap(new WeakHashMap<>());
 	}
 
 	@Override
 	public void dispose() {
 		DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(this);
+		breakpointCache.clear();
 	}
 
 	@Override
@@ -49,6 +57,7 @@ public IAdaptable[] getCategories(IBreakpoint breakpoint) {
 			} else {
 				categories = new IAdaptable[] { DISABLED };
 			}
+			breakpointCache.put(breakpoint, breakpoint.isEnabled());
 			return categories;
 		} catch (CoreException e) {
 			DebugPlugin.log(e);
@@ -57,15 +66,40 @@ public IAdaptable[] getCategories(IBreakpoint breakpoint) {
 	}
 
 	@Override
-	public void breakpointAdded(IBreakpoint breakpoint) {
+	public void breakpointsAdded(IBreakpoint[] breakpoints) {
+		for (IBreakpoint breakpoint : breakpoints) {
+			try {
+				breakpointCache.put(breakpoint, breakpoint.isEnabled());
+			} catch (CoreException e) {
+				DebugPlugin.log(e);
+			}
+		}
 	}
 
 	@Override
-	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
+	public void breakpointsRemoved(IBreakpoint[] breakpoints, IMarkerDelta[] deltas) {
+		for (IBreakpoint breakpoint : breakpoints) {
+			breakpointCache.remove(breakpoint);
+		}
 	}
 
 	@Override
-	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
-		fireCategoryChanged(ENABLED);
+	public void breakpointsChanged(IBreakpoint[] breakpoints, IMarkerDelta[] deltas) {
+		boolean updateCategories = false;
+		for (IBreakpoint breakpoint : breakpoints) {
+			try {
+				boolean isEnabled = breakpoint.isEnabled();
+				Boolean wasEnabled = breakpointCache.get(breakpoint);
+				if (wasEnabled == null || wasEnabled != isEnabled) {
+					breakpointCache.put(breakpoint, isEnabled);
+					updateCategories = true;
+				}
+			} catch (CoreException e) {
+				DebugPlugin.log(e);
+			}
+		}
+		if (updateCategories) {
+			fireCategoryChanged(ENABLED);
+		}
 	}
 }

debug/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/launch/DebugElementHelper.java

@@ -13,8 +13,8 @@
  *******************************************************************************/
 package org.eclipse.debug.internal.ui.views.launch;
 
-import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.eclipse.debug.core.model.Breakpoint;
 import org.eclipse.debug.internal.ui.DelegatingModelPresentation;
@@ -44,7 +44,7 @@ public class DebugElementHelper {
 	private static DelegatingModelPresentation fgPresenetation;
 
 	// map of images to image descriptors
-	private static Map<Image, ImageDescriptor> fgImages = new HashMap<>();
+	private static Map<Image, ImageDescriptor> fgImages = new ConcurrentHashMap<>();
 
 	/**
 	 * Disposes this adapter

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/AbstractDataTreeNode.java

@@ -50,10 +50,11 @@ public abstract class AbstractDataTreeNode {
 	 */
 	AbstractDataTreeNode(String name, AbstractDataTreeNode[] children) {
 		this.name = name;
-		if (children == null || children.length == 0)
+		if (children == null || children.length == 0) {
 			this.children = AbstractDataTreeNode.NO_CHILDREN;
-		else
+		} else {
 			this.children = children;
+		}
 	}
 
 	/**
@@ -84,8 +85,9 @@ AbstractDataTreeNode asReverseComparisonNode(IComparator comparator) {
 	static AbstractDataTreeNode[] assembleWith(AbstractDataTreeNode[] oldNodes, AbstractDataTreeNode[] newNodes, boolean keepDeleted) {
 
 		// Optimize the common case where the new list is empty.
-		if (newNodes.length == 0)
+		if (newNodes.length == 0) {
 			return oldNodes;
+		}
 
 		// Can't just return newNodes if oldNodes has length 0
 		// because newNodes may contain deleted nodes.
@@ -198,8 +200,9 @@ AbstractDataTreeNode assembleWith(AbstractDataTreeNode node) {
 		}
 		if (this.isDelta()) {
 			AbstractDataTreeNode[] assembledChildren = assembleWith(children, node.children, true);
-			if (this.hasData())
+			if (this.hasData()) {
 				return new DataDeltaNode(name, this.getData(), assembledChildren);
+			}
 			return new NoDataDeltaNode(name, assembledChildren);
 		}
 		AbstractDataTreeNode[] assembledChildren = assembleWith(children, node.children, false);
@@ -271,10 +274,11 @@ AbstractDataTreeNode childAtIgnoreCase(String localName) {
 		for (AbstractDataTreeNode element : children) {
 			if (element.getName().equalsIgnoreCase(localName)) {
 				//if we find a deleted child, keep looking for a real child
-				if (element.isDeleted())
+				if (element.isDeleted()) {
 					result = element;
-				else
+				} else {
 					return element;
+				}
 			}
 		}
 		return result;
@@ -502,8 +506,9 @@ boolean isEmptyDelta() {
 	String[] namesOfChildren() {
 		String names[] = new String[children.length];
 		/* copy child names (Reverse loop optimized) */
-		for (int i = children.length; --i >= 0;)
+		for (int i = children.length; --i >= 0;) {
 			names[i] = children[i].getName();
+		}
 		return names;
 	}
 
@@ -538,8 +543,9 @@ void setName(String s) {
 	 */
 	protected static AbstractDataTreeNode[] simplifyWithParent(AbstractDataTreeNode[] nodes, IPath key, DeltaDataTree parent, IComparator comparer) {
 		int nodeCount = nodes.length;
-		if (nodeCount == 0)
+		if (nodeCount == 0) {
 			return NO_CHILDREN;
+		}
 		AbstractDataTreeNode[] simplifiedNodes = new AbstractDataTreeNode[nodeCount];
 		int simplifiedCount = 0;
 		for (int i = 0; i < nodeCount; ++i) {
@@ -577,9 +583,11 @@ public void storeStrings(StringPool set) {
 		name = set.add(name);
 		//copy children pointer in case of concurrent modification
 		AbstractDataTreeNode[] nodes = children;
-		if (nodes != null)
-			for (int i = nodes.length; --i >= 0;)
+		if (nodes != null) {
+			for (int i = nodes.length; --i >= 0;) {
 				nodes[i].storeStrings(set);
+			}
+		}
 	}
 
 	/**

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DataDeltaNode.java

@@ -100,8 +100,9 @@ boolean isDelta() {
 	AbstractDataTreeNode simplifyWithParent(IPath key, DeltaDataTree parent, IComparator comparer) {
 		AbstractDataTreeNode[] simplifiedChildren = simplifyWithParent(children, key, parent, comparer);
 		/* don't compare root nodes */
-		if (!key.isRoot() && comparer.compare(parent.getData(key), data) == 0)
+		if (!key.isRoot() && comparer.compare(parent.getData(key), data) == 0) {
 			return new NoDataDeltaNode(name, simplifiedChildren);
+		}
 		return new DataDeltaNode(name, data, simplifiedChildren);
 	}
 

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DataTreeNode.java

@@ -55,8 +55,9 @@ public DataTreeNode(String name, Object data, AbstractDataTreeNode[] children) {
 	 */
 	@Override
 	AbstractDataTreeNode asBackwardDelta(DeltaDataTree myTree, DeltaDataTree parentTree, IPath key) {
-		if (parentTree.includes(key))
+		if (parentTree.includes(key)) {
 			return parentTree.copyCompleteSubtree(key);
+		}
 		return new DeletedNode(name);
 	}
 
@@ -116,8 +117,9 @@ AbstractDataTreeNode compareWith(DataTreeNode other, IComparator comparator) {
 
 	@Override
 	AbstractDataTreeNode compareWithParent(IPath key, DeltaDataTree parent, IComparator comparator) {
-		if (!parent.includes(key))
+		if (!parent.includes(key)) {
 			return convertToAddedComparisonNode(this, NodeComparison.K_ADDED);
+		}
 		DataTreeNode inParent = (DataTreeNode) parent.copyCompleteSubtree(key);
 		return inParent.compareWith(this, comparator);
 	}
@@ -218,47 +220,52 @@ protected static AbstractDataTreeNode[] forwardDeltaWith(AbstractDataTreeNode[]
 				AbstractDataTreeNode deltaNode = forwardDeltaWithOrNullIfEqual(oldNodes[oldIndex++], newNodes[newIndex++], comparer);
 				if (deltaNode != null) {
 					if (numChildDeltas >= childDeltaMax) {
-						if (childDeltas == null)
+						if (childDeltas == null) {
 							childDeltas = new AbstractDataTreeNode[childDeltaMax = 5];
-						else
+						} else {
 							System.arraycopy(childDeltas, 0, childDeltas = new AbstractDataTreeNode[childDeltaMax = childDeltaMax * 2 + 1], 0, numChildDeltas);
+						}
 					}
 					childDeltas[numChildDeltas++] = deltaNode;
 				}
 			} else if (compare < 0) {
 				if (numChildDeltas >= childDeltaMax) {
-					if (childDeltas == null)
+					if (childDeltas == null) {
 						childDeltas = new AbstractDataTreeNode[childDeltaMax = 5];
-					else
+					} else {
 						System.arraycopy(childDeltas, 0, childDeltas = new AbstractDataTreeNode[childDeltaMax = childDeltaMax * 2 + 1], 0, numChildDeltas);
+					}
 				}
 				childDeltas[numChildDeltas++] = new DeletedNode(oldName);
 				oldIndex++;
 			} else {
 				if (numChildDeltas >= childDeltaMax) {
-					if (childDeltas == null)
+					if (childDeltas == null) {
 						childDeltas = new AbstractDataTreeNode[childDeltaMax = 5];
-					else
+					} else {
 						System.arraycopy(childDeltas, 0, childDeltas = new AbstractDataTreeNode[childDeltaMax = childDeltaMax * 2 + 1], 0, numChildDeltas);
+					}
 				}
 				childDeltas[numChildDeltas++] = newNodes[newIndex++];
 			}
 		}
 		while (oldIndex < oldNodes.length) {
 			if (numChildDeltas >= childDeltaMax) {
-				if (childDeltas == null)
+				if (childDeltas == null) {
 					childDeltas = new AbstractDataTreeNode[childDeltaMax = 5];
-				else
+				} else {
 					System.arraycopy(childDeltas, 0, childDeltas = new AbstractDataTreeNode[childDeltaMax = childDeltaMax * 2 + 1], 0, numChildDeltas);
+				}
 			}
 			childDeltas[numChildDeltas++] = new DeletedNode(oldNodes[oldIndex++].name);
 		}
 		while (newIndex < newNodes.length) {
 			if (numChildDeltas >= childDeltaMax) {
-				if (childDeltas == null)
+				if (childDeltas == null) {
 					childDeltas = new AbstractDataTreeNode[childDeltaMax = 5];
-				else
+				} else {
 					System.arraycopy(childDeltas, 0, childDeltas = new AbstractDataTreeNode[childDeltaMax = childDeltaMax * 2 + 1], 0, numChildDeltas);
+				}
 			}
 			childDeltas[numChildDeltas++] = newNodes[newIndex++];
 		}
@@ -346,8 +353,9 @@ public void storeStrings(StringPool set) {
 		super.storeStrings(set);
 		//copy data for thread safety
 		Object o = data;
-		if (o instanceof IStringPoolParticipant)
+		if (o instanceof IStringPoolParticipant) {
 			((IStringPoolParticipant) o).shareStrings(set);
+		}
 	}
 
 	@Override

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/dtree/DeletedNode.java

@@ -36,8 +36,9 @@ public class DeletedNode extends AbstractDataTreeNode {
 	 */
 	@Override
 	AbstractDataTreeNode asBackwardDelta(DeltaDataTree myTree, DeltaDataTree parentTree, IPath key) {
-		if (parentTree.includes(key))
+		if (parentTree.includes(key)) {
 			return parentTree.copyCompleteSubtree(key);
+		}
 		return this;
 	}
 
@@ -66,8 +67,9 @@ AbstractDataTreeNode compareWithParent(IPath key, DeltaDataTree parent, ICompara
 		 * be a corresponding node in the parent.  Deleted nodes can live
 		 * in isolation.
 		 */
-		if (parent.includes(key))
+		if (parent.includes(key)) {
 			return convertToRemovedComparisonNode(parent.copyCompleteSubtree(key), NodeComparison.K_REMOVED);
+		}
 		// Node doesn't exist in either tree.  Return an empty comparison.
 		// Empty comparisons are omitted from the delta.
 		return new DataTreeNode(key.lastSegment(), new NodeComparison(null, null, 0, 0));
@@ -95,8 +97,9 @@ boolean isDeleted() {
 	 */
 	@Override
 	AbstractDataTreeNode simplifyWithParent(IPath key, DeltaDataTree parent, IComparator comparer) {
-		if (parent.includes(key))
+		if (parent.includes(key)) {
 			return this;
+		}
 		return new NoDataDeltaNode(name);
 	}