Changeset 238199 in webkit


Ignore:
Timestamp:
Nov 14, 2018 2:03:14 PM (5 years ago)
Author:
Devin Rousso
Message:

Web Inspector: Canvas: send a call stack with each action instead of an array of call frames
​https://bugs.webkit.org/show_bug.cgi?id=191628

Reviewed by Dean Jackson.

Source/WebCore:

Updated existing test: inspector/model/recording.html

  • inspector/InspectorCanvas.h:
  • inspector/InspectorCanvas.cpp:

(WebCore::InspectorCanvas::indexForData):
(WebCore::InspectorCanvas::buildInitialState):
(WebCore::InspectorCanvas::buildAction):
Drive-by: prevent de-duplicated objects from being destroyed while recording.

Source/WebInspectorUI:

  • UserInterface/Models/Recording.js:

(WI.Recording.prototype.async swizzle):

  • UserInterface/Models/RecordingAction.js:

(WI.RecordingAction.fromPayload):
(WI.RecordingAction.prototype.async swizzle):

LayoutTests:

  • inspector/model/recording.html:
Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r238194 r238199  
     12018-11-14  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: send a call stack with each action instead of an array of call frames
     4        https://bugs.webkit.org/show_bug.cgi?id=191628
     5
     6        Reviewed by Dean Jackson.
     7
     8        * inspector/model/recording.html:
     9
    1102018-11-14  Ryan Haddad  <ryanhaddad@apple.com>
    211

  • trunk/LayoutTests/inspector/model/recording-expected.txt

    r237198 r238199  
    161161            0
    162162          ],
    163           [
    164             0
    165           ]
     163          0
    166164        ]
    167165      ],

  • trunk/LayoutTests/inspector/model/recording.html

    r237198 r238199  
    169169                                [0],
    170170                                [0],
    171                                 [0],
     171                                0,
    172172                            ],
    173173                        ],

  • trunk/Source/WebCore/ChangeLog

    r238196 r238199  
     12018-11-14  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: send a call stack with each action instead of an array of call frames
     4        https://bugs.webkit.org/show_bug.cgi?id=191628
     5
     6        Reviewed by Dean Jackson.
     7
     8        Updated existing test: inspector/model/recording.html
     9
     10        * inspector/InspectorCanvas.h:
     11        * inspector/InspectorCanvas.cpp:
     12        (WebCore::InspectorCanvas::indexForData):
     13        (WebCore::InspectorCanvas::buildInitialState):
     14        (WebCore::InspectorCanvas::buildAction):
     15        Drive-by: prevent de-duplicated objects from being destroyed while recording.
     16
    1172018-11-14  Stephan Szabo  <stephan.szabo@sony.com>
    218

  • trunk/Source/WebCore/inspector/InspectorCanvas.cpp

    r237670 r238199  
    6868#endif
    6969#include <JavaScriptCore/IdentifiersFactory.h>
    70 #include <JavaScriptCore/ScriptCallStack.h>
    7170#include <JavaScriptCore/ScriptCallStackFactory.h>
    72 
    7371
    7472namespace WebCore {
    … …  
    344342int InspectorCanvas::indexForData(DuplicateDataVariant data)
    345343{
    346     size_t index = m_indexedDuplicateData.find(data);
     344    size_t index = m_indexedDuplicateData.findMatching([&] (auto item) {
     345        if (data == item)
     346            return true;
     347
     348        auto traceA = WTF::get_if<RefPtr<ScriptCallStack>>(data);
     349        auto traceB = WTF::get_if<RefPtr<ScriptCallStack>>(item);
     350        if (traceA && *traceA && traceB && *traceB)
     351            return (*traceA)->isEqual((*traceB).get());
     352
     353        return false;
     354    });
    347355    if (index != notFound) {
    348356        ASSERT(index < std::numeric_limits<int>::max());
    … …  
    355363    RefPtr<JSON::Value> item;
    356364    WTF::switchOn(data,
    357         [&] (const HTMLImageElement* imageElement) {
     365        [&] (const RefPtr<HTMLImageElement>& imageElement) {
    358366            String dataURL = "data:,"_s;
    359367
    … …  
    370378        },
    371379#if ENABLE(VIDEO)
    372         [&] (HTMLVideoElement* videoElement) {
     380        [&] (RefPtr<HTMLVideoElement>& videoElement) {
    373381            String dataURL = "data:,"_s;
    374382
    … …  
    384392        },
    385393#endif
    386         [&] (HTMLCanvasElement* canvasElement) {
     394        [&] (RefPtr<HTMLCanvasElement>& canvasElement) {
    387395            String dataURL = "data:,"_s;
    388396
    … …  
    393401            index = indexForData(dataURL);
    394402        },
    395         [&] (const CanvasGradient* canvasGradient) { item = buildArrayForCanvasGradient(*canvasGradient); },
    396         [&] (const CanvasPattern* canvasPattern) { item = buildArrayForCanvasPattern(*canvasPattern); },
    397         [&] (const ImageData* imageData) { item = buildArrayForImageData(*imageData); },
    398         [&] (ImageBitmap* imageBitmap) {
     403        [&] (const RefPtr<CanvasGradient>& canvasGradient) { item = buildArrayForCanvasGradient(*canvasGradient); },
     404        [&] (const RefPtr<CanvasPattern>& canvasPattern) { item = buildArrayForCanvasPattern(*canvasPattern); },
     405        [&] (const RefPtr<ImageData>& imageData) { item = buildArrayForImageData(*imageData); },
     406        [&] (RefPtr<ImageBitmap>& imageBitmap) {
    399407            index = indexForData(imageBitmap->buffer()->toDataURL("image/png"));
     408        },
     409        [&] (const RefPtr<ScriptCallStack>& scriptCallStack) {
     410            auto array = JSON::ArrayOf<double>::create();
     411            for (size_t i = 0; i < scriptCallStack->size(); ++i)
     412                array->addItem(indexForData(scriptCallStack->at(i)));
     413            item = WTFMove(array);
    400414        },
    401415        [&] (const ScriptCallFrame& scriptCallFrame) {
    … …  
    490504            int strokeStyleIndex;
    491505            if (auto canvasGradient = state.strokeStyle.canvasGradient())
    492                 strokeStyleIndex = indexForData(canvasGradient.get());
     506                strokeStyleIndex = indexForData(canvasGradient);
    493507            else if (auto canvasPattern = state.strokeStyle.canvasPattern())
    494                 strokeStyleIndex = indexForData(canvasPattern.get());
     508                strokeStyleIndex = indexForData(canvasPattern);
    495509            else
    496510                strokeStyleIndex = indexForData(state.strokeStyle.color());
    … …  
    499513            int fillStyleIndex;
    500514            if (auto canvasGradient = state.fillStyle.canvasGradient())
    501                 fillStyleIndex = indexForData(canvasGradient.get());
     515                fillStyleIndex = indexForData(canvasGradient);
    502516            else if (auto canvasPattern = state.fillStyle.canvasPattern())
    503                 fillStyleIndex = indexForData(canvasPattern.get());
     517                fillStyleIndex = indexForData(canvasPattern);
    504518            else
    505519                fillStyleIndex = indexForData(state.fillStyle.color());
    … …  
    599613            [&] (const RefPtr<ArrayBuffer>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    600614            [&] (const RefPtr<ArrayBufferView>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    601             [&] (const RefPtr<CanvasGradient>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::CanvasGradient); },
    602             [&] (const RefPtr<CanvasPattern>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::CanvasPattern); },
     615            [&] (const RefPtr<CanvasGradient>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::CanvasGradient); },
     616            [&] (const RefPtr<CanvasPattern>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::CanvasPattern); },
    603617            [&] (const RefPtr<Float32Array>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    604             [&] (const RefPtr<HTMLCanvasElement>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::Image); },
    605             [&] (const RefPtr<HTMLImageElement>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::Image); },
     618            [&] (const RefPtr<HTMLCanvasElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
     619            [&] (const RefPtr<HTMLImageElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
    606620#if ENABLE(VIDEO)
    607             [&] (const RefPtr<HTMLVideoElement>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::Image); },
    608 #endif
    609             [&] (const RefPtr<ImageBitmap>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::ImageBitmap); },
    610             [&] (const RefPtr<ImageData>& value) { addParameter(indexForData(value.get()), RecordingSwizzleTypes::ImageData); },
     621            [&] (const RefPtr<HTMLVideoElement>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::Image); },
     622#endif
     623            [&] (const RefPtr<ImageBitmap>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageBitmap); },
     624            [&] (const RefPtr<ImageData>& value) { addParameter(indexForData(value), RecordingSwizzleTypes::ImageData); },
    611625            [&] (const RefPtr<Int32Array>&) { addParameter(0, RecordingSwizzleTypes::TypedArray); },
    612626            [&] (const Vector<float>& value) { addParameter(buildArrayForVector(value).ptr(), RecordingSwizzleTypes::Array); },
    … …  
    626640    action->addItem(WTFMove(swizzleTypes));
    627641
    628     auto trace = JSON::ArrayOf<double>::create();
    629     auto stackTrace = Inspector::createScriptCallStack(JSExecState::currentState(), Inspector::ScriptCallStack::maxCallStackSizeToCapture);
    630     for (size_t i = 0; i < stackTrace->size(); ++i)
    631         trace->addItem(indexForData(stackTrace->at(i)));
    632     action->addItem(WTFMove(trace));
     642    RefPtr<ScriptCallStack> trace = Inspector::createScriptCallStack(JSExecState::currentState(), Inspector::ScriptCallStack::maxCallStackSizeToCapture);
     643    action->addItem(indexForData(WTFMove(trace)));
    633644
    634645    return action;

  • trunk/Source/WebCore/inspector/InspectorCanvas.h

    r237670 r238199  
    2929#include <JavaScriptCore/InspectorProtocolObjects.h>
    3030#include <JavaScriptCore/ScriptCallFrame.h>
     31#include <JavaScriptCore/ScriptCallStack.h>
    3132#include <wtf/Variant.h>
    3233#include <wtf/Vector.h>
    … …  
    8384
    8485    using DuplicateDataVariant = Variant<
    85         CanvasGradient*,
    86         CanvasPattern*,
    87         HTMLCanvasElement*,
    88         HTMLImageElement*,
     86        RefPtr<CanvasGradient>,
     87        RefPtr<CanvasPattern>,
     88        RefPtr<HTMLCanvasElement>,
     89        RefPtr<HTMLImageElement>,
    8990#if ENABLE(VIDEO)
    90         HTMLVideoElement*,
     91        RefPtr<HTMLVideoElement>,
    9192#endif
    92         ImageData*,
    93         ImageBitmap*,
     93        RefPtr<ImageData>,
     94        RefPtr<ImageBitmap>,
     95        RefPtr<Inspector::ScriptCallStack>,
    9496        Inspector::ScriptCallFrame,
    9597        String

  • trunk/Source/WebInspectorUI/ChangeLog

    r238198 r238199  
     12018-11-14  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Canvas: send a call stack with each action instead of an array of call frames
     4        https://bugs.webkit.org/show_bug.cgi?id=191628
     5
     6        Reviewed by Dean Jackson.
     7
     8        * UserInterface/Models/Recording.js:
     9        (WI.Recording.prototype.async swizzle):
     10
     11        * UserInterface/Models/RecordingAction.js:
     12        (WI.RecordingAction.fromPayload):
     13        (WI.RecordingAction.prototype.async swizzle):
     14
    1152018-11-14  Devin Rousso  <drousso@apple.com>
    216

  • trunk/Source/WebInspectorUI/UserInterface/Models/Recording.js

    r237808 r238199  
    313313                    this._swizzle[index][type] = await createImageBitmap(image);
    314314                    break;
     315
     316                case WI.Recording.Swizzle.CallStack: {
     317                    let array = await this.swizzle(data, WI.Recording.Swizzle.Array);
     318                    this._swizzle[index][type] = await Promise.all(array.map((item) => this.swizzle(item, WI.Recording.Swizzle.CallFrame)));
     319                    break;
     320                }
     321
     322                case WI.Recording.Swizzle.CallFrame: {
     323                    let array = await this.swizzle(data, WI.Recording.Swizzle.Array);
     324                    let [functionName, url] = await Promise.all([
     325                        this.swizzle(array[0], WI.Recording.Swizzle.String),
     326                        this.swizzle(array[1], WI.Recording.Swizzle.String),
     327                    ]);
     328                    this._swizzle[index][type] = WI.CallFrame.fromPayload(WI.assumingMainTarget(), {
     329                        functionName,
     330                        url,
     331                        lineNumber: array[2],
     332                        columnNumber: array[3],
     333                    });
     334                    break;
     335                }
    315336                }
    316337            } catch { }
    … …  
    489510    WebGLUniformLocation: 18,
    490511    ImageBitmap: 19,
     512
     513    // Special frontend-only swizzle types.
     514    CallStack: Symbol("CallStack"),
     515    CallFrame: Symbol("CallFrame"),
    491516};

  • trunk/Source/WebInspectorUI/UserInterface/Models/RecordingAction.js

    r237808 r238199  
    5858    // Static
    5959
    60     // Payload format: [name, parameters, swizzleTypes, trace, [snapshot]]
     60    // Payload format: (name, parameters, swizzleTypes, [trace, [snapshot]])
    6161    static fromPayload(payload)
    6262    {
    … …  
    7373            payload[2] = [];
    7474
    75         if (!Array.isArray(payload[3]))
    76             payload[3] = [];
     75        if (isNaN(payload[3]) || (!payload[3] && payload[3] !== 0)) {
     76            // COMPATIBILITY (iOS 12.1): "trace" was sent as an array of call frames instead of a single call stack
     77            if (!Array.isArray(payload[3]))
     78                payload[3] = [];
     79        }
    7780
    7881        if (payload.length >= 5 && isNaN(payload[4]))
    … …  
    263266        };
    264267
    265         let swizzleCallFrame = async (item, index) => {
    266             let array = await recording.swizzle(item, WI.Recording.Swizzle.None);
    267             let [functionName, url] = await Promise.all([
    268                 recording.swizzle(array[0], WI.Recording.Swizzle.String),
    269                 recording.swizzle(array[1], WI.Recording.Swizzle.String),
    270             ]);
    271             return WI.CallFrame.fromPayload(WI.mainTarget, {
    272                 functionName,
    273                 url,
    274                 lineNumber: array[2],
    275                 columnNumber: array[3],
    276             });
    277         };
    278 
    279268        let swizzlePromises = [
    280269            recording.swizzle(this._payloadName, WI.Recording.Swizzle.String),
    281270            Promise.all(this._payloadParameters.map(swizzleParameter)),
    282             Promise.all(this._payloadTrace.map(swizzleCallFrame)),
    283271        ];
     272
     273        if (!isNaN(this._payloadTrace))
     274            swizzlePromises.push(recording.swizzle(this._payloadTrace, WI.Recording.Swizzle.CallStack))
     275        else {
     276            // COMPATIBILITY (iOS 12.1): "trace" was sent as an array of call frames instead of a single call stack
     277            swizzlePromises.push(Promise.all(this._payloadTrace.map((item) => recording.swizzle(item, WI.Recording.Swizzle.CallFrame))));
     278        }
     279
    284280        if (this._payloadSnapshot >= 0)
    285281            swizzlePromises.push(recording.swizzle(this._payloadSnapshot, WI.Recording.Swizzle.String));
Note: See TracChangeset for help on using the changeset viewer.