JSGlobalObjectConsoleClient.cpp

@@void JSGlobalObjectConsoleClient::warnUnimplemented(const String& method)

    m_consoleAgent->addMessageToConsole(std::make_unique<ConsoleMessage>(MessageSource::ConsoleAPI, MessageType::Log, MessageLevel::Warning, message));

}

void JSGlobalObjectConsoleClient::record(ExecState*, Ref<ScriptArguments>&&) { }

void JSGlobalObjectConsoleClient::recordEnd(ExecState*, Ref<ScriptArguments>&&) { }

174177} // namespace Inspector

Source/JavaScriptCore/inspector/JSGlobalObjectConsoleClient.h

@@protected:

    void time(JSC::ExecState*, const String& title) override;

    void timeEnd(JSC::ExecState*, const String& title) override;

    void timeStamp(JSC::ExecState*, Ref<ScriptArguments>&&) override;

56 void record(JSC::ExecState*, Ref<ScriptArguments>&&) override;

57 void recordEnd(JSC::ExecState*, Ref<ScriptArguments>&&) override;

private:

    void warnUnimplemented(const String& method);

Source/JavaScriptCore/inspector/protocol/Canvas.json

                { "name": "contextAttributes", "$ref": "ContextAttributes", "optional": true, "description": "Context attributes for WebGL rendering contexts." },

                { "name": "memoryCost", "type": "number", "optional": true, "description": "Memory usage of the canvas." }

            ]

        },

        {

            "id": "InitialState",

            "type": "object",

            "description": "Information about the initial state of the recorded canvas.",

            "properties": [

                { "name": "attributes", "type": "object", "optional": true, "description": "Key-value map for each attribute." },

                { "name": "functions", "type": "object", "optional": true, "description": "Key-value map for each state that is only accessible via a function call. Values must be arrays." },

                { "name": "content", "type": "string", "optional": true, "description": "Current content at the start of the recording." }

            ]

        },

        {

            "id": "RecordingAction",

            "type": "object",

            "description": "Information about an action made to the recorded canvas.",

            "properties": [

                { "name": "name", "type": "string", "description": "Name of the function/attribute that was called/changed." },

                { "name": "parameters", "type": "array", "items": { "type": "any" }, "optional": true, "description": "Array of parameter values." }

            ]

        }

    ],

    "commands": [

            "returns": [

                { "name": "object", "$ref": "Runtime.RemoteObject", "description": "JavaScript object wrapper for given canvas context." }

            ]

        },

        {

            "name": "toggleRecording",

            "description": "Sets whether the next draw frame should be recorded for the given canvas.",

            "parameters": [

                { "name": "canvasId", "$ref": "CanvasId", "description": "Canvas identifier." },

                { "name": "flag", "type": "boolean", "description": "Flag of whether to request a recording or cancel an existing request." }

            ]

        }

    ],

    "events": [

                { "name": "canvasId", "$ref": "CanvasId", "description": "Identifier of canvas who's memory cost changed." },

                { "name": "memoryCost", "type": "number", "description": "New memory cost value for the canvas." }

            ]

        },

        {

            "name": "recordingFinished",

            "parameters": [

                { "name": "canvasId", "$ref": "CanvasId", "description": "Identifier of canvas who's memory cost changed." },

                { "name": "initialState", "$ref": "InitialState", "description": "JSON data of inital state of canvas before recording." },

                { "name": "actions", "type": "array", "items": { "$ref": "RecordingAction" }, "description": "JSON data of all canvas API calls." }

            ]

Source/JavaScriptCore/runtime/ConsoleClient.h

@@public:

    virtual void time(ExecState*, const String& title) = 0;

    virtual void timeEnd(ExecState*, const String& title) = 0;

    virtual void timeStamp(ExecState*, Ref<Inspector::ScriptArguments>&&) = 0;

65 virtual void record(ExecState*, Ref<Inspector::ScriptArguments>&&) = 0;

66 virtual void recordEnd(ExecState*, Ref<Inspector::ScriptArguments>&&) = 0;

private:

    enum ArgumentRequirement { ArgumentRequired, ArgumentNotRequired };

Source/JavaScriptCore/runtime/ConsoleObject.cpp

@@static EncodedJSValue JSC_HOST_CALL consoleProtoFuncTimeStamp(ExecState*);

static EncodedJSValue JSC_HOST_CALL consoleProtoFuncGroup(ExecState*);

static EncodedJSValue JSC_HOST_CALL consoleProtoFuncGroupCollapsed(ExecState*);

static EncodedJSValue JSC_HOST_CALL consoleProtoFuncGroupEnd(ExecState*);

60static EncodedJSValue JSC_HOST_CALL consoleProtoFuncRecord(ExecState*);

61static EncodedJSValue JSC_HOST_CALL consoleProtoFuncRecordEnd(ExecState*);

const ClassInfo ConsoleObject::s_info = { "Console", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(ConsoleObject) };

@@void ConsoleObject::finishCreation(VM& vm, JSGlobalObject* globalObject)

    JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("group", consoleProtoFuncGroup, None, 0);

    JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("groupCollapsed", consoleProtoFuncGroupCollapsed, None, 0);

    JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("groupEnd", consoleProtoFuncGroupEnd, None, 0);

100 JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("record", consoleProtoFuncRecord, None, 0);

101 JSC_NATIVE_FUNCTION_WITHOUT_TRANSITION("recordEnd", consoleProtoFuncRecordEnd, None, 0);

}

static String valueToStringWithUndefinedOrNullCheck(ExecState* exec, JSValue value)

@@static EncodedJSValue JSC_HOST_CALL consoleProtoFuncGroupEnd(ExecState* exec)

    return JSValue::encode(jsUndefined());

}

static EncodedJSValue JSC_HOST_CALL consoleProtoFuncRecord(ExecState* exec)

{

    ConsoleClient* client = exec->lexicalGlobalObject()->consoleClient();

    if (!client)

        return JSValue::encode(jsUndefined());

    client->record(exec, Inspector::createScriptArguments(exec, 0));

    return JSValue::encode(jsUndefined());

}

static EncodedJSValue JSC_HOST_CALL consoleProtoFuncRecordEnd(ExecState* exec)

{

    ConsoleClient* client = exec->lexicalGlobalObject()->consoleClient();

    if (!client)

        return JSValue::encode(jsUndefined());

    client->recordEnd(exec, Inspector::createScriptArguments(exec, 0));

    return JSValue::encode(jsUndefined());

}

370394} // namespace JSC

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		94E839521DFB2A12007BC6A7 /* CSSNamespaceRule.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94E8394E1DFB2700007BC6A7 /* CSSNamespaceRule.cpp */; };

		94E839551DFB2BC4007BC6A7 /* JSCSSNamespaceRule.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94E839531DFB2BA6007BC6A7 /* JSCSSNamespaceRule.cpp */; };

		94E839561DFB2BC4007BC6A7 /* JSCSSNamespaceRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 94E839541DFB2BA6007BC6A7 /* JSCSSNamespaceRule.h */; };

3972 9540D31F1EFCA78D00DA2EBB /* InspectorCanvasActionTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 9540D31E1EFCA76E00DA2EBB /* InspectorCanvasActionTypes.h */; };

		96ABA42314BCB80E00D56204 /* GraphicsContext3DOpenGLCommon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 96ABA42214BCB80E00D56204 /* GraphicsContext3DOpenGLCommon.cpp */; };

		9703E1BF15DC4E37001F24C8 /* JSVoidCallback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97E9EC8B15DC492F004F2E71 /* JSVoidCallback.cpp */; };

		97059977107D975200A50A7C /* PolicyCallback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97059973107D975200A50A7C /* PolicyCallback.cpp */; };

		94E839531DFB2BA6007BC6A7 /* JSCSSNamespaceRule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCSSNamespaceRule.cpp; sourceTree = "<group>"; };

		94E839541DFB2BA6007BC6A7 /* JSCSSNamespaceRule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCSSNamespaceRule.h; sourceTree = "<group>"; };

		950C4C02BED8936F818E2F99 /* JSSVGGraphicsElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSSVGGraphicsElement.h; sourceTree = "<group>"; };

12173 9540D31E1EFCA76E00DA2EBB /* InspectorCanvasActionTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = InspectorCanvasActionTypes.h; sourceTree = "<group>"; };

		96ABA42214BCB80E00D56204 /* GraphicsContext3DOpenGLCommon.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GraphicsContext3DOpenGLCommon.cpp; sourceTree = "<group>"; };

		97059973107D975200A50A7C /* PolicyCallback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PolicyCallback.cpp; sourceTree = "<group>"; };

		97059974107D975200A50A7C /* PolicyCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PolicyCallback.h; sourceTree = "<group>"; };

				7A54881514E432A1006AE05A /* DOMPatchSupport.h */,

				B885E8D211E06DD2009FFBF4 /* InspectorApplicationCacheAgent.cpp */,

				B885E8D311E06DD2009FFBF4 /* InspectorApplicationCacheAgent.h */,

17254 9540D31E1EFCA76E00DA2EBB /* InspectorCanvasActionTypes.h */,

				6A4B6D6619D225D8006F11D3 /* InspectorCanvasAgent.cpp */,

				6A4B6D6419D22519006F11D3 /* InspectorCanvasAgent.h */,

				7A1F2B51126C61B20006A7E6 /* InspectorClient.cpp */,

				FD1762E4176686EA00D836A8 /* DownSampler.h in Headers */,

				A718760E0B2A120100A16ECE /* DragActions.h in Headers */,

				A7CA59630B27C1F200FA021D /* DragClient.h in Headers */,

27269 9540D31F1EFCA78D00DA2EBB /* InspectorCanvasActionTypes.h in Headers */,

				A7CA595D0B27BD9E00FA021D /* DragController.h in Headers */,

				A7B6E69F0B291A9600D0529F /* DragData.h in Headers */,

				A7CFB3D20B7ED10A0070C32D /* DragImage.h in Headers */,

Source/WebCore/html/HTMLCanvasElement.cpp

@@void HTMLCanvasElement::removeObserver(CanvasObserver& observer)

void HTMLCanvasElement::setHeight(unsigned value)

{

    if (UNLIKELY(m_recordingState != RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(*this, ASCIILiteral("width"), { value });

    setAttributeWithoutSynchronization(heightAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultHeight)));

}

void HTMLCanvasElement::setWidth(unsigned value)

{

    if (UNLIKELY(m_recordingState != RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(*this, ASCIILiteral("height"), { value });

    setAttributeWithoutSynchronization(widthAttr, AtomicString::number(limitToOnlyHTMLNonNegative(value, defaultWidth)));

}

@@bool HTMLCanvasElement::paintsIntoCanvasBuffer() const

void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r)

{

    if (UNLIKELY(m_recordingState != RecordingState::Inactive))

        InspectorInstrumentation::didFinishRecordingCanvas(*this);

    // Clear the dirty rect

    m_dirtyRect = FloatRect();

Source/WebCore/html/HTMLCanvasElement.h

@@public:

    size_t memoryCost() const;

    size_t externalMemoryCost() const;

    enum RecordingState { Inactive, Requested, Active };

    RecordingState recordingState() const { return m_recordingState; }

    void setRecordingState(RecordingState state) { m_recordingState = state; }

private:

    HTMLCanvasElement(const QualifiedName&, Document&);

@@private:

    bool m_usesDisplayListDrawing { false };

    bool m_tracksDisplayListReplay { false };

195 RecordingState m_recordingState { Inactive };

196

    // m_createdImageBuffer means we tried to malloc the buffer.  We didn't necessarily get it.

    mutable bool m_hasCreatedImageBuffer { false };

    mutable bool m_didClearImageBuffer { false };

Source/WebCore/html/canvas/CanvasPath.cpp

#include "CanvasPath.h"

#include "AffineTransform.h"

39#include "CanvasRenderingContext2D.h"

3940#include "ExceptionCode.h"

4041#include "FloatRect.h"

42#include "HTMLCanvasElement.h"

43#include "InspectorInstrumentation.h"

#include <wtf/MathExtras.h>

namespace WebCore {

void CanvasPath::closePath()

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("closePath"));

    if (m_path.isEmpty())

        return;

@@void CanvasPath::closePath()

void CanvasPath::moveTo(float x, float y)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("moveTo"), { x, y });

    if (!std::isfinite(x) || !std::isfinite(y))

        return;

    if (!hasInvertibleTransform())

@@void CanvasPath::lineTo(FloatPoint point)

void CanvasPath::lineTo(float x, float y)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("lineTo"), { x, y });

    if (!std::isfinite(x) || !std::isfinite(y))

        return;

    if (!hasInvertibleTransform())

@@void CanvasPath::lineTo(float x, float y)

void CanvasPath::quadraticCurveTo(float cpx, float cpy, float x, float y)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("quadraticCurveTo"), { cpx, cpy, x, y });

    if (!std::isfinite(cpx) || !std::isfinite(cpy) || !std::isfinite(x) || !std::isfinite(y))

        return;

    if (!hasInvertibleTransform())

@@void CanvasPath::quadraticCurveTo(float cpx, float cpy, float x, float y)

void CanvasPath::bezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("bezierCurveTo"), { cp1x, cp1y, cp2x, cp2y, x, y });

    if (!std::isfinite(cp1x) || !std::isfinite(cp1y) || !std::isfinite(cp2x) || !std::isfinite(cp2y) || !std::isfinite(x) || !std::isfinite(y))

        return;

    if (!hasInvertibleTransform())

@@void CanvasPath::bezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y, f

ExceptionOr<void> CanvasPath::arcTo(float x1, float y1, float x2, float y2, float r)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("arcTo"), { x1, y1, x2, y2, r });

    if (!std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(x2) || !std::isfinite(y2) || !std::isfinite(r))

        return { };

@@static void normalizeAngles(float& startAngle, float& endAngle, bool anticlockwi

ExceptionOr<void> CanvasPath::arc(float x, float y, float radius, float startAngle, float endAngle, bool anticlockwise)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("arc"), { x, y, radius, startAngle, endAngle, anticlockwise });

    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radius) || !std::isfinite(startAngle) || !std::isfinite(endAngle))

        return { };

@@ExceptionOr<void> CanvasPath::arc(float x, float y, float radius, float startAng

    
ExceptionOr<void> CanvasPath::ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("ellipse"), { x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise });

    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radiusX) || !std::isfinite(radiusY) || !std::isfinite(rotation) || !std::isfinite(startAngle) || !std::isfinite(endAngle))

        return { };

@@ExceptionOr<void> CanvasPath::ellipse(float x, float y, float radiusX, float rad

void CanvasPath::rect(float x, float y, float width, float height)

{

    if (HTMLCanvasElement* canvas = recordingCanvas())

        InspectorInstrumentation::recordCanvasAction(*canvas, ASCIILiteral("rect"), { x, y, width, height });

    if (!hasInvertibleTransform())

        return;

@@void CanvasPath::rect(float x, float y, float width, float height)

    m_path.addRect(FloatRect(x, y, width, height));

}

HTMLCanvasElement* CanvasPath::recordingCanvas() const

{

    if (!is<CanvasRenderingContext2D>(this))

        return nullptr;

    HTMLCanvasElement& canvas = downcast<CanvasRenderingContext2D>(this)->canvas();

    if (LIKELY(canvas.recordingState() == HTMLCanvasElement::RecordingState::Inactive))

        return nullptr;

    return &canvas;

238279}

280

281} // namespace WebCore

Source/WebCore/html/canvas/CanvasPath.h

#pragma once

#include "ExceptionOr.h"

32#include "HTMLCanvasElement.h"

3233#include "Path.h"

34#include <wtf/text/WTFString.h>

namespace WebCore {

@@class CanvasPath {

public:

    virtual ~CanvasPath() { }

    virtual bool isCanvasRenderingContext2D() const { return false; }

    virtual bool isDOMPath() const { return false; }

    void closePath();

    void moveTo(float x, float y);

    void lineTo(float x, float y);

@@protected:

    void lineTo(FloatPoint);

65 HTMLCanvasElement* recordingCanvas() const;

66

    Path m_path;

};

Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

#include "HTMLVideoElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

51#include "InspectorInstrumentation.h"

52#include "Pattern.h"

#include "RenderElement.h"

#include "RenderImage.h"

#include "RenderLayer.h"

#include "TextMetrics.h"

#include "TextRun.h"

#include "TextStream.h"

64#include <runtime/TypedArrayInlines.h>

#include <wtf/CheckedArithmetic.h>

#include <wtf/MathExtras.h>

#include <wtf/NeverDestroyed.h>

@@void CanvasRenderingContext2D::realizeSavesLoop()

    } while (--m_unrealizedSaveCount);

}

void CanvasRenderingContext2D::save()

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("save"));

    ++m_unrealizedSaveCount;

}

374385void CanvasRenderingContext2D::restore()

375386{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("restore"));

    if (m_unrealizedSaveCount) {

        --m_unrealizedSaveCount;

        return;

@@float CanvasRenderingContext2D::lineWidth() const

void CanvasRenderingContext2D::setLineWidth(float width)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("lineWidth"), { width });

    if (!(std::isfinite(width) && width > 0))

        return;

    if (state().lineWidth == width)

@@String CanvasRenderingContext2D::lineCap() const

void CanvasRenderingContext2D::setLineCap(const String& s)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("lineCap"), { s });

    LineCap cap;

    if (!parseLineCap(s, cap))

        return;

@@String CanvasRenderingContext2D::lineJoin() const

void CanvasRenderingContext2D::setLineJoin(const String& s)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("lineJoin"), { s });

    LineJoin join;

    if (!parseLineJoin(s, join))

        return;

@@float CanvasRenderingContext2D::miterLimit() const

void CanvasRenderingContext2D::setMiterLimit(float limit)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("miterLimit"), { limit });

    if (!(std::isfinite(limit) && limit > 0))

        return;

    if (state().miterLimit == limit)

@@float CanvasRenderingContext2D::shadowOffsetX() const

void CanvasRenderingContext2D::setShadowOffsetX(float x)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("shadowOffsetX"), { x });

    if (!std::isfinite(x))

        return;

    if (state().shadowOffset.width() == x)

@@float CanvasRenderingContext2D::shadowOffsetY() const

void CanvasRenderingContext2D::setShadowOffsetY(float y)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("shadowOffsetY"), { y });

    if (!std::isfinite(y))

        return;

    if (state().shadowOffset.height() == y)

@@float CanvasRenderingContext2D::shadowBlur() const

void CanvasRenderingContext2D::setShadowBlur(float blur)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("shadowBlur"), { blur });

    if (!(std::isfinite(blur) && blur >= 0))

        return;

    if (state().shadowBlur == blur)

@@String CanvasRenderingContext2D::shadowColor() const

void CanvasRenderingContext2D::setShadowColor(const String& colorString)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("shadowColor"), { colorString });

    Color color = parseColorOrCurrentColor(colorString, &canvas());

    if (!color.isValid())

        return;

@@static bool lineDashSequenceIsValid(const Vector<float>& dash)

void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setLineDash"), { dash });

    if (!lineDashSequenceIsValid(dash))

        return;

@@void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)

void CanvasRenderingContext2D::setWebkitLineDash(const Vector<float>& dash)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("webkitLineDash"), { dash });

    if (!lineDashSequenceIsValid(dash))

        return;

@@float CanvasRenderingContext2D::lineDashOffset() const

void CanvasRenderingContext2D::setLineDashOffset(float offset)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("lineDashOffset"), { offset });

    if (!std::isfinite(offset) || state().lineDashOffset == offset)

        return;

@@float CanvasRenderingContext2D::globalAlpha() const

void CanvasRenderingContext2D::setGlobalAlpha(float alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("globalAlpha"), { alpha });

    if (!(alpha >= 0 && alpha <= 1))

        return;

    if (state().globalAlpha == alpha)

@@String CanvasRenderingContext2D::globalCompositeOperation() const

void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("globalCompositeOperation"), { operation });

    CompositeOperator op = CompositeSourceOver;

    BlendMode blendMode = BlendModeNormal;

    if (!parseCompositeAndBlendOperator(operation, op, blendMode))

@@void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operati

void CanvasRenderingContext2D::scale(float sx, float sy)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("scale"), { sx, sy });

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::scale(float sx, float sy)

void CanvasRenderingContext2D::rotate(float angleInRadians)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("rotate"), { angleInRadians });

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::rotate(float angleInRadians)

void CanvasRenderingContext2D::translate(float tx, float ty)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("translate"), { tx, ty });

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::translate(float tx, float ty)

void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("transform"), { m11, m12, m21, m22, dx, dy });

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float

void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setTransform"), { m11, m12, m21, m22, dx, dy });

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, flo

void CanvasRenderingContext2D::resetTransform()

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("resetTransform"));

    GraphicsContext* c = drawingContext();

    if (!c)

        return;

@@void CanvasRenderingContext2D::resetTransform()

void CanvasRenderingContext2D::setStrokeColor(const String& color, std::optional<float> alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        Vector<Canvas2DParameterVariant> parameters { color };

        if (alpha)

            parameters.append(alpha.value());

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setStrokeColor"), WTFMove(parameters));

    }

    if (alpha) {

        setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));

        return;

@@void CanvasRenderingContext2D::setStrokeColor(const String& color, std::optional

void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setStrokeColor"), { grayLevel, alpha });

    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))

        return;

    setStrokeStyle(CanvasStyle(grayLevel, alpha));

@@void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)

void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setStrokeColor"), { r, g, b, a });

    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(r, g, b, a))

        return;

    setStrokeStyle(CanvasStyle(r, g, b, a));

@@void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a

void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setStrokeColor"), { c, m, y, k, a });

    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentCMYKA(c, m, y, k, a))

        return;

    setStrokeStyle(CanvasStyle(c, m, y, k, a));

@@void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k

void CanvasRenderingContext2D::setFillColor(const String& color, std::optional<float> alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        Vector<Canvas2DParameterVariant> parameters { color };

        if (alpha)

            parameters.append(alpha.value());

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setFillColor"), WTFMove(parameters));

    }

    if (alpha) {

        setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));

        return;

@@void CanvasRenderingContext2D::setFillColor(const String& color, std::optional<f

void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setFillColor"), { grayLevel, alpha });

    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))

        return;

    setFillStyle(CanvasStyle(grayLevel, alpha));

@@void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)

void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setFillColor"), { r, g, b, a });

    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(r, g, b, a))

        return;

    setFillStyle(CanvasStyle(r, g, b, a));

@@void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)

void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setFillColor"), { c, m, y, k, a });

    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentCMYKA(c, m, y, k, a))

        return;

    setFillStyle(CanvasStyle(c, m, y, k, a));

@@void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k,

void CanvasRenderingContext2D::beginPath()

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("beginPath"));

    m_path.clear();

}

@@static WindRule toWindRule(CanvasRenderingContext2D::WindingRule rule)

    return rule == CanvasRenderingContext2D::WindingRule::Nonzero ? RULE_NONZERO : RULE_EVENODD;

}

static inline String stringForWindingRule(CanvasRenderingContext2D::WindingRule windingRule)

{

    switch (windingRule) {

    case CanvasRenderingContext2D::WindingRule::Nonzero:

        return ASCIILiteral("nonzero");

    case CanvasRenderingContext2D::WindingRule::Evenodd:

        return ASCIILiteral("evenodd");

    }

    ASSERT_NOT_REACHED();

    return "";

}

9501071void CanvasRenderingContext2D::fill(WindingRule windingRule)

9511072{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fill"), { stringForWindingRule(windingRule) });

    fillInternal(m_path, windingRule);

    clearPathForDashboardBackwardCompatibilityMode();

}

void CanvasRenderingContext2D::stroke()

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("stroke"));

    strokeInternal(m_path);

    clearPathForDashboardBackwardCompatibilityMode();

}

void CanvasRenderingContext2D::clip(WindingRule windingRule)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("clip"), { stringForWindingRule(windingRule) });

    clipInternal(m_path, windingRule);

    clearPathForDashboardBackwardCompatibilityMode();

}

void CanvasRenderingContext2D::fill(DOMPath& path, WindingRule windingRule)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fill"), { path.toString(), stringForWindingRule(windingRule) });

    fillInternal(path.path(), windingRule);

}

void CanvasRenderingContext2D::stroke(DOMPath& path)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("stroke"), { path.toString() });

    strokeInternal(path.path());

}

void CanvasRenderingContext2D::clip(DOMPath& path, WindingRule windingRule)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("clip"), { path.toString(), stringForWindingRule(windingRule) });

    clipInternal(path.path(), windingRule);

}

@@inline void CanvasRenderingContext2D::endCompositeLayer()

bool CanvasRenderingContext2D::isPointInPath(float x, float y, WindingRule windingRule)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("isPointInPath"), { x, y, stringForWindingRule(windingRule) });

    return isPointInPathInternal(m_path, x, y, windingRule);

}

bool CanvasRenderingContext2D::isPointInStroke(float x, float y)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("isPointInStroke"), { x, y });

    return isPointInStrokeInternal(m_path, x, y);

}

bool CanvasRenderingContext2D::isPointInPath(DOMPath& path, float x, float y, WindingRule windingRule)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("isPointInPath"), { path.toString(), x, y, stringForWindingRule(windingRule) });

    return isPointInPathInternal(path.path(), x, y, windingRule);

}

bool CanvasRenderingContext2D::isPointInStroke(DOMPath& path, float x, float y)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("isPointInStroke"), { path.toString(), x, y });

    return isPointInStrokeInternal(path.path(), x, y);

}

@@bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, float x

void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("clearRect"), { x, y, width, height });

    if (!validateRectForCanvas(x, y, width, height))

        return;

    auto* context = drawingContext();

@@void CanvasRenderingContext2D::clearRect(float x, float y, float width, float he

void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fillRect"), { x, y, width, height });

    if (!validateRectForCanvas(x, y, width, height))

        return;

@@void CanvasRenderingContext2D::fillRect(float x, float y, float width, float hei

void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("strokeRect"), { x, y, width, height });

    if (!validateRectForCanvas(x, y, width, height))

        return;

@@void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float h

void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& colorString, std::optional<float> alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        Vector<Canvas2DParameterVariant> parameters { width, height, blur, colorString };

        if (alpha)

            parameters.append(alpha.value());

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setShadow"), WTFMove(parameters));

    }

    Color color = Color::transparent;

    if (!colorString.isNull()) {

        color = parseColorOrCurrentColor(colorString, &canvas());

@@void CanvasRenderingContext2D::setShadow(float width, float height, float blur,

void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setShadow"), { width, height, blur, grayLevel, alpha });

    setShadow(FloatSize(width, height), blur, Color(grayLevel, grayLevel, grayLevel, alpha));

}

void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setShadow"), { width, height, blur, r, g, b, a });

    setShadow(FloatSize(width, height), blur, Color(r, g, b, a));

}

void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setShadow"), { width, height, blur, c, m, y, k, a });

    setShadow(FloatSize(width, height), blur, Color(c, m, y, k, a));

}

void CanvasRenderingContext2D::clearShadow()

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("clearShadow"));

    setShadow(FloatSize(), 0, Color::transparent);

}

@@static inline FloatRect normalizeRect(const FloatRect& rect)

ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        String source;

        WTF::switchOn(image,

            [&] (RefPtr<HTMLImageElement>& imageElement) {

                source = imageElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLVideoElement>& videoElement) {

                // get dataURL of current frame

                source = videoElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLCanvasElement>& canvasElement) {

                source = canvasElement->toDataURL(ASCIILiteral("image/png")).releaseReturnValue();

            }

        );

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawImage"), { source, dx, dy });

    }

    return WTF::switchOn(image,

        [&] (RefPtr<HTMLImageElement>& imageElement) -> ExceptionOr<void> {

            LayoutSize destRectSize = size(*imageElement, ImageSizeType::AfterDevicePixelRatio);

@@ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image,

ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy, float dw, float dh)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        String source;

        WTF::switchOn(image,

            [&] (RefPtr<HTMLImageElement>& imageElement) {

                source = imageElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLVideoElement>& videoElement) {

                // get dataURL of current frame

                source = videoElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLCanvasElement>& canvasElement) {

                source = canvasElement->toDataURL(ASCIILiteral("image/png")).releaseReturnValue();

            }

        );

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawImage"), { source, dx, dy, dw, dh });

    }

    return WTF::switchOn(image,

        [&] (auto& element) -> ExceptionOr<void> {

            FloatSize elementSize = size(*element);

@@ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image,

ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        String source;

        WTF::switchOn(image,

            [&] (RefPtr<HTMLImageElement>& imageElement) {

                source = imageElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLVideoElement>& videoElement) {

                // get dataURL of current frame

                source = videoElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLCanvasElement>& canvasElement) {

                source = canvasElement->toDataURL(ASCIILiteral("image/png")).releaseReturnValue();

            }

        );

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawImage"), { source, sx, sy, sw, sh, dx, dy, dw, dh });

    }

    return WTF::switchOn(image,

        [&] (auto& element) -> ExceptionOr<void> {

            return this->drawImage(*element, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh });

@@ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, c

void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawImageFromRect"), { imageElement.currentSrc().string(), sx, sy, sw, sh, dx, dy, dw, dh, compositeOperation });

    CompositeOperator op;

    auto blendOp = BlendModeNormal;

    if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal)

@@void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement,

void CanvasRenderingContext2D::setAlpha(float alpha)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setAlpha"), { alpha });

    setGlobalAlpha(alpha);

}

void CanvasRenderingContext2D::setCompositeOperation(const String& operation)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("setCompositeOperation"), { operation });

    setGlobalCompositeOperation(operation);

}

@@CanvasRenderingContext2D::Style CanvasRenderingContext2D::strokeStyle() const

void CanvasRenderingContext2D::setStrokeStyle(CanvasRenderingContext2D::Style&& style)

{

    WTF::switchOn(style,

        [this] (const String& string) { this->setStrokeColor(string); },

        [this] (const RefPtr<CanvasGradient>& gradient) { this->setStrokeStyle(CanvasStyle(*gradient)); },

        [this] (const RefPtr<CanvasPattern>& pattern) { this->setStrokeStyle(CanvasStyle(*pattern)); }

        [this] (const String& string) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("strokeStyle"), { string });

            if (string == state().unparsedStrokeColor)

                return;

            realizeSaves();

            setStrokeStyle(CanvasStyle::createFromString(string));

            modifiableState().unparsedStrokeColor = string;

        },

        [this] (const RefPtr<CanvasGradient>& gradient) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("strokeStyle"), { gradient });

            setStrokeStyle(CanvasStyle(*gradient));

        },

        [this] (const RefPtr<CanvasPattern>& pattern) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("strokeStyle"), { pattern });

            setStrokeStyle(CanvasStyle(*pattern));

        }

    );

}

@@CanvasRenderingContext2D::Style CanvasRenderingContext2D::fillStyle() const

void CanvasRenderingContext2D::setFillStyle(CanvasRenderingContext2D::Style&& style)

{

    WTF::switchOn(style,

        [this] (const String& string) { this->setFillColor(string); },

        [this] (const RefPtr<CanvasGradient>& gradient) { this->setFillStyle(CanvasStyle(*gradient)); },

        [this] (const RefPtr<CanvasPattern>& pattern) { this->setFillStyle(CanvasStyle(*pattern)); }

        [this] (const String& string) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fillStyle"), { string });

            if (string == state().unparsedFillColor)

                return;

            realizeSaves();

            setFillStyle(CanvasStyle::createFromString(string));

            modifiableState().unparsedFillColor = string;

        },

        [this] (const RefPtr<CanvasGradient>& gradient) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fillStyle"), { gradient });

            setFillStyle(CanvasStyle(*gradient));

        },

        [this] (const RefPtr<CanvasPattern>& pattern) {

            if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

                InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fillStyle"), { pattern });

            setFillStyle(CanvasStyle(*pattern));

        }

    );

}

ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("createLinearGradient"), { x0, y0, x1, y1 });

    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1))

        return Exception { NOT_SUPPORTED_ERR };

@@ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createLinearGradient(

ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("createRadialGradient"), { x0, y0, r0, x1, y1, r1 });

    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1))

        return Exception { NOT_SUPPORTED_ERR };

@@ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createRadialGradient(

ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(CanvasImageSource&& image, const String& repetition)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        String source;

        WTF::switchOn(image,

            [&] (RefPtr<HTMLImageElement>& imageElement) {

                source = imageElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLVideoElement>& videoElement) {

                // get dataURL of current frame

                source = videoElement->currentSrc().string();

            },

            [&] (RefPtr<HTMLCanvasElement>& canvasElement) {

                source = canvasElement->toDataURL(ASCIILiteral("image/png")).releaseReturnValue();

            }

        );

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("createPattern"), { source, repetition });

    }

    bool repeatX, repeatY;

    if (!CanvasPattern::parseRepetitionType(repetition, repeatX, repeatY))

        return Exception { SYNTAX_ERR };

@@GraphicsContext* CanvasRenderingContext2D::drawingContext() const

    return canvas().drawingContext();

}

static RefPtr<ImageData> duplicateImageData(ImageData& imageData)

{

    return ImageData::create(imageData.size(), Uint8ClampedArray::create(imageData.data()->data(), imageData.data()->length()).releaseNonNull());

}

static RefPtr<ImageData> createEmptyImageData(const IntSize& size)

{

    auto data = ImageData::create(size);

@@static RefPtr<ImageData> createEmptyImageData(const IntSize& size)

ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(ImageData* imageData) const

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("createImageData"), { imageData ? duplicateImageData(*imageData) : createEmptyImageData(canvas().size()) });

    if (!imageData)

        return Exception { NOT_SUPPORTED_ERR };

@@ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(ImageDa

ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(float sw, float sh) const

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("createImageData"), { sw, sh });

    if (!sw || !sh)

        return Exception { INDEX_SIZE_ERR };

@@ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(float s

ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) const

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("getImageData"), { sx, sy, sw, sh });

    return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh);

}

ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh) const

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("webkitGetImageDataHD"), { sx, sy, sw, sh });

    return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh);

}

@@ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(ImageBuffe

void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy)

{

2031 putImageData(data, dx, dy, 0, 0, data.width(), data.height());

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("putImageData"), { duplicateImageData(data), dx, dy });

    putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, 0, 0, data.width(), data.height());

}

void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy)

{

2036 webkitPutImageDataHD(data, dx, dy, 0, 0, data.width(), data.height());

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("webkitPutImageDataHD"), { duplicateImageData(data), dx, dy });

    putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, 0, 0, data.width(), data.height());

}

void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("putImageData"), { duplicateImageData(data), dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight });

    putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);

}

void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("webkitPutImageDataHD"), { duplicateImageData(data), dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight });

    putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);

}

void CanvasRenderingContext2D::drawFocusIfNeeded(Element& element)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawFocusIfNeeded"), { String("element") });

    drawFocusIfNeededInternal(m_path, element);

}

void CanvasRenderingContext2D::drawFocusIfNeeded(DOMPath& path, Element& element)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("drawFocusIfNeeded"), { path.toString(), String("element") });

    drawFocusIfNeededInternal(path.path(), element);

}

@@String CanvasRenderingContext2D::font() const

void CanvasRenderingContext2D::setFont(const String& newFont)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("font"), { newFont });

    if (newFont == state().unparsedFont && state().font.realized())

        return;

@@String CanvasRenderingContext2D::textAlign() const

void CanvasRenderingContext2D::setTextAlign(const String& s)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("textAlign"), { s });

    TextAlign align;

    if (!parseTextAlign(s, align))

        return;

@@String CanvasRenderingContext2D::textBaseline() const

void CanvasRenderingContext2D::setTextBaseline(const String& s)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("textBaseline"), { s });

    TextBaseline baseline;

    if (!parseTextBaseline(s, baseline))

        return;

@@String CanvasRenderingContext2D::direction() const

void CanvasRenderingContext2D::setDirection(const String& directionString)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("direction"), { directionString });

    Direction direction;

    if (directionString == "inherit")

        direction = Direction::Inherit;

@@void CanvasRenderingContext2D::setDirection(const String& directionString)

void CanvasRenderingContext2D::fillText(const String& text, float x, float y, std::optional<float> maxWidth)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        Vector<Canvas2DParameterVariant> parameters { text, x, y };

        if (maxWidth)

            parameters.append(maxWidth.value());

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("fillText"), WTFMove(parameters));

    }

    drawTextInternal(text, x, y, true, maxWidth);

}

void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, std::optional<float> maxWidth)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive)) {

        Vector<Canvas2DParameterVariant> parameters { text, x, y };

        if (maxWidth)

            parameters.append(maxWidth.value());

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("strokeText"), WTFMove(parameters));

    }

    drawTextInternal(text, x, y, false, maxWidth);

}

@@static void normalizeSpaces(String& text)

Ref<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("measureText"), { text });

    Ref<TextMetrics> metrics = TextMetrics::create();

    String normalizedText = text;

@@auto CanvasRenderingContext2D::imageSmoothingQuality() const -> ImageSmoothingQu

void CanvasRenderingContext2D::setImageSmoothingQuality(ImageSmoothingQuality quality)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("imageSmoothingQuality"), { stringForImageSmoothingQuality(quality) });

    if (quality == state().imageSmoothingQuality)

        return;

@@bool CanvasRenderingContext2D::imageSmoothingEnabled() const

void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)

{

    if (UNLIKELY(canvas().recordingState() != HTMLCanvasElement::RecordingState::Inactive))

        InspectorInstrumentation::recordCanvasAction(canvas(), ASCIILiteral("imageSmoothingEnabled"), { enabled });

    if (enabled == state().imageSmoothingEnabled)

        return;

Source/WebCore/html/canvas/CanvasRenderingContext2D.h

@@public:

    String globalCompositeOperation() const;

    void setGlobalCompositeOperation(const String&);

107 void save() ~~{ ++m_unrealizedSaveCount; }~~

107 void save();

    void restore();

    // This is a no-op in a direct-2d canvas.

@@public:

    void setImageSmoothingEnabled(bool);

    enum class ImageSmoothingQuality { Low, Medium, High };

    static inline String stringForImageSmoothingQuality(ImageSmoothingQuality quality)

    {

        switch (quality) {

        case ImageSmoothingQuality::Low:

            return ASCIILiteral("low");

        case ImageSmoothingQuality::Medium:

            return ASCIILiteral("medium");

        case ImageSmoothingQuality::High:

            return ASCIILiteral("high");

        }

        ASSERT_NOT_REACHED();

        return "";

    }

    ImageSmoothingQuality imageSmoothingQuality() const;

    void setImageSmoothingQuality(ImageSmoothingQuality);

@@public:

    String displayListAsText(DisplayList::AsTextFlags) const;

    String replayDisplayListAsText(DisplayList::AsTextFlags) const;

230 private:

    enum class Direction {

        Inherit,

        RTL,

@@private:

        FontProxy font;

    };

    State& modifiableState() { ASSERT(!m_unrealizedSaveCount || m_stateStack.size() >= MaxSaveCount); return m_stateStack.last(); }

    const State& state() const { return m_stateStack.last(); }

private:

    enum CanvasDidDrawOption {

        CanvasDidDrawApplyNone = 0,

        CanvasDidDrawApplyTransform = 1,

@@private:

        CanvasDidDrawApplyAll = 0xffffffff

    };

    State& modifiableState() { ASSERT(!m_unrealizedSaveCount || m_stateStack.size() >= MaxSaveCount); return m_stateStack.last(); }

    const State& state() const { return m_stateStack.last(); }

    void applyLineDash() const;

    void setShadow(const FloatSize& offset, float blur, const Color&);

    void applyShadow();

@@private:

    bool is2d() const override { return true; }

    bool isAccelerated() const override;

396 bool isCanvasRenderingContext2D() const override { return true; }

397

    bool hasInvertibleTransform() const override { return state().hasInvertibleTransform; }

    TextDirection toTextDirection(Direction, const RenderStyle** computedStyle = nullptr) const;

@@private:

} // namespace WebCore

402 SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::CanvasRenderingContext2D, is2d())

SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::CanvasRenderingContext2D)

    static bool isType(const WebCore::CanvasRenderingContext& context) { return context.is2d(); }

    static bool isType(const WebCore::CanvasPath& canvasPath) { return canvasPath.isCanvasRenderingContext2D(); }

SPECIALIZE_TYPE_TRAITS_END()

Source/WebCore/html/canvas/DOMPath.h

@@public:

    const Path& path() const { return m_path; }

    String toString() const

    {

        String result;

        buildStringFromPath(m_path, result);

        return result;

    }

    bool isDOMPath() const override { return true; }

private:

    DOMPath() { }

    DOMPath(const Path& path)

@@private:

};

} // namespace WebCore

SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DOMPath)

    static bool isType(const WebCore::CanvasPath& canvasPath) { return canvasPath.isDOMPath(); }

SPECIALIZE_TYPE_TRAITS_END()

Source/WebCore/inspector/InspectorCanvasActionTypes.h

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

#pragma once

#include "CanvasGradient.h"

#include "CanvasPattern.h"

#include "ImageData.h"

#include <wtf/RefPtr.h>

#include <wtf/Variant.h>

#include <wtf/Vector.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

typedef Variant<RefPtr<CanvasGradient>, RefPtr<CanvasPattern>, RefPtr<ImageData>, Vector<float>, String, double, float, unsigned, bool> Canvas2DParameterVariant;

} // namespace WebCore

Source/WebCore/inspector/InspectorCanvasAgent.cpp

#include "config.h"

#include "InspectorCanvasAgent.h"

29#include "CanvasGradient.h"

30#include "CanvasPattern.h"

#include "CanvasRenderingContext.h"

#include "CanvasRenderingContext2D.h"

#include "Document.h"

#include "Frame.h"

35#include "Gradient.h"

36#include "ImageData.h"

#include "InspectorDOMAgent.h"

#include "InspectorPageAgent.h"

#include "InstrumentingAgents.h"

#include "JSWebGL2RenderingContext.h"

#include "JSWebGPURenderingContext.h"

#include "MainFrame.h"

46#include "Pattern.h"

#include "ScriptState.h"

#include "WebGL2RenderingContext.h"

#include "ScriptState.h"

#include <inspector/IdentifiersFactory.h>

#include <inspector/InjectedScript.h>

#include <inspector/InjectedScriptManager.h>

52 #include <inspector/InspectorProtocolObjects.h>

#include <runtime/JSCInlines.h>

using namespace Inspector;

@@InspectorCanvasAgent::InspectorCanvasAgent(WebAgentContext& context, InspectorPa

    , m_backendDispatcher(Inspector::CanvasBackendDispatcher::create(context.backendDispatcher, this))

    , m_injectedScriptManager(context.injectedScriptManager)

    , m_pageAgent(pageAgent)

65 , m_timer(*this, &InspectorCanvasAgent::canvasDestroyedTimerFired)

69 , m_canvasRecordingTimer(*this, &InspectorCanvasAgent::canvasRecordingTimerFired)

70 , m_canvasDestroyedTimer(*this, &InspectorCanvasAgent::canvasDestroyedTimerFired)

{

}

@@void InspectorCanvasAgent::disable(ErrorString&)

    if (!m_enabled)

        return;

103 if (m_timer.isActive())

104 m_timer.stop();

108 if (m_canvasDestroyedTimer.isActive())

109 m_canvasDestroyedTimer.stop();

    m_removedCanvasIdentifiers.clear();

@@void InspectorCanvasAgent::resolveCanvasContext(ErrorString& errorString, const

    result = injectedScript.wrapObject(value, objectGroupName);

}

void InspectorCanvasAgent::toggleRecording(ErrorString& errorString, const String& canvasId, bool flag)

{

    const CanvasEntry* canvasEntry = getCanvasEntry(canvasId);

    if (!canvasEntry) {

        errorString = ASCIILiteral("Invalid canvas identifier");

        return;

    }

    if (!flag) {

        clearRecordingData(*canvasEntry->element);

        canvasEntry->element->setRecordingState(HTMLCanvasElement::RecordingState::Inactive);

    } else if (canvasEntry->element->recordingState() == HTMLCanvasElement::RecordingState::Inactive)

        canvasEntry->element->setRecordingState(HTMLCanvasElement::RecordingState::Requested);

}

void InspectorCanvasAgent::frameNavigated(Frame& frame)

{

    if (frame.isMainFrame()) {

@@void InspectorCanvasAgent::didChangeCanvasMemory(HTMLCanvasElement& canvasElemen

    m_frontendDispatcher->canvasMemoryChanged(canvasEntry->identifier, canvasElement.memoryCost());

}

static RefPtr<Inspector::Protocol::Array<double>> buildArrayForAffineTransform(const AffineTransform& affineTransform)

{

    RefPtr<Inspector::Protocol::Array<double>> array = Inspector::Protocol::Array<double>::create();

    array->addItem(affineTransform.a());

    array->addItem(affineTransform.b());

    array->addItem(affineTransform.c());

    array->addItem(affineTransform.d());

    array->addItem(affineTransform.e());

    array->addItem(affineTransform.f());

    return array;

}

static RefPtr<InspectorObject> buildObjectForImageData(const ImageData& imageData)

{

    RefPtr<InspectorObject> object = InspectorObject::create();

    object->setInteger(ASCIILiteral("width"), imageData.width());

    object->setInteger(ASCIILiteral("height"), imageData.height());

    RefPtr<Inspector::Protocol::Array<int>> data = Inspector::Protocol::Array<int>::create();

    for (size_t i = 0; i < imageData.data()->length(); ++i)

        data->addItem(imageData.data()->item(i));

    object->setArray(ASCIILiteral("data"), WTFMove(data));

    return object;

}

static RefPtr<InspectorObject> buildObjectForCanvasGradient(const CanvasGradient& canvasGradient)

{

    bool isRadial = canvasGradient.gradient().isRadial();

    RefPtr<InspectorObject> object = InspectorObject::create();

    object->setString("type", isRadial ? "radial-gradient" : "linear-gradient");

    RefPtr<Inspector::Protocol::Array<float>> parameters = Inspector::Protocol::Array<float>::create();

    parameters->addItem(canvasGradient.gradient().p0().x());

    parameters->addItem(canvasGradient.gradient().p0().y());

    if (isRadial)

        parameters->addItem(canvasGradient.gradient().startRadius());

    parameters->addItem(canvasGradient.gradient().p1().x());

    parameters->addItem(canvasGradient.gradient().p1().y());

    if (isRadial)

        parameters->addItem(canvasGradient.gradient().endRadius());

    object->setArray(ASCIILiteral("parameters"), WTFMove(parameters));

    if (!canvasGradient.gradient().stops().isEmpty()) {

        RefPtr<Inspector::Protocol::Array<InspectorValue>> stops = Inspector::Protocol::Array<InspectorValue>::create();

        for (const Gradient::ColorStop& colorStop : canvasGradient.gradient().stops()) {

            RefPtr<Inspector::Protocol::Array<InspectorValue>> stop = Inspector::Protocol::Array<InspectorValue>::create();

            stop->addItem(colorStop.offset);

            stop->addItem(colorStop.color.cssText());

            stops->addItem(WTFMove(stop));

        }

        object->setArray(ASCIILiteral("stops"), WTFMove(stops));

    }

    return object;

}

static RefPtr<InspectorObject> buildObjectForCanvasPattern(const CanvasPattern& canvasPattern)

{

    RefPtr<InspectorObject> object = InspectorObject::create();

    object->setString(ASCIILiteral("type"), ASCIILiteral("pattern"));

    object->setString(ASCIILiteral("image"), ASCIILiteral("data:,"));

    // object->setString(ASCIILiteral("image"), "data:image/png," + base64Encode(pattern->tileImage().data()));

    String repeat;

    bool repeatX = canvasPattern.pattern().repeatX();

    bool repeatY = canvasPattern.pattern().repeatY();

    if (repeatX && repeatY)

        repeat = ASCIILiteral("repeat");

    else if (repeatX && !repeatY)

        repeat = ASCIILiteral("repeat-x");

    else if (!repeatX && repeatY)

        repeat = ASCIILiteral("repeat-y");

    else

        repeat = ASCIILiteral("no-repeat");

    object->setString(ASCIILiteral("repeat"), repeat);

    return object;

}

static RefPtr<Inspector::Protocol::Array<double>> buildArrayForVector(const Vector<float>& vector)

{

    RefPtr<Inspector::Protocol::Array<double>> array = Inspector::Protocol::Array<double>::create();

    for (double item : vector)

        array->addItem(item);

    return array;

}

void InspectorCanvasAgent::didStartRecordingCanvas(HTMLCanvasElement& canvasElement, bool fromConsole)

{

    CanvasEntry* canvasEntry = getCanvasEntry(canvasElement);

    if (!canvasEntry)

        return;

    auto initialState = Inspector::Protocol::Canvas::InitialState::create()

        .release();

    RefPtr<InspectorObject> attributes = InspectorObject::create();

    RefPtr<InspectorObject> functions = InspectorObject::create();

    attributes->setInteger(ASCIILiteral("width"), canvasEntry->element->width());

    attributes->setInteger(ASCIILiteral("height"), canvasEntry->element->height());

    CanvasRenderingContext* context = canvasEntry->element->renderingContext();

    if (is<CanvasRenderingContext2D>(context)) {

        CanvasRenderingContext2D* context2d = downcast<CanvasRenderingContext2D>(context);

        functions->setArray(ASCIILiteral("transform"), buildArrayForAffineTransform(context2d->state().transform));

        attributes->setDouble(ASCIILiteral("globalAlpha"), context2d->globalAlpha());

        attributes->setString(ASCIILiteral("globalCompositeOperation"), context2d->globalCompositeOperation());

        attributes->setDouble(ASCIILiteral("lineWidth"), context2d->lineWidth());

        attributes->setString(ASCIILiteral("lineCap"), context2d->lineCap());

        attributes->setString(ASCIILiteral("lineJoin"), context2d->lineJoin());

        attributes->setDouble(ASCIILiteral("miterLimit"), context2d->miterLimit());

        attributes->setDouble(ASCIILiteral("shadowOffsetX"), context2d->shadowOffsetX());

        attributes->setDouble(ASCIILiteral("shadowOffsetY"), context2d->shadowOffsetY());

        attributes->setDouble(ASCIILiteral("shadowBlur"), context2d->shadowBlur());

        attributes->setString(ASCIILiteral("shadowColor"), context2d->shadowColor());

        functions->setArray(ASCIILiteral("setLineDash"), buildArrayForVector(context2d->getLineDash()));

        attributes->setDouble(ASCIILiteral("lineDashOffset"), context2d->lineDashOffset());

        attributes->setString(ASCIILiteral("font"), context2d->font());

        attributes->setString(ASCIILiteral("textAlign"), context2d->textAlign());

        attributes->setString(ASCIILiteral("textBaseline"), context2d->textBaseline());

        attributes->setString(ASCIILiteral("direction"), context2d->direction());

        if (const CanvasGradient* canvasGradient = context2d->state().strokeStyle.canvasGradient())

            attributes->setObject(ASCIILiteral("strokeStyle"), buildObjectForCanvasGradient(*canvasGradient));

        else if (const CanvasPattern* canvasPattern = context2d->state().strokeStyle.canvasPattern())

            attributes->setObject(ASCIILiteral("strokeStyle"), buildObjectForCanvasPattern(*canvasPattern));

        else

            attributes->setString(ASCIILiteral("strokeStyle"), context2d->state().strokeStyle.color());

        if (const CanvasGradient* canvasGradient = context2d->state().fillStyle.canvasGradient())

            attributes->setObject(ASCIILiteral("fillStyle"), buildObjectForCanvasGradient(*canvasGradient));

        else if (const CanvasPattern* canvasPattern = context2d->state().fillStyle.canvasPattern())

            attributes->setObject(ASCIILiteral("fillStyle"), buildObjectForCanvasPattern(*canvasPattern));

        else

            attributes->setString(ASCIILiteral("fillStyle"), context2d->state().fillStyle.color());

        attributes->setBoolean(ASCIILiteral("imageSmoothingEnabled"), context2d->imageSmoothingEnabled());

        attributes->setString(ASCIILiteral("imageSmoothingQuality"), CanvasRenderingContext2D::stringForImageSmoothingQuality(context2d->imageSmoothingQuality()));

    }

    if (attributes->size())

        initialState->setAttributes(WTFMove(attributes));

    if (functions->size())

        initialState->setFunctions(WTFMove(functions));

    ExceptionOr<String> result = canvasEntry->element->toDataURL(ASCIILiteral("image/png"));

    if (!result.hasException())

        initialState->setContent(result.releaseReturnValue());

    m_recordingData.set(canvasEntry->element, CanvasRecordingData(WTFMove(initialState), fromConsole));

    if (!fromConsole && !m_canvasRecordingTimer.isActive())

        m_canvasRecordingTimer.startOneShot(0_s);

    canvasElement.setRecordingState(HTMLCanvasElement::RecordingState::Active);

}

void InspectorCanvasAgent::recordCanvasAction(HTMLCanvasElement& canvasElement, const String& name, Vector<Canvas2DParameterVariant>&& parameters)

{

    if (canvasElement.recordingState() == HTMLCanvasElement::RecordingState::Requested)

        didStartRecordingCanvas(canvasElement);

    CanvasRecordingData* data = getRecordingData(canvasElement);

    if (!data)

        return;

    auto action = Inspector::Protocol::Canvas::RecordingAction::create()

        .setName(name)

        .release();

    if (!parameters.isEmpty()) {

        RefPtr<Inspector::Protocol::Array<Inspector::InspectorValue>> parametersData = Inspector::Protocol::Array<Inspector::InspectorValue>::create();

        for (const Canvas2DParameterVariant& item : parameters) {

            WTF::switchOn(item,

                [&] (const RefPtr<CanvasGradient>& value) { parametersData->addItem(buildObjectForCanvasGradient(*value)); },

                [&] (const RefPtr<CanvasPattern>& value) { parametersData->addItem(buildObjectForCanvasPattern(*value)); },

                [&] (const RefPtr<ImageData>& value) { parametersData->addItem(buildObjectForImageData(*value)); },

                [&] (const Vector<float>& value) { parametersData->addItem(buildArrayForVector(value)); },

                [&] (const String& value) { parametersData->addItem(value); },

                [&] (double value) { parametersData->addItem(value); },

                [&] (float value) { parametersData->addItem(value); },

                [&] (unsigned value) { parametersData->addItem(static_cast<int>(value)); },

                [&] (bool value) { parametersData->addItem(value); }

            );

        }

        action->setParameters(WTFMove(parametersData));

    }

    data->actions->addItem(WTFMove(action));

}

void InspectorCanvasAgent::didFinishRecordingCanvas(HTMLCanvasElement& canvasElement, bool fromConsole)

{

    CanvasEntry* canvasEntry = getCanvasEntry(canvasElement);

    if (!canvasEntry) {

        clearRecordingData(canvasElement);

        return;

    }

    CanvasRecordingData* data = getRecordingData(*canvasEntry->element);

    if (!data) {

        clearRecordingData(canvasElement);

        return;

    }

    if (!fromConsole && data->fromConsole)

        return;

    m_frontendDispatcher->recordingFinished(canvasEntry->identifier, data->initialState, data->actions);

    clearRecordingData(canvasElement);

}

void InspectorCanvasAgent::canvasDestroyed(HTMLCanvasElement& canvasElement)

{

    auto it = m_canvasEntries.find(&canvasElement);

@@void InspectorCanvasAgent::canvasDestroyed(HTMLCanvasElement& canvasElement)

    // the frontend from making JS allocations while the GC is still active.

    m_removedCanvasIdentifiers.append(canvasIdentifier);

291 if (!m_timer.isActive())

292 m_timer.startOneShot(0_s);

529 if (!m_canvasDestroyedTimer.isActive())

530 m_canvasDestroyedTimer.startOneShot(0_s);

}

void InspectorCanvasAgent::canvasDestroyedTimerFired()

@@void InspectorCanvasAgent::canvasDestroyedTimerFired()

    m_removedCanvasIdentifiers.clear();

}

void InspectorCanvasAgent::canvasRecordingTimerFired()

{

    for (HTMLCanvasElement* canvasElement : m_recordingData.keys()) {

        if (canvasElement->recordingState() != HTMLCanvasElement::RecordingState::Active)

            continue;

        didFinishRecordingCanvas(*canvasElement);

    }

}

void InspectorCanvasAgent::clearCanvasData()

{

    for (auto* canvasElement : m_canvasEntries.keys())

@@void InspectorCanvasAgent::clearCanvasData()

    m_canvasEntries.clear();

    m_canvasToCSSCanvasId.clear();

    m_removedCanvasIdentifiers.clear();

562 m_recordingData.clear();

314563

315 if (m_timer.isActive())

316 m_timer.stop();

    if (m_canvasRecordingTimer.isActive())

        m_canvasRecordingTimer.stop();

    if (m_canvasDestroyedTimer.isActive())

        m_canvasDestroyedTimer.stop();

}

void InspectorCanvasAgent::clearRecordingData(HTMLCanvasElement& canvasElement)

{

    canvasElement.setRecordingState(HTMLCanvasElement::RecordingState::Inactive);

    auto it = m_recordingData.find(&canvasElement);

    if (it != m_recordingData.end())

        m_recordingData.remove(it);

    if (m_canvasRecordingTimer.isActive())

        m_canvasRecordingTimer.stop();

}

InspectorCanvasAgent::CanvasEntry* InspectorCanvasAgent::getCanvasEntry(HTMLCanvasElement& canvasElement)

@@InspectorCanvasAgent::CanvasEntry* InspectorCanvasAgent::getCanvasEntry(const St

    return nullptr;

}

InspectorCanvasAgent::CanvasRecordingData* InspectorCanvasAgent::getRecordingData(HTMLCanvasElement& canvasElement)

{

    auto findResult = m_recordingData.find(&canvasElement);

    if (findResult == m_recordingData.end())

        return nullptr;

    return &findResult->value;

}

Ref<Inspector::Protocol::Canvas::Canvas> InspectorCanvasAgent::buildObjectForCanvas(const CanvasEntry& canvasEntry, HTMLCanvasElement& canvasElement)

{

    Frame* frame = canvasElement.document().frame();

Source/WebCore/inspector/InspectorCanvasAgent.h

#pragma once

#include "HTMLCanvasElement.h"

29#include "InspectorCanvasActionTypes.h"

#include "InspectorWebAgentBase.h"

#include "Timer.h"

#include <inspector/InspectorBackendDispatchers.h>

#include <inspector/InspectorFrontendDispatchers.h>

34#include <inspector/InspectorProtocolObjects.h>

#include <wtf/HashMap.h>

#include <wtf/HashSet.h>

#include <wtf/RefPtr.h>

@@public:

    void requestContent(ErrorString&, const String& canvasId, String* content) override;

    void maxPixelMemory(ErrorString&, double* maxPixelMemory) override;

    void resolveCanvasContext(ErrorString&, const String& canvasId, const String* const objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) override;

70 void toggleRecording(ErrorString&, const String& canvasId, bool flag) override;

    // InspectorInstrumentation

    void frameNavigated(Frame&);

    void didCreateCSSCanvas(HTMLCanvasElement&, const String&);

    void didCreateCanvasRenderingContext(HTMLCanvasElement&);

    void didChangeCanvasMemory(HTMLCanvasElement&);

    void didStartRecordingCanvas(HTMLCanvasElement&, bool = false);

    void recordCanvasAction(HTMLCanvasElement&, const String&, Vector<Canvas2DParameterVariant>&& = { });

    void didFinishRecordingCanvas(HTMLCanvasElement&, bool = false);

    // CanvasObserver

    void canvasChanged(HTMLCanvasElement&, const FloatRect&) override { }

@@private:

        }

    };

    struct CanvasRecordingData {

        RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Canvas::RecordingAction>> actions;

        RefPtr<Inspector::Protocol::Canvas::InitialState> initialState;

        bool fromConsole { true };

        CanvasRecordingData() { }

        CanvasRecordingData(Ref<Inspector::Protocol::Canvas::InitialState>&& initialState, bool fromConsole)

            : actions(Inspector::Protocol::Array<Inspector::Protocol::Canvas::RecordingAction>::create())

            , initialState(WTFMove(initialState))

            , fromConsole(fromConsole)

        {

        }

    };

95116 void canvasDestroyedTimerFired();

117 void canvasRecordingTimerFired();

96118 void clearCanvasData();

119 void clearRecordingData(HTMLCanvasElement&);

97120 CanvasEntry* getCanvasEntry(HTMLCanvasElement&);

98121 CanvasEntry* getCanvasEntry(const String&);

122 CanvasRecordingData* getRecordingData(HTMLCanvasElement&);

    Ref<Inspector::Protocol::Canvas::Canvas> buildObjectForCanvas(const CanvasEntry&, HTMLCanvasElement&);

    std::unique_ptr<Inspector::CanvasFrontendDispatcher> m_frontendDispatcher;

@@private:

    HashMap<HTMLCanvasElement*, CanvasEntry> m_canvasEntries;

    HashMap<HTMLCanvasElement*, String> m_canvasToCSSCanvasId;

132 HashMap<HTMLCanvasElement*, CanvasRecordingData> m_recordingData;

133 Timer m_canvasRecordingTimer;

108134 Vector<String> m_removedCanvasIdentifiers;

109 Timer m_timer;

135 Timer m_canvasDestroyedTimer;

136

    bool m_enabled { false };

};

Source/WebCore/inspector/InspectorInstrumentation.cpp

@@void InspectorInstrumentation::didChangeCanvasMemoryImpl(InstrumentingAgents* in

        canvasAgent->didChangeCanvasMemory(canvasElement);

}

void InspectorInstrumentation::didStartRecordingCanvasImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement, bool fromConsole)

{

    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())

        canvasAgent->didStartRecordingCanvas(canvasElement, fromConsole);

}

void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement, const String& name, Vector<Canvas2DParameterVariant>&& parameters)

{

    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())

        canvasAgent->recordCanvasAction(canvasElement, name, WTFMove(parameters));

}

void InspectorInstrumentation::didFinishRecordingCanvasImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement, bool fromConsole)

{

    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())

        canvasAgent->didFinishRecordingCanvas(canvasElement, fromConsole);

}

#if ENABLE(WEB_REPLAY)

void InspectorInstrumentation::sessionCreatedImpl(InstrumentingAgents& instrumentingAgents, RefPtr<ReplaySession>&& session)

{

Source/WebCore/inspector/InspectorInstrumentation.h

#include "Frame.h"

#include "HTMLCanvasElement.h"

#include "HitTestResult.h"

41#include "InspectorCanvasActionTypes.h"

#include "InspectorController.h"

#include "InspectorInstrumentationCookie.h"

#include "Page.h"

@@public:

    static void didCreateCSSCanvas(HTMLCanvasElement&, const String&);

    static void didCreateCanvasRenderingContext(HTMLCanvasElement&);

    static void didChangeCanvasMemory(HTMLCanvasElement&);

    static void didStartRecordingCanvas(HTMLCanvasElement&, bool = false);

    static void recordCanvasAction(HTMLCanvasElement&, const String&, Vector<Canvas2DParameterVariant>&& = { });

    static void didFinishRecordingCanvas(HTMLCanvasElement&, bool  = false);

    static void networkStateChanged(Page&);

    static void updateApplicationCacheStatus(Frame*);

@@private:

    static void didCreateCSSCanvasImpl(InstrumentingAgents*, HTMLCanvasElement&, const String&);

    static void didCreateCanvasRenderingContextImpl(InstrumentingAgents*, HTMLCanvasElement&);

    static void didChangeCanvasMemoryImpl(InstrumentingAgents*, HTMLCanvasElement&);

    static void didStartRecordingCanvasImpl(InstrumentingAgents*, HTMLCanvasElement&, bool = false);

    static void recordCanvasActionImpl(InstrumentingAgents*, HTMLCanvasElement&, const String&, Vector<Canvas2DParameterVariant>&& = { });

    static void didFinishRecordingCanvasImpl(InstrumentingAgents*, HTMLCanvasElement&, bool = false);

    static void layerTreeDidChangeImpl(InstrumentingAgents&);

    static void renderLayerDestroyedImpl(InstrumentingAgents&, const RenderLayer&);

@@inline void InspectorInstrumentation::didCreateCanvasRenderingContext(HTMLCanvas

inline void InspectorInstrumentation::didChangeCanvasMemory(HTMLCanvasElement& canvasElement)

{

1207 FAST_RETURN_IF_NO_FRONTENDS(void());

    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))

        didChangeCanvasMemoryImpl(instrumentingAgents, canvasElement);

}

inline void InspectorInstrumentation::didStartRecordingCanvas(HTMLCanvasElement& canvasElement, bool fromConsole)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))

        didStartRecordingCanvasImpl(instrumentingAgents, canvasElement, fromConsole);

}

inline void InspectorInstrumentation::recordCanvasAction(HTMLCanvasElement& canvasElement, const String& name, Vector<Canvas2DParameterVariant>&& parameters)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))

        recordCanvasActionImpl(instrumentingAgents, canvasElement, name, WTFMove(parameters));

}

inline void InspectorInstrumentation::didFinishRecordingCanvas(HTMLCanvasElement& canvasElement, bool fromConsole)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))

        didFinishRecordingCanvasImpl(instrumentingAgents, canvasElement, fromConsole);

}

inline void InspectorInstrumentation::networkStateChanged(Page& page)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

Source/WebCore/page/PageConsoleClient.cpp

#include "config.h"

#include "PageConsoleClient.h"

32#include "CanvasRenderingContext2D.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Document.h"

#include "Frame.h"

37#include "HTMLCanvasElement.h"

3638#include "InspectorController.h"

3739#include "InspectorInstrumentation.h"

40#include "JSCanvasRenderingContext2D.h"

41#include "JSHTMLCanvasElement.h"

#include "JSMainThreadExecState.h"

#include "MainFrame.h"

#include "Page.h"

#include "ScriptableDocumentParser.h"

#include "Settings.h"

47#include <bindings/ScriptValue.h>

#include <inspector/ConsoleMessage.h>

#include <inspector/ScriptArguments.h>

#include <inspector/ScriptCallStack.h>

#include <inspector/ScriptCallStackFactory.h>

52#include <runtime/JSCInlines.h>

using namespace Inspector;

@@void PageConsoleClient::timeStamp(JSC::ExecState*, Ref<ScriptArguments>&& argume

    InspectorInstrumentation::consoleTimeStamp(m_page.mainFrame(), WTFMove(arguments));

}

void PageConsoleClient::record(JSC::ExecState*, Ref<ScriptArguments>&& arguments)

{

    if (arguments->argumentCount() < 1)

        return;

    const JSC::JSValue& firstArgument = arguments->argumentAt(0).jsValue();

    if (!firstArgument.isObject())

        return;

    JSC::VM& vm = *firstArgument.getObject()->vm();

    JSC::JSObject* object = firstArgument.getObject();

    if (HTMLCanvasElement* canvasElement = JSHTMLCanvasElement::toWrapped(vm, object))

        InspectorInstrumentation::didStartRecordingCanvas(*canvasElement, true);

    else if (CanvasRenderingContext2D* context2d = JSCanvasRenderingContext2D::toWrapped(vm, object))

        InspectorInstrumentation::didStartRecordingCanvas(context2d->canvas(), true);

}

void PageConsoleClient::recordEnd(JSC::ExecState*, Ref<ScriptArguments>&& arguments)

{

    if (arguments->argumentCount() < 1)

        return;

    const JSC::JSValue& firstArgument = arguments->argumentAt(0).jsValue();

    if (!firstArgument.isObject())

        return;

    JSC::VM& vm = *firstArgument.getObject()->vm();

    JSC::JSObject* object = firstArgument.getObject();

    if (HTMLCanvasElement* canvasElement = JSHTMLCanvasElement::toWrapped(vm, object))

        InspectorInstrumentation::didFinishRecordingCanvas(*canvasElement, true);

    else if (CanvasRenderingContext2D* context2d = JSCanvasRenderingContext2D::toWrapped(vm, object))

        InspectorInstrumentation::didFinishRecordingCanvas(context2d->canvas(), true);

}

211251} // namespace WebCore

Source/WebCore/page/PageConsoleClient.h

@@protected:

    void time(JSC::ExecState*, const String& title) override;

    void timeEnd(JSC::ExecState*, const String& title) override;

    void timeStamp(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

77 void record(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

78 void recordEnd(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

private:

    Page& m_page;

Source/WebCore/platform/graphics/Gradient.h

@@namespace WebCore {

                { }

        };

149 const Vector<ColorStop, 2>& stops() const { return m_stops; }

150

        void setStopsSorted(bool s) { m_stopsSorted = s; }

        void setSpreadMethod(GradientSpreadMethod);

Source/WebCore/svg/SVGPathUtilities.cpp

@@bool buildPathFromString(const String& d, Path& result)

    return SVGPathParser::parse(source, builder);

}

bool buildStringFromPath(const Path& path, String& result)

{

    if (path.isNull() || path.isEmpty())

        return false;

    StringBuilder builder;

    path.apply([&builder] (const PathElement& element) {

        switch (element.type) {

        case PathElementMoveToPoint: // The points member will contain 1 value.

            builder.append('M');

            builder.appendNumber(element.points[0].x());

            builder.append(' ');

            builder.appendNumber(element.points[0].y());

            break;

        case PathElementAddLineToPoint: // The points member will contain 1 value.

            builder.append('L');

            builder.appendNumber(element.points[0].x());

            builder.append(' ');

            builder.appendNumber(element.points[0].y());

            break;

        case PathElementAddQuadCurveToPoint: // The points member will contain 2 values.

            builder.append('Q');

            builder.appendNumber(element.points[0].x());

            builder.append(' ');

            builder.appendNumber(element.points[0].y());

            builder.append(',');

            builder.appendNumber(element.points[1].x());

            builder.append(' ');

            builder.appendNumber(element.points[1].y());

            break;

        case PathElementAddCurveToPoint: // The points member will contain 3 values.

            builder.append('C');

            builder.appendNumber(element.points[0].x());

            builder.append(' ');

            builder.appendNumber(element.points[0].y());

            builder.append(',');

            builder.appendNumber(element.points[1].x());

            builder.append(' ');

            builder.appendNumber(element.points[1].y());

            builder.append(',');

            builder.appendNumber(element.points[2].x());

            builder.append(' ');

            builder.appendNumber(element.points[2].y());

            break;

        case PathElementCloseSubpath: // The points member will contain no values.

            break;

        }

    });

    result = builder.toString();

    return true;

}

bool buildSVGPathByteStreamFromSVGPathSegListValues(const SVGPathSegListValues& list, SVGPathByteStream& result, PathParsingMode parsingMode)

{

    result.clear();

Source/WebCore/svg/SVGPathUtilities.h

@@class SVGPathSegListValues;

bool buildPathFromString(const String&, Path&);

bool buildPathFromByteStream(const SVGPathByteStream&, Path&);

// Path -> String

bool buildStringFromPath(const Path&, String&);

// SVGPathSegListValues/String -> SVGPathByteStream

bool buildSVGPathByteStreamFromSVGPathSegListValues(const SVGPathSegListValues&, SVGPathByteStream& result, PathParsingMode);

bool appendSVGPathByteStreamFromSVGPathSeg(RefPtr<SVGPathSeg>&&, SVGPathByteStream&, PathParsingMode);

Source/WebCore/workers/WorkerConsoleClient.cpp

@@void WorkerConsoleClient::profileEnd(JSC::ExecState*, const String&) { }

void WorkerConsoleClient::takeHeapSnapshot(JSC::ExecState*, const String&) { }

void WorkerConsoleClient::timeStamp(JSC::ExecState*, Ref<ScriptArguments>&&) { }

void WorkerConsoleClient::record(JSC::ExecState*, Ref<ScriptArguments>&&) { };

void WorkerConsoleClient::recordEnd(JSC::ExecState*, Ref<ScriptArguments>&&) { };

7982} // namespace WebCore

Source/WebCore/workers/WorkerConsoleClient.h

@@protected:

    void time(JSC::ExecState*, const String& title) override;

    void timeEnd(JSC::ExecState*, const String& title) override;

    void timeStamp(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

53 void record(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

54 void recordEnd(JSC::ExecState*, Ref<Inspector::ScriptArguments>&&) override;

private:

    WorkerGlobalScope& m_workerGlobalScope;

Source/WebInspectorUI/.eslintrc

        "timestamp": true,

        "handlePromiseException": true,

        "insertObjectIntoSortedArray": true,

106 "numericStringComparator": true,

        // Image Utilities

        "platformImagePath": true,

Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js

@@localizedStrings["Call Trees"] = "Call Trees";

localizedStrings["Calls"] = "Calls";

localizedStrings["Cancel Automatic Continue"] = "Cancel Automatic Continue";

localizedStrings["Cancel comparison"] = "Cancel comparison";

151localizedStrings["Cancel recording of next active draw frame (%s)"] = "Cancel recording of next active draw frame (%s)";

localizedStrings["Canvas"] = "Canvas";

localizedStrings["Canvas %d"] = "Canvas %d";

localizedStrings["Canvas %s"] = "Canvas %s";

@@localizedStrings["Count"] = "Count";

localizedStrings["Create %s Rule"] = "Create %s Rule";

localizedStrings["Create a new tab"] = "Create a new tab";

localizedStrings["Current"] = "Current";

248localizedStrings["Current State"] = "Current State";

localizedStrings["Cursor"] = "Cursor";

localizedStrings["Custom"] = "Custom";

localizedStrings["DNS"] = "DNS";

@@localizedStrings["Expand All"] = "Expand All";

localizedStrings["Expand columns"] = "Expand columns";

localizedStrings["Expanded"] = "Expanded";

localizedStrings["Expires"] = "Expires";

375localizedStrings["Export"] = "Export";

localizedStrings["Expression"] = "Expression";

localizedStrings["Extension Scripts"] = "Extension Scripts";

localizedStrings["Extra Scripts"] = "Extra Scripts";

@@localizedStrings["File or Resource"] = "File or Resource";

localizedStrings["Filename"] = "Filename";

localizedStrings["Fill"] = "Fill";

localizedStrings["Fill Mode"] = "Fill Mode";

390localizedStrings["Filter Actions"] = "Filter Actions";

localizedStrings["Filter Console Log"] = "Filter Console Log";

localizedStrings["Filter List"] = "Filter List";

localizedStrings["Filter Records"] = "Filter Records";

@@localizedStrings["Image"] = "Image";

localizedStrings["Image Size"] = "Image Size";

localizedStrings["Images"] = "Images";

localizedStrings["Immediate Pause Requested"] = "Immediate Pause Requested";

467localizedStrings["Import"] = "Import";

localizedStrings["Indent"] = "Indent";

localizedStrings["Indent width:"] = "Indent width:";

localizedStrings["Index"] = "Index";

@@localizedStrings["Indexed Databases"] = "Indexed Databases";

localizedStrings["Info: "] = "Info: ";

localizedStrings["Inherited From: "] = "Inherited From: ";

localizedStrings["Inherited from %s"] = "Inherited from %s";

476localizedStrings["Initial State"] = "Initial State";

localizedStrings["Initial Velocity"] = "Initial Velocity";

localizedStrings["Initiated"] = "Initiated";

localizedStrings["Initiator"] = "Initiator";

@@localizedStrings["Key"] = "Key";

localizedStrings["Key Path"] = "Key Path";

localizedStrings["Label"] = "Label";

localizedStrings["Latency"] = "Latency";

493 localizedStrings["Layer"] = "Layer";

localizedStrings["Layer Count: %d"] = "Layer Count: %d";

localizedStrings["Layer Info"] = "Layer Info";

localizedStrings["Layers"] = "Layers";

@@localizedStrings["No Preview Available"] = "No Preview Available";

localizedStrings["No Properties"] = "No Properties";

localizedStrings["No Properties \u2014 Click to Edit"] = "No Properties \u2014 Click to Edit";

localizedStrings["No Query Parameters"] = "No Query Parameters";

587localizedStrings["No Recording Data"] = "No Recording Data";

localizedStrings["No Request Headers"] = "No Request Headers";

localizedStrings["No Response Headers"] = "No Response Headers";

localizedStrings["No Results Found"] = "No Results Found";

@@localizedStrings["Range Issue"] = "Range Issue";

localizedStrings["Readonly"] = "Readonly";

localizedStrings["Reasons for compositing:"] = "Reasons for compositing:";

localizedStrings["Recently Closed Tabs"] = "Recently Closed Tabs";

677localizedStrings["Recording"] = "Recording";

671678localizedStrings["Recording Timeline Data"] = "Recording Timeline Data";

679localizedStrings["Recording error: %s"] = "Recording error: %s";

localizedStrings["Reference Issue"] = "Reference Issue";

localizedStrings["Reflection"] = "Reflection";

localizedStrings["Refresh"] = "Refresh";

@@localizedStrings["Request"] = "Request";

localizedStrings["Request & Response"] = "Request & Response";

localizedStrings["Request Data"] = "Request Data";

localizedStrings["Request Headers"] = "Request Headers";

703localizedStrings["Request recording of next active draw frame (%s)"] = "Request recording of next active draw frame (%s)";

localizedStrings["Requesting: %s"] = "Requesting: %s";

localizedStrings["Required"] = "Required";

localizedStrings["Reset"] = "Reset";

@@localizedStrings["spaces"] = "spaces";

localizedStrings["time before stopping"] = "time before stopping";

localizedStrings["times before stopping"] = "times before stopping";

localizedStrings["toggle"] = "toggle";

967localizedStrings["unsupported version"] = "unsupported version";

958968localizedStrings["value"] = "value";

959969localizedStrings["“%s” Profile Recorded"] = "“%s” Profile Recorded";

970localizedStrings["“%s” is invalid"] = "“%s” is invalid";

Source/WebInspectorUI/UserInterface/Base/Main.js

@@WebInspector.contentLoaded = function()

        WebInspector.ElementsTabContentView,

        WebInspector.NetworkTabContentView,

        WebInspector.NewTabContentView,

447 WebInspector.RecordingTabContentView,

        WebInspector.ResourcesTabContentView,

        WebInspector.SearchTabContentView,

        WebInspector.SettingsTabContentView,

@@WebInspector.contentLoaded = function()

        let tabContentView = this._createTabContentViewForType(tabType);

        if (!tabContentView)

            continue;

481 this.tabBrowser.addTabForContentView(tabContentView, true);

482 this.tabBrowser.addTabForContentView(tabContentView, {doNotAnimate: true});

    }

    this._restoreCookieForOpenTabs(WebInspector.StateRestorationType.Load);

@@WebInspector.contentLoaded = function()

// This function returns a lazily constructed instance of a class scoped to this WebInspector

// instance. In the unlikely event that we ever need to construct multiple WebInspector instances

// this allows us to scope objects within the WebInspector.

522// Classes can prevent usage of this function via a static `disallowInstanceForClass` function that

523// returns true. It is then their responsibility to ensure that the returned value is tracked.

// Currently it is only used for sidebars.

WebInspector.instanceForClass = function(constructor)

{

    console.assert(typeof constructor === "function");

528 if (typeof constructor.disallowInstanceForClass === "function" && constructor.disallowInstanceForClass())

529 return new constructor;

    let key = `__${constructor.name}`;

    if (!WebInspector[key])

@@WebInspector._tryToRestorePendingTabs = function()

        if (!tabContentView)

            continue;

619 this.tabBrowser.addTabForContentView(tabContentView, true, index);

        this.tabBrowser.addTabForContentView(tabContentView, {

            doNotAnimate: true,

            insertionIndex: index,

        });

        tabContentView.restoreStateFromCookie(WebInspector.StateRestorationType.Load);

    }

@@WebInspector.showNewTabTab = function(shouldAnimate)

    let tabContentView = this.tabBrowser.bestTabContentViewForClass(WebInspector.NewTabContentView);

    if (!tabContentView)

        tabContentView = new WebInspector.NewTabContentView;

637 this.tabBrowser.showTabForContentView(tabContentView, !shouldAnimate);

645 this.tabBrowser.showTabForContentView(tabContentView, {doNotAnimate: !shouldAnimate});

};

WebInspector.isNewTabWithTypeAllowed = function(tabType)

@@WebInspector.createNewTabWithType = function(tabType, options = {})

    console.assert(!shouldReplaceTab || referencedView, "Must provide a reference view to replace a tab.");

    let tabContentView = this._createTabContentViewForType(tabType);

    const suppressAnimations = true;

    let insertionIndex = referencedView ? this.tabBar.tabBarItems.indexOf(referencedView.tabBarItem) : undefined;

    this.tabBrowser.addTabForContentView(tabContentView, suppressAnimations, insertionIndex);

    const doNotAnimate = true;

    this.tabBrowser.addTabForContentView(tabContentView, {

        doNotAnimate,

        insertionIndex: referencedView ? this.tabBar.tabBarItems.indexOf(referencedView.tabBarItem) : undefined,

    });

677687

678688 if (shouldReplaceTab)

679 this.tabBrowser.closeTabForContentView(referencedView, ~~suppress~~Animat~~ions~~);

689 this.tabBrowser.closeTabForContentView(referencedView, {doNotAnimate});

    if (shouldShowNewTab)

        this.tabBrowser.showTabForContentView(tabContentView);

@@WebInspector.saveDataToFile = function(saveData, forceSaveAs)

    });

};

WebInspector.loadDataFromFile = function(callback)

{

    let inputElement = document.createElement("input");

    inputElement.type = "file";

    inputElement.addEventListener("change", (event) => {

        if (!inputElement.files.length)

            return;

        let reader = new FileReader;

        reader.addEventListener("loadend", (event) => {

            callback(reader.result);

        });

        reader.readAsText(inputElement.files[0]);

    });

    inputElement.click();

};

WebInspector.isConsoleFocused = function()

{

    return this.quickConsole.prompt.focused;

@@WebInspector.tabContentViewClassForRepresentedObject = function(representedObjec

        representedObject instanceof WebInspector.IndexedDatabaseObjectStoreIndex)

        return WebInspector.ResourcesTabContentView;

1149 if (representedObject instanceof WebInspector.~~Collect~~ion)

1150 return WebInspector.~~Collect~~ionContentView;

1176 if (representedObject instanceof WebInspector.Recording)

1177 return WebInspector.RecordingTabContentView;

    return null;

};

@@WebInspector.showRepresentedObject = function(representedObject, cookie, options

    if (!tabContentView)

        return;

1181 this.tabBrowser.showTabForContentView(tabContentView);

1208 this.tabBrowser.showTabForContentView(tabContentView, options);

    tabContentView.showRepresentedObject(representedObject, cookie);

};

Source/WebInspectorUI/UserInterface/Base/Utilities.js

@@function insertObjectIntoSortedArray(object, array, comparator)

    array.splice(insertionIndexForObjectInListSortedByFunction(object, array, comparator), 0, object);

}

function numericStringComparator(a, b)

{

    return a.localeCompare(b, undefined, {numeric: true});

}

function decodeBase64ToBlob(base64Data, mimeType)

{

    mimeType = mimeType || '';

Source/WebInspectorUI/UserInterface/Controllers/CanvasManager.js

@@WebInspector.CanvasManager = class CanvasManager extends WebInspector.Object

        if (window.CanvasAgent)

            CanvasAgent.enable();

38

39 this._revealNextRecording = false;

    }

    // Public

@@WebInspector.CanvasManager = class CanvasManager extends WebInspector.Object

        return [...this._canvasIdentifierMap.values()];

    }

49 set revealNextRecording(flag) { this._revealNextRecording = !!flag; }

50

    canvasAdded(canvasPayload)

    {

        // Called from WebInspector.CanvasObserver.

@@WebInspector.CanvasManager = class CanvasManager extends WebInspector.Object

        this.dispatchEventToListeners(WebInspector.CanvasManager.Event.CanvasMemoryChanged, {canvas});

    }

    recordingFinished(canvasIdentifier, initialState, actions)

    {

        // Called from WebInspector.CanvasObserver.

        let canvas = this._canvasIdentifierMap.get(canvasIdentifier);

        console.assert(canvas);

        if (!canvas)

            return;

        this.dispatchEventToListeners(WebInspector.CanvasManager.Event.RecordingFinished, {canvas});

        let recording = WebInspector.Recording.fromPayload({

            type: WebInspector.Recording.Type.Canvas2D,

            initialState,

            actions,

        });

        WebInspector.showRepresentedObject(recording, null, {skipReveal: !this._revealNextRecording});

        this._revealNextRecording = false;

    }

    // Private

    _mainResourceDidChange(event)

@@WebInspector.CanvasManager.Event = {

    CanvasWasAdded: "canvas-manager-canvas-was-added",

    CanvasWasRemoved: "canvas-manager-canvas-was-removed",

    CanvasMemoryChanged: "canvas-manager-canvas-memory-changed",

136 RecordingFinished: "canvas-managger-recording-finished",

111137};

Source/WebInspectorUI/UserInterface/Images/Recording.svg

<?xml version="1.0" encoding="utf-8"?>

<!-- Copyright © 2017 Apple Inc. All rights reserved. -->

<svg xmlns="http://www.w3.org/2000/svg" id="root" version="1.1" viewBox="0 0 16 16">

    <path fill="currentColor" d="M 13 1 L 3 1 C 1.898438 1 1 1.898438 1 3 L 1 13 C 1 14.101562 1.898438 15 3 15 L 13 15 C 14.101562 15 15 14.101562 15 13 L 15 3 C 15 1.898438 14.101562 1 13 1 M 13 2 C 13.550781 2 14 2.449219 14 3 L 14 13 C 14 13.550781 13.550781 14 13 14 L 3 14 C 2.449219 14 2 13.550781 2 13 L 2 3 C 2 2.449219 2.449219 2 3 2 L 13 2"/>

    <rect fill="currentColor" x="4.25" y="4.5" width="7.5" height="1"/>

    <rect fill="currentColor" x="4.25" y="6.5" width="7.5" height="1"/>

    <rect fill="currentColor" x="4.25" y="8.5" width="7.5" height="1"/>

    <rect fill="currentColor" x="4.25" y="10.5" width="7.5" height="1"/>

</svg>

Source/WebInspectorUI/UserInterface/Main.html

    <link rel="stylesheet" href="Views/ProfileView.css">

    <link rel="stylesheet" href="Views/QuickConsole.css">

    <link rel="stylesheet" href="Views/RadioButtonNavigationItem.css">

    <link rel="stylesheet" href="Views/RecordingContentView.css">

    <link rel="stylesheet" href="Views/RecordingDetailsSidebarPanel.css">

    <link rel="stylesheet" href="Views/RecordingNavigationSidebarPanel.css">

    <link rel="stylesheet" href="Views/RenderingFrameTimelineOverviewGraph.css">

    <link rel="stylesheet" href="Views/RenderingFrameTimelineView.css">

    <link rel="stylesheet" href="Views/ReplayDashboardView.css">

    <link rel="stylesheet" href="Views/Sidebar.css">

    <link rel="stylesheet" href="Views/SidebarPanel.css">

    <link rel="stylesheet" href="Views/Slider.css">

166 <link rel="stylesheet" href="Views/ScrubberNavigationItem.css">

    <link rel="stylesheet" href="Views/SoftContextMenu.css">

    <link rel="stylesheet" href="Views/SourceCodeTextEditor.css">

    <link rel="stylesheet" href="Views/SpringEditor.css">

    <script src="Models/BreakpointAction.js"></script>

    <script src="Models/ConsoleMessage.js"></script>

    <script src="Models/Instrument.js"></script>

    <script src="Models/Recording.js"></script>

    <script src="Models/RecordingAction.js"></script>

    <script src="Models/RecordingInitialStateAction.js"></script>

    <script src="Models/SourceCode.js"></script>

    <script src="Models/SourceCodeLocation.js"></script>

    <script src="Models/Timeline.js"></script>

    <script src="Views/ConsoleTabContentView.js"></script>

    <script src="Views/DebuggerTabContentView.js"></script>

    <script src="Views/ElementsTabContentView.js"></script>

485 <script src="Views/RecordingTabContentView.js"></script>

    <script src="Views/ResourceTreeElement.js"></script>

    <script src="Views/ResourcesTabContentView.js"></script>

    <script src="Views/SearchTabContentView.js"></script>

    <script src="Views/QuickConsole.js"></script>

    <script src="Views/QuickConsoleNavigationBar.js"></script>

    <script src="Views/RadioButtonNavigationItem.js"></script>

    <script src="Views/RecordingContentView.js"></script>

    <script src="Views/RecordingDetailsSidebarPanel.js"></script>

    <script src="Views/RecordingNavigationSidebarPanel.js"></script>

    <script src="Views/RenderingFrameTimelineDataGridNode.js"></script>

    <script src="Views/RenderingFrameTimelineOverviewGraph.js"></script>

    <script src="Views/RenderingFrameTimelineView.js"></script>

    <script src="Views/SearchSidebarPanel.js"></script>

    <script src="Views/Sidebar.js"></script>

    <script src="Views/Slider.js"></script>

684 <script src="Views/ScrubberNavigationItem.js"></script>

    <script src="Views/SoftContextMenu.js"></script>

    <script src="Views/SourceCodeTextEditor.js"></script>

    <script src="Views/SourceCodeTimelineTimelineDataGridNode.js"></script>

Source/WebInspectorUI/UserInterface/Models/Canvas.js

@@WebInspector.Canvas = class Canvas extends WebInspector.Object

        });

    }

    toggleRecording(flag, callback)

    {

        CanvasAgent.toggleRecording(this._identifier, flag, (error) => {

            callback(error);

        });

    }

    saveIdentityToCookie(cookie)

    {

        cookie[WebInspector.Canvas.FrameURLCookieKey] = this._frame.url.hash;

Source/WebInspectorUI/UserInterface/Models/NativeFunctionParameters.js

@@WebInspector.NativeConstructorFunctionParameters = {

        time: "name = \"default\"",

        timeEnd: "name = \"default\"",

        timeStamp: "[label]",

182 record: "object",

183 recordEnd: "object",

        trace: "message, [...values]",

        warn: "message, [...values]",

        __proto__: null,

Source/WebInspectorUI/UserInterface/Models/Recording.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.Recording = class Recording extends WebInspector.Object

{

    constructor(type, initialState, actions)

    {

        super();

        console.assert(typeof initialState === "object");

        console.assert(Array.isArray(actions));

        this._type = String(type);

        this._initialState = typeof initialState === "object" ? initialState : {};

        this._actions = Array.isArray(actions) ? actions : [];

        this._actions.unshift(new WebInspector.RecordingInitialStateAction(WebInspector.UIString("Initial State")));

    }

    // Static

    static fromPayload(payload)

    {

        let initialState = {

            attributes: payload.initialState.attributes || {},

            functions: payload.initialState.functions || {},

            content: payload.initialState.content || "",

        };

        let actions = payload.actions.map((actionPayload) => {

            let action = WebInspector.RecordingAction.fromPayload(actionPayload);

            if (payload.type === WebInspector.Recording.Type.Canvas2D) {

                if (!(action.name in CanvasRenderingContext2D.prototype) && action.name !== "width" && action.name !== "height") {

                    action.valid = false;

                    WebInspector.Recording.synthesizeError(WebInspector.UIString("“%s” is invalid").format(action.name));

                }

            }

            return action;

        });

        return new WebInspector.Recording(payload.type, initialState, actions);

    }

    static synthesizeError(message)

    {

        const target = WebInspector.mainTarget;

        const source = WebInspector.ConsoleMessage.MessageSource.Other;

        const level = WebInspector.ConsoleMessage.MessageLevel.Error;

        let consoleMessage = new WebInspector.ConsoleMessage(target, source, level, WebInspector.UIString("Recording error: %s").format(message));

        consoleMessage.shouldRevealConsole = true; // TODO

        WebInspector.consoleLogViewController.appendConsoleMessage(consoleMessage);

    }

    // Public

    get type() { return this._type; }

    get initialState() { return this._initialState; }

    get actions() { return this._actions; }

    toJSON()

    {

        let initialState = {};

        if (!isEmptyObject(this._initialState.attributes))

            initialState.attributes = this._initialState.attributes;

        if (!isEmptyObject(this._initialState.functions))

            initialState.functions = this._initialState.functions;

        if (this._initialState.content && this._initialState.content.length)

            initialState.content = this._initialState.content;

        return {

            version: WebInspector.Recording.Version,

            type: this._type,

            initialState,

            actions: this._actions.slice(1).map((action) => action.toJSON()),

        };

    }

};

WebInspector.Recording.Type = {

    Canvas2D: "canvas-2d",

};

WebInspector.Recording.Version = 1;

Source/WebInspectorUI/UserInterface/Models/RecordingAction.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingAction = class RecordingAction extends WebInspector.Object

{

    constructor(name, parameters)

    {

        super();

        console.assert(typeof name === "string");

        this._name = String(name);

        this._parameters = Array.isArray(parameters) ? parameters : [];

        this._valid = true;

    }

    // Static

    static fromPayload(payload)

    {

        return new WebInspector.RecordingAction(payload.name, payload.parameters);

    }

    // Public

    get name() { return this._name; }

    get parameters() { return this._parameters; }

    get valid() { return this._valid; }

    set valid(valid) { this._valid = !!valid; }

    unavailableParameterReplacementForType(type, parameterIndex)

    {

        let forType = WebInspector.RecordingAction._unavailableParameterReplacements[type];

        if (!forType)

            return null;

        let forFunction = forType[this._name];

        if (!forFunction)

            return null;

        let forArgumentsLength = forFunction[this._parameters.length];

        if (!forArgumentsLength)

            return null;

        return forArgumentsLength[parameterIndex] || null;

    }

    attributeForType(type)

    {

        let forType = WebInspector.RecordingAction._attributeNames[type];

        if (!forType)

            return false;

        return forType.includes(this._name);

    }

    visualForType(type)

    {

        let forType = WebInspector.RecordingAction._visualNames[type];

        if (!forType)

            return false;

        return forType.includes(this._name);

    }

    toJSON()

    {

        let json = {name: this._name};

        if (this._parameters.length)

            json.parameters = this._parameters;

        return json;

    }

};

WebInspector.RecordingAction._replacementData = {

    CanvasStyle: {

        name(data) {

            if (typeof data === "string")

                return data;

            if (data.type === "pattern")

                return "CanvasPattern";

            if (data.type === "linear-gradient" || data.type === "radial-gradient")

                return "CanvasGradient";

            return "";

        },

        callback(data, context) {

            if (typeof data === "string")

                return data;

            if (data.type === "pattern") {

                let image = new Image;

                image.src = data.image;

                return context.createPattern(image, data.repeat);

            }

            if (data.type === "linear-gradient" || data.type === "radial-gradient") {

                let gradient = data.type === "radial-gradient" ? context.createRadialGradient(...data.parameters) : context.createLinearGradient(...data.parameters);

                if (Array.isArray(data.stops)) {

                    for (let stop of data.stops)

                        gradient.addColorStop(...stop);

                }

                return gradient;

            }

            return null;

        },

    },

    Element: {

        name(data) { return "Element"; },

    },

    Image: {

        name(data) { return "Image"; },

        callback(data, context) {

            let image = new Image;

            image.src = data;

            return image;

        },

    },

    ImageData: {

        name(data) { return "ImageData"; },

        callback(data, context) { return new ImageData(new Uint8ClampedArray(data.data), data.width, data.height); },

    },

    Path2D: {

        name(data) { return "Path2D"; },

        callback(data, context) { return new Path2D(data); },

    },

};

WebInspector.RecordingAction._unavailableParameterReplacements = {

    [WebInspector.Recording.Type.Canvas2D]: {

        "clip": {

            2: {0: WebInspector.RecordingAction._replacementData.Path2D},

        },

        "createImageData": {

            1: {0: WebInspector.RecordingAction._replacementData.ImageData},

        },

        "createPattern": {

            2: {0: WebInspector.RecordingAction._replacementData.Image},

        },

        "drawImage": {

            3: {0: WebInspector.RecordingAction._replacementData.Image},

            5: {0: WebInspector.RecordingAction._replacementData.Image},

            9: {0: WebInspector.RecordingAction._replacementData.Image},

        },

        "drawImageFromRect": {

            10: {0: WebInspector.RecordingAction._replacementData.Image},

        },

        "drawFocusIfNeeded": {

            1: {0: WebInspector.RecordingAction._replacementData.Element},

            2: {0: WebInspector.RecordingAction._replacementData.Path2D, 1: WebInspector.RecordingAction._replacementData.Element},

        },

        "fill": {

            2: {0: WebInspector.RecordingAction._replacementData.Path2D},

        },

        "fillStyle": {

            1: {0: WebInspector.RecordingAction._replacementData.CanvasStyle},

        },

        "isPointInPath": {

            4: {0: WebInspector.RecordingAction._replacementData.Path2D},

        },

        "isPointInStroke": {

            3: {0: WebInspector.RecordingAction._replacementData.Path2D},

        },

        "putImageData": {

            3: {0: WebInspector.RecordingAction._replacementData.ImageData},

            7: {0: WebInspector.RecordingAction._replacementData.ImageData},

        },

        "stroke": {

            1: {0: WebInspector.RecordingAction._replacementData.Path2D},

        },

        "strokeStyle": {

            1: {0: WebInspector.RecordingAction._replacementData.CanvasStyle},

        },

        "webkitPutImageData": {

            3: {0: WebInspector.RecordingAction._replacementData.ImageData},

            7: {0: WebInspector.RecordingAction._replacementData.ImageData},

        },

    },

};

WebInspector.RecordingAction._attributeNames = {

    [WebInspector.Recording.Type.Canvas2D]: [

        "direction",

        "fillStyle",

        "font",

        "globalAlpha",

        "globalCompositeOperation",

        "height",

        "imageSmoothingEnabled",

        "imageSmoothingQuality",

        "lineCap",

        "lineDashOffset",

        "lineJoin",

        "lineWidth",

        "miterLimit",

        "shadowBlur",

        "shadowColor",

        "shadowOffsetX",

        "shadowOffsetY",

        "strokeStyle",

        "textAlign",

        "textBaseline",

        "webkitImageSmoothingEnabled",

        "webkitLineDash",

        "webkitLineDashOffset",

        "width",

    ],

};

WebInspector.RecordingAction._visualNames = {

    [WebInspector.Recording.Type.Canvas2D]: [

        "clearRect",

        "drawFocusIfNeeded",

        "drawImage",

        "drawImageFromRect",

        "fill",

        "fillRect",

        "fillText",

        "height",

        "putImageData",

        "stroke",

        "strokeRect",

        "strokeText",

        "webkitPutImageDataHD",

        "width",

    ],

};

Source/WebInspectorUI/UserInterface/Models/RecordingInitialStateAction.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingInitialStateAction = class RecordingInitialStateAction extends WebInspector.RecordingAction

{

    constructor(name)

    {

        const parameters = [];

        const properties = {"initial-state": true};

        super(name, parameters, properties);

        this.valid = false;

    }

};

Source/WebInspectorUI/UserInterface/Protocol/CanvasObserver.js

@@WebInspector.CanvasObserver = class CanvasObserver

    {

        WebInspector.canvasManager.canvasMemoryChanged(canvasId, memoryCost);

    }

    recordingFinished(canvasId, initialState, actions)

    {

        WebInspector.canvasManager.recordingFinished(canvasId, initialState, actions);

    }

4449};

Source/WebInspectorUI/UserInterface/Views/ApplicationCacheDetailsSidebarPanel.js

@@WebInspector.ApplicationCacheDetailsSidebarPanel = class ApplicationCacheDetails

{

    constructor()

    {

30 super("application-cache-details", WebInspector.UIString("Storage")~~, WebInspector.UIString("Storage")~~);

30 super("application-cache-details", WebInspector.UIString("Storage"));

        this.element.classList.add("application-cache");

Source/WebInspectorUI/UserInterface/Views/ApplicationCacheFrameTreeElement.js

@@WebInspector.ApplicationCacheFrameTreeElement = class ApplicationCacheFrameTreeE

    {

        console.assert(representedObject instanceof WebInspector.ApplicationCacheFrame);

32 super("application-cache-frame", "", "", representedObject~~, false~~);

32 super("application-cache-frame", "", "", representedObject);

        this.updateTitles();

    }

Source/WebInspectorUI/UserInterface/Views/BreakpointTreeElement.js

@@WebInspector.BreakpointTreeElement = class BreakpointTreeElement extends WebInsp

        if (!className)

            className = WebInspector.BreakpointTreeElement.GenericLineIconStyleClassName;

35 super(["breakpoint", className], title, null, breakpoint~~, false~~);

35 super(["breakpoint", className], title, null, breakpoint);

        this._breakpoint = breakpoint;

        this._probeSet = null;

Source/WebInspectorUI/UserInterface/Views/CSSStyleDetailsSidebarPanel.js

@@WebInspector.CSSStyleDetailsSidebarPanel = class CSSStyleDetailsSidebarPanel ext

{

    constructor()

    {

30 super("css-style", WebInspector.UIString("Styles"), WebInspector.UIString("Style"), null, true);

30 const dontCreateNavigationItem = true;

31 super("css-style", WebInspector.UIString("Styles"), dontCreateNavigationItem);

        this._selectedPanel = null;

        this._computedStyleDetailsPanel = new WebInspector.ComputedStyleDetailsPanel(this);

Source/WebInspectorUI/UserInterface/Views/CSSStyleSheetTreeElement.js

@@WebInspector.CSSStyleSheetTreeElement = class CSSStyleSheetTreeElement extends W

        const classNames = ["stylesheet", "stylesheet-icon"];

        const title = WebInspector.UIString("Inspector Style Sheet");

        const subtitle = null;

36 const hasChildren = false;

37 super(styleSheet, classNames, title, subtitle, styleSheet, hasChildren);

36 super(styleSheet, classNames, title, subtitle, styleSheet);

3837 }

3938};

Source/WebInspectorUI/UserInterface/Views/CallFrameTreeElement.js

@@WebInspector.CallFrameTreeElement = class CallFrameTreeElement extends WebInspec

        let className = WebInspector.CallFrameView.iconClassNameForCallFrame(callFrame);

        let title = callFrame.functionName || WebInspector.UIString("(anonymous function)");

35 super(["call-frame", className], title, null, callFrame~~, false~~);

35 super(["call-frame", className], title, null, callFrame);

        this._callFrame = callFrame;

        this._isActiveCallFrame = false;

Source/WebInspectorUI/UserInterface/Views/CanvasContentView.js

@@WebInspector.CanvasContentView = class CanvasContentView extends WebInspector.Co

        this._previewImageElement = null;

        this._errorElement = null;

        if (representedObject.contextType === WebInspector.Canvas.ContextType.Canvas2D) {

            const modifiers = null;

            this._toggleRequestRecordingShortcut = new WebInspector.KeyboardShortcut(modifiers, WebInspector.KeyboardShortcut.Key.Space, this._toggleRecording.bind(this));

            this._toggleRequestRecordingShortcut.implicitlyPreventsDefault = false;

            this._toggleRequestRecordingShortcut.disabled = true;

            let toolTip = WebInspector.UIString("Request recording of next active draw frame (%s)").format(this._toggleRequestRecordingShortcut.displayName);

            let altToolTip = WebInspector.UIString("Cancel recording of next active draw frame (%s)").format(this._toggleRequestRecordingShortcut.displayName);

            this._recordButtonNavigationItem = new WebInspector.ToggleButtonNavigationItem("canvas-record", toolTip, altToolTip, "Images/Record.svg", "Images/Stop.svg", 13, 13);

            this._recordButtonNavigationItem.addEventListener(WebInspector.ButtonNavigationItem.Event.Clicked, this._toggleRecording, this);

        }

        this._refreshButtonNavigationItem = new WebInspector.ButtonNavigationItem("canvas-refresh", WebInspector.UIString("Refresh"), "Images/ReloadFull.svg", 13, 13);

        this._refreshButtonNavigationItem.addEventListener(WebInspector.ButtonNavigationItem.Event.Clicked, this._showPreview, this);

@@WebInspector.CanvasContentView = class CanvasContentView extends WebInspector.Co

    get navigationItems()

    {

52 return [this._refreshButtonNavigationItem, this._showGridButtonNavigationItem];

        let navigationItems = [this._refreshButtonNavigationItem, this._showGridButtonNavigationItem];

        if (this._recordButtonNavigationItem)

            navigationItems.unshift(this._recordButtonNavigationItem);

        return navigationItems;

    }

    initialLayout()

    {

        super.initialLayout();

        WebInspector.canvasManager.addEventListener(WebInspector.CanvasManager.Event.RecordingFinished, this._recordingFinished, this);

    }

    shown()

@@WebInspector.CanvasContentView = class CanvasContentView extends WebInspector.Co

        super.hidden();

    }

    closed()

    {

        WebInspector.canvasManager.removeEventListener(null, null, this);

        super.closed();

    }

71100 // Private

72101

    _toggleRecording(event)

    {

        let toggled = this._recordButtonNavigationItem.toggled;

        this.representedObject.toggleRecording(!toggled, (error) => {

            if (error)

                return;

            this._recordButtonNavigationItem.toggled = !toggled;

            WebInspector.canvasManager.revealNextRecording = !toggled;

        });

    }

    _recordingFinished(event)

    {

        if (event.data.canvas !== this.representedObject)

            return;

        if (this._recordButtonNavigationItem)

            this._recordButtonNavigationItem.toggled = false;

    }

    _showPreview()

    {

        let showError = () => {

Source/WebInspectorUI/UserInterface/Views/ContentBrowser.js

WebInspector.ContentBrowser = class ContentBrowser extends WebInspector.View

{

28 constructor(element, delegate, disableBackForward, disableFindBanner)

28 constructor(element, delegate, disableBackForward, disableFindBanner, flexibleNavigationItem)

    {

        super(element);

@@WebInspector.ContentBrowser = class ContentBrowser extends WebInspector.View

        this._contentViewSelectionPathNavigationItem = new WebInspector.HierarchicalPathNavigationItem;

82 this._~~dividingF~~lexibl~~eSpac~~eNavigationItem = new WebInspector.FlexibleSpaceNavigationItem;

83 this._navigationBar.addNavigationItem(this._~~dividingF~~lexibl~~eSpac~~eNavigationItem);

82 this._flexibleNavigationItem = flexibleNavigationItem || new WebInspector.FlexibleSpaceNavigationItem;

83 this._navigationBar.addNavigationItem(this._flexibleNavigationItem);

        WebInspector.ContentView.addEventListener(WebInspector.ContentView.Event.SelectionPathComponentsDidChange, this._contentViewSelectionPathComponentDidChange, this);

        WebInspector.ContentView.addEventListener(WebInspector.ContentView.Event.SupplementalRepresentedObjectsDidChange, this._contentViewSupplementalRepresentedObjectsDidChange, this);

@@WebInspector.ContentBrowser = class ContentBrowser extends WebInspector.View

        this._removeAllNavigationItems();

        let navigationBar = this.navigationBar;

395 let insertionIndex = navigationBar.navigationItems.indexOf(this._~~dividingF~~lexibl~~eSpac~~eNavigationItem) + 1;

395 let insertionIndex = navigationBar.navigationItems.indexOf(this._flexibleNavigationItem) + 1;

        console.assert(insertionIndex >= 0);

        // Keep track of items we'll be adding to the navigation bar.

Source/WebInspectorUI/UserInterface/Views/ContentBrowserTabContentView.js

WebInspector.ContentBrowserTabContentView = class ContentBrowserTabContentView extends WebInspector.TabContentView

{

28 constructor(identifier, styleClassNames, tabBarItem, navigationSidebarPanelConstructor, detailsSidebarPanelConstructors, disableBackForward)

28 constructor(identifier, styleClassNames, tabBarItem, navigationSidebarPanelConstructor, detailsSidebarPanelConstructors, disableBackForward, flexibleNavigationItem)

    {

        if (typeof styleClassNames === "string")

            styleClassNames = [styleClassNames];

        styleClassNames.push("content-browser");

35 var contentBrowser = new WebInspector.ContentBrowser(null, null, disableBackForward);

35 var contentBrowser = new WebInspector.ContentBrowser(null, null, disableBackForward, false, flexibleNavigationItem);

        super(identifier, styleClassNames, tabBarItem, navigationSidebarPanelConstructor, detailsSidebarPanelConstructors);

Source/WebInspectorUI/UserInterface/Views/ContentFlowTreeElement.js

@@WebInspector.ContentFlowTreeElement = class ContentFlowTreeElement extends WebIn

    {

        console.assert(representedObject instanceof WebInspector.ContentFlow);

37 super("content-flow-icon", representedObject.name, null, representedObject~~, false~~);

37 super("content-flow-icon", representedObject.name, null, representedObject);

3838 }

3939};

Source/WebInspectorUI/UserInterface/Views/ContentView.js

@@WebInspector.ContentView = class ContentView extends WebInspector.View

        if (representedObject instanceof WebInspector.HeapSnapshotProxy || representedObject instanceof WebInspector.HeapSnapshotDiffProxy)

            return new WebInspector.HeapSnapshotClusterContentView(representedObject, extraArguments);

        if (representedObject instanceof WebInspector.Recording)

            return new WebInspector.RecordingContentView(representedObject, extraArguments);

        if (representedObject instanceof WebInspector.Collection)

            return new WebInspector.CollectionContentView(representedObject, extraArguments);

@@WebInspector.ContentView = class ContentView extends WebInspector.View

            return true;

        if (representedObject instanceof WebInspector.HeapSnapshotProxy || representedObject instanceof WebInspector.HeapSnapshotDiffProxy)

            return true;

286 if (representedObject instanceof WebInspector.Recording)

287 return true;

        if (representedObject instanceof WebInspector.Collection)

            return true;

        if (typeof representedObject === "string" || representedObject instanceof String)

Source/WebInspectorUI/UserInterface/Views/DOMDetailsSidebarPanel.js

WebInspector.DOMDetailsSidebarPanel = class DOMDetailsSidebarPanel extends WebInspector.DetailsSidebarPanel

{

28 constructor(identifier, displayName, ~~singularDisplayName, element,~~ dontCreateNavigationItem)

28 constructor(identifier, displayName, dontCreateNavigationItem)

2929 {

30 super(identifier, displayName, ~~singularDisplayName, element,~~ dontCreateNavigationItem);

30 super(identifier, displayName, dontCreateNavigationItem);

        this.element.addEventListener("click", this._mouseWasClicked.bind(this), true);

Source/WebInspectorUI/UserInterface/Views/DOMNodeDetailsSidebarPanel.js

@@WebInspector.DOMNodeDetailsSidebarPanel = class DOMNodeDetailsSidebarPanel exten

{

    constructor()

    {

30 super("dom-node-details", WebInspector.UIString("Node")~~, WebInspector.UIString("Node")~~);

30 super("dom-node-details", WebInspector.UIString("Node"));

        this._eventListenerGroupingMethodSetting = new WebInspector.Setting("dom-node-event-listener-grouping-method", WebInspector.DOMNodeDetailsSidebarPanel.EventListenerGroupingMethod.Event);

Source/WebInspectorUI/UserInterface/Views/DOMNodeTreeElement.js

@@WebInspector.DOMNodeTreeElement = class DOMNodeTreeElement extends WebInspector.

    {

        console.assert(domNode instanceof WebInspector.DOMNode);

32 super("dom-node", domNode.displayName, null, domNode, true);

32 super("dom-node", domNode.displayName, null, domNode, {hasChildren: true});

        this.status = WebInspector.linkifyNodeReferenceElement(domNode, WebInspector.createGoToArrowButton());

    }

Source/WebInspectorUI/UserInterface/Views/DOMTreeOutline.css

@@body[dir=rtl] .tree-outline.dom li.parent.shadow::after {

}

@keyframes node-state-changed {

292 from { background-color: hs~~la(83, 100%, 48%, 0.4~~); }

292 from { background-color: var(--value-changed-highlight); }

}

.node-state-changed {

Source/WebInspectorUI/UserInterface/Views/DataGridNode.js

WebInspector.DataGridNode = class DataGridNode extends WebInspector.Object

{

28 constructor(data, hasChildren)

28 constructor(data, hasChildren, classNames)

    {

        super();

@@WebInspector.DataGridNode = class DataGridNode extends WebInspector.Object

        this.previousSibling = null;

        this.nextSibling = null;

        this.disclosureToggleWidth = 10;

45 this._classNames = classNames || [];

    }

    get hidden()

@@WebInspector.DataGridNode = class DataGridNode extends WebInspector.Object

            this._element.classList.add("revealed");

        if (this._hidden)

            this._element.classList.add("hidden");

104 this._element.classList.add(...this._classNames);

        this.createCells();

        return this._element;

Source/WebInspectorUI/UserInterface/Views/DatabaseTableTreeElement.js

@@WebInspector.DatabaseTableTreeElement = class DatabaseTableTreeElement extends W

    {

        console.assert(representedObject instanceof WebInspector.DatabaseTableObject);

32 super("database-table-icon", representedObject.name, null, representedObject~~, false~~);

32 super("database-table-icon", representedObject.name, null, representedObject);

3333 }

3434};

Source/WebInspectorUI/UserInterface/Views/DatabaseTreeElement.js

@@WebInspector.DatabaseTreeElement = class DatabaseTreeElement extends WebInspecto

    {

        console.assert(representedObject instanceof WebInspector.DatabaseObject);

32 super("database-icon", representedObject.name, null, representedObject, true);

32 super("database-icon", representedObject.name, null, representedObject, {hasChildren: true});

        this.hasChildren = false;

Source/WebInspectorUI/UserInterface/Views/DetailsSidebarPanel.js

WebInspector.DetailsSidebarPanel = class DetailsSidebarPanel extends WebInspector.SidebarPanel

{

28 constructor(identifier, displayName, ~~singularDisplayName, element,~~ dontCreateNavigationItem)

28 constructor(identifier, displayName, dontCreateNavigationItem)

2929 {

30 super(identifier, displayName~~, element~~);

30 super(identifier, displayName);

        this.element.classList.add("details");

Source/WebInspectorUI/UserInterface/Views/FolderTreeElement.js

@@WebInspector.FolderTreeElement = class FolderTreeElement extends WebInspector.Ge

        const classNames = [WebInspector.FolderTreeElement.FolderIconStyleClassName];

        const subtitle = null;

34 const hasChildren = true;

35 super(classNames, title, subtitle, representedObject, hasChildren);

34 super(classNames, title, subtitle, representedObject, {hasChildren: true});

    }

};

Source/WebInspectorUI/UserInterface/Views/FolderizedTreeElement.js

WebInspector.FolderizedTreeElement = class FolderizedTreeElement extends WebInspector.GeneralTreeElement

{

28 constructor(classNames, title, subtitle, representedObject~~, hasChildren~~)

28 constructor(classNames, title, subtitle, representedObject)

2929 {

30 super(classNames, title, subtitle, representedObject~~, hasChildren~~);

30 super(classNames, title, subtitle, representedObject);

        this.shouldRefreshChildren = true;

@@WebInspector.FolderizedTreeElement = class FolderizedTreeElement extends WebInsp

            return 1;

        // Then sort by title.

240 return a.ma~~inTitle.locale~~Compare(b.mainTitle, ~~undef~~in~~ed, {numeric: true}~~);

240 return numericStringComparator(a.mainTitle, b.mainTitle);

    }

    _insertFolderTreeElement(folderTreeElement)

Source/WebInspectorUI/UserInterface/Views/GeneralTreeElement.js

WebInspector.GeneralTreeElement = class GeneralTreeElement extends WebInspector.TreeElement

{

28 constructor(classNames, title, subtitle, representedObject, ha~~sChildren~~)

28 constructor(classNames, title, subtitle, representedObject, options)

2929 {

30 super("", representedObject, ha~~sChildren~~);

30 super("", representedObject, options);

        this.classNames = classNames;

Source/WebInspectorUI/UserInterface/Views/IndexedDatabaseDetailsSidebarPanel.js

@@WebInspector.IndexedDatabaseDetailsSidebarPanel = class IndexedDatabaseDetailsSi

{

    constructor()

    {

30 super("indexed-database-details", WebInspector.UIString("Storage")~~, WebInspector.UIString("Storage")~~);

30 super("indexed-database-details", WebInspector.UIString("Storage"));

        this.element.classList.add("indexed-database");

Source/WebInspectorUI/UserInterface/Views/IndexedDatabaseObjectStoreIndexTreeElement.js

@@WebInspector.IndexedDatabaseObjectStoreIndexTreeElement = class IndexedDatabaseO

    {

        console.assert(objectStoreIndex instanceof WebInspector.IndexedDatabaseObjectStoreIndex);

32 super("database-table-icon", objectStoreIndex.name, null, objectStoreIndex~~, false~~);

32 super("database-table-icon", objectStoreIndex.name, null, objectStoreIndex);

        this._objectStoreIndex = objectStoreIndex;

    }

Source/WebInspectorUI/UserInterface/Views/IndexedDatabaseObjectStoreTreeElement.js

@@WebInspector.IndexedDatabaseObjectStoreTreeElement = class IndexedDatabaseObject

    {

        console.assert(objectStore instanceof WebInspector.IndexedDatabaseObjectStore);

32 super("database-table-icon", objectStore.name, null, objectStore, !!objectStore.indexes.length);

32 super("database-table-icon", objectStore.name, null, objectStore, {hasChildren: !!objectStore.indexes.length});

        this._objectStore = objectStore;

    }

Source/WebInspectorUI/UserInterface/Views/IndexedDatabaseTreeElement.js

@@WebInspector.IndexedDatabaseTreeElement = class IndexedDatabaseTreeElement exten

    {

        console.assert(indexedDatabase instanceof WebInspector.IndexedDatabase);

32 super("database-icon", indexedDatabase.name, null, indexedDatabase, !!indexedDatabase.objectStores.length);

32 super("database-icon", indexedDatabase.name, null, indexedDatabase, {hasChildren: !!indexedDatabase.objectStores.length});

        this._indexedDatabase = indexedDatabase;

    }

Source/WebInspectorUI/UserInterface/Views/IssueTreeElement.js

@@WebInspector.IssueTreeElement = class IssueTreeElement extends WebInspector.Gene

            break;

        }

40 super([WebInspector.IssueTreeElement.StyleClassName, levelStyleClassName], null, null, issueMessage~~, false~~);

40 super([WebInspector.IssueTreeElement.StyleClassName, levelStyleClassName], null, null, issueMessage);

        this._issueMessage = issueMessage;

        this._updateTitles();

Source/WebInspectorUI/UserInterface/Views/LayerTreeDetailsSidebarPanel.js

@@WebInspector.LayerTreeDetailsSidebarPanel = class LayerTreeDetailsSidebarPanel e

{

    constructor()

    {

30 super("layer-tree", WebInspector.UIString("Layers")~~, WebInspector.UIString("Layer")~~);

30 super("layer-tree", WebInspector.UIString("Layers"));

        this._dataGridNodesByLayerId = new Map;

Source/WebInspectorUI/UserInterface/Views/LogTreeElement.js

@@WebInspector.LogTreeElement = class LogTreeElement extends WebInspector.GeneralT

    {

        console.assert(representedObject instanceof WebInspector.LogObject);

32 super("log-icon", WebInspector.UIString("Console"), representedObject.startDate.toLocaleTimeString(), representedObject~~, false~~);

32 super("log-icon", WebInspector.UIString("Console"), representedObject.startDate.toLocaleTimeString(), representedObject);

        this._logObject = representedObject;

    }

Source/WebInspectorUI/UserInterface/Views/Main.css

@@body[dir=rtl] .go-to-link:not(.dont-float) {

    }

}

411 img.show-grid {

411:matches(img, canvas).show-grid {

    background-image: linear-gradient(315deg, transparent 75%, hsl(0, 0%, 95%) 75%),

                      linear-gradient(45deg, transparent 75%, hsl(0, 0%, 95%) 75%),

                      linear-gradient(315deg, hsl(0, 0%, 95%) 25%, transparent 25%),

Source/WebInspectorUI/UserInterface/Views/NavigationBar.css

.navigation-bar {

    display: flex;

    justify-content: center;

29 align-items: center;

    flex-wrap: wrap;

    border-bottom: 1px solid var(--border-color);

Source/WebInspectorUI/UserInterface/Views/NavigationSidebarPanel.css

    border-bottom: 1px solid var(--border-color);

}

.sidebar > .panel.navigation > .overflow-shadow.top {

    top: calc(var(--navigation-bar-height) - 1px);

    bottom: initial;

}

.sidebar > .panel.navigation > .content .empty-content-placeholder {

    left: 0;

    right: 0;

Source/WebInspectorUI/UserInterface/Views/NavigationSidebarPanel.js

WebInspector.NavigationSidebarPanel = class NavigationSidebarPanel extends WebInspector.SidebarPanel

{

28 constructor(identifier, displayName, shouldAutoPruneStaleTopLevelResourceTreeElements~~, wantsTopOverflowShadow, element, role, label~~)

28 constructor(identifier, displayName, shouldAutoPruneStaleTopLevelResourceTreeElements)

2929 {

30 super(identifier, displayName~~, element, role, label || displayName~~);

30 super(identifier, displayName);

        this.element.classList.add("navigation");

@@WebInspector.NavigationSidebarPanel = class NavigationSidebarPanel extends WebIn

        this._bottomOverflowShadowElement.className = WebInspector.NavigationSidebarPanel.OverflowShadowElementStyleClassName;

        this.element.appendChild(this._bottomOverflowShadowElement);

        if (wantsTopOverflowShadow) {

            this._topOverflowShadowElement = document.createElement("div");

            this._topOverflowShadowElement.classList.add(WebInspector.NavigationSidebarPanel.OverflowShadowElementStyleClassName);

            this._topOverflowShadowElement.classList.add(WebInspector.NavigationSidebarPanel.TopOverflowShadowElementStyleClassName);

            this.element.appendChild(this._topOverflowShadowElement);

        }

        this._boundUpdateContentOverflowShadowVisibility = this.soon._updateContentOverflowShadowVisibility;

        window.addEventListener("resize", this._boundUpdateContentOverflowShadowVisibility);

@@WebInspector.NavigationSidebarPanel.SuppressFilteringSymbol = Symbol("suppress-f

WebInspector.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol = Symbol("was-expanded-during-filtering");

WebInspector.NavigationSidebarPanel.OverflowShadowElementStyleClassName = "overflow-shadow";

763 WebInspector.NavigationSidebarPanel.TopOverflowShadowElementStyleClassName = "top";

WebInspector.NavigationSidebarPanel.ContentTreeOutlineElementStyleClassName = "navigation-sidebar-panel-content-tree-outline";

WebInspector.NavigationSidebarPanel.EmptyContentPlaceholderElementStyleClassName = "empty-content-placeholder";

WebInspector.NavigationSidebarPanel.EmptyContentPlaceholderMessageElementStyleClassName = "message";

Source/WebInspectorUI/UserInterface/Views/NetworkSidebarPanel.css

}

.sidebar > .panel.navigation.network.network-grid-content-view-showing > .content > .tree-outline {

95 background-image: linear-gradient(to bottom, transparent, transparent 50%, hsla(0, 0%, 0%, 0.03) 50%, hsla(0, 0%, 0%, 0.03));

96 background-size: 100% 40px;

95 background: var(--transparent-stripe-background-gradient);

}

.sidebar > .panel.navigation.network .tree-outline > .preserved:not(.selected) > :not(.status) {

Source/WebInspectorUI/UserInterface/Views/ObjectTreeBaseTreeElement.js

@@WebInspector.ObjectTreeBaseTreeElement = class ObjectTreeBaseTreeElement extends

        console.assert(propertyPath instanceof WebInspector.PropertyPath);

        console.assert(!property || property instanceof WebInspector.PropertyDescriptor);

34 super(null, null, null, representedObject~~, false~~);

34 super(null, null, null, representedObject);

        this._property = property;

        this._propertyPath = propertyPath;

Source/WebInspectorUI/UserInterface/Views/ProbeDetailsSidebarPanel.js

@@WebInspector.ProbeDetailsSidebarPanel = class ProbeDetailsSidebarPanel extends W

{

    constructor()

    {

31 super("probe", WebInspector.UIString("Probes")~~, WebInspector.UIString("Probes")~~);

31 super("probe", WebInspector.UIString("Probes"));

        this._probeSetSections = new Map;

        this._inspectedProbeSets = [];

Source/WebInspectorUI/UserInterface/Views/ProfileNodeTreeElement.js

@@WebInspector.ProfileNodeTreeElement = class ProfileNodeTreeElement extends WebIn

        if (profileNode.functionName && profileNode.functionName.startsWith("on") && profileNode.functionName.length >= 5)

            className = WebInspector.CallFrameView.EventListenerIconStyleClassName;

        var hasChildren = !!profileNode.childNodes.length;

        super([className], title, subtitle, profileNode, hasChildren);

75 super([className], title, subtitle, profileNode, {hasChildren: !!profileNode.childNodes.length});

        this._profileNode = profileNode;

        this._delegate = delegate || null;

Source/WebInspectorUI/UserInterface/Views/RecordingContentView.css

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

.content-view.recording {

    display: flex;

    align-items: center;

    justify-content: center;

    padding: 15px;

}

.content-view.recording > canvas {

    max-width: 100%;

    max-height: 100%;

}

Source/WebInspectorUI/UserInterface/Views/RecordingContentView.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingContentView = class RecordingContentView extends WebInspector.ContentView

{

    constructor(representedObject)

    {

        console.assert(representedObject instanceof WebInspector.Recording);

        super(representedObject);

        this._index = NaN;

        this.element.classList.add("recording", this.representedObject.type);

        if (this.representedObject.type === WebInspector.Recording.Type.Canvas2D) {

            this._showGridButtonNavigationItem = new WebInspector.ActivateButtonNavigationItem("show-grid", WebInspector.UIString("Show Grid"), WebInspector.UIString("Hide Grid"), "Images/NavigationItemCheckers.svg", 13, 13);

            this._showGridButtonNavigationItem.addEventListener(WebInspector.ButtonNavigationItem.Event.Clicked, this._showGridButtonClicked, this);

            this._showGridButtonNavigationItem.activated = !!WebInspector.settings.showImageGrid.value;

            this._context = this.element.appendChild(document.createElement("canvas")).getContext("2d");

            this._content = null;

        }

    }

    // Public

    get navigationItems()

    {

        if (this.representedObject.type === WebInspector.Recording.Type.Canvas2D)

            return [this._showGridButtonNavigationItem];

        return [];

    }

    set actionIndex(index)

    {

        console.assert(!this.representedObject || (index >= 0 && index < this.representedObject.actions.length));

        if (!this.representedObject || index < 0 || index >= this.representedObject.actions.length || index === this._index)

            return;

        this._index = index;

        if (this.representedObject.type === WebInspector.Recording.Type.Canvas2D) {

            let initialState = this.representedObject.initialState;

            if (initialState.content && !this._content) {

                let image = new Image;

                image.src = initialState.content;

                image.addEventListener("load", (event) => {

                    // Loading took too long and the current action index has already changed.

                    if (index !== this._index)

                        return;

                    this._content = image;

                    this._index = NaN;

                    this.actionIndex = index;

                });

                image.addEventListener("error", (event) => {

                    // Loading took too long and the current action index has already changed.

                    if (index !== this._index)

                        return;

                    this._index = NaN;

                    this.actionIndex = index;

                });

                return;

            }

            if ("width" in initialState.attributes)

                this._context.canvas.width = initialState.attributes.width;

            if ("height" in initialState.attributes)

                this._context.canvas.height = initialState.attributes.height;

            this._context.clearRect(0, 0, this._context.canvas.width, this._context.canvas.height);

            if (this._content)

                this._context.drawImage(this._content, 0, 0);

            for (let name in initialState.attributes) {

                if (!(name in this._context))

                    continue;

                try {

                    this._context[name] = initialState.attributes[name];

                } catch (e) {

                    // Ignore

                }

            }

            for (let name in initialState.functions) {

                if (!(name in this._context))

                    continue;

                try {

                    this._context[name](...initialState.functions[name]);

                } catch (e) {

                    // Ignore

                }

            }

            let actions = this.representedObject.actions;

            for (let i = 0; i <= this._index; ++i) {

                if (!actions[i].valid)

                    continue;

                let hasIrreplaceableParameter = false;

                let parameters = actions[i].parameters.map((parameter, parameterIndex) => {

                    let unavailableReplacement = actions[i].unavailableParameterReplacementForType(this.representedObject.type, parameterIndex);

                    if (unavailableReplacement) {

                        if (typeof unavailableReplacement.callback === "function")

                            return unavailableReplacement.callback(parameter, this._context);

                        hasIrreplaceableParameter = true;

                    }

                    return parameter;

                });

                if (hasIrreplaceableParameter)

                    continue;

                try {

                    if (actions[i].attributeForType(this.representedObject.type)) {

                        if (actions[i].name === "width" || actions[i].name === "height")

                            this._context.canvas[actions[i].name] = parameters[0];

                        else

                            this._context[actions[i].name] = parameters[0];

                    } else

                        this._context[actions[i].name](...parameters);

                } catch (e) {

                    // Ignore

                }

            }

        }

    }

    // Protected

    shown()

    {

        super.shown();

        this._updateImageGrid();

    }

    // Private

    _updateImageGrid()

    {

        let activated = WebInspector.settings.showImageGrid.value;

        this._showGridButtonNavigationItem.activated = activated;

        this._context.canvas.classList.toggle("show-grid", activated);

    }

    _showGridButtonClicked(event)

    {

        WebInspector.settings.showImageGrid.value = !this._showGridButtonNavigationItem.activated;

        this._updateImageGrid();

    }

};

Source/WebInspectorUI/UserInterface/Views/RecordingDetailsSidebarPanel.css

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

.sidebar > .panel.details.recording > .content > .data-grid {

    min-height: 100%;

}

.sidebar > .panel.details.recording > .content > .data-grid tr.modified {

    background-color: var(--value-changed-highlight);

}

.sidebar > .panel.details.recording > .content > .data-grid tr:not(.selected) .parameter.unavailable {

    color: grey;

}

Source/WebInspectorUI/UserInterface/Views/RecordingDetailsSidebarPanel.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingDetailsSidebarPanel = class RecordingDetailsSidebarPanel extends WebInspector.DetailsSidebarPanel

{

    constructor()

    {

        super("recording", WebInspector.UIString("Current State"));

        this.recording = null;

        this._dataGrid = null;

    }

    // Static

    static disallowInstanceForClass()

    {

        return true;

    }

    // Public

    inspect(objects)

    {

        // Always show this sidebar, as it will have it's data populated by the model object.

        return true;

    }

    set recording(recording)

    {

        this._recording = recording;

        for (let subview of this.contentView.subviews)

            this.contentView.removeSubview(subview);

        this._index = NaN;

    }

    set actionIndex(index)

    {

        console.assert(!this._recording || (index >= 0 && index < this._recording.actions.length));

        if (!this._recording || index < 0 || index > this._recording.actions.length || index === this._index)

            return;

        this._index = index;

        if (this._recording.type === WebInspector.Recording.Type.Canvas2D) {

            if (!this._dataGrid) {

                this._dataGrid = new WebInspector.DataGrid({

                    name: {title: WebInspector.UIString("Name")},

                    value: {title: WebInspector.UIString("Value")},

                });

            }

            if (!this._dataGrid.parentView)

                this.contentView.addSubview(this._dataGrid);

            this._dataGrid.removeChildren();

            let initialState = this._recording.initialState;

            let data = Object.shallowMerge(initialState.attributes, initialState.functions);

            let actions = this._recording.actions;

            for (let i = 0; i <= this._index; ++i) {

                if (!(actions[i].name in data) || !actions[i].valid)

                    continue;

                data[actions[i].name] = actions[i];

            }

            for (let name of Object.keys(data).sort(numericStringComparator)) {

                let valueFragment = document.createDocumentFragment();

                let parameters = data[name];

                if (parameters instanceof WebInspector.RecordingAction)

                    parameters = parameters.parameters;

                else

                    parameters = [parameters];

                for (let i = 0; i < parameters.length; ++i) {

                    if (i)

                        valueFragment.append(", ");

                    let parameterElement = valueFragment.appendChild(document.createElement("span"));

                    parameterElement.classList.add("parameter");

                    let textContent = "";

                    if (data[name] instanceof WebInspector.RecordingAction) {

                        let unavailableReplacement = data[name].unavailableParameterReplacementForType(this._recording.type, i);

                        if (unavailableReplacement) {

                            let replacement = unavailableReplacement.name(parameters[i]);

                            if (replacement !== parameters[i]) {

                                parameterElement.classList.add("unavailable");

                                textContent = replacement;

                            }

                        }

                    }

                    if (!textContent.length) {

                        textContent = parameters[i];

                        if (name in initialState.functions)

                            textContent = JSON.stringify(textContent);

                    }

                    parameterElement.textContent = textContent;

                    if (name in initialState.attributes)

                        break;

                }

                let classNames = [];

                if (name === actions[this._index].name)

                    classNames.push("modified");

                const hasChildren = false;

                this._dataGrid.appendChild(new WebInspector.DataGridNode({name, value: valueFragment}, hasChildren, classNames));

            }

            this.updateLayoutIfNeeded();

        }

    }

};

Source/WebInspectorUI/UserInterface/Views/RecordingNavigationSidebarPanel.css

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

.sidebar > .panel.navigation.recording > :matches(.content, .empty-content-placeholder) {

    top: var(--navigation-bar-height);

}

.sidebar > .panel.navigation.recording > .content > .tree-outline {

    min-height: 100%;

    background: var(--transparent-stripe-background-gradient);

    counter-reset: actions -1; /* Ensures that the "Initial State" item has the index 0. */

}

.sidebar > .panel.navigation.recording > .content > .tree-outline > .item.action::before {

    position: relative;

    top: 3px;

    float: left;

    margin-right: 4px;

    counter-increment: actions;

    content: counter(actions);

    font-family: Menlo, monospace;

}

.sidebar > .panel.navigation.recording > .content .action > .icon {

    content: url("../Images/Source.svg");

}

.sidebar > .panel.navigation.recording > .content .action.function > .icon {

    content: url(../Images/Function.svg);

}

.sidebar > .panel.navigation.recording > .content .action.attribute.boolean > .icon {

    content: url(../Images/TypeBoolean.svg);

}

.sidebar > .panel.navigation.recording > .content .action.attribute.number > .icon {

    content: url(../Images/TypeNumber.svg);

}

.sidebar > .panel.navigation.recording > .content .action.attribute.object > .icon {

    content: url(../Images/TypeObject.svg);

}

.sidebar > .panel.navigation.recording > .content .action.attribute.string > .icon {

    content: url(../Images/TypeString.svg);

}

.sidebar > .panel.navigation.recording > .content .action:matches(.invalid, .unavailable) > .icon {

    filter: grayscale();

}

.sidebar > .panel.navigation.recording > .content .action.visual:not(.selected, .invalid, .unavailable) {

    background-color: var(--value-visual-highlight);

}

.sidebar > .panel.navigation.recording > .content .action:not(.selected, .initial-state) > .titles .parameter.unavailable {

    color: grey;

}

.sidebar > .panel.navigation.recording > .content .action.invalid:not(.selected, .initial-state) > .titles .name,

.sidebar > .panel.navigation.recording > .content .action.unavailable:not(.selected, .initial-state) > .titles .parameter.unavailable {

    color: red;

}

Source/WebInspectorUI/UserInterface/Views/RecordingNavigationSidebarPanel.js

/*

 * Copyright (C) 2015 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingNavigationSidebarPanel = class RecordingNavigationSidebarPanel extends WebInspector.NavigationSidebarPanel

{

    constructor()

    {

        super("recording", WebInspector.UIString("Recording"));

        this.contentTreeOutline.disclosureButtons = false;

        this.filterBar.placeholder = WebInspector.UIString("Filter Actions");

        this.recording = null;

        this._importButton = null;

        this._exportButton = null;

    }

    // Static

    static disallowInstanceForClass()

    {

        return true;

    }

    // Public

    set recording(recording)

    {

        if (recording === this._recording)

            return;

        this.contentTreeOutline.removeChildren();

        this._recording = recording;

        if (this._recording) {

            for (let action of this._recording.actions) {

                let classNames = ["action"];

                let attribute = action.attributeForType(this._recording.type);

                if (attribute)

                    classNames.push("attribute", typeof action.parameters[0]);

                else

                    classNames.push("function");

                if (action.visualForType(this._recording.type))

                    classNames.push("visual");

                if (!action.valid)

                    classNames.push("invalid");

                let titleFragment = document.createDocumentFragment();

                let nameContainer = titleFragment.appendChild(document.createElement("span"));

                nameContainer.classList.add("name");

                nameContainer.textContent = action.name;

                if (!(action instanceof WebInspector.RecordingInitialStateAction)) {

                    let hasIrreplaceableParameter = false;

                    titleFragment.append(attribute ? " = " : "(");

                    for (let i = 0; i < action.parameters.length; ++i) {

                        if (i)

                            titleFragment.append(", ");

                        let parameterElement = titleFragment.appendChild(document.createElement("span"));

                        parameterElement.classList.add("parameter");

                        let textContent = "";

                        let unavailableReplacement = action.unavailableParameterReplacementForType(this._recording.type, i);

                        if (unavailableReplacement) {

                            if (typeof unavailableReplacement.callback !== "function")

                                hasIrreplaceableParameter = true;

                            let name = unavailableReplacement.name(action.parameters[i]);

                            if (name !== action.parameters[i]) {

                                parameterElement.classList.add("unavailable");

                                textContent = name;

                            }

                        }

                        if (!textContent.length)

                            textContent = JSON.stringify(action.parameters[i]);

                        parameterElement.textContent = textContent;

                        if (attribute)

                            break;

                    }

                    if (!attribute)

                        titleFragment.append(")");

                    if (hasIrreplaceableParameter)

                        classNames.push("unavailable");

                } else

                    classNames.push("initial-state");

                const subtitle = null;

                let treeElement = new WebInspector.GeneralTreeElement(classNames, titleFragment, subtitle, action);

                this.contentTreeOutline.appendChild(treeElement);

            }

        }

        this.updateEmptyContentPlaceholder(WebInspector.UIString("No Recording Data"));

        if (this._exportButton)

            this._exportButton.disabled = !this.contentTreeOutline.hasChildren;

    }

    set actionIndex(index)

    {

        console.assert(!this._recording || (index >= 0 && index < this._recording.actions.length));

        if (!this._recording || index < 0 || index >= this._recording.actions.length)

            return;

        const omitFocus = true;

        const selectedByUser = false;

        const suppressOnSelect = true;

        const suppressOnDeselect = true;

        this.contentTreeOutline.children[index].select(omitFocus, selectedByUser, suppressOnSelect, suppressOnDeselect);

    }

    // Protected

    initialLayout()

    {

        super.initialLayout();

        const role = "button";

        const importLabel = WebInspector.UIString("Import");

        let importNavigationItem = new WebInspector.NavigationItem("recording-import", role, importLabel);

        this._importButton = importNavigationItem.element.appendChild(document.createElement("button"));

        this._importButton.textContent = importLabel;

        this._importButton.addEventListener("click", this._importNavigationItemClicked.bind(this));

        const exportLabel = WebInspector.UIString("Export");

        let exportNavigationItem = new WebInspector.NavigationItem("recording-export", role, exportLabel);

        this._exportButton = exportNavigationItem.element.appendChild(document.createElement("button"));

        this._exportButton.textContent = exportLabel;

        this._exportButton.disabled = true;

        this._exportButton.addEventListener("click", this._exportNavigationItemClicked.bind(this));

        const element = null;

        this.addSubview(new WebInspector.NavigationBar(element, [importNavigationItem, exportNavigationItem]));

    }

    // Private

    _importNavigationItemClicked(event)

    {

        WebInspector.loadDataFromFile((data) => {

            let payload = null;

            try {

                payload = JSON.parse(data);

            } catch (e) {

                WebInspector.Recording.synthesizeError(e);

                return;

            }

            if (payload.version !== WebInspector.Recording.Version) {

                WebInspector.Recording.synthesizeError(WebInspector.UIString("unsupported version"));

                return;

            }

            this.dispatchEventToListeners(WebInspector.RecordingNavigationSidebarPanel.Event.Import, {payload});

        });

    }

    _exportNavigationItemClicked(event)

    {

        if (!this._recording)

            return;

        const forceSaveAs = true;

        WebInspector.saveDataToFile({

            url: "web-inspector:///Recording.json",

            content: JSON.stringify(this._recording.toJSON()),

        }, forceSaveAs);

    }

};

WebInspector.RecordingNavigationSidebarPanel.Event = {

    Import: "recording-navigation-sidebar-panel-import",

};

Source/WebInspectorUI/UserInterface/Views/RecordingTabContentView.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.RecordingTabContentView = class RecordingTabContentView extends WebInspector.ContentBrowserTabContentView

{

    constructor()

    {

        let {image, title} = WebInspector.RecordingTabContentView.tabInfo();

        let tabBarItem = new WebInspector.GeneralTabBarItem(image, title);

        const navigationSidebarPanelConstructor = WebInspector.RecordingNavigationSidebarPanel;

        const detailsSidebarPanelConstructors = [WebInspector.RecordingDetailsSidebarPanel];

        const disableBackForward = true;

        let flexibleNavigationItem = new WebInspector.ScrubberNavigationItem;

        super("recording", "recording", tabBarItem, navigationSidebarPanelConstructor, detailsSidebarPanelConstructors, disableBackForward, flexibleNavigationItem);

        this._visualActionIndexes = [];

        this._scrubberNavigationItem = flexibleNavigationItem;

        this._scrubberNavigationItem.value = 0;

        this._scrubberNavigationItem.disabled = true;

        this._scrubberNavigationItem.addEventListener(WebInspector.ScrubberNavigationItem.Event.ValueChanged, this._scrubberNavigationItemValueChanged, this);

        this.navigationSidebarPanel.addEventListener(WebInspector.RecordingNavigationSidebarPanel.Event.Import, this._navigationSidebarImport, this);

        this.navigationSidebarPanel.contentTreeOutline.addEventListener(WebInspector.TreeOutline.Event.SelectionDidChange, this._navigationSidebarTreeOutlineSelectionChanged, this);

        this._recording = null;

    }

    // Static

    static tabInfo()

    {

        return {

            image: "Images/Recording.svg",

            title: WebInspector.UIString("Recording"),

        };

    }

    // Public

    get type()

    {

        return WebInspector.RecordingTabContentView.Type;

    }

    canShowRepresentedObject(representedObject)

    {

        // Once a recording has been loaded for this tab, do not allow another one to be loaded.

        // This will cause new tabs to be opened for each recording, which is the desired behavior.

        if (this._recording)

            return false;

        return representedObject instanceof WebInspector.Recording;

    }

    showRepresentedObject(representedObject, cookie)

    {

        super.showRepresentedObject(representedObject, cookie);

        this._recording = representedObject;

        this._visualActionIndexes = [];

        representedObject.actions.forEach((action, i) => {

            if (action.visualForType(representedObject.type))

                this._visualActionIndexes.push(i);

        });

        this._scrubberNavigationItem.value = 0;

        this._scrubberNavigationItem.min = 0;

        this._scrubberNavigationItem.max = representedObject.actions.length - 1;

        this._scrubberNavigationItem.disabled = false;

        this.navigationSidebarPanel.recording = representedObject;

        for (let detailsSidebarPanel of this.detailsSidebarPanels)

            detailsSidebarPanel.recording = representedObject;

        this._actionIndex = this._scrubberNavigationItem.value;

    }

    // Protected

    restoreStateFromCookie(restorationType)

    {

        // Don't attempt to do anything to this tab.

    }

    saveStateToCookie(cookie)

    {

        // Don't attempt to do anything to this tab.

    }

    closed()

    {

        super.closed();

        this.navigationSidebarPanel.recording = null;

        for (let detailsSidebarPanel of this.detailsSidebarPanels)

            detailsSidebarPanel.recording = null;

    }

    // Private

    set _actionIndex(index)

    {

        this._scrubberNavigationItem.value = index;

        this.navigationSidebarPanel.actionIndex = index;

        this.contentBrowser.currentContentView.actionIndex = index;

        for (let detailsSidebarPanel of this.detailsSidebarPanels)

            detailsSidebarPanel.actionIndex = index;

    }

    _scrubberNavigationItemValueChanged(event)

    {

        for (let i = 0; i <= this._visualActionIndexes.length; ++i) {

            if (this._visualActionIndexes[i] < this._scrubberNavigationItem.value)

                continue;

            let min = i ? this._visualActionIndexes[i - 1] : this._scrubberNavigationItem.min;

            let max = i < this._visualActionIndexes.length ? this._visualActionIndexes[i] : this._scrubberNavigationItem.max;

            this._actionIndex = (this._scrubberNavigationItem.value >= (min + max) / 2) ? max : min;

            return;

        }

    }

    _navigationSidebarImport(event)

    {

        this.showRepresentedObject(WebInspector.Recording.fromPayload(event.data.payload));

    }

    _navigationSidebarTreeOutlineSelectionChanged(event)

    {

        // Ignore deselect events.

        if (!event.data.selectedElement)

            return;

        this._actionIndex = this.navigationSidebarPanel.contentTreeOutline.selectedTreeElementIndex;

    }

};

WebInspector.RecordingTabContentView.Type = "recording";

Source/WebInspectorUI/UserInterface/Views/ResourceDetailsSidebarPanel.js

@@WebInspector.ResourceDetailsSidebarPanel = class ResourceDetailsSidebarPanel ext

{

    constructor()

    {

30 super("resource-details", WebInspector.UIString("Resource")~~, WebInspector.UIString("Resource")~~);

30 super("resource-details", WebInspector.UIString("Resource"));

        this.element.classList.add("resource");

Source/WebInspectorUI/UserInterface/Views/ResourceTreeElement.js

@@WebInspector.ResourceTreeElement = class ResourceTreeElement extends WebInspecto

    {

        console.assert(resource instanceof WebInspector.Resource);

32 super(resource, ["resource", WebInspector.ResourceTreeElement.ResourceIconStyleClassName, resource.type], "", "", representedObject || resource~~, false~~);

32 super(resource, ["resource", WebInspector.ResourceTreeElement.ResourceIconStyleClassName, resource.type], "", "", representedObject || resource);

        this._updateResource(resource);

    }

Source/WebInspectorUI/UserInterface/Views/ScopeChainDetailsSidebarPanel.js

@@WebInspector.ScopeChainDetailsSidebarPanel = class ScopeChainDetailsSidebarPanel

{

    constructor()

    {

30 super("scope-chain", WebInspector.UIString("Scope Chain")~~, WebInspector.UIString("Scope Chain")~~);

30 super("scope-chain", WebInspector.UIString("Scope Chain"));

        this._callFrame = null;

Source/WebInspectorUI/UserInterface/Views/ScriptTreeElement.js

@@WebInspector.ScriptTreeElement = class ScriptTreeElement extends WebInspector.So

    {

        console.assert(script instanceof WebInspector.Script);

32 super(script, "script", null, null, script~~, false~~);

32 super(script, "script", null, null, script);

        this.mainTitle = script.displayName;

Source/WebInspectorUI/UserInterface/Views/ScrubberNavigationItem.css

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

.navigation-bar .item.scrubber {

    padding: 0 4px;

}

.navigation-bar .item.scrubber > input {

    width: 100%;

}

.navigation-bar .item.scrubber > input[disabled] {

    opacity: 0.5;

    pointer-events: none;

}

Source/WebInspectorUI/UserInterface/Views/ScrubberNavigationItem.js

/*

 * Copyright (C) 2017 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. AND ITS CONTRIBUTORS ``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 ITS 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.

 */

WebInspector.ScrubberNavigationItem = class ScrubberNavigationItem extends WebInspector.FlexibleSpaceNavigationItem

{

    constructor(identifier)

    {

        super(identifier);

        this._sliderElement = this._element.appendChild(document.createElement("input"));

        this._sliderElement.type = "range";

        this._sliderElement.addEventListener("input", this._sliderChanged.bind(this));

    }

    // Public

    get value() { return parseInt(this._sliderElement.value); }

    set value(value) { this._sliderElement.value = value; }

    get min() { return parseInt(this._sliderElement.min); }

    set min(min) { this._sliderElement.min = min; }

    get max() { return parseInt(this._sliderElement.max); }

    set max(max) { this._sliderElement.max = max; }

    set disabled(flag)

    {

        this._sliderElement.disabled = !!flag;

    }

    // Protected

    get additionalClassNames()

    {

        return super.additionalClassNames.concat(["scrubber"]);

    }

    // Private

    _sliderChanged(event)

    {

        this.dispatchEventToListeners(WebInspector.ScrubberNavigationItem.Event.ValueChanged);

    }

};

WebInspector.ScrubberNavigationItem.Event = {

    ValueChanged: "slider-navigation-item-value-changed",

};

Source/WebInspectorUI/UserInterface/Views/SearchResultTreeElement.js

@@WebInspector.SearchResultTreeElement = class SearchResultTreeElement extends Web

        var title = WebInspector.SearchResultTreeElement.truncateAndHighlightTitle(representedObject.title, representedObject.searchTerm, representedObject.sourceCodeTextRange);

34 super(representedObject.className, title, null, representedObject~~, false~~);

34 super(representedObject.className, title, null, representedObject);

    }

    // Static

Source/WebInspectorUI/UserInterface/Views/SidebarPanel.js

WebInspector.SidebarPanel = class SidebarPanel extends WebInspector.View

{

28 constructor(identifier, displayName~~, element, role, label~~)

28 constructor(identifier, displayName)

2929 {

30 super(~~element~~);

30 super();

        this._identifier = identifier;

        this._displayName = displayName;

@@WebInspector.SidebarPanel = class SidebarPanel extends WebInspector.View

        this.element.classList.add("panel", identifier);

40 this.element.setAttribute("role", ~~role ||~~ "group");

41 this.element.setAttribute("aria-label", ~~label ||~~ displayName);

40 this.element.setAttribute("role", "group");

41 this.element.setAttribute("aria-label", displayName);

        this._contentView = new WebInspector.View;

        this._contentView.element.classList.add("content");

Source/WebInspectorUI/UserInterface/Views/SourceCodeTreeElement.js

WebInspector.SourceCodeTreeElement = class SourceCodeTreeElement extends WebInspector.FolderizedTreeElement

{

28 constructor(sourceCode, classNames, title, subtitle, representedObject~~, hasChildren~~)

28 constructor(sourceCode, classNames, title, subtitle, representedObject)

    {

        console.assert(sourceCode instanceof WebInspector.SourceCode);

32 super(classNames, title, subtitle, representedObject || sourceCode~~, hasChildren~~);

32 super(classNames, title, subtitle, representedObject || sourceCode);

        this._updateSourceCode(sourceCode);

    }

Source/WebInspectorUI/UserInterface/Views/StorageTreeElement.js

@@WebInspector.StorageTreeElement = class StorageTreeElement extends WebInspector.

{

    constructor(classNames, title, representedObject)

    {

30 super(classNames, title, null, representedObject~~, false~~);

30 super(classNames, title, null, representedObject);

        this.flattened = false;

    }

Source/WebInspectorUI/UserInterface/Views/TabBar.js

@@WebInspector.TabBar = class TabBar extends WebInspector.View

                this.addTabBarItem(tabBarItem);

        }

47 this.addTabBarItem(WebInspector.settingsTabContentView.tabBarItem, true);

47 this.addTabBarItem(WebInspector.settingsTabContentView.tabBarItem, {doNotAnimate: true});

        this._newTabTabBarItem = new WebInspector.PinnedTabBarItem("Images/NewTabPlus.svg", WebInspector.UIString("Create a new tab"));

        this._newTabTabBarItem.element.addEventListener("mouseenter", this._handleNewTabMouseEnter.bind(this));

        this._newTabTabBarItem.element.addEventListener("click", this._handleNewTabClick.bind(this));

52 this.addTabBarItem(this._newTabTabBarItem, true);

52 this.addTabBarItem(this._newTabTabBarItem, {doNotAnimate: true});

    }

    // Public

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        this._newTabTabBarItem.disabled = newTabExists;

    }

65 addTabBarItem(tabBarItem, doN~~otAnimate~~)

65 addTabBarItem(tabBarItem, options = {})

6666 {

67 return this.insertTabBarItem(tabBarItem, this._tabBarItems.length, doN~~otAnimate~~);

67 return this.insertTabBarItem(tabBarItem, this._tabBarItems.length, options);

6868 }

6969

70 insertTabBarItem(tabBarItem, index, doN~~otAnimate~~)

70 insertTabBarItem(tabBarItem, index, options = {})

    {

        console.assert(tabBarItem instanceof WebInspector.TabBarItem);

        if (!(tabBarItem instanceof WebInspector.TabBarItem))

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        if (this._tabAnimatedClosedSinceMouseEnter) {

            // Delay adding the new tab until we can expand the tabs after a closed tab.

            this._finishExpandingTabsAfterClose().then(() => {

82 this.insertTabBarItem(tabBarItem, index, doN~~otAnimate~~);

82 this.insertTabBarItem(tabBarItem, index, options);

            });

            return;

        }

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        if (this.element.classList.contains("animating")) {

            requestAnimationFrame(removeStyles.bind(this));

96 doNotAnimate = true;

96 options.doNotAnimate = true;

        }

        var beforeTabSizesAndPositions;

100 if (!doNotAnimate)

100 if (!options.doNotAnimate)

            beforeTabSizesAndPositions = this._recordTabBarItemSizesAndPositions();

        this._tabBarItems.splice(index, 0, tabBarItem);

@@WebInspector.TabBar = class TabBar extends WebInspector.View

            this.element.removeEventListener("webkitTransitionEnd", removeStylesListener);

        }

141 if (!doNotAnimate) {

141 if (!options.doNotAnimate) {

            var afterTabSizesAndPositions = this._recordTabBarItemSizesAndPositions();

            this.updateLayout();

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        return tabBarItem;

    }

174 removeTabBarItem(tabBarItemOrIndex, doN~~otAnimate,~~ ~~doNotExpand~~)

174 removeTabBarItem(tabBarItemOrIndex, options = {})

    {

        let tabBarItem = this._findTabBarItem(tabBarItemOrIndex);

        if (!tabBarItem || tabBarItem instanceof WebInspector.PinnedTabBarItem)

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        if (this.element.classList.contains("animating")) {

            requestAnimationFrame(removeStyles.bind(this));

193 doNotAnimate = true;

193 options.doNotAnimate = true;

        }

        var beforeTabSizesAndPositions;

197 if (!doNotAnimate)

197 if (!options.doNotAnimate)

            beforeTabSizesAndPositions = this._recordTabBarItemSizesAndPositions();

        // Subtract 1 from normalTabCount since arrays begin indexing at 0.

@@WebInspector.TabBar = class TabBar extends WebInspector.View

        const shouldOpenDefaultTab = !tabBarItem.isDefaultTab && !this.normalTabCount;

        if (shouldOpenDefaultTab)

211 doNotAnimate = true;

211 options.doNotAnimate = true;

212212

213 if (!hasMoreThanOneNormalTab || wasLastNormalTab || !doNotExpand) {

214 if (!doNotAnimate) {

213 if (!hasMoreThanOneNormalTab || wasLastNormalTab || !options.doNotExpand) {

214 if (!options.doNotAnimate) {

                this._tabAnimatedClosedSinceMouseEnter = true;

                this._finishExpandingTabsAfterClose(beforeTabSizesAndPositions);

            } else

@@WebInspector.TabBar = class TabBar extends WebInspector.View

            this.element.removeEventListener("webkitTransitionEnd", removeStylesListener);

        }

283 if (!doNotAnimate) {

283 if (!options.doNotAnimate) {

            this.element.classList.add("static-layout");

            this._tabAnimatedClosedSinceMouseEnter = true;

@@WebInspector.TabBar = class TabBar extends WebInspector.View

                return;

            if (!event.altKey) {

618 this.removeTabBarItem(tabBarItem, f~~alse,~~ true);

618 this.removeTabBarItem(tabBarItem, {doNotExpand: true});

                return;

            }

Source/WebInspectorUI/UserInterface/Views/TabBrowser.js

@@WebInspector.TabBrowser = class TabBrowser extends WebInspector.View

        return null;

    }

139 addTabForContentView(tabContentView, d~~oNotAnimate, inser~~tion~~Index~~)

139 addTabForContentView(tabContentView, options = {})

    {

        console.assert(tabContentView instanceof WebInspector.TabContentView);

        if (!(tabContentView instanceof WebInspector.TabContentView))

@@WebInspector.TabBrowser = class TabBrowser extends WebInspector.View

        else

            this._recentTabContentViews.push(tabContentView);

166 if (typeof insertionIndex === "number")

167 this._tabBar.insertTabBarItem(tabBarItem, insertionIndex, doN~~otAnimate~~);

166 if (typeof options.insertionIndex === "number")

167 this._tabBar.insertTabBarItem(tabBarItem, options.insertionIndex, options);

168168 else

169 this._tabBar.addTabBarItem(tabBarItem, doN~~otAnimate~~);

169 this._tabBar.addTabBarItem(tabBarItem, options);

        console.assert(this._recentTabContentViews.length === this._tabBar.normalTabCount);

        console.assert(!this.selectedTabContentView || this.selectedTabContentView === this._recentTabContentViews[0]);

@@WebInspector.TabBrowser = class TabBrowser extends WebInspector.View

        return true;

    }

177 showTabForContentView(tabContentView, d~~oNotAnimate, inser~~tion~~Index~~)

177 showTabForContentView(tabContentView, options = {})

178178 {

179 if (!this.addTabForContentView(tabContentView, d~~oNotAnimate, inser~~tion~~Index~~))

179 if (!this.addTabForContentView(tabContentView, options))

180180 return false;

181181

182 this._tabBar.selectedTabBarItem = tabContentView.tabBarItem;

182 if (!options.skipReveal)

183 this._tabBar.selectedTabBarItem = tabContentView.tabBarItem;

        // FIXME: this is a workaround for <https://webkit.org/b/151876>.

        // Without this extra call, we might never lay out the child tab

@@WebInspector.TabBrowser = class TabBrowser extends WebInspector.View

        return true;

    }

194 closeTabForContentView(tabContentView, doN~~otAnimate~~)

195 closeTabForContentView(tabContentView, options = {})

    {

        console.assert(tabContentView instanceof WebInspector.TabContentView);

        if (!(tabContentView instanceof WebInspector.TabContentView))

@@WebInspector.TabBrowser = class TabBrowser extends WebInspector.View

        if (tabContentView.tabBarItem.parentTabBar !== this._tabBar)

            return false;

207 this._tabBar.removeTabBarItem(tabContentView.tabBarItem, doN~~otAnimate~~);

208 this._tabBar.removeTabBarItem(tabContentView.tabBarItem, options);

        console.assert(this._recentTabContentViews.length === this._tabBar.normalTabCount);

        console.assert(!this.selectedTabContentView || this.selectedTabContentView === this._recentTabContentViews[0]);

Source/WebInspectorUI/UserInterface/Views/TabContentView.js

@@WebInspector.TabContentView = class TabContentView extends WebInspector.ContentV

    {

        if (!this._navigationSidebarPanelConstructor)

            return null;

180 return WebInspector.instanceForClass(this._navigationSidebarPanelConstructor);

        if (!this._navigationSidebarPanel)

            this._navigationSidebarPanel = WebInspector.instanceForClass(this._navigationSidebarPanelConstructor);

        return this._navigationSidebarPanel;

    }

    get navigationSidebarCollapsedSetting() { return this._navigationSidebarCollapsedSetting; }

Source/WebInspectorUI/UserInterface/Views/TimelineRecordTreeElement.js

@@WebInspector.TimelineRecordTreeElement = class TimelineRecordTreeElement extends

        let iconStyleClass = WebInspector.TimelineTabContentView.iconClassNameForRecord(timelineRecord);

        let title = WebInspector.TimelineTabContentView.displayNameForRecord(timelineRecord);

58 super([iconStyleClass], title, subtitle, representedObject || timelineRecord~~, false~~);

58 super([iconStyleClass], title, subtitle, representedObject || timelineRecord);

        this._record = timelineRecord;

        this._sourceCodeLocation = sourceCodeLocation;

Source/WebInspectorUI/UserInterface/Views/TimelineTabContentView.css

}

.timeline.tab.content-view .navigation-bar > .item.radio {

44 margin-top: 5px;

4544 height: 17px;

4645}

Source/WebInspectorUI/UserInterface/Views/TimelineView.css

}

.panel.navigation.timeline.timeline-recording-content-view-showing > .content > .tree-outline {

45 background-image: linear-gradient(to bottom, transparent, transparent 50%, hsla(0, 0%, 0%, 0.03) 50%, hsla(0, 0%, 0%, 0.03));

46 background-size: 100% 40px;

45 background: var(--transparent-stripe-background-gradient);

4746}

Source/WebInspectorUI/UserInterface/Views/TreeElement.js

WebInspector.TreeElement = class TreeElement extends WebInspector.Object

{

31 constructor(title, representedObject, hasChildren)

31 constructor(title, representedObject, {hasChildren} = {})

    {

        super();

Source/WebInspectorUI/UserInterface/Views/TreeOutline.js

@@WebInspector.TreeOutline = class TreeOutline extends WebInspector.Object

        }

        this.children = [];

316 this.hasChildren = false;

    }

    removeChildrenRecursive(suppressOnDeselect)

Source/WebInspectorUI/UserInterface/Views/TypeTreeElement.js

@@WebInspector.TypeTreeElement = class TypeTreeElement extends WebInspector.Genera

{

    constructor(name, structureDescription, isPrototype)

    {

30 super(null, null, null, structureDescription || null~~, false~~);

30 super(null, null, null, structureDescription || null);

        console.assert(!structureDescription || structureDescription instanceof WebInspector.StructureDescription);

Source/WebInspectorUI/UserInterface/Views/Variables.css

    --text-color-gray-medium: hsl(0, 0%, 50%);

    --error-text-color: hsl(0, 86%, 47%);

    --value-changed-highlight: hsla(83, 100%, 48%, 0.4);

    --value-visual-highlight: hsla(60, 100%, 50%, 0.4);

    --breakpoint-fill-color: hsl(212, 45%, 54%);

    --breakpoint-stroke-color: hsl(212, 45%, 48%);

    --breakpoint-disabled-fill-color: hsl(212, 40%, 84%);

    --even-zebra-stripe-row-background-color: white;

    --odd-zebra-stripe-row-background-color: hsl(0, 0%, 95%);

97 --transparent-stripe-background-gradient: linear-gradient(to bottom, transparent, transparent 50%, hsla(0, 0%, 0%, 0.03) 50%, hsla(0, 0%, 0%, 0.03)) top left / 100% 40px;

    --toolbar-height: 36px;

    --tab-bar-height: 24px;