diff --git a/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/DirtyRegionProcessor.java b/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/DirtyRegionProcessor.java
index f9166fd..0149033 100644
--- a/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/DirtyRegionProcessor.java
+++ b/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/DirtyRegionProcessor.java
@@ -211,18 +211,20 @@
 	 * @param resource
 	 */
 	private synchronized void addRequest(DirtyRegion newDirtyRegion) {
+		// NOTE: This method is called a lot so make sure it's fast
 		List dirtyRegionQueue = getDirtyRegionQueue();
-		// if we already have a request which contains the new request,
-		// discare the new request
-		int size = dirtyRegionQueue.size();
-		for (int i = 0; i < size; i++) {
-			if (contains((DirtyRegion) dirtyRegionQueue.get(i), newDirtyRegion))
-				return;
-		}
-		// if new request is contains any existing requests,
-		// remove those
 		for (Iterator it = dirtyRegionQueue.iterator(); it.hasNext();) {
-			if (contains(newDirtyRegion, (DirtyRegion) it.next()))
+			// go through list of existing dirty regions and check if any
+			// dirty regions need to be discarded
+			DirtyRegion currentExisting = (DirtyRegion) it.next();
+			DirtyRegion outer = getOuterRegion(currentExisting, newDirtyRegion);
+			// if we already have a request which contains the new request,
+			// discard the new request
+			if (outer == currentExisting)
+				return;
+			// if new request contains any existing requests,
+			// remove those
+			if (outer == newDirtyRegion)
 				it.remove();
 		}
 		dirtyRegionQueue.add(newDirtyRegion);
@@ -273,14 +275,39 @@
 	}
 
 	/**
+	 * @deprecated use getOuterRegion() instead
+	 */
+	protected boolean contains(DirtyRegion root, DirtyRegion possible) {
+		// remove method post wtp 1.5.1
+		return isContained(root, possible);
+	}
+
+	/**
+	 * Used to determine if one dirty region contains the other and if so,
+	 * which is the one that contains it.
+	 * 
+	 * @param root
+	 * @param possible
+	 * @return the outer dirty region if it contains the other dirty region,
+	 *         null otherwise
+	 */
+	protected DirtyRegion getOuterRegion(DirtyRegion root, DirtyRegion possible) {
+		DirtyRegion outer = null;
+		if (isContained(root, possible))
+			outer = root;
+		else if (isContained(possible, root))
+			outer = possible;
+		return outer;
+	}
+
+	/**
 	 * Used to determine of a "possible" dirty region can be discarded in
 	 * favor of using just the "root" dirty region.
 	 * 
 	 * @return if the root dirty region contains possible, return true,
 	 *         otherwise return false
 	 */
-	protected boolean contains(DirtyRegion root, DirtyRegion possible) {
-
+	private boolean isContained(DirtyRegion root, DirtyRegion possible) {
 		int rootStart = root.getOffset();
 		int rootEnd = rootStart + root.getLength();
 		int possStart = possible.getOffset();
diff --git a/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/StructuredRegionProcessor.java b/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/StructuredRegionProcessor.java
index b93bf19..220127b 100644
--- a/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/StructuredRegionProcessor.java
+++ b/bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/reconcile/StructuredRegionProcessor.java
@@ -87,43 +87,149 @@
 	private IModelLifecycleListener fLifeCycleListener = new ModelLifecycleListener();
 
 	/**
-	 * @see org.eclipse.wst.sse.ui.internal.reconcile.DirtyRegionProcessor#contains(org.eclipse.jface.text.reconciler.DirtyRegion,
-	 *      org.eclipse.jface.text.reconciler.DirtyRegion)
+	 * @deprecated use getOuterRegion() instead
 	 */
 	protected boolean contains(DirtyRegion root, DirtyRegion possible) {
+		// remove method post wtp 1.5.1
 		// this method is a performance hit
 		// look for alternatives
 
-		boolean contains = false;
-		IStructuredModel sModel = getStructuredModelForRead(getDocument());
-		try {
-			if (sModel != null) {
-				IndexedRegion rootRegion = sModel.getIndexedRegion(root.getOffset());
-				IndexedRegion rootRegion2 = sModel.getIndexedRegion(root.getOffset() + root.getLength());
-				IndexedRegion possRegion = sModel.getIndexedRegion(possible.getOffset());
-				IndexedRegion possRegion2 = sModel.getIndexedRegion(possible.getOffset() + possible.getLength());
-				if (rootRegion != null && possRegion != null) {
-					int rootStart = rootRegion.getStartOffset();
-					int rootEnd = rootRegion2 != null ? rootRegion2.getEndOffset() : getDocument().getLength();
-					int possStart = possRegion.getStartOffset();
-					int possEnd = possRegion2 != null ? possRegion2.getEndOffset() : getDocument().getLength();
+		// call super to just check if possible is already contained within
+		// root based on offsets
+		boolean contains = super.contains(root, possible);
+		if (!contains) {
+			IStructuredModel sModel = getStructuredModelForRead(getDocument());
+			try {
+				if (sModel != null) {
+					// first just check if possregion appears after rootregion
+					IndexedRegion rootRegion = sModel.getIndexedRegion(root.getOffset());
+					IndexedRegion possRegion = sModel.getIndexedRegion(possible.getOffset());
+					if (rootRegion != null && possRegion != null) {
+						int rootStart = rootRegion.getStartOffset();
+						int possStart = possRegion.getStartOffset();
+						if (rootStart <= possStart) {
+							// then check if rootregion's end appears after
+							// possregion's end
+							IndexedRegion rootRegion2 = sModel.getIndexedRegion(root.getOffset() + root.getLength());
+							int rootEnd = rootRegion2 != null ? rootRegion2.getEndOffset() : getDocument().getLength();
+							IndexedRegion possRegion2 = sModel.getIndexedRegion(possible.getOffset() + possible.getLength());
+							int possEnd = possRegion2 != null ? possRegion2.getEndOffset() : getDocument().getLength();
 
-					if (rootStart <= possStart && rootEnd >= possEnd) {
-						contains = true;
+							if (rootEnd >= possEnd) {
+								contains = true;
+							}
+							if (DEBUG)
+								System.out.println("checking if [" + rootStart + ":" + rootEnd + "] contains [" + possStart + ":" + possEnd + "] ... " + contains); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+						}
 					}
-
-					if (DEBUG)
-						System.out.println("checking if [" + rootStart + ":" + rootEnd + "] contains [" + possStart + ":" + possEnd + "] ... " + contains); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
 				}
 			}
-		}
-		finally {
-			if (sModel != null)
-				sModel.releaseFromRead();
+			finally {
+				if (sModel != null)
+					sModel.releaseFromRead();
+			}
 		}
 		return contains;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.wst.sse.ui.internal.reconcile.DirtyRegionProcessor#getOuterRegion(org.eclipse.jface.text.reconciler.DirtyRegion,
+	 *      org.eclipse.jface.text.reconciler.DirtyRegion)
+	 */
+	protected DirtyRegion getOuterRegion(DirtyRegion root, DirtyRegion possible) {
+		// first try simple region check if one region contains the other
+		DirtyRegion outer = super.getOuterRegion(root, possible);
+		if (outer == null) {
+			// now compare nodes
+			IStructuredModel sModel = getStructuredModelForRead(getDocument());
+			try {
+				if (sModel != null) {
+					IndexedRegion rootRegion = sModel.getIndexedRegion(root.getOffset());
+					IndexedRegion possRegion = sModel.getIndexedRegion(possible.getOffset());
+					if (rootRegion != null && possRegion != null) {
+						int rootStart = rootRegion.getStartOffset();
+						int possStart = possRegion.getStartOffset();
+						// first just check if rootregion starts before
+						// possregion
+						if (rootStart <= possStart) {
+							// check if possregion is inside rootregion
+							outer = _getOuterRegion(root, possible, sModel, rootStart, possStart);
+						}
+						else {
+							// otherwise if rootregion is inside possregion
+							outer = _getOuterRegion(possible, root, sModel, possStart, rootStart);
+						}
+					}
+				}
+			}
+			finally {
+				if (sModel != null)
+					sModel.releaseFromRead();
+			}
+		}
+		return outer;
+	}
+
+	/**
+	 * Assumes that when this method is called, region1's node start offset >=
+	 * region2's node start offset. Determines if region1 contains region2 or
+	 * vice versa. Returns region1 if:
+	 * <ul>
+	 * <li>region1's node region == region2's node region</li>
+	 * <li>region1's node region contains region2's node region</li>
+	 * </ul>
+	 * Returns region2 if:
+	 * <ul>
+	 * <li>region1's node region and region2's node region starts at same
+	 * offset but region2's node region is longer</li>
+	 * </ul>
+	 * Returns null otherwise.
+	 * 
+	 * @param region1
+	 * @param region2
+	 * @param sModel
+	 * @param region1NodeStart
+	 * @param region2NodeStart
+	 * @return outer dirty region or null if none exists.
+	 */
+	private DirtyRegion _getOuterRegion(DirtyRegion region1, DirtyRegion region2, IStructuredModel sModel, int region1NodeStart, int region2NodeStart) {
+		DirtyRegion outer = null;
+		int region1NodeEnd = -1;
+		int region2NodeEnd = -1;
+		// then check if region1's end appears after
+		// region2's end
+		IndexedRegion region1EndNode = sModel.getIndexedRegion(region1.getOffset() + region1.getLength());
+		if (region1EndNode == null) {
+			// if no end, just assume region spans all the
+			// way to the end so it includes other region
+			outer = region1;
+		}
+		else {
+			region1NodeEnd = region1EndNode.getEndOffset();
+			IndexedRegion region2EndNode = sModel.getIndexedRegion(region2.getOffset() + region2.getLength());
+			region2NodeEnd = region2EndNode != null ? region2EndNode.getEndOffset() : getDocument().getLength();
+			if (region1NodeEnd >= region2NodeEnd) {
+				// root contains or is equal to possible
+				outer = region1;
+			}
+			else if (region1NodeStart == region2NodeStart && region2NodeEnd >= region1NodeEnd) {
+				// possible contains root because they
+				// both start at same place but possible
+				// is longer
+				outer = region2;
+			}
+		}
+		if (DEBUG) {
+			if (outer != null)
+				System.out.println("checking if [" + region1NodeStart + ":" + region1NodeEnd + "] contains [" + region2NodeStart + ":" + region2NodeEnd + "] ... " + outer.toString()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+			else
+				System.out.println("checking if [" + region1NodeStart + ":" + region1NodeEnd + "] contains [" + region2NodeStart + ":" + region2NodeEnd + "] ... NO CONTAIN"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+		}
+		return outer;
+	}
+
 	/**
 	 * We already know content type from when we created the model, so just
 	 * use that.