WPF - Add basic Wpf HwndHost implementation

Author: amaitland

CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs

@@ -99,12 +99,30 @@ Task IOutOfProcessClientRpc.CreateBrowser(IntPtr parentHwnd, string url, int id)
                 windowInfo.WindowName = "CefSharpBrowserProcess";
                 windowInfo.SetAsChild(parentHwnd);
 
+                //Disable Window activation by default
+                //https://bitbucket.org/chromiumembedded/cef/issues/1856/branch-2526-cef-activates-browser-window
+                windowInfo.ExStyle |= OutOfProcessChromiumWebBrowser.WS_EX_NOACTIVATE;
+
                 browser.CreateBrowser(windowInfo);
 
                 _browsers.Add(browser);
 
                 return true;
             });
         }
+
+        void IOutOfProcessClientRpc.NotifyMoveOrResizeStarted(int browserId)
+        {
+            var browser = _browsers.FirstOrDefault(x => x.Id == browserId);
+
+            browser?.GetBrowserHost().NotifyMoveOrResizeStarted();
+        }
+
+        void IOutOfProcessClientRpc.SetFocus(int browserId, bool focus)
+        {
+            var browser = _browsers.FirstOrDefault(x => x.Id == browserId);
+
+            browser?.GetBrowserHost().SetFocus(focus);
+        }
     }
 }

CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs

@@ -6,6 +6,9 @@
 using CefSharp.Callback;
 using System.IO;
 using CefSharp.OutOfProcess.Interface;
+using System.Runtime.InteropServices;
+using PInvoke;
+using System.Diagnostics;
 
 namespace CefSharp.OutOfProcess.BrowserProcess
 {
@@ -19,9 +22,17 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
             "The undelying CefBrowser instance is not yet initialized. Use the IsBrowserInitializedChanged event and check " +
             "the IsBrowserInitialized property to determine when the browser has been initialized.";
 
+        public const uint WS_EX_NOACTIVATE = 0x08000000;
+
         private IDevToolsMessageObserver _devtoolsMessageObserver;
         private IRegistration _devtoolsRegistration;
 
+        /// <summary>
+        /// If true the the WS_EX_NOACTIVATE style will be removed so that future mouse clicks
+        /// inside the browser correctly activate and focus the window.
+        /// </summary>
+        private bool _removeExNoActivateStyle;
+
         /// <summary>
         /// Internal ID used for tracking browsers between Processes;
         /// </summary>
@@ -382,6 +393,18 @@ void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)
         /// <param name="args">The <see cref="LoadingStateChangedEventArgs"/> instance containing the event data.</param>
         void IWebBrowserInternal.SetLoadingStateChange(LoadingStateChangedEventArgs args)
         {
+            if (_removeExNoActivateStyle && InternalIsBrowserInitialized())
+            {
+                _removeExNoActivateStyle = false;
+
+                var hwnd = BrowserCore.GetHost().GetWindowHandle();
+
+                // Remove the WS_EX_NOACTIVATE style so that future mouse clicks inside the
+                // browser correctly activate and focus the browser. 
+                //https://github.com/chromiumembedded/cef/blob/9df4a54308a88fd80c5774d91c62da35afb5fd1b/tests/cefclient/browser/root_window_win.cc#L1088
+                RemoveExNoActivateStyle(hwnd);
+            }
+
             CanGoBack = args.CanGoBack;
             CanGoForward = args.CanGoForward;
             IsLoading = args.IsLoading;
@@ -391,6 +414,42 @@ void IWebBrowserInternal.SetLoadingStateChange(LoadingStateChangedEventArgs args
             LoadingStateChanged?.Invoke(this, args);
         }
 
+        [DllImport("user32.dll", EntryPoint = "GetWindowLong")]
+        private static extern IntPtr GetWindowLongPtr(IntPtr hWnd, int index);
+
+        [DllImport("user32.dll", EntryPoint = "SetWindowLong")]
+        private static extern int SetWindowLong32(HandleRef hWnd, int index, int dwNewLong);
+
+        [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")]
+        private static extern IntPtr SetWindowLongPtr64(HandleRef hWnd, int index, IntPtr dwNewLong);
+
+        private const int GWL_EXSTYLE = -20;
+
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowlongptra
+        //SetWindowLongPtr for x64, SetWindowLong for x86
+        private void RemoveExNoActivateStyle(IntPtr hwnd)
+        {
+            var exStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
+
+            if (IntPtr.Size == 8)
+            {
+                if ((exStyle.ToInt64() & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE)
+                {
+                    exStyle = new IntPtr(exStyle.ToInt64() & ~WS_EX_NOACTIVATE);
+                    //Remove WS_EX_NOACTIVATE
+                    SetWindowLongPtr64(new HandleRef(this, hwnd), GWL_EXSTYLE, exStyle);
+                }
+            }
+            else
+            {
+                if ((exStyle.ToInt32() & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE)
+                {
+                    //Remove WS_EX_NOACTIVATE
+                    SetWindowLong32(new HandleRef(this, hwnd), GWL_EXSTYLE, (int)(exStyle.ToInt32() & ~WS_EX_NOACTIVATE));
+                }
+            }
+        }
+
         /// <inheritdoc/>
         public void LoadUrl(string url)
         {
@@ -699,6 +758,8 @@ protected virtual void Dispose(bool disposing)
         /// <exception cref="System.Exception">An instance of the underlying browser has already been created, this method can only be called once.</exception>
         public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browserSettings = null)
         {
+            //Debugger.Break();
+
             if (_browserCreated)
             {
                 throw new Exception("An instance of the underlying browser has already been created, this method can only be called once.");
@@ -711,11 +772,9 @@ public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browse
                 browserSettings = Core.ObjectFactory.CreateBrowserSettings(autoDispose: true);
             }
 
-            if (windowInfo == null)
-            {
-                windowInfo = Core.ObjectFactory.CreateWindowInfo();
-                windowInfo.SetAsWindowless(IntPtr.Zero);
-            }
+            //We actually check if WS_EX_NOACTIVATE was set for instances
+            //the user has override CreateBrowserWindowInfo and not called base.CreateBrowserWindowInfo
+            _removeExNoActivateStyle = (windowInfo.ExStyle & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE;
 
             //TODO: We need some sort of timeout and
             //if we use the same approach for WPF/WinForms then

CefSharp.OutOfProcess.BrowserProcess/Program.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics;
-using System.IO;
 using System.Threading.Tasks;
 using CefSharp.Internals;
 
@@ -18,21 +17,27 @@ public static int Main(string[] args)
             //Debugger.Launch();
 
             var parentProcessId = int.Parse(CommandLineArgsParser.GetArgumentValue(args, "--parentProcessId"));
+            var cachePath = CommandLineArgsParser.GetArgumentValue(args, "--cachePath");
 
             var parentProcess = Process.GetProcessById(parentProcessId);
 
             var settings = new CefSettings()
             {
                 //By default CefSharp will use an in-memory cache, you need to specify a Cache Folder to persist data
-                CachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\OutOfProcessCache"),
+                CachePath = cachePath,
                 MultiThreadedMessageLoop = false
             };
 
             var browserProcessHandler = new BrowserProcessHandler(parentProcessId);
 
             Cef.EnableWaitForBrowsersToClose();
 
-            Cef.Initialize(settings, performDependencyCheck:true, browserProcessHandler: browserProcessHandler);
+            var success = Cef.Initialize(settings, performDependencyCheck:true, browserProcessHandler: browserProcessHandler);
+
+            if(!success)
+            {
+                return 1;
+            }
 
             _ = Task.Run(() =>
             {

CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs

@@ -13,10 +13,6 @@ public interface IChromiumWebBrowser : IDisposable
         /// Occurs when the browser address changed.
         /// </summary>
         event EventHandler<AddressChangedEventArgs> AddressChanged;
-        /// <summary>
-        /// Occurs when document title changes.
-        /// </summary>
-        event EventHandler<TitleChangedEventArgs> TitleChanged;
 
         /// <summary>
         /// Event handler for changes to the status message.

CefSharp.OutOfProcess.Core/Internal/IChromiumWebBrowserInternal.cs

@@ -13,7 +13,7 @@ public interface IChromiumWebBrowserInternal : IChromiumWebBrowser
         /// Set the browser Hwnd
         /// </summary>
         /// <param name="hwnd">Hwnd</param>
-        void SetBrowserHwnd(IntPtr hwnd);
+        void OnAfterBrowserCreated(IntPtr hwnd);
 
         /// <summary>
         /// Called when a DevTools message arrives from the browser process

CefSharp.OutOfProcess.Core/OutOfProcessHost.cs

@@ -19,21 +19,22 @@ public class OutOfProcessHost : IOutOfProcessHostRpc, IDisposable
 
         private Process _browserProcess;
         private JsonRpc _jsonRpc;
-        private IOutOfProcessClientRpc _browserProcessServer;
+        private IOutOfProcessClientRpc _outOfProcessClient;
         private string _cefSharpVersion;
         private string _cefVersion;
         private string _chromiumVersion;
         private int _uiThreadId;
         private int _remoteuiThreadId;
         private int _browserIdentifier = 1;
-        private string _outofProcessFilePath;
-
+        private string _outofProcessHostExePath;
+        private string _cachePath;
         private ConcurrentDictionary<int, IChromiumWebBrowserInternal> _browsers = new ConcurrentDictionary<int, IChromiumWebBrowserInternal>();
         private TaskCompletionSource<OutOfProcessHost> _processInitialized = new TaskCompletionSource<OutOfProcessHost>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        private OutOfProcessHost(string path)
+        private OutOfProcessHost(string outOfProcessHostExePath, string cachePath = null)
         {
-            _outofProcessFilePath = path;
+            _outofProcessHostExePath = outOfProcessHostExePath;
+            _cachePath = cachePath;
         }
 
         /// <summary>
@@ -88,14 +89,14 @@ public string ChromiumVersion
         public bool CreateBrowser(IChromiumWebBrowserInternal browser, IntPtr handle, string url, out int id)
         {
             id = _browserIdentifier++;
-            _ = _browserProcessServer.CreateBrowser(handle, url, id);
+            _ = _outOfProcessClient.CreateBrowser(handle, url, id);
 
             return _browsers.TryAdd(id, browser);
         }
 
         internal Task SendDevToolsMessageAsync(int browserId, string message)
         {
-            return _browserProcessServer.SendDevToolsMessage(browserId, message);
+            return _outOfProcessClient.SendDevToolsMessage(browserId, message);
         }
 
         private Task<OutOfProcessHost> InitializedTask
@@ -107,24 +108,31 @@ private void Init()
         {
             var currentProcess = Process.GetCurrentProcess();
 
-            var args = $"--parentProcessId={currentProcess.Id}";
+            var args = $"--parentProcessId={currentProcess.Id} --cachePath={_cachePath}";
 
-            _browserProcess = Process.Start(new ProcessStartInfo(_outofProcessFilePath, args)
+            _browserProcess = Process.Start(new ProcessStartInfo(_outofProcessHostExePath, args)
             {
                 RedirectStandardInput = true,
                 RedirectStandardOutput = true,
             });
 
+            _browserProcess.Exited += OnBrowserProcessExited;
+
             _jsonRpc = JsonRpc.Attach(_browserProcess.StandardInput.BaseStream, _browserProcess.StandardOutput.BaseStream);
 
-            _browserProcessServer = _jsonRpc.Attach<IOutOfProcessClientRpc>();
+            _outOfProcessClient = _jsonRpc.Attach<IOutOfProcessClientRpc>();
             _jsonRpc.AllowModificationWhileListening = true;
             _jsonRpc.AddLocalRpcTarget<IOutOfProcessHostRpc>(this, null);
             _jsonRpc.AllowModificationWhileListening = false;
 
             _uiThreadId = Kernel32.GetCurrentThreadId();
         }
 
+        private void OnBrowserProcessExited(object sender, EventArgs e)
+        {
+            var exitCode = _browserProcess.ExitCode;
+        }
+
         void IOutOfProcessHostRpc.NotifyAddressChanged(int browserId, string address)
         {
             if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
@@ -137,7 +145,7 @@ void IOutOfProcessHostRpc.NotifyBrowserCreated(int browserId, IntPtr browserHwnd
         {
             if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
             {
-                chromiumWebBrowser.SetBrowserHwnd(browserHwnd);
+                chromiumWebBrowser.OnAfterBrowserCreated(browserHwnd);
             }
         }
 
@@ -199,19 +207,34 @@ void IOutOfProcessHostRpc.NotifyTitleChanged(int browserId, string title)
             }
         }
 
+        public void NotifyMoveOrResizeStarted(int id)
+        {
+            _outOfProcessClient.NotifyMoveOrResizeStarted(id);
+        }
+
+        /// <summary>
+        /// Set whether the browser is focused. (Used for Normal Rendering e.g. WinForms)
+        /// </summary>
+        /// <param name="id">browser id</param>
+        /// <param name="focus">set focus</param>
+        public void SetFocus(int id, bool focus)
+        {
+            _outOfProcessClient.SetFocus(id, focus);
+        }
+
         public void CloseBrowser(int id)
         {
-            _browserProcessServer.CloseBrowser(id);
+            _ = _outOfProcessClient.CloseBrowser(id);
         }
 
         public void Dispose()
         {
-            _browserProcessServer.CloseHost();
+            _ = _outOfProcessClient.CloseHost();
             _jsonRpc?.Dispose();
             _jsonRpc = null;
         }
 
-        public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName)
+        public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName, string cachePath = null)
         {
             if(string.IsNullOrEmpty(path))
             {
@@ -225,7 +248,7 @@ public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName)
                 throw new FileNotFoundException("Unable to find Host executable.", path);
             }
 
-            var host = new OutOfProcessHost(fullPath);
+            var host = new OutOfProcessHost(fullPath, cachePath);
 
             host.Init();            
 

CefSharp.OutOfProcess.Interface/IOutOfProcessClientRpc.cs

@@ -20,7 +20,7 @@ public interface IOutOfProcessClientRpc
         /// </summary>
         /// <param name="browserId">browser Id</param>
         /// <param name="message"devtools message (json)></param>
-        /// <returns></returns>
+        /// <returns>Task</returns>
         Task SendDevToolsMessage(int browserId, string message);
 
         /// <summary>
@@ -34,8 +34,22 @@ public interface IOutOfProcessClientRpc
         /// </summary>
         /// <param name="parentHwnd">parent Hwnd</param>
         /// <param name="url">start url</param>
-        /// <param name="id">browser id</param>
+        /// <param name="browserId">browser id</param>
         /// <returns>Task</returns>
-        Task CreateBrowser(IntPtr parentHwnd, string url, int id);
+        Task CreateBrowser(IntPtr parentHwnd, string url, int browserId);
+
+        /// <summary>
+        /// Notify the browser that the window hosting it is about to be moved or resized.
+        /// This will dismiss any existing popups (dropdowns).
+        /// </summary>
+        /// <param name="browserId">browser Id</param>
+        void NotifyMoveOrResizeStarted(int browserId);
+
+        /// <summary>
+        /// Set whether the browser is focused.
+        /// </summary>
+        /// <param name="id">browser id</param>
+        /// <param name="focus">set focus</param>
+        void SetFocus(int browserId, bool focus);
     }
 }

CefSharp.OutOfProcess.WinForms.Example/BrowserForm.cs

@@ -61,7 +61,8 @@ private async void BrowserFormLoad(object sender, EventArgs e)
         {
             var outOfProcessHostPath = Path.GetFullPath($"..\\..\\..\\..\\..\\CefSharp.OutOfProcess.BrowserProcess\\bin\\{_buildType}\\{_targetFramework}");
             outOfProcessHostPath = Path.Combine(outOfProcessHostPath, OutOfProcessHost.HostExeName);
-            _outOfProcessHost = await OutOfProcessHost.CreateAsync(outOfProcessHostPath);
+            var cachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\OutOfProcessCache");
+            _outOfProcessHost = await OutOfProcessHost.CreateAsync(outOfProcessHostPath, cachePath);
 
             AddTab(DefaultUrlForAddedTabs);
         }

CefSharp.OutOfProcess.WinForms.Example/BrowserTabUserControl.cs

@@ -43,7 +43,7 @@ private async void OnBrowserNetworkRequestFailed(object sender, Puppeteer.Reques
         {
             var request = args.Request;
 
-            var errorHtml = string.Format("<html><body><h2>Failed to load URL {0} with error {1} ({2}).</h2></body></html>",
+            var errorHtml = string.Format("<html><body><h2>Failed to load URL {0} with error {1}.</h2></body></html>",
                                               request.Url, request.Failure);
 
             await Browser.MainFrame.SetContentAsync(errorHtml);