| TestPage.registerInitializer(() => { |
| function log(object, indent) { |
| for (let key of Object.keys(object)) { |
| let value = object[key]; |
| if (typeof value === "string") |
| value = sanitizeURL(value); |
| InspectorTest.log(indent + key + ": " + JSON.stringify(value)); |
| } |
| } |
| |
| function logRecording(recording) { |
| InspectorTest.log("initialState:"); |
| |
| InspectorTest.log(" attributes:"); |
| log(recording.initialState.attributes, " "); |
| |
| InspectorTest.log(" parameters:"); |
| log(recording.initialState.parameters, " "); |
| |
| InspectorTest.log(" content: " + JSON.stringify(recording.initialState.content)); |
| |
| InspectorTest.log("frames:"); |
| for (let i = 0; i < recording.frames.length; ++i) { |
| let frame = recording.frames[i]; |
| |
| let frameText = ` ${i}:`; |
| if (!isNaN(frame.duration)) |
| frameText += " (duration)"; |
| if (frame.incomplete) |
| frameText += " (incomplete)"; |
| InspectorTest.log(frameText); |
| |
| for (let j = 0; j < frame.actions.length; ++j) { |
| let action = frame.actions[j]; |
| let actionText = ` ${j}: ${action.name}`; |
| |
| let parameters = action.parameters.map((parameter) => { |
| if (typeof parameter === "object" && !Array.isArray(parameter)) |
| return String(parameter); |
| return JSON.stringify(parameter); |
| }); |
| if (action.isFunction) |
| actionText += "(" + parameters.join(", ") + ")"; |
| else if (!action.isGetter) |
| actionText += " = " + parameters[0]; |
| |
| InspectorTest.log(actionText); |
| |
| if (action.swizzleTypes.length) { |
| let swizzleNames = action.swizzleTypes.map((item, i) => { |
| let swizzleText = WI.Recording.displayNameForSwizzleType(item); |
| if (action.parameters[i] != action._payloadParameters[i] && Number.isInteger(action._payloadParameters[i])) |
| swizzleText += " (" + action._payloadParameters[i] + ")"; |
| return swizzleText; |
| }); |
| InspectorTest.log(" swizzleTypes: [" + swizzleNames.join(", ") + "]"); |
| } |
| |
| if (action.trace.length) { |
| InspectorTest.log(" trace:"); |
| |
| for (let k = 0; k < action.trace.length; ++k) { |
| let callFrame = action.trace[k]; |
| let traceText = ` ${k}: `; |
| traceText += callFrame.functionName || "(anonymous function)"; |
| |
| if (callFrame.nativeCode) |
| traceText += " - [native code]"; |
| else if (callFrame.programCode) |
| traceText += " - [program code]"; |
| else if (callFrame.sourceCodeLocation) { |
| let location = callFrame.sourceCodeLocation; |
| traceText += " - " + sanitizeURL(location.sourceCode.url) + `:${location.lineNumber}:${location.columnNumber}`; |
| } |
| |
| traceText += " (" + action._payloadTrace[k] + ")"; |
| InspectorTest.log(traceText); |
| } |
| } |
| |
| if (action.snapshot) |
| InspectorTest.log(" snapshot: " + JSON.stringify(action.snapshot) + " (" + action._payloadSnapshot + ")"); |
| } |
| } |
| |
| InspectorTest.log("data:"); |
| log(recording.data, " "); |
| } |
| |
| window.getCanvas = function(type) { |
| let canvases = WI.canvasManager.canvases.filter((canvas) => canvas.contextType === type); |
| InspectorTest.assert(canvases.length === 1, `There should only be one canvas with type "${type}".`); |
| if (canvases.length !== 1) |
| return null; |
| return canvases[0]; |
| }; |
| |
| window.startRecording = function(type, resolve, reject, {singleFrame, memoryLimit} = {}) { |
| let canvas = getCanvas(type); |
| if (!canvas) { |
| reject(`Missing canvas with type "${type}".`); |
| return; |
| } |
| |
| let bufferUsed = 0; |
| let frameCount = 0; |
| function handleRecordingProgress(event) { |
| InspectorTest.assert(event.data.frameCount > frameCount, "Additional frames were captured for this progress event."); |
| frameCount = event.data.frameCount; |
| |
| InspectorTest.assert(event.data.bufferUsed > bufferUsed, "Total memory usage increases with each progress event."); |
| bufferUsed = event.data.bufferUsed; |
| } |
| WI.canvasManager.addEventListener(WI.CanvasManager.Event.RecordingProgress, handleRecordingProgress); |
| |
| WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingStopped).then((event) => { |
| WI.canvasManager.removeEventListener(WI.CanvasManager.Event.RecordingProgress, handleRecordingProgress); |
| |
| InspectorTest.evaluateInPage(`cancelActions()`); |
| |
| let recording = event.data.recording; |
| InspectorTest.assert(recording.source === canvas, "Recording should be of the given canvas."); |
| InspectorTest.assert(recording.source.contextType === type, `Recording should be of a canvas with type "${type}".`); |
| InspectorTest.assert(recording.source.recordingCollection.items.has(recording), "Recording should be in the canvas' list of recordings."); |
| InspectorTest.assert(recording.frames.length === frameCount, `Recording should have ${frameCount} frames.`) |
| |
| return recording.actions.then(() => { |
| logRecording(recording, type); |
| }); |
| }).then(resolve, reject); |
| |
| CanvasAgent.startRecording(canvas.identifier, singleFrame, memoryLimit, (error) => { |
| if (error) { |
| reject(error); |
| return; |
| } |
| |
| InspectorTest.evaluateInPage(`performActions()`); |
| }); |
| |
| return canvas; |
| }; |
| |
| window.consoleRecord = function(resolve, reject) { |
| WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingStopped).then((event) => { |
| let recording = event.data.recording; |
| InspectorTest.expectEqual(recording.displayName, "TEST", "The recording should have the name \"TEST\"."); |
| InspectorTest.expectEqual(recording.frames.length, 1, "The recording should have one frame."); |
| InspectorTest.expectEqual(recording.frames[0].actions.length, 1, "The first frame should have one action."); |
| }).then(resolve, reject); |
| |
| InspectorTest.evaluateInPage(`performConsoleActions()`); |
| }; |
| }); |