- bug 188776: [api] support task relationships

https://bugs.eclipse.org/bugs/show_bug.cgi?id=188776

18 files changed, 294 insertions, 164 deletions

diff --git a/org.eclipse.mylyn.bugzilla.core/src/org/eclipse/mylyn/internal/bugzilla/core/BugzillaRepositoryConnector.java b/org.eclipse.mylyn.bugzilla.core/src/org/eclipse/mylyn/internal/bugzilla/core/BugzillaRepositoryConnector.java
index e3471ed31..92659fab5 100644
--- a/org.eclipse.mylyn.bugzilla.core/src/org/eclipse/mylyn/internal/bugzilla/core/BugzillaRepositoryConnector.java
+++ b/org.eclipse.mylyn.bugzilla.core/src/org/eclipse/mylyn/internal/bugzilla/core/BugzillaRepositoryConnector.java
@@ -39,7 +39,7 @@ import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
 import org.eclipse.mylyn.tasks.core.data.TaskData;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
 import org.eclipse.mylyn.tasks.core.data.TaskMapper;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * @author Mik Kersten
@@ -205,9 +205,9 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 	}
 
 	@Override
-	public void preSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
-		TaskRepository repository = event.getTaskRepository();
-		if (event.getTasks().isEmpty()) {
+	public void preSynchronization(ISynchronizationSession session, IProgressMonitor monitor) throws CoreException {
+		TaskRepository repository = session.getTaskRepository();
+		if (session.getTasks().isEmpty()) {
 			return;
 		}
 
@@ -216,8 +216,8 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 			monitor.beginTask("Checking for changed tasks", IProgressMonitor.UNKNOWN);
 
 			if (repository.getSynchronizationTimeStamp() == null) {
-				for (ITask task : event.getTasks()) {
-					task.setStale(true);
+				for (ITask task : session.getTasks()) {
+					session.markStale(task);
 				}
 				return;
 			}
@@ -233,7 +233,7 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 			String urlQueryString = urlQueryBase + BUG_ID;
 
 			Set<ITask> changedTasks = new HashSet<ITask>();
-			Iterator<ITask> itr = event.getTasks().iterator();
+			Iterator<ITask> itr = session.getTasks().iterator();
 			int queryCounter = 0;
 			Set<ITask> checking = new HashSet<ITask>();
 			while (itr.hasNext()) {
@@ -243,7 +243,7 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 				String newurlQueryString = URLEncoder.encode(task.getTaskId() + ",", repository.getCharacterEncoding());
 				urlQueryString += newurlQueryString;
 				if (queryCounter >= 1000) {
-					queryForChanged(repository, changedTasks, urlQueryString, event);
+					queryForChanged(repository, changedTasks, urlQueryString, session);
 
 					queryCounter = 0;
 					urlQueryString = urlQueryBase + BUG_ID;
@@ -251,13 +251,13 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 				}
 
 				if (!itr.hasNext() && queryCounter != 0) {
-					queryForChanged(repository, changedTasks, urlQueryString, event);
+					queryForChanged(repository, changedTasks, urlQueryString, session);
 				}
 			}
 
-			for (ITask task : event.getTasks()) {
+			for (ITask task : session.getTasks()) {
 				if (changedTasks.contains(task)) {
-					task.setStale(true);
+					session.markStale(task);
 				}
 			}
 
@@ -275,7 +275,7 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 	 * TODO: clean up use of BugzillaTaskDataCollector
 	 */
 	private void queryForChanged(final TaskRepository repository, Set<ITask> changedTasks, String urlQueryString,
-			ISynchronizationContext context) throws UnsupportedEncodingException, CoreException {
+			ISynchronizationSession context) throws UnsupportedEncodingException, CoreException {
 
 		HashMap<String, ITask> taskById = new HashMap<String, ITask>();
 		for (ITask task : context.getTasks()) {
@@ -314,7 +314,7 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 
 	@Override
 	public IStatus performQuery(TaskRepository repository, final IRepositoryQuery query,
-			TaskDataCollector resultCollector, ISynchronizationContext event, IProgressMonitor monitor) {
+			TaskDataCollector resultCollector, ISynchronizationSession event, IProgressMonitor monitor) {
 		try {
 			monitor.beginTask("Running query", IProgressMonitor.UNKNOWN);
 			BugzillaClient client = getClientManager().getClient(repository, monitor);
@@ -470,7 +470,7 @@ public class BugzillaRepositoryConnector extends AbstractRepositoryConnector {
 	}
 
 	@Override
-	public void postSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
+	public void postSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
 //		try {
 //			monitor.beginTask("", 1);
 //			if (event.isFullSynchronization()) {
diff --git a/org.eclipse.mylyn.tasks.core/META-INF/MANIFEST.MF b/org.eclipse.mylyn.tasks.core/META-INF/MANIFEST.MF
index e841bcac6..15bbd9ed9 100644
--- a/org.eclipse.mylyn.tasks.core/META-INF/MANIFEST.MF
+++ b/org.eclipse.mylyn.tasks.core/META-INF/MANIFEST.MF
@@ -9,11 +9,11 @@ Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.core.net,
  org.eclipse.mylyn.commons.core;bundle-version="[3.0.0,4.0.0)",
  org.eclipse.mylyn.commons.net;bundle-version="[3.0.0,4.0.0)"
-Export-Package: org.eclipse.mylyn.internal.tasks.core;x-friends:="org.eclipse.mylyn.tasks.ui",
- org.eclipse.mylyn.internal.tasks.core.data;x-friends:="org.eclipse.mylyn.tasks.ui",
+Export-Package: org.eclipse.mylyn.internal.tasks.core;x-friends:="org.eclipse.mylyn.tasks.ui,org.eclipse.mylyn.tasks.bugs",
+ org.eclipse.mylyn.internal.tasks.core.data;x-friends:="org.eclipse.mylyn.tasks.ui,org.eclipse.mylyn.tasks.bugs",
  org.eclipse.mylyn.internal.tasks.core.deprecated;x-internal:=true,
- org.eclipse.mylyn.internal.tasks.core.externalization;x-friends:="org.eclipse.mylyn.tasks.ui",
- org.eclipse.mylyn.internal.tasks.core.sync;x-friends:="org.eclipse.mylyn.tasks.ui",
+ org.eclipse.mylyn.internal.tasks.core.externalization;x-friends:="org.eclipse.mylyn.tasks.ui,org.eclipse.mylyn.tasks.bugs",
+ org.eclipse.mylyn.internal.tasks.core.sync;x-friends:="org.eclipse.mylyn.tasks.ui,org.eclipse.mylyn.tasks.bugs",
  org.eclipse.mylyn.tasks.core,
  org.eclipse.mylyn.tasks.core.data,
  org.eclipse.mylyn.tasks.core.sync
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/AbstractTask.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/AbstractTask.java
index 104f3433c..45f6eb8c4 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/AbstractTask.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/AbstractTask.java
@@ -399,10 +399,12 @@ public abstract class AbstractTask extends AbstractTaskContainer implements ITas
 		this.dueDate = date;
 	}
 
+	@Deprecated
 	public boolean isStale() {
 		return stale;
 	}
 
+	@Deprecated
 	public void setStale(boolean stale) {
 		this.stale = stale;
 	}
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java
index 3c4abbd13..7996685ed 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java
@@ -18,7 +18,7 @@ import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.data.TaskData;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * @author Rob Elves
@@ -75,7 +75,7 @@ public class LocalRepositoryConnector extends AbstractRepositoryConnector {
 
 	@Override
 	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,
-			ISynchronizationContext event, IProgressMonitor monitor) {
+			ISynchronizationSession event, IProgressMonitor monitor) {
 		// ignore
 		return null;
 	}
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/deprecated/AbstractLegacyRepositoryConnector.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/deprecated/AbstractLegacyRepositoryConnector.java
index 00e93db49..b940d9fe3 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/deprecated/AbstractLegacyRepositoryConnector.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/deprecated/AbstractLegacyRepositoryConnector.java
@@ -23,7 +23,7 @@ import org.eclipse.mylyn.internal.tasks.core.ITaskList;
 import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
 import org.eclipse.mylyn.internal.tasks.core.RepositoryTemplateManager;
 import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
-import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationContext;
+import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationSession;
 import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
 import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
 import org.eclipse.mylyn.tasks.core.ITask;
@@ -178,9 +178,8 @@ public abstract class AbstractLegacyRepositoryConnector extends AbstractReposito
 
 	/**
 	 * @since 2.0
-	 * @deprecated use
-	 *             {@link #performQuery(TaskRepository, RepositoryQuery, TaskDataCollector, SynchronizationContext, IProgressMonitor)}
-	 *             instead
+	 * @deprecated use {@link #performQuery(TaskRepository, RepositoryQuery, TaskDataCollector,
+	 * 	SynchronizationSession, IProgressMonitor)} instead
 	 */
 	@Deprecated
 	public IStatus performQuery(IRepositoryQuery query, TaskRepository repository, IProgressMonitor monitor,
@@ -286,8 +285,8 @@ public abstract class AbstractLegacyRepositoryConnector extends AbstractReposito
 	 *         <code>tasks</code> collection), so empty collection means that there are some other tasks changed
 	 * 
 	 * @throws CoreException
-	 * @deprecated use {@link #preQuerySynchronization(TaskRepository, SynchronizationContext, IProgressMonitor)}
-	 *             instead
+	 * @deprecated use {@link #preQuerySynchronization(TaskRepository, SynchronizationSession, IProgressMonitor)}
+	 * 	instead
 	 */
 	@Deprecated
 	public boolean markStaleTasks(TaskRepository repository, Set<AbstractTask> tasks, IProgressMonitor monitor)
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizationContext.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizationSession.java
index 3cd72d573..8133fb97e 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizationContext.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizationSession.java
@@ -8,18 +8,21 @@
 
 package org.eclipse.mylyn.internal.tasks.core.sync;
 
+import java.util.HashSet;
 import java.util.Set;
 
+import org.eclipse.core.runtime.CoreException;
 import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.data.ITaskDataManager;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.data.TaskData;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * @author Steffen Pingel
  * @since 3.0
  */
-public class SynchronizationContext implements ISynchronizationContext {
+public class SynchronizationSession implements ISynchronizationSession {
 
 	private boolean fullSynchronization;
 
@@ -29,17 +32,19 @@ public class SynchronizationContext implements ISynchronizationContext {
 
 	private Set<ITask> changedTasks;
 
+	private Set<ITask> staleTasks;
+
 	private TaskRepository taskRepository;
 
 	private Object data;
 
 	private ITaskDataManager taskDataManager;
 
-	public SynchronizationContext(ITaskDataManager taskDataManager) {
+	public SynchronizationSession(ITaskDataManager taskDataManager) {
 		this.taskDataManager = taskDataManager;
 	}
 
-	public SynchronizationContext() {
+	public SynchronizationSession() {
 	}
 
 	public void setFullSynchronization(boolean fullSynchronization) {
@@ -94,4 +99,21 @@ public class SynchronizationContext implements ISynchronizationContext {
 		return taskDataManager;
 	}
 
+	public void markStale(ITask task) {
+		if (staleTasks == null) {
+			staleTasks = new HashSet<ITask>();
+		}
+		staleTasks.add(task);
+	}
+
+	public Set<ITask> getStaleTasks() {
+		return staleTasks;
+	}
+
+	public void putUpdatedTaskData(ITask task, TaskData taskData) throws CoreException {
+		if (taskDataManager != null) {
+			taskDataManager.putUpdatedTaskData(task, taskData, false);
+		}
+	}
+
 }
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java
index 8fc7d9511..8e9242614 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeQueriesJob.java
@@ -11,7 +11,9 @@ package org.eclipse.mylyn.internal.tasks.core.sync;
 import java.text.SimpleDateFormat;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.core.runtime.CoreException;
@@ -40,7 +42,8 @@ import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
 import org.eclipse.mylyn.tasks.core.data.ITaskDataManager;
 import org.eclipse.mylyn.tasks.core.data.TaskData;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob;
 
 /**
@@ -79,8 +82,11 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 
 		private int resultCount;
 
-		public TaskCollector(RepositoryQuery repositoryQuery) {
+		private final SynchronizationSession session;
+
+		public TaskCollector(RepositoryQuery repositoryQuery, SynchronizationSession session) {
 			this.repositoryQuery = repositoryQuery;
+			this.session = session;
 			this.removedQueryResults = new HashSet<ITask>(repositoryQuery.getChildren());
 		}
 
@@ -89,12 +95,14 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 			ITask task = taskList.getTask(taskData.getRepositoryUrl(), taskData.getTaskId());
 			if (task == null) {
 				task = tasksModel.createTask(repository, taskData.getTaskId());
-				task.setStale(true);
+				if (taskData.isPartial()) {
+					session.markStale(task);
+				}
 			} else {
 				removedQueryResults.remove(task);
 			}
 			try {
-				taskDataManager.putUpdatedTaskData(task, taskData, isUser());
+				session.putUpdatedTaskData(task, taskData);
 			} catch (CoreException e) {
 				StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Failed to save task", e));
 			}
@@ -127,8 +135,8 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 				// set incoming marker for web tasks 
 				task.setSynchronizationState(SynchronizationState.INCOMING);
 			}
-			if (isChangedTasksSynchronization() && task.isStale()) {
-				tasksToBeSynchronized.add(task);
+			if (task.isStale()) {
+				session.markStale(task);
 				task.setSynchronizing(true);
 			}
 			resultCount++;
@@ -156,8 +164,6 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 
 	private final TaskList taskList;
 
-	private final HashSet<ITask> tasksToBeSynchronized = new HashSet<ITask>();
-
 	private final ITasksModel tasksModel;
 
 	public SynchronizeQueriesJob(TaskList taskList, ITaskDataManager taskDataManager, ITasksModel tasksModel,
@@ -183,50 +189,65 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 					allTasks.addAll(query.getChildren());
 				}
 			} else {
-				allTasks = Collections.unmodifiableSet(taskList.getTasks(repository.getRepositoryUrl()));
+				allTasks = taskList.getTasks(repository.getRepositoryUrl());
 			}
 
 			MutexRule rule = new MutexRule(repository);
 			try {
 				Job.getJobManager().beginRule(rule, monitor);
 
-				SynchronizationContext event = new SynchronizationContext(taskDataManager);
-				event.setTaskRepository(repository);
-				event.setFullSynchronization(isFullSynchronization());
-				event.setTasks(allTasks);
-				event.setNeedsPerformQueries(true);
-
-//				try {
-				// hook into the connector for checking for changed tasks and have the connector mark tasks that need synchronization
-				if (firePreSynchronization(event, new SubProgressMonitor(monitor, 20))) {
-					// synchronize queries, tasks changed within query are added to set of tasks to be synchronized
-					synchronizeQueries(monitor, event);
-
-					// for background synchronizations all changed tasks are synchronized including the ones that are not part of a query
-					//if (!isUser()) {
-					for (ITask task : allTasks) {
-						if (task.isStale()) {
-							tasksToBeSynchronized.add(task);
-							((AbstractTask) task).setSynchronizing(true);
+				final Map<String, TaskRelation[]> relationsByTaskId = new HashMap<String, TaskRelation[]>();
+				SynchronizationSession session = new SynchronizationSession(taskDataManager) {
+					@Override
+					public void putUpdatedTaskData(ITask task, TaskData taskData) throws CoreException {
+						taskDataManager.putUpdatedTaskData(task, taskData, isUser());
+						if (!taskData.isPartial()) {
+							TaskRelation[] relations = connector.getTaskRelations(taskData);
+							if (relations != null) {
+								relationsByTaskId.put(task.getTaskId(), relations);
+							}
 						}
 					}
-					//}
-
-					// synchronize tasks that were marked by the connector
-					if (!tasksToBeSynchronized.isEmpty()) {
-						Policy.checkCanceled(monitor);
-						monitor.subTask("Synchronizing " + tasksToBeSynchronized.size() + " changed tasks");
-						synchronizeTasks(new SubProgressMonitor(monitor, 40));
-					} else {
-						monitor.worked(40);
+				};
+				session.setTaskRepository(repository);
+				session.setFullSynchronization(isFullSynchronization());
+				session.setTasks(Collections.unmodifiableSet(allTasks));
+				session.setNeedsPerformQueries(true);
+
+				preSynchronization(session, new SubProgressMonitor(monitor, 20));
+
+				if (session.needsPerformQueries()) {
+					// synchronize queries, tasks changed within query are added to set of tasks to be synchronized
+					synchronizeQueries(monitor, session);
+				} else {
+					monitor.worked(queries.size() * 20);
+				}
+
+				Set<ITask> tasksToBeSynchronized = new HashSet<ITask>();
+				if (session.getStaleTasks() != null) {
+					for (ITask task : session.getStaleTasks()) {
+						tasksToBeSynchronized.add(task);
+						((AbstractTask) task).setSynchronizing(true);
 					}
+				}
+
+				SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, tasksModel, connector,
+						repository, tasksToBeSynchronized);
+				job.setUser(isUser());
 
-					// hook into the connector for synchronization time stamp management
-					firePostSynchronization(event, new SubProgressMonitor(monitor, 10));
+				// synchronize tasks that were marked by the connector
+				if (!tasksToBeSynchronized.isEmpty()) {
+					Policy.checkCanceled(monitor);
+					job.run(new SubProgressMonitor(monitor, 30));
 				}
-//				} finally {
-//					taskList.notifyElementsChanged(null);
-//				}
+				monitor.subTask("Receiving related tasks");
+				job.synchronizedTaskRelations(monitor, relationsByTaskId);
+				monitor.worked(10);
+
+				session.setChangedTasks(tasksToBeSynchronized);
+
+				// hook into the connector for synchronization time stamp management
+				postSynchronization(session, new SubProgressMonitor(monitor, 10));
 			} finally {
 				Job.getJobManager().endRule(rule);
 			}
@@ -238,24 +259,23 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 		}
 	}
 
-	private void synchronizeQueries(IProgressMonitor monitor, ISynchronizationContext event) {
+	private void synchronizeQueries(IProgressMonitor monitor, SynchronizationSession session) {
 		for (RepositoryQuery repositoryQuery : queries) {
 			Policy.checkCanceled(monitor);
 			repositoryQuery.setStatus(null);
 
 			monitor.subTask("Synchronizing query " + repositoryQuery.getSummary());
-			synchronizeQuery(repositoryQuery, event, new SubProgressMonitor(monitor, 20));
+			synchronizeQuery(repositoryQuery, session, new SubProgressMonitor(monitor, 20));
 
 			repositoryQuery.setSynchronizing(false);
 			taskList.notifySynchronizationStateChanged(Collections.singleton(repositoryQuery));
 		}
 	}
 
-	private boolean firePostSynchronization(SynchronizationContext event, IProgressMonitor monitor) {
+	private boolean postSynchronization(SynchronizationSession event, IProgressMonitor monitor) {
 		try {
 			Policy.checkCanceled(monitor);
 			monitor.subTask("Updating repository state");
-			event.setChangedTasks(tasksToBeSynchronized);
 			if (!isUser()) {
 				monitor = Policy.backgroundMonitorFor(monitor);
 			}
@@ -267,7 +287,7 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 		}
 	}
 
-	private boolean firePreSynchronization(ISynchronizationContext event, IProgressMonitor monitor) {
+	private boolean preSynchronization(ISynchronizationSession event, IProgressMonitor monitor) {
 		try {
 			Policy.checkCanceled(monitor);
 			monitor.subTask("Querying repository");
@@ -287,9 +307,9 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 		}
 	}
 
-	private void synchronizeQuery(RepositoryQuery repositoryQuery, ISynchronizationContext event,
+	private void synchronizeQuery(RepositoryQuery repositoryQuery, SynchronizationSession event,
 			IProgressMonitor monitor) {
-		TaskCollector collector = new TaskCollector(repositoryQuery);
+		TaskCollector collector = new TaskCollector(repositoryQuery, event);
 
 		if (!isUser()) {
 			monitor = Policy.backgroundMonitorFor(monitor);
@@ -314,13 +334,6 @@ public class SynchronizeQueriesJob extends SynchronizationJob {
 		}
 	}
 
-	private void synchronizeTasks(IProgressMonitor monitor) {
-		SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, connector, repository,
-				tasksToBeSynchronized);
-		job.setUser(isUser());
-		job.run(monitor);
-	}
-
 	private void updateQueryStatus(final IStatus status) {
 		for (RepositoryQuery repositoryQuery : queries) {
 			repositoryQuery.setStatus(status);
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java
index 006ca89f1..f4356f189 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/internal/tasks/core/sync/SynchronizeTasksJob.java
@@ -24,6 +24,7 @@ import org.eclipse.core.runtime.SubProgressMonitor;
 import org.eclipse.mylyn.commons.core.StatusHandler;
 import org.eclipse.mylyn.commons.net.Policy;
 import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
+import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
 import org.eclipse.mylyn.internal.tasks.core.ITaskList;
 import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
 import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
@@ -35,9 +36,13 @@ import org.eclipse.mylyn.internal.tasks.core.deprecated.TaskFactory;
 import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
 import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.ITaskRepositoryManager;
+import org.eclipse.mylyn.tasks.core.ITasksModel;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.data.ITaskDataManager;
 import org.eclipse.mylyn.tasks.core.data.TaskData;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation.Direction;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation.Kind;
 import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob;
 
 /**
@@ -59,22 +64,30 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 
 	private TaskRepository taskRepository;
 
-	public SynchronizeTasksJob(ITaskList taskList, ITaskDataManager synchronizationManager,
+	private Map<String, TaskRelation[]> relationsByTaskId;
+
+	private boolean updateRelations;
+
+	private final ITasksModel tasksModel;
+
+	public SynchronizeTasksJob(ITaskList taskList, ITaskDataManager synchronizationManager, ITasksModel tasksModel,
 			AbstractRepositoryConnector connector, TaskRepository taskRepository, Set<ITask> tasks) {
 		super("Synchronizing Tasks (" + tasks.size() + " tasks)");
 		this.taskList = taskList;
 		this.taskDataManager = synchronizationManager;
+		this.tasksModel = tasksModel;
 		this.connector = connector;
 		this.taskRepository = taskRepository;
 		this.allTasks = tasks;
 		this.repositoryManager = null;
 	}
 
-	public SynchronizeTasksJob(ITaskList taskList, ITaskDataManager synchronizationManager,
+	public SynchronizeTasksJob(ITaskList taskList, ITaskDataManager synchronizationManager, ITasksModel tasksModel,
 			AbstractRepositoryConnector connector, ITaskRepositoryManager repositoryManager, Set<ITask> tasks) {
 		super("Synchronizing Tasks (" + tasks.size() + " tasks)");
 		this.taskList = taskList;
 		this.taskDataManager = synchronizationManager;
+		this.tasksModel = tasksModel;
 		this.connector = connector;
 		this.repositoryManager = repositoryManager;
 		this.allTasks = tasks;
@@ -122,6 +135,45 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 	}
 
 	private void run(Set<ITask> tasks, IProgressMonitor monitor) {
+		relationsByTaskId = new HashMap<String, TaskRelation[]>();
+		updateRelations = true;
+		runInternal(tasks, monitor);
+		synchronizedTaskRelations(monitor, relationsByTaskId);
+	}
+
+	public void synchronizedTaskRelations(IProgressMonitor monitor, Map<String, TaskRelation[]> relationsByTaskId) {
+		updateRelations = false;
+		for (String taskId : relationsByTaskId.keySet()) {
+			ITask parentTask = taskList.getTask(taskRepository.getRepositoryUrl(), taskId);
+			if (parentTask != null) {
+				Set<ITask> removedChildTasks = new HashSet<ITask>(parentTask.getChildren());
+
+				TaskRelation[] relations = relationsByTaskId.get(taskId);
+				for (TaskRelation relation : relations) {
+					if (relation.getDirection() == Direction.OUTWARD && relation.getKind() == Kind.CONTAINMENT) {
+						ITask task = taskList.getTask(taskRepository.getRepositoryUrl(), relation.getTaskId());
+						if (task == null) {
+							try {
+								task = synchronizeTask(monitor, relation.getTaskId());
+							} catch (CoreException e) {
+								StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN,
+										"Synchronization failed", e));
+							}
+						} else {
+							removedChildTasks.remove(task);
+						}
+						taskList.addTask(task, (AbstractTaskContainer) parentTask);
+					}
+				}
+
+				for (ITask task : removedChildTasks) {
+					taskList.removeFromContainer((AbstractTaskContainer) parentTask, task);
+				}
+			}
+		}
+	}
+
+	private void runInternal(Set<ITask> tasks, IProgressMonitor monitor) {
 		try {
 			monitor.beginTask("Processing", tasks.size() * 100);
 			if (canGetMultiTaskData(taskRepository)) {
@@ -170,26 +222,51 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 	private void synchronizeTask(IProgressMonitor monitor, ITask task) throws CoreException {
 		monitor.subTask("Receiving task " + task.getSummary());
 		resetStatus(task);
-
-		String taskId = task.getTaskId();
 		if (!isUser()) {
 			monitor = Policy.backgroundMonitorFor(monitor);
 		}
+		String taskId = task.getTaskId();
 		if (connector instanceof AbstractLegacyRepositoryConnector) {
 			RepositoryTaskData downloadedTaskData = ((AbstractLegacyRepositoryConnector) connector).getLegacyTaskData(
 					taskRepository, taskId, monitor);
 			if (downloadedTaskData != null) {
-				updateFromTaskData(taskRepository, task, downloadedTaskData);
+				try {
+					updateFromTaskData(taskRepository, task, downloadedTaskData);
+				} catch (CoreException e) {
+					updateStatus(taskRepository, task, e.getStatus());
+				}
+				return;
 			}
 		} else {
 			TaskData taskData = connector.getTaskData(taskRepository, taskId, monitor);
 			if (taskData != null) {
 				updateFromTaskData(taskRepository, task, taskData);
-			} else {
-				throw new CoreException(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN,
-						"Connector failed to return task data for task \"" + task + "\""));
+				return;
 			}
 		}
+		throw new CoreException(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN,
+				"Connector failed to return task data for task \"" + task + "\""));
+	}
+
+	private ITask synchronizeTask(IProgressMonitor monitor, String taskId) throws CoreException {
+		monitor.subTask("Receiving task " + taskId);
+		if (!isUser()) {
+			monitor = Policy.backgroundMonitorFor(monitor);
+		}
+		if (connector instanceof AbstractLegacyRepositoryConnector) {
+			RepositoryTaskData downloadedTaskData = ((AbstractLegacyRepositoryConnector) connector).getLegacyTaskData(
+					taskRepository, taskId, monitor);
+			if (downloadedTaskData != null) {
+				return updateFromTaskData(taskRepository, null, downloadedTaskData);
+			}
+		} else {
+			TaskData taskData = connector.getTaskData(taskRepository, taskId, monitor);
+			if (taskData != null) {
+				return createFromTaskData(taskRepository, taskId, taskData);
+			}
+		}
+		throw new CoreException(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN,
+				"Connector failed to return task data for task \"" + taskId + "\""));
 	}
 
 	private void resetStatus(ITask task) {
@@ -212,7 +289,12 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 			public void accept(RepositoryTaskData taskData) {
 				ITask task = idToTask.remove(taskData.getTaskId());
 				if (task != null) {
-					updateFromTaskData(repository, task, taskData);
+					try {
+						updateFromTaskData(repository, task, taskData);
+					} catch (CoreException e) {
+						StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN,
+								"Synchronization failed", e));
+					}
 				}
 			}
 
@@ -228,18 +310,19 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 		if (!isUser()) {
 			monitor = Policy.backgroundMonitorFor(monitor);
 		}
+		Set<String> taskIds = Collections.unmodifiableSet(new HashSet<String>(idToTask.keySet()));
 		if (connector instanceof AbstractLegacyRepositoryConnector) {
 			((AbstractLegacyRepositoryConnector) connector).getLegacyTaskDataHandler().getMultiTaskData(repository,
-					Collections.unmodifiableSet(idToTask.keySet()), collector, monitor);
+					taskIds, collector, monitor);
 		} else {
-			connector.getTaskDataHandler().getMultiTaskData(repository, Collections.unmodifiableSet(idToTask.keySet()),
-					collector, monitor);
+			connector.getTaskDataHandler().getMultiTaskData(repository, taskIds, collector, monitor);
 		}
 
 	}
 
 	@SuppressWarnings("deprecation")
-	private void updateFromTaskData(TaskRepository repository, ITask task, RepositoryTaskData taskData) {
+	private ITask updateFromTaskData(TaskRepository repository, ITask task, RepositoryTaskData taskData)
+			throws CoreException {
 		// HACK: part of hack below
 		//Date oldDueDate = repositoryTask.getDueDate();
 
@@ -255,12 +338,7 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 
 		TaskFactory factory = new TaskFactory(repository, true, isUser(),
 				(AbstractLegacyRepositoryConnector) connector, (TaskDataManager) taskDataManager, taskList);
-		try {
-			task = factory.createTask(taskData, new NullProgressMonitor());
-		} catch (CoreException e) {
-			StatusHandler.log(new Status(IStatus.ERROR, ITasksCoreConstants.ID_PLUGIN, "Synchronization failed", e));
-			return;
-		}
+		task = factory.createTask(taskData, new NullProgressMonitor());
 
 		// HACK: Remove once connectors can get access to
 		// TaskDataManager and do this themselves
@@ -272,19 +350,33 @@ public class SynchronizeTasksJob extends SynchronizationJob {
 //			TasksUiPlugin.getTaskActivityManager().setDueDate(repositoryTask, repositoryTask.getDueDate());
 //		}
 
-		task.setStale(false);
 		((AbstractTask) task).setSynchronizing(false);
 		taskList.notifySynchronizationStateChanged(task);
+
+		return task;
 	}
 
 	private void updateFromTaskData(TaskRepository taskRepository, ITask task, TaskData taskData) {
 		try {
 			taskDataManager.putUpdatedTaskData(task, taskData, isUser());
+			if (updateRelations) {
+				TaskRelation[] relations = connector.getTaskRelations(taskData);
+				if (relations != null) {
+					relationsByTaskId.put(task.getTaskId(), relations);
+				}
+			}
 		} catch (CoreException e) {
 			updateStatus(taskRepository, task, e.getStatus());
 		}
 	}
 
+	private ITask createFromTaskData(TaskRepository taskRepository, String taskId, TaskData taskData)
+			throws CoreException {
+		ITask task = tasksModel.createTask(taskRepository, taskData.getTaskId());
+		taskDataManager.putUpdatedTaskData(task, taskData, isUser());
+		return task;
+	}
+
 	private void updateStatus(TaskRepository repository, ITask task, IStatus status) {
 		((AbstractTask) task).setErrorStatus(status);
 		if (!isUser()) {
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/AbstractRepositoryConnector.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/AbstractRepositoryConnector.java
index a48501208..a929c9be5 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/AbstractRepositoryConnector.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/AbstractRepositoryConnector.java
@@ -18,7 +18,8 @@ import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler;
 import org.eclipse.mylyn.tasks.core.data.TaskData;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
 import org.eclipse.mylyn.tasks.core.data.TaskMapper;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * Encapsulates common operations that can be performed on a task repository. Extend to connect with a Java API or WS
@@ -152,7 +153,8 @@ public abstract class AbstractRepositoryConnector {
 	public abstract String getTaskUrl(String repositoryUrl, String taskId);
 
 	/**
-	 * @param taskRepository TODO
+	 * @param taskRepository
+	 *            TODO
 	 * @since 3.0
 	 */
 	public abstract boolean hasChanged(TaskRepository taskRepository, ITask task, TaskData taskData);
@@ -187,12 +189,12 @@ public abstract class AbstractRepositoryConnector {
 	 * @since 3.0
 	 */
 	public abstract IStatus performQuery(TaskRepository repository, IRepositoryQuery query,
-			TaskDataCollector resultCollector, ISynchronizationContext event, IProgressMonitor monitor);
+			TaskDataCollector resultCollector, ISynchronizationSession event, IProgressMonitor monitor);
 
 	/**
 	 * @since 3.0
 	 */
-	public void postSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
+	public void postSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
 		try {
 			monitor.beginTask("", 1);
 		} finally {
@@ -203,7 +205,7 @@ public abstract class AbstractRepositoryConnector {
 	/**
 	 * @since 3.0
 	 */
-	public void preSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
+	public void preSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
 		try {
 			monitor.beginTask("", 1);
 		} finally {
@@ -232,4 +234,12 @@ public abstract class AbstractRepositoryConnector {
 		return false;
 	}
 
+	/**
+	 * @return Task id for any sub tasks referenced by the provided task data
+	 * @since 3.0
+	 */
+	public TaskRelation[] getTaskRelations(TaskData taskData) {
+		return new TaskRelation[0];
+	}
+
 }
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/ITask.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/ITask.java
index 79f380a4c..cfbf2e3bc 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/ITask.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/ITask.java
@@ -292,12 +292,6 @@ public interface ITask extends ITaskElement, IAttributeContainer {
 	/**
 	 * @since 3.0
 	 */
-	@Deprecated
-	public abstract boolean isStale();
-
-	/**
-	 * @since 3.0
-	 */
 	public abstract void setCompletionDate(Date completionDate);
 
 	/**
@@ -328,13 +322,6 @@ public interface ITask extends ITaskElement, IAttributeContainer {
 
 	/**
 	 * @since 3.0
-	 * @deprecated
-	 */
-	@Deprecated
-	public abstract void setStale(boolean stale);
-
-	/**
-	 * @since 3.0
 	 */
 	public abstract void setSummary(String summary);
 
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/AbstractTaskDataHandler.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/AbstractTaskDataHandler.java
index 731e4927b..32780c583 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/AbstractTaskDataHandler.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/AbstractTaskDataHandler.java
@@ -78,13 +78,6 @@ public abstract class AbstractTaskDataHandler {
 	public abstract TaskAttributeMapper getAttributeMapper(TaskRepository taskRepository);
 
 	/**
-	 * @return Task id for any sub tasks referenced by the provided task data
-	 */
-	public TaskRelation[] getTaskRelations(TaskData taskData) {
-		return new TaskRelation[0];
-	}
-
-	/**
 	 * @param taskRepository
 	 *            TODO
 	 * @return true if connector support downloading multiple task data in single request, false otherwise. If true,
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/TaskRelation.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/TaskRelation.java
index c6ea747c8..5f991a8b8 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/TaskRelation.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/TaskRelation.java
@@ -8,6 +8,8 @@
 
 package org.eclipse.mylyn.tasks.core.data;
 
+import org.eclipse.core.runtime.Assert;
+
 /**
  * @author Steffen Pingel
  * @since 3.0
@@ -29,6 +31,9 @@ public class TaskRelation {
 	}
 
 	private TaskRelation(Kind kind, Direction direction, String taskId) {
+		Assert.isNotNull(kind);
+		Assert.isNotNull(direction);
+		Assert.isNotNull(taskId);
 		this.kind = kind;
 		this.direction = direction;
 		this.taskId = taskId;
@@ -55,7 +60,7 @@ public class TaskRelation {
 	}
 
 	public static TaskRelation dependency(String taskId, Direction direction) {
-		return new TaskRelation(Kind.CONTAINMENT, direction, taskId);
+		return new TaskRelation(Kind.DEPENDENCY, direction, taskId);
 	}
 
 }
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/ISynchronizationContext.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/ISynchronizationSession.java
index beaf288fd..18870c7b0 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/ISynchronizationContext.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/ISynchronizationSession.java
@@ -10,15 +10,17 @@ package org.eclipse.mylyn.tasks.core.sync;
 
 import java.util.Set;
 
+import org.eclipse.core.runtime.CoreException;
 import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.data.ITaskDataManager;
+import org.eclipse.mylyn.tasks.core.data.TaskData;
 
 /**
  * @since 3.0
  * @author Steffen Pingel
  */
-public interface ISynchronizationContext {
+public interface ISynchronizationSession {
 
 	public abstract Set<ITask> getChangedTasks();
 
@@ -38,4 +40,8 @@ public interface ISynchronizationContext {
 
 	public abstract void setNeedsPerformQueries(boolean performQueries);
 
+	public abstract void markStale(ITask task);
+
+	public abstract void putUpdatedTaskData(ITask task, TaskData taskData) throws CoreException;
+
 }
\ No newline at end of file
diff --git a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/SynchronizationJob.java b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/SynchronizationJob.java
index 6b19c6ddf..8a48ed7cf 100644
--- a/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/SynchronizationJob.java
+++ b/org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/sync/SynchronizationJob.java
@@ -16,7 +16,7 @@ import org.eclipse.core.runtime.jobs.Job;
  */
 public abstract class SynchronizationJob extends Job {
 
-	private boolean changedTasksSynchronization = true;
+//	private boolean changedTasksSynchronization = true;
 
 	private boolean fullSynchronization = false;
 
@@ -24,17 +24,17 @@ public abstract class SynchronizationJob extends Job {
 		super(name);
 	}
 
-	public boolean isChangedTasksSynchronization() {
-		return changedTasksSynchronization;
-	}
+//	public boolean isChangedTasksSynchronization() {
+//		return changedTasksSynchronization;
+//	}
 
 	public boolean isFullSynchronization() {
 		return fullSynchronization;
 	}
 
-	public void setChangedTasksSynchronization(boolean synchronizeChangedTasks) {
-		this.changedTasksSynchronization = synchronizeChangedTasks;
-	}
+//	public void setChangedTasksSynchronization(boolean synchronizeChangedTasks) {
+//		this.changedTasksSynchronization = synchronizeChangedTasks;
+//	}
 
 	public void setFullSynchronization(boolean fullSynchronization) {
 		this.fullSynchronization = fullSynchronization;
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryConnector.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryConnector.java
index 806acb8f7..79cc6e096 100644
--- a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryConnector.java
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryConnector.java
@@ -27,7 +27,7 @@ import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.RepositoryTemplate;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * @author Mik Kersten
@@ -183,7 +183,7 @@ public class MockRepositoryConnector extends AbstractLegacyRepositoryConnector {
 
 	@Override
 	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query,
-			TaskDataCollector resultCollector, ISynchronizationContext event, IProgressMonitor monitor) {
+			TaskDataCollector resultCollector, ISynchronizationSession event, IProgressMonitor monitor) {
 		return Status.OK_STATUS;
 	}
 
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskJobFactory.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskJobFactory.java
index 807fc0416..1edad4b31 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskJobFactory.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskJobFactory.java
@@ -63,8 +63,8 @@ public class TaskJobFactory implements ITaskJobFactory {
 	}
 
 	public SynchronizationJob createSynchronizeTasksJob(AbstractRepositoryConnector connector, Set<ITask> tasks) {
-		SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, connector, repositoryManager,
-				tasks);
+		SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, tasksModel, connector,
+				repositoryManager, tasks);
 		job.setProperty(IProgressConstants.ICON_PROPERTY, TasksUiImages.REPOSITORY_SYNCHRONIZE);
 		job.setPriority(Job.LONG);
 		return job;
@@ -72,7 +72,8 @@ public class TaskJobFactory implements ITaskJobFactory {
 
 	public SynchronizationJob createSynchronizeTasksJob(AbstractRepositoryConnector connector,
 			TaskRepository taskRepository, Set<ITask> tasks) {
-		SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, connector, taskRepository, tasks);
+		SynchronizeTasksJob job = new SynchronizeTasksJob(taskList, taskDataManager, tasksModel, connector,
+				taskRepository, tasks);
 		job.setProperty(IProgressConstants.ICON_PROPERTY, TasksUiImages.REPOSITORY_SYNCHRONIZE);
 		job.setPriority(Job.LONG);
 		return job;
diff --git a/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java b/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
index e82ff00d8..a6dede07f 100644
--- a/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
+++ b/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
@@ -44,7 +44,7 @@ import org.eclipse.mylyn.tasks.core.RepositoryStatus;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.core.TaskRepositoryLocationFactory;
 import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
-import org.eclipse.mylyn.tasks.core.sync.ISynchronizationContext;
+import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
 
 /**
  * @author Steffen Pingel
@@ -145,8 +145,8 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 	}
 
 	@Override
-	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query,
-			TaskDataCollector resultCollector, ISynchronizationContext event, IProgressMonitor monitor) {
+	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,
+			ISynchronizationSession event, IProgressMonitor monitor) {
 		try {
 			monitor.beginTask("Querying repository", IProgressMonitor.UNKNOWN);
 
@@ -176,21 +176,21 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 	}
 
 	@Override
-	public void preSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
+	public void preSynchronization(ISynchronizationSession session, IProgressMonitor monitor) throws CoreException {
 		monitor = Policy.monitorFor(monitor);
 		try {
 			monitor.beginTask("Getting changed tasks", IProgressMonitor.UNKNOWN);
 
-			if (!event.isFullSynchronization()) {
+			if (!session.isFullSynchronization()) {
 				return;
 			}
 
 			// there are no Trac tasks in the task list, skip contacting the repository
-			if (event.getTasks().isEmpty()) {
+			if (session.getTasks().isEmpty()) {
 				return;
 			}
 
-			TaskRepository repository = event.getTaskRepository();
+			TaskRepository repository = session.getTaskRepository();
 			if (!TracRepositoryConnector.hasChangedSince(repository)) {
 				// always run the queries for web mode
 				return;
@@ -198,8 +198,8 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 
 			if (repository.getSynchronizationTimeStamp() == null
 					|| repository.getSynchronizationTimeStamp().length() == 0) {
-				for (ITask task : event.getTasks()) {
-					task.setStale(true);
+				for (ITask task : session.getTasks()) {
+					session.markStale(task);
 				}
 				return;
 			}
@@ -215,7 +215,7 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 				Set<Integer> ids = client.getChangedTickets(since, monitor);
 				if (ids.isEmpty()) {
 					// repository is unchanged
-					event.setNeedsPerformQueries(false);
+					session.setNeedsPerformQueries(false);
 					return;
 				}
 
@@ -228,15 +228,15 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 					Date lastChanged = client.getTicketLastChanged(id, monitor);
 					if (since.equals(lastChanged)) {
 						// repository didn't actually change
-						event.setNeedsPerformQueries(false);
+						session.setNeedsPerformQueries(false);
 						return;
 					}
 				}
 
-				for (ITask task : event.getTasks()) {
+				for (ITask task : session.getTasks()) {
 					Integer id = getTicketId(task.getTaskId());
 					if (ids.contains(id)) {
-						task.setStale(true);
+						session.markStale(task);
 					}
 				}
 			} catch (OperationCanceledException e) {
@@ -427,12 +427,12 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
 	}
 
 	@Override
-	public void postSynchronization(ISynchronizationContext event, IProgressMonitor monitor) throws CoreException {
+	public void postSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
 		try {
 			monitor.beginTask("", 1);
 			if (event.isFullSynchronization()) {
-				event.getTaskRepository().setSynchronizationTimeStamp(getSynchronizationTimestamp(event.getTaskRepository(),
-						event.getChangedTasks()));
+				event.getTaskRepository().setSynchronizationTimeStamp(
+						getSynchronizationTimestamp(event.getTaskRepository(), event.getChangedTasks()));
 			}
 		} finally {
 			monitor.done();
diff --git a/org.eclipse.mylyn.trac.tests/src/org/eclipse/mylyn/trac/tests/TracTaskDataHandlerTest.java b/org.eclipse.mylyn.trac.tests/src/org/eclipse/mylyn/trac/tests/TracTaskDataHandlerTest.java
index 046927c92..426fd36f3 100644
--- a/org.eclipse.mylyn.trac.tests/src/org/eclipse/mylyn/trac/tests/TracTaskDataHandlerTest.java
+++ b/org.eclipse.mylyn.trac.tests/src/org/eclipse/mylyn/trac/tests/TracTaskDataHandlerTest.java
@@ -29,7 +29,7 @@ import org.eclipse.mylyn.internal.tasks.core.deprecated.DefaultTaskSchema;
 import org.eclipse.mylyn.internal.tasks.core.deprecated.ITaskAttachment;
 import org.eclipse.mylyn.internal.tasks.core.deprecated.RepositoryTaskAttribute;
 import org.eclipse.mylyn.internal.tasks.core.deprecated.RepositoryTaskData;
-import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationContext;
+import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationSession;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
 import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
 import org.eclipse.mylyn.internal.trac.core.ITracClient;
@@ -104,7 +104,7 @@ public class TracTaskDataHandlerTest extends TestCase {
 
 		Set<ITask> tasks = new HashSet<ITask>();
 		tasks.add(task);
-		SynchronizationContext event = new SynchronizationContext();
+		SynchronizationSession event = new SynchronizationSession();
 		event.setNeedsPerformQueries(true);
 		event.setTaskRepository(repository);
 		event.setFullSynchronization(true);
@@ -144,7 +144,7 @@ public class TracTaskDataHandlerTest extends TestCase {
 
 		Set<ITask> tasks = new HashSet<ITask>();
 		tasks.add(task);
-		SynchronizationContext event = new SynchronizationContext();
+		SynchronizationSession event = new SynchronizationSession();
 		event.setNeedsPerformQueries(true);
 		event.setTaskRepository(repository);
 		event.setFullSynchronization(true);
@@ -205,7 +205,7 @@ public class TracTaskDataHandlerTest extends TestCase {
 		TracTask task = (TracTask) TasksUiInternal.createTask(repository, data.offlineHandlerTicketId + "", null);
 		Set<ITask> tasks = new HashSet<ITask>();
 		tasks.add(task);
-		SynchronizationContext event = new SynchronizationContext();
+		SynchronizationSession event = new SynchronizationSession();
 		event.setNeedsPerformQueries(true);
 		event.setTaskRepository(repository);
 		event.setFullSynchronization(true);