Update to native Electron 13.1.5, Update Changelog

ElectronNET.API/BrowserWindow.cs

@@ -2340,58 +2340,5 @@ namespace ElectronNET.API
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             NullValueHandling = NullValueHandling.Ignore
         };
-
-        /// <summary>
-        /// Adds Chrome extension located at path, and returns extension's name.
-        /// The method will also not return if the extension's manifest is missing or incomplete.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <param name="path">Path to the Chrome extension</param>
-        /// <returns></returns>
-        public static Task<string> AddExtensionAsync(string path)
-        {
-            var taskCompletionSource = new TaskCompletionSource<string>();
-
-            BridgeConnector.Socket.On("browserWindow-addExtension-completed", (extensionname) => {
-                BridgeConnector.Socket.Off("browserWindow-addExtension-completed");
-
-                taskCompletionSource.SetResult(extensionname.ToString());
-            });
-
-            BridgeConnector.Socket.Emit("browserWindowAddExtension", path);
-
-            return taskCompletionSource.Task;
-        }
-
-        /// <summary>
-        /// Remove Chrome extension with the specified name.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <param name="name">Name of the Chrome extension to remove</param>
-        public static void RemoveExtension(string name)
-        {
-            BridgeConnector.Socket.Emit("browserWindowRemoveExtension", name);
-        }
-
-        /// <summary>
-        /// The keys are the extension names and each value is an object containing name and version properties.
-        /// Note: This API cannot be called before the ready event of the app module is emitted.
-        /// </summary>
-        /// <returns></returns>
-        public static Task<ChromeExtensionInfo[]> GetExtensionsAsync()
-        {
-            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
-
-            BridgeConnector.Socket.On("browserWindow-getExtensions-completed", (extensionslist) => {
-                BridgeConnector.Socket.Off("browserWindow-getExtensions-completed");
-                var chromeExtensionInfos = ((JArray)extensionslist).ToObject<ChromeExtensionInfo[]>();
-                
-                taskCompletionSource.SetResult(chromeExtensionInfos);
-            });
-
-            BridgeConnector.Socket.Emit("browserWindowGetExtensions");
-
-            return taskCompletionSource.Task;
-        }
     }
 }

ElectronNET.API/Entities/Extension.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Docs: https://electronjs.org/docs/api/structures/extension
+    /// </summary>
+    public class Extension
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Copy of the extension's manifest data.
+        /// </summary>
+        public dynamic Manifest { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The extension's file path.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// The extension's `chrome-extension://` URL.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public string Version { get; set; }
+    }
+}

ElectronNET.API/Entities/WebPreferences.cs

@@ -185,8 +185,8 @@ namespace ElectronNET.API.Entities
         /// Context' entry in the combo box at the top of the Console tab. This option is
         /// currently experimental and may change or be removed in future Electron releases.
         /// </summary>
-        [DefaultValue(true)]
-        public bool ContextIsolation { get; set; } = true;
+        [DefaultValue(false)]
+        public bool ContextIsolation { get; set; } = false;
 
         /// <summary>
         /// Whether to use native window.open(). Defaults to false. This option is currently experimental.

ElectronNET.API/Session.cs

@@ -375,6 +375,81 @@ namespace ElectronNET.API
             BridgeConnector.Socket.Emit("webContents-session-setUserAgent", Id, userAgent, acceptLanguages);
         }
 
+        /// <summary>
+        /// The keys are the extension names and each value is an object containing name and version properties.
+        /// Note: This API cannot be called before the ready event of the app module is emitted.
+        /// </summary>
+        /// <returns></returns>
+        public Task<ChromeExtensionInfo[]> GetAllExtensionsAsync()
+        {
+            var taskCompletionSource = new TaskCompletionSource<ChromeExtensionInfo[]>();
+
+            BridgeConnector.Socket.On("webContents-session-getAllExtensions-completed", (extensionslist) =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-getAllExtensions-completed");
+                var chromeExtensionInfos = ((JArray)extensionslist).ToObject<ChromeExtensionInfo[]>();
+
+                taskCompletionSource.SetResult(chromeExtensionInfos);
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-getAllExtensions", Id);
+
+            return taskCompletionSource.Task;
+        }
+
+        /// <summary>
+        /// Remove Chrome extension with the specified name.
+        /// Note: This API cannot be called before the ready event of the app module is emitted.
+        /// </summary>
+        /// <param name="name">Name of the Chrome extension to remove</param>
+        public void RemoveExtension(string name)
+        {
+            BridgeConnector.Socket.Emit("webContents-session-removeExtension", Id, name);
+        }
+
+        /// <summary>
+        /// resolves when the extension is loaded.
+        ///
+        /// This method will raise an exception if the extension could not be loaded.If
+        /// there are warnings when installing the extension (e.g. if the extension requests
+        /// an API that Electron does not support) then they will be logged to the console.
+        ///
+        /// Note that Electron does not support the full range of Chrome extensions APIs.
+        /// See Supported Extensions APIs for more details on what is supported.
+        ///
+        /// Note that in previous versions of Electron, extensions that were loaded would be
+        /// remembered for future runs of the application.This is no longer the case:
+        /// `loadExtension` must be called on every boot of your app if you want the
+        /// extension to be loaded.
+        ///
+        /// This API does not support loading packed (.crx) extensions.
+        ///
+        ///** Note:** This API cannot be called before the `ready` event of the `app` module
+        /// is emitted.
+        ///
+        ///** Note:** Loading extensions into in-memory(non-persistent) sessions is not supported and will throw an error.
+        /// </summary>
+        /// <param name="path">Path to the Chrome extension</param>
+        /// <param name="allowFileAccess">Whether to allow the extension to read local files over `file://` protocol and
+        /// inject content scripts into `file://` pages. This is required e.g. for loading
+        /// devtools extensions on `file://` URLs. Defaults to false.</param>
+        /// <returns></returns>
+        public Task<Extension> LoadExtensionAsync(string path, bool allowFileAccess = false)
+        {
+            var taskCompletionSource = new TaskCompletionSource<Extension>();
+
+            BridgeConnector.Socket.On("webContents-session-loadExtension-completed", (extension) =>
+            {
+                BridgeConnector.Socket.Off("webContents-session-loadExtension-completed");
+
+                taskCompletionSource.SetResult(((JObject)extension).ToObject<Extension>());
+            });
+
+            BridgeConnector.Socket.Emit("webContents-session-loadExtension", Id, path, allowFileAccess);
+
+            return taskCompletionSource.Task;
+        }
+
         private JsonSerializer _jsonSerializer = new JsonSerializer()
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),

ElectronNET.API/Shell.cs

@@ -120,20 +120,19 @@ namespace ElectronNET.API
         /// Move the given file to trash and returns a <see cref="bool"/> status for the operation.
         /// </summary>
         /// <param name="fullPath">The full path to the directory / file.</param>
-        /// <param name="deleteOnFail">Whether or not to unilaterally remove the item if the Trash is disabled or unsupported on the volume.</param>
         /// <returns> Whether the item was successfully moved to the trash.</returns>
-        public Task<bool> MoveItemToTrashAsync(string fullPath, bool deleteOnFail)
+        public Task<bool> TrashItemAsync(string fullPath)
         {
             var taskCompletionSource = new TaskCompletionSource<bool>();
 
-            BridgeConnector.Socket.On("shell-moveItemToTrashCompleted", (success) =>
+            BridgeConnector.Socket.On("shell-trashItem-completed", (success) =>
             {
-                BridgeConnector.Socket.Off("shell-moveItemToTrashCompleted");
+                BridgeConnector.Socket.Off("shell-trashItem-completed");
 
                 taskCompletionSource.SetResult((bool) success);
             });
 
-            BridgeConnector.Socket.Emit("shell-moveItemToTrash", fullPath, deleteOnFail);
+            BridgeConnector.Socket.Emit("shell-trashItem", fullPath);
 
             return taskCompletionSource.Task;
         }