Changeset 222888 in webkit


Ignore:
Timestamp:
Oct 4, 2017 4:51:47 PM (6 years ago)
Author:
Matt Baker
Message:

Web Inspector: Improve CanvasManager recording events
https://bugs.webkit.org/show_bug.cgi?id=177762

Reviewed by Devin Rousso.

Source/JavaScriptCore:

  • inspector/protocol/Canvas.json:

Renamed events for clarity and consistency; made recording data optional.

Source/WebCore:

Dispatch Canvas.recordingFinished regardless of whether any actions were
recorded. Without this extra guarantee, the frontend has to keep track
of additional state to determine whether a recording is in progress.

  • inspector/InspectorCanvasAgent.cpp:

(WebCore::InspectorCanvasAgent::startRecording):
(WebCore::InspectorCanvasAgent::stopRecording):
(WebCore::InspectorCanvasAgent::didFinishRecordingCanvasFrame):
(WebCore::InspectorCanvasAgent::requestRecording): Deleted.
(WebCore::InspectorCanvasAgent::cancelRecording): Deleted.

  • inspector/InspectorCanvasAgent.h:

Source/WebInspectorUI:

  • UserInterface/Controllers/CanvasManager.js:

(WI.CanvasManager.prototype.startRecording):
(WI.CanvasManager.prototype.stopRecording):
(WI.CanvasManager.prototype.recordingFinished):
Replace the RecordingFinished event with a pair of events. RecordingStarted
is sent when CanvasAgent.startRecording succeeds. RecordingStopped is
sent when a recordingFinished event is received from the backend, or
when a call to CanvasAgent.stopRecording fails.

  • UserInterface/Views/CanvasContentView.js:

(WI.CanvasContentView.prototype.initialLayout):
(WI.CanvasContentView.prototype._toggleRecording):
(WI.CanvasContentView.prototype._recordingStarted):
(WI.CanvasContentView.prototype._recordingFinished): Deleted.
Update recording status when CanvasManager fires recording events,
instead of immediately after clicking the record button.

LayoutTests:

Update tests for renamed CanvasManager event.

  • inspector/canvas/recording-2d.html:
  • inspector/canvas/recording-expected.txt:
  • inspector/canvas/recording-webgl-snapshots.html:
  • inspector/canvas/recording-webgl.html:
  • inspector/canvas/recording.html:
  • inspector/canvas/resources/recording-utilities.js:

(TestPage.registerInitializer):

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r222887 r222888  
     12017-10-04  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve CanvasManager recording events
     4        https://bugs.webkit.org/show_bug.cgi?id=177762
     5
     6        Reviewed by Devin Rousso.
     7
     8        Update tests for renamed CanvasManager event.
     9
     10        * inspector/canvas/recording-2d.html:
     11        * inspector/canvas/recording-expected.txt:
     12        * inspector/canvas/recording-webgl-snapshots.html:
     13        * inspector/canvas/recording-webgl.html:
     14        * inspector/canvas/recording.html:
     15        * inspector/canvas/resources/recording-utilities.js:
     16        (TestPage.registerInitializer):
     17
    1182017-10-04  Nan Wang  <n_wang@apple.com>
    219
  • trunk/LayoutTests/inspector/canvas/recording-2d.html

    r222182 r222888  
    407407        description: "Check that the recording is stopped after a single frame.",
    408408        test(resolve, reject) {
    409             requestRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {singleFrame: true});
     409            startRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {singleFrame: true});
    410410        },
    411411    });
     
    415415        description: "Check that recording data is serialized correctly for multiple frames.",
    416416        test(resolve, reject) {
    417             let canvas = requestRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {singleFrame: false});
     417            let canvas = startRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {singleFrame: false});
    418418
    419419            InspectorTest.singleFireEventListener("LastFrame", () => {
    420                 CanvasAgent.cancelRecording(canvas.identifier, (error) => {
     420                CanvasAgent.stopRecording(canvas.identifier, (error) => {
    421421                    if (error) {
    422422                        reject(error);
     
    432432        description: "Check that the recording is stopped when it reaches the memory limit.",
    433433        test(resolve, reject) {
    434             requestRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {memoryLimit: 10});
     434            startRecording(WI.Canvas.ContextType.Canvas2D, resolve, reject, {memoryLimit: 10});
    435435        },
    436436    });
     
    446446            }
    447447
    448             WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingFinished)
     448            WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingStopped)
    449449            .then((event) => {
    450450                let recording = event.data.recording.toJSON();
     
    461461
    462462            const singleFrame = true;
    463             CanvasAgent.requestRecording(canvas.identifier, singleFrame, (error) => {
     463            CanvasAgent.startRecording(canvas.identifier, singleFrame, (error) => {
    464464                if (error) {
    465465                    reject(error);
  • trunk/LayoutTests/inspector/canvas/recording-expected.txt

    r220008 r222888  
    33
    44== Running test suite: Canvas.recording
    5 -- Running test case: Canvas.requestRecording.InvalidCanvasId
     5-- Running test case: Canvas.startRecording.InvalidCanvasId
    66PASS: Should produce an error.
    77Error: No canvas for given identifier.
    88
    9 -- Running test case: Canvas.cancelRecording.InvalidCanvasId
     9-- Running test case: Canvas.stopRecording.InvalidCanvasId
    1010PASS: Should produce an error.
    1111Error: No canvas for given identifier.
  • trunk/LayoutTests/inspector/canvas/recording-webgl-snapshots.html

    r222182 r222888  
    9797        description: "Check that the snapshot taken after each visual action is different.",
    9898        test(resolve, reject) {
    99             requestRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: true});
     99            startRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: true});
    100100        },
    101101    });
  • trunk/LayoutTests/inspector/canvas/recording-webgl.html

    r222182 r222888  
    504504        description: "Check that the recording is stopped after a single frame.",
    505505        test(resolve, reject) {
    506             requestRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: true});
     506            startRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: true});
    507507        },
    508508    });
     
    512512        description: "Check that recording data is serialized correctly for multiple frames.",
    513513        test(resolve, reject) {
    514             let canvas = requestRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: false});
     514            let canvas = startRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {singleFrame: false});
    515515
    516516            InspectorTest.singleFireEventListener("LastFrame", () => {
    517                 CanvasAgent.cancelRecording(canvas.identifier, (error) => {
     517                CanvasAgent.stopRecording(canvas.identifier, (error) => {
    518518                    if (error) {
    519519                        reject(error);
     
    529529        description: "Check that the recording is stopped when it reaches the memory limit.",
    530530        test(resolve, reject) {
    531             requestRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {memoryLimit: 10});
     531            startRecording(WI.Canvas.ContextType.WebGL, resolve, reject, {memoryLimit: 10});
    532532        },
    533533    });
  • trunk/LayoutTests/inspector/canvas/recording.html

    r220008 r222888  
    88
    99    suite.addTestCase({
    10         name: "Canvas.requestRecording.InvalidCanvasId",
     10        name: "Canvas.startRecording.InvalidCanvasId",
    1111        description: "Invalid canvas identifiers should cause an error.",
    1212        test(resolve, reject) {
    1313            const canvasId = "DOES_NOT_EXIST";
    14             CanvasAgent.requestRecording(canvasId, (error) => {
     14            CanvasAgent.startRecording(canvasId, (error) => {
    1515                InspectorTest.expectThat(error, "Should produce an error.");
    1616                InspectorTest.log("Error: " + error);
     
    2121
    2222    suite.addTestCase({
    23         name: "Canvas.cancelRecording.InvalidCanvasId",
     23        name: "Canvas.stopRecording.InvalidCanvasId",
    2424        description: "Invalid canvas identifiers should cause an error.",
    2525        test(resolve, reject) {
    2626            const canvasId = "DOES_NOT_EXIST";
    27             CanvasAgent.cancelRecording(canvasId, (error) => {
     27            CanvasAgent.stopRecording(canvasId, (error) => {
    2828                InspectorTest.expectThat(error, "Should produce an error.");
    2929                InspectorTest.log("Error: " + error);
  • trunk/LayoutTests/inspector/canvas/resources/recording-utilities.js

    r222182 r222888  
    9494    };
    9595
    96     window.requestRecording = function(type, resolve, reject, {singleFrame, memoryLimit} = {}) {
     96    window.startRecording = function(type, resolve, reject, {singleFrame, memoryLimit} = {}) {
    9797        let canvas = getCanvas(type);
    9898        if (!canvas) {
     
    101101        }
    102102
    103         WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingFinished).then((event) => {
     103        WI.canvasManager.awaitEvent(WI.CanvasManager.Event.RecordingStopped).then((event) => {
    104104            InspectorTest.evaluateInPage(`cancelActions()`);
    105105
     
    112112        }).then(resolve, reject);
    113113
    114         CanvasAgent.requestRecording(canvas.identifier, singleFrame, memoryLimit, (error) => {
     114        CanvasAgent.startRecording(canvas.identifier, singleFrame, memoryLimit, (error) => {
    115115            if (error) {
    116116                reject(error);
  • trunk/Source/JavaScriptCore/ChangeLog

    r222878 r222888  
     12017-10-04  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve CanvasManager recording events
     4        https://bugs.webkit.org/show_bug.cgi?id=177762
     5
     6        Reviewed by Devin Rousso.
     7
     8        * inspector/protocol/Canvas.json:
     9        Renamed events for clarity and consistency; made recording data optional.
     10
    1112017-10-04  JF Bastien  <jfbastien@apple.com>
    212
  • trunk/Source/JavaScriptCore/inspector/protocol/Canvas.json

    r221025 r222888  
    106106        },
    107107        {
    108             "name": "requestRecording",
    109             "description": "Requests that the next frame or up to the given number of bytes of data be recorded for the given canvas.",
     108            "name": "startRecording",
     109            "description": "Record the next frame, or up to the given number of bytes of data, for the given canvas.",
    110110            "parameters": [
    111111                { "name": "canvasId", "$ref": "CanvasId" },
     
    115115        },
    116116        {
    117             "name": "cancelRecording",
    118             "description": "Cancels a requested recording for the given canvas.",
     117            "name": "stopRecording",
     118            "description": "Stop recording the given canvas.",
    119119            "parameters": [
    120120                { "name": "canvasId", "$ref": "CanvasId" }
     
    180180            "parameters": [
    181181                { "name": "canvasId", "$ref": "CanvasId" },
    182                 { "name": "recording", "$ref": "Recording.Recording" }
     182                { "name": "recording", "$ref": "Recording.Recording", "optional": true }
    183183            ]
    184184        },
  • trunk/Source/WebCore/ChangeLog

    r222887 r222888  
     12017-10-04  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve CanvasManager recording events
     4        https://bugs.webkit.org/show_bug.cgi?id=177762
     5
     6        Reviewed by Devin Rousso.
     7
     8        Dispatch Canvas.recordingFinished regardless of whether any actions were
     9        recorded. Without this extra guarantee, the frontend has to keep track
     10        of additional state to determine whether a recording is in progress.
     11
     12        * inspector/InspectorCanvasAgent.cpp:
     13        (WebCore::InspectorCanvasAgent::startRecording):
     14        (WebCore::InspectorCanvasAgent::stopRecording):
     15        (WebCore::InspectorCanvasAgent::didFinishRecordingCanvasFrame):
     16        (WebCore::InspectorCanvasAgent::requestRecording): Deleted.
     17        (WebCore::InspectorCanvasAgent::cancelRecording): Deleted.
     18        * inspector/InspectorCanvasAgent.h:
     19
    1202017-10-04  Nan Wang  <n_wang@apple.com>
    221
  • trunk/Source/WebCore/inspector/InspectorCanvasAgent.cpp

    r221232 r222888  
    238238}
    239239
    240 void InspectorCanvasAgent::requestRecording(ErrorString& errorString, const String& canvasId, const bool* const singleFrame, const int* const memoryLimit)
     240void InspectorCanvasAgent::startRecording(ErrorString& errorString, const String& canvasId, const bool* const singleFrame, const int* const memoryLimit)
    241241{
    242242    auto* inspectorCanvas = assertInspectorCanvas(errorString, canvasId);
     
    258258}
    259259
    260 void InspectorCanvasAgent::cancelRecording(ErrorString& errorString, const String& canvasId)
     260void InspectorCanvasAgent::stopRecording(ErrorString& errorString, const String& canvasId)
    261261{
    262262    auto* inspectorCanvas = assertInspectorCanvas(errorString, canvasId);
     
    461461        return;
    462462
    463     if (!inspectorCanvas->hasRecordingData())
    464         return;
     463    if (!inspectorCanvas->hasRecordingData()) {
     464        if (forceDispatch)
     465            m_frontendDispatcher->recordingFinished(inspectorCanvas->identifier(), nullptr);
     466        return;
     467    }
    465468
    466469    if (!forceDispatch && !inspectorCanvas->singleFrame()) {
  • trunk/Source/WebCore/inspector/InspectorCanvasAgent.h

    r221025 r222888  
    7474    void requestCSSCanvasClientNodes(ErrorString&, const String& canvasId, RefPtr<Inspector::Protocol::Array<int>>&) override;
    7575    void resolveCanvasContext(ErrorString&, const String& canvasId, const String* const objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) override;
    76     void requestRecording(ErrorString&, const String& canvasId, const bool* const singleFrame, const int* const memoryLimit) override;
    77     void cancelRecording(ErrorString&, const String& canvasId) override;
     76    void startRecording(ErrorString&, const String& canvasId, const bool* const singleFrame, const int* const memoryLimit) override;
     77    void stopRecording(ErrorString&, const String& canvasId) override;
    7878    void requestShaderSource(ErrorString&, const String& programId, const String& shaderType, String*) override;
    7979    void updateShader(ErrorString&, const String& programId, const String& shaderType, const String& source) override;
  • trunk/Source/WebInspectorUI/ChangeLog

    r222868 r222888  
     12017-10-04  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve CanvasManager recording events
     4        https://bugs.webkit.org/show_bug.cgi?id=177762
     5
     6        Reviewed by Devin Rousso.
     7
     8        * UserInterface/Controllers/CanvasManager.js:
     9        (WI.CanvasManager.prototype.startRecording):
     10        (WI.CanvasManager.prototype.stopRecording):
     11        (WI.CanvasManager.prototype.recordingFinished):
     12        Replace the RecordingFinished event with a pair of events. RecordingStarted
     13        is sent when CanvasAgent.startRecording succeeds. RecordingStopped is
     14        sent when a recordingFinished event is received from the backend, or
     15        when a call to CanvasAgent.stopRecording fails.
     16
     17        * UserInterface/Views/CanvasContentView.js:
     18        (WI.CanvasContentView.prototype.initialLayout):
     19        (WI.CanvasContentView.prototype._toggleRecording):
     20        (WI.CanvasContentView.prototype._recordingStarted):
     21        (WI.CanvasContentView.prototype._recordingFinished): Deleted.
     22        Update recording status when CanvasManager fires recording events,
     23        instead of immediately after clicking the record button.
     24
    1252017-10-04  Joseph Pecoraro  <pecoraro@apple.com>
    226
  • trunk/Source/WebInspectorUI/UserInterface/Controllers/CanvasManager.js

    r222171 r222888  
    6262        this._recordingCanvas = canvas;
    6363
    64         CanvasAgent.requestRecording(canvas.identifier, singleFrame, (error) => {
     64        CanvasAgent.startRecording(canvas.identifier, singleFrame, (error) => {
     65            if (error) {
     66                console.error(error);
     67                this._recordingCanvas = null;
     68                return;
     69            }
     70
     71            this.dispatchEventToListeners(WI.CanvasManager.Event.RecordingStarted, {canvas});
     72        });
     73    }
     74
     75    stopRecording()
     76    {
     77        console.assert(this._recordingCanvas, "No recording started.");
     78        if (!this._recordingCanvas)
     79            return;
     80
     81        let canvas = this._recordingCanvas;
     82        this._recordingCanvas = null;
     83
     84        CanvasAgent.stopRecording(canvas.identifier, (error) => {
    6585            if (!error)
    6686                return;
    6787
    6888            console.error(error);
    69             this._recordingCanvas = null;
    70 
    71             this.dispatchEventToListeners(WI.CanvasManager.Event.RecordingFinished, {canvas, recording: null});
    72         });
    73     }
    74 
    75     stopRecording()
    76     {
    77         console.assert(this._recordingCanvas, "No recording started.");
    78         if (!this._recordingCanvas)
    79             return;
    80 
    81         let canvasIdentifier = this._recordingCanvas.identifier;
    82         this._recordingCanvas = null;
    83 
    84         CanvasAgent.cancelRecording(canvasIdentifier, (error) => {
    85             if (error)
    86                 console.error(error);
     89            this.dispatchEventToListeners(WI.CanvasManager.Event.RecordingStopped, {canvas, recording: null});
    8790        });
    8891    }
     
    156159            return;
    157160
    158         let recording = WI.Recording.fromPayload(recordingPayload);
    159         recording.source = canvas;
    160 
    161         this.dispatchEventToListeners(WI.CanvasManager.Event.RecordingFinished, {canvas, recording});
     161        let recording = recordingPayload ? WI.Recording.fromPayload(recordingPayload) : null
     162        if (recording)
     163            recording.source = canvas;
     164
     165        this.dispatchEventToListeners(WI.CanvasManager.Event.RecordingStopped, {canvas, recording});
    162166    }
    163167
     
    223227    CanvasWasAdded: "canvas-manager-canvas-was-added",
    224228    CanvasWasRemoved: "canvas-manager-canvas-was-removed",
    225     RecordingFinished: "canvas-managger-recording-finished",
     229    RecordingStarted: "canvas-manager-recording-started",
     230    RecordingStopped: "canvas-manager-recording-stopped",
    226231    ShaderProgramAdded: "canvas-manager-shader-program-added",
    227232    ShaderProgramRemoved: "canvas-manager-shader-program-removed",
  • trunk/Source/WebInspectorUI/UserInterface/Views/CanvasContentView.js

    r221901 r222888  
    7070        super.initialLayout();
    7171
    72         WI.canvasManager.addEventListener(WI.CanvasManager.Event.RecordingFinished, this._recordingFinished, this);
     72        WI.canvasManager.addEventListener(WI.CanvasManager.Event.RecordingStarted, this._recordingStarted, this);
     73        WI.canvasManager.addEventListener(WI.CanvasManager.Event.RecordingStopped, this._recordingStopped, this);
    7374    }
    7475
     
    107108            WI.canvasManager.startRecording(this.representedObject, singleFrame);
    108109        }
     110    }
    109111
     112    _recordingStarted(event)
     113    {
    110114        this._updateRecordNavigationItem();
    111115    }
    112116
    113     _recordingFinished(event)
     117    _recordingStopped(event)
    114118    {
    115119        this._updateRecordNavigationItem();
Note: See TracChangeset for help on using the changeset viewer.