Move JavaScript to root lib/ folder

This commit is contained in:
Kevin Sawicki 2016-03-07 17:12:09 -08:00
parent a9c40de393
commit 70aa9b06ee
56 changed files with 0 additions and 0 deletions

View file

@ -0,0 +1,47 @@
const ipcRenderer = require('electron').ipcRenderer;
const nativeImage = require('electron').nativeImage;
var nextId = 0;
var includes = [].includes;
var getNextId = function() {
return ++nextId;
};
// |options.type| can not be empty and has to include 'window' or 'screen'.
var isValid = function(options) {
return ((options != null ? options.types : void 0) != null) && Array.isArray(options.types);
};
exports.getSources = function(options, callback) {
var captureScreen, captureWindow, id;
if (!isValid(options)) {
return callback(new Error('Invalid options'));
}
captureWindow = includes.call(options.types, 'window');
captureScreen = includes.call(options.types, 'screen');
if (options.thumbnailSize == null) {
options.thumbnailSize = {
width: 150,
height: 150
};
}
id = getNextId();
ipcRenderer.send('ATOM_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', captureWindow, captureScreen, options.thumbnailSize, id);
return ipcRenderer.once("ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_" + id, function(event, sources) {
var source;
return callback(null, (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: nativeImage.createFromDataURL(source.thumbnail)
});
}
return results;
})());
});
};

View file

@ -0,0 +1,38 @@
const common = require('../../../../common/api/lib/exports/electron');
// Import common modules.
common.defineProperties(exports);
Object.defineProperties(exports, {
// Renderer side modules, please sort with alphabet order.
desktopCapturer: {
enumerable: true,
get: function() {
return require('../desktop-capturer');
}
},
ipcRenderer: {
enumerable: true,
get: function() {
return require('../ipc-renderer');
}
},
remote: {
enumerable: true,
get: function() {
return require('../remote');
}
},
screen: {
enumerable: true,
get: function() {
return require('../screen');
}
},
webFrame: {
enumerable: true,
get: function() {
return require('../web-frame');
}
}
});

View file

@ -0,0 +1,27 @@
const binding = process.atomBinding('ipc');
const v8Util = process.atomBinding('v8_util');
var slice = [].slice;
// Created by init.coffee.
const ipcRenderer = v8Util.getHiddenValue(global, 'ipc');
ipcRenderer.send = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return binding.send('ipc-message', slice.call(args));
};
ipcRenderer.sendSync = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return JSON.parse(binding.sendSync('ipc-message-sync', slice.call(args)));
};
ipcRenderer.sendToHost = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return binding.send('ipc-message-host', slice.call(args));
};
module.exports = ipcRenderer;

31
lib/renderer/api/ipc.js Normal file
View file

@ -0,0 +1,31 @@
const ipcRenderer = require('electron').ipcRenderer;
const deprecate = require('electron').deprecate;
const EventEmitter = require('events').EventEmitter;
var slice = [].slice;
// This module is deprecated, we mirror everything from ipcRenderer.
deprecate.warn('ipc module', 'require("electron").ipcRenderer');
// Routes events of ipcRenderer.
var ipc = new EventEmitter;
ipcRenderer.emit = function() {
var channel = arguments[0];
var args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
ipc.emit.apply(ipc, [channel].concat(slice.call(args)));
return EventEmitter.prototype.emit.apply(ipcRenderer, arguments);
};
// Deprecated.
for (var method in ipcRenderer) {
if (method.startsWith('send')) {
ipc[method] = ipcRenderer[method];
}
}
deprecate.rename(ipc, 'sendChannel', 'send');
deprecate.rename(ipc, 'sendChannelSync', 'sendSync');
module.exports = ipc;

306
lib/renderer/api/remote.js Normal file
View file

@ -0,0 +1,306 @@
'use strict';
const ipcRenderer = require('electron').ipcRenderer;
const CallbacksRegistry = require('electron').CallbacksRegistry;
const v8Util = process.atomBinding('v8_util');
const IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap;
const callbacksRegistry = new CallbacksRegistry;
var includes = [].includes;
var remoteObjectCache = new IDWeakMap;
// Check for circular reference.
var isCircular = function(field, visited) {
if (typeof field === 'object') {
if (includes.call(visited, field)) {
return true;
}
visited.push(field);
}
return false;
};
// Convert the arguments object into an array of meta data.
var wrapArgs = function(args, visited) {
var valueToMeta;
if (visited == null) {
visited = [];
}
valueToMeta = function(value) {
var field, prop, ret;
if (Array.isArray(value)) {
return {
type: 'array',
value: wrapArgs(value, visited)
};
} else if (Buffer.isBuffer(value)) {
return {
type: 'buffer',
value: Array.prototype.slice.call(value, 0)
};
} else if (value instanceof Date) {
return {
type: 'date',
value: value.getTime()
};
} else if ((value != null ? value.constructor.name : void 0) === 'Promise') {
return {
type: 'promise',
then: valueToMeta(value.then.bind(value))
};
} else if ((value != null) && typeof value === 'object' && v8Util.getHiddenValue(value, 'atomId')) {
return {
type: 'remote-object',
id: v8Util.getHiddenValue(value, 'atomId')
};
} else if ((value != null) && typeof value === 'object') {
ret = {
type: 'object',
name: value.constructor.name,
members: []
};
for (prop in value) {
field = value[prop];
ret.members.push({
name: prop,
value: valueToMeta(isCircular(field, visited) ? null : field)
});
}
return ret;
} else if (typeof value === 'function' && v8Util.getHiddenValue(value, 'returnValue')) {
return {
type: 'function-with-return-value',
value: valueToMeta(value())
};
} else if (typeof value === 'function') {
return {
type: 'function',
id: callbacksRegistry.add(value),
location: v8Util.getHiddenValue(value, 'location')
};
} else {
return {
type: 'value',
value: value
};
}
};
return Array.prototype.slice.call(args).map(valueToMeta);
};
// Populate object's members from descriptors.
// This matches |getObjectMemebers| in rpc-server.
let setObjectMembers = function(object, metaId, members) {
for (let member of members) {
if (object.hasOwnProperty(member.name))
continue;
let descriptor = { enumerable: member.enumerable };
if (member.type === 'method') {
let remoteMemberFunction = function() {
if (this && this.constructor === remoteMemberFunction) {
// Constructor call.
let ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CONSTRUCTOR', metaId, member.name, wrapArgs(arguments));
return metaToValue(ret);
} else {
// Call member function.
let ret = ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_CALL', metaId, member.name, wrapArgs(arguments));
return metaToValue(ret);
}
};
descriptor.writable = true;
descriptor.configurable = true;
descriptor.value = remoteMemberFunction;
} else if (member.type === 'get') {
descriptor.get = function() {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_GET', metaId, member.name));
};
// Only set setter when it is writable.
if (member.writable) {
descriptor.set = function(value) {
ipcRenderer.sendSync('ATOM_BROWSER_MEMBER_SET', metaId, member.name, value);
return value;
};
}
}
Object.defineProperty(object, member.name, descriptor);
}
};
// Populate object's prototype from descriptor.
// This matches |getObjectPrototype| in rpc-server.
let setObjectPrototype = function(object, metaId, descriptor) {
if (descriptor === null)
return;
let proto = {};
setObjectMembers(proto, metaId, descriptor.members);
setObjectPrototype(proto, metaId, descriptor.proto);
Object.setPrototypeOf(object, proto);
};
// Convert meta data from browser into real value.
let metaToValue = function(meta) {
var el, i, len, ref1, results, ret;
switch (meta.type) {
case 'value':
return meta.value;
case 'array':
ref1 = meta.members;
results = [];
for (i = 0, len = ref1.length; i < len; i++) {
el = ref1[i];
results.push(metaToValue(el));
}
return results;
case 'buffer':
return new Buffer(meta.value);
case 'promise':
return Promise.resolve({
then: metaToValue(meta.then)
});
case 'error':
return metaToPlainObject(meta);
case 'date':
return new Date(meta.value);
case 'exception':
throw new Error(meta.message + "\n" + meta.stack);
default:
if (remoteObjectCache.has(meta.id))
return remoteObjectCache.get(meta.id);
if (meta.type === 'function') {
// A shadow class to represent the remote function object.
let remoteFunction = function() {
if (this && this.constructor === remoteFunction) {
// Constructor call.
let obj = ipcRenderer.sendSync('ATOM_BROWSER_CONSTRUCTOR', meta.id, wrapArgs(arguments));
// Returning object in constructor will replace constructed object
// with the returned object.
// http://stackoverflow.com/questions/1978049/what-values-can-a-constructor-return-to-avoid-returning-this
return metaToValue(obj);
} else {
// Function call.
let obj = ipcRenderer.sendSync('ATOM_BROWSER_FUNCTION_CALL', meta.id, wrapArgs(arguments));
return metaToValue(obj);
}
};
ret = remoteFunction;
} else {
ret = {};
}
// Populate delegate members.
setObjectMembers(ret, meta.id, meta.members);
// Populate delegate prototype.
setObjectPrototype(ret, meta.id, meta.proto);
// Set constructor.name to object's name.
Object.defineProperty(ret.constructor, 'name', { value: meta.name });
// Track delegate object's life time, and tell the browser to clean up
// when the object is GCed.
v8Util.setDestructor(ret, function() {
ipcRenderer.send('ATOM_BROWSER_DEREFERENCE', meta.id);
});
// Remember object's id.
v8Util.setHiddenValue(ret, 'atomId', meta.id);
remoteObjectCache.set(meta.id, ret);
return ret;
}
};
// Construct a plain object from the meta.
var metaToPlainObject = function(meta) {
var i, len, name, obj, ref1, ref2, value;
obj = (function() {
switch (meta.type) {
case 'error':
return new Error;
default:
return {};
}
})();
ref1 = meta.members;
for (i = 0, len = ref1.length; i < len; i++) {
ref2 = ref1[i], name = ref2.name, value = ref2.value;
obj[name] = value;
}
return obj;
};
// Browser calls a callback in renderer.
ipcRenderer.on('ATOM_RENDERER_CALLBACK', function(event, id, args) {
return callbacksRegistry.apply(id, metaToValue(args));
});
// A callback in browser is released.
ipcRenderer.on('ATOM_RENDERER_RELEASE_CALLBACK', function(event, id) {
return callbacksRegistry.remove(id);
});
// List all built-in modules in browser process.
const browserModules = require('../../../browser/api/lib/exports/electron');
// And add a helper receiver for each one.
var fn = function(name) {
return Object.defineProperty(exports, name, {
get: function() {
return exports.getBuiltin(name);
}
});
};
for (var name in browserModules) {
fn(name);
}
// Get remote module.
exports.require = function(module) {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_REQUIRE', module));
};
// Alias to remote.require('electron').xxx.
exports.getBuiltin = function(module) {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_GET_BUILTIN', module));
};
// Get current BrowserWindow.
exports.getCurrentWindow = function() {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WINDOW'));
};
// Get current WebContents object.
exports.getCurrentWebContents = function() {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_CURRENT_WEB_CONTENTS'));
};
// Get a global object in browser.
exports.getGlobal = function(name) {
return metaToValue(ipcRenderer.sendSync('ATOM_BROWSER_GLOBAL', name));
};
// Get the process object in browser.
exports.__defineGetter__('process', function() {
return exports.getGlobal('process');
});
// Create a funtion that will return the specifed value when called in browser.
exports.createFunctionWithReturnValue = function(returnValue) {
var func;
func = function() {
return returnValue;
};
v8Util.setHiddenValue(func, 'returnValue', true);
return func;
};
// Get the guest WebContents from guestInstanceId.
exports.getGuestWebContents = function(guestInstanceId) {
var meta;
meta = ipcRenderer.sendSync('ATOM_BROWSER_GUEST_WEB_CONTENTS', guestInstanceId);
return metaToValue(meta);
};

View file

@ -0,0 +1 @@
module.exports = require('electron').remote.screen;

View file

@ -0,0 +1,19 @@
'use strict';
const deprecate = require('electron').deprecate;
const EventEmitter = require('events').EventEmitter;
const webFrame = process.atomBinding('web_frame').webFrame;
// webFrame is an EventEmitter.
webFrame.__proto__ = EventEmitter.prototype;
// Lots of webview would subscribe to webFrame's events.
webFrame.setMaxListeners(0);
// Deprecated.
deprecate.rename(webFrame, 'registerUrlSchemeAsSecure', 'registerURLSchemeAsSecure');
deprecate.rename(webFrame, 'registerUrlSchemeAsBypassingCSP', 'registerURLSchemeAsBypassingCSP');
deprecate.rename(webFrame, 'registerUrlSchemeAsPrivileged', 'registerURLSchemeAsPrivileged');
module.exports = webFrame;

View file

@ -0,0 +1,13 @@
const url = require('url');
const chrome = window.chrome = window.chrome || {};
chrome.extension = {
getURL: function(path) {
return url.format({
protocol: location.protocol,
slashes: true,
hostname: location.hostname,
pathname: path
});
}
};

139
lib/renderer/init.js Normal file
View file

@ -0,0 +1,139 @@
'use strict';
const events = require('events');
const path = require('path');
const Module = require('module');
// We modified the original process.argv to let node.js load the
// atom-renderer.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'));
// The global variable will be used by ipc for event dispatching
var v8Util = process.atomBinding('v8_util');
v8Util.setHiddenValue(global, 'ipc', new events.EventEmitter);
// Use electron module after everything is ready.
const electron = require('electron');
// Call webFrame method.
electron.ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', (event, method, args) => {
electron.webFrame[method].apply(electron.webFrame, args);
});
electron.ipcRenderer.on('ELECTRON_INTERNAL_RENDERER_ASYNC_WEB_FRAME_METHOD', (event, requestId, method, args) => {
const responseCallback = function(result) {
event.sender.send(`ELECTRON_INTERNAL_BROWSER_ASYNC_WEB_FRAME_RESPONSE_${requestId}`, result);
};
args.push(responseCallback);
electron.webFrame[method].apply(electron.webFrame, args);
});
// Process command line arguments.
var nodeIntegration = 'false';
var preloadScript = null;
var ref = process.argv;
var i, len, arg;
for (i = 0, len = ref.length; i < len; i++) {
arg = ref[i];
if (arg.indexOf('--guest-instance-id=') === 0) {
// This is a guest web view.
process.guestInstanceId = parseInt(arg.substr(arg.indexOf('=') + 1));
} else if (arg.indexOf('--opener-id=') === 0) {
// This is a guest BrowserWindow.
process.openerId = parseInt(arg.substr(arg.indexOf('=') + 1));
} else if (arg.indexOf('--node-integration=') === 0) {
nodeIntegration = arg.substr(arg.indexOf('=') + 1);
} else if (arg.indexOf('--preload=') === 0) {
preloadScript = arg.substr(arg.indexOf('=') + 1);
}
}
if (location.protocol === 'chrome-devtools:') {
// Override some inspector APIs.
require('./inspector');
nodeIntegration = 'true';
} else if (location.protocol === 'chrome-extension:') {
// Add implementations of chrome API.
require('./chrome-api');
nodeIntegration = 'true';
} else {
// Override default web functions.
require('./override');
// Load webview tag implementation.
if (process.guestInstanceId == null) {
require('./web-view/web-view');
require('./web-view/web-view-attributes');
}
}
if (nodeIntegration === 'true' || nodeIntegration === 'all' || nodeIntegration === 'except-iframe' || nodeIntegration === 'manual-enable-iframe') {
// Export node bindings to global.
global.require = require;
global.module = module;
// Set the __filename to the path of html file if it is file: protocol.
if (window.location.protocol === 'file:') {
var pathname = process.platform === 'win32' && window.location.pathname[0] === '/' ? window.location.pathname.substr(1) : window.location.pathname;
global.__filename = path.normalize(decodeURIComponent(pathname));
global.__dirname = path.dirname(global.__filename);
// Set module's filename so relative require can work as expected.
module.filename = global.__filename;
// Also search for module under the html file.
module.paths = module.paths.concat(Module._nodeModulePaths(global.__dirname));
} else {
global.__filename = __filename;
global.__dirname = __dirname;
}
// Redirect window.onerror to uncaughtException.
window.onerror = function(message, filename, lineno, colno, error) {
if (global.process.listeners('uncaughtException').length > 0) {
global.process.emit('uncaughtException', error);
return true;
} else {
return false;
}
};
} else {
// Delete Node's symbols after the Environment has been loaded.
process.once('loaded', function() {
delete global.process;
delete global.setImmediate;
delete global.clearImmediate;
return delete global.global;
});
}
// Load the script specfied by the "preload" attribute.
if (preloadScript) {
try {
require(preloadScript);
} catch (error) {
if (error.code === 'MODULE_NOT_FOUND') {
console.error("Unable to load preload script " + preloadScript);
} else {
console.error(error);
console.error(error.stack);
}
}
}

81
lib/renderer/inspector.js Normal file
View file

@ -0,0 +1,81 @@
window.onload = function() {
// Use menu API to show context menu.
InspectorFrontendHost.showContextMenuAtPoint = createMenu;
// Use dialog API to override file chooser dialog.
return WebInspector.createFileSelectorElement = createFileSelectorElement;
};
var convertToMenuTemplate = function(items) {
var fn, i, item, len, template;
template = [];
fn = function(item) {
var transformed;
transformed = item.type === 'subMenu' ? {
type: 'submenu',
label: item.label,
enabled: item.enabled,
submenu: convertToMenuTemplate(item.subItems)
} : item.type === 'separator' ? {
type: 'separator'
} : item.type === 'checkbox' ? {
type: 'checkbox',
label: item.label,
enabled: item.enabled,
checked: item.checked
} : {
type: 'normal',
label: item.label,
enabled: item.enabled
};
if (item.id != null) {
transformed.click = function() {
DevToolsAPI.contextMenuItemSelected(item.id);
return DevToolsAPI.contextMenuCleared();
};
}
return template.push(transformed);
};
for (i = 0, len = items.length; i < len; i++) {
item = items[i];
fn(item);
}
return template;
};
var createMenu = function(x, y, items) {
const remote = require('electron').remote;
const Menu = remote.Menu;
const menu = Menu.buildFromTemplate(convertToMenuTemplate(items));
// The menu is expected to show asynchronously.
return setTimeout(function() {
return menu.popup(remote.getCurrentWindow());
});
};
var showFileChooserDialog = function(callback) {
var dialog, files, remote;
remote = require('electron').remote;
dialog = remote.dialog;
files = dialog.showOpenDialog({});
if (files != null) {
return callback(pathToHtml5FileObject(files[0]));
}
};
var pathToHtml5FileObject = function(path) {
var blob, fs;
fs = require('fs');
blob = new Blob([fs.readFileSync(path)]);
blob.name = path;
return blob;
};
var createFileSelectorElement = function(callback) {
var fileSelectorElement;
fileSelectorElement = document.createElement('span');
fileSelectorElement.style.display = 'none';
fileSelectorElement.click = showFileChooserDialog.bind(this, callback);
return fileSelectorElement;
};

230
lib/renderer/override.js Normal file
View file

@ -0,0 +1,230 @@
const ipcRenderer = require('electron').ipcRenderer;
const remote = require('electron').remote;
var slice = [].slice;
// Helper function to resolve relative url.
var a = window.top.document.createElement('a');
var resolveURL = function(url) {
a.href = url;
return a.href;
};
// Window object returned by "window.open".
var BrowserWindowProxy = (function() {
BrowserWindowProxy.proxies = {};
BrowserWindowProxy.getOrCreate = function(guestId) {
var base;
return (base = this.proxies)[guestId] != null ? base[guestId] : base[guestId] = new BrowserWindowProxy(guestId);
};
BrowserWindowProxy.remove = function(guestId) {
return delete this.proxies[guestId];
};
function BrowserWindowProxy(guestId1) {
this.guestId = guestId1;
this.closed = false;
ipcRenderer.once("ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_" + this.guestId, (function(_this) {
return function() {
BrowserWindowProxy.remove(_this.guestId);
return _this.closed = true;
};
})(this));
}
BrowserWindowProxy.prototype.close = function() {
return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', this.guestId);
};
BrowserWindowProxy.prototype.focus = function() {
return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', this.guestId, 'focus');
};
BrowserWindowProxy.prototype.blur = function() {
return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', this.guestId, 'blur');
};
BrowserWindowProxy.prototype.postMessage = function(message, targetOrigin) {
if (targetOrigin == null) {
targetOrigin = '*';
}
return ipcRenderer.send('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', this.guestId, message, targetOrigin, location.origin);
};
BrowserWindowProxy.prototype["eval"] = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return ipcRenderer.send.apply(ipcRenderer, ['ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', this.guestId, 'executeJavaScript'].concat(slice.call(args)));
};
return BrowserWindowProxy;
})();
if (process.guestInstanceId == null) {
// Override default window.close.
window.close = function() {
return remote.getCurrentWindow().close();
};
}
// Make the browser window or guest view emit "new-window" event.
window.open = function(url, frameName, features) {
var feature, guestId, i, ints, j, len, len1, name, options, ref1, ref2, value;
if (frameName == null) {
frameName = '';
}
if (features == null) {
features = '';
}
options = {};
ints = ['x', 'y', 'width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'zoom-factor'];
// Make sure to get rid of excessive whitespace in the property name
ref1 = features.split(/,\s*/);
for (i = 0, len = ref1.length; i < len; i++) {
feature = ref1[i];
ref2 = feature.split(/\s*=/), name = ref2[0], value = ref2[1];
options[name] = value === 'yes' || value === '1' ? true : value === 'no' || value === '0' ? false : value;
}
if (options.left) {
if (options.x == null) {
options.x = options.left;
}
}
if (options.top) {
if (options.y == null) {
options.y = options.top;
}
}
if (options.title == null) {
options.title = frameName;
}
if (options.width == null) {
options.width = 800;
}
if (options.height == null) {
options.height = 600;
}
// Resolve relative urls.
url = resolveURL(url);
for (j = 0, len1 = ints.length; j < len1; j++) {
name = ints[j];
if (options[name] != null) {
options[name] = parseInt(options[name], 10);
}
}
guestId = ipcRenderer.sendSync('ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', url, frameName, options);
if (guestId) {
return BrowserWindowProxy.getOrCreate(guestId);
} else {
return null;
}
};
// Use the dialog API to implement alert().
window.alert = function(message, title) {
var buttons;
if (title == null) {
title = '';
}
buttons = ['OK'];
message = message.toString();
remote.dialog.showMessageBox(remote.getCurrentWindow(), {
message: message,
title: title,
buttons: buttons
});
// Alert should always return undefined.
};
// And the confirm().
window.confirm = function(message, title) {
var buttons, cancelId;
if (title == null) {
title = '';
}
buttons = ['OK', 'Cancel'];
cancelId = 1;
return !remote.dialog.showMessageBox(remote.getCurrentWindow(), {
message: message,
title: title,
buttons: buttons,
cancelId: cancelId
});
};
// But we do not support prompt().
window.prompt = function() {
throw new Error('prompt() is and will not be supported.');
};
if (process.openerId != null) {
window.opener = BrowserWindowProxy.getOrCreate(process.openerId);
}
ipcRenderer.on('ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', function(event, sourceId, message, sourceOrigin) {
// Manually dispatch event instead of using postMessage because we also need to
// set event.source.
event = document.createEvent('Event');
event.initEvent('message', false, false);
event.data = message;
event.origin = sourceOrigin;
event.source = BrowserWindowProxy.getOrCreate(sourceId);
return window.dispatchEvent(event);
});
// Forward history operations to browser.
var sendHistoryOperation = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return ipcRenderer.send.apply(ipcRenderer, ['ATOM_SHELL_NAVIGATION_CONTROLLER'].concat(slice.call(args)));
};
var getHistoryOperation = function() {
var args;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return ipcRenderer.sendSync.apply(ipcRenderer, ['ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER'].concat(slice.call(args)));
};
window.history.back = function() {
return sendHistoryOperation('goBack');
};
window.history.forward = function() {
return sendHistoryOperation('goForward');
};
window.history.go = function(offset) {
return sendHistoryOperation('goToOffset', offset);
};
Object.defineProperty(window.history, 'length', {
get: function() {
return getHistoryOperation('length');
}
});
// Make document.hidden and document.visibilityState return the correct value.
Object.defineProperty(document, 'hidden', {
get: function() {
var currentWindow;
currentWindow = remote.getCurrentWindow();
return currentWindow.isMinimized() || !currentWindow.isVisible();
}
});
Object.defineProperty(document, 'visibilityState', {
get: function() {
if (document.hidden) {
return "hidden";
} else {
return "visible";
}
}
});

View file

@ -0,0 +1,112 @@
const ipcRenderer = require('electron').ipcRenderer;
const webFrame = require('electron').webFrame;
var slice = [].slice;
var requestId = 0;
var WEB_VIEW_EVENTS = {
'load-commit': ['url', 'isMainFrame'],
'did-finish-load': [],
'did-fail-load': ['errorCode', 'errorDescription', 'validatedURL'],
'did-frame-finish-load': ['isMainFrame'],
'did-start-loading': [],
'did-stop-loading': [],
'did-get-response-details': ['status', 'newURL', 'originalURL', 'httpResponseCode', 'requestMethod', 'referrer', 'headers'],
'did-get-redirect-request': ['oldURL', 'newURL', 'isMainFrame'],
'dom-ready': [],
'console-message': ['level', 'message', 'line', 'sourceId'],
'devtools-opened': [],
'devtools-closed': [],
'devtools-focused': [],
'new-window': ['url', 'frameName', 'disposition', 'options'],
'will-navigate': ['url'],
'did-navigate': ['url'],
'did-navigate-in-page': ['url'],
'close': [],
'crashed': [],
'gpu-crashed': [],
'plugin-crashed': ['name', 'version'],
'media-started-playing': [],
'media-paused': [],
'did-change-theme-color': ['themeColor'],
'destroyed': [],
'page-title-updated': ['title', 'explicitSet'],
'page-favicon-updated': ['favicons'],
'enter-html-full-screen': [],
'leave-html-full-screen': [],
'found-in-page': ['result']
};
var DEPRECATED_EVENTS = {
'page-title-updated': 'page-title-set'
};
var dispatchEvent = function() {
var args, domEvent, eventKey, eventName, f, i, j, len, ref1, webView;
webView = arguments[0], eventName = arguments[1], eventKey = arguments[2], args = 4 <= arguments.length ? slice.call(arguments, 3) : [];
if (DEPRECATED_EVENTS[eventName] != null) {
dispatchEvent.apply(null, [webView, DEPRECATED_EVENTS[eventName], eventKey].concat(slice.call(args)));
}
domEvent = new Event(eventName);
ref1 = WEB_VIEW_EVENTS[eventKey];
for (i = j = 0, len = ref1.length; j < len; i = ++j) {
f = ref1[i];
domEvent[f] = args[i];
}
webView.dispatchEvent(domEvent);
if (eventName === 'load-commit') {
return webView.onLoadCommit(domEvent);
}
};
module.exports = {
registerEvents: function(webView, viewInstanceId) {
ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-" + viewInstanceId, function() {
var eventName = arguments[1];
var args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
return dispatchEvent.apply(null, [webView, eventName, eventName].concat(slice.call(args)));
});
ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-" + viewInstanceId, function() {
var channel = arguments[1];
var args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
var domEvent = new Event('ipc-message');
domEvent.channel = channel;
domEvent.args = slice.call(args);
return webView.dispatchEvent(domEvent);
});
return ipcRenderer.on("ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-" + viewInstanceId, function() {
var args, domEvent, f, i, j, len, ref1;
args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
domEvent = new Event('size-changed');
ref1 = ['oldWidth', 'oldHeight', 'newWidth', 'newHeight'];
for (i = j = 0, len = ref1.length; j < len; i = ++j) {
f = ref1[i];
domEvent[f] = args[i];
}
return webView.onSizeChanged(domEvent);
});
},
deregisterEvents: function(viewInstanceId) {
ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-" + viewInstanceId);
ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-" + viewInstanceId);
return ipcRenderer.removeAllListeners("ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-" + viewInstanceId);
},
createGuest: function(params, callback) {
requestId++;
ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', params, requestId);
return ipcRenderer.once("ATOM_SHELL_RESPONSE_" + requestId, callback);
},
attachGuest: function(elementInstanceId, guestInstanceId, params) {
ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_ATTACH_GUEST', elementInstanceId, guestInstanceId, params);
return webFrame.attachGuest(elementInstanceId);
},
destroyGuest: function(guestInstanceId) {
return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', guestInstanceId);
},
setSize: function(guestInstanceId, params) {
return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', guestInstanceId, params);
},
setAllowTransparency: function(guestInstanceId, allowtransparency) {
return ipcRenderer.send('ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', guestInstanceId, allowtransparency);
}
};

View file

@ -0,0 +1,321 @@
'use strict';
const WebViewImpl = require('./web-view');
const guestViewInternal = require('./guest-view-internal');
const webViewConstants = require('./web-view-constants');
const remote = require('electron').remote;
// Helper function to resolve url set in attribute.
var a = document.createElement('a');
var resolveURL = function(url) {
a.href = url;
return a.href;
};
// Attribute objects.
// Default implementation of a WebView attribute.
class WebViewAttribute {
constructor(name, webViewImpl) {
this.name = name;
this.value = webViewImpl.webviewNode[name] || '';
this.webViewImpl = webViewImpl;
this.ignoreMutation = false;
this.defineProperty();
}
// Retrieves and returns the attribute's value.
getValue() {
return this.webViewImpl.webviewNode.getAttribute(this.name) || this.value;
}
// Sets the attribute's value.
setValue(value) {
return this.webViewImpl.webviewNode.setAttribute(this.name, value || '');
}
// Changes the attribute's value without triggering its mutation handler.
setValueIgnoreMutation(value) {
this.ignoreMutation = true;
this.setValue(value);
return this.ignoreMutation = false;
}
// Defines this attribute as a property on the webview node.
defineProperty() {
return Object.defineProperty(this.webViewImpl.webviewNode, this.name, {
get: (function(_this) {
return function() {
return _this.getValue();
};
})(this),
set: (function(_this) {
return function(value) {
return _this.setValue(value);
};
})(this),
enumerable: true
});
}
// Called when the attribute's value changes.
handleMutation() {}
}
// An attribute that is treated as a Boolean.
class BooleanAttribute extends WebViewAttribute {
constructor(name, webViewImpl) {
super(name, webViewImpl);
}
getValue() {
return this.webViewImpl.webviewNode.hasAttribute(this.name);
}
setValue(value) {
if (!value) {
return this.webViewImpl.webviewNode.removeAttribute(this.name);
} else {
return this.webViewImpl.webviewNode.setAttribute(this.name, '');
}
}
}
// Attribute that specifies whether transparency is allowed in the webview.
class AllowTransparencyAttribute extends BooleanAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY, webViewImpl);
}
handleMutation() {
if (!this.webViewImpl.guestInstanceId) {
return;
}
return guestViewInternal.setAllowTransparency(this.webViewImpl.guestInstanceId, this.getValue());
}
}
// Attribute used to define the demension limits of autosizing.
class AutosizeDimensionAttribute extends WebViewAttribute {
constructor(name, webViewImpl) {
super(name, webViewImpl);
}
getValue() {
return parseInt(this.webViewImpl.webviewNode.getAttribute(this.name)) || 0;
}
handleMutation() {
if (!this.webViewImpl.guestInstanceId) {
return;
}
return guestViewInternal.setSize(this.webViewImpl.guestInstanceId, {
enableAutoSize: this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE].getValue(),
min: {
width: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MINWIDTH].getValue() || 0),
height: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MINHEIGHT].getValue() || 0)
},
max: {
width: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MAXWIDTH].getValue() || 0),
height: parseInt(this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_MAXHEIGHT].getValue() || 0)
}
});
}
}
// Attribute that specifies whether the webview should be autosized.
class AutosizeAttribute extends BooleanAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_AUTOSIZE, webViewImpl);
}
}
AutosizeAttribute.prototype.handleMutation = AutosizeDimensionAttribute.prototype.handleMutation;
// Attribute representing the state of the storage partition.
class PartitionAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_PARTITION, webViewImpl);
this.validPartitionId = true;
}
handleMutation(oldValue, newValue) {
newValue = newValue || '';
// The partition cannot change if the webview has already navigated.
if (!this.webViewImpl.beforeFirstNavigation) {
window.console.error(webViewConstants.ERROR_MSG_ALREADY_NAVIGATED);
this.setValueIgnoreMutation(oldValue);
return;
}
if (newValue === 'persist:') {
this.validPartitionId = false;
return window.console.error(webViewConstants.ERROR_MSG_INVALID_PARTITION_ATTRIBUTE);
}
}
}
// Attribute that handles the location and navigation of the webview.
class SrcAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_SRC, webViewImpl);
this.setupMutationObserver();
}
getValue() {
if (this.webViewImpl.webviewNode.hasAttribute(this.name)) {
return resolveURL(this.webViewImpl.webviewNode.getAttribute(this.name));
} else {
return this.value;
}
}
setValueIgnoreMutation(value) {
super.setValueIgnoreMutation(value);
// takeRecords() is needed to clear queued up src mutations. Without it, it
// is possible for this change to get picked up asyncronously by src's
// mutation observer |observer|, and then get handled even though we do not
// want to handle this mutation.
return this.observer.takeRecords();
}
handleMutation(oldValue, newValue) {
// Once we have navigated, we don't allow clearing the src attribute.
// Once <webview> enters a navigated state, it cannot return to a
// placeholder state.
if (!newValue && oldValue) {
// src attribute changes normally initiate a navigation. We suppress
// the next src attribute handler call to avoid reloading the page
// on every guest-initiated navigation.
this.setValueIgnoreMutation(oldValue);
return;
}
return this.parse();
}
// The purpose of this mutation observer is to catch assignment to the src
// attribute without any changes to its value. This is useful in the case
// where the webview guest has crashed and navigating to the same address
// spawns off a new process.
setupMutationObserver() {
var params;
this.observer = new MutationObserver((function(_this) {
return function(mutations) {
var i, len, mutation, newValue, oldValue;
for (i = 0, len = mutations.length; i < len; i++) {
mutation = mutations[i];
oldValue = mutation.oldValue;
newValue = _this.getValue();
if (oldValue !== newValue) {
return;
}
_this.handleMutation(oldValue, newValue);
}
};
})(this));
params = {
attributes: true,
attributeOldValue: true,
attributeFilter: [this.name]
};
return this.observer.observe(this.webViewImpl.webviewNode, params);
}
parse() {
var guestContents, httpreferrer, opts, useragent;
if (!this.webViewImpl.elementAttached || !this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_PARTITION].validPartitionId || !this.getValue()) {
return;
}
if (this.webViewImpl.guestInstanceId == null) {
if (this.webViewImpl.beforeFirstNavigation) {
this.webViewImpl.beforeFirstNavigation = false;
this.webViewImpl.createGuest();
}
return;
}
// Navigate to |this.src|.
opts = {};
httpreferrer = this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_HTTPREFERRER].getValue();
if (httpreferrer) {
opts.httpReferrer = httpreferrer;
}
useragent = this.webViewImpl.attributes[webViewConstants.ATTRIBUTE_USERAGENT].getValue();
if (useragent) {
opts.userAgent = useragent;
}
guestContents = remote.getGuestWebContents(this.webViewImpl.guestInstanceId);
return guestContents.loadURL(this.getValue(), opts);
}
}
// Attribute specifies HTTP referrer.
class HttpReferrerAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_HTTPREFERRER, webViewImpl);
}
}
// Attribute specifies user agent
class UserAgentAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_USERAGENT, webViewImpl);
}
}
// Attribute that set preload script.
class PreloadAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_PRELOAD, webViewImpl);
}
getValue() {
var preload, protocol;
if (!this.webViewImpl.webviewNode.hasAttribute(this.name)) {
return this.value;
}
preload = resolveURL(this.webViewImpl.webviewNode.getAttribute(this.name));
protocol = preload.substr(0, 5);
if (protocol !== 'file:') {
console.error(webViewConstants.ERROR_MSG_INVALID_PRELOAD_ATTRIBUTE);
preload = '';
}
return preload;
}
}
// Attribute that specifies the blink features to be enabled.
class BlinkFeaturesAttribute extends WebViewAttribute {
constructor(webViewImpl) {
super(webViewConstants.ATTRIBUTE_BLINKFEATURES, webViewImpl);
}
}
// Sets up all of the webview attributes.
WebViewImpl.prototype.setupWebViewAttributes = function() {
var attribute, autosizeAttributes, i, len, results;
this.attributes = {};
this.attributes[webViewConstants.ATTRIBUTE_ALLOWTRANSPARENCY] = new AllowTransparencyAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE] = new AutosizeAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_PARTITION] = new PartitionAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_SRC] = new SrcAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_HTTPREFERRER] = new HttpReferrerAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_USERAGENT] = new UserAgentAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_NODEINTEGRATION] = new BooleanAttribute(webViewConstants.ATTRIBUTE_NODEINTEGRATION, this);
this.attributes[webViewConstants.ATTRIBUTE_PLUGINS] = new BooleanAttribute(webViewConstants.ATTRIBUTE_PLUGINS, this);
this.attributes[webViewConstants.ATTRIBUTE_DISABLEWEBSECURITY] = new BooleanAttribute(webViewConstants.ATTRIBUTE_DISABLEWEBSECURITY, this);
this.attributes[webViewConstants.ATTRIBUTE_ALLOWPOPUPS] = new BooleanAttribute(webViewConstants.ATTRIBUTE_ALLOWPOPUPS, this);
this.attributes[webViewConstants.ATTRIBUTE_PRELOAD] = new PreloadAttribute(this);
this.attributes[webViewConstants.ATTRIBUTE_BLINKFEATURES] = new BlinkFeaturesAttribute(this);
autosizeAttributes = [webViewConstants.ATTRIBUTE_MAXHEIGHT, webViewConstants.ATTRIBUTE_MAXWIDTH, webViewConstants.ATTRIBUTE_MINHEIGHT, webViewConstants.ATTRIBUTE_MINWIDTH];
results = [];
for (i = 0, len = autosizeAttributes.length; i < len; i++) {
attribute = autosizeAttributes[i];
results.push(this.attributes[attribute] = new AutosizeDimensionAttribute(attribute, this));
}
return results;
};

View file

@ -0,0 +1,29 @@
module.exports = {
// Attributes.
ATTRIBUTE_ALLOWTRANSPARENCY: 'allowtransparency',
ATTRIBUTE_AUTOSIZE: 'autosize',
ATTRIBUTE_MAXHEIGHT: 'maxheight',
ATTRIBUTE_MAXWIDTH: 'maxwidth',
ATTRIBUTE_MINHEIGHT: 'minheight',
ATTRIBUTE_MINWIDTH: 'minwidth',
ATTRIBUTE_NAME: 'name',
ATTRIBUTE_PARTITION: 'partition',
ATTRIBUTE_SRC: 'src',
ATTRIBUTE_HTTPREFERRER: 'httpreferrer',
ATTRIBUTE_NODEINTEGRATION: 'nodeintegration',
ATTRIBUTE_PLUGINS: 'plugins',
ATTRIBUTE_DISABLEWEBSECURITY: 'disablewebsecurity',
ATTRIBUTE_ALLOWPOPUPS: 'allowpopups',
ATTRIBUTE_PRELOAD: 'preload',
ATTRIBUTE_USERAGENT: 'useragent',
ATTRIBUTE_BLINKFEATURES: 'blinkfeatures',
// Internal attribute.
ATTRIBUTE_INTERNALINSTANCEID: 'internalinstanceid',
// Error messages.
ERROR_MSG_ALREADY_NAVIGATED: 'The object has already navigated, so its partition cannot be changed.',
ERROR_MSG_CANNOT_INJECT_SCRIPT: '<webview>: ' + 'Script cannot be injected into content until the page has loaded.',
ERROR_MSG_INVALID_PARTITION_ATTRIBUTE: 'Invalid partition attribute.',
ERROR_MSG_INVALID_PRELOAD_ATTRIBUTE: 'Only "file:" protocol is supported in "preload" attribute.'
};

View file

@ -0,0 +1,478 @@
'use strict';
const deprecate = require('electron').deprecate;
const webFrame = require('electron').webFrame;
const remote = require('electron').remote;
const ipcRenderer = require('electron').ipcRenderer;
const v8Util = process.atomBinding('v8_util');
const guestViewInternal = require('./guest-view-internal');
const webViewConstants = require('./web-view-constants');
var hasProp = {}.hasOwnProperty;
var slice = [].slice;
// ID generator.
var nextId = 0;
var getNextId = function() {
return ++nextId;
};
// Represents the internal state of the WebView node.
var WebViewImpl = (function() {
function WebViewImpl(webviewNode) {
var shadowRoot;
this.webviewNode = webviewNode;
v8Util.setHiddenValue(this.webviewNode, 'internal', this);
this.attached = false;
this.elementAttached = false;
this.beforeFirstNavigation = true;
// on* Event handlers.
this.on = {};
this.browserPluginNode = this.createBrowserPluginNode();
shadowRoot = this.webviewNode.createShadowRoot();
shadowRoot.innerHTML = '<style>:host { display: flex; }</style>';
this.setupWebViewAttributes();
this.setupFocusPropagation();
this.viewInstanceId = getNextId();
shadowRoot.appendChild(this.browserPluginNode);
// Subscribe to host's zoom level changes.
this.onZoomLevelChanged = (zoomLevel) => {
this.webviewNode.setZoomLevel(zoomLevel);
};
webFrame.on('zoom-level-changed', this.onZoomLevelChanged);
}
WebViewImpl.prototype.createBrowserPluginNode = function() {
// We create BrowserPlugin as a custom element in order to observe changes
// to attributes synchronously.
var browserPluginNode;
browserPluginNode = new WebViewImpl.BrowserPlugin();
v8Util.setHiddenValue(browserPluginNode, 'internal', this);
return browserPluginNode;
};
// Resets some state upon reattaching <webview> element to the DOM.
WebViewImpl.prototype.reset = function() {
// Unlisten the zoom-level-changed event.
webFrame.removeListener('zoom-level-changed', this.onZoomLevelChanged);
// If guestInstanceId is defined then the <webview> has navigated and has
// already picked up a partition ID. Thus, we need to reset the initialization
// state. However, it may be the case that beforeFirstNavigation is false BUT
// guestInstanceId has yet to be initialized. This means that we have not
// heard back from createGuest yet. We will not reset the flag in this case so
// that we don't end up allocating a second guest.
if (this.guestInstanceId) {
guestViewInternal.destroyGuest(this.guestInstanceId);
this.webContents = null;
this.guestInstanceId = void 0;
this.beforeFirstNavigation = true;
this.attributes[webViewConstants.ATTRIBUTE_PARTITION].validPartitionId = true;
}
return this.internalInstanceId = 0;
};
// Sets the <webview>.request property.
WebViewImpl.prototype.setRequestPropertyOnWebViewNode = function(request) {
return Object.defineProperty(this.webviewNode, 'request', {
value: request,
enumerable: true
});
};
WebViewImpl.prototype.setupFocusPropagation = function() {
if (!this.webviewNode.hasAttribute('tabIndex')) {
// <webview> needs a tabIndex in order to be focusable.
// TODO(fsamuel): It would be nice to avoid exposing a tabIndex attribute
// to allow <webview> to be focusable.
// See http://crbug.com/231664.
this.webviewNode.setAttribute('tabIndex', -1);
}
this.webviewNode.addEventListener('focus', (function(_this) {
return function() {
// Focus the BrowserPlugin when the <webview> takes focus.
return _this.browserPluginNode.focus();
};
})(this));
return this.webviewNode.addEventListener('blur', (function(_this) {
return function() {
// Blur the BrowserPlugin when the <webview> loses focus.
return _this.browserPluginNode.blur();
};
})(this));
};
// This observer monitors mutations to attributes of the <webview> and
// updates the BrowserPlugin properties accordingly. In turn, updating
// a BrowserPlugin property will update the corresponding BrowserPlugin
// attribute, if necessary. See BrowserPlugin::UpdateDOMAttribute for more
// details.
WebViewImpl.prototype.handleWebviewAttributeMutation = function(attributeName, oldValue, newValue) {
if (!this.attributes[attributeName] || this.attributes[attributeName].ignoreMutation) {
return;
}
// Let the changed attribute handle its own mutation;
return this.attributes[attributeName].handleMutation(oldValue, newValue);
};
WebViewImpl.prototype.handleBrowserPluginAttributeMutation = function(attributeName, oldValue, newValue) {
if (attributeName === webViewConstants.ATTRIBUTE_INTERNALINSTANCEID && !oldValue && !!newValue) {
this.browserPluginNode.removeAttribute(webViewConstants.ATTRIBUTE_INTERNALINSTANCEID);
this.internalInstanceId = parseInt(newValue);
// Track when the element resizes using the element resize callback.
webFrame.registerElementResizeCallback(this.internalInstanceId, this.onElementResize.bind(this));
if (!this.guestInstanceId) {
return;
}
return guestViewInternal.attachGuest(this.internalInstanceId, this.guestInstanceId, this.buildParams());
}
};
WebViewImpl.prototype.onSizeChanged = function(webViewEvent) {
var maxHeight, maxWidth, minHeight, minWidth, newHeight, newWidth, node, width;
newWidth = webViewEvent.newWidth;
newHeight = webViewEvent.newHeight;
node = this.webviewNode;
width = node.offsetWidth;
// Check the current bounds to make sure we do not resize <webview>
// outside of current constraints.
maxWidth = this.attributes[webViewConstants.ATTRIBUTE_MAXWIDTH].getValue() | width;
maxHeight = this.attributes[webViewConstants.ATTRIBUTE_MAXHEIGHT].getValue() | width;
minWidth = this.attributes[webViewConstants.ATTRIBUTE_MINWIDTH].getValue() | width;
minHeight = this.attributes[webViewConstants.ATTRIBUTE_MINHEIGHT].getValue() | width;
minWidth = Math.min(minWidth, maxWidth);
minHeight = Math.min(minHeight, maxHeight);
if (!this.attributes[webViewConstants.ATTRIBUTE_AUTOSIZE].getValue() || (newWidth >= minWidth && newWidth <= maxWidth && newHeight >= minHeight && newHeight <= maxHeight)) {
node.style.width = newWidth + 'px';
node.style.height = newHeight + 'px';
// Only fire the DOM event if the size of the <webview> has actually
// changed.
return this.dispatchEvent(webViewEvent);
}
};
WebViewImpl.prototype.onElementResize = function(newSize) {
// Dispatch the 'resize' event.
var resizeEvent;
resizeEvent = new Event('resize', {
bubbles: true
});
resizeEvent.newWidth = newSize.width;
resizeEvent.newHeight = newSize.height;
this.dispatchEvent(resizeEvent);
if (this.guestInstanceId) {
return guestViewInternal.setSize(this.guestInstanceId, {
normal: newSize
});
}
};
WebViewImpl.prototype.createGuest = function() {
return guestViewInternal.createGuest(this.buildParams(), (function(_this) {
return function(event, guestInstanceId) {
return _this.attachWindow(guestInstanceId);
};
})(this));
};
WebViewImpl.prototype.dispatchEvent = function(webViewEvent) {
return this.webviewNode.dispatchEvent(webViewEvent);
};
// Adds an 'on<event>' property on the webview, which can be used to set/unset
// an event handler.
WebViewImpl.prototype.setupEventProperty = function(eventName) {
var propertyName;
propertyName = 'on' + eventName.toLowerCase();
return Object.defineProperty(this.webviewNode, propertyName, {
get: (function(_this) {
return function() {
return _this.on[propertyName];
};
})(this),
set: (function(_this) {
return function(value) {
if (_this.on[propertyName]) {
_this.webviewNode.removeEventListener(eventName, _this.on[propertyName]);
}
_this.on[propertyName] = value;
if (value) {
return _this.webviewNode.addEventListener(eventName, value);
}
};
})(this),
enumerable: true
});
};
// Updates state upon loadcommit.
WebViewImpl.prototype.onLoadCommit = function(webViewEvent) {
var newValue, oldValue;
oldValue = this.webviewNode.getAttribute(webViewConstants.ATTRIBUTE_SRC);
newValue = webViewEvent.url;
if (webViewEvent.isMainFrame && (oldValue !== newValue)) {
// Touching the src attribute triggers a navigation. To avoid
// triggering a page reload on every guest-initiated navigation,
// we do not handle this mutation.
return this.attributes[webViewConstants.ATTRIBUTE_SRC].setValueIgnoreMutation(newValue);
}
};
WebViewImpl.prototype.onAttach = function(storagePartitionId) {
return this.attributes[webViewConstants.ATTRIBUTE_PARTITION].setValue(storagePartitionId);
};
WebViewImpl.prototype.buildParams = function() {
var attribute, attributeName, css, elementRect, params, ref1;
params = {
instanceId: this.viewInstanceId,
userAgentOverride: this.userAgentOverride
};
ref1 = this.attributes;
for (attributeName in ref1) {
if (!hasProp.call(ref1, attributeName)) continue;
attribute = ref1[attributeName];
params[attributeName] = attribute.getValue();
}
// When the WebView is not participating in layout (display:none)
// then getBoundingClientRect() would report a width and height of 0.
// However, in the case where the WebView has a fixed size we can
// use that value to initially size the guest so as to avoid a relayout of
// the on display:block.
css = window.getComputedStyle(this.webviewNode, null);
elementRect = this.webviewNode.getBoundingClientRect();
params.elementWidth = parseInt(elementRect.width) || parseInt(css.getPropertyValue('width'));
params.elementHeight = parseInt(elementRect.height) || parseInt(css.getPropertyValue('height'));
return params;
};
WebViewImpl.prototype.attachWindow = function(guestInstanceId) {
this.guestInstanceId = guestInstanceId;
this.webContents = remote.getGuestWebContents(this.guestInstanceId);
if (!this.internalInstanceId) {
return true;
}
return guestViewInternal.attachGuest(this.internalInstanceId, this.guestInstanceId, this.buildParams());
};
return WebViewImpl;
})();
// Registers browser plugin <object> custom element.
var registerBrowserPluginElement = function() {
var proto;
proto = Object.create(HTMLObjectElement.prototype);
proto.createdCallback = function() {
this.setAttribute('type', 'application/browser-plugin');
this.setAttribute('id', 'browser-plugin-' + getNextId());
// The <object> node fills in the <webview> container.
return this.style.flex = '1 1 auto';
};
proto.attributeChangedCallback = function(name, oldValue, newValue) {
var internal;
internal = v8Util.getHiddenValue(this, 'internal');
if (!internal) {
return;
}
return internal.handleBrowserPluginAttributeMutation(name, oldValue, newValue);
};
proto.attachedCallback = function() {
// Load the plugin immediately.
return this.nonExistentAttribute;
};
WebViewImpl.BrowserPlugin = webFrame.registerEmbedderCustomElement('browserplugin', {
"extends": 'object',
prototype: proto
});
delete proto.createdCallback;
delete proto.attachedCallback;
delete proto.detachedCallback;
return delete proto.attributeChangedCallback;
};
// Registers <webview> custom element.
var registerWebViewElement = function() {
var createBlockHandler, createNonBlockHandler, i, j, len, len1, m, methods, nonblockMethods, proto;
proto = Object.create(HTMLObjectElement.prototype);
proto.createdCallback = function() {
return new WebViewImpl(this);
};
proto.attributeChangedCallback = function(name, oldValue, newValue) {
var internal;
internal = v8Util.getHiddenValue(this, 'internal');
if (!internal) {
return;
}
return internal.handleWebviewAttributeMutation(name, oldValue, newValue);
};
proto.detachedCallback = function() {
var internal;
internal = v8Util.getHiddenValue(this, 'internal');
if (!internal) {
return;
}
guestViewInternal.deregisterEvents(internal.viewInstanceId);
internal.elementAttached = false;
return internal.reset();
};
proto.attachedCallback = function() {
var internal;
internal = v8Util.getHiddenValue(this, 'internal');
if (!internal) {
return;
}
if (!internal.elementAttached) {
guestViewInternal.registerEvents(internal, internal.viewInstanceId);
internal.elementAttached = true;
return internal.attributes[webViewConstants.ATTRIBUTE_SRC].parse();
}
};
// Public-facing API methods.
methods = [
'getURL',
'loadURL',
'getTitle',
'isLoading',
'isWaitingForResponse',
'stop',
'reload',
'reloadIgnoringCache',
'canGoBack',
'canGoForward',
'canGoToOffset',
'clearHistory',
'goBack',
'goForward',
'goToIndex',
'goToOffset',
'isCrashed',
'setUserAgent',
'getUserAgent',
'openDevTools',
'closeDevTools',
'isDevToolsOpened',
'isDevToolsFocused',
'inspectElement',
'setAudioMuted',
'isAudioMuted',
'undo',
'redo',
'cut',
'copy',
'paste',
'pasteAndMatchStyle',
'delete',
'selectAll',
'unselect',
'replace',
'replaceMisspelling',
'findInPage',
'stopFindInPage',
'getId',
'downloadURL',
'inspectServiceWorker',
'print',
'printToPDF',
];
nonblockMethods = [
'insertCSS',
'insertText',
'send',
'sendInputEvent',
'setZoomFactor',
'setZoomLevel',
'setZoomLevelLimits',
];
// Forward proto.foo* method calls to WebViewImpl.foo*.
createBlockHandler = function(m) {
return function() {
var args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
var internal = v8Util.getHiddenValue(this, 'internal');
if (internal.webContents) {
return internal.webContents[m].apply(internal.webContents, args);
} else {
throw new Error(`Cannot call ${m} because the webContents is unavailable. The WebView must be attached to the DOM and the dom-ready event emitted before this method can be called.`);
}
};
};
for (i = 0, len = methods.length; i < len; i++) {
m = methods[i];
proto[m] = createBlockHandler(m);
}
createNonBlockHandler = function(m) {
return function() {
var args, internal;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
internal = v8Util.getHiddenValue(this, 'internal');
return ipcRenderer.send.apply(ipcRenderer, ['ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', null, internal.guestInstanceId, m].concat(slice.call(args)));
};
};
for (j = 0, len1 = nonblockMethods.length; j < len1; j++) {
m = nonblockMethods[j];
proto[m] = createNonBlockHandler(m);
}
proto.executeJavaScript = function(code, hasUserGesture, callback) {
var internal = v8Util.getHiddenValue(this, 'internal');
if (typeof hasUserGesture === "function") {
callback = hasUserGesture;
hasUserGesture = false;
}
let requestId = getNextId();
ipcRenderer.send('ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', requestId, internal.guestInstanceId, "executeJavaScript", code, hasUserGesture);
ipcRenderer.once(`ATOM_RENDERER_ASYNC_CALL_TO_GUEST_VIEW_RESPONSE_${requestId}`, function(event, result) {
if (callback)
callback(result);
});
};
// WebContents associated with this webview.
proto.getWebContents = function() {
var internal = v8Util.getHiddenValue(this, 'internal');
return internal.webContents;
};
// Deprecated.
deprecate.rename(proto, 'getUrl', 'getURL');
window.WebView = webFrame.registerEmbedderCustomElement('webview', {
prototype: proto
});
// Delete the callbacks so developers cannot call them and produce unexpected
// behavior.
delete proto.createdCallback;
delete proto.attachedCallback;
delete proto.detachedCallback;
return delete proto.attributeChangedCallback;
};
var useCapture = true;
var listener = function(event) {
if (document.readyState === 'loading') {
return;
}
registerBrowserPluginElement();
registerWebViewElement();
return window.removeEventListener(event.type, listener, useCapture);
};
window.addEventListener('readystatechange', listener, true);
module.exports = WebViewImpl;