track non roslyn text buffer changes as well as roslyn text buffer chang...

src/Features/Core/SolutionCrawler/IDocumentTrackingService.cs

@@ -20,5 +20,12 @@ internal interface IDocumentTrackingService : IWorkspaceService
         ImmutableArray<DocumentId> GetVisibleDocuments();
 
         event EventHandler<DocumentId> ActiveDocumentChanged;
+
+        /// <summary>
+        /// Events for Non Roslyn text buffer changes.
+        /// 
+        /// It raises events for buffers opened in a view in host.
+        /// </summary>
+        event EventHandler<EventArgs> NonRoslynBufferTextChanged;
     }
 }

src/Features/Core/SolutionCrawler/WorkCoordinator.GlobalOperationAwareIdleProcessor.cs

@@ -37,12 +37,36 @@ public GlobalOperationAwareIdleProcessor(
                         base(listener, backOffTimeSpanInMs, shutdownToken)
                     {
                         this.Processor = processor;
+
                         _globalOperation = null;
                         _globalOperationTask = SpecializedTasks.EmptyTask;
 
                         _globalOperationNotificationService = globalOperationNotificationService;
                         _globalOperationNotificationService.Started += OnGlobalOperationStarted;
                         _globalOperationNotificationService.Stopped += OnGlobalOperationStopped;
+
+                        if (this.Processor._documentTracker != null)
+                        {
+                            this.Processor._documentTracker.NonRoslynBufferTextChanged += OnNonRoslynBufferTextChanged;
+                        }
+                    }
+
+                    private void OnNonRoslynBufferTextChanged(object sender, EventArgs e)
+                    {
+                        // There are 2 things incremental processor takes care of
+                        //
+                        // #1 is making sure we delay processing any work until there is enough idle (ex, typing) in host.
+                        // #2 is managing cancellation and pending works.
+                        //
+                        // we used to do #1 and #2 only for Roslyn files. and that is usually fine since most of time solution contains only roslyn files.
+                        //
+                        // but for mixed solution (ex, Roslyn files + HTML + JS + CSS), #2 still makes sense but #1 doesn't. We want
+                        // to pause any work while something is going on in other project types as well. 
+                        //
+                        // we need to make sure we play nice with neighbors as well.
+                        //
+                        // now, we don't care where changes are coming from. if there is any change in host, we puase oursevles for a while.
+                        this.UpdateLastAccessTime();
                     }
 
                     protected Task GlobalOperationTask
@@ -114,6 +138,11 @@ public virtual void Shutdown()
                     {
                         _globalOperationNotificationService.Started -= OnGlobalOperationStarted;
                         _globalOperationNotificationService.Stopped -= OnGlobalOperationStopped;
+
+                        if (this.Processor._documentTracker != null)
+                        {
+                            this.Processor._documentTracker.NonRoslynBufferTextChanged -= OnNonRoslynBufferTextChanged;
+                        }
                     }
                 }
             }

src/VisualStudio/Core/Def/Implementation/ProjectSystem/DocumentProvider.cs

@@ -266,12 +266,30 @@ private void OnBeforeDocumentWindowShow(IVsWindowFrame frame, uint docCookie, bo
             {
                 OnBeforeDocumentWindowShow(frame, id, firstShow);
             }
+
+            if (ids.Count == 0)
+            {
+                // deal with non roslyn text file opened in the editor
+                var buffer = TryGetTextBufferFromDocData(RunningDocumentTable.GetDocumentData(docCookie));
+                if (buffer != null)
+                {
+                    OnBeforeNonRoslynDocumentWindowShow(buffer, firstShow);
+                }
+            }
         }
 
         protected virtual void OnBeforeDocumentWindowShow(IVsWindowFrame frame, DocumentId id, bool firstShow)
         {
         }
 
+        protected virtual void OnBeforeNonRoslynDocumentWindowShow(ITextBuffer buffer, bool firstShow)
+        {
+        }
+
+        protected virtual void OnBeforeNonRoslynDocumentClose(ITextBuffer buffer)
+        {
+        }
+
         private IList<DocumentId> GetDocumentIdsFromDocCookie(uint docCookie)
         {
             List<DocumentKey> documentKeys;
@@ -300,35 +318,44 @@ private IList<DocumentId> GetDocumentIdsFromDocCookie(uint docCookie)
         private void CloseDocuments(uint docCookie, string monikerToKeep)
         {
             List<DocumentKey> documentKeys;
-            if (_docCookiesToOpenDocumentKeys.TryGetValue(docCookie, out documentKeys))
+            if (!_docCookiesToOpenDocumentKeys.TryGetValue(docCookie, out documentKeys))
             {
-                // We will remove from documentKeys the things we successfully closed,
-                // so clone the list so we can mutate while enumerating
-                var documentsToClose = documentKeys.Where(key => !StringComparer.OrdinalIgnoreCase.Equals(key.Moniker, monikerToKeep)).ToList();
-
-                // For a given set of open linked or shared files, we may be closing one of the
-                // documents (e.g. excluding a linked file from one of its owning projects or
-                // unloading one of the head projects for a shared project) or the entire set of
-                // documents (e.g. closing the tab of a shared document). If the entire set of
-                // documents is closing, then we should avoid the process of updating the active
-                // context document between the closing of individual documents in the set. In the
-                // case of closing the tab of a shared document, this avoids updating the shared 
-                // item context hierarchy for the entire shared project to head project owning the
-                // last documentKey in this list.
-                var updateActiveContext = documentsToClose.Count == 1;
-
-                foreach (var documentKey in documentsToClose)
+                // let others know about non roslyn document close
+                var buffer = TryGetTextBufferFromDocData(RunningDocumentTable.GetDocumentData(docCookie));
+                if (buffer != null)
                 {
-                    var document = _documentMap[documentKey];
-                    document.ProcessClose(updateActiveContext);
-                    Contract.ThrowIfFalse(documentKeys.Remove(documentKey));
+                    OnBeforeNonRoslynDocumentClose(buffer);
                 }
 
-                // If we removed all the keys, then remove the list entirely
-                if (documentKeys.Count == 0)
-                {
-                    _docCookiesToOpenDocumentKeys.Remove(docCookie);
-                }
+                return;
+            }
+
+            // We will remove from documentKeys the things we successfully closed,
+            // so clone the list so we can mutate while enumerating
+            var documentsToClose = documentKeys.Where(key => !StringComparer.OrdinalIgnoreCase.Equals(key.Moniker, monikerToKeep)).ToList();
+
+            // For a given set of open linked or shared files, we may be closing one of the
+            // documents (e.g. excluding a linked file from one of its owning projects or
+            // unloading one of the head projects for a shared project) or the entire set of
+            // documents (e.g. closing the tab of a shared document). If the entire set of
+            // documents is closing, then we should avoid the process of updating the active
+            // context document between the closing of individual documents in the set. In the
+            // case of closing the tab of a shared document, this avoids updating the shared 
+            // item context hierarchy for the entire shared project to head project owning the
+            // last documentKey in this list.
+            var updateActiveContext = documentsToClose.Count == 1;
+
+            foreach (var documentKey in documentsToClose)
+            {
+                var document = _documentMap[documentKey];
+                document.ProcessClose(updateActiveContext);
+                Contract.ThrowIfFalse(documentKeys.Remove(documentKey));
+            }
+
+            // If we removed all the keys, then remove the list entirely
+            if (documentKeys.Count == 0)
+            {
+                _docCookiesToOpenDocumentKeys.Remove(docCookie);
             }
         }
 

src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioDocumentTrackingService.cs

@@ -1,26 +1,34 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
     [DebuggerDisplay("{GetDebuggerDisplay(),nq}")]
     internal class VisualStudioDocumentTrackingService : IDocumentTrackingService, IVsSelectionEvents, IDisposable
     {
+        private readonly NonRoslynTextBufferTracker _tracker;
+
         private IVsMonitorSelection _monitorSelection;
         private uint _cookie;
         private ImmutableList<FrameListener> _visibleFrames;
         private IVsWindowFrame _activeFrame;
 
         public VisualStudioDocumentTrackingService(IServiceProvider serviceProvider)
         {
+            _tracker = new NonRoslynTextBufferTracker(this);
+
             _visibleFrames = ImmutableList<FrameListener>.Empty;
 
             _monitorSelection = (IVsMonitorSelection)serviceProvider.GetService(typeof(SVsShellMonitorSelection));
@@ -132,6 +140,18 @@ public int OnCmdUIContextChanged([ComAliasName("Microsoft.VisualStudio.Shell.Int
             return VSConstants.E_NOTIMPL;
         }
 
+        public event EventHandler<EventArgs> NonRoslynBufferTextChanged;
+
+        public void OnNonRoslynBufferOpened(ITextBuffer buffer)
+        {
+            _tracker.OnOpened(buffer);
+        }
+
+        public void OnNonRoslynBufferClosed(ITextBuffer buffer)
+        {
+            _tracker.OnClosed(buffer);
+        }
+
         public void Dispose()
         {
             if (_cookie != VSConstants.VSCOOKIE_NIL && _monitorSelection != null)
@@ -262,5 +282,51 @@ internal string GetDebuggerDisplay()
                 return caption.ToString();
             }
         }
+
+        /// <summary>
+        /// It tracks non roslyn text buffer text changes.
+        /// </summary>
+        private class NonRoslynTextBufferTracker : ForegroundThreadAffinitizedObject
+        {
+            private readonly VisualStudioDocumentTrackingService _owner;
+            private readonly HashSet<ITextBuffer> _buffers;
+
+            public NonRoslynTextBufferTracker(VisualStudioDocumentTrackingService owner)
+            {
+                _owner = owner;
+                _buffers = new HashSet<ITextBuffer>();
+            }
+
+            public void OnOpened(ITextBuffer buffer)
+            {
+                AssertIsForeground();
+
+                if (_buffers.Contains(buffer))
+                {
+                    return;
+                }
+
+                _buffers.Add(buffer);
+                buffer.PostChanged += OnTextChanged;
+            }
+
+            public void OnClosed(ITextBuffer buffer)
+            {
+                AssertIsForeground();
+
+                if (!_buffers.Contains(buffer))
+                {
+                    return;
+                }
+
+                buffer.PostChanged -= OnTextChanged;
+                _buffers.Remove(buffer);
+            }
+
+            private void OnTextChanged(object sender, EventArgs e)
+            {
+                _owner.NonRoslynBufferTextChanged?.Invoke(sender, e);
+            }
+        }
     }
 }

src/VisualStudio/Core/Def/RoslynDocumentProvider.cs

@@ -5,6 +5,7 @@
 using Microsoft.VisualStudio.LanguageServices.Implementation;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Text;
 
 namespace Microsoft.VisualStudio.LanguageServices
 {
@@ -23,10 +24,28 @@ public RoslynDocumentProvider(
 
         protected override void OnBeforeDocumentWindowShow(IVsWindowFrame frame, DocumentId id, bool firstShow)
         {
-            if (_documentTrackingService != null)
+            base.OnBeforeDocumentWindowShow(frame, id, firstShow);
+
+            _documentTrackingService?.DocumentFrameShowing(frame, id, firstShow);
+        }
+
+        protected override void OnBeforeNonRoslynDocumentWindowShow(ITextBuffer buffer, bool firstShow)
+        {
+            base.OnBeforeNonRoslynDocumentWindowShow(buffer, firstShow);
+
+            if (!firstShow)
             {
-                _documentTrackingService.DocumentFrameShowing(frame, id, firstShow);
+                return;
             }
+
+            _documentTrackingService?.OnNonRoslynBufferOpened(buffer);
+        }
+
+        protected override void OnBeforeNonRoslynDocumentClose(ITextBuffer buffer)
+        {
+            base.OnBeforeNonRoslynDocumentClose(buffer);
+
+            _documentTrackingService?.OnNonRoslynBufferClosed(buffer);
         }
     }
 }