WPF - Updated #2779 hack to run asynchronous without crashing. (#2879)

* Updated the issue #2779 hack to run asynchronous without crashing.
* Fixed race condition between ChromiumWebBrowser.Dispose and running code on the CEF UI thread.

Author: mol

CefSharp.Wpf/ChromiumWebBrowser.cs

@@ -1756,7 +1756,7 @@ private void PresentationSourceChangedHandler(object sender, SourceChangedEventA
             }
         }
 
-        private void OnWindowStateChanged(object sender, EventArgs e)
+        private async void OnWindowStateChanged(object sender, EventArgs e)
         {
             var window = (Window)sender;
 
@@ -1767,33 +1767,54 @@ private void OnWindowStateChanged(object sender, EventArgs e)
                 {
                     if (previousWindowState == WindowState.Minimized)
                     {
-                        CefUiThreadRunAsync(() =>
+                        await CefUiThreadRunAsync(async () =>
                         {
-                            if (browser != null)
+                            var host = browser?.GetHost();
+                            if (host != null && !host.IsDisposed)
                             {
-                                browser.GetHost().WasHidden(false);
+                                try
+                                {
+                                    host.WasHidden(false);
+
+                                    await ResizeHackFor2779();
+                                }
+                                catch (ObjectDisposedException)
+                                {
+                                    // Because Dispose runs in another thread there's a race condition between
+                                    // that and this code running on the CEF UI thread, so the host could be disposed
+                                    // between the check and using it. We can either synchronize access using locking
+                                    // (potentially blocking the UI thread in Dispose) or catch the extremely rare
+                                    // exception, which is what we do here
+                                }
                             }
                         });
-
-                        ResizeHackFor2779();
                     }
 
                     break;
                 }
                 case WindowState.Minimized:
                 {
-                    if (EnableResizeHackForIssue2779)
-                    {
-                        resizeHackForIssue2779Enabled = true;
-                    }
-
-                    CefUiThreadRunAsync(() =>
+                    await CefUiThreadRunAsync(() =>
                     {
-                        if (browser != null)
+                        var host = browser?.GetHost();
+                        if (host != null && !host.IsDisposed)
                         {
-                            browser.GetHost().WasHidden(true);
+                            if (EnableResizeHackForIssue2779)
+                            {
+                                resizeHackForIssue2779Enabled = true;
+                            }
+
+                            try
+                            {
+                                host.WasHidden(true);
+                            }
+                            catch (ObjectDisposedException)
+                            {
+                                // See comment in catch in OnWindowStateChanged
+                            }
                         }
                     });
+
                     break;
                 }
             }
@@ -1889,7 +1910,7 @@ internal void UiThreadRunAsync(Action action, DispatcherPriority priority = Disp
             }
         }
 
-        protected void CefUiThreadRunAsync(Action action)
+        protected async Task CefUiThreadRunAsync(Action action)
         {
             if (!IsDisposed && InternalIsBrowserInitialized())
             {
@@ -1899,7 +1920,7 @@ protected void CefUiThreadRunAsync(Action action)
                 }
                 else
                 {
-                    Cef.UIThreadTaskFactory.StartNew(delegate
+                    await Cef.UIThreadTaskFactory.StartNew(delegate
                     {
                         action();
                     });
@@ -1929,54 +1950,96 @@ private void UiThreadRunSync(Action action, DispatcherPriority priority = Dispat
         /// </summary>
         /// <param name="sender">The sender.</param>
         /// <param name="e">The <see cref="SizeChangedEventArgs"/> instance containing the event data.</param>
-        private void OnActualSizeChanged(object sender, SizeChangedEventArgs e)
+        private async void OnActualSizeChanged(object sender, SizeChangedEventArgs e)
         {
             // Initialize RenderClientAdapter when WPF has calculated the actual size of current content.
             CreateOffscreenBrowser(e.NewSize);
 
-            //NOTE: Previous we used Math.Ceiling to round the sizing up, we
-            //now set UseLayoutRounding = true; on the control so the sizes are
-            //already rounded to a whole number for us.
-            viewRect = new Rect(0, 0, (int)e.NewSize.Width, (int)e.NewSize.Height);
+            // If the internal browser isn't initialized then the CEF UI thread is not yet running
+            // and so we need to set the view rectangle here because it has to be set.
+            var hasSetViewRect = false;
+            if (!InternalIsBrowserInitialized())
+            {
+                SetViewRect(e);
+                hasSetViewRect = true;
+            }
 
-            CefUiThreadRunAsync(() =>
+            await CefUiThreadRunAsync(() =>
             {
-                if (browser != null)
+                // If we haven't already set the view rectangle we do it here.
+                // If the browser is initialized we need to set this on the CEF UI thread to
+                // avoid the crash issue reported here: https://github.com/cefsharp/CefSharp/issues/2779
+                if (!hasSetViewRect)
                 {
-                    browser.GetHost().WasResized();
+                    SetViewRect(e);
+                }
+
+                var host = browser?.GetHost();
+                if (host != null && !host.IsDisposed)
+                {
+                    try
+                    {
+                        host.WasResized();
+                    }
+                    catch (ObjectDisposedException)
+                    {
+                        // See comment in catch in OnWindowStateChanged
+                    }
                 }
             });
         }
 
+        private void SetViewRect(SizeChangedEventArgs e)
+        {
+            //NOTE: Previous we used Math.Ceiling to round the sizing up, we
+            //now set UseLayoutRounding = true; on the control so the sizes are
+            //already rounded to a whole number for us.
+            viewRect = new Rect(0, 0, (int)e.NewSize.Width, (int)e.NewSize.Height);
+        }
+
         /// <summary>
         /// Handles the <see cref="E:IsVisibleChanged" /> event.
         /// </summary>
         /// <param name="sender">The sender.</param>
         /// <param name="args">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
-        private void OnIsVisibleChanged(object sender, DependencyPropertyChangedEventArgs args)
+        private async void OnIsVisibleChanged(object sender, DependencyPropertyChangedEventArgs args)
         {
             var isVisible = (bool)args.NewValue;
 
             if (browser != null)
             {
-                CefUiThreadRunAsync(() =>
+                await CefUiThreadRunAsync(async () =>
                 {
-                    if (browser != null)
+                    var host = browser?.GetHost();
+                    if (host != null && !host.IsDisposed)
                     {
-                        browser.GetHost().WasHidden(!isVisible);
+                        try
+                        {
+                            host.WasHidden(!isVisible);
+
+                            if (isVisible)
+                            {
+                                await ResizeHackFor2779();
+                            }
+                            else if (EnableResizeHackForIssue2779)
+                            {
+                                resizeHackForIssue2779Enabled = true;
+                            }
+                        }
+                        catch (ObjectDisposedException)
+                        {
+                            // See comment in catch in OnWindowStateChanged
+                        }
                     }
                 });
 
-
-                if (isVisible)
+                if (browser != null)
                 {
-                    ResizeHackFor2779();
-
                     //Fix for #1778 - When browser becomes visible we update the zoom level
                     //browsers of the same origin will share the same zoomlevel and
                     //we need to track the update, so our ZoomLevelProperty works
                     //properly
-                    browser.GetHost().GetZoomLevelAsync().ContinueWith(t =>
+                    await browser.GetHost().GetZoomLevelAsync().ContinueWith(t =>
                     {
                         if (!IsDisposed)
                         {
@@ -1987,10 +2050,6 @@ private void OnIsVisibleChanged(object sender, DependencyPropertyChangedEventArg
                     TaskContinuationOptions.OnlyOnRanToCompletion,
                     TaskScheduler.FromCurrentSynchronizationContext());
                 }
-                else if (EnableResizeHackForIssue2779)
-                {
-                    resizeHackForIssue2779Enabled = true;
-                }
             }
         }
 
@@ -2442,33 +2501,30 @@ protected bool InternalIsBrowserInitialized()
             return Interlocked.CompareExchange(ref browserInitialized, 0, 0) == 1;
         }
 
-        private void ResizeHackFor2779()
+        private async Task ResizeHackFor2779()
         {
             if (EnableResizeHackForIssue2779)
             {
                 const int delayInMs = 50;
 
-                CefUiThreadRunAsync(async () =>
+                var host = browser?.GetHost();
+                if (host != null && !host.IsDisposed)
                 {
-                    if (browser != null)
-                    {
-                        resizeHackForIssue2779Size = new Structs.Size(viewRect.Width - 1, viewRect.Height - 1);
-                        browser.GetHost().WasResized();
-                    }
+                    resizeHackForIssue2779Size = new Structs.Size(viewRect.Width - 1, viewRect.Height - 1);
+                    host.WasResized();
 
                     await Task.Delay(delayInMs);
 
-                    if (browser != null)
+                    if (!host.IsDisposed)
                     {
-                        var host = browser.GetHost();
                         resizeHackForIssue2779Size = null;
                         host.WasResized();
 
                         resizeHackForIssue2779Enabled = false;
 
                         host.Invalidate(PaintElementType.View);
                     }
-                });
+                }
             }
         }
     }