Import Tabbed form from CefSharp.WinForms.Example

Author: amaitland

CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs

@@ -76,7 +76,7 @@ protected override void OnContextInitialized()
 
             var threadId = Kernel32.GetCurrentThreadId();
 
-            _ = _jsonRpc.NotifyAsync("OnContextInitialized", threadId);
+            _ = _jsonRpc.NotifyAsync("OnContextInitialized", threadId, Cef.CefSharpVersion, Cef.CefVersion, Cef.ChromiumVersion);
         }
 
         protected override void Dispose(bool disposing)

CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs

@@ -1,4 +1,5 @@
-using System;
+using CefSharp.Puppeteer;
+using System.Threading.Tasks;
 
 namespace CefSharp.OutOfProcess
 {
@@ -8,25 +9,74 @@ namespace CefSharp.OutOfProcess
     public interface IChromiumWebBrowser
     {
         /// <summary>
-        /// Identifier
+        /// Loads the specified <paramref name="url"/> in the Main Frame.
         /// </summary>
-        int Id { get; }
+        /// <param name="url">The URL to be loaded.</param>
+        /// <remarks>
+        /// This is exactly the same as calling Load(string), it was added
+        /// as the method name is more meaningful and easier to discover
+        /// via Intellisense.
+        /// </remarks>
+        void LoadUrl(string url);
 
         /// <summary>
-        /// Set the browser Hwnd
+        /// A flag that indicates whether the WebBrowser is initialized (true) or not (false).
         /// </summary>
-        /// <param name="hwnd">Hwnd</param>
-        void SetBrowserHwnd(IntPtr hwnd);
+        /// <value><c>true</c> if this instance is browser initialized; otherwise, <c>false</c>.</value>
+        bool IsBrowserInitialized { get; }
 
         /// <summary>
-        /// Called when a DevTools message arrives from the browser process
+        /// A flag that indicates whether the WebBrowser has been disposed (<see langword="true" />) or not (<see langword="false" />)
         /// </summary>
-        /// <param name="jsonMsg"></param>
-        void OnDevToolsMessage(string jsonMsg);
+        /// <value><see langword="true" /> if this instance is disposed; otherwise, <see langword="false" /></value>
+        bool IsDisposed { get; }
 
         /// <summary>
-        /// DevTools is ready in the browser process to create the DevToolsContext
+        /// The address (URL) which the browser control is currently displaying.
+        /// Will automatically be updated as the user navigates to another page (e.g. by clicking on a link).
         /// </summary>
-        void OnDevToolsReady();
+        /// <value>The address.</value>
+        /// <remarks>In the WPF control, this property is implemented as a Dependency Property and fully supports data
+        /// binding.</remarks>
+        string Address { get; }
+
+        /// <summary>
+        /// Gets all frames attached to the page.
+        /// </summary>
+        /// <value>An array of all frames attached to the page.</value>
+        Frame[] Frames { get; }
+
+        /// <summary>
+        /// Gets page's main frame
+        /// </summary>
+        /// <remarks>
+        /// Page is guaranteed to have a main frame which persists during navigations.
+        /// </remarks>
+        Frame MainFrame { get; }
+
+        /// <summary>
+        /// Navigates to an url
+        /// </summary>
+        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>
+        /// <param name="timeout">Maximum navigation time in milliseconds, defaults to 30 seconds, pass <c>0</c> to disable timeout. </param>
+        /// <param name="waitUntil">When to consider navigation succeeded, defaults to <see cref="WaitUntilNavigation.Load"/>. Given an array of <see cref="WaitUntilNavigation"/>, navigation is considered to be successful after all events have been fired</param>
+        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>
+        Task<Response> LoadUrlAsync(string url, int? timeout = null, WaitUntilNavigation[] waitUntil = null);
+
+        /// <summary>
+        /// Navigate to the previous page in history.
+        /// </summary>
+        /// <returns>Task that resolves to the main resource response. In case of multiple redirects,
+        /// the navigation will resolve with the response of the last redirect. If can not go back, resolves to null.</returns>
+        /// <param name="options">Navigation parameters.</param>
+        Task<Response> GoBackAsync(NavigationOptions options = null);
+
+        /// <summary>
+        /// Navigate to the next page in history.
+        /// </summary>
+        /// <returns>Task that resolves to the main resource response. In case of multiple redirects,
+        /// the navigation will resolve with the response of the last redirect. If can not go forward, resolves to null.</returns>
+        /// <param name="options">Navigation parameters.</param>
+        Task<Response> GoForwardAsync(NavigationOptions options = null);
     }
 }

CefSharp.OutOfProcess.Core/Internal/IChromiumWebBrowserInternal.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace CefSharp.OutOfProcess.Internal
+{
+    public interface IChromiumWebBrowserInternal : IChromiumWebBrowser
+    {
+        /// <summary>
+        /// Identifier
+        /// </summary>
+        int Id { get; }
+
+        /// <summary>
+        /// Set the browser Hwnd
+        /// </summary>
+        /// <param name="hwnd">Hwnd</param>
+        void SetBrowserHwnd(IntPtr hwnd);
+
+        /// <summary>
+        /// Called when a DevTools message arrives from the browser process
+        /// </summary>
+        /// <param name="jsonMsg"></param>
+        void OnDevToolsMessage(string jsonMsg);
+
+        /// <summary>
+        /// DevTools is ready in the browser process to create the DevToolsContext
+        /// </summary>
+        void OnDevToolsReady();
+    }
+}

CefSharp.OutOfProcess.Core/OutOfProcessConnectionTransport.cs

@@ -30,7 +30,7 @@ public void InvokeMessageReceived(string message)
 
         public Task SendAsync(string message)
         {
-            return OutOfProcessHost.SendDevToolsMessage(BrowserId, message);
+            return OutOfProcessHost.SendDevToolsMessageAsync(BrowserId, message);
         }
 
         public void StopReading()

CefSharp.OutOfProcess.Core/OutOfProcessHost.cs

@@ -1,4 +1,5 @@
-using PInvoke;
+using CefSharp.OutOfProcess.Internal;
+using PInvoke;
 using StreamJsonRpc;
 using System;
 using System.Collections.Concurrent;
@@ -17,11 +18,14 @@ public class OutOfProcessHost : IDisposable
 
         private Process _browserProcess;
         private JsonRpc _jsonRpc;
+        private string _cefSharpVersion;
+        private string _cefVersion;
+        private string _chromiumVersion;
         private int _uiThreadId;
         private int _remoteuiThreadId;
         private int _browserIdentifier = 1;
         private string _outofProcessFilePath;
-        private ConcurrentDictionary<int, IChromiumWebBrowser> _browsers = new ConcurrentDictionary<int, IChromiumWebBrowser>();
+        private ConcurrentDictionary<int, IChromiumWebBrowserInternal> _browsers = new ConcurrentDictionary<int, IChromiumWebBrowserInternal>();
 
         private TaskCompletionSource<OutOfProcessHost> _processInitialized = new TaskCompletionSource<OutOfProcessHost>(TaskCreationOptions.RunContinuationsAsynchronously);
 
@@ -30,15 +34,30 @@ private OutOfProcessHost(string path)
             _outofProcessFilePath = path;
         }
 
-        public bool CreateBrowser(IChromiumWebBrowser browser, IntPtr handle, string url, out int id)
+        public string CefSharpVerson
+        {
+            get { return _cefSharpVersion; }
+        }
+
+        public string CefVersion
+        {
+            get { return _cefVersion; }
+        }
+
+        public string ChromiumVersion
+        {
+            get { return _chromiumVersion; }
+        }
+
+        public bool CreateBrowser(IChromiumWebBrowserInternal browser, IntPtr handle, string url, out int id)
         {
             id = _browserIdentifier++;
             _ = _jsonRpc.NotifyAsync("CreateBrowser", handle.ToInt32(), url, id);
 
             return _browsers.TryAdd(id, browser);
         }
 
-        internal Task SendDevToolsMessage(int browserId, string message)
+        internal Task SendDevToolsMessageAsync(int browserId, string message)
         {
             return _jsonRpc.NotifyAsync("SendDevToolsMessage", browserId, message);            
         }
@@ -75,9 +94,12 @@ private void Init()
                 //var attached = User32.AttachThreadInput(_remoteThreadId, _uiThreadId, true);
             });
 
-            _jsonRpc.AddLocalRpcMethod("OnContextInitialized", (Action<int>) delegate (int threadId)
+            _jsonRpc.AddLocalRpcMethod("OnContextInitialized", (Action<int, string, string, string>) delegate (int threadId, string cefSharpVersion, string cefVersion, string chromiumVersion)
             {
                 _remoteuiThreadId = threadId;
+                _cefSharpVersion = cefSharpVersion;
+                _cefVersion = cefVersion;
+                _chromiumVersion = chromiumVersion;
 
                 _processInitialized.TrySetResult(this);
 
@@ -118,7 +140,7 @@ public void CloseBrowser(int id)
 
         public void Dispose()
         {
-            _jsonRpc?.NotifyAsync("CloseHost");
+            _ = _jsonRpc?.NotifyAsync("CloseHost");
             _jsonRpc?.Dispose();
             _jsonRpc = null;
         }