*** empty log message ***branch_20031205_synchWorkFlowEnhancements

8 files changed, 84 insertions, 78 deletions

diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSCompareSubscriber.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSCompareSubscriber.java
index 6f496f55d..80ee96bbf 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSCompareSubscriber.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSCompareSubscriber.java
@@ -16,9 +16,11 @@ import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.QualifiedName;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.subscribers.*;
+import org.eclipse.team.core.synchronize.IResourceVariant;
 import org.eclipse.team.core.synchronize.SyncInfo;
-import org.eclipse.team.internal.core.subscribers.caches.SessionResourceVariantTree;
-import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTree;
+import org.eclipse.team.internal.ccvs.core.syncinfo.CVSBaseSynchronizationCache;
+import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore;
+import org.eclipse.team.internal.core.subscribers.caches.SessionResourceVariantByteStore;
 
 /**
  * This subscriber is used when comparing the local workspace with its
@@ -30,7 +32,7 @@ public class CVSCompareSubscriber extends CVSSyncTreeSubscriber implements ISubs
 	private static final String UNIQUE_ID_PREFIX = "compare-"; //$NON-NLS-1$
 	
 	private CVSTag tag;
-	private SessionResourceVariantTree remoteSynchronizer;
+	private SessionResourceVariantByteStore remoteSynchronizer;
 	private IResource[] resources;
 	
 	public CVSCompareSubscriber(IResource[] resources, CVSTag tag) {
@@ -41,7 +43,7 @@ public class CVSCompareSubscriber extends CVSSyncTreeSubscriber implements ISubs
 	}
 
 	private void initialize() {
-		remoteSynchronizer = new SessionResourceVariantTree();
+		remoteSynchronizer = new SessionResourceVariantByteStore();
 		CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber().addListener(this);
 	}
 
@@ -73,7 +75,7 @@ public class CVSCompareSubscriber extends CVSSyncTreeSubscriber implements ISubs
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getBaseSynchronizationCache()
 	 */
-	protected ResourceVariantTree getBaseSynchronizationCache() {
+	protected ResourceVariantByteStore getBaseSynchronizationCache() {
 		// No base cache needed since it's a two way compare
 		return null;
 	}
@@ -81,7 +83,7 @@ public class CVSCompareSubscriber extends CVSSyncTreeSubscriber implements ISubs
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getRemoteSynchronizationCache()
 	 */
-	protected ResourceVariantTree getRemoteSynchronizationCache() {
+	protected ResourceVariantByteStore getRemoteSynchronizationCache() {
 		return remoteSynchronizer;
 	}
 	
@@ -182,9 +184,16 @@ public class CVSCompareSubscriber extends CVSSyncTreeSubscriber implements ISubs
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getSyncInfo(org.eclipse.core.resources.IResource)
 	 */
 	public SyncInfo getSyncInfo(IResource resource) throws TeamException {
+		// TODO: Temporary measure to avoid showing all local as additions before the refresh completes
 		if (remoteSynchronizer.isEmpty()) {
-			return null;
+			// Use the base as the remote so that outgoing changes are included
+			return new CVSSyncInfo(resource, null, getBase(resource), this);
 		}
 		return super.getSyncInfo(resource);
 	}
+
+	private CVSBaseSynchronizationCache baseCache = new CVSBaseSynchronizationCache();
+	private IResourceVariant getBase(IResource resource) throws TeamException {
+		return getRemoteResource(resource, baseCache);
+	}
 }
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSMergeSubscriber.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSMergeSubscriber.java
index 26851a8bb..500ce8d47 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSMergeSubscriber.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSMergeSubscriber.java
@@ -23,8 +23,8 @@ import org.eclipse.team.internal.ccvs.core.resources.RemoteFile;
 import org.eclipse.team.internal.ccvs.core.syncinfo.CVSSynchronizationCache;
 import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
 import org.eclipse.team.internal.ccvs.core.util.Util;
-import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTree;
-import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantTree;
+import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore;
+import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantByteStore;
 
 /**
  * A CVSMergeSubscriber is responsible for maintaining the remote trees for a merge into
@@ -48,9 +48,9 @@ public class CVSMergeSubscriber extends CVSSyncTreeSubscriber implements IResour
 	
 	private CVSTag start, end;
 	private List roots;
-	private ResourceVariantTree remoteSynchronizer;
-	private PersistantResourceVariantTree mergedSynchronizer;
-	private ResourceVariantTree baseSynchronizer;
+	private CVSSynchronizationCache remoteSynchronizer;
+	private PersistantResourceVariantByteStore mergedSynchronizer;
+	private CVSSynchronizationCache baseSynchronizer;
 	
 	public CVSMergeSubscriber(IResource[] roots, CVSTag start, CVSTag end) {		
 		this(getUniqueId(), roots, start, end);
@@ -77,7 +77,7 @@ public class CVSMergeSubscriber extends CVSSyncTreeSubscriber implements IResour
 		String syncKeyPrefix = id.getLocalName();
 		remoteSynchronizer = new CVSSynchronizationCache(new QualifiedName(SYNC_KEY_QUALIFIER, syncKeyPrefix + end.getName()));
 		baseSynchronizer = new CVSSynchronizationCache(new QualifiedName(SYNC_KEY_QUALIFIER, syncKeyPrefix + start.getName()));
-		mergedSynchronizer = new PersistantResourceVariantTree(new QualifiedName(SYNC_KEY_QUALIFIER, syncKeyPrefix + "0merged")); //$NON-NLS-1$
+		mergedSynchronizer = new PersistantResourceVariantByteStore(new QualifiedName(SYNC_KEY_QUALIFIER, syncKeyPrefix + "0merged")); //$NON-NLS-1$
 		
 		ResourcesPlugin.getWorkspace().addResourceChangeListener(this);
 		CVSProviderPlugin.getPlugin().getCVSWorkspaceSubscriber().addListener(this);
@@ -100,7 +100,7 @@ public class CVSMergeSubscriber extends CVSSyncTreeSubscriber implements IResour
 	private void internalMerged(IResource resource) throws TeamException {
 		byte[] remoteBytes = remoteSynchronizer.getBytes(resource);
 		if (remoteBytes == null) {
-			mergedSynchronizer.setVariantDoesNotExist(resource);
+			mergedSynchronizer.deleteBytes(resource);
 		} else {
 			mergedSynchronizer.setBytes(resource, remoteBytes);
 		}
@@ -238,14 +238,14 @@ public class CVSMergeSubscriber extends CVSSyncTreeSubscriber implements IResour
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getBaseSynchronizationCache()
 	 */
-	protected ResourceVariantTree getBaseSynchronizationCache() {
+	protected ResourceVariantByteStore getBaseSynchronizationCache() {
 		return baseSynchronizer;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getRemoteSynchronizationCache()
 	 */
-	protected ResourceVariantTree getRemoteSynchronizationCache() {
+	protected ResourceVariantByteStore getRemoteSynchronizationCache() {
 		return remoteSynchronizer;
 	}
 	
@@ -326,6 +326,11 @@ public class CVSMergeSubscriber extends CVSSyncTreeSubscriber implements IResour
 			if (parentBytes != null) {
 				return RemoteFile.fromBytes(resource, mergedBytes, parentBytes);
 			}
+		} else {
+			// A deletion was merged so return null for the base
+			if (mergedSynchronizer.isVariantKnown(resource)) {
+				return null;
+			}
 		}
 		return super.getBaseResource(resource);
 	}
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSSyncTreeSubscriber.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSSyncTreeSubscriber.java
index 2cb785bd7..4bc1dca7b 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSSyncTreeSubscriber.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSSyncTreeSubscriber.java
@@ -213,14 +213,14 @@ public abstract class CVSSyncTreeSubscriber extends SyncTreeSubscriber {
 	/**
 	 * Return the synchronization cache that provides access to the base sychronization bytes.
 	 */
-	protected abstract ResourceVariantTree getBaseSynchronizationCache();
+	protected abstract ResourceVariantByteStore getBaseSynchronizationCache();
 
 	/**
 	 * Return the synchronization cache that provides access to the base sychronization bytes.
 	 */
-	protected abstract ResourceVariantTree getRemoteSynchronizationCache();
+	protected abstract ResourceVariantByteStore getRemoteSynchronizationCache();
 	
-	protected IResourceVariant getRemoteResource(IResource resource, ResourceVariantTree cache) throws TeamException {
+	public IResourceVariant getRemoteResource(IResource resource, ResourceVariantByteStore cache) throws TeamException {
 		byte[] remoteBytes = cache.getBytes(resource);
 		if (remoteBytes == null) {
 			// There is no remote handle for this resource
@@ -260,9 +260,9 @@ public abstract class CVSSyncTreeSubscriber extends SyncTreeSubscriber {
 		}
 	}
 	
-	private String getSyncName(ResourceVariantTree cache) {
-		if (cache instanceof PersistantResourceVariantTree) {
-			return ((PersistantResourceVariantTree)cache).getSyncName().toString();
+	private String getSyncName(ResourceVariantByteStore cache) {
+		if (cache instanceof PersistantResourceVariantByteStore) {
+			return ((PersistantResourceVariantByteStore)cache).getSyncName().toString();
 		}
 		return cache.getClass().getName();
 	}
@@ -316,7 +316,7 @@ public abstract class CVSSyncTreeSubscriber extends SyncTreeSubscriber {
 		}
 	}
 
-	private IResource[] getMembers(ResourceVariantTree cache, IResource resource) throws TeamException, CoreException {
+	private IResource[] getMembers(ResourceVariantByteStore cache, IResource resource) throws TeamException, CoreException {
 		// Filter and return only phantoms associated with the remote synchronizer.
 		IResource[] members;
 		try {
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber.java
index 4be128a42..3fb66fe63 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/CVSWorkspaceSubscriber.java
@@ -25,8 +25,8 @@ import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
 import org.eclipse.team.internal.ccvs.core.resources.EclipseSynchronizer;
 import org.eclipse.team.internal.ccvs.core.syncinfo.*;
 import org.eclipse.team.internal.ccvs.core.util.ResourceStateChangeListeners;
-import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantTree;
-import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTree;
+import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantByteStore;
+import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore;
 import org.eclipse.team.internal.ccvs.core.Policy;
 
 /**
@@ -34,8 +34,8 @@ import org.eclipse.team.internal.ccvs.core.Policy;
  */
 public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IResourceStateChangeListener {
 	
-	private ResourceVariantTree remoteSynchronizer;
-	private ResourceVariantTree baseSynchronizer;
+	private CVSDescendantSynchronizationCache remoteSynchronizer;
+	private ResourceVariantByteStore baseSynchronizer;
 	
 	// qualified name for remote sync info
 	private static final String REMOTE_RESOURCE_KEY = "remote-resource-key"; //$NON-NLS-1$
@@ -47,7 +47,7 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 		baseSynchronizer = new CVSBaseSynchronizationCache();
 		remoteSynchronizer = new CVSDescendantSynchronizationCache(
 				baseSynchronizer, 
-				new PersistantResourceVariantTree(new QualifiedName(SYNC_KEY_QUALIFIER, REMOTE_RESOURCE_KEY)));
+				new PersistantResourceVariantByteStore(new QualifiedName(SYNC_KEY_QUALIFIER, REMOTE_RESOURCE_KEY)));
 		
 		ResourceStateChangeListeners.getListener().addResourceStateChangeListener(this); 
 	}
@@ -96,7 +96,7 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 							// managed then this information is stale
 							if (getBaseSynchronizationCache().getBytes(resource) != null) {
 								if (canModifyWorkspace) {
-									remoteSynchronizer.removeBytes(resource, IResource.DEPTH_ZERO);
+									remoteSynchronizer.flushBytes(resource, IResource.DEPTH_ZERO);
 								} else {
 									// The revision  comparison will handle the stale sync bytes
 									// TODO: Unless the remote is known not to exist (see bug 52936)
@@ -107,7 +107,7 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 						byte[] localBytes = baseSynchronizer.getBytes(resource);
 						if (localBytes == null || !isLaterRevision(remoteBytes, localBytes)) {
 							if (canModifyWorkspace) {
-								remoteSynchronizer.removeBytes(resource, IResource.DEPTH_ZERO);
+								remoteSynchronizer.flushBytes(resource, IResource.DEPTH_ZERO);
 							} else {
 								// The getRemoteResource method handles the stale sync bytes
 							}
@@ -116,7 +116,7 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 				} else if (resource.getType() == IResource.FOLDER) {
 					// If the base has sync info for the folder, purge the remote bytes
 					if (getBaseSynchronizationCache().getBytes(resource) != null && canModifyWorkspace) {
-						remoteSynchronizer.removeBytes(resource, IResource.DEPTH_ZERO);
+						remoteSynchronizer.flushBytes(resource, IResource.DEPTH_ZERO);
 					}
 				}
 			} catch (TeamException e) {
@@ -168,7 +168,7 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 	 */
 	public void projectDeconfigured(IProject project) {
 		try {
-			remoteSynchronizer.removeBytes(project, IResource.DEPTH_INFINITE);
+			remoteSynchronizer.flushBytes(project, IResource.DEPTH_INFINITE);
 		} catch (TeamException e) {
 			CVSProviderPlugin.log(e);
 		}
@@ -212,14 +212,14 @@ public class CVSWorkspaceSubscriber extends CVSSyncTreeSubscriber implements IRe
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getBaseSynchronizationCache()
 	 */
-	protected ResourceVariantTree getBaseSynchronizationCache() {
+	protected ResourceVariantByteStore getBaseSynchronizationCache() {
 		return baseSynchronizer;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ccvs.core.CVSSyncTreeSubscriber#getRemoteSynchronizationCache()
 	 */
-	protected ResourceVariantTree getRemoteSynchronizationCache() {
+	protected ResourceVariantByteStore getRemoteSynchronizationCache() {
 		return remoteSynchronizer;
 	}
 	
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSBaseSynchronizationCache.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSBaseSynchronizationCache.java
index e3059df18..b1c615668 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSBaseSynchronizationCache.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSBaseSynchronizationCache.java
@@ -13,11 +13,11 @@ package org.eclipse.team.internal.ccvs.core.syncinfo;
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.team.core.TeamException;
-import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTree;
+import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore;
 import org.eclipse.team.internal.ccvs.core.resources.EclipseSynchronizer;
 
 
-public class CVSBaseSynchronizationCache extends ResourceVariantTree {
+public class CVSBaseSynchronizationCache extends ResourceVariantByteStore {
 	public void dispose() {
 		// Do nothing
 	}
@@ -44,13 +44,13 @@ public class CVSBaseSynchronizationCache extends ResourceVariantTree {
 	public boolean isVariantKnown(IResource resource) throws TeamException {
 		return getBytes(resource) != null;
 	}
-	public boolean removeBytes(IResource resource, int depth) throws TeamException {
+	public boolean flushBytes(IResource resource, int depth) throws TeamException {
 		throw new UnsupportedOperationException();
 	}
 	public boolean setBytes(IResource resource, byte[] bytes) throws TeamException {
 		throw new UnsupportedOperationException();
 	}
-	public boolean setVariantDoesNotExist(IResource resource) throws TeamException {
+	public boolean deleteBytes(IResource resource) throws TeamException {
 		throw new UnsupportedOperationException();
 	}
 	
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSDescendantSynchronizationCache.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSDescendantSynchronizationCache.java
index a3c413710..7baefb8cc 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSDescendantSynchronizationCache.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSDescendantSynchronizationCache.java
@@ -18,9 +18,9 @@ import org.eclipse.team.internal.ccvs.core.*;
 /**
  * CVS sycnrhonization cache that ignores stale remote bytes
  */
-public class CVSDescendantSynchronizationCache extends DescendantResourceVariantTree {
+public class CVSDescendantSynchronizationCache extends DescendantResourceVariantByteStore {
 
-	public CVSDescendantSynchronizationCache(ResourceVariantTree baseCache, PersistantResourceVariantTree remoteCache) {
+	public CVSDescendantSynchronizationCache(ResourceVariantByteStore baseCache, PersistantResourceVariantByteStore remoteCache) {
 		super(baseCache, remoteCache);
 	}
 
@@ -44,7 +44,7 @@ public class CVSDescendantSynchronizationCache extends DescendantResourceVariant
 		if (resource.getType() == IResource.FILE && getBytes(resource) != null && !parentHasSyncBytes(resource)) {
 			// Log a warning if there is no sync bytes available for the resource's
 			// parent but there is valid sync bytes for the child
-			CVSProviderPlugin.log(new TeamException(Policy.bind("ResourceSynchronizer.missingParentBytesOnSet", ((PersistantResourceVariantTree)getRemoteTree()).getSyncName().toString(), resource.getFullPath().toString()))); //$NON-NLS-1$
+			CVSProviderPlugin.log(new TeamException(Policy.bind("ResourceSynchronizer.missingParentBytesOnSet", ((PersistantResourceVariantByteStore)getRemoteTree()).getSyncName().toString(), resource.getFullPath().toString()))); //$NON-NLS-1$
 		}
 		return changed;
 	}
@@ -59,4 +59,10 @@ public class CVSDescendantSynchronizationCache extends DescendantResourceVariant
 		return (getBytes(resource.getParent()) != null);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore#isVariantKnown(org.eclipse.core.resources.IResource)
+	 */
+	public boolean isVariantKnown(IResource resource) throws TeamException {
+		return ((PersistantResourceVariantByteStore)getRemoteTree()).isVariantKnown(resource);
+	}
 }
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSRefreshOperation.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSRefreshOperation.java
index 395166a28..829a34dd6 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSRefreshOperation.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSRefreshOperation.java
@@ -10,10 +10,6 @@
  *******************************************************************************/
 package org.eclipse.team.internal.ccvs.core.syncinfo;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.team.core.TeamException;
@@ -21,19 +17,20 @@ import org.eclipse.team.core.synchronize.IResourceVariant;
 import org.eclipse.team.internal.ccvs.core.*;
 import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
 import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
+import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantByteStore;
 import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTree;
-import org.eclipse.team.internal.core.subscribers.caches.ResourceVariantTreeRefresh;
 
 /**
  * CVS Specific refresh operation
  */
-public class CVSRefreshOperation extends ResourceVariantTreeRefresh {
+public class CVSRefreshOperation extends ResourceVariantTree {
 
-	private ResourceVariantTree cache, baseCache;
+	private ResourceVariantByteStore cache, baseCache;
 	private CVSTag tag;
 	private boolean cacheFileContentsHint;
+	private CVSSyncTreeSubscriber subscriber;
 
-	public CVSRefreshOperation(ResourceVariantTree cache, ResourceVariantTree baseCache, CVSTag tag, boolean cacheFileContentsHint) {
+	public CVSRefreshOperation(ResourceVariantByteStore cache, ResourceVariantByteStore baseCache, CVSTag tag, boolean cacheFileContentsHint) {
 		this.tag = tag;
 		this.cache = cache;
 		this.baseCache = cache;
@@ -43,7 +40,7 @@ public class CVSRefreshOperation extends ResourceVariantTreeRefresh {
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.core.subscribers.RefreshOperation#getSynchronizationCache()
 	 */
-	protected ResourceVariantTree getResourceVariantTree() {
+	protected ResourceVariantByteStore getByteStore() {
 		return cache;
 	}
 
@@ -75,31 +72,6 @@ public class CVSRefreshOperation extends ResourceVariantTreeRefresh {
 	}
 
 	/* (non-Javadoc)
-	 * @see org.eclipse.team.core.subscribers.RefreshOperation#getLocalChildren(org.eclipse.core.resources.IResource)
-	 */
-	protected IResource[] members(IResource local) throws TeamException {
-		IResource[] localChildren = null;			
-		if( local.getType() != IResource.FILE && (local.exists() || local.isPhantom())) {
-			// Include all non-ignored resources including outgoing deletions
-			ICVSFolder cvsFolder = CVSWorkspaceRoot.getCVSFolderFor((IContainer)local);
-			// Look inside existing folders and phantoms that are CVS folders
-			if (local.exists() || cvsFolder.isCVSFolder()) {
-				ICVSResource[] cvsChildren = cvsFolder.members(ICVSFolder.MANAGED_MEMBERS | ICVSFolder.UNMANAGED_MEMBERS);
-				List resourceChildren = new ArrayList();
-				for (int i = 0; i < cvsChildren.length; i++) {
-					ICVSResource cvsResource = cvsChildren[i];
-					resourceChildren.add(cvsResource.getIResource());
-				}
-				localChildren = (IResource[]) resourceChildren.toArray(new IResource[resourceChildren.size()]);
-			}
-		}
-		if (localChildren == null) {
-			localChildren = new IResource[0];
-		}
-		return localChildren;
-	}
-
-	/* (non-Javadoc)
 	 * @see org.eclipse.team.core.subscribers.RefreshOperation#buildRemoteTree(org.eclipse.core.resources.IResource, int, boolean, org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	protected IResourceVariant fetchVariant(IResource resource, int depth, IProgressMonitor monitor) throws TeamException {
@@ -117,4 +89,18 @@ public class CVSRefreshOperation extends ResourceVariantTreeRefresh {
 		return super.collectChanges(local, remote, depth, monitor);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.eclipse.team.internal.core.subscribers.caches.IResourceVariantTree#getRoots()
+	 */
+	public IResource[] getRoots() {
+		return subscriber.roots();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.eclipse.team.internal.core.subscribers.caches.IResourceVariantTree#getResourceVariant(org.eclipse.core.resources.IResource)
+	 */
+	public IResourceVariant getResourceVariant(IResource resource) throws TeamException {
+		return subscriber.getRemoteResource(resource, getByteStore());
+	}
+
 }
diff --git a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSSynchronizationCache.java b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSSynchronizationCache.java
index e910a03f4..32579df08 100644
--- a/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSSynchronizationCache.java
+++ b/bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/syncinfo/CVSSynchronizationCache.java
@@ -13,15 +13,15 @@ package org.eclipse.team.internal.ccvs.core.syncinfo;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.QualifiedName;
 import org.eclipse.team.core.TeamException;
-import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantTree;
+import org.eclipse.team.internal.core.subscribers.caches.PersistantResourceVariantByteStore;
 import org.eclipse.team.internal.ccvs.core.CVSProviderPlugin;
 import org.eclipse.team.internal.ccvs.core.Policy;
 
 /**
- * Override <code>PersistantResourceVariantTree</code> to log an error
+ * Override <code>PersistantResourceVariantByteStore</code> to log an error
  * if there are no parent bytes for a file.
  */
-public class CVSSynchronizationCache extends PersistantResourceVariantTree {
+public class CVSSynchronizationCache extends PersistantResourceVariantByteStore {
 
 	public CVSSynchronizationCache(QualifiedName name) {
 		super(name);