mirror of
https://github.com/react/react-native-devtools-frontend.git
synced 2026-10-08 12:53:45 +08:00
Junyi Xiao
89142cffe3
Accessibility testing revealed that there are tab traps in all of the text editors including read only ones. Once keyboard users tab into the editor, they cannot tab out the editor. This change adds a shortcut to disable/re-enable tab for indentation, which allows keyboard users continue to use tab to navigate to next UI component. Settings Shortcuts page screenshot: https://imgur.com/a/qeOjGoB Change-Id: I026a5a9c47407634a78c2ccf1a0bc532baa39e07 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1545200 Reviewed-by: Joel Einbinder <einbinder@chromium.org> Commit-Queue: Junyi Xiao <juxiao@microsoft.com> Cr-Original-Commit-Position: refs/heads/master@{#649901} Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src Cr-Mirrored-Commit: 27ff38b767bc1659a596830b864acf60850e6bd0
1427 lines
39 KiB
JavaScript
1427 lines
39 KiB
JavaScript
// Copyright 2014 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
/* eslint-disable indent */
|
|
(function(window) {
|
|
|
|
// DevToolsAPI ----------------------------------------------------------------
|
|
|
|
/**
|
|
* @unrestricted
|
|
*/
|
|
const DevToolsAPIImpl = class {
|
|
constructor() {
|
|
/**
|
|
* @type {number}
|
|
*/
|
|
this._lastCallId = 0;
|
|
|
|
/**
|
|
* @type {!Object.<number, function(?Object)>}
|
|
*/
|
|
this._callbacks = {};
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {?Object} arg
|
|
*/
|
|
embedderMessageAck(id, arg) {
|
|
const callback = this._callbacks[id];
|
|
delete this._callbacks[id];
|
|
if (callback)
|
|
callback(arg);
|
|
}
|
|
|
|
/**
|
|
* @param {string} method
|
|
* @param {!Array.<*>} args
|
|
* @param {?function(?Object)} callback
|
|
*/
|
|
sendMessageToEmbedder(method, args, callback) {
|
|
const callId = ++this._lastCallId;
|
|
if (callback)
|
|
this._callbacks[callId] = callback;
|
|
const message = {'id': callId, 'method': method};
|
|
if (args.length)
|
|
message.params = args;
|
|
DevToolsHost.sendMessageToEmbedder(JSON.stringify(message));
|
|
}
|
|
|
|
/**
|
|
* @param {string} method
|
|
* @param {!Array<*>} args
|
|
*/
|
|
_dispatchOnInspectorFrontendAPI(method, args) {
|
|
const inspectorFrontendAPI = /** @type {!Object<string, function()>} */ (window['InspectorFrontendAPI']);
|
|
inspectorFrontendAPI[method].apply(inspectorFrontendAPI, args);
|
|
}
|
|
|
|
// API methods below this line --------------------------------------------
|
|
|
|
/**
|
|
* @param {!Array.<!ExtensionDescriptor>} extensions
|
|
*/
|
|
addExtensions(extensions) {
|
|
// Support for legacy front-ends (<M41).
|
|
if (window['WebInspector'] && window['WebInspector']['addExtensions']) {
|
|
window['WebInspector']['addExtensions'](extensions);
|
|
} else if (window['InspectorFrontendAPI']) {
|
|
// The addExtensions command is sent as the onload event happens for
|
|
// DevTools front-end. In case of hosted mode, this
|
|
// happens before the InspectorFrontendAPI is initialized.
|
|
this._dispatchOnInspectorFrontendAPI('addExtensions', [extensions]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} url
|
|
*/
|
|
appendedToURL(url) {
|
|
this._dispatchOnInspectorFrontendAPI('appendedToURL', [url]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} url
|
|
*/
|
|
canceledSaveURL(url) {
|
|
this._dispatchOnInspectorFrontendAPI('canceledSaveURL', [url]);
|
|
}
|
|
|
|
contextMenuCleared() {
|
|
this._dispatchOnInspectorFrontendAPI('contextMenuCleared', []);
|
|
}
|
|
|
|
/**
|
|
* @param {string} id
|
|
*/
|
|
contextMenuItemSelected(id) {
|
|
this._dispatchOnInspectorFrontendAPI('contextMenuItemSelected', [id]);
|
|
}
|
|
|
|
/**
|
|
* @param {number} count
|
|
*/
|
|
deviceCountUpdated(count) {
|
|
this._dispatchOnInspectorFrontendAPI('deviceCountUpdated', [count]);
|
|
}
|
|
|
|
/**
|
|
* @param {!Adb.Config} config
|
|
*/
|
|
devicesDiscoveryConfigChanged(config) {
|
|
this._dispatchOnInspectorFrontendAPI('devicesDiscoveryConfigChanged', [config]);
|
|
}
|
|
|
|
/**
|
|
* @param {!Adb.PortForwardingStatus} status
|
|
*/
|
|
devicesPortForwardingStatusChanged(status) {
|
|
this._dispatchOnInspectorFrontendAPI('devicesPortForwardingStatusChanged', [status]);
|
|
}
|
|
|
|
/**
|
|
* @param {!Array.<!Adb.Device>} devices
|
|
*/
|
|
devicesUpdated(devices) {
|
|
this._dispatchOnInspectorFrontendAPI('devicesUpdated', [devices]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} message
|
|
*/
|
|
dispatchMessage(message) {
|
|
this._dispatchOnInspectorFrontendAPI('dispatchMessage', [message]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} messageChunk
|
|
* @param {number} messageSize
|
|
*/
|
|
dispatchMessageChunk(messageChunk, messageSize) {
|
|
this._dispatchOnInspectorFrontendAPI('dispatchMessageChunk', [messageChunk, messageSize]);
|
|
}
|
|
|
|
enterInspectElementMode() {
|
|
this._dispatchOnInspectorFrontendAPI('enterInspectElementMode', []);
|
|
}
|
|
|
|
/**
|
|
* @param {!{r: number, g: number, b: number, a: number}} color
|
|
*/
|
|
eyeDropperPickedColor(color) {
|
|
this._dispatchOnInspectorFrontendAPI('eyeDropperPickedColor', [color]);
|
|
}
|
|
|
|
/**
|
|
* @param {!Array.<!{fileSystemName: string, rootURL: string, fileSystemPath: string}>} fileSystems
|
|
*/
|
|
fileSystemsLoaded(fileSystems) {
|
|
this._dispatchOnInspectorFrontendAPI('fileSystemsLoaded', [fileSystems]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} fileSystemPath
|
|
*/
|
|
fileSystemRemoved(fileSystemPath) {
|
|
this._dispatchOnInspectorFrontendAPI('fileSystemRemoved', [fileSystemPath]);
|
|
}
|
|
|
|
/**
|
|
* @param {?string} error
|
|
* @param {?{type: string, fileSystemName: string, rootURL: string, fileSystemPath: string}} fileSystem
|
|
*/
|
|
fileSystemAdded(error, fileSystem) {
|
|
this._dispatchOnInspectorFrontendAPI('fileSystemAdded', [error, fileSystem]);
|
|
}
|
|
|
|
/**
|
|
* @param {!Array<string>} changedPaths
|
|
* @param {!Array<string>} addedPaths
|
|
* @param {!Array<string>} removedPaths
|
|
*/
|
|
fileSystemFilesChangedAddedRemoved(changedPaths, addedPaths, removedPaths) {
|
|
// Support for legacy front-ends (<M58)
|
|
if (window['InspectorFrontendAPI'] && window['InspectorFrontendAPI']['fileSystemFilesChanged']) {
|
|
this._dispatchOnInspectorFrontendAPI(
|
|
'fileSystemFilesChanged', [changedPaths.concat(addedPaths).concat(removedPaths)]);
|
|
} else {
|
|
this._dispatchOnInspectorFrontendAPI(
|
|
'fileSystemFilesChangedAddedRemoved', [changedPaths, addedPaths, removedPaths]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
* @param {number} totalWork
|
|
*/
|
|
indexingTotalWorkCalculated(requestId, fileSystemPath, totalWork) {
|
|
this._dispatchOnInspectorFrontendAPI('indexingTotalWorkCalculated', [requestId, fileSystemPath, totalWork]);
|
|
}
|
|
|
|
/**
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
* @param {number} worked
|
|
*/
|
|
indexingWorked(requestId, fileSystemPath, worked) {
|
|
this._dispatchOnInspectorFrontendAPI('indexingWorked', [requestId, fileSystemPath, worked]);
|
|
}
|
|
|
|
/**
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
*/
|
|
indexingDone(requestId, fileSystemPath) {
|
|
this._dispatchOnInspectorFrontendAPI('indexingDone', [requestId, fileSystemPath]);
|
|
}
|
|
|
|
/**
|
|
* @param {{type: string, key: string, code: string, keyCode: number, modifiers: number}} event
|
|
*/
|
|
keyEventUnhandled(event) {
|
|
event.keyIdentifier = keyCodeToKeyIdentifier(event.keyCode);
|
|
this._dispatchOnInspectorFrontendAPI('keyEventUnhandled', [event]);
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} hard
|
|
*/
|
|
reloadInspectedPage(hard) {
|
|
this._dispatchOnInspectorFrontendAPI('reloadInspectedPage', [hard]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {number} lineNumber
|
|
* @param {number} columnNumber
|
|
*/
|
|
revealSourceLine(url, lineNumber, columnNumber) {
|
|
this._dispatchOnInspectorFrontendAPI('revealSourceLine', [url, lineNumber, columnNumber]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} url
|
|
* @param {string=} fileSystemPath
|
|
*/
|
|
savedURL(url, fileSystemPath) {
|
|
this._dispatchOnInspectorFrontendAPI('savedURL', [url, fileSystemPath]);
|
|
}
|
|
|
|
/**
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
* @param {!Array.<string>} files
|
|
*/
|
|
searchCompleted(requestId, fileSystemPath, files) {
|
|
this._dispatchOnInspectorFrontendAPI('searchCompleted', [requestId, fileSystemPath, files]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} tabId
|
|
*/
|
|
setInspectedTabId(tabId) {
|
|
// Support for legacy front-ends (<M41).
|
|
if (window['WebInspector'] && window['WebInspector']['setInspectedTabId'])
|
|
window['WebInspector']['setInspectedTabId'](tabId);
|
|
else
|
|
this._dispatchOnInspectorFrontendAPI('setInspectedTabId', [tabId]);
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} useSoftMenu
|
|
*/
|
|
setUseSoftMenu(useSoftMenu) {
|
|
this._dispatchOnInspectorFrontendAPI('setUseSoftMenu', [useSoftMenu]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} panelName
|
|
*/
|
|
showPanel(panelName) {
|
|
this._dispatchOnInspectorFrontendAPI('showPanel', [panelName]);
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {string} chunk
|
|
* @param {boolean} encoded
|
|
*/
|
|
streamWrite(id, chunk, encoded) {
|
|
this._dispatchOnInspectorFrontendAPI('streamWrite', [id, encoded ? this._decodeBase64(chunk) : chunk]);
|
|
}
|
|
|
|
/**
|
|
* @param {string} chunk
|
|
* @return {string}
|
|
*/
|
|
_decodeBase64(chunk) {
|
|
const request = new XMLHttpRequest();
|
|
request.open('GET', 'data:text/plain;base64,' + chunk, false);
|
|
request.send(null);
|
|
if (request.status === 200) {
|
|
return request.responseText;
|
|
} else {
|
|
console.error('Error while decoding chunk in streamWrite');
|
|
return '';
|
|
}
|
|
}
|
|
};
|
|
|
|
const DevToolsAPI = new DevToolsAPIImpl();
|
|
window.DevToolsAPI = DevToolsAPI;
|
|
|
|
// InspectorFrontendHostImpl --------------------------------------------------
|
|
|
|
/**
|
|
* @implements {InspectorFrontendHostAPI}
|
|
* @unrestricted
|
|
*/
|
|
const InspectorFrontendHostImpl = class {
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
getSelectionBackgroundColor() {
|
|
return '#6e86ff';
|
|
}
|
|
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
getSelectionForegroundColor() {
|
|
return '#ffffff';
|
|
}
|
|
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
getInactiveSelectionBackgroundColor() {
|
|
return '#c9c8c8';
|
|
}
|
|
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
getInactiveSelectionForegroundColor() {
|
|
return '#323232';
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @return {string}
|
|
*/
|
|
platform() {
|
|
return DevToolsHost.platform();
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
loadCompleted() {
|
|
DevToolsAPI.sendMessageToEmbedder('loadCompleted', [], null);
|
|
// Support for legacy (<57) frontends.
|
|
if (window.Runtime && window.Runtime.queryParam) {
|
|
const panelToOpen = window.Runtime.queryParam('panel');
|
|
if (panelToOpen)
|
|
window.DevToolsAPI.showPanel(panelToOpen);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
bringToFront() {
|
|
DevToolsAPI.sendMessageToEmbedder('bringToFront', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
closeWindow() {
|
|
DevToolsAPI.sendMessageToEmbedder('closeWindow', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {boolean} isDocked
|
|
* @param {function()} callback
|
|
*/
|
|
setIsDocked(isDocked, callback) {
|
|
DevToolsAPI.sendMessageToEmbedder('setIsDocked', [isDocked], callback);
|
|
}
|
|
|
|
/**
|
|
* Requests inspected page to be placed atop of the inspector frontend with specified bounds.
|
|
* @override
|
|
* @param {{x: number, y: number, width: number, height: number}} bounds
|
|
*/
|
|
setInspectedPageBounds(bounds) {
|
|
DevToolsAPI.sendMessageToEmbedder('setInspectedPageBounds', [bounds], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
inspectElementCompleted() {
|
|
DevToolsAPI.sendMessageToEmbedder('inspectElementCompleted', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
* @param {string} headers
|
|
* @param {number} streamId
|
|
* @param {function(!InspectorFrontendHostAPI.LoadNetworkResourceResult)} callback
|
|
*/
|
|
loadNetworkResource(url, headers, streamId, callback) {
|
|
DevToolsAPI.sendMessageToEmbedder(
|
|
'loadNetworkResource', [url, headers, streamId], /** @type {function(?Object)} */ (callback));
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {function(!Object<string, string>)} callback
|
|
*/
|
|
getPreferences(callback) {
|
|
DevToolsAPI.sendMessageToEmbedder('getPreferences', [], /** @type {function(?Object)} */ (callback));
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} name
|
|
* @param {string} value
|
|
*/
|
|
setPreference(name, value) {
|
|
DevToolsAPI.sendMessageToEmbedder('setPreference', [name, value], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} name
|
|
*/
|
|
removePreference(name) {
|
|
DevToolsAPI.sendMessageToEmbedder('removePreference', [name], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
clearPreferences() {
|
|
DevToolsAPI.sendMessageToEmbedder('clearPreferences', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} origin
|
|
* @param {string} script
|
|
*/
|
|
setInjectedScriptForOrigin(origin, script) {
|
|
DevToolsAPI.sendMessageToEmbedder('registerExtensionsAPI', [origin, script], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
*/
|
|
inspectedURLChanged(url) {
|
|
DevToolsAPI.sendMessageToEmbedder('inspectedURLChanged', [url], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} text
|
|
*/
|
|
copyText(text) {
|
|
DevToolsHost.copyText(text);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
*/
|
|
openInNewTab(url) {
|
|
DevToolsAPI.sendMessageToEmbedder('openInNewTab', [url], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} fileSystemPath
|
|
*/
|
|
showItemInFolder(fileSystemPath) {
|
|
DevToolsAPI.sendMessageToEmbedder('showItemInFolder', [fileSystemPath], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
* @param {string} content
|
|
* @param {boolean} forceSaveAs
|
|
*/
|
|
save(url, content, forceSaveAs) {
|
|
DevToolsAPI.sendMessageToEmbedder('save', [url, content, forceSaveAs], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
* @param {string} content
|
|
*/
|
|
append(url, content) {
|
|
DevToolsAPI.sendMessageToEmbedder('append', [url, content], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} url
|
|
*/
|
|
close(url) {
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} message
|
|
*/
|
|
sendMessageToBackend(message) {
|
|
DevToolsAPI.sendMessageToEmbedder('dispatchProtocolMessage', [message], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} actionName
|
|
* @param {number} actionCode
|
|
* @param {number} bucketSize
|
|
*/
|
|
recordEnumeratedHistogram(actionName, actionCode, bucketSize) {
|
|
// Support for M49 frontend.
|
|
if (actionName === 'DevTools.DrawerShown')
|
|
return;
|
|
DevToolsAPI.sendMessageToEmbedder('recordEnumeratedHistogram', [actionName, actionCode, bucketSize], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} histogramName
|
|
* @param {number} duration
|
|
*/
|
|
recordPerformanceHistogram(histogramName, duration) {
|
|
DevToolsAPI.sendMessageToEmbedder('recordPerformanceHistogram', [histogramName, duration], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
requestFileSystems() {
|
|
DevToolsAPI.sendMessageToEmbedder('requestFileSystems', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string=} type
|
|
*/
|
|
addFileSystem(type) {
|
|
DevToolsAPI.sendMessageToEmbedder('addFileSystem', [type || ''], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} fileSystemPath
|
|
*/
|
|
removeFileSystem(fileSystemPath) {
|
|
DevToolsAPI.sendMessageToEmbedder('removeFileSystem', [fileSystemPath], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} fileSystemId
|
|
* @param {string} registeredName
|
|
* @return {?DOMFileSystem}
|
|
*/
|
|
isolatedFileSystem(fileSystemId, registeredName) {
|
|
return DevToolsHost.isolatedFileSystem(fileSystemId, registeredName);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {!FileSystem} fileSystem
|
|
*/
|
|
upgradeDraggedFileSystemPermissions(fileSystem) {
|
|
DevToolsHost.upgradeDraggedFileSystemPermissions(fileSystem);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
* @param {string} excludedFolders
|
|
*/
|
|
indexPath(requestId, fileSystemPath, excludedFolders) {
|
|
// |excludedFolders| added in M67. For backward compatibility,
|
|
// pass empty array.
|
|
excludedFolders = excludedFolders || '[]';
|
|
DevToolsAPI.sendMessageToEmbedder('indexPath', [requestId, fileSystemPath, excludedFolders], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {number} requestId
|
|
*/
|
|
stopIndexing(requestId) {
|
|
DevToolsAPI.sendMessageToEmbedder('stopIndexing', [requestId], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {number} requestId
|
|
* @param {string} fileSystemPath
|
|
* @param {string} query
|
|
*/
|
|
searchInPath(requestId, fileSystemPath, query) {
|
|
DevToolsAPI.sendMessageToEmbedder('searchInPath', [requestId, fileSystemPath, query], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @return {number}
|
|
*/
|
|
zoomFactor() {
|
|
return DevToolsHost.zoomFactor();
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
zoomIn() {
|
|
DevToolsAPI.sendMessageToEmbedder('zoomIn', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
zoomOut() {
|
|
DevToolsAPI.sendMessageToEmbedder('zoomOut', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
resetZoom() {
|
|
DevToolsAPI.sendMessageToEmbedder('resetZoom', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} shortcuts
|
|
*/
|
|
setWhitelistedShortcuts(shortcuts) {
|
|
DevToolsAPI.sendMessageToEmbedder('setWhitelistedShortcuts', [shortcuts], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {boolean} active
|
|
*/
|
|
setEyeDropperActive(active) {
|
|
DevToolsAPI.sendMessageToEmbedder('setEyeDropperActive', [active], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {!Array<string>} certChain
|
|
*/
|
|
showCertificateViewer(certChain) {
|
|
DevToolsAPI.sendMessageToEmbedder('showCertificateViewer', [JSON.stringify(certChain)], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {function()} callback
|
|
*/
|
|
reattach(callback) {
|
|
DevToolsAPI.sendMessageToEmbedder('reattach', [], callback);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
readyForTest() {
|
|
DevToolsAPI.sendMessageToEmbedder('readyForTest', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
connectionReady() {
|
|
DevToolsAPI.sendMessageToEmbedder('connectionReady', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {boolean} value
|
|
*/
|
|
setOpenNewWindowForPopups(value) {
|
|
DevToolsAPI.sendMessageToEmbedder('setOpenNewWindowForPopups', [value], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {!Adb.Config} config
|
|
*/
|
|
setDevicesDiscoveryConfig(config) {
|
|
DevToolsAPI.sendMessageToEmbedder(
|
|
'setDevicesDiscoveryConfig',
|
|
[
|
|
config.discoverUsbDevices, config.portForwardingEnabled, JSON.stringify(config.portForwardingConfig),
|
|
config.networkDiscoveryEnabled, JSON.stringify(config.networkDiscoveryConfig)
|
|
],
|
|
null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {boolean} enabled
|
|
*/
|
|
setDevicesUpdatesEnabled(enabled) {
|
|
DevToolsAPI.sendMessageToEmbedder('setDevicesUpdatesEnabled', [enabled], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} pageId
|
|
* @param {string} action
|
|
*/
|
|
performActionOnRemotePage(pageId, action) {
|
|
DevToolsAPI.sendMessageToEmbedder('performActionOnRemotePage', [pageId, action], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {string} browserId
|
|
* @param {string} url
|
|
*/
|
|
openRemotePage(browserId, url) {
|
|
DevToolsAPI.sendMessageToEmbedder('openRemotePage', [browserId, url], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
openNodeFrontend() {
|
|
DevToolsAPI.sendMessageToEmbedder('openNodeFrontend', [], null);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {!Array.<!InspectorFrontendHostAPI.ContextMenuDescriptor>} items
|
|
* @param {!Document} document
|
|
*/
|
|
showContextMenuAtPoint(x, y, items, document) {
|
|
DevToolsHost.showContextMenuAtPoint(x, y, items, document);
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
* @return {boolean}
|
|
*/
|
|
isHostedMode() {
|
|
return DevToolsHost.isHostedMode();
|
|
}
|
|
|
|
// Backward-compatible methods below this line --------------------------------------------
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M65).
|
|
* @return {boolean}
|
|
*/
|
|
isUnderTest() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M50).
|
|
* @param {string} message
|
|
*/
|
|
sendFrontendAPINotification(message) {
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M41).
|
|
* @return {string}
|
|
*/
|
|
port() {
|
|
return 'unknown';
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M38).
|
|
* @param {number} zoomFactor
|
|
*/
|
|
setZoomFactor(zoomFactor) {
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M34).
|
|
*/
|
|
sendMessageToEmbedder() {
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M34).
|
|
* @param {string} dockSide
|
|
*/
|
|
requestSetDockSide(dockSide) {
|
|
DevToolsAPI.sendMessageToEmbedder('setIsDocked', [dockSide !== 'undocked'], null);
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M34).
|
|
* @return {boolean}
|
|
*/
|
|
supportsFileSystems() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M44).
|
|
* @param {number} actionCode
|
|
*/
|
|
recordActionTaken(actionCode) {
|
|
this.recordEnumeratedHistogram('DevTools.ActionTaken', actionCode, 100);
|
|
}
|
|
|
|
/**
|
|
* Support for legacy front-ends (<M44).
|
|
* @param {number} panelCode
|
|
*/
|
|
recordPanelShown(panelCode) {
|
|
this.recordEnumeratedHistogram('DevTools.PanelShown', panelCode, 20);
|
|
}
|
|
};
|
|
|
|
window.InspectorFrontendHost = new InspectorFrontendHostImpl();
|
|
|
|
// DevToolsApp ---------------------------------------------------------------
|
|
|
|
function installObjectObserve() {
|
|
/** @type {!Array<string>} */
|
|
const properties = [
|
|
'advancedSearchConfig',
|
|
'auditsPanelSplitViewState',
|
|
'auditsSidebarWidth',
|
|
'blockedURLs',
|
|
'breakpoints',
|
|
'cacheDisabled',
|
|
'colorFormat',
|
|
'consoleHistory',
|
|
'consoleTimestampsEnabled',
|
|
'cpuProfilerView',
|
|
'cssSourceMapsEnabled',
|
|
'currentDockState',
|
|
'customColorPalette',
|
|
'customDevicePresets',
|
|
'customEmulatedDeviceList',
|
|
'customFormatters',
|
|
'customUserAgent',
|
|
'databaseTableViewVisibleColumns',
|
|
'dataGrid-cookiesTable',
|
|
'dataGrid-DOMStorageItemsView',
|
|
'debuggerSidebarHidden',
|
|
'disableDataSaverInfobar',
|
|
'disablePausedStateOverlay',
|
|
'domBreakpoints',
|
|
'domWordWrap',
|
|
'elementsPanelSplitViewState',
|
|
'elementsSidebarWidth',
|
|
'emulation.deviceHeight',
|
|
'emulation.deviceModeValue',
|
|
'emulation.deviceOrientationOverride',
|
|
'emulation.deviceScale',
|
|
'emulation.deviceScaleFactor',
|
|
'emulation.deviceUA',
|
|
'emulation.deviceWidth',
|
|
'emulation.geolocationOverride',
|
|
'emulation.showDeviceMode',
|
|
'emulation.showRulers',
|
|
'enableAsyncStackTraces',
|
|
'eventListenerBreakpoints',
|
|
'fileMappingEntries',
|
|
'fileSystemMapping',
|
|
'FileSystemViewSidebarWidth',
|
|
'fileSystemViewSplitViewState',
|
|
'filterBar-consoleView',
|
|
'filterBar-networkPanel',
|
|
'filterBar-promisePane',
|
|
'filterBar-timelinePanel',
|
|
'frameViewerHideChromeWindow',
|
|
'heapSnapshotRetainersViewSize',
|
|
'heapSnapshotSplitViewState',
|
|
'hideCollectedPromises',
|
|
'hideNetworkMessages',
|
|
'highlightNodeOnHoverInOverlay',
|
|
'highResolutionCpuProfiling',
|
|
'inlineVariableValues',
|
|
'Inspector.drawerSplitView',
|
|
'Inspector.drawerSplitViewState',
|
|
'InspectorView.panelOrder',
|
|
'InspectorView.screencastSplitView',
|
|
'InspectorView.screencastSplitViewState',
|
|
'InspectorView.splitView',
|
|
'InspectorView.splitViewState',
|
|
'javaScriptDisabled',
|
|
'jsSourceMapsEnabled',
|
|
'lastActivePanel',
|
|
'lastDockState',
|
|
'lastSelectedSourcesSidebarPaneTab',
|
|
'lastSnippetEvaluationIndex',
|
|
'layerDetailsSplitView',
|
|
'layerDetailsSplitViewState',
|
|
'layersPanelSplitViewState',
|
|
'layersShowInternalLayers',
|
|
'layersSidebarWidth',
|
|
'messageLevelFilters',
|
|
'messageURLFilters',
|
|
'monitoringXHREnabled',
|
|
'navigatorGroupByFolder',
|
|
'navigatorHidden',
|
|
'networkColorCodeResourceTypes',
|
|
'networkConditions',
|
|
'networkConditionsCustomProfiles',
|
|
'networkHideDataURL',
|
|
'networkLogColumnsVisibility',
|
|
'networkLogLargeRows',
|
|
'networkLogShowOverview',
|
|
'networkPanelSplitViewState',
|
|
'networkRecordFilmStripSetting',
|
|
'networkResourceTypeFilters',
|
|
'networkShowPrimaryLoadWaterfall',
|
|
'networkSidebarWidth',
|
|
'openLinkHandler',
|
|
'pauseOnCaughtException',
|
|
'pauseOnExceptionEnabled',
|
|
'preserveConsoleLog',
|
|
'prettyPrintInfobarDisabled',
|
|
'previouslyViewedFiles',
|
|
'profilesPanelSplitViewState',
|
|
'profilesSidebarWidth',
|
|
'promiseStatusFilters',
|
|
'recordAllocationStacks',
|
|
'requestHeaderFilterSetting',
|
|
'request-info-formData-category-expanded',
|
|
'request-info-general-category-expanded',
|
|
'request-info-queryString-category-expanded',
|
|
'request-info-requestHeaders-category-expanded',
|
|
'request-info-requestPayload-category-expanded',
|
|
'request-info-responseHeaders-category-expanded',
|
|
'resources',
|
|
'resourcesLastSelectedItem',
|
|
'resourcesPanelSplitViewState',
|
|
'resourcesSidebarWidth',
|
|
'resourceViewTab',
|
|
'savedURLs',
|
|
'screencastEnabled',
|
|
'scriptsPanelNavigatorSidebarWidth',
|
|
'searchInContentScripts',
|
|
'selectedAuditCategories',
|
|
'selectedColorPalette',
|
|
'selectedProfileType',
|
|
'shortcutPanelSwitch',
|
|
'showAdvancedHeapSnapshotProperties',
|
|
'showEventListenersForAncestors',
|
|
'showFrameowkrListeners',
|
|
'showHeaSnapshotObjectsHiddenProperties',
|
|
'showInheritedComputedStyleProperties',
|
|
'showMediaQueryInspector',
|
|
'showNativeFunctionsInJSProfile',
|
|
'showUAShadowDOM',
|
|
'showWhitespacesInEditor',
|
|
'sidebarPosition',
|
|
'skipContentScripts',
|
|
'skipStackFramesPattern',
|
|
'sourceMapInfobarDisabled',
|
|
'sourcesPanelDebuggerSidebarSplitViewState',
|
|
'sourcesPanelNavigatorSplitViewState',
|
|
'sourcesPanelSplitSidebarRatio',
|
|
'sourcesPanelSplitViewState',
|
|
'sourcesSidebarWidth',
|
|
'standardEmulatedDeviceList',
|
|
'StylesPaneSplitRatio',
|
|
'stylesPaneSplitViewState',
|
|
'textEditorAutocompletion',
|
|
'textEditorAutoDetectIndent',
|
|
'textEditorBracketMatching',
|
|
'textEditorIndent',
|
|
'textEditorTabMovesFocus',
|
|
'timelineCaptureFilmStrip',
|
|
'timelineCaptureLayersAndPictures',
|
|
'timelineCaptureMemory',
|
|
'timelineCaptureNetwork',
|
|
'timeline-details',
|
|
'timelineEnableJSSampling',
|
|
'timelineOverviewMode',
|
|
'timelinePanelDetailsSplitViewState',
|
|
'timelinePanelRecorsSplitViewState',
|
|
'timelinePanelTimelineStackSplitViewState',
|
|
'timelinePerspective',
|
|
'timeline-split',
|
|
'timelineTreeGroupBy',
|
|
'timeline-view',
|
|
'timelineViewMode',
|
|
'uiTheme',
|
|
'watchExpressions',
|
|
'WebInspector.Drawer.lastSelectedView',
|
|
'WebInspector.Drawer.showOnLoad',
|
|
'workspaceExcludedFolders',
|
|
'workspaceFolderExcludePattern',
|
|
'workspaceInfobarDisabled',
|
|
'workspaceMappingInfobarDisabled',
|
|
'xhrBreakpoints'
|
|
];
|
|
|
|
/**
|
|
* @this {!{_storage: Object, _name: string}}
|
|
*/
|
|
function settingRemove() {
|
|
this._storage[this._name] = undefined;
|
|
}
|
|
|
|
/**
|
|
* @param {!Object} object
|
|
* @param {function(!Array<!{name: string}>)} observer
|
|
*/
|
|
function objectObserve(object, observer) {
|
|
if (window['WebInspector']) {
|
|
const settingPrototype = /** @type {!Object} */ (window['WebInspector']['Setting']['prototype']);
|
|
if (typeof settingPrototype['remove'] === 'function')
|
|
settingPrototype['remove'] = settingRemove;
|
|
}
|
|
/** @type {!Set<string>} */
|
|
const changedProperties = new Set();
|
|
let scheduled = false;
|
|
|
|
function scheduleObserver() {
|
|
if (scheduled)
|
|
return;
|
|
scheduled = true;
|
|
setImmediate(callObserver);
|
|
}
|
|
|
|
function callObserver() {
|
|
scheduled = false;
|
|
const changes = /** @type {!Array<!{name: string}>} */ ([]);
|
|
changedProperties.forEach(function(name) {
|
|
changes.push({name: name});
|
|
});
|
|
changedProperties.clear();
|
|
observer.call(null, changes);
|
|
}
|
|
|
|
/** @type {!Map<string, *>} */
|
|
const storage = new Map();
|
|
|
|
/**
|
|
* @param {string} property
|
|
*/
|
|
function defineProperty(property) {
|
|
if (property in object) {
|
|
storage.set(property, object[property]);
|
|
delete object[property];
|
|
}
|
|
|
|
Object.defineProperty(object, property, {
|
|
/**
|
|
* @return {*}
|
|
*/
|
|
get: function() {
|
|
return storage.get(property);
|
|
},
|
|
|
|
/**
|
|
* @param {*} value
|
|
*/
|
|
set: function(value) {
|
|
storage.set(property, value);
|
|
changedProperties.add(property);
|
|
scheduleObserver();
|
|
}
|
|
});
|
|
}
|
|
|
|
for (let i = 0; i < properties.length; ++i)
|
|
defineProperty(properties[i]);
|
|
}
|
|
|
|
window.Object.observe = objectObserve;
|
|
}
|
|
|
|
/** @type {!Map<number, string>} */
|
|
const staticKeyIdentifiers = new Map([
|
|
[0x12, 'Alt'],
|
|
[0x11, 'Control'],
|
|
[0x10, 'Shift'],
|
|
[0x14, 'CapsLock'],
|
|
[0x5b, 'Win'],
|
|
[0x5c, 'Win'],
|
|
[0x0c, 'Clear'],
|
|
[0x28, 'Down'],
|
|
[0x23, 'End'],
|
|
[0x0a, 'Enter'],
|
|
[0x0d, 'Enter'],
|
|
[0x2b, 'Execute'],
|
|
[0x70, 'F1'],
|
|
[0x71, 'F2'],
|
|
[0x72, 'F3'],
|
|
[0x73, 'F4'],
|
|
[0x74, 'F5'],
|
|
[0x75, 'F6'],
|
|
[0x76, 'F7'],
|
|
[0x77, 'F8'],
|
|
[0x78, 'F9'],
|
|
[0x79, 'F10'],
|
|
[0x7a, 'F11'],
|
|
[0x7b, 'F12'],
|
|
[0x7c, 'F13'],
|
|
[0x7d, 'F14'],
|
|
[0x7e, 'F15'],
|
|
[0x7f, 'F16'],
|
|
[0x80, 'F17'],
|
|
[0x81, 'F18'],
|
|
[0x82, 'F19'],
|
|
[0x83, 'F20'],
|
|
[0x84, 'F21'],
|
|
[0x85, 'F22'],
|
|
[0x86, 'F23'],
|
|
[0x87, 'F24'],
|
|
[0x2f, 'Help'],
|
|
[0x24, 'Home'],
|
|
[0x2d, 'Insert'],
|
|
[0x25, 'Left'],
|
|
[0x22, 'PageDown'],
|
|
[0x21, 'PageUp'],
|
|
[0x13, 'Pause'],
|
|
[0x2c, 'PrintScreen'],
|
|
[0x27, 'Right'],
|
|
[0x91, 'Scroll'],
|
|
[0x29, 'Select'],
|
|
[0x26, 'Up'],
|
|
[0x2e, 'U+007F'], // Standard says that DEL becomes U+007F.
|
|
[0xb0, 'MediaNextTrack'],
|
|
[0xb1, 'MediaPreviousTrack'],
|
|
[0xb2, 'MediaStop'],
|
|
[0xb3, 'MediaPlayPause'],
|
|
[0xad, 'VolumeMute'],
|
|
[0xae, 'VolumeDown'],
|
|
[0xaf, 'VolumeUp'],
|
|
]);
|
|
|
|
/**
|
|
* @param {number} keyCode
|
|
* @return {string}
|
|
*/
|
|
function keyCodeToKeyIdentifier(keyCode) {
|
|
let result = staticKeyIdentifiers.get(keyCode);
|
|
if (result !== undefined)
|
|
return result;
|
|
result = 'U+';
|
|
const hexString = keyCode.toString(16).toUpperCase();
|
|
for (let i = hexString.length; i < 4; ++i)
|
|
result += '0';
|
|
result += hexString;
|
|
return result;
|
|
}
|
|
|
|
function installBackwardsCompatibility() {
|
|
const majorVersion = getRemoteMajorVersion();
|
|
if (!majorVersion)
|
|
return;
|
|
|
|
/** @type {!Array<string>} */
|
|
const styleRules = [];
|
|
// Shadow DOM V0 polyfill
|
|
if (majorVersion <= 73 && !Element.prototype.createShadowRoot) {
|
|
Element.prototype.createShadowRoot = function() {
|
|
try {
|
|
return this.attachShadow({mode: 'open'});
|
|
} catch (e) {
|
|
// some elements we use to add shadow roots can no
|
|
// longer have shadow roots.
|
|
const fakeShadowHost = document.createElement('span');
|
|
this.appendChild(fakeShadowHost);
|
|
fakeShadowHost.className = 'fake-shadow-host';
|
|
return fakeShadowHost.createShadowRoot();
|
|
}
|
|
};
|
|
|
|
const origAdd = DOMTokenList.prototype.add;
|
|
DOMTokenList.prototype.add = function(...tokens) {
|
|
if (tokens[0].startsWith('insertion-point') || tokens[0].startsWith('tabbed-pane-header'))
|
|
this._myElement.slot = '.' + tokens[0];
|
|
return origAdd.apply(this, tokens);
|
|
};
|
|
|
|
const origCreateElement = Document.prototype.createElement;
|
|
Document.prototype.createElement = function(tagName, ...rest) {
|
|
if (tagName === 'content')
|
|
tagName = 'slot';
|
|
const element = origCreateElement.call(this, tagName, ...rest);
|
|
element.classList._myElement = element;
|
|
return element;
|
|
};
|
|
|
|
Object.defineProperty(HTMLSlotElement.prototype, 'select', {
|
|
async set(selector) {
|
|
this.name = selector;
|
|
}
|
|
});
|
|
|
|
// Document.prototype.createElementWithClass is a DevTools method, so we
|
|
// need to wait for DOMContentLoaded in order to override it.
|
|
if (window.document.head &&
|
|
(window.document.readyState === 'complete' || window.document.readyState === 'interactive'))
|
|
overrideCreateElementWithClass();
|
|
else
|
|
window.addEventListener('DOMContentLoaded', overrideCreateElementWithClass);
|
|
|
|
function overrideCreateElementWithClass() {
|
|
window.removeEventListener('DOMContentLoaded', overrideCreateElementWithClass);
|
|
|
|
const origCreateElementWithClass = Document.prototype.createElementWithClass;
|
|
Document.prototype.createElementWithClass = function(tagName, className, ...rest) {
|
|
if (tagName !== 'button' || (className !== 'soft-dropdown' && className !== 'dropdown-button'))
|
|
return origCreateElementWithClass.call(this, tagName, className, ...rest);
|
|
const element = origCreateElementWithClass.call(this, 'div', className, ...rest);
|
|
element.tabIndex = 0;
|
|
element.role = 'button';
|
|
return element;
|
|
};
|
|
}
|
|
}
|
|
|
|
// Custom Elements V0 polyfill
|
|
if (majorVersion <= 73 && !Document.prototype.registerElement) {
|
|
const fakeRegistry = new Map();
|
|
Document.prototype.registerElement = function(typeExtension, options) {
|
|
const {prototype, extends: localName} = options;
|
|
const document = this;
|
|
const callback = function() {
|
|
const element = document.createElement(localName || typeExtension);
|
|
const skip = new Set(['constructor', '__proto__']);
|
|
for (const key of Object.keys(Object.getOwnPropertyDescriptors(prototype.__proto__ || {}))) {
|
|
if (skip.has(key))
|
|
continue;
|
|
element[key] = prototype[key];
|
|
}
|
|
element.setAttribute('is', typeExtension);
|
|
if (element['createdCallback'])
|
|
element['createdCallback']();
|
|
return element;
|
|
};
|
|
fakeRegistry.set(typeExtension, callback);
|
|
return callback;
|
|
};
|
|
|
|
const origCreateElement = Document.prototype.createElement;
|
|
Document.prototype.createElement = function(tagName, fakeCustomElementType) {
|
|
const fakeConstructor = fakeRegistry.get(fakeCustomElementType);
|
|
if (fakeConstructor)
|
|
return fakeConstructor();
|
|
return origCreateElement.call(this, tagName, fakeCustomElementType);
|
|
};
|
|
|
|
// DevTools front-ends mistakenly assume that
|
|
// classList.toggle('a', undefined) works as
|
|
// classList.toggle('a', false) rather than as
|
|
// classList.toggle('a');
|
|
const originalDOMTokenListToggle = DOMTokenList.prototype.toggle;
|
|
DOMTokenList.prototype.toggle = function(token, force) {
|
|
if (arguments.length === 1)
|
|
force = !this.contains(token);
|
|
return originalDOMTokenListToggle.call(this, token, !!force);
|
|
};
|
|
}
|
|
|
|
if (majorVersion <= 66) {
|
|
/** @type {(!function(number, number):Element|undefined)} */
|
|
ShadowRoot.prototype.__originalShadowRootElementFromPoint;
|
|
|
|
if (!ShadowRoot.prototype.__originalShadowRootElementFromPoint) {
|
|
ShadowRoot.prototype.__originalShadowRootElementFromPoint = ShadowRoot.prototype.elementFromPoint;
|
|
/**
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @return {Element}
|
|
*/
|
|
ShadowRoot.prototype.elementFromPoint = function(x, y) {
|
|
const originalResult = ShadowRoot.prototype.__originalShadowRootElementFromPoint.apply(this, arguments);
|
|
if (this.host && originalResult === this.host)
|
|
return null;
|
|
return originalResult;
|
|
};
|
|
}
|
|
}
|
|
|
|
if (majorVersion <= 53) {
|
|
Object.defineProperty(window.KeyboardEvent.prototype, 'keyIdentifier', {
|
|
/**
|
|
* @return {string}
|
|
* @this {KeyboardEvent}
|
|
*/
|
|
get: function() {
|
|
return keyCodeToKeyIdentifier(this.keyCode);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (majorVersion <= 50)
|
|
installObjectObserve();
|
|
|
|
if (majorVersion <= 45) {
|
|
/**
|
|
* @param {string} property
|
|
* @return {!CSSValue|null}
|
|
* @this {CSSStyleDeclaration}
|
|
*/
|
|
function getValue(property) {
|
|
// Note that |property| comes from another context, so we can't use === here.
|
|
// eslint-disable-next-line eqeqeq
|
|
if (property == 'padding-left') {
|
|
return /** @type {!CSSValue} */ ({
|
|
/**
|
|
* @return {number}
|
|
* @this {!{__paddingLeft: number}}
|
|
*/
|
|
getFloatValue: function() {
|
|
return this.__paddingLeft;
|
|
},
|
|
__paddingLeft: parseFloat(this.paddingLeft)
|
|
});
|
|
}
|
|
throw new Error('getPropertyCSSValue is undefined');
|
|
}
|
|
|
|
window.CSSStyleDeclaration.prototype.getPropertyCSSValue = getValue;
|
|
|
|
function CSSPrimitiveValue() {
|
|
}
|
|
CSSPrimitiveValue.CSS_PX = 5;
|
|
window.CSSPrimitiveValue = CSSPrimitiveValue;
|
|
}
|
|
|
|
if (majorVersion <= 45)
|
|
styleRules.push('* { min-width: 0; min-height: 0; }');
|
|
|
|
if (majorVersion <= 51) {
|
|
// Support for quirky border-image behavior (<M51), see:
|
|
// https://bugs.chromium.org/p/chromium/issues/detail?id=559258
|
|
styleRules.push('.cm-breakpoint .CodeMirror-linenumber { border-style: solid !important; }');
|
|
styleRules.push(
|
|
'.cm-breakpoint.cm-breakpoint-conditional .CodeMirror-linenumber { border-style: solid !important; }');
|
|
}
|
|
if (majorVersion <= 71) {
|
|
styleRules.push(
|
|
'.coverage-toolbar-container, .animation-timeline-toolbar-container, .computed-properties { flex-basis: auto; }');
|
|
}
|
|
|
|
if (majorVersion <= 50)
|
|
Event.prototype.deepPath = undefined;
|
|
|
|
if (majorVersion <= 54) {
|
|
window.FileError = /** @type {!function (new: FileError) : ?} */ ({
|
|
NOT_FOUND_ERR: DOMException.NOT_FOUND_ERR,
|
|
ABORT_ERR: DOMException.ABORT_ERR,
|
|
INVALID_MODIFICATION_ERR: DOMException.INVALID_MODIFICATION_ERR,
|
|
NOT_READABLE_ERR: 0 // No matching DOMException, so code will be 0.
|
|
});
|
|
}
|
|
|
|
installExtraStyleRules(styleRules);
|
|
}
|
|
|
|
/**
|
|
* @return {?number}
|
|
*/
|
|
function getRemoteMajorVersion() {
|
|
try {
|
|
const remoteVersion = new URLSearchParams(window.location.search).get('remoteVersion');
|
|
if (!remoteVersion)
|
|
return null;
|
|
const majorVersion = parseInt(remoteVersion.split('.')[0], 10);
|
|
return majorVersion;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {!Array<string>} styleRules
|
|
*/
|
|
function installExtraStyleRules(styleRules) {
|
|
if (!styleRules.length)
|
|
return;
|
|
const styleText = styleRules.join('\n');
|
|
document.head.appendChild(createStyleElement(styleText));
|
|
|
|
const origCreateShadowRoot = HTMLElement.prototype.createShadowRoot;
|
|
HTMLElement.prototype.createShadowRoot = function(...args) {
|
|
const shadowRoot = origCreateShadowRoot.call(this, ...args);
|
|
shadowRoot.appendChild(createStyleElement(styleText));
|
|
return shadowRoot;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {string} styleText
|
|
* @return {!Element}
|
|
*/
|
|
function createStyleElement(styleText) {
|
|
const style = document.createElement('style');
|
|
style.type = 'text/css';
|
|
style.textContent = styleText;
|
|
return style;
|
|
}
|
|
|
|
installBackwardsCompatibility();
|
|
|
|
})(window);
|