2020-03-20 20:28:31 +00:00
|
|
|
import * as electron from 'electron';
|
2016-01-13 04:46:13 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
import { ipcRendererInternal } from '@electron/internal/renderer/ipc-renderer-internal';
|
|
|
|
import * as ipcRendererUtils from '@electron/internal/renderer/ipc-renderer-internal-utils';
|
|
|
|
import * as guestViewInternal from '@electron/internal/renderer/web-view/guest-view-internal';
|
|
|
|
import { WEB_VIEW_CONSTANTS } from '@electron/internal/renderer/web-view/web-view-constants';
|
|
|
|
import { syncMethods, asyncMethods, properties } from '@electron/internal/common/web-view-methods';
|
2020-11-03 23:02:23 +00:00
|
|
|
import type { WebViewAttribute, PartitionAttribute } from '@electron/internal/renderer/web-view/web-view-attributes';
|
2020-03-20 20:28:31 +00:00
|
|
|
import { deserialize } from '@electron/internal/common/type-utils';
|
2020-10-13 21:11:06 +00:00
|
|
|
import { IPC_MESSAGES } from '@electron/internal/common/ipc-messages';
|
2020-03-20 20:28:31 +00:00
|
|
|
const { webFrame } = electron;
|
2019-03-07 23:26:23 +00:00
|
|
|
|
2020-06-23 03:32:45 +00:00
|
|
|
const v8Util = process._linkedBinding('electron_common_v8_util');
|
2018-07-10 08:15:40 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// ID generator.
|
2020-03-20 20:28:31 +00:00
|
|
|
let nextId = 0;
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-11-03 17:39:40 +00:00
|
|
|
const getNextId = function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
return ++nextId;
|
|
|
|
};
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Represents the internal state of the WebView node.
|
2019-03-07 23:26:23 +00:00
|
|
|
export class WebViewImpl {
|
|
|
|
public beforeFirstNavigation = true
|
|
|
|
public elementAttached = false
|
|
|
|
public guestInstanceId?: number
|
|
|
|
public hasFocus = false
|
|
|
|
public internalInstanceId?: number;
|
|
|
|
public resizeObserver?: ResizeObserver;
|
|
|
|
public userAgentOverride?: string;
|
|
|
|
public viewInstanceId: number
|
|
|
|
|
|
|
|
// on* Event handlers.
|
|
|
|
public on: Record<string, any> = {}
|
|
|
|
public internalElement: HTMLIFrameElement
|
|
|
|
|
|
|
|
// Replaced in web-view-attributes
|
2020-11-03 23:02:23 +00:00
|
|
|
public attributes = new Map<string, WebViewAttribute>();
|
2019-03-07 23:26:23 +00:00
|
|
|
public setupWebViewAttributes (): void {}
|
|
|
|
|
|
|
|
constructor (public webviewNode: HTMLElement) {
|
2018-08-28 18:35:44 +00:00
|
|
|
// Create internal iframe element.
|
2020-03-20 20:28:31 +00:00
|
|
|
this.internalElement = this.createInternalElement();
|
|
|
|
const shadowRoot = this.webviewNode.attachShadow({ mode: 'open' });
|
|
|
|
shadowRoot.innerHTML = '<!DOCTYPE html><style type="text/css">:host { display: flex; }</style>';
|
|
|
|
this.setupWebViewAttributes();
|
|
|
|
this.viewInstanceId = getNextId();
|
|
|
|
shadowRoot.appendChild(this.internalElement);
|
2018-08-28 18:35:44 +00:00
|
|
|
|
|
|
|
// Provide access to contentWindow.
|
|
|
|
Object.defineProperty(this.webviewNode, 'contentWindow', {
|
|
|
|
get: () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
return this.internalElement.contentWindow;
|
2018-08-28 18:35:44 +00:00
|
|
|
},
|
|
|
|
enumerable: true
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
|
|
|
|
2018-08-16 22:57:40 +00:00
|
|
|
createInternalElement () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const iframeElement = document.createElement('iframe');
|
|
|
|
iframeElement.style.flex = '1 1 auto';
|
|
|
|
iframeElement.style.width = '100%';
|
|
|
|
iframeElement.style.border = '0';
|
|
|
|
v8Util.setHiddenValue(iframeElement, 'internal', this);
|
|
|
|
return iframeElement;
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Resets some state upon reattaching <webview> element to the DOM.
|
2016-11-03 17:55:12 +00:00
|
|
|
reset () {
|
2016-01-14 19:10:12 +00:00
|
|
|
// 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.
|
2016-01-12 02:40:23 +00:00
|
|
|
if (this.guestInstanceId) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.guestInstanceId = undefined;
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-09-08 17:01:01 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
this.beforeFirstNavigation = true;
|
2020-11-03 23:02:23 +00:00
|
|
|
(this.attributes.get(WEB_VIEW_CONSTANTS.ATTRIBUTE_PARTITION) as PartitionAttribute).validPartitionId = true;
|
2016-11-03 00:28:37 +00:00
|
|
|
|
2018-08-16 22:57:40 +00:00
|
|
|
// Since attachment swaps a local frame for a remote frame, we need our
|
|
|
|
// internal iframe element to be local again before we can reattach.
|
2020-03-20 20:28:31 +00:00
|
|
|
const newFrame = this.createInternalElement();
|
|
|
|
const oldFrame = this.internalElement;
|
|
|
|
this.internalElement = newFrame;
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
if (oldFrame && oldFrame.parentNode) {
|
2020-03-20 20:28:31 +00:00
|
|
|
oldFrame.parentNode.replaceChild(newFrame, oldFrame);
|
2019-03-07 23:26:23 +00:00
|
|
|
}
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 19:10:12 +00:00
|
|
|
// 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.
|
2019-03-07 23:26:23 +00:00
|
|
|
handleWebviewAttributeMutation (attributeName: string, oldValue: any, newValue: any) {
|
2020-11-03 23:02:23 +00:00
|
|
|
if (!this.attributes.has(attributeName) || this.attributes.get(attributeName)!.ignoreMutation) {
|
2020-03-20 20:28:31 +00:00
|
|
|
return;
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
|
|
|
|
2016-03-25 19:57:17 +00:00
|
|
|
// Let the changed attribute handle its own mutation
|
2020-11-03 23:02:23 +00:00
|
|
|
this.attributes.get(attributeName)!.handleMutation(oldValue, newValue);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2018-08-16 22:57:40 +00:00
|
|
|
onElementResize () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const resizeEvent = new Event('resize') as ElectronInternal.WebFrameResizeEvent;
|
|
|
|
resizeEvent.newWidth = this.webviewNode.clientWidth;
|
|
|
|
resizeEvent.newHeight = this.webviewNode.clientHeight;
|
|
|
|
this.dispatchEvent(resizeEvent);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-11-03 17:55:12 +00:00
|
|
|
createGuest () {
|
2019-03-01 18:33:03 +00:00
|
|
|
guestViewInternal.createGuest(this.buildParams()).then(guestInstanceId => {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.attachGuestInstance(guestInstanceId);
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
dispatchEvent (webViewEvent: Electron.Event) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.webviewNode.dispatchEvent(webViewEvent);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Adds an 'on<event>' property on the webview, which can be used to set/unset
|
|
|
|
// an event handler.
|
2019-03-07 23:26:23 +00:00
|
|
|
setupEventProperty (eventName: string) {
|
2020-03-20 20:28:31 +00:00
|
|
|
const propertyName = `on${eventName.toLowerCase()}`;
|
2016-01-12 02:40:23 +00:00
|
|
|
return Object.defineProperty(this.webviewNode, propertyName, {
|
2016-03-10 19:54:17 +00:00
|
|
|
get: () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
return this.on[propertyName];
|
2016-03-10 19:54:17 +00:00
|
|
|
},
|
|
|
|
set: (value) => {
|
|
|
|
if (this.on[propertyName]) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.webviewNode.removeEventListener(eventName, this.on[propertyName]);
|
2016-03-10 19:54:17 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
this.on[propertyName] = value;
|
2016-03-10 19:54:17 +00:00
|
|
|
if (value) {
|
2020-03-20 20:28:31 +00:00
|
|
|
return this.webviewNode.addEventListener(eventName, value);
|
2016-03-10 19:54:17 +00:00
|
|
|
}
|
|
|
|
},
|
2016-01-12 02:40:23 +00:00
|
|
|
enumerable: true
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Updates state upon loadcommit.
|
2019-03-07 23:26:23 +00:00
|
|
|
onLoadCommit (webViewEvent: ElectronInternal.WebViewEvent) {
|
2020-03-20 20:28:31 +00:00
|
|
|
const oldValue = this.webviewNode.getAttribute(WEB_VIEW_CONSTANTS.ATTRIBUTE_SRC);
|
|
|
|
const newValue = webViewEvent.url;
|
2016-01-12 02:40:23 +00:00
|
|
|
if (webViewEvent.isMainFrame && (oldValue !== newValue)) {
|
2016-01-14 19:10:12 +00:00
|
|
|
// Touching the src attribute triggers a navigation. To avoid
|
|
|
|
// triggering a page reload on every guest-initiated navigation,
|
|
|
|
// we do not handle this mutation.
|
2020-11-03 23:02:23 +00:00
|
|
|
this.attributes.get(WEB_VIEW_CONSTANTS.ATTRIBUTE_SRC)!.setValueIgnoreMutation(newValue);
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2018-08-28 18:35:44 +00:00
|
|
|
// Emits focus/blur events.
|
|
|
|
onFocusChange () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const hasFocus = document.activeElement === this.webviewNode;
|
2018-08-28 18:35:44 +00:00
|
|
|
if (hasFocus !== this.hasFocus) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.hasFocus = hasFocus;
|
|
|
|
this.dispatchEvent(new Event(hasFocus ? 'focus' : 'blur'));
|
2018-08-28 18:35:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
onAttach (storagePartitionId: number) {
|
2020-11-03 23:02:23 +00:00
|
|
|
return this.attributes.get(WEB_VIEW_CONSTANTS.ATTRIBUTE_PARTITION)!.setValue(storagePartitionId);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-11-03 17:55:12 +00:00
|
|
|
buildParams () {
|
2019-03-07 23:26:23 +00:00
|
|
|
const params: Record<string, any> = {
|
2016-01-12 02:40:23 +00:00
|
|
|
instanceId: this.viewInstanceId,
|
2017-01-30 17:06:50 +00:00
|
|
|
userAgentOverride: this.userAgentOverride
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2019-03-07 23:26:23 +00:00
|
|
|
|
2020-11-03 23:02:23 +00:00
|
|
|
for (const [attributeName, attribute] of this.attributes) {
|
|
|
|
params[attributeName] = attribute.getValue();
|
2016-01-12 02:40:23 +00:00
|
|
|
}
|
2019-03-07 23:26:23 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
return params;
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
attachGuestInstance (guestInstanceId: number) {
|
2018-08-16 22:57:40 +00:00
|
|
|
if (!this.elementAttached) {
|
|
|
|
// The element could be detached before we got response from browser.
|
2020-03-20 20:28:31 +00:00
|
|
|
return;
|
2018-08-16 22:57:40 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
this.internalInstanceId = getNextId();
|
|
|
|
this.guestInstanceId = guestInstanceId;
|
2019-03-07 23:26:23 +00:00
|
|
|
|
|
|
|
guestViewInternal.attachGuest(
|
|
|
|
this.internalInstanceId,
|
|
|
|
this.guestInstanceId,
|
|
|
|
this.buildParams(),
|
|
|
|
this.internalElement.contentWindow!
|
2020-03-20 20:28:31 +00:00
|
|
|
);
|
2019-03-07 23:26:23 +00:00
|
|
|
|
2018-08-16 22:57:40 +00:00
|
|
|
// TODO(zcbenz): Should we deprecate the "resize" event? Wait, it is not
|
|
|
|
// even documented.
|
2020-03-20 20:28:31 +00:00
|
|
|
this.resizeObserver = new ResizeObserver(this.onElementResize.bind(this));
|
|
|
|
this.resizeObserver.observe(this.internalElement);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
export const setupAttributes = () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
require('@electron/internal/renderer/web-view/web-view-attributes');
|
|
|
|
};
|
2019-01-12 01:00:43 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
// I wish eslint wasn't so stupid, but it is
|
|
|
|
// eslint-disable-next-line
|
|
|
|
export const setupMethods = (WebViewElement: typeof ElectronInternal.WebViewElement) => {
|
2019-03-26 01:57:27 +00:00
|
|
|
WebViewElement.prototype.getWebContentsId = function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const internal = v8Util.getHiddenValue<WebViewImpl>(this, 'internal');
|
2019-03-26 01:57:27 +00:00
|
|
|
if (!internal.guestInstanceId) {
|
2020-03-20 20:28:31 +00:00
|
|
|
throw new Error('The WebView must be attached to the DOM and the dom-ready event emitted before this method can be called.');
|
2019-03-26 01:57:27 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
return internal.guestInstanceId;
|
|
|
|
};
|
2019-03-26 01:57:27 +00:00
|
|
|
|
2019-01-12 01:00:43 +00:00
|
|
|
// Focusing the webview should move page focus to the underlying iframe.
|
|
|
|
WebViewElement.prototype.focus = function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.contentWindow.focus();
|
|
|
|
};
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2016-01-14 18:35:29 +00:00
|
|
|
// Forward proto.foo* method calls to WebViewImpl.foo*.
|
2019-03-07 23:26:23 +00:00
|
|
|
const createBlockHandler = function (method: string) {
|
2019-03-26 01:57:27 +00:00
|
|
|
return function (this: ElectronInternal.WebViewElement, ...args: Array<any>) {
|
2020-10-13 21:11:06 +00:00
|
|
|
return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_CALL, this.getWebContentsId(), method, args);
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
|
|
|
};
|
2019-03-07 23:26:23 +00:00
|
|
|
|
2018-12-04 15:12:21 +00:00
|
|
|
for (const method of syncMethods) {
|
2020-03-20 20:28:31 +00:00
|
|
|
(WebViewElement.prototype as Record<string, any>)[method] = createBlockHandler(method);
|
2016-03-25 19:57:17 +00:00
|
|
|
}
|
2016-11-03 18:09:53 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
const createNonBlockHandler = function (method: string) {
|
2019-03-26 01:57:27 +00:00
|
|
|
return function (this: ElectronInternal.WebViewElement, ...args: Array<any>) {
|
2020-10-13 21:11:06 +00:00
|
|
|
return ipcRendererInternal.invoke(IPC_MESSAGES.GUEST_VIEW_MANAGER_CALL, this.getWebContentsId(), method, args);
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
|
|
|
};
|
2019-01-17 20:08:54 +00:00
|
|
|
|
2019-06-17 09:10:02 +00:00
|
|
|
for (const method of asyncMethods) {
|
2020-03-20 20:28:31 +00:00
|
|
|
(WebViewElement.prototype as Record<string, any>)[method] = createNonBlockHandler(method);
|
2019-01-17 20:08:54 +00:00
|
|
|
}
|
2019-11-12 20:56:17 +00:00
|
|
|
|
|
|
|
WebViewElement.prototype.capturePage = async function (...args) {
|
2020-10-13 21:11:06 +00:00
|
|
|
return deserialize(await ipcRendererInternal.invoke(IPC_MESSAGES.GUEST_VIEW_MANAGER_CAPTURE_PAGE, this.getWebContentsId(), args));
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2020-03-03 22:25:14 +00:00
|
|
|
|
|
|
|
const createPropertyGetter = function (property: string) {
|
|
|
|
return function (this: ElectronInternal.WebViewElement) {
|
2020-10-13 21:11:06 +00:00
|
|
|
return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_GET, this.getWebContentsId(), property);
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
|
|
|
};
|
2020-03-03 22:25:14 +00:00
|
|
|
|
|
|
|
const createPropertySetter = function (property: string) {
|
|
|
|
return function (this: ElectronInternal.WebViewElement, arg: any) {
|
2020-10-13 21:11:06 +00:00
|
|
|
return ipcRendererUtils.invokeSync(IPC_MESSAGES.GUEST_VIEW_MANAGER_PROPERTY_SET, this.getWebContentsId(), property, arg);
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
|
|
|
};
|
2020-03-03 22:25:14 +00:00
|
|
|
|
|
|
|
for (const property of properties) {
|
|
|
|
Object.defineProperty(WebViewElement.prototype, property, {
|
2020-10-08 01:01:23 +00:00
|
|
|
get: createPropertyGetter(property),
|
2020-03-03 22:25:14 +00:00
|
|
|
set: createPropertySetter(property)
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2020-03-03 22:25:14 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2016-01-12 02:40:23 +00:00
|
|
|
|
2019-03-07 23:26:23 +00:00
|
|
|
export const webViewImplModule = {
|
|
|
|
setupAttributes,
|
|
|
|
setupMethods,
|
|
|
|
guestViewInternal,
|
|
|
|
webFrame,
|
|
|
|
WebViewImpl
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|