Changed electron fs-job to invoke, for simplefying storage (#1106)

* Changed electron fs-job to invoke, for simplefying storage
(And it helps for the modloader)

* Reverted some unneeded chages

* Uploaded wrong file

* Removed uneeded promise

electron/index.js

@@ -1,9 +1,8 @@
 /* eslint-disable quotes,no-undef */
 
-const { app, BrowserWindow, Menu, MenuItem, session } = require("electron");
+const { app, BrowserWindow, Menu, MenuItem, ipcMain, shell } = require("electron");
 const path = require("path");
 const url = require("url");
-const { ipcMain, shell } = require("electron");
 const fs = require("fs");
 const steam = require("./steam");
 const asyncLock = require("async-lock");
@@ -287,10 +286,7 @@ async function performFsJob(job) {
     }
 }
 
-ipcMain.on("fs-job", async (event, arg) => {
-    const result = await performFsJob(arg);
-    event.reply("fs-response", { id: arg.id, result });
-});
+ipcMain.handle("fs-job", (event, arg) => performFsJob(arg));
 
 steam.init(isDev);
 steam.listen();

src/js/platform/electron/storage.js

@@ -7,24 +7,6 @@ const logger = createLogger("electron-storage");
 export class StorageImplElectron extends StorageInterface {
     constructor(app) {
         super(app);
-
-        /** @type {Object.<number, {resolve:Function, reject: Function}>} */
-        this.jobs = {};
-        this.jobId = 0;
-
-        getIPCRenderer().on("fs-response", (event, arg) => {
-            const id = arg.id;
-            if (!this.jobs[id]) {
-                logger.warn("Got unhandled FS response, job not known:", id);
-                return;
-            }
-            const { resolve, reject } = this.jobs[id];
-            if (arg.result.success) {
-                resolve(arg.result.data);
-            } else {
-                reject(arg.result.error);
-            }
-        });
     }
 
     initialize() {
@@ -33,43 +15,53 @@ export class StorageImplElectron extends StorageInterface {
 
     writeFileAsync(filename, contents) {
         return new Promise((resolve, reject) => {
-            // ipcMain
-            const jobId = ++this.jobId;
-            this.jobs[jobId] = { resolve, reject };
-
-            getIPCRenderer().send("fs-job", {
-                type: "write",
-                filename,
-                contents,
-                id: jobId,
-            });
+            getIPCRenderer()
+                .invoke("fs-job", {
+                    type: "write",
+                    filename,
+                    contents,
+                })
+                .then(result => {
+                    if (result.success) {
+                        resolve(result.data);
+                    } else {
+                        reject(result.error);
+                    }
+                });
         });
     }
 
     readFileAsync(filename) {
         return new Promise((resolve, reject) => {
-            // ipcMain
-            const jobId = ++this.jobId;
-            this.jobs[jobId] = { resolve, reject };
-
-            getIPCRenderer().send("fs-job", {
-                type: "read",
-                filename,
-                id: jobId,
-            });
+            getIPCRenderer()
+                .invoke("fs-job", {
+                    type: "read",
+                    filename,
+                })
+                .then(result => {
+                    if (result.success) {
+                        resolve(result.data);
+                    } else {
+                        reject(result.error);
+                    }
+                });
         });
     }
 
     deleteFileAsync(filename) {
         return new Promise((resolve, reject) => {
-            // ipcMain
-            const jobId = ++this.jobId;
-            this.jobs[jobId] = { resolve, reject };
-            getIPCRenderer().send("fs-job", {
-                type: "delete",
-                filename,
-                id: jobId,
-            });
+            getIPCRenderer()
+                .invoke("fs-job", {
+                    type: "delete",
+                    filename,
+                })
+                .then(result => {
+                    if (result.success) {
+                        resolve(result.data);
+                    } else {
+                        reject(result.error);
+                    }
+                });
         });
     }
 }