// Copyright 2021 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. /* * Copyright (C) 2008 Apple Inc. All Rights Reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ import * as Platform from '../../core/platform/platform.js'; import * as Protocol from '../../generated/protocol.js'; import * as TextUtils from '../../models/text_utils/text_utils.js'; import * as Common from '../common/common.js'; import * as i18n from '../i18n/i18n.js'; import { COND_BREAKPOINT_SOURCE_URL, type DebuggerModel, Events, Location, LOGPOINT_SOURCE_URL, } from './DebuggerModel.js'; import type {FrameAssociated} from './FrameAssociated.js'; import type {PageResourceLoadInitiator} from './PageResourceLoader.js'; import {ResourceTreeModel} from './ResourceTreeModel.js'; import type {ExecutionContext} from './RuntimeModel.js'; import type {DebugId, SourceMap} from './SourceMap.js'; import type {Target} from './Target.js'; const UIStrings = { /** * @description Error message for when a script can't be loaded which had been previously */ scriptRemovedOrDeleted: 'Script removed or deleted.', /** * @description Error message when failing to load a script source text */ unableToFetchScriptSource: 'Unable to fetch script source.', } as const; const str_ = i18n.i18n.registerUIStrings('core/sdk/Script.ts', UIStrings); const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_); let scriptCacheInstance: { cache: Map>>, registry: FinalizationRegistry, }|null = null; export class Script implements TextUtils.ContentProvider.ContentProvider, FrameAssociated { debuggerModel: DebuggerModel; scriptId: Protocol.Runtime.ScriptId; /** * The URL of the script. When `hasSourceURL` is true, this value comes from a `//# sourceURL=` directive. Otherwise, * it's the original `src` URL from which the script was loaded. */ sourceURL: Platform.DevToolsPath.UrlString; lineOffset: number; columnOffset: number; endLine: number; endColumn: number; executionContextId: number; hash: string; readonly #isContentScript: boolean; readonly #isLiveEdit: boolean; sourceMapURL?: string; debugSymbols: Protocol.Debugger.DebugSymbols|null; hasSourceURL: boolean; contentLength: number; originStackTrace: Protocol.Runtime.StackTrace|null; readonly #codeOffset: number|null; readonly #language: string|null; #contentPromise: Promise|null; readonly #embedderName: Platform.DevToolsPath.UrlString|null; readonly isModule: boolean|null; readonly buildId: string|null; constructor( debuggerModel: DebuggerModel, scriptId: Protocol.Runtime.ScriptId, sourceURL: Platform.DevToolsPath.UrlString, startLine: number, startColumn: number, endLine: number, endColumn: number, executionContextId: number, hash: string, isContentScript: boolean, isLiveEdit: boolean, sourceMapURL: string|undefined, hasSourceURL: boolean, length: number, isModule: boolean|null, originStackTrace: Protocol.Runtime.StackTrace|null, codeOffset: number|null, scriptLanguage: string|null, debugSymbols: Protocol.Debugger.DebugSymbols|null, embedderName: Platform.DevToolsPath.UrlString|null, buildId: string|null) { this.debuggerModel = debuggerModel; this.scriptId = scriptId; this.sourceURL = sourceURL; this.lineOffset = startLine; this.columnOffset = startColumn; this.endLine = endLine; this.endColumn = endColumn; this.isModule = isModule; this.buildId = buildId; this.executionContextId = executionContextId; this.hash = hash; this.#isContentScript = isContentScript; this.#isLiveEdit = isLiveEdit; this.sourceMapURL = sourceMapURL; this.debugSymbols = debugSymbols; this.hasSourceURL = hasSourceURL; this.contentLength = length; this.originStackTrace = originStackTrace; this.#codeOffset = codeOffset; this.#language = scriptLanguage; this.#contentPromise = null; this.#embedderName = embedderName; } embedderName(): Platform.DevToolsPath.UrlString|null { return this.#embedderName; } target(): Target { return this.debuggerModel.target(); } private static trimSourceURLComment(source: string): string { let sourceURLIndex = source.lastIndexOf('//# sourceURL='); if (sourceURLIndex === -1) { sourceURLIndex = source.lastIndexOf('//@ sourceURL='); if (sourceURLIndex === -1) { return source; } } const sourceURLLineIndex = source.lastIndexOf('\n', sourceURLIndex); if (sourceURLLineIndex === -1) { return source; } const sourceURLLine = source.substr(sourceURLLineIndex + 1); if (!sourceURLLine.match(sourceURLRegex)) { return source; } return source.substr(0, sourceURLLineIndex); } isContentScript(): boolean { return this.#isContentScript; } codeOffset(): number|null { return this.#codeOffset; } isJavaScript(): boolean { return this.#language === Protocol.Debugger.ScriptLanguage.JavaScript; } isWasm(): boolean { return this.#language === Protocol.Debugger.ScriptLanguage.WebAssembly; } scriptLanguage(): string|null { return this.#language; } executionContext(): ExecutionContext|null { return this.debuggerModel.runtimeModel().executionContext(this.executionContextId); } isLiveEdit(): boolean { return this.#isLiveEdit; } contentURL(): Platform.DevToolsPath.UrlString { return this.sourceURL; } contentType(): Common.ResourceType.ResourceType { return Common.ResourceType.resourceTypes.Script; } private async loadTextContent(): Promise { const result = await this.debuggerModel.target().debuggerAgent().invoke_getScriptSource({scriptId: this.scriptId}); if (result.getError()) { throw new Error(result.getError()); } const {scriptSource, bytecode} = result; if (bytecode) { return new TextUtils.ContentData.ContentData(bytecode, /* isBase64 */ true, 'application/wasm'); } let content: string = scriptSource || ''; if (this.hasSourceURL && Common.ParsedURL.schemeIs(this.sourceURL, 'snippet:')) { // TODO(crbug.com/1330846): Find a better way to establish the snippet automapping binding then adding // a sourceURL comment before evaluation and removing it here. content = Script.trimSourceURLComment(content); } return new TextUtils.ContentData.ContentData(content, /* isBase64 */ false, 'text/javascript'); } private async loadWasmContent(): Promise { if (!this.isWasm()) { throw new Error('Not a wasm script'); } const result = await this.debuggerModel.target().debuggerAgent().invoke_disassembleWasmModule({scriptId: this.scriptId}); if (result.getError()) { // Fall through to text content loading if v8-based disassembly fails. This is to ensure backwards compatibility with // older v8 versions. const contentData = await this.loadTextContent(); return await disassembleWasm(contentData.base64); } const {streamId, functionBodyOffsets, chunk: {lines, bytecodeOffsets}} = result; const lineChunks = []; const bytecodeOffsetChunks = []; let totalLength = lines.reduce((sum, line) => sum + line.length + 1, 0); const truncationMessage = ''; // This is a magic number used in code mirror which, when exceeded, sends it into an infinite loop. const cmSizeLimit = 1000000000 - truncationMessage.length; if (streamId) { while (true) { const result = await this.debuggerModel.target().debuggerAgent().invoke_nextWasmDisassemblyChunk({streamId}); if (result.getError()) { throw new Error(result.getError()); } const {chunk: {lines: linesChunk, bytecodeOffsets: bytecodeOffsetsChunk}} = result; totalLength += linesChunk.reduce((sum, line) => sum + line.length + 1, 0); if (linesChunk.length === 0) { break; } if (totalLength >= cmSizeLimit) { lineChunks.push([truncationMessage]); bytecodeOffsetChunks.push([0]); break; } lineChunks.push(linesChunk); bytecodeOffsetChunks.push(bytecodeOffsetsChunk); } } const functionBodyRanges: Array<{start: number, end: number}> = []; // functionBodyOffsets contains a sequence of pairs of start and end offsets for (let i = 0; i < functionBodyOffsets.length; i += 2) { functionBodyRanges.push({start: functionBodyOffsets[i], end: functionBodyOffsets[i + 1]}); } return new TextUtils.WasmDisassembly.WasmDisassembly( lines.concat(...lineChunks), bytecodeOffsets.concat(...bytecodeOffsetChunks), functionBodyRanges); } requestContentData(): Promise { if (!this.#contentPromise) { const fileSizeToCache = 65535; // We won't bother cacheing files under 64K if (this.hash && !this.#isLiveEdit && this.contentLength > fileSizeToCache) { // For large files that aren't live edits and have a hash, we keep a content-addressed cache // so we don't need to load multiple copies or disassemble wasm modules multiple times. if (!scriptCacheInstance) { // Initialize script cache singleton. Add a finalizer for removing keys from the map. scriptCacheInstance = { cache: new Map(), registry: new FinalizationRegistry(hashCode => scriptCacheInstance?.cache.delete(hashCode)), }; } // This key should be sufficient to identify scripts that are known to have the same content. const fullHash = [ this.#language, this.contentLength, this.lineOffset, this.columnOffset, this.endLine, this.endColumn, this.#codeOffset, this.hash, ].join(':'); const cachedContentPromise = scriptCacheInstance.cache.get(fullHash)?.deref(); if (cachedContentPromise) { this.#contentPromise = cachedContentPromise; } else { this.#contentPromise = this.#requestContent(); scriptCacheInstance.cache.set(fullHash, new WeakRef(this.#contentPromise)); scriptCacheInstance.registry.register(this.#contentPromise, fullHash); } } else { this.#contentPromise = this.#requestContent(); } } return this.#contentPromise; } async #requestContent(): Promise { if (!this.scriptId) { return {error: i18nString(UIStrings.scriptRemovedOrDeleted)}; } try { return this.isWasm() ? await this.loadWasmContent() : await this.loadTextContent(); } catch { // TODO(bmeurer): Propagate errors as exceptions / rejections. return {error: i18nString(UIStrings.unableToFetchScriptSource)}; } } async getWasmBytecode(): Promise { const base64 = await this.debuggerModel.target().debuggerAgent().invoke_getWasmBytecode({scriptId: this.scriptId}); const response = await fetch(`data:application/wasm;base64,${base64.bytecode}`); return await response.arrayBuffer(); } originalContentProvider(): TextUtils.ContentProvider.ContentProvider { return new TextUtils.StaticContentProvider.StaticContentProvider( this.contentURL(), this.contentType(), () => this.requestContentData()); } async searchInContent(query: string, caseSensitive: boolean, isRegex: boolean): Promise { if (!this.scriptId) { return []; } const matches = await this.debuggerModel.target().debuggerAgent().invoke_searchInContent( {scriptId: this.scriptId, query, caseSensitive, isRegex}); return TextUtils.TextUtils.performSearchInSearchMatches(matches.result || [], query, caseSensitive, isRegex); } private appendSourceURLCommentIfNeeded(source: string): string { if (!this.hasSourceURL) { return source; } return source + '\n //# sourceURL=' + this.sourceURL; } async editSource(newSource: string): Promise<{ changed: boolean, status: Protocol.Debugger.SetScriptSourceResponseStatus, exceptionDetails?: Protocol.Runtime.ExceptionDetails, }> { newSource = Script.trimSourceURLComment(newSource); // We append correct #sourceURL to script for consistency only. It's not actually needed for things to work correctly. newSource = this.appendSourceURLCommentIfNeeded(newSource); const oldSource = TextUtils.ContentData.ContentData.textOr(await this.requestContentData(), null); if (oldSource === newSource) { return {changed: false, status: Protocol.Debugger.SetScriptSourceResponseStatus.Ok}; } const response = await this.debuggerModel.target().debuggerAgent().invoke_setScriptSource( {scriptId: this.scriptId, scriptSource: newSource, allowTopFrameEditing: true}); if (response.getError()) { // Something went seriously wrong, like the V8 inspector no longer knowing about this script without // shutting down the Debugger agent etc. throw new Error(`Script#editSource failed for script with id ${this.scriptId}: ${response.getError()}`); } if (!response.getError() && response.status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) { this.#contentPromise = Promise.resolve(new TextUtils.ContentData.ContentData(newSource, /* isBase64 */ false, 'text/javascript')); } this.debuggerModel.dispatchEventToListeners(Events.ScriptSourceWasEdited, {script: this, status: response.status}); return {changed: true, status: response.status, exceptionDetails: response.exceptionDetails}; } rawLocation(lineNumber: number, columnNumber: number): Location|null { if (this.containsLocation(lineNumber, columnNumber)) { return new Location(this.debuggerModel, this.scriptId, lineNumber, columnNumber); } return null; } isInlineScript(): boolean { const startsAtZero = !this.lineOffset && !this.columnOffset; return !this.isWasm() && Boolean(this.sourceURL) && !startsAtZero; } isAnonymousScript(): boolean { return !this.sourceURL; } async setBlackboxedRanges(positions: Protocol.Debugger.ScriptPosition[]): Promise { const response = await this.debuggerModel.target().debuggerAgent().invoke_setBlackboxedRanges( {scriptId: this.scriptId, positions}); return !response.getError(); } containsLocation(lineNumber: number, columnNumber: number): boolean { const afterStart = (lineNumber === this.lineOffset && columnNumber >= this.columnOffset) || lineNumber > this.lineOffset; const beforeEnd = lineNumber < this.endLine || (lineNumber === this.endLine && columnNumber <= this.endColumn); return afterStart && beforeEnd; } get frameId(): Protocol.Page.FrameId { // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration // @ts-expect-error if (typeof this[frameIdSymbol] !== 'string') { // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration // @ts-expect-error this[frameIdSymbol] = frameIdForScript(this); } // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration // @ts-expect-error return this[frameIdSymbol]; } /** * @returns true, iff this script originates from a breakpoint/logpoint condition */ get isBreakpointCondition(): boolean { return [COND_BREAKPOINT_SOURCE_URL, LOGPOINT_SOURCE_URL].includes(this.sourceURL); } /** * @returns the currently attached source map for this Script or `undefined` if there is none or it * hasn't loaded yet. */ sourceMap(): SourceMap|undefined { return this.debuggerModel.sourceMapManager().sourceMapForClient(this); } createPageResourceLoadInitiator(): PageResourceLoadInitiator { return {target: this.target(), frameId: this.frameId, initiatorUrl: this.embedderName()}; } debugId(): DebugId|null { return this.buildId as (DebugId | null); } /** * Translates the `rawLocation` from line and column number in terms of what V8 understands * to a script relative location. Specifically this means that for inline `