Changeset 220233 in webkit


Ignore:
Timestamp:
Aug 3, 2017, 3:31:44 PM (8 years ago)
Author:
Matt Baker
Message:

Web Inspector: Instrument WebGLProgram created/deleted
​https://bugs.webkit.org/show_bug.cgi?id=175059

Reviewed by Devin Rousso.

Source/JavaScriptCore:

Extend the Canvas protocol with types/events for tracking WebGLPrograms.

  • inspector/protocol/Canvas.json:

Source/WebCore:

Tests: inspector/canvas/shaderProgram-add-remove-webgl.html

inspector/canvas/shaderProgram-add-remove-webgl2.html

This patch adds instrumentation to WebGLRenderingContextBase for tracking
WebGLPrograms. A new helper class, InspectorShaderProgram, is used by
the CanvasAgent to hold related data.

  • CMakeLists.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::createProgram):
(WebCore::WebGLRenderingContextBase::deleteProgram):

  • inspector/InspectorCanvasAgent.cpp:

(WebCore::InspectorCanvasAgent::enable):
(WebCore::InspectorCanvasAgent::frameNavigated):
(WebCore::InspectorCanvasAgent::didCreateProgram):
(WebCore::InspectorCanvasAgent::willDeleteProgram):
(WebCore::InspectorCanvasAgent::clearCanvasData):
(WebCore::InspectorCanvasAgent::unbindCanvas):
(WebCore::InspectorCanvasAgent::unbindProgram):
(WebCore::InspectorCanvasAgent::assertInspectorProgram):
(WebCore::InspectorCanvasAgent::findInspectorProgram):

  • inspector/InspectorCanvasAgent.h:
  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::didCreateCSSCanvasImpl):
(WebCore::InspectorInstrumentation::didChangeCSSCanvasClientNodesImpl):
(WebCore::InspectorInstrumentation::didCreateCanvasRenderingContextImpl):
(WebCore::InspectorInstrumentation::didChangeCanvasMemoryImpl):
(WebCore::InspectorInstrumentation::recordCanvasActionImpl):
(WebCore::InspectorInstrumentation::didFinishRecordingCanvasFrameImpl):
(WebCore::InspectorInstrumentation::didCreateProgramImpl):
(WebCore::InspectorInstrumentation::willDeleteProgramImpl):

  • inspector/InspectorInstrumentation.h:

(WebCore::InspectorInstrumentation::recordCanvasActionImpl):
(WebCore::InspectorInstrumentation::didCreateCSSCanvas):
(WebCore::InspectorInstrumentation::didChangeCSSCanvasClientNodes):
(WebCore::InspectorInstrumentation::didCreateCanvasRenderingContext):
(WebCore::InspectorInstrumentation::didChangeCanvasMemory):
(WebCore::InspectorInstrumentation::recordCanvasAction):
(WebCore::InspectorInstrumentation::didFinishRecordingCanvasFrame):
(WebCore::InspectorInstrumentation::didCreateProgram):
(WebCore::InspectorInstrumentation::willDeleteProgram):

  • inspector/InspectorShaderProgram.cpp: Added.

(WebCore::InspectorShaderProgram::create):
(WebCore::InspectorShaderProgram::InspectorShaderProgram):
(WebCore::InspectorShaderProgram::context const):

  • inspector/InspectorShaderProgram.h: Added.

Source/WebInspectorUI:

This patch adds frontend support for shader program instrumentation.
The frontend creates a ShaderProgram model object for each WebGLProgram.
Since only canvases with a WebGL context have programs, the Canvas model
object does not contain any logic specific to programs. CanvasManager
dispatches program added/removed events, and the parent Canvas can be
accessed from ShaderProgram but not the other way around.

  • UserInterface/Controllers/CanvasManager.js:

(WI.CanvasManager):
(WI.CanvasManager.prototype.get shaderPrograms):
(WI.CanvasManager.prototype.canvasRemoved):
(WI.CanvasManager.prototype.programCreated):
(WI.CanvasManager.prototype.programDeleted):
(WI.CanvasManager.prototype._mainResourceDidChange):
(WI.CanvasManager.prototype._dispatchShaderProgramRemoved):

  • UserInterface/Main.html:
  • UserInterface/Models/Canvas.js:

(WI.Canvas.prototype.nextShaderProgramDisplayNumber):
(WI.Canvas):

  • UserInterface/Models/ShaderProgram.js: Added.

(WI.ShaderProgram):
(WI.ShaderProgram.prototype.get identifier):
(WI.ShaderProgram.prototype.get canvas):
(WI.ShaderProgram.prototype.get displayName):

  • UserInterface/Protocol/CanvasObserver.js:

(WI.CanvasObserver.prototype.programCreated):
(WI.CanvasObserver.prototype.programDeleted):
(WI.CanvasObserver):

  • UserInterface/Test.html:

LayoutTests:

Add tests for CanvasManager shader program events and ShaderProgram model object.
WebGL and WebGL2 contexts are tested separately based on platform support.

  • inspector/canvas/resources/shaderProgram-utilities.js: Added.

(createProgram):
(deleteProgram):
(deleteContext):
(TestPage.registerInitializer.awaitProgramAdded):
(TestPage.registerInitializer):
(TestPage.registerInitializer.window.initializeTestSuite):
(TestPage.registerInitializer.window.addSimpleTestCase):
(TestPage.registerInitializer.window.addParentCanvasRemovedTestCase):

  • inspector/canvas/shaderProgram-add-remove-webgl-expected.txt: Added.
  • inspector/canvas/shaderProgram-add-remove-webgl.html: Added.
  • inspector/canvas/shaderProgram-add-remove-webgl2-expected.txt: Added.
  • inspector/canvas/shaderProgram-add-remove-webgl2.html: Added.
  • platform/gtk/TestExpectations:
  • platform/mac/TestExpectations:
  • platform/win/TestExpectations:
Location:
trunk
Files:
7 added
20 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r220223 r220233  
     12017-08-03  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Instrument WebGLProgram created/deleted
     4        https://bugs.webkit.org/show_bug.cgi?id=175059
     5
     6        Reviewed by Devin Rousso.
     7
     8        Add tests for CanvasManager shader program events and ShaderProgram model object.
     9        WebGL and WebGL2 contexts are tested separately based on platform support.
     10
     11        * inspector/canvas/resources/shaderProgram-utilities.js: Added.
     12        (createProgram):
     13        (deleteProgram):
     14        (deleteContext):
     15        (TestPage.registerInitializer.awaitProgramAdded):
     16        (TestPage.registerInitializer):
     17        (TestPage.registerInitializer.window.initializeTestSuite):
     18        (TestPage.registerInitializer.window.addSimpleTestCase):
     19        (TestPage.registerInitializer.window.addParentCanvasRemovedTestCase):
     20
     21        * inspector/canvas/shaderProgram-add-remove-webgl-expected.txt: Added.
     22        * inspector/canvas/shaderProgram-add-remove-webgl.html: Added.
     23        * inspector/canvas/shaderProgram-add-remove-webgl2-expected.txt: Added.
     24        * inspector/canvas/shaderProgram-add-remove-webgl2.html: Added.
     25
     26        * platform/gtk/TestExpectations:
     27        * platform/mac/TestExpectations:
     28        * platform/win/TestExpectations:
     29
    1302017-08-03  Youenn Fablet  <youenn@apple.com>
    231

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r220218 r220233  
    592592webkit.org/b/166536 inspector/canvas/requestContent-webgl2.html [ Skip ]
    593593webkit.org/b/166536 inspector/canvas/resolveCanvasContext-webgl2.html [ Skip ]
     594webkit.org/b/166536 inspector/canvas/shaderProgram-add-remove-webgl2.html [ Skip ]
    594595
    595596# These tests reference specific fonts on Mac port.

  • trunk/LayoutTests/platform/mac/TestExpectations

    r220164 r220233  
    11391139webkit.org/b/174066 inspector/canvas/create-context-webgpu.html [ Pass Timeout ]
    11401140webkit.org/b/174272 inspector/canvas/css-canvas-clients.html [ Pass Timeout ]
     1141webkit.org/b/174066 inspector/canvas/shaderProgram-add-remove-webgl2.html [ Pass Timeout ]
    11411142webkit.org/b/170615 inspector/codemirror/prettyprinting-css.html [ Pass Timeout ]
    11421143webkit.org/b/153460 inspector/codemirror/prettyprinting-css-rules.html [ Pass Timeout ]

  • trunk/LayoutTests/platform/win/TestExpectations

    r220218 r220233  
    19141914inspector/canvas/resolveCanvasContext-webgl.html [ Skip ]
    19151915inspector/canvas/resolveCanvasContext-webgl2.html [ Skip ]
     1916inspector/canvas/shaderProgram-add-remove-webgl.html [ Skip ]
     1917inspector/canvas/shaderProgram-add-remove-webgl2.html [ Skip ]
    19161918################################################################################
    19171919#################          End WebGL Issues              #######################

  • trunk/Source/JavaScriptCore/ChangeLog

    r220220 r220233  
     12017-08-03  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Instrument WebGLProgram created/deleted
     4        https://bugs.webkit.org/show_bug.cgi?id=175059
     5
     6        Reviewed by Devin Rousso.
     7
     8        Extend the Canvas protocol with types/events for tracking WebGLPrograms.
     9
     10        * inspector/protocol/Canvas.json:
     11
    1122017-08-03  Brady Eidson  <beidson@apple.com>
    213

  • trunk/Source/JavaScriptCore/inspector/protocol/Canvas.json

    r219964 r220233  
    88            "type": "string",
    99            "description": "Unique canvas identifier."
     10        },
     11        {
     12            "id": "ProgramId",
     13            "type": "string",
     14            "description": "Unique shader program identifier."
    1015        },
    1116        {
    … …  
    143148                { "name": "recording", "$ref": "Recording.Recording" }
    144149            ]
     150        },
     151        {
     152            "name": "programCreated",
     153            "parameters": [
     154                { "name": "canvasId", "$ref": "CanvasId", "description": "Canvas identifier." },
     155                { "name": "programId", "$ref": "ProgramId", "description": "Program identifier." }
     156            ]
     157        },
     158        {
     159            "name": "programDeleted",
     160            "parameters": [
     161                { "name": "programId", "$ref": "ProgramId", "description": "Program identifier." }
     162            ]
    145163        }
    146164    ]

  • trunk/Source/WebCore/CMakeLists.txt

    r220220 r220233  
    32473247        html/canvas/WebGLVertexArrayObjectBase.cpp
    32483248        html/canvas/WebGLVertexArrayObjectOES.cpp
     3249
     3250        inspector/InspectorShaderProgram.cpp
    32493251    )
    32503252    list(APPEND WebCore_IDL_FILES

  • trunk/Source/WebCore/ChangeLog

    r220226 r220233  
     12017-08-03  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Instrument WebGLProgram created/deleted
     4        https://bugs.webkit.org/show_bug.cgi?id=175059
     5
     6        Reviewed by Devin Rousso.
     7
     8        Tests: inspector/canvas/shaderProgram-add-remove-webgl.html
     9               inspector/canvas/shaderProgram-add-remove-webgl2.html
     10
     11        This patch adds instrumentation to WebGLRenderingContextBase for tracking
     12        WebGLPrograms. A new helper class, InspectorShaderProgram, is used by
     13        the CanvasAgent to hold related data.
     14
     15        * CMakeLists.txt:
     16        * WebCore.xcodeproj/project.pbxproj:
     17
     18        * html/canvas/WebGLRenderingContextBase.cpp:
     19        (WebCore::WebGLRenderingContextBase::createProgram):
     20        (WebCore::WebGLRenderingContextBase::deleteProgram):
     21
     22        * inspector/InspectorCanvasAgent.cpp:
     23        (WebCore::InspectorCanvasAgent::enable):
     24        (WebCore::InspectorCanvasAgent::frameNavigated):
     25        (WebCore::InspectorCanvasAgent::didCreateProgram):
     26        (WebCore::InspectorCanvasAgent::willDeleteProgram):
     27        (WebCore::InspectorCanvasAgent::clearCanvasData):
     28        (WebCore::InspectorCanvasAgent::unbindCanvas):
     29        (WebCore::InspectorCanvasAgent::unbindProgram):
     30        (WebCore::InspectorCanvasAgent::assertInspectorProgram):
     31        (WebCore::InspectorCanvasAgent::findInspectorProgram):
     32        * inspector/InspectorCanvasAgent.h:
     33
     34        * inspector/InspectorInstrumentation.cpp:
     35        (WebCore::InspectorInstrumentation::didCreateCSSCanvasImpl):
     36        (WebCore::InspectorInstrumentation::didChangeCSSCanvasClientNodesImpl):
     37        (WebCore::InspectorInstrumentation::didCreateCanvasRenderingContextImpl):
     38        (WebCore::InspectorInstrumentation::didChangeCanvasMemoryImpl):
     39        (WebCore::InspectorInstrumentation::recordCanvasActionImpl):
     40        (WebCore::InspectorInstrumentation::didFinishRecordingCanvasFrameImpl):
     41        (WebCore::InspectorInstrumentation::didCreateProgramImpl):
     42        (WebCore::InspectorInstrumentation::willDeleteProgramImpl):
     43
     44        * inspector/InspectorInstrumentation.h:
     45        (WebCore::InspectorInstrumentation::recordCanvasActionImpl):
     46        (WebCore::InspectorInstrumentation::didCreateCSSCanvas):
     47        (WebCore::InspectorInstrumentation::didChangeCSSCanvasClientNodes):
     48        (WebCore::InspectorInstrumentation::didCreateCanvasRenderingContext):
     49        (WebCore::InspectorInstrumentation::didChangeCanvasMemory):
     50        (WebCore::InspectorInstrumentation::recordCanvasAction):
     51        (WebCore::InspectorInstrumentation::didFinishRecordingCanvasFrame):
     52        (WebCore::InspectorInstrumentation::didCreateProgram):
     53        (WebCore::InspectorInstrumentation::willDeleteProgram):
     54
     55        * inspector/InspectorShaderProgram.cpp: Added.
     56        (WebCore::InspectorShaderProgram::create):
     57        (WebCore::InspectorShaderProgram::InspectorShaderProgram):
     58        (WebCore::InspectorShaderProgram::context const):
     59        * inspector/InspectorShaderProgram.h: Added.
     60
    1612017-08-03  Matt Lewis  <jlewis3@apple.com>
    262

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r220220 r220233  
    28842884                6A32D7CE1A16D8C000412F0B /* InspectorCanvasAgent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6A4B6D6619D225D8006F11D3 /* InspectorCanvasAgent.cpp */; };
    28852885                6A4B6D6519D22519006F11D3 /* InspectorCanvasAgent.h in Headers */ = {isa = PBXBuildFile; fileRef = 6A4B6D6419D22519006F11D3 /* InspectorCanvasAgent.h */; };
     2886                6A72798B1F16C29C003F39B8 /* InspectorShaderProgram.h in Headers */ = {isa = PBXBuildFile; fileRef = 6A7279881F16C29B003F39B8 /* InspectorShaderProgram.h */; };
     2887                6A72798C1F16C29C003F39B8 /* InspectorShaderProgram.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6A7279891F16C29B003F39B8 /* InspectorShaderProgram.cpp */; };
    28862888                6B3480940EEF50D400AC1B41 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B3480920EEF50D400AC1B41 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
    28872889                6B693A2E1C51A82E00B03BEF /* ResourceLoadObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B693A2D1C51A82E00B03BEF /* ResourceLoadObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1071210714                6A4B6D6419D22519006F11D3 /* InspectorCanvasAgent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorCanvasAgent.h; sourceTree = "<group>"; };
    1071310715                6A4B6D6619D225D8006F11D3 /* InspectorCanvasAgent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorCanvasAgent.cpp; sourceTree = "<group>"; };
     10716                6A7279881F16C29B003F39B8 /* InspectorShaderProgram.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorShaderProgram.h; sourceTree = "<group>"; };
     10717                6A7279891F16C29B003F39B8 /* InspectorShaderProgram.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorShaderProgram.cpp; sourceTree = "<group>"; };
    1071410718                6B3480920EEF50D400AC1B41 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
    1071510719                6B693A2D1C51A82E00B03BEF /* ResourceLoadObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceLoadObserver.h; sourceTree = "<group>"; };
    … …  
    1725017254                                4F6FDD621341DEDD001F8EE3 /* InspectorPageAgent.cpp */,
    1725117255                                4F6FDD631341DEDD001F8EE3 /* InspectorPageAgent.h */,
     17256                                6A7279891F16C29B003F39B8 /* InspectorShaderProgram.cpp */,
     17257                                6A7279881F16C29B003F39B8 /* InspectorShaderProgram.h */,
    1725217258                                82AB176F125C826700C5069D /* InspectorStyleSheet.cpp */,
    1725317259                                82AB1770125C826700C5069D /* InspectorStyleSheet.h */,
    … …  
    2777527781                                0F03C0751884805500A5F8CA /* InspectorOverlay.h in Headers */,
    2777627782                                4F6FDD651341DEDD001F8EE3 /* InspectorPageAgent.h in Headers */,
     27783                                6A72798B1F16C29C003F39B8 /* InspectorShaderProgram.h in Headers */,
    2777727784                                82AB1774125C826700C5069D /* InspectorStyleSheet.h in Headers */,
    2777827785                                754133A8102E00E800075D00 /* InspectorTimelineAgent.h in Headers */,
    … …  
    3175231759                                7C522D4B15B477E8009B7C95 /* InspectorOverlay.cpp in Sources */,
    3175331760                                4F6FDD641341DEDD001F8EE3 /* InspectorPageAgent.cpp in Sources */,
     31761                                6A72798C1F16C29C003F39B8 /* InspectorShaderProgram.cpp in Sources */,
    3175431762                                82AB1773125C826700C5069D /* InspectorStyleSheet.cpp in Sources */,
    3175531763                                754133AA102E00F400075D00 /* InspectorTimelineAgent.cpp in Sources */,

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r219856 r220233  
    15031503    auto program = WebGLProgram::create(*this);
    15041504    addSharedObject(program.get());
     1505
     1506    InspectorInstrumentation::didCreateProgram(*this, program.get());
     1507
    15051508    return WTFMove(program);
    15061509}
    … …  
    15731576void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program)
    15741577{
     1578    ASSERT(program);
     1579    InspectorInstrumentation::willDeleteProgram(*this, *program);
     1580
    15751581    deleteObject(program);
    15761582    // We don't reset m_currentProgram to 0 here because the deletion of the

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

    r220008 r220233  
    4747#if ENABLE(WEBGL)
    4848#include "JSWebGLRenderingContext.h"
     49#include "WebGLProgram.h"
    4950#endif
    5051
    … …  
    9596    for (auto& inspectorCanvas : m_identifierToInspectorCanvas.values())
    9697        m_frontendDispatcher->canvasAdded(inspectorCanvas->buildObjectForCanvas(m_instrumentingAgents));
     98
     99#if ENABLE(WEBGL)
     100    for (auto& inspectorProgram : m_identifierToInspectorProgram.values()) {
     101        auto& inspectorCanvas = inspectorProgram->canvas();
     102        m_frontendDispatcher->programCreated(inspectorCanvas.identifier(), inspectorProgram->identifier());
     103    }
     104#endif
    97105}
    98106
    … …  
    271279
    272280    Vector<InspectorCanvas*> inspectorCanvases;
    273     for (RefPtr<InspectorCanvas>& inspectorCanvas : m_identifierToInspectorCanvas.values()) {
     281    for (auto& inspectorCanvas : m_identifierToInspectorCanvas.values()) {
    274282        if (inspectorCanvas->canvas().document().frame() == &frame)
    275283            inspectorCanvases.append(inspectorCanvas.get());
    … …  
    418426}
    419427
     428#if ENABLE(WEBGL)
     429void InspectorCanvasAgent::didCreateProgram(WebGLRenderingContextBase& context, WebGLProgram& program)
     430{
     431    auto* inspectorCanvas = findInspectorCanvas(context.canvas());
     432    ASSERT(inspectorCanvas);
     433    if (!inspectorCanvas)
     434        return;
     435
     436    auto inspectorProgram = InspectorShaderProgram::create(program, *inspectorCanvas);
     437    String programIdentifier = inspectorProgram->identifier();
     438    m_identifierToInspectorProgram.set(programIdentifier, WTFMove(inspectorProgram));
     439
     440    if (m_enabled)
     441        m_frontendDispatcher->programCreated(inspectorCanvas->identifier(), programIdentifier);
     442}
     443
     444void InspectorCanvasAgent::willDeleteProgram(WebGLProgram& program)
     445{
     446    auto* inspectorProgram = findInspectorProgram(program);
     447    if (!inspectorProgram)
     448        return;
     449
     450    String identifier = unbindProgram(*inspectorProgram);
     451    if (m_enabled)
     452        m_frontendDispatcher->programDeleted(identifier);
     453}
     454#endif
     455
    420456void InspectorCanvasAgent::canvasDestroyedTimerFired()
    421457{
    … …  
    449485    m_canvasToCSSCanvasName.clear();
    450486    m_removedCanvasIdentifiers.clear();
     487#if ENABLE(WEBGL)
     488    m_identifierToInspectorProgram.clear();
     489#endif
    451490
    452491    if (m_canvasRecordingTimer.isActive())
    … …  
    460499{
    461500    ASSERT(!m_canvasToCSSCanvasName.contains(&inspectorCanvas.canvas()));
     501
     502#if ENABLE(WEBGL)
     503    Vector<InspectorShaderProgram*> programsToRemove;
     504    for (auto& inspectorProgram : m_identifierToInspectorProgram.values()) {
     505        if (&inspectorProgram->canvas() == &inspectorCanvas)
     506            programsToRemove.append(inspectorProgram.get());
     507    }
     508
     509    for (auto* inspectorProgram : programsToRemove)
     510        unbindProgram(*inspectorProgram);
     511#endif
    462512
    463513    String identifier = inspectorCanvas.identifier();
    … …  
    488538}
    489539
     540#if ENABLE(WEBGL)
     541String InspectorCanvasAgent::unbindProgram(InspectorShaderProgram& inspectorProgram)
     542{
     543    ASSERT(inspectorProgram.context());
     544
     545    String identifier = inspectorProgram.identifier();
     546    m_identifierToInspectorProgram.remove(identifier);
     547
     548    return identifier;
     549}
     550
     551InspectorShaderProgram* InspectorCanvasAgent::assertInspectorProgram(ErrorString& errorString, const String& identifier)
     552{
     553    RefPtr<InspectorShaderProgram> inspectorProgram = m_identifierToInspectorProgram.get(identifier);
     554    if (!inspectorProgram) {
     555        errorString = ASCIILiteral("No shader program for given identifier.");
     556        return nullptr;
     557    }
     558
     559    return inspectorProgram.get();
     560}
     561
     562InspectorShaderProgram* InspectorCanvasAgent::findInspectorProgram(WebGLProgram& program)
     563{
     564    for (auto& inspectorProgram : m_identifierToInspectorProgram.values()) {
     565        if (&inspectorProgram->program() == &program)
     566            return inspectorProgram.get();
     567    }
     568
     569    return nullptr;
     570}
     571#endif
     572
    490573} // namespace WebCore

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

    r220008 r220233  
    3838#include <wtf/text/WTFString.h>
    3939
     40#if ENABLE(WEBGL)
     41#include "InspectorShaderProgram.h"
     42#endif
     43
    4044namespace Inspector {
    4145class InjectedScriptManager;
    … …  
    4549
    4650class CanvasRenderingContext;
     51#if ENABLE(WEBGL)
     52class WebGLProgram;
    4753class WebGLRenderingContextBase;
     54#endif
    4855
    4956typedef String ErrorString;
    … …  
    7885    void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    7986    void didFinishRecordingCanvasFrame(HTMLCanvasElement&, bool forceDispatch = false);
     87#if ENABLE(WEBGL)
     88    void didCreateProgram(WebGLRenderingContextBase&, WebGLProgram&);
     89    void willDeleteProgram(WebGLProgram&);
     90#endif
    8091
    8192    // CanvasObserver
    … …  
    89100    void clearCanvasData();
    90101    String unbindCanvas(InspectorCanvas&);
    91     InspectorCanvas* assertInspectorCanvas(ErrorString&, const String&);
     102    InspectorCanvas* assertInspectorCanvas(ErrorString&, const String& identifier);
    92103    InspectorCanvas* findInspectorCanvas(HTMLCanvasElement&);
     104#if ENABLE(WEBGL)
     105    String unbindProgram(InspectorShaderProgram&);
     106    InspectorShaderProgram* assertInspectorProgram(ErrorString&, const String& identifier);
     107    InspectorShaderProgram* findInspectorProgram(WebGLProgram&);
     108
     109    HashMap<String, RefPtr<InspectorShaderProgram>> m_identifierToInspectorProgram;
     110#endif
    93111
    94112    std::unique_ptr<Inspector::CanvasFrontendDispatcher> m_frontendDispatcher;
    95113    RefPtr<Inspector::CanvasBackendDispatcher> m_backendDispatcher;
    96114    Inspector::InjectedScriptManager& m_injectedScriptManager;
    97 
    98115    HashMap<String, RefPtr<InspectorCanvas>> m_identifierToInspectorCanvas;
    99116    HashMap<HTMLCanvasElement*, String> m_canvasToCSSCanvasName;

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

    r220036 r220233  
    979979#endif
    980980
    981 void InspectorInstrumentation::didCreateCSSCanvasImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement, const String& name)
    982 {
    983     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     981void InspectorInstrumentation::didCreateCSSCanvasImpl(InstrumentingAgents& instrumentingAgents, HTMLCanvasElement& canvasElement, const String& name)
     982{
     983    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    984984        canvasAgent->didCreateCSSCanvas(canvasElement, name);
    985985}
    986986
    987 void InspectorInstrumentation::didChangeCSSCanvasClientNodesImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement)
    988 {
    989     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     987void InspectorInstrumentation::didChangeCSSCanvasClientNodesImpl(InstrumentingAgents& instrumentingAgents, HTMLCanvasElement& canvasElement)
     988{
     989    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    990990        canvasAgent->didChangeCSSCanvasClientNodes(canvasElement);
    991991}
    992992
    993 void InspectorInstrumentation::didCreateCanvasRenderingContextImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement)
    994 {
    995     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     993void InspectorInstrumentation::didCreateCanvasRenderingContextImpl(InstrumentingAgents& instrumentingAgents, HTMLCanvasElement& canvasElement)
     994{
     995    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    996996        canvasAgent->didCreateCanvasRenderingContext(canvasElement);
    997997}
    998998
    999 void InspectorInstrumentation::didChangeCanvasMemoryImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement)
    1000 {
    1001     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     999void InspectorInstrumentation::didChangeCanvasMemoryImpl(InstrumentingAgents& instrumentingAgents, HTMLCanvasElement& canvasElement)
     1000{
     1001    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    10021002        canvasAgent->didChangeCanvasMemory(canvasElement);
    10031003}
    10041004
    1005 void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents* instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
    1006 {
    1007     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     1005void InspectorInstrumentation::recordCanvasActionImpl(InstrumentingAgents& instrumentingAgents, CanvasRenderingContext& canvasRenderingContext, const String& name, Vector<RecordCanvasActionVariant>&& parameters)
     1006{
     1007    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    10081008        canvasAgent->recordCanvasAction(canvasRenderingContext, name, WTFMove(parameters));
    10091009}
    10101010
    1011 void InspectorInstrumentation::didFinishRecordingCanvasFrameImpl(InstrumentingAgents* instrumentingAgents, HTMLCanvasElement& canvasElement, bool forceDispatch)
    1012 {
    1013     if (InspectorCanvasAgent* canvasAgent = instrumentingAgents->inspectorCanvasAgent())
     1011void InspectorInstrumentation::didFinishRecordingCanvasFrameImpl(InstrumentingAgents& instrumentingAgents, HTMLCanvasElement& canvasElement, bool forceDispatch)
     1012{
     1013    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
    10141014        canvasAgent->didFinishRecordingCanvasFrame(canvasElement, forceDispatch);
    10151015}
     1016
     1017#if ENABLE(WEBGL)
     1018void InspectorInstrumentation::didCreateProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLRenderingContextBase& context, WebGLProgram& program)
     1019{
     1020    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
     1021        canvasAgent->didCreateProgram(context, program);
     1022}
     1023
     1024void InspectorInstrumentation::willDeleteProgramImpl(InstrumentingAgents& instrumentingAgents, WebGLProgram& program)
     1025{
     1026    if (InspectorCanvasAgent* canvasAgent = instrumentingAgents.inspectorCanvasAgent())
     1027        canvasAgent->willDeleteProgram(program);
     1028}
     1029#endif
    10161030
    10171031#if ENABLE(RESOURCE_USAGE)

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

    r220036 r220233  
    5151#include <wtf/RefPtr.h>
    5252
     53#if ENABLE(WEBGL)
     54#include "WebGLRenderingContextBase.h"
     55#endif
     56
    5357namespace Inspector {
    5458class ConsoleMessage;
    … …  
    8387class ShadowRoot;
    8488class URL;
    85 class WebGLRenderingContextBase;
     89#if ENABLE(WEBGL)
     90class WebGLProgram;
     91#endif
    8692class WebKitNamedFlow;
    8793class WorkerInspectorProxy;
    … …  
    235241    static void recordCanvasAction(CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    236242    static void didFinishRecordingCanvasFrame(HTMLCanvasElement&, bool forceDispatch = false);
     243
     244#if ENABLE(WEBGL)
     245    static void didCreateProgram(WebGLRenderingContextBase&, WebGLProgram&);
     246    static void willDeleteProgram(WebGLRenderingContextBase&, WebGLProgram&);
     247#endif
    237248
    238249    static void networkStateChanged(Page&);
    … …  
    391402    static void updateApplicationCacheStatusImpl(InstrumentingAgents&, Frame&);
    392403
    393     static void didCreateCSSCanvasImpl(InstrumentingAgents*, HTMLCanvasElement&, const String&);
    394     static void didChangeCSSCanvasClientNodesImpl(InstrumentingAgents*, HTMLCanvasElement&);
    395     static void didCreateCanvasRenderingContextImpl(InstrumentingAgents*, HTMLCanvasElement&);
    396     static void didChangeCanvasMemoryImpl(InstrumentingAgents*, HTMLCanvasElement&);
    397     static void recordCanvasActionImpl(InstrumentingAgents*, CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
    398     static void didFinishRecordingCanvasFrameImpl(InstrumentingAgents*, HTMLCanvasElement&, bool forceDispatch = false);
     404    static void didCreateCSSCanvasImpl(InstrumentingAgents&, HTMLCanvasElement&, const String&);
     405    static void didChangeCSSCanvasClientNodesImpl(InstrumentingAgents&, HTMLCanvasElement&);
     406    static void didCreateCanvasRenderingContextImpl(InstrumentingAgents&, HTMLCanvasElement&);
     407    static void didChangeCanvasMemoryImpl(InstrumentingAgents&, HTMLCanvasElement&);
     408    static void recordCanvasActionImpl(InstrumentingAgents&, CanvasRenderingContext&, const String&, Vector<RecordCanvasActionVariant>&& = { });
     409    static void didFinishRecordingCanvasFrameImpl(InstrumentingAgents&, HTMLCanvasElement&, bool forceDispatch = false);
     410#if ENABLE(WEBGL)
     411    static void didCreateProgramImpl(InstrumentingAgents&, WebGLRenderingContextBase&, WebGLProgram&);
     412    static void willDeleteProgramImpl(InstrumentingAgents&, WebGLProgram&);
     413#endif
    399414
    400415    static void layerTreeDidChangeImpl(InstrumentingAgents&);
    … …  
    11001115{
    11011116    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))
    1102         didCreateCSSCanvasImpl(instrumentingAgents, canvasElement, name);
     1117        didCreateCSSCanvasImpl(*instrumentingAgents, canvasElement, name);
    11031118}
    11041119
    … …  
    11071122    FAST_RETURN_IF_NO_FRONTENDS(void());
    11081123    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))
    1109         didChangeCSSCanvasClientNodesImpl(instrumentingAgents, canvasElement);
     1124        didChangeCSSCanvasClientNodesImpl(*instrumentingAgents, canvasElement);
    11101125}
    11111126
    … …  
    11131128{
    11141129    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))
    1115         didCreateCanvasRenderingContextImpl(instrumentingAgents, canvasElement);
     1130        didCreateCanvasRenderingContextImpl(*instrumentingAgents, canvasElement);
    11161131}
    11171132
    … …  
    11201135    FAST_RETURN_IF_NO_FRONTENDS(void());
    11211136    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))
    1122         didChangeCanvasMemoryImpl(instrumentingAgents, canvasElement);
     1137        didChangeCanvasMemoryImpl(*instrumentingAgents, canvasElement);
    11231138}
    11241139
    … …  
    11271142    FAST_RETURN_IF_NO_FRONTENDS(void());
    11281143    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasRenderingContext.canvas().document()))
    1129         recordCanvasActionImpl(instrumentingAgents, canvasRenderingContext, name, WTFMove(parameters));
     1144        recordCanvasActionImpl(*instrumentingAgents, canvasRenderingContext, name, WTFMove(parameters));
    11301145}
    11311146
    … …  
    11341149    FAST_RETURN_IF_NO_FRONTENDS(void());
    11351150    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(&canvasElement.document()))
    1136         didFinishRecordingCanvasFrameImpl(instrumentingAgents, canvasElement, forceDispatch);
    1137 }
     1151        didFinishRecordingCanvasFrameImpl(*instrumentingAgents, canvasElement, forceDispatch);
     1152}
     1153
     1154#if ENABLE(WEBGL)
     1155inline void InspectorInstrumentation::didCreateProgram(WebGLRenderingContextBase& context, WebGLProgram& program)
     1156{
     1157    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(context.canvas().document()))
     1158        didCreateProgramImpl(*instrumentingAgents, context, program);
     1159}
     1160
     1161inline void InspectorInstrumentation::willDeleteProgram(WebGLRenderingContextBase& context, WebGLProgram& program)
     1162{
     1163    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForDocument(context.canvas().document()))
     1164        willDeleteProgramImpl(*instrumentingAgents, program);
     1165}
     1166#endif
    11381167
    11391168inline void InspectorInstrumentation::networkStateChanged(Page& page)

  • trunk/Source/WebInspectorUI/ChangeLog

    r220232 r220233  
     12017-08-03  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Instrument WebGLProgram created/deleted
     4        https://bugs.webkit.org/show_bug.cgi?id=175059
     5
     6        Reviewed by Devin Rousso.
     7
     8        This patch adds frontend support for shader program instrumentation.
     9        The frontend creates a ShaderProgram model object for each WebGLProgram.
     10        Since only canvases with a WebGL context have programs, the Canvas model
     11        object does not contain any logic specific to programs. CanvasManager
     12        dispatches program added/removed events, and the parent Canvas can be
     13        accessed from ShaderProgram but not the other way around.
     14
     15        * UserInterface/Controllers/CanvasManager.js:
     16        (WI.CanvasManager):
     17        (WI.CanvasManager.prototype.get shaderPrograms):
     18        (WI.CanvasManager.prototype.canvasRemoved):
     19        (WI.CanvasManager.prototype.programCreated):
     20        (WI.CanvasManager.prototype.programDeleted):
     21        (WI.CanvasManager.prototype._mainResourceDidChange):
     22        (WI.CanvasManager.prototype._dispatchShaderProgramRemoved):
     23
     24        * UserInterface/Main.html:
     25
     26        * UserInterface/Models/Canvas.js:
     27        (WI.Canvas.prototype.nextShaderProgramDisplayNumber):
     28        (WI.Canvas):
     29
     30        * UserInterface/Models/ShaderProgram.js: Added.
     31        (WI.ShaderProgram):
     32        (WI.ShaderProgram.prototype.get identifier):
     33        (WI.ShaderProgram.prototype.get canvas):
     34        (WI.ShaderProgram.prototype.get displayName):
     35
     36        * UserInterface/Protocol/CanvasObserver.js:
     37        (WI.CanvasObserver.prototype.programCreated):
     38        (WI.CanvasObserver.prototype.programDeleted):
     39        (WI.CanvasObserver):
     40
     41        * UserInterface/Test.html:
     42
    1432017-08-03  Joseph Pecoraro  <pecoraro@apple.com>
    244

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/CanvasManager.js

    r220119 r220233  
    3333
    3434        this._canvasIdentifierMap = new Map;
     35        this._shaderProgramIdentifierMap = new Map;
     36        this._canvasShaderProgramMap = new Map;
    3537
    3638        if (window.CanvasAgent)
    … …  
    4547    }
    4648
     49    get shaderPrograms()
     50    {
     51        return [...this._shaderProgramIdentifierMap.values()];
     52    }
     53
    4754    canvasAdded(canvasPayload)
    4855    {
    … …  
    6875            return;
    6976
     77        let programs = this._canvasShaderProgramMap.take(canvas);
     78        if (programs) {
     79            for (let program of programs) {
     80                this._shaderProgramIdentifierMap.delete(program.identifier);
     81                this._dispatchShaderProgramRemoved(program);
     82            }
     83        }
     84
    7085        canvas.frame.canvasCollection.remove(canvas);
    7186
    … …  
    112127    }
    113128
     129    programCreated(canvasIdentifier, programIdentifier)
     130    {
     131        // Called from WI.CanvasObserver.
     132
     133        let canvas = this._canvasIdentifierMap.get(canvasIdentifier);
     134        console.assert(canvas);
     135        if (!canvas)
     136            return;
     137
     138        console.assert(!this._shaderProgramIdentifierMap.has(programIdentifier), `ShaderProgram already exists with id ${programIdentifier}.`);
     139
     140        let program = new WI.ShaderProgram(programIdentifier, canvas);
     141        this._shaderProgramIdentifierMap.set(program.identifier, program);
     142
     143        let programs = this._canvasShaderProgramMap.get(canvas);
     144        if (!programs) {
     145            programs = [];
     146            this._canvasShaderProgramMap.set(canvas, programs);
     147        }
     148
     149        programs.push(program);
     150
     151        this.dispatchEventToListeners(WI.CanvasManager.Event.ShaderProgramAdded, {program});
     152    }
     153
     154    programDeleted(programIdentifier)
     155    {
     156        // Called from WI.CanvasObserver.
     157
     158        let program = this._shaderProgramIdentifierMap.take(programIdentifier);
     159        console.assert(program);
     160        if (!program)
     161            return;
     162
     163        let programs = this._canvasShaderProgramMap.get(program.canvas);
     164
     165        programs.remove(program);
     166
     167        if (!programs.length)
     168            this._canvasShaderProgramMap.delete(program.canvas);
     169
     170        this._dispatchShaderProgramRemoved(program);
     171    }
     172
    114173    // Private
    115174
    … …  
    121180
    122181        WI.Canvas.resetUniqueDisplayNameNumbers();
     182
     183        this._shaderProgramIdentifierMap.clear();
     184        this._canvasShaderProgramMap.clear();
    123185
    124186        if (this._canvasIdentifierMap.size) {
    … …  
    126188            this.dispatchEventToListeners(WI.CanvasManager.Event.Cleared);
    127189        }
     190    }
     191
     192    _dispatchShaderProgramRemoved(program)
     193    {
     194        this.dispatchEventToListeners(WI.CanvasManager.Event.ShaderProgramRemoved, {program});
    128195    }
    129196};
    … …  
    134201    CanvasWasRemoved: "canvas-manager-canvas-was-removed",
    135202    RecordingFinished: "canvas-managger-recording-finished",
     203    ShaderProgramAdded: "canvas-manager-shader-program-added",
     204    ShaderProgramRemoved: "canvas-manager-shader-program-removed",
    136205};

  • trunk/Source/WebInspectorUI/UserInterface/Main.html

    r220188 r220233  
    401401    <script src="Models/ScriptSyntaxTree.js"></script>
    402402    <script src="Models/ScriptTimelineRecord.js"></script>
     403    <script src="Models/ShaderProgram.js"></script>
    403404    <script src="Models/SourceCodePosition.js"></script>
    404405    <script src="Models/SourceCodeRevision.js"></script>

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

    r220119 r220233  
    4343
    4444        this._cssCanvasClientNodes = null;
     45
     46        this._nextShaderProgramDisplayNumber = 1;
    4547    }
    4648
    … …  
    225227        this.dispatchEventToListeners(WI.Canvas.Event.CSSCanvasClientNodesChanged);
    226228    }
     229
     230    nextShaderProgramDisplayNumber()
     231    {
     232        // Called from WI.ShaderProgram.
     233
     234        return this._nextShaderProgramDisplayNumber++;
     235    }
    227236};
    228237

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

    r220232 r220233  
    2424 */
    2525
    26 WI.CanvasObserver = class CanvasObserver
     26WI.ShaderProgram = class ShaderProgram extends WI.Object
    2727{
    28     // Events defined by the "Canvas" domain.
     28    constructor(identifier, canvas)
     29    {
     30        super();
    2931
    30     canvasAdded(canvas)
    31     {
    32         WI.canvasManager.canvasAdded(canvas);
     32        console.assert(identifier);
     33        console.assert(canvas instanceof WI.Canvas);
     34
     35        this._identifier = identifier;
     36        this._canvas = canvas;
     37        this._uniqueDisplayNumber = canvas.nextShaderProgramDisplayNumber();
    3338    }
    3439
    35     canvasRemoved(canvasId)
     40    // Public
     41
     42    get identifier() { return this._identifier; }
     43    get canvas() { return this._canvas; }
     44
     45    get displayName()
    3646    {
    37         WI.canvasManager.canvasRemoved(canvasId);
    38     }
    39 
    40     canvasMemoryChanged(canvasId, memoryCost)
    41     {
    42         WI.canvasManager.canvasMemoryChanged(canvasId, memoryCost);
    43     }
    44 
    45     cssCanvasClientNodesChanged(canvasId)
    46     {
    47         WI.canvasManager.cssCanvasClientNodesChanged(canvasId);
    48     }
    49 
    50     recordingFinished(canvasId, recording)
    51     {
    52         WI.canvasManager.recordingFinished(canvasId, recording);
     47        return WI.UIString("Program %d").format(this._uniqueDisplayNumber);
    5348    }
    5449};
     50
     51WI.ShaderProgram.Event = {
     52    ProgramLinked: "shader-program-program-linked",
     53    ShaderCompiled: "shader-program-shader-compiled",
     54};

  • trunk/Source/WebInspectorUI/UserInterface/Protocol/CanvasObserver.js

    r220119 r220233  
    5252        WI.canvasManager.recordingFinished(canvasId, recording);
    5353    }
     54
     55    programCreated(canvasId, programId)
     56    {
     57        WI.canvasManager.programCreated(canvasId, programId);
     58    }
     59
     60    programDeleted(programId)
     61    {
     62        WI.canvasManager.programDeleted(programId);
     63    }
    5464};

  • trunk/Source/WebInspectorUI/UserInterface/Test.html

    r220119 r220233  
    169169    <script src="Models/ScriptSyntaxTree.js"></script>
    170170    <script src="Models/ScriptTimelineRecord.js"></script>
     171    <script src="Models/ShaderProgram.js"></script>
    171172    <script src="Models/SourceCodeRevision.js"></script>
    172173    <script src="Models/SourceCodeTimeline.js"></script>
Note: See TracChangeset for help on using the changeset viewer.