renamed SolutionSynchronizationService -> RemotableDataService

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticAnalyzerExecutor.cs

@@ -120,7 +120,7 @@ public AnalyzerExecutor(AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateS
                 RemoteHostClient client, CompilationWithAnalyzers analyzerDriver, Project project, bool forcedAnalysis, CancellationToken cancellationToken)
             {
                 var solution = project.Solution;
-                var snapshotService = solution.Workspace.Services.GetService<ISolutionSynchronizationService>();
+                var snapshotService = solution.Workspace.Services.GetService<IRemotableDataService>();
 
                 // TODO: this should be moved out
                 var analyzerMap = CreateAnalyzerMap(analyzerDriver.Analyzers.Where(a => !a.IsOpenFileOnly(project.Solution.Workspace)));

src/VisualStudio/Core/Def/Implementation/Remote/RemoteHostClientServiceFactory.RemoteHostClientService.cs

@@ -186,7 +186,7 @@ private Checksum[] AddGlobalAssets(CancellationToken cancellationToken)
 
                 using (Logger.LogBlock(FunctionId.RemoteHostClientService_AddGlobalAssetsAsync, cancellationToken))
                 {
-                    var snapshotService = _workspace.Services.GetService<ISolutionSynchronizationService>();
+                    var snapshotService = _workspace.Services.GetService<IRemotableDataService>();
                     var assetBuilder = new CustomAssetBuilder(_workspace);
 
                     foreach (var reference in _analyzerService.GetHostAnalyzerReferences())
@@ -205,7 +205,7 @@ private void RemoveGlobalAssets()
             {
                 using (Logger.LogBlock(FunctionId.RemoteHostClientService_RemoveGlobalAssets, CancellationToken.None))
                 {
-                    var snapshotService = _workspace.Services.GetService<ISolutionSynchronizationService>();
+                    var snapshotService = _workspace.Services.GetService<IRemotableDataService>();
 
                     foreach (var reference in _analyzerService.GetHostAnalyzerReferences())
                     {

src/VisualStudio/Core/Next/Remote/RemotableDataJsonRpcEx.cs

@@ -24,7 +24,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Remote
     /// </summary>
     internal class RemotableDataJsonRpcEx : JsonRpcEx
     {
-        private readonly ISolutionSynchronizationService _remotableDataService;
+        private readonly IRemotableDataService _remotableDataService;
         private readonly CancellationTokenSource _source;
 
         /// <summary>
@@ -39,7 +39,7 @@ public RemotableDataJsonRpcEx(Microsoft.CodeAnalysis.Workspace workspace, Stream
             _gate = new object();
             _count = 1;
 
-            _remotableDataService = workspace.Services.GetService<ISolutionSynchronizationService>();
+            _remotableDataService = workspace.Services.GetService<IRemotableDataService>();
 
             // cancellation will be removed once I get to cancellation refactoring
             _source = new CancellationTokenSource();

src/VisualStudio/Core/Test.Next/Remote/RemoteHostClientServiceFactoryTests.cs

@@ -63,7 +63,7 @@ public async Task GlobalAssets()
             // make sure client is ready
             var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None);
 
-            var checksumService = workspace.Services.GetService<ISolutionSynchronizationService>();
+            var checksumService = workspace.Services.GetService<IRemotableDataService>();
             var asset = checksumService.GetGlobalAsset(analyzerReference, CancellationToken.None);
             Assert.NotNull(asset);
 

src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs

@@ -139,7 +139,7 @@ void Method()
                 var analyzerReference = new AnalyzerFileReference(analyzerType.Assembly.Location, new TestAnalyzerAssemblyLoader());
 
                 // add host analyzer as global assets
-                var snapshotService = workspace.Services.GetService<ISolutionSynchronizationService>();
+                var snapshotService = workspace.Services.GetService<IRemotableDataService>();
                 var assetBuilder = new CustomAssetBuilder(workspace);
 
                 var asset = assetBuilder.Build(analyzerReference, CancellationToken.None);

src/Workspaces/Core/Portable/Execution/CustomAsset.cs

@@ -10,7 +10,7 @@
 namespace Microsoft.CodeAnalysis.Execution
 {
     /// <summary>
-    /// Asset that is not part of solution, but want to participate in <see cref="ISolutionSynchronizationService"/>
+    /// Asset that is not part of solution, but want to participate in <see cref="IRemotableDataService"/>
     /// </summary>
     internal abstract class CustomAsset : RemotableData
     {

src/Workspaces/Core/Portable/Execution/CustomAssetBuilder.cs

@@ -9,7 +9,7 @@
 namespace Microsoft.CodeAnalysis.Execution
 {
     /// <summary>
-    /// builder to create custom asset which is not part of solution but want to participate in <see cref="ISolutionSynchronizationService"/>
+    /// builder to create custom asset which is not part of solution but want to participate in <see cref="IRemotableDataService"/>
     /// </summary>
     internal class CustomAssetBuilder
     {

src/Workspaces/Core/Portable/Execution/ISolutionSynchronizationService.cs

@@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.Execution
     /// a service that lets one to create <see cref="PinnedRemotableDataScope"/> that can be used to pin solution
     /// while working on remote host
     /// </summary>
-    internal interface ISolutionSynchronizationService : IWorkspaceService
+    internal interface IRemotableDataService : IWorkspaceService
     {
         /// <summary>
         /// Add global <see cref="CustomAsset"/> which stays alive while host is alive.

src/Workspaces/Core/Portable/Execution/RemotableData.cs

@@ -8,7 +8,7 @@
 namespace Microsoft.CodeAnalysis.Execution
 {
     /// <summary>
-    /// Base for object that will use <see cref="ISolutionSynchronizationService"/> framework to synchronize data to remote host
+    /// Base for object that will use <see cref="IRemotableDataService"/> framework to synchronize data to remote host
     /// </summary>
     internal abstract partial class RemotableData
     {

src/Workspaces/Core/Portable/Execution/SolutionSynchronizationService.cs

@@ -11,8 +11,8 @@
 
 namespace Microsoft.CodeAnalysis.Execution
 {
-    [ExportWorkspaceServiceFactory(typeof(ISolutionSynchronizationService)), Shared]
-    internal class SolutionSynchronizationServiceFactory : IWorkspaceServiceFactory
+    [ExportWorkspaceServiceFactory(typeof(IRemotableDataService)), Shared]
+    internal class RemotableDataServiceFactory : IWorkspaceServiceFactory
     {
         private readonly AssetStorages _assetStorages = new AssetStorages();
 
@@ -21,7 +21,7 @@ public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
             return new Service(workspaceServices, _assetStorages);
         }
 
-        internal class Service : ISolutionSynchronizationService
+        internal class Service : IRemotableDataService
         {
             private readonly HostWorkspaceServices _workspaceServices;
             private readonly AssetStorages _assetStorages;

src/Workspaces/Core/Portable/Remote/RemoteHostClientExtensions.cs

@@ -238,7 +238,7 @@ public static async Task<PinnedRemotableDataScope> GetPinnedScopeAsync(this Solu
         {
             Contract.ThrowIfNull(solution);
 
-            var service = solution.Workspace.Services.GetService<ISolutionSynchronizationService>();
+            var service = solution.Workspace.Services.GetService<IRemotableDataService>();
             return await service.CreatePinnedRemotableDataScopeAsync(solution, cancellationToken).ConfigureAwait(false);
         }
 

src/Workspaces/CoreTest/Execution/Extensions.cs

@@ -15,9 +15,9 @@ namespace Microsoft.CodeAnalysis.UnitTests.Execution
 {
     internal static class Extensions
     {
-        public static async Task<T> GetValueAsync<T>(this ISolutionSynchronizationService service, Checksum checksum)
+        public static async Task<T> GetValueAsync<T>(this IRemotableDataService service, Checksum checksum)
         {
-            var syncService = (SolutionSynchronizationServiceFactory.Service)service;
+            var syncService = (RemotableDataServiceFactory.Service)service;
             var syncObject = syncService.GetRemotableData_TestOnly(checksum, CancellationToken.None);
 
             using (var stream = SerializableBytes.CreateWritableStream())
@@ -36,17 +36,17 @@ public static async Task<T> GetValueAsync<T>(this ISolutionSynchronizationServic
             }
         }
 
-        public static ChecksumObjectCollection<ProjectStateChecksums> ToProjectObjects(this ProjectChecksumCollection collection, ISolutionSynchronizationService service)
+        public static ChecksumObjectCollection<ProjectStateChecksums> ToProjectObjects(this ProjectChecksumCollection collection, IRemotableDataService service)
         {
             return new ChecksumObjectCollection<ProjectStateChecksums>(service, collection);
         }
 
-        public static ChecksumObjectCollection<DocumentStateChecksums> ToDocumentObjects(this DocumentChecksumCollection collection, ISolutionSynchronizationService service)
+        public static ChecksumObjectCollection<DocumentStateChecksums> ToDocumentObjects(this DocumentChecksumCollection collection, IRemotableDataService service)
         {
             return new ChecksumObjectCollection<DocumentStateChecksums>(service, collection);
         }
 
-        public static ChecksumObjectCollection<DocumentStateChecksums> ToDocumentObjects(this TextDocumentChecksumCollection collection, ISolutionSynchronizationService service)
+        public static ChecksumObjectCollection<DocumentStateChecksums> ToDocumentObjects(this TextDocumentChecksumCollection collection, IRemotableDataService service)
         {
             return new ChecksumObjectCollection<DocumentStateChecksums>(service, collection);
         }
@@ -59,7 +59,7 @@ internal class ChecksumObjectCollection<T> : RemotableData, IEnumerable<T> where
     {
         public ImmutableArray<T> Children { get; }
 
-        public ChecksumObjectCollection(ISolutionSynchronizationService service, ChecksumCollection collection) : base(collection.Checksum, collection.GetWellKnownSynchronizationKind())
+        public ChecksumObjectCollection(IRemotableDataService service, ChecksumCollection collection) : base(collection.Checksum, collection.GetWellKnownSynchronizationKind())
         {
             // using .Result here since we don't want to convert all calls to this to async.
             // and none of ChecksumWithChildren actually use async

src/Workspaces/CoreTest/Execution/SnapshotSerializationTestBase.cs

@@ -36,7 +36,7 @@ internal static Solution CreateFullSolution(HostServices hostServices = null)
             return textDocument1.Project.Solution;
         }
 
-        internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, SolutionStateChecksums solutionObject)
+        internal static async Task VerifyAssetAsync(IRemotableDataService service, SolutionStateChecksums solutionObject)
         {
             await VerifyAssetSerializationAsync<SolutionInfo.SolutionAttributes>(
                 service, solutionObject.Info, WellKnownSynchronizationKind.SolutionAttributes,
@@ -49,7 +49,7 @@ internal static async Task VerifyAssetAsync(ISolutionSynchronizationService serv
             }
         }
 
-        internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, ProjectStateChecksums projectObject)
+        internal static async Task VerifyAssetAsync(IRemotableDataService service, ProjectStateChecksums projectObject)
         {
             var info = await VerifyAssetSerializationAsync<ProjectInfo.ProjectAttributes>(
                 service, projectObject.Info, WellKnownSynchronizationKind.ProjectAttributes,
@@ -97,7 +97,7 @@ internal static async Task VerifyAssetAsync(ISolutionSynchronizationService serv
             }
         }
 
-        internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, DocumentStateChecksums documentObject)
+        internal static async Task VerifyAssetAsync(IRemotableDataService service, DocumentStateChecksums documentObject)
         {
             var info = await VerifyAssetSerializationAsync<DocumentInfo.DocumentAttributes>(
                 service, documentObject.Info, WellKnownSynchronizationKind.DocumentAttributes,
@@ -109,13 +109,13 @@ internal static async Task VerifyAssetAsync(ISolutionSynchronizationService serv
         }
 
         internal static async Task<T> VerifyAssetSerializationAsync<T>(
-            ISolutionSynchronizationService service,
+            IRemotableDataService service,
             Checksum checksum,
             WellKnownSynchronizationKind kind,
             Func<T, WellKnownSynchronizationKind, Serializer, RemotableData> assetGetter)
         {
             // re-create asset from object
-            var syncService = (SolutionSynchronizationServiceFactory.Service)service;
+            var syncService = (RemotableDataServiceFactory.Service)service;
             var syncObject = syncService.GetRemotableData_TestOnly(checksum, CancellationToken.None);
 
             var recoveredValue = await service.GetValueAsync<T>(checksum);
@@ -127,7 +127,7 @@ internal static async Task VerifyAssetAsync(ISolutionSynchronizationService serv
             return recoveredValue;
         }
 
-        internal static async Task VerifySolutionStateSerializationAsync(ISolutionSynchronizationService service, Solution solution, Checksum solutionChecksum)
+        internal static async Task VerifySolutionStateSerializationAsync(IRemotableDataService service, Solution solution, Checksum solutionChecksum)
         {
             var solutionObjectFromSyncObject = await service.GetValueAsync<SolutionStateChecksums>(solutionChecksum);
             Assert.True(solution.State.TryGetStateChecksums(out var solutionObjectFromSolution));
@@ -135,14 +135,14 @@ internal static async Task VerifySolutionStateSerializationAsync(ISolutionSynchr
             SolutionStateEqual(service, solutionObjectFromSolution, solutionObjectFromSyncObject);
         }
 
-        internal static void SolutionStateEqual(ISolutionSynchronizationService service, SolutionStateChecksums solutionObject1, SolutionStateChecksums solutionObject2)
+        internal static void SolutionStateEqual(IRemotableDataService service, SolutionStateChecksums solutionObject1, SolutionStateChecksums solutionObject2)
         {
             ChecksumWithChildrenEqual(solutionObject1, solutionObject2);
 
             ProjectStatesEqual(service, solutionObject1.Projects.ToProjectObjects(service), solutionObject2.Projects.ToProjectObjects(service));
         }
 
-        internal static void ProjectStateEqual(ISolutionSynchronizationService service, ProjectStateChecksums projectObjects1, ProjectStateChecksums projectObjects2)
+        internal static void ProjectStateEqual(IRemotableDataService service, ProjectStateChecksums projectObjects1, ProjectStateChecksums projectObjects2)
         {
             ChecksumWithChildrenEqual(projectObjects1, projectObjects2);
 
@@ -150,7 +150,7 @@ internal static void ProjectStateEqual(ISolutionSynchronizationService service,
             ChecksumWithChildrenEqual(projectObjects1.AdditionalDocuments.ToDocumentObjects(service), projectObjects2.AdditionalDocuments.ToDocumentObjects(service));
         }
 
-        internal static void ProjectStatesEqual(ISolutionSynchronizationService service, ChecksumObjectCollection<ProjectStateChecksums> projectObjects1, ChecksumObjectCollection<ProjectStateChecksums> projectObjects2)
+        internal static void ProjectStatesEqual(IRemotableDataService service, ChecksumObjectCollection<ProjectStateChecksums> projectObjects1, ChecksumObjectCollection<ProjectStateChecksums> projectObjects2)
         {
             SynchronizationObjectEqual(projectObjects1, projectObjects2);
 
@@ -197,7 +197,7 @@ internal static void ChecksumWithChildrenEqual(ChecksumWithChildren checksums1,
         }
 
         internal static void VerifySnapshotInService(
-            ISolutionSynchronizationService snapshotService,
+            IRemotableDataService snapshotService,
             ProjectStateChecksums projectObject,
             int expectedDocumentCount,
             int expectedProjectReferenceCount,
@@ -219,7 +219,7 @@ internal static void ChecksumWithChildrenEqual(ChecksumWithChildren checksums1,
             VerifyCollectionInService(snapshotService, projectObject.AdditionalDocuments.ToDocumentObjects(snapshotService), expectedAdditionalDocumentCount);
         }
 
-        internal static void VerifyCollectionInService(ISolutionSynchronizationService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind)
+        internal static void VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind)
         {
             VerifyChecksumInService(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind());
             Assert.Equal(checksums.Count, expectedCount);
@@ -230,7 +230,7 @@ internal static void VerifyCollectionInService(ISolutionSynchronizationService s
             }
         }
 
-        internal static void VerifyCollectionInService(ISolutionSynchronizationService snapshotService, ChecksumObjectCollection<DocumentStateChecksums> documents, int expectedCount)
+        internal static void VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumObjectCollection<DocumentStateChecksums> documents, int expectedCount)
         {
             VerifySynchronizationObjectInService(snapshotService, documents);
             Assert.Equal(documents.Count, expectedCount);
@@ -241,22 +241,22 @@ internal static void VerifyCollectionInService(ISolutionSynchronizationService s
             }
         }
 
-        internal static void VerifySnapshotInService(ISolutionSynchronizationService snapshotService, DocumentStateChecksums documentObject)
+        internal static void VerifySnapshotInService(IRemotableDataService snapshotService, DocumentStateChecksums documentObject)
         {
             VerifyChecksumInService(snapshotService, documentObject.Checksum, documentObject.GetWellKnownSynchronizationKind());
             VerifyChecksumInService(snapshotService, documentObject.Info, WellKnownSynchronizationKind.DocumentAttributes);
             VerifyChecksumInService(snapshotService, documentObject.Text, WellKnownSynchronizationKind.SourceText);
         }
 
-        internal static void VerifySynchronizationObjectInService<T>(ISolutionSynchronizationService snapshotService, T syncObject) where T : RemotableData
+        internal static void VerifySynchronizationObjectInService<T>(IRemotableDataService snapshotService, T syncObject) where T : RemotableData
         {
             VerifyChecksumInService(snapshotService, syncObject.Checksum, syncObject.Kind);
         }
 
-        internal static void VerifyChecksumInService(ISolutionSynchronizationService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind)
+        internal static void VerifyChecksumInService(IRemotableDataService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind)
         {
             Assert.NotNull(checksum);
-            var service = (SolutionSynchronizationServiceFactory.Service)snapshotService;
+            var service = (RemotableDataServiceFactory.Service)snapshotService;
             var otherObject = service.GetRemotableData_TestOnly(checksum, CancellationToken.None);
 
             ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind);

src/Workspaces/CoreTest/Execution/SnapshotSerializationTests.cs

@@ -33,7 +33,7 @@ public async Task CreateSolutionSnapshotId_Empty()
         {
             var solution = new AdhocWorkspace().CurrentSolution;
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var checksum = snapshot.SolutionChecksum;
@@ -56,7 +56,7 @@ public async Task CreateSolutionSnapshotId_Empty_Serialization()
         {
             var solution = new AdhocWorkspace().CurrentSolution;
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 await VerifySolutionStateSerializationAsync(snapshotService, solution, snapshot.SolutionChecksum).ConfigureAwait(false);
@@ -68,7 +68,7 @@ public async Task CreateSolutionSnapshotId_Project()
         {
             var project = new AdhocWorkspace().CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var checksum = snapshot.SolutionChecksum;
@@ -93,7 +93,7 @@ public async Task CreateSolutionSnapshotId_Project_Serialization()
         {
             var project = new AdhocWorkspace().CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 await VerifySolutionStateSerializationAsync(snapshotService, project.Solution, snapshot.SolutionChecksum).ConfigureAwait(false);
@@ -107,7 +107,7 @@ public async Task CreateSolutionSnapshotId()
 
             var document = new AdhocWorkspace().CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code));
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(document.Project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(document.Project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var syncObject = snapshot.GetRemotableData(snapshot.SolutionChecksum, CancellationToken.None);
@@ -129,7 +129,7 @@ public async Task CreateSolutionSnapshotId_Serialization()
 
             var document = new AdhocWorkspace().CurrentSolution.AddProject("Project", "Project.dll", LanguageNames.CSharp).AddDocument("Document", SourceText.From(code));
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(document.Project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(document.Project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(document.Project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 await VerifySolutionStateSerializationAsync(snapshotService, document.Project.Solution, snapshot.SolutionChecksum).ConfigureAwait(false);
@@ -144,7 +144,7 @@ public async Task CreateSolutionSnapshotId_Full()
             var firstProjectChecksum = await solution.GetProject(solution.ProjectIds[0]).State.GetChecksumAsync(CancellationToken.None);
             var secondProjectChecksum = await solution.GetProject(solution.ProjectIds[1]).State.GetChecksumAsync(CancellationToken.None);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var syncObject = snapshot.GetRemotableData(snapshot.SolutionChecksum, CancellationToken.None);
@@ -167,7 +167,7 @@ public async Task CreateSolutionSnapshotId_Full_Serialization()
         {
             var solution = CreateFullSolution();
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 await VerifySolutionStateSerializationAsync(snapshotService, solution, snapshot.SolutionChecksum).ConfigureAwait(false);
@@ -179,7 +179,7 @@ public async Task CreateSolutionSnapshotId_Full_Asset_Serialization()
         {
             var solution = CreateFullSolution();
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var solutionObject = await snapshotService.GetValueAsync<SolutionStateChecksums>(snapshot.SolutionChecksum);
@@ -195,7 +195,7 @@ public async Task CreateSolutionSnapshotId_Full_Asset_Serialization_Desktop()
 
             var solution = CreateFullSolution(hostServices);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 var solutionObject = await snapshotService.GetValueAsync<SolutionStateChecksums>(snapshot.SolutionChecksum);
@@ -213,7 +213,7 @@ public async Task CreateSolutionSnapshotId_Duplicate()
             SolutionStateChecksums solutionId1;
             SolutionStateChecksums solutionId2;
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot1 = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false))
             {
                 solutionId1 = await snapshotService.GetValueAsync<SolutionStateChecksums>(snapshot1.SolutionChecksum).ConfigureAwait(false);
@@ -250,7 +250,7 @@ public async Task Workspace_RoundTrip_Test()
         {
             var solution = CreateFullSolution();
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             var snapshot1 = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
 
             // recover solution from given snapshot
@@ -292,7 +292,7 @@ public async Task Workspace_RoundTrip_Test_Desktop()
 
             var solution = CreateFullSolution(hostServices);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
             var snapshot1 = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None).ConfigureAwait(false);
 
             // recover solution from given snapshot
@@ -455,7 +455,7 @@ public async Task SnapshotWithMissingReferencesTest()
             project = project.AddMetadataReference(metadata);
             project = project.AddAnalyzerReference(analyzer);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 // this shouldn't throw
@@ -470,7 +470,7 @@ public async Task UnknownLanguageTest()
 
             var project = new AdhocWorkspace(hostServices).CurrentSolution.AddProject("Project", "Project.dll", NullLanguageService.TestLanguage);
 
-            var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(project.Solution.Workspace.Services) as ISolutionSynchronizationService;
+            var snapshotService = (new RemotableDataServiceFactory()).CreateService(project.Solution.Workspace.Services) as IRemotableDataService;
             using (var snapshot = await snapshotService.CreatePinnedRemotableDataScopeAsync(project.Solution, CancellationToken.None).ConfigureAwait(false))
             {
                 // this shouldn't throw
@@ -601,7 +601,7 @@ private async Task<string> GetXmlDocumentAsync(HostServices services)
                                                    .AddMetadataReference(MetadataReference.CreateFromFile(tempCorlib.Path))
                                                    .Solution;
 
-                var snapshotService = (new SolutionSynchronizationServiceFactory()).CreateService(solution.Workspace.Services) as ISolutionSynchronizationService;
+                var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService;
                 using (var scope = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None))
                 {
                     // recover solution from given snapshot
@@ -642,7 +642,7 @@ private static async Task VerifyOptionSetsAsync(Workspace workspace, string lang
             }
         }
 
-        private async Task<Solution> GetSolutionAsync(ISolutionSynchronizationService service, PinnedRemotableDataScope syncScope)
+        private async Task<Solution> GetSolutionAsync(IRemotableDataService service, PinnedRemotableDataScope syncScope)
         {
             var workspace = new AdhocWorkspace();