Move JavaScript to root lib/ folder
This commit is contained in:
Kevin Sawicki
parent
a9c40de393
commit
70aa9b06ee
56 changed files with 0 additions and 0 deletions
|
|
@ -1,145 +0,0 @@
|
|||
const electron = require('electron');
|
||||
const app = electron.app;
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const url = require('url');
|
||||
|
||||
// Mapping between hostname and file path.
|
||||
var hostPathMap = {};
|
||||
var hostPathMapNextKey = 0;
|
||||
|
||||
var getHostForPath = function(path) {
|
||||
var key;
|
||||
key = "extension-" + (++hostPathMapNextKey);
|
||||
hostPathMap[key] = path;
|
||||
return key;
|
||||
};
|
||||
|
||||
var getPathForHost = function(host) {
|
||||
return hostPathMap[host];
|
||||
};
|
||||
|
||||
// Cache extensionInfo.
|
||||
var extensionInfoMap = {};
|
||||
|
||||
var getExtensionInfoFromPath = function(srcDirectory) {
|
||||
var manifest, page;
|
||||
manifest = JSON.parse(fs.readFileSync(path.join(srcDirectory, 'manifest.json')));
|
||||
if (extensionInfoMap[manifest.name] == null) {
|
||||
|
||||
// We can not use 'file://' directly because all resources in the extension
|
||||
// will be treated as relative to the root in Chrome.
|
||||
page = url.format({
|
||||
protocol: 'chrome-extension',
|
||||
slashes: true,
|
||||
hostname: getHostForPath(srcDirectory),
|
||||
pathname: manifest.devtools_page
|
||||
});
|
||||
extensionInfoMap[manifest.name] = {
|
||||
startPage: page,
|
||||
name: manifest.name,
|
||||
srcDirectory: srcDirectory,
|
||||
exposeExperimentalAPIs: true
|
||||
};
|
||||
return extensionInfoMap[manifest.name];
|
||||
}
|
||||
};
|
||||
|
||||
// The loaded extensions cache and its persistent path.
|
||||
var loadedExtensions = null;
|
||||
var loadedExtensionsPath = null;
|
||||
|
||||
app.on('will-quit', function() {
|
||||
try {
|
||||
loadedExtensions = Object.keys(extensionInfoMap).map(function(key) {
|
||||
return extensionInfoMap[key].srcDirectory;
|
||||
});
|
||||
if (loadedExtensions.length > 0) {
|
||||
try {
|
||||
fs.mkdirSync(path.dirname(loadedExtensionsPath));
|
||||
} catch (error) {
|
||||
// Ignore error
|
||||
}
|
||||
fs.writeFileSync(loadedExtensionsPath, JSON.stringify(loadedExtensions));
|
||||
} else {
|
||||
fs.unlinkSync(loadedExtensionsPath);
|
||||
}
|
||||
} catch (error) {
|
||||
// Ignore error
|
||||
}
|
||||
});
|
||||
|
||||
// We can not use protocol or BrowserWindow until app is ready.
|
||||
app.once('ready', function() {
|
||||
var BrowserWindow, chromeExtensionHandler, i, init, len, protocol, srcDirectory;
|
||||
protocol = electron.protocol, BrowserWindow = electron.BrowserWindow;
|
||||
|
||||
// Load persisted extensions.
|
||||
loadedExtensionsPath = path.join(app.getPath('userData'), 'DevTools Extensions');
|
||||
try {
|
||||
loadedExtensions = JSON.parse(fs.readFileSync(loadedExtensionsPath));
|
||||
if (!Array.isArray(loadedExtensions)) {
|
||||
loadedExtensions = [];
|
||||
}
|
||||
|
||||
// Preheat the extensionInfo cache.
|
||||
for (i = 0, len = loadedExtensions.length; i < len; i++) {
|
||||
srcDirectory = loadedExtensions[i];
|
||||
getExtensionInfoFromPath(srcDirectory);
|
||||
}
|
||||
} catch (error) {
|
||||
// Ignore error
|
||||
}
|
||||
|
||||
// The chrome-extension: can map a extension URL request to real file path.
|
||||
chromeExtensionHandler = function(request, callback) {
|
||||
var directory, parsed;
|
||||
parsed = url.parse(request.url);
|
||||
if (!(parsed.hostname && (parsed.path != null))) {
|
||||
return callback();
|
||||
}
|
||||
if (!/extension-\d+/.test(parsed.hostname)) {
|
||||
return callback();
|
||||
}
|
||||
directory = getPathForHost(parsed.hostname);
|
||||
if (directory == null) {
|
||||
return callback();
|
||||
}
|
||||
return callback(path.join(directory, parsed.path));
|
||||
};
|
||||
protocol.registerFileProtocol('chrome-extension', chromeExtensionHandler, function(error) {
|
||||
if (error) {
|
||||
return console.error('Unable to register chrome-extension protocol');
|
||||
}
|
||||
});
|
||||
BrowserWindow.prototype._loadDevToolsExtensions = function(extensionInfoArray) {
|
||||
var ref;
|
||||
return (ref = this.devToolsWebContents) != null ? ref.executeJavaScript("DevToolsAPI.addExtensions(" + (JSON.stringify(extensionInfoArray)) + ");") : void 0;
|
||||
};
|
||||
BrowserWindow.addDevToolsExtension = function(srcDirectory) {
|
||||
var extensionInfo, j, len1, ref, window;
|
||||
extensionInfo = getExtensionInfoFromPath(srcDirectory);
|
||||
if (extensionInfo) {
|
||||
ref = BrowserWindow.getAllWindows();
|
||||
for (j = 0, len1 = ref.length; j < len1; j++) {
|
||||
window = ref[j];
|
||||
window._loadDevToolsExtensions([extensionInfo]);
|
||||
}
|
||||
return extensionInfo.name;
|
||||
}
|
||||
};
|
||||
BrowserWindow.removeDevToolsExtension = function(name) {
|
||||
return delete extensionInfoMap[name];
|
||||
};
|
||||
|
||||
// Load persistented extensions when devtools is opened.
|
||||
init = BrowserWindow.prototype._init;
|
||||
return BrowserWindow.prototype._init = function() {
|
||||
init.call(this);
|
||||
return this.on('devtools-opened', function() {
|
||||
return this._loadDevToolsExtensions(Object.keys(extensionInfoMap).map(function(key) {
|
||||
return extensionInfoMap[key];
|
||||
}));
|
||||
});
|
||||
};
|
||||
});
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
const ipcMain = require('electron').ipcMain;
|
||||
const desktopCapturer = process.atomBinding('desktop_capturer').desktopCapturer;
|
||||
|
||||
var deepEqual = function(opt1, opt2) {
|
||||
return JSON.stringify(opt1) === JSON.stringify(opt2);
|
||||
};
|
||||
|
||||
// A queue for holding all requests from renderer process.
|
||||
var requestsQueue = [];
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', function(event, captureWindow, captureScreen, thumbnailSize, id) {
|
||||
var request;
|
||||
request = {
|
||||
id: id,
|
||||
options: {
|
||||
captureWindow: captureWindow,
|
||||
captureScreen: captureScreen,
|
||||
thumbnailSize: thumbnailSize
|
||||
},
|
||||
webContents: event.sender
|
||||
};
|
||||
requestsQueue.push(request);
|
||||
if (requestsQueue.length === 1) {
|
||||
desktopCapturer.startHandling(captureWindow, captureScreen, thumbnailSize);
|
||||
}
|
||||
|
||||
// If the WebContents is destroyed before receiving result, just remove the
|
||||
// reference from requestsQueue to make the module not send the result to it.
|
||||
return event.sender.once('destroyed', function() {
|
||||
return request.webContents = null;
|
||||
});
|
||||
});
|
||||
|
||||
desktopCapturer.emit = function(event, name, sources) {
|
||||
// Receiving sources result from main process, now send them back to renderer.
|
||||
var captureScreen, captureWindow, handledRequest, i, len, ref, ref1, ref2, request, result, source, thumbnailSize, unhandledRequestsQueue;
|
||||
handledRequest = requestsQueue.shift(0);
|
||||
result = (function() {
|
||||
var i, len, results;
|
||||
results = [];
|
||||
for (i = 0, len = sources.length; i < len; i++) {
|
||||
source = sources[i];
|
||||
results.push({
|
||||
id: source.id,
|
||||
name: source.name,
|
||||
thumbnail: source.thumbnail.toDataUrl()
|
||||
});
|
||||
}
|
||||
return results;
|
||||
})();
|
||||
if ((ref = handledRequest.webContents) != null) {
|
||||
ref.send("ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_" + handledRequest.id, result);
|
||||
}
|
||||
|
||||
// Check the queue to see whether there is other same request. If has, handle
|
||||
// it for reducing redunplicated `desktopCaptuer.startHandling` calls.
|
||||
unhandledRequestsQueue = [];
|
||||
for (i = 0, len = requestsQueue.length; i < len; i++) {
|
||||
request = requestsQueue[i];
|
||||
if (deepEqual(handledRequest.options, request.options)) {
|
||||
if ((ref1 = request.webContents) != null) {
|
||||
ref1.send("ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_" + request.id, result);
|
||||
}
|
||||
} else {
|
||||
unhandledRequestsQueue.push(request);
|
||||
}
|
||||
}
|
||||
requestsQueue = unhandledRequestsQueue;
|
||||
|
||||
// If the requestsQueue is not empty, start a new request handling.
|
||||
if (requestsQueue.length > 0) {
|
||||
ref2 = requestsQueue[0].options, captureWindow = ref2.captureWindow, captureScreen = ref2.captureScreen, thumbnailSize = ref2.thumbnailSize;
|
||||
return desktopCapturer.startHandling(captureWindow, captureScreen, thumbnailSize);
|
||||
}
|
||||
};
|
||||
|
|
@ -1,247 +0,0 @@
|
|||
const ipcMain = require('electron').ipcMain;
|
||||
const webContents = require('electron').webContents;
|
||||
|
||||
var slice = [].slice;
|
||||
|
||||
// Doesn't exist in early initialization.
|
||||
var webViewManager = null;
|
||||
|
||||
var supportedWebViewEvents = [
|
||||
'load-commit',
|
||||
'did-finish-load',
|
||||
'did-fail-load',
|
||||
'did-frame-finish-load',
|
||||
'did-start-loading',
|
||||
'did-stop-loading',
|
||||
'did-get-response-details',
|
||||
'did-get-redirect-request',
|
||||
'dom-ready',
|
||||
'console-message',
|
||||
'devtools-opened',
|
||||
'devtools-closed',
|
||||
'devtools-focused',
|
||||
'new-window',
|
||||
'will-navigate',
|
||||
'did-navigate',
|
||||
'did-navigate-in-page',
|
||||
'close',
|
||||
'crashed',
|
||||
'gpu-crashed',
|
||||
'plugin-crashed',
|
||||
'destroyed',
|
||||
'page-title-updated',
|
||||
'page-favicon-updated',
|
||||
'enter-html-full-screen',
|
||||
'leave-html-full-screen',
|
||||
'media-started-playing',
|
||||
'media-paused',
|
||||
'found-in-page',
|
||||
'did-change-theme-color'
|
||||
];
|
||||
|
||||
var nextInstanceId = 0;
|
||||
var guestInstances = {};
|
||||
var embedderElementsMap = {};
|
||||
var reverseEmbedderElementsMap = {};
|
||||
|
||||
// Moves the last element of array to the first one.
|
||||
var moveLastToFirst = function(list) {
|
||||
return list.unshift(list.pop());
|
||||
};
|
||||
|
||||
// Generate guestInstanceId.
|
||||
var getNextInstanceId = function() {
|
||||
return ++nextInstanceId;
|
||||
};
|
||||
|
||||
// Create a new guest instance.
|
||||
var createGuest = function(embedder, params) {
|
||||
var destroy, destroyEvents, event, fn, guest, i, id, j, len, len1, listeners;
|
||||
if (webViewManager == null) {
|
||||
webViewManager = process.atomBinding('web_view_manager');
|
||||
}
|
||||
id = getNextInstanceId(embedder);
|
||||
guest = webContents.create({
|
||||
isGuest: true,
|
||||
partition: params.partition,
|
||||
embedder: embedder
|
||||
});
|
||||
guestInstances[id] = {
|
||||
guest: guest,
|
||||
embedder: embedder
|
||||
};
|
||||
|
||||
// Destroy guest when the embedder is gone or navigated.
|
||||
destroyEvents = ['will-destroy', 'crashed', 'did-navigate'];
|
||||
destroy = function() {
|
||||
if (guestInstances[id] != null) {
|
||||
return destroyGuest(embedder, id);
|
||||
}
|
||||
};
|
||||
for (i = 0, len = destroyEvents.length; i < len; i++) {
|
||||
event = destroyEvents[i];
|
||||
embedder.once(event, destroy);
|
||||
|
||||
// Users might also listen to the crashed event, so We must ensure the guest
|
||||
// is destroyed before users' listener gets called. It is done by moving our
|
||||
// listener to the first one in queue.
|
||||
listeners = embedder._events[event];
|
||||
if (Array.isArray(listeners)) {
|
||||
moveLastToFirst(listeners);
|
||||
}
|
||||
}
|
||||
guest.once('destroyed', function() {
|
||||
var j, len1, results;
|
||||
results = [];
|
||||
for (j = 0, len1 = destroyEvents.length; j < len1; j++) {
|
||||
event = destroyEvents[j];
|
||||
results.push(embedder.removeListener(event, destroy));
|
||||
}
|
||||
return results;
|
||||
});
|
||||
|
||||
// Init guest web view after attached.
|
||||
guest.once('did-attach', function() {
|
||||
var opts;
|
||||
params = this.attachParams;
|
||||
delete this.attachParams;
|
||||
this.viewInstanceId = params.instanceId;
|
||||
this.setSize({
|
||||
normal: {
|
||||
width: params.elementWidth,
|
||||
height: params.elementHeight
|
||||
},
|
||||
enableAutoSize: params.autosize,
|
||||
min: {
|
||||
width: params.minwidth,
|
||||
height: params.minheight
|
||||
},
|
||||
max: {
|
||||
width: params.maxwidth,
|
||||
height: params.maxheight
|
||||
}
|
||||
});
|
||||
if (params.src) {
|
||||
opts = {};
|
||||
if (params.httpreferrer) {
|
||||
opts.httpReferrer = params.httpreferrer;
|
||||
}
|
||||
if (params.useragent) {
|
||||
opts.userAgent = params.useragent;
|
||||
}
|
||||
this.loadURL(params.src, opts);
|
||||
}
|
||||
if (params.allowtransparency != null) {
|
||||
this.setAllowTransparency(params.allowtransparency);
|
||||
}
|
||||
return guest.allowPopups = params.allowpopups;
|
||||
});
|
||||
|
||||
// Dispatch events to embedder.
|
||||
fn = function(event) {
|
||||
return guest.on(event, function() {
|
||||
var args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
|
||||
return embedder.send.apply(embedder, ["ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-" + guest.viewInstanceId, event].concat(slice.call(args)));
|
||||
});
|
||||
};
|
||||
for (j = 0, len1 = supportedWebViewEvents.length; j < len1; j++) {
|
||||
event = supportedWebViewEvents[j];
|
||||
fn(event);
|
||||
}
|
||||
|
||||
// Dispatch guest's IPC messages to embedder.
|
||||
guest.on('ipc-message-host', function(_, packed) {
|
||||
var args, channel;
|
||||
channel = packed[0], args = 2 <= packed.length ? slice.call(packed, 1) : [];
|
||||
return embedder.send.apply(embedder, ["ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-" + guest.viewInstanceId, channel].concat(slice.call(args)));
|
||||
});
|
||||
|
||||
// Autosize.
|
||||
guest.on('size-changed', function() {
|
||||
var args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
|
||||
return embedder.send.apply(embedder, ["ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-" + guest.viewInstanceId].concat(slice.call(args)));
|
||||
});
|
||||
return id;
|
||||
};
|
||||
|
||||
// Attach the guest to an element of embedder.
|
||||
var attachGuest = function(embedder, elementInstanceId, guestInstanceId, params) {
|
||||
var guest, key, oldGuestInstanceId, ref1, webPreferences;
|
||||
guest = guestInstances[guestInstanceId].guest;
|
||||
|
||||
// Destroy the old guest when attaching.
|
||||
key = (embedder.getId()) + "-" + elementInstanceId;
|
||||
oldGuestInstanceId = embedderElementsMap[key];
|
||||
if (oldGuestInstanceId != null) {
|
||||
|
||||
// Reattachment to the same guest is not currently supported.
|
||||
if (oldGuestInstanceId === guestInstanceId) {
|
||||
return;
|
||||
}
|
||||
if (guestInstances[oldGuestInstanceId] == null) {
|
||||
return;
|
||||
}
|
||||
destroyGuest(embedder, oldGuestInstanceId);
|
||||
}
|
||||
webPreferences = {
|
||||
guestInstanceId: guestInstanceId,
|
||||
nodeIntegration: (ref1 = params.nodeintegration) != null ? ref1 : false,
|
||||
plugins: params.plugins,
|
||||
webSecurity: !params.disablewebsecurity,
|
||||
blinkFeatures: params.blinkfeatures
|
||||
};
|
||||
if (params.preload) {
|
||||
webPreferences.preloadURL = params.preload;
|
||||
}
|
||||
webViewManager.addGuest(guestInstanceId, elementInstanceId, embedder, guest, webPreferences);
|
||||
guest.attachParams = params;
|
||||
embedderElementsMap[key] = guestInstanceId;
|
||||
return reverseEmbedderElementsMap[guestInstanceId] = key;
|
||||
};
|
||||
|
||||
// Destroy an existing guest instance.
|
||||
var destroyGuest = function(embedder, id) {
|
||||
var key;
|
||||
webViewManager.removeGuest(embedder, id);
|
||||
guestInstances[id].guest.destroy();
|
||||
delete guestInstances[id];
|
||||
key = reverseEmbedderElementsMap[id];
|
||||
if (key != null) {
|
||||
delete reverseEmbedderElementsMap[id];
|
||||
return delete embedderElementsMap[key];
|
||||
}
|
||||
};
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', function(event, params, requestId) {
|
||||
return event.sender.send("ATOM_SHELL_RESPONSE_" + requestId, createGuest(event.sender, params));
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_VIEW_MANAGER_ATTACH_GUEST', function(event, elementInstanceId, guestInstanceId, params) {
|
||||
return attachGuest(event.sender, elementInstanceId, guestInstanceId, params);
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', function(event, id) {
|
||||
return destroyGuest(event.sender, id);
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', function(event, id, params) {
|
||||
var ref1;
|
||||
return (ref1 = guestInstances[id]) != null ? ref1.guest.setSize(params) : void 0;
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', function(event, id, allowtransparency) {
|
||||
var ref1;
|
||||
return (ref1 = guestInstances[id]) != null ? ref1.guest.setAllowTransparency(allowtransparency) : void 0;
|
||||
});
|
||||
|
||||
// Returns WebContents from its guest id.
|
||||
exports.getGuest = function(id) {
|
||||
var ref1;
|
||||
return (ref1 = guestInstances[id]) != null ? ref1.guest : void 0;
|
||||
};
|
||||
|
||||
// Returns the embedder of the guest.
|
||||
exports.getEmbedder = function(id) {
|
||||
var ref1;
|
||||
return (ref1 = guestInstances[id]) != null ? ref1.embedder : void 0;
|
||||
};
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
const ipcMain = require('electron').ipcMain;
|
||||
const BrowserWindow = require('electron').BrowserWindow;
|
||||
|
||||
var hasProp = {}.hasOwnProperty;
|
||||
var slice = [].slice;
|
||||
var frameToGuest = {};
|
||||
|
||||
// Copy attribute of |parent| to |child| if it is not defined in |child|.
|
||||
var mergeOptions = function(child, parent) {
|
||||
var key, value;
|
||||
for (key in parent) {
|
||||
if (!hasProp.call(parent, key)) continue;
|
||||
value = parent[key];
|
||||
if (!(key in child)) {
|
||||
if (typeof value === 'object') {
|
||||
child[key] = mergeOptions({}, value);
|
||||
} else {
|
||||
child[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return child;
|
||||
};
|
||||
|
||||
// Merge |options| with the |embedder|'s window's options.
|
||||
var mergeBrowserWindowOptions = function(embedder, options) {
|
||||
if (embedder.browserWindowOptions != null) {
|
||||
|
||||
// Inherit the original options if it is a BrowserWindow.
|
||||
mergeOptions(options, embedder.browserWindowOptions);
|
||||
} else {
|
||||
|
||||
// Or only inherit web-preferences if it is a webview.
|
||||
if (options.webPreferences == null) {
|
||||
options.webPreferences = {};
|
||||
}
|
||||
mergeOptions(options.webPreferences, embedder.getWebPreferences());
|
||||
}
|
||||
return options;
|
||||
};
|
||||
|
||||
// Create a new guest created by |embedder| with |options|.
|
||||
var createGuest = function(embedder, url, frameName, options) {
|
||||
var closedByEmbedder, closedByUser, guest, guestId, ref1;
|
||||
guest = frameToGuest[frameName];
|
||||
if (frameName && (guest != null)) {
|
||||
guest.loadURL(url);
|
||||
return guest.id;
|
||||
}
|
||||
|
||||
// Remember the embedder window's id.
|
||||
if (options.webPreferences == null) {
|
||||
options.webPreferences = {};
|
||||
}
|
||||
options.webPreferences.openerId = (ref1 = BrowserWindow.fromWebContents(embedder)) != null ? ref1.id : void 0;
|
||||
guest = new BrowserWindow(options);
|
||||
guest.loadURL(url);
|
||||
|
||||
// When |embedder| is destroyed we should also destroy attached guest, and if
|
||||
// guest is closed by user then we should prevent |embedder| from double
|
||||
// closing guest.
|
||||
guestId = guest.id;
|
||||
closedByEmbedder = function() {
|
||||
guest.removeListener('closed', closedByUser);
|
||||
return guest.destroy();
|
||||
};
|
||||
closedByUser = function() {
|
||||
embedder.send("ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_" + guestId);
|
||||
return embedder.removeListener('render-view-deleted', closedByEmbedder);
|
||||
};
|
||||
embedder.once('render-view-deleted', closedByEmbedder);
|
||||
guest.once('closed', closedByUser);
|
||||
if (frameName) {
|
||||
frameToGuest[frameName] = guest;
|
||||
guest.frameName = frameName;
|
||||
guest.once('closed', function() {
|
||||
return delete frameToGuest[frameName];
|
||||
});
|
||||
}
|
||||
return guest.id;
|
||||
};
|
||||
|
||||
// Routed window.open messages.
|
||||
ipcMain.on('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', function() {
|
||||
var args, event, frameName, options, url;
|
||||
event = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
|
||||
url = args[0], frameName = args[1], options = args[2];
|
||||
options = mergeBrowserWindowOptions(event.sender, options);
|
||||
event.sender.emit('new-window', event, url, frameName, 'new-window', options);
|
||||
if ((event.sender.isGuest() && !event.sender.allowPopups) || event.defaultPrevented) {
|
||||
return event.returnValue = null;
|
||||
} else {
|
||||
return event.returnValue = createGuest(event.sender, url, frameName, options);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', function(event, guestId) {
|
||||
var ref1;
|
||||
return (ref1 = BrowserWindow.fromId(guestId)) != null ? ref1.destroy() : void 0;
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', function() {
|
||||
var args, guestId, method, ref1;
|
||||
guestId = arguments[1], method = arguments[2], args = 4 <= arguments.length ? slice.call(arguments, 3) : [];
|
||||
return (ref1 = BrowserWindow.fromId(guestId)) != null ? ref1[method].apply(ref1, args) : void 0;
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', function(event, guestId, message, targetOrigin, sourceOrigin) {
|
||||
var guestContents, ref1, ref2, sourceId;
|
||||
sourceId = (ref1 = BrowserWindow.fromWebContents(event.sender)) != null ? ref1.id : void 0;
|
||||
if (sourceId == null) {
|
||||
return;
|
||||
}
|
||||
guestContents = (ref2 = BrowserWindow.fromId(guestId)) != null ? ref2.webContents : void 0;
|
||||
if ((guestContents != null ? guestContents.getURL().indexOf(targetOrigin) : void 0) === 0 || targetOrigin === '*') {
|
||||
return guestContents != null ? guestContents.send('ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', sourceId, message, sourceOrigin) : void 0;
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', function() {
|
||||
var args, guestId, method, ref1, ref2;
|
||||
guestId = arguments[1], method = arguments[2], args = 4 <= arguments.length ? slice.call(arguments, 3) : [];
|
||||
return (ref1 = BrowserWindow.fromId(guestId)) != null ? (ref2 = ref1.webContents) != null ? ref2[method].apply(ref2, args) : void 0 : void 0;
|
||||
});
|
||||
|
|
@ -1,158 +0,0 @@
|
|||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const util = require('util');
|
||||
const Module = require('module');
|
||||
const v8 = require('v8');
|
||||
|
||||
var slice = [].slice;
|
||||
|
||||
// We modified the original process.argv to let node.js load the atom.js,
|
||||
// we need to restore it here.
|
||||
process.argv.splice(1, 1);
|
||||
|
||||
// Clear search paths.
|
||||
require(path.resolve(__dirname, '..', '..', 'common', 'lib', 'reset-search-paths'));
|
||||
|
||||
// Import common settings.
|
||||
require(path.resolve(__dirname, '..', '..', 'common', 'lib', 'init'));
|
||||
|
||||
var globalPaths = Module.globalPaths;
|
||||
|
||||
if (!process.env.ELECTRON_HIDE_INTERNAL_MODULES) {
|
||||
globalPaths.push(path.resolve(__dirname, '..', 'api', 'lib'));
|
||||
}
|
||||
|
||||
// Expose public APIs.
|
||||
globalPaths.push(path.resolve(__dirname, '..', 'api', 'lib', 'exports'));
|
||||
|
||||
if (process.platform === 'win32') {
|
||||
// Redirect node's console to use our own implementations, since node can not
|
||||
// handle console output when running as GUI program.
|
||||
var consoleLog = function() {
|
||||
var args;
|
||||
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
|
||||
return process.log(util.format.apply(util, args) + "\n");
|
||||
};
|
||||
var streamWrite = function(chunk, encoding, callback) {
|
||||
if (Buffer.isBuffer(chunk)) {
|
||||
chunk = chunk.toString(encoding);
|
||||
}
|
||||
process.log(chunk);
|
||||
if (callback) {
|
||||
callback();
|
||||
}
|
||||
return true;
|
||||
};
|
||||
console.log = console.error = console.warn = consoleLog;
|
||||
process.stdout.write = process.stderr.write = streamWrite;
|
||||
|
||||
// Always returns EOF for stdin stream.
|
||||
var Readable = require('stream').Readable;
|
||||
var stdin = new Readable;
|
||||
stdin.push(null);
|
||||
process.__defineGetter__('stdin', function() {
|
||||
return stdin;
|
||||
});
|
||||
}
|
||||
|
||||
// Don't quit on fatal error.
|
||||
process.on('uncaughtException', function(error) {
|
||||
|
||||
// Do nothing if the user has a custom uncaught exception handler.
|
||||
var dialog, message, ref, stack;
|
||||
if (process.listeners('uncaughtException').length > 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Show error in GUI.
|
||||
dialog = require('electron').dialog;
|
||||
stack = (ref = error.stack) != null ? ref : error.name + ": " + error.message;
|
||||
message = "Uncaught Exception:\n" + stack;
|
||||
return dialog.showErrorBox('A JavaScript error occurred in the main process', message);
|
||||
});
|
||||
|
||||
// Emit 'exit' event on quit.
|
||||
var app = require('electron').app;
|
||||
|
||||
app.on('quit', function(event, exitCode) {
|
||||
return process.emit('exit', exitCode);
|
||||
});
|
||||
|
||||
// Map process.exit to app.exit, which quits gracefully.
|
||||
process.exit = app.exit;
|
||||
|
||||
// Load the RPC server.
|
||||
require('./rpc-server');
|
||||
|
||||
// Load the guest view manager.
|
||||
require('./guest-view-manager');
|
||||
|
||||
require('./guest-window-manager');
|
||||
|
||||
// Now we try to load app's package.json.
|
||||
var packageJson = null;
|
||||
var searchPaths = ['app', 'app.asar', 'default_app'];
|
||||
var i, len, packagePath;
|
||||
for (i = 0, len = searchPaths.length; i < len; i++) {
|
||||
packagePath = searchPaths[i];
|
||||
try {
|
||||
packagePath = path.join(process.resourcesPath, packagePath);
|
||||
packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')));
|
||||
break;
|
||||
} catch (error) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (packageJson == null) {
|
||||
process.nextTick(function() {
|
||||
return process.exit(1);
|
||||
});
|
||||
throw new Error("Unable to find a valid app");
|
||||
}
|
||||
|
||||
// Set application's version.
|
||||
if (packageJson.version != null) {
|
||||
app.setVersion(packageJson.version);
|
||||
}
|
||||
|
||||
// Set application's name.
|
||||
if (packageJson.productName != null) {
|
||||
app.setName(packageJson.productName);
|
||||
} else if (packageJson.name != null) {
|
||||
app.setName(packageJson.name);
|
||||
}
|
||||
|
||||
// Set application's desktop name.
|
||||
if (packageJson.desktopName != null) {
|
||||
app.setDesktopName(packageJson.desktopName);
|
||||
} else {
|
||||
app.setDesktopName((app.getName()) + ".desktop");
|
||||
}
|
||||
|
||||
// Set v8 flags
|
||||
if (packageJson.v8Flags != null) {
|
||||
v8.setFlagsFromString(packageJson.v8Flags);
|
||||
}
|
||||
|
||||
// Chrome 42 disables NPAPI plugins by default, reenable them here
|
||||
app.commandLine.appendSwitch('enable-npapi');
|
||||
|
||||
// Set the user path according to application's name.
|
||||
app.setPath('userData', path.join(app.getPath('appData'), app.getName()));
|
||||
|
||||
app.setPath('userCache', path.join(app.getPath('cache'), app.getName()));
|
||||
|
||||
app.setAppPath(packagePath);
|
||||
|
||||
// Load the chrome extension support.
|
||||
require('./chrome-extension');
|
||||
|
||||
// Load internal desktop-capturer module.
|
||||
require('./desktop-capturer');
|
||||
|
||||
// Set main startup script of the app.
|
||||
var mainStartupScript = packageJson.main || 'index.js';
|
||||
|
||||
// Finally load app's main.js and transfer control to C++.
|
||||
Module._load(path.join(packagePath, mainStartupScript), Module, true);
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
'use strict';
|
||||
|
||||
const v8Util = process.atomBinding('v8_util');
|
||||
|
||||
class ObjectsRegistry {
|
||||
constructor() {
|
||||
this.nextId = 0;
|
||||
|
||||
// Stores all objects by ref-counting.
|
||||
// (id) => {object, count}
|
||||
this.storage = {};
|
||||
|
||||
// Stores the IDs of objects referenced by WebContents.
|
||||
// (webContentsId) => [id]
|
||||
this.owners = {};
|
||||
}
|
||||
|
||||
// Register a new object and return its assigned ID. If the object is already
|
||||
// registered then the already assigned ID would be returned.
|
||||
add(webContents, obj) {
|
||||
// Get or assign an ID to the object.
|
||||
let id = this.saveToStorage(obj);
|
||||
|
||||
// Add object to the set of referenced objects.
|
||||
let webContentsId = webContents.getId();
|
||||
let owner = this.owners[webContentsId];
|
||||
if (!owner) {
|
||||
owner = this.owners[webContentsId] = new Set();
|
||||
// Clear the storage when webContents is reloaded/navigated.
|
||||
webContents.once('render-view-deleted', (event, id) => {
|
||||
this.clear(id);
|
||||
});
|
||||
}
|
||||
if (!owner.has(id)) {
|
||||
owner.add(id);
|
||||
// Increase reference count if not referenced before.
|
||||
this.storage[id].count++;
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
// Get an object according to its ID.
|
||||
get(id) {
|
||||
return this.storage[id].object;
|
||||
}
|
||||
|
||||
// Dereference an object according to its ID.
|
||||
remove(webContentsId, id) {
|
||||
// Dereference from the storage.
|
||||
this.dereference(id);
|
||||
|
||||
// Also remove the reference in owner.
|
||||
this.owners[webContentsId].delete(id);
|
||||
}
|
||||
|
||||
// Clear all references to objects refrenced by the WebContents.
|
||||
clear(webContentsId) {
|
||||
let owner = this.owners[webContentsId];
|
||||
if (!owner)
|
||||
return;
|
||||
for (let id of owner)
|
||||
this.dereference(id);
|
||||
delete this.owners[webContentsId];
|
||||
}
|
||||
|
||||
// Private: Saves the object into storage and assigns an ID for it.
|
||||
saveToStorage(object) {
|
||||
let id = v8Util.getHiddenValue(object, 'atomId');
|
||||
if (!id) {
|
||||
id = ++this.nextId;
|
||||
this.storage[id] = {
|
||||
count: 0,
|
||||
object: object
|
||||
};
|
||||
v8Util.setHiddenValue(object, 'atomId', id);
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
// Private: Dereference the object from store.
|
||||
dereference(id) {
|
||||
let pointer = this.storage[id];
|
||||
if (pointer == null) {
|
||||
return;
|
||||
}
|
||||
pointer.count -= 1;
|
||||
if (pointer.count === 0) {
|
||||
v8Util.deleteHiddenValue(pointer.object, 'atomId');
|
||||
return delete this.storage[id];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = new ObjectsRegistry;
|
||||
|
|
@ -1,371 +0,0 @@
|
|||
'use strict';
|
||||
|
||||
const electron = require('electron');
|
||||
const ipcMain = electron.ipcMain;
|
||||
const objectsRegistry = require('./objects-registry');
|
||||
const v8Util = process.atomBinding('v8_util');
|
||||
const IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap;
|
||||
|
||||
// The internal properties of Function.
|
||||
const FUNCTION_PROPERTIES = [
|
||||
'length', 'name', 'arguments', 'caller', 'prototype',
|
||||
];
|
||||
|
||||
// The remote functions in renderer processes.
|
||||
// (webContentsId) => {id: Function}
|
||||
let rendererFunctions = {};
|
||||
|
||||
// Return the description of object's members:
|
||||
let getObjectMembers = function(object) {
|
||||
let names = Object.getOwnPropertyNames(object);
|
||||
// For Function, we should not override following properties even though they
|
||||
// are "own" properties.
|
||||
if (typeof object === 'function') {
|
||||
names = names.filter((name) => {
|
||||
return !FUNCTION_PROPERTIES.includes(name);
|
||||
});
|
||||
}
|
||||
// Map properties to descriptors.
|
||||
return names.map((name) => {
|
||||
let descriptor = Object.getOwnPropertyDescriptor(object, name);
|
||||
let member = {name, enumerable: descriptor.enumerable, writable: false};
|
||||
if (descriptor.get === undefined && typeof object[name] === 'function') {
|
||||
member.type = 'method';
|
||||
} else {
|
||||
if (descriptor.set || descriptor.writable)
|
||||
member.writable = true;
|
||||
member.type = 'get';
|
||||
}
|
||||
return member;
|
||||
});
|
||||
};
|
||||
|
||||
// Return the description of object's prototype.
|
||||
let getObjectPrototype = function(object) {
|
||||
let proto = Object.getPrototypeOf(object);
|
||||
if (proto === null || proto === Object.prototype)
|
||||
return null;
|
||||
return {
|
||||
members: getObjectMembers(proto),
|
||||
proto: getObjectPrototype(proto),
|
||||
};
|
||||
};
|
||||
|
||||
// Convert a real value into meta data.
|
||||
var valueToMeta = function(sender, value, optimizeSimpleObject) {
|
||||
var el, i, len, meta;
|
||||
if (optimizeSimpleObject == null) {
|
||||
optimizeSimpleObject = false;
|
||||
}
|
||||
meta = {
|
||||
type: typeof value
|
||||
};
|
||||
if (Buffer.isBuffer(value)) {
|
||||
meta.type = 'buffer';
|
||||
}
|
||||
if (value === null) {
|
||||
meta.type = 'value';
|
||||
}
|
||||
if (Array.isArray(value)) {
|
||||
meta.type = 'array';
|
||||
}
|
||||
if (value instanceof Error) {
|
||||
meta.type = 'error';
|
||||
}
|
||||
if (value instanceof Date) {
|
||||
meta.type = 'date';
|
||||
}
|
||||
if ((value != null ? value.constructor.name : void 0) === 'Promise') {
|
||||
meta.type = 'promise';
|
||||
}
|
||||
|
||||
// Treat simple objects as value.
|
||||
if (optimizeSimpleObject && meta.type === 'object' && v8Util.getHiddenValue(value, 'simple')) {
|
||||
meta.type = 'value';
|
||||
}
|
||||
|
||||
// Treat the arguments object as array.
|
||||
if (meta.type === 'object' && (value.hasOwnProperty('callee')) && (value.length != null)) {
|
||||
meta.type = 'array';
|
||||
}
|
||||
if (meta.type === 'array') {
|
||||
meta.members = [];
|
||||
for (i = 0, len = value.length; i < len; i++) {
|
||||
el = value[i];
|
||||
meta.members.push(valueToMeta(sender, el));
|
||||
}
|
||||
} else if (meta.type === 'object' || meta.type === 'function') {
|
||||
meta.name = value.constructor.name;
|
||||
|
||||
// Reference the original value if it's an object, because when it's
|
||||
// passed to renderer we would assume the renderer keeps a reference of
|
||||
// it.
|
||||
meta.id = objectsRegistry.add(sender, value);
|
||||
meta.members = getObjectMembers(value);
|
||||
meta.proto = getObjectPrototype(value);
|
||||
} else if (meta.type === 'buffer') {
|
||||
meta.value = Array.prototype.slice.call(value, 0);
|
||||
} else if (meta.type === 'promise') {
|
||||
meta.then = valueToMeta(sender, value.then.bind(value));
|
||||
} else if (meta.type === 'error') {
|
||||
meta.members = plainObjectToMeta(value);
|
||||
|
||||
// Error.name is not part of own properties.
|
||||
meta.members.push({
|
||||
name: 'name',
|
||||
value: value.name
|
||||
});
|
||||
} else if (meta.type === 'date') {
|
||||
meta.value = value.getTime();
|
||||
} else {
|
||||
meta.type = 'value';
|
||||
meta.value = value;
|
||||
}
|
||||
return meta;
|
||||
};
|
||||
|
||||
// Convert object to meta by value.
|
||||
var plainObjectToMeta = function(obj) {
|
||||
return Object.getOwnPropertyNames(obj).map(function(name) {
|
||||
return {
|
||||
name: name,
|
||||
value: obj[name]
|
||||
};
|
||||
});
|
||||
};
|
||||
|
||||
// Convert Error into meta data.
|
||||
var exceptionToMeta = function(error) {
|
||||
return {
|
||||
type: 'exception',
|
||||
message: error.message,
|
||||
stack: error.stack || error
|
||||
};
|
||||
};
|
||||
|
||||
// Convert array of meta data from renderer into array of real values.
|
||||
var unwrapArgs = function(sender, args) {
|
||||
var metaToValue;
|
||||
metaToValue = function(meta) {
|
||||
var i, len, member, ref, returnValue;
|
||||
switch (meta.type) {
|
||||
case 'value':
|
||||
return meta.value;
|
||||
case 'remote-object':
|
||||
return objectsRegistry.get(meta.id);
|
||||
case 'array':
|
||||
return unwrapArgs(sender, meta.value);
|
||||
case 'buffer':
|
||||
return new Buffer(meta.value);
|
||||
case 'date':
|
||||
return new Date(meta.value);
|
||||
case 'promise':
|
||||
return Promise.resolve({
|
||||
then: metaToValue(meta.then)
|
||||
});
|
||||
case 'object': {
|
||||
let ret = {};
|
||||
Object.defineProperty(ret.constructor, 'name', { value: meta.name });
|
||||
|
||||
ref = meta.members;
|
||||
for (i = 0, len = ref.length; i < len; i++) {
|
||||
member = ref[i];
|
||||
ret[member.name] = metaToValue(member.value);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
case 'function-with-return-value':
|
||||
returnValue = metaToValue(meta.value);
|
||||
return function() {
|
||||
return returnValue;
|
||||
};
|
||||
case 'function': {
|
||||
// Cache the callbacks in renderer.
|
||||
let webContentsId = sender.getId();
|
||||
let callbacks = rendererFunctions[webContentsId];
|
||||
if (!callbacks) {
|
||||
callbacks = rendererFunctions[webContentsId] = new IDWeakMap;
|
||||
sender.once('render-view-deleted', function(event, id) {
|
||||
callbacks.clear();
|
||||
delete rendererFunctions[id];
|
||||
});
|
||||
}
|
||||
|
||||
if (callbacks.has(meta.id))
|
||||
return callbacks.get(meta.id);
|
||||
|
||||
let callIntoRenderer = function(...args) {
|
||||
if ((webContentsId in rendererFunctions) && !sender.isDestroyed())
|
||||
sender.send('ATOM_RENDERER_CALLBACK', meta.id, valueToMeta(sender, args));
|
||||
else
|
||||
throw new Error(`Attempting to call a function in a renderer window that has been closed or released. Function provided here: ${meta.location}.`);
|
||||
};
|
||||
v8Util.setDestructor(callIntoRenderer, function() {
|
||||
if ((webContentsId in rendererFunctions) && !sender.isDestroyed())
|
||||
sender.send('ATOM_RENDERER_RELEASE_CALLBACK', meta.id);
|
||||
});
|
||||
callbacks.set(meta.id, callIntoRenderer);
|
||||
return callIntoRenderer;
|
||||
}
|
||||
default:
|
||||
throw new TypeError("Unknown type: " + meta.type);
|
||||
}
|
||||
};
|
||||
return args.map(metaToValue);
|
||||
};
|
||||
|
||||
// Call a function and send reply asynchronously if it's a an asynchronous
|
||||
// style function and the caller didn't pass a callback.
|
||||
var callFunction = function(event, func, caller, args) {
|
||||
var funcMarkedAsync, funcName, funcPassedCallback, ref, ret;
|
||||
funcMarkedAsync = v8Util.getHiddenValue(func, 'asynchronous');
|
||||
funcPassedCallback = typeof args[args.length - 1] === 'function';
|
||||
try {
|
||||
if (funcMarkedAsync && !funcPassedCallback) {
|
||||
args.push(function(ret) {
|
||||
return event.returnValue = valueToMeta(event.sender, ret, true);
|
||||
});
|
||||
return func.apply(caller, args);
|
||||
} else {
|
||||
ret = func.apply(caller, args);
|
||||
return event.returnValue = valueToMeta(event.sender, ret, true);
|
||||
}
|
||||
} catch (error) {
|
||||
// Catch functions thrown further down in function invocation and wrap
|
||||
// them with the function name so it's easier to trace things like
|
||||
// `Error processing argument -1.`
|
||||
funcName = (ref = func.name) != null ? ref : "anonymous";
|
||||
throw new Error("Could not call remote function `" + funcName + "`. Check that the function signature is correct. Underlying error: " + error.message);
|
||||
}
|
||||
};
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_REQUIRE', function(event, module) {
|
||||
try {
|
||||
return event.returnValue = valueToMeta(event.sender, process.mainModule.require(module));
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_GET_BUILTIN', function(event, module) {
|
||||
try {
|
||||
return event.returnValue = valueToMeta(event.sender, electron[module]);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_GLOBAL', function(event, name) {
|
||||
try {
|
||||
return event.returnValue = valueToMeta(event.sender, global[name]);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_CURRENT_WINDOW', function(event) {
|
||||
try {
|
||||
return event.returnValue = valueToMeta(event.sender, event.sender.getOwnerBrowserWindow());
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_CURRENT_WEB_CONTENTS', function(event) {
|
||||
return event.returnValue = valueToMeta(event.sender, event.sender);
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_CONSTRUCTOR', function(event, id, args) {
|
||||
try {
|
||||
args = unwrapArgs(event.sender, args);
|
||||
let constructor = objectsRegistry.get(id);
|
||||
|
||||
// Call new with array of arguments.
|
||||
// http://stackoverflow.com/questions/1606797/use-of-apply-with-new-operator-is-this-possible
|
||||
let obj = new (Function.prototype.bind.apply(constructor, [null].concat(args)));
|
||||
return event.returnValue = valueToMeta(event.sender, obj);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_FUNCTION_CALL', function(event, id, args) {
|
||||
try {
|
||||
args = unwrapArgs(event.sender, args);
|
||||
let func = objectsRegistry.get(id);
|
||||
return callFunction(event, func, global, args);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_MEMBER_CONSTRUCTOR', function(event, id, method, args) {
|
||||
try {
|
||||
args = unwrapArgs(event.sender, args);
|
||||
let constructor = objectsRegistry.get(id)[method];
|
||||
|
||||
// Call new with array of arguments.
|
||||
let obj = new (Function.prototype.bind.apply(constructor, [null].concat(args)));
|
||||
return event.returnValue = valueToMeta(event.sender, obj);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_MEMBER_CALL', function(event, id, method, args) {
|
||||
try {
|
||||
args = unwrapArgs(event.sender, args);
|
||||
let obj = objectsRegistry.get(id);
|
||||
return callFunction(event, obj[method], obj, args);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_MEMBER_SET', function(event, id, name, value) {
|
||||
try {
|
||||
let obj = objectsRegistry.get(id);
|
||||
obj[name] = value;
|
||||
return event.returnValue = null;
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_MEMBER_GET', function(event, id, name) {
|
||||
try {
|
||||
let obj = objectsRegistry.get(id);
|
||||
return event.returnValue = valueToMeta(event.sender, obj[name]);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_DEREFERENCE', function(event, id) {
|
||||
return objectsRegistry.remove(event.sender.getId(), id);
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_GUEST_WEB_CONTENTS', function(event, guestInstanceId) {
|
||||
try {
|
||||
let guestViewManager = require('./guest-view-manager');
|
||||
return event.returnValue = valueToMeta(event.sender, guestViewManager.getGuest(guestInstanceId));
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
|
||||
ipcMain.on('ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', function(event, requestId, guestInstanceId, method, ...args) {
|
||||
try {
|
||||
let guestViewManager = require('./guest-view-manager');
|
||||
let guest = guestViewManager.getGuest(guestInstanceId);
|
||||
if (requestId) {
|
||||
const responseCallback = function(result) {
|
||||
event.sender.send(`ATOM_RENDERER_ASYNC_CALL_TO_GUEST_VIEW_RESPONSE_${requestId}`, result);
|
||||
};
|
||||
args.push(responseCallback);
|
||||
}
|
||||
guest[method].apply(guest, args);
|
||||
} catch (error) {
|
||||
return event.returnValue = exceptionToMeta(error);
|
||||
}
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue