Changeset 265708 in webkit


Ignore:
Timestamp:
Aug 14, 2020 3:06:42 PM (4 years ago)
Author:
commit-queue@webkit.org
Message:

[WebGL2] expando-loss and expando-loss-2 conformance tests are failing
​https://bugs.webkit.org/show_bug.cgi?id=214765

Patch by Kenneth Russell <​kbr@chromium.org> on 2020-08-14
Reviewed by Yusuke Suzuki.

Re-land with locking fixes ysuzuki@ pointed out as necessary, and
advised heavily on.

Source/WebCore:

Use JSWebGLRenderingContext's and JSWebGL2RenderingContext's
existing visitAdditionalChildren hook, via JSCustomMarkFunction in
their IDL, to add opaque roots for all WebGLObjects latched in to
the context state, and all WebGLObjects they refer to. Extensions
were already previously handled.

In order to support JSC's concurrent marking, grab a
per-WebGL-context lock in visitAdditionalChildren, and in all
WebGL context- and object-related methods which modify compound
data structures like HashMaps and Vectors that are traversed by
visitAdditionalChildren and its callees. Add "const
AbstractLocker&" throughout WebGL's call hierarchy to guarantee
that this lock is held where needed. Add needed exception in
WebGLObjects' destructors to avoid recursive locking, and in
WebGLContextGroup destruction to avoid mutating objects that GC
might be traversing when a lock is no longer available on the
application's thread.

Add "GenerateIsReachable=Impl" to the IDL files of needed WebGL
objects (WebGLBuffer, WebGLTexture, etc.) so that they pay
attention to the opaque root state when determining liveness of
their JavaScript wrappers. Add a FIXME to objectGraphLock in
WebGLRenderingContextBase to consider rewriting this in a
lock-free manner.

Covered by existing WebGL conformance tests.

  • bindings/js/JSWebGL2RenderingContextCustom.cpp:

(WebCore::JSWebGL2RenderingContext::visitAdditionalChildren):

  • bindings/js/JSWebGLRenderingContextCustom.cpp:

(WebCore::JSWebGLRenderingContext::visitAdditionalChildren):

  • html/canvas/OESVertexArrayObject.cpp:

(WebCore::OESVertexArrayObject::deleteVertexArrayOES):
(WebCore::OESVertexArrayObject::bindVertexArrayOES):

  • html/canvas/WebGL2RenderingContext.cpp:

(WebCore::WebGL2RenderingContext::validateAndCacheBufferBinding):
(WebCore::WebGL2RenderingContext::bindFramebuffer):
(WebCore::WebGL2RenderingContext::deleteFramebuffer):
(WebCore::WebGL2RenderingContext::deleteQuery):
(WebCore::WebGL2RenderingContext::beginQuery):
(WebCore::WebGL2RenderingContext::endQuery):
(WebCore::WebGL2RenderingContext::deleteSampler):
(WebCore::WebGL2RenderingContext::bindSampler):
(WebCore::WebGL2RenderingContext::deleteSync):
(WebCore::WebGL2RenderingContext::deleteTransformFeedback):
(WebCore::WebGL2RenderingContext::bindTransformFeedback):
(WebCore::WebGL2RenderingContext::beginTransformFeedback):
(WebCore::WebGL2RenderingContext::setIndexedBufferBinding):
(WebCore::WebGL2RenderingContext::deleteVertexArray):
(WebCore::WebGL2RenderingContext::bindVertexArray):
(WebCore::WebGL2RenderingContext::addMembersToOpaqueRoots):
(WebCore::WebGL2RenderingContext::uncacheDeletedBuffer):

  • html/canvas/WebGL2RenderingContext.h:
  • html/canvas/WebGLBuffer.cpp:

(WebCore::WebGLBuffer::~WebGLBuffer):
(WebCore::WebGLBuffer::deleteObjectImpl):

  • html/canvas/WebGLBuffer.h:
  • html/canvas/WebGLBuffer.idl:
  • html/canvas/WebGLContextGroup.cpp:

(WebCore::WebGLContextGroup::hasAContext const):
(WebCore::WebGLContextGroup::objectGraphLockForAContext):
(WebCore::WebGLContextGroup::detachAndRemoveAllObjects):

  • html/canvas/WebGLContextGroup.h:
  • html/canvas/WebGLContextObject.cpp:

(WebCore::WebGLContextObject::detachContext):
(WebCore::WebGLContextObject::objectGraphLockForContext):

  • html/canvas/WebGLContextObject.h:
  • html/canvas/WebGLFramebuffer.cpp:

(WebCore::WebGLFramebuffer::~WebGLFramebuffer):
(WebCore::WebGLFramebuffer::removeAttachmentFromBoundFramebuffer):
(WebCore::WebGLFramebuffer::deleteObjectImpl):
(WebCore::WebGLFramebuffer::initializeAttachments):
(WebCore::WebGLFramebuffer::addMembersToOpaqueRoots):
(WebCore::WebGLFramebuffer::setAttachmentInternal):
(WebCore::WebGLFramebuffer::removeAttachmentInternal):

  • html/canvas/WebGLFramebuffer.h:
  • html/canvas/WebGLFramebuffer.idl:
  • html/canvas/WebGLObject.cpp:

(WebCore::WebGLObject::runDestructor):
(WebCore::WebGLObject::deleteObject):

  • html/canvas/WebGLObject.h:
  • html/canvas/WebGLProgram.cpp:

(WebCore::WebGLProgram::~WebGLProgram):
(WebCore::WebGLProgram::deleteObjectImpl):
(WebCore::WebGLProgram::attachShader):
(WebCore::WebGLProgram::detachShader):
(WebCore::WebGLProgram::addMembersToOpaqueRoots):

  • html/canvas/WebGLProgram.h:
  • html/canvas/WebGLProgram.idl:
  • html/canvas/WebGLQuery.cpp:

(WebCore::WebGLQuery::~WebGLQuery):
(WebCore::WebGLQuery::deleteObjectImpl):

  • html/canvas/WebGLQuery.h:
  • html/canvas/WebGLQuery.idl:
  • html/canvas/WebGLRenderbuffer.cpp:

(WebCore::WebGLRenderbuffer::~WebGLRenderbuffer):
(WebCore::WebGLRenderbuffer::deleteObjectImpl):

  • html/canvas/WebGLRenderbuffer.h:
  • html/canvas/WebGLRenderbuffer.idl:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::attachShader):
(WebCore::WebGLRenderingContextBase::validateAndCacheBufferBinding):
(WebCore::WebGLRenderingContextBase::bindBuffer):
(WebCore::WebGLRenderingContextBase::bindFramebuffer):
(WebCore::WebGLRenderingContextBase::bindRenderbuffer):
(WebCore::WebGLRenderingContextBase::bindTexture):
(WebCore::WebGLRenderingContextBase::deleteObject):
(WebCore::WebGLRenderingContextBase::uncacheDeletedBuffer):
(WebCore::WebGLRenderingContextBase::setBoundVertexArrayObject):
(WebCore::WebGLRenderingContextBase::deleteBuffer):
(WebCore::WebGLRenderingContextBase::deleteFramebuffer):
(WebCore::WebGLRenderingContextBase::deleteProgram):
(WebCore::WebGLRenderingContextBase::deleteRenderbuffer):
(WebCore::WebGLRenderingContextBase::deleteShader):
(WebCore::WebGLRenderingContextBase::deleteTexture):
(WebCore::WebGLRenderingContextBase::detachShader):
(WebCore::WebGLRenderingContextBase::useProgram):
(WebCore::WebGLRenderingContextBase::vertexAttribPointer):
(WebCore::WebGLRenderingContextBase::detachAndRemoveAllObjects):
(WebCore::WebGLRenderingContextBase::setFramebuffer):
(WebCore::WebGLRenderingContextBase::addMembersToOpaqueRoots):
(WebCore::WebGLRenderingContextBase::objectGraphLock):

  • html/canvas/WebGLRenderingContextBase.h:

(WebCore::WebGLRenderingContextBase::setBoundVertexArrayObject): Deleted.

  • html/canvas/WebGLSampler.cpp:

(WebCore::WebGLSampler::~WebGLSampler):
(WebCore::WebGLSampler::deleteObjectImpl):

  • html/canvas/WebGLSampler.h:
  • html/canvas/WebGLSampler.idl:
  • html/canvas/WebGLShader.cpp:

(WebCore::WebGLShader::~WebGLShader):
(WebCore::WebGLShader::deleteObjectImpl):

  • html/canvas/WebGLShader.h:
  • html/canvas/WebGLShader.idl:
  • html/canvas/WebGLSharedObject.cpp:

(WebCore::WebGLSharedObject::detachContextGroup):
(WebCore::WebGLSharedObject::detachContextGroupWithoutDeletingObject):
(WebCore::WebGLSharedObject::hasGroupOrContext const):
(WebCore::WebGLSharedObject::objectGraphLockForContext):

  • html/canvas/WebGLSharedObject.h:
  • html/canvas/WebGLSync.cpp:

(WebCore::WebGLSync::~WebGLSync):
(WebCore::WebGLSync::deleteObjectImpl):

  • html/canvas/WebGLSync.h:
  • html/canvas/WebGLTexture.cpp:

(WebCore::WebGLTexture::~WebGLTexture):
(WebCore::WebGLTexture::deleteObjectImpl):

  • html/canvas/WebGLTexture.h:
  • html/canvas/WebGLTexture.idl:
  • html/canvas/WebGLTransformFeedback.cpp:

(WebCore::WebGLTransformFeedback::~WebGLTransformFeedback):
(WebCore::WebGLTransformFeedback::deleteObjectImpl):
(WebCore::WebGLTransformFeedback::setProgram):
(WebCore::WebGLTransformFeedback::setBoundIndexedTransformFeedbackBuffer):
(WebCore::WebGLTransformFeedback::addMembersToOpaqueRoots):
(WebCore::WebGLTransformFeedback::unbindBuffer):

  • html/canvas/WebGLTransformFeedback.h:
  • html/canvas/WebGLTransformFeedback.idl:
  • html/canvas/WebGLVertexArrayObject.cpp:

(WebCore::WebGLVertexArrayObject::~WebGLVertexArrayObject):
(WebCore::WebGLVertexArrayObject::deleteObjectImpl):

  • html/canvas/WebGLVertexArrayObject.h:
  • html/canvas/WebGLVertexArrayObject.idl:
  • html/canvas/WebGLVertexArrayObjectBase.cpp:

(WebCore::WebGLVertexArrayObjectBase::setElementArrayBuffer):
(WebCore::WebGLVertexArrayObjectBase::setVertexAttribState):
(WebCore::WebGLVertexArrayObjectBase::unbindBuffer):
(WebCore::WebGLVertexArrayObjectBase::addMembersToOpaqueRoots):

  • html/canvas/WebGLVertexArrayObjectBase.h:
  • html/canvas/WebGLVertexArrayObjectOES.cpp:

(WebCore::WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES):
(WebCore::WebGLVertexArrayObjectOES::deleteObjectImpl):

  • html/canvas/WebGLVertexArrayObjectOES.h:
  • html/canvas/WebGLVertexArrayObjectOES.idl:

LayoutTests:

Rebaseline expando-loss.html and expando-loss-2.html, which are
now fully passing.

Add a hook to js-test-pre.js which allows these tests to be run
correctly in the MiniBrowser by setting the following environment
variables:

export JSC_useDollarVM=1
export XPC_JSC_useDollarVM=1

  • webgl/2.0.0/conformance/misc/expando-loss-expected.txt:
  • webgl/2.0.0/conformance2/misc/expando-loss-2-expected.txt:
  • webgl/2.0.0/resources/webgl_test_files/js/js-test-pre.js:
Location:
trunk
Files:
57 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r265706 r265708  
     12020-08-14  Kenneth Russell  <kbr@chromium.org>
     2
     3        [WebGL2] expando-loss and expando-loss-2 conformance tests are failing
     4        https://bugs.webkit.org/show_bug.cgi?id=214765
     5
     6        Reviewed by Yusuke Suzuki.
     7
     8        Re-land with locking fixes ysuzuki@ pointed out as necessary, and
     9        advised heavily on.
     10
     11        Rebaseline expando-loss.html and expando-loss-2.html, which are
     12        now fully passing.
     13
     14        Add a hook to js-test-pre.js which allows these tests to be run
     15        correctly in the MiniBrowser by setting the following environment
     16        variables:
     17          export JSC_useDollarVM=1
     18          export __XPC_JSC_useDollarVM=1
     19
     20        * webgl/2.0.0/conformance/misc/expando-loss-expected.txt:
     21        * webgl/2.0.0/conformance2/misc/expando-loss-2-expected.txt:
     22        * webgl/2.0.0/resources/webgl_test_files/js/js-test-pre.js:
     23
    1242020-08-14  Wenson Hsieh  <wenson_hsieh@apple.com>
    225

  • trunk/LayoutTests/webgl/2.0.0/conformance/misc/expando-loss-expected.txt

    r265534 r265708  
    22
    33Test: ../../resources/webgl_test_files/conformance/misc/expando-loss.html
    4 
    5 [ 1: PASS ] getParameter(TEXTURE_BINDING_2D) returns instance that was bound.
    6 [ 2: FAIL ] getParameter(TEXTURE_BINDING_2D): Expect basic expando to survive despite GC.
    7 [ 3: FAIL ] getParameter(TEXTURE_BINDING_2D): Expect subobject expando to survive despite GC.
    8 [ 4: PASS ] getParameter(FRAMEBUFFER_BINDING) returns instance that was bound.
    9 [ 5: FAIL ] getParameter(FRAMEBUFFER_BINDING): Expect basic expando to survive despite GC.
    10 [ 6: FAIL ] getParameter(FRAMEBUFFER_BINDING): Expect subobject expando to survive despite GC.
    11 [ 7: PASS ] getParameter(RENDERBUFFER_BINDING) returns instance that was bound.
    12 [ 8: FAIL ] getParameter(RENDERBUFFER_BINDING): Expect basic expando to survive despite GC.
    13 [ 9: FAIL ] getParameter(RENDERBUFFER_BINDING): Expect subobject expando to survive despite GC.
    14 [ 10: PASS ] getParameter(ELEMENT_ARRAY_BUFFER_BINDING) returns instance that was bound.
    15 [ 11: FAIL ] getParameter(ELEMENT_ARRAY_BUFFER_BINDING): Expect basic expando to survive despite GC.
    16 [ 12: FAIL ] getParameter(ELEMENT_ARRAY_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    17 [ 13: PASS ] getParameter(ARRAY_BUFFER_BINDING) returns instance that was bound.
    18 [ 14: FAIL ] getParameter(ARRAY_BUFFER_BINDING): Expect basic expando to survive despite GC.
    19 [ 15: FAIL ] getParameter(ARRAY_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    20 [ 16: PASS ] getParameter(TEXTURE_BINDING_CUBE_MAP) returns instance that was bound.
    21 [ 17: FAIL ] getParameter(TEXTURE_BINDING_CUBE_MAP): Expect basic expando to survive despite GC.
    22 [ 18: FAIL ] getParameter(TEXTURE_BINDING_CUBE_MAP): Expect subobject expando to survive despite GC.
    23 [ 19: PASS ] getParameter(gl.CURRENT_PROGRAM) return instance set with useProgram
    24 [ 20: PASS ] Vertex shader instance found in getAttachedShaders
    25 [ 21: PASS ] Fragment shader instance found in getAttachedShaders
    26 [ 22: FAIL ] Current program: Expect basic expando to survive despite GC.
    27 [ 23: FAIL ] Current program: Expect subobject expando to survive despite GC.
    28 [ 24: PASS ] [object WebGLProgram] is an instance of WebGLProgram
    29 [ 25: FAIL ] Shader[0]: Expect basic expando to survive despite GC.
    30 [ 26: FAIL ] Shader[0]: Expect subobject expando to survive despite GC.
    31 [ 27: PASS ] [object WebGLShader] is an instance of WebGLShader
    32 [ 28: FAIL ] Shader[1]: Expect basic expando to survive despite GC.
    33 [ 29: FAIL ] Shader[1]: Expect subobject expando to survive despite GC.
    34 [ 30: PASS ] [object WebGLShader] is an instance of WebGLShader
    35 [ 31: PASS ] getVertexAttrib(VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) return instance set with vertexAttribPointer
    36 [ 32: FAIL ] Vertex Attribute Buffer: Expect basic expando to survive despite GC.
    37 [ 33: FAIL ] Vertex Attribute Buffer: Expect subobject expando to survive despite GC.
    38 [ 34: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    39 [ 35: PASS ] getFramebufferAttachmentParameter(COLOR_ATTACHMENT0) returns instance set with framebufferRenderbuffer
    40 [ 36: PASS ] getFramebufferAttachmentParameter(DEPTH_ATTACHMENT) returns instance set with framebufferRenderbuffer
    41 [ 37: PASS ] getFramebufferAttachmentParameter(STENCIL_ATTACHMENT) returns instance set with framebufferRenderbuffer
    42 [ 38: PASS ] getFramebufferAttachmentParameter(DEPTH_STENCIL_ATTACHMENT) returns instance set with framebufferRenderbuffer
    43 [ 39: FAIL ] COLOR_ATTACHMENT0: Expect basic expando to survive despite GC.
    44 [ 40: FAIL ] COLOR_ATTACHMENT0: Expect subobject expando to survive despite GC.
    45 [ 41: PASS ] [object WebGLRenderbuffer] is an instance of WebGLRenderbuffer
    46 [ 42: FAIL ] DEPTH_ATTACHMENT: Expect basic expando to survive despite GC.
    47 [ 43: FAIL ] DEPTH_ATTACHMENT: Expect subobject expando to survive despite GC.
    48 [ 44: PASS ] [object WebGLRenderbuffer] is an instance of WebGLRenderbuffer
    49 [ 45: FAIL ] STENCIL_ATTACHMENT: Expect basic expando to survive despite GC.
    50 [ 46: FAIL ] STENCIL_ATTACHMENT: Expect subobject expando to survive despite GC.
    51 [ 47: PASS ] [object WebGLRenderbuffer] is an instance of WebGLRenderbuffer
    52 [ 48: FAIL ] DEPTH_STENCIL_ATTACHMENT: Expect basic expando to survive despite GC.
    53 [ 49: FAIL ] DEPTH_STENCIL_ATTACHMENT: Expect subobject expando to survive despite GC.
    54 [ 50: PASS ] [object WebGLRenderbuffer] is an instance of WebGLRenderbuffer
    55 [ 51: PASS ] successfullyParsed is true
    56 [ FAIL ] 28 failures reported
     4[ PASS ] All tests passed

  • trunk/LayoutTests/webgl/2.0.0/conformance2/misc/expando-loss-2-expected.txt

    r265534 r265708  
    22
    33Test: ../../resources/webgl_test_files/conformance2/misc/expando-loss-2.html
    4 
    5 [ 1: PASS ] getParameter(SAMPLER_BINDING) returns instance that was bound.
    6 [ 2: FAIL ] getParameter(SAMPLER_BINDING): Expect basic expando to survive despite GC.
    7 [ 3: FAIL ] getParameter(SAMPLER_BINDING): Expect subobject expando to survive despite GC.
    8 [ 4: PASS ] getParameter(SAMPLER_BINDING): Expect extra expando to survive despite GC.
    9 [ 5: PASS ] [object WebGLSampler] is an instance of WebGLSampler
    10 [ 6: PASS ] getParameter(TRANSFORM_FEEDBACK_BINDING) returns instance that was bound.
    11 [ 7: FAIL ] getParameter(TRANSFORM_FEEDBACK_BINDING): Expect basic expando to survive despite GC.
    12 [ 8: FAIL ] getParameter(TRANSFORM_FEEDBACK_BINDING): Expect subobject expando to survive despite GC.
    13 [ 9: PASS ] getParameter(TRANSFORM_FEEDBACK_BINDING): Expect extra expando to survive despite GC.
    14 [ 10: PASS ] [object WebGLTransformFeedback] is an instance of WebGLTransformFeedback
    15 [ 11: PASS ] getParameter(VERTEX_ARRAY_BINDING) returns instance that was bound.
    16 [ 12: FAIL ] getParameter(VERTEX_ARRAY_BINDING): Expect basic expando to survive despite GC.
    17 [ 13: FAIL ] getParameter(VERTEX_ARRAY_BINDING): Expect subobject expando to survive despite GC.
    18 [ 14: PASS ] getParameter(VERTEX_ARRAY_BINDING): Expect extra expando to survive despite GC.
    19 [ 15: PASS ] [object WebGLVertexArrayObject] is an instance of WebGLVertexArrayObject
    20 [ 16: PASS ] getParameter(TEXTURE_BINDING_3D) returns instance that was bound.
    21 [ 17: FAIL ] getParameter(TEXTURE_BINDING_3D): Expect basic expando to survive despite GC.
    22 [ 18: FAIL ] getParameter(TEXTURE_BINDING_3D): Expect subobject expando to survive despite GC.
    23 [ 19: PASS ] getParameter(TEXTURE_BINDING_3D): Expect extra expando to survive despite GC.
    24 [ 20: PASS ] [object WebGLTexture] is an instance of WebGLTexture
    25 [ 21: PASS ] getParameter(TEXTURE_BINDING_2D_ARRAY) returns instance that was bound.
    26 [ 22: FAIL ] getParameter(TEXTURE_BINDING_2D_ARRAY): Expect basic expando to survive despite GC.
    27 [ 23: FAIL ] getParameter(TEXTURE_BINDING_2D_ARRAY): Expect subobject expando to survive despite GC.
    28 [ 24: PASS ] getParameter(TEXTURE_BINDING_2D_ARRAY): Expect extra expando to survive despite GC.
    29 [ 25: PASS ] [object WebGLTexture] is an instance of WebGLTexture
    30 [ 26: PASS ] getParameter(READ_FRAMEBUFFER_BINDING) returns instance that was bound.
    31 [ 27: FAIL ] getParameter(READ_FRAMEBUFFER_BINDING): Expect basic expando to survive despite GC.
    32 [ 28: FAIL ] getParameter(READ_FRAMEBUFFER_BINDING): Expect subobject expando to survive despite GC.
    33 [ 29: PASS ] getParameter(READ_FRAMEBUFFER_BINDING): Expect extra expando to survive despite GC.
    34 [ 30: PASS ] [object WebGLFramebuffer] is an instance of WebGLFramebuffer
    35 [ 31: PASS ] getParameter(DRAW_FRAMEBUFFER_BINDING) returns instance that was bound.
    36 [ 32: FAIL ] getParameter(DRAW_FRAMEBUFFER_BINDING): Expect basic expando to survive despite GC.
    37 [ 33: FAIL ] getParameter(DRAW_FRAMEBUFFER_BINDING): Expect subobject expando to survive despite GC.
    38 [ 34: PASS ] getParameter(DRAW_FRAMEBUFFER_BINDING): Expect extra expando to survive despite GC.
    39 [ 35: PASS ] [object WebGLFramebuffer] is an instance of WebGLFramebuffer
    40 [ 36: PASS ] getParameter(COPY_READ_BUFFER_BINDING) returns instance that was bound.
    41 [ 37: FAIL ] getParameter(COPY_READ_BUFFER_BINDING): Expect basic expando to survive despite GC.
    42 [ 38: FAIL ] getParameter(COPY_READ_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    43 [ 39: PASS ] getParameter(COPY_READ_BUFFER_BINDING): Expect extra expando to survive despite GC.
    44 [ 40: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    45 [ 41: PASS ] getParameter(COPY_WRITE_BUFFER_BINDING) returns instance that was bound.
    46 [ 42: FAIL ] getParameter(COPY_WRITE_BUFFER_BINDING): Expect basic expando to survive despite GC.
    47 [ 43: FAIL ] getParameter(COPY_WRITE_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    48 [ 44: PASS ] getParameter(COPY_WRITE_BUFFER_BINDING): Expect extra expando to survive despite GC.
    49 [ 45: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    50 [ 46: PASS ] getParameter(PIXEL_PACK_BUFFER_BINDING) returns instance that was bound.
    51 [ 47: FAIL ] getParameter(PIXEL_PACK_BUFFER_BINDING): Expect basic expando to survive despite GC.
    52 [ 48: FAIL ] getParameter(PIXEL_PACK_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    53 [ 49: PASS ] getParameter(PIXEL_PACK_BUFFER_BINDING): Expect extra expando to survive despite GC.
    54 [ 50: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    55 [ 51: PASS ] getParameter(PIXEL_UNPACK_BUFFER_BINDING) returns instance that was bound.
    56 [ 52: FAIL ] getParameter(PIXEL_UNPACK_BUFFER_BINDING): Expect basic expando to survive despite GC.
    57 [ 53: FAIL ] getParameter(PIXEL_UNPACK_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    58 [ 54: PASS ] getParameter(PIXEL_UNPACK_BUFFER_BINDING): Expect extra expando to survive despite GC.
    59 [ 55: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    60 [ 56: PASS ] getParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING) returns instance that was bound.
    61 [ 57: FAIL ] getParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING): Expect basic expando to survive despite GC.
    62 [ 58: FAIL ] getParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    63 [ 59: PASS ] getParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING): Expect extra expando to survive despite GC.
    64 [ 60: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    65 [ 61: PASS ] getParameter(UNIFORM_BUFFER_BINDING) returns instance that was bound.
    66 [ 62: FAIL ] getParameter(UNIFORM_BUFFER_BINDING): Expect basic expando to survive despite GC.
    67 [ 63: FAIL ] getParameter(UNIFORM_BUFFER_BINDING): Expect subobject expando to survive despite GC.
    68 [ 64: PASS ] getParameter(UNIFORM_BUFFER_BINDING): Expect extra expando to survive despite GC.
    69 [ 65: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    70 [ 66: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 0) returns instance that was bound.
    71 [ 67: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 1) returns instance that was bound.
    72 [ 68: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 2) returns instance that was bound.
    73 [ 69: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 3) returns instance that was bound.
    74 [ 70: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 0): Expect basic expando to survive despite GC.
    75 [ 71: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 0): Expect subobject expando to survive despite GC.
    76 [ 72: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 0): Expect extra expando to survive despite GC.
    77 [ 73: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    78 [ 74: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 1): Expect basic expando to survive despite GC.
    79 [ 75: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 1): Expect subobject expando to survive despite GC.
    80 [ 76: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 1): Expect extra expando to survive despite GC.
    81 [ 77: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    82 [ 78: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 2): Expect basic expando to survive despite GC.
    83 [ 79: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 2): Expect subobject expando to survive despite GC.
    84 [ 80: FAIL ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 2): Expect extra expando to survive despite GC.
    85 [ 81: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    86 [ 82: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 3): Expect basic expando to survive despite GC.
    87 [ 83: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 3): Expect subobject expando to survive despite GC.
    88 [ 84: PASS ] getIndexedParameter(TRANSFORM_FEEDBACK_BUFFER_BINDING, 3): Expect extra expando to survive despite GC.
    89 [ 85: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    90 [ 86: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 0) returns instance that was bound.
    91 [ 87: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 1) returns instance that was bound.
    92 [ 88: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 2) returns instance that was bound.
    93 [ 89: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 3) returns instance that was bound.
    94 [ 90: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 4) returns instance that was bound.
    95 [ 91: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 5) returns instance that was bound.
    96 [ 92: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 6) returns instance that was bound.
    97 [ 93: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 7) returns instance that was bound.
    98 [ 94: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 8) returns instance that was bound.
    99 [ 95: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 9) returns instance that was bound.
    100 [ 96: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 10) returns instance that was bound.
    101 [ 97: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 11) returns instance that was bound.
    102 [ 98: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 12) returns instance that was bound.
    103 [ 99: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 13) returns instance that was bound.
    104 [ 100: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 14) returns instance that was bound.
    105 [ 101: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 15) returns instance that was bound.
    106 [ 102: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 16) returns instance that was bound.
    107 [ 103: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 17) returns instance that was bound.
    108 [ 104: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 18) returns instance that was bound.
    109 [ 105: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 19) returns instance that was bound.
    110 [ 106: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 20) returns instance that was bound.
    111 [ 107: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 21) returns instance that was bound.
    112 [ 108: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 22) returns instance that was bound.
    113 [ 109: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 23) returns instance that was bound.
    114 [ 110: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 24) returns instance that was bound.
    115 [ 111: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 25) returns instance that was bound.
    116 [ 112: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 26) returns instance that was bound.
    117 [ 113: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 27) returns instance that was bound.
    118 [ 114: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 28) returns instance that was bound.
    119 [ 115: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 29) returns instance that was bound.
    120 [ 116: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 30) returns instance that was bound.
    121 [ 117: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 31) returns instance that was bound.
    122 [ 118: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 32) returns instance that was bound.
    123 [ 119: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 33) returns instance that was bound.
    124 [ 120: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 34) returns instance that was bound.
    125 [ 121: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 35) returns instance that was bound.
    126 [ 122: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 36) returns instance that was bound.
    127 [ 123: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 37) returns instance that was bound.
    128 [ 124: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 38) returns instance that was bound.
    129 [ 125: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 39) returns instance that was bound.
    130 [ 126: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 40) returns instance that was bound.
    131 [ 127: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 41) returns instance that was bound.
    132 [ 128: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 42) returns instance that was bound.
    133 [ 129: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 43) returns instance that was bound.
    134 [ 130: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 44) returns instance that was bound.
    135 [ 131: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 45) returns instance that was bound.
    136 [ 132: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 46) returns instance that was bound.
    137 [ 133: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 47) returns instance that was bound.
    138 [ 134: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 0): Expect basic expando to survive despite GC.
    139 [ 135: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 0): Expect subobject expando to survive despite GC.
    140 [ 136: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 0): Expect extra expando to survive despite GC.
    141 [ 137: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    142 [ 138: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 1): Expect basic expando to survive despite GC.
    143 [ 139: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 1): Expect subobject expando to survive despite GC.
    144 [ 140: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 1): Expect extra expando to survive despite GC.
    145 [ 141: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    146 [ 142: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 2): Expect basic expando to survive despite GC.
    147 [ 143: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 2): Expect subobject expando to survive despite GC.
    148 [ 144: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 2): Expect extra expando to survive despite GC.
    149 [ 145: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    150 [ 146: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 3): Expect basic expando to survive despite GC.
    151 [ 147: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 3): Expect subobject expando to survive despite GC.
    152 [ 148: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 3): Expect extra expando to survive despite GC.
    153 [ 149: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    154 [ 150: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 4): Expect basic expando to survive despite GC.
    155 [ 151: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 4): Expect subobject expando to survive despite GC.
    156 [ 152: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 4): Expect extra expando to survive despite GC.
    157 [ 153: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    158 [ 154: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 5): Expect basic expando to survive despite GC.
    159 [ 155: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 5): Expect subobject expando to survive despite GC.
    160 [ 156: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 5): Expect extra expando to survive despite GC.
    161 [ 157: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    162 [ 158: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 6): Expect basic expando to survive despite GC.
    163 [ 159: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 6): Expect subobject expando to survive despite GC.
    164 [ 160: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 6): Expect extra expando to survive despite GC.
    165 [ 161: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    166 [ 162: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 7): Expect basic expando to survive despite GC.
    167 [ 163: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 7): Expect subobject expando to survive despite GC.
    168 [ 164: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 7): Expect extra expando to survive despite GC.
    169 [ 165: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    170 [ 166: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 8): Expect basic expando to survive despite GC.
    171 [ 167: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 8): Expect subobject expando to survive despite GC.
    172 [ 168: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 8): Expect extra expando to survive despite GC.
    173 [ 169: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    174 [ 170: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 9): Expect basic expando to survive despite GC.
    175 [ 171: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 9): Expect subobject expando to survive despite GC.
    176 [ 172: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 9): Expect extra expando to survive despite GC.
    177 [ 173: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    178 [ 174: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 10): Expect basic expando to survive despite GC.
    179 [ 175: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 10): Expect subobject expando to survive despite GC.
    180 [ 176: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 10): Expect extra expando to survive despite GC.
    181 [ 177: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    182 [ 178: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 11): Expect basic expando to survive despite GC.
    183 [ 179: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 11): Expect subobject expando to survive despite GC.
    184 [ 180: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 11): Expect extra expando to survive despite GC.
    185 [ 181: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    186 [ 182: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 12): Expect basic expando to survive despite GC.
    187 [ 183: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 12): Expect subobject expando to survive despite GC.
    188 [ 184: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 12): Expect extra expando to survive despite GC.
    189 [ 185: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    190 [ 186: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 13): Expect basic expando to survive despite GC.
    191 [ 187: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 13): Expect subobject expando to survive despite GC.
    192 [ 188: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 13): Expect extra expando to survive despite GC.
    193 [ 189: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    194 [ 190: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 14): Expect basic expando to survive despite GC.
    195 [ 191: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 14): Expect subobject expando to survive despite GC.
    196 [ 192: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 14): Expect extra expando to survive despite GC.
    197 [ 193: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    198 [ 194: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 15): Expect basic expando to survive despite GC.
    199 [ 195: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 15): Expect subobject expando to survive despite GC.
    200 [ 196: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 15): Expect extra expando to survive despite GC.
    201 [ 197: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    202 [ 198: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 16): Expect basic expando to survive despite GC.
    203 [ 199: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 16): Expect subobject expando to survive despite GC.
    204 [ 200: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 16): Expect extra expando to survive despite GC.
    205 [ 201: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    206 [ 202: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 17): Expect basic expando to survive despite GC.
    207 [ 203: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 17): Expect subobject expando to survive despite GC.
    208 [ 204: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 17): Expect extra expando to survive despite GC.
    209 [ 205: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    210 [ 206: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 18): Expect basic expando to survive despite GC.
    211 [ 207: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 18): Expect subobject expando to survive despite GC.
    212 [ 208: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 18): Expect extra expando to survive despite GC.
    213 [ 209: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    214 [ 210: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 19): Expect basic expando to survive despite GC.
    215 [ 211: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 19): Expect subobject expando to survive despite GC.
    216 [ 212: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 19): Expect extra expando to survive despite GC.
    217 [ 213: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    218 [ 214: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 20): Expect basic expando to survive despite GC.
    219 [ 215: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 20): Expect subobject expando to survive despite GC.
    220 [ 216: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 20): Expect extra expando to survive despite GC.
    221 [ 217: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    222 [ 218: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 21): Expect basic expando to survive despite GC.
    223 [ 219: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 21): Expect subobject expando to survive despite GC.
    224 [ 220: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 21): Expect extra expando to survive despite GC.
    225 [ 221: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    226 [ 222: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 22): Expect basic expando to survive despite GC.
    227 [ 223: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 22): Expect subobject expando to survive despite GC.
    228 [ 224: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 22): Expect extra expando to survive despite GC.
    229 [ 225: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    230 [ 226: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 23): Expect basic expando to survive despite GC.
    231 [ 227: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 23): Expect subobject expando to survive despite GC.
    232 [ 228: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 23): Expect extra expando to survive despite GC.
    233 [ 229: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    234 [ 230: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 24): Expect basic expando to survive despite GC.
    235 [ 231: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 24): Expect subobject expando to survive despite GC.
    236 [ 232: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 24): Expect extra expando to survive despite GC.
    237 [ 233: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    238 [ 234: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 25): Expect basic expando to survive despite GC.
    239 [ 235: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 25): Expect subobject expando to survive despite GC.
    240 [ 236: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 25): Expect extra expando to survive despite GC.
    241 [ 237: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    242 [ 238: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 26): Expect basic expando to survive despite GC.
    243 [ 239: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 26): Expect subobject expando to survive despite GC.
    244 [ 240: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 26): Expect extra expando to survive despite GC.
    245 [ 241: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    246 [ 242: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 27): Expect basic expando to survive despite GC.
    247 [ 243: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 27): Expect subobject expando to survive despite GC.
    248 [ 244: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 27): Expect extra expando to survive despite GC.
    249 [ 245: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    250 [ 246: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 28): Expect basic expando to survive despite GC.
    251 [ 247: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 28): Expect subobject expando to survive despite GC.
    252 [ 248: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 28): Expect extra expando to survive despite GC.
    253 [ 249: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    254 [ 250: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 29): Expect basic expando to survive despite GC.
    255 [ 251: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 29): Expect subobject expando to survive despite GC.
    256 [ 252: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 29): Expect extra expando to survive despite GC.
    257 [ 253: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    258 [ 254: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 30): Expect basic expando to survive despite GC.
    259 [ 255: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 30): Expect subobject expando to survive despite GC.
    260 [ 256: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 30): Expect extra expando to survive despite GC.
    261 [ 257: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    262 [ 258: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 31): Expect basic expando to survive despite GC.
    263 [ 259: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 31): Expect subobject expando to survive despite GC.
    264 [ 260: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 31): Expect extra expando to survive despite GC.
    265 [ 261: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    266 [ 262: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 32): Expect basic expando to survive despite GC.
    267 [ 263: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 32): Expect subobject expando to survive despite GC.
    268 [ 264: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 32): Expect extra expando to survive despite GC.
    269 [ 265: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    270 [ 266: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 33): Expect basic expando to survive despite GC.
    271 [ 267: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 33): Expect subobject expando to survive despite GC.
    272 [ 268: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 33): Expect extra expando to survive despite GC.
    273 [ 269: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    274 [ 270: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 34): Expect basic expando to survive despite GC.
    275 [ 271: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 34): Expect subobject expando to survive despite GC.
    276 [ 272: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 34): Expect extra expando to survive despite GC.
    277 [ 273: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    278 [ 274: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 35): Expect basic expando to survive despite GC.
    279 [ 275: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 35): Expect subobject expando to survive despite GC.
    280 [ 276: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 35): Expect extra expando to survive despite GC.
    281 [ 277: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    282 [ 278: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 36): Expect basic expando to survive despite GC.
    283 [ 279: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 36): Expect subobject expando to survive despite GC.
    284 [ 280: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 36): Expect extra expando to survive despite GC.
    285 [ 281: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    286 [ 282: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 37): Expect basic expando to survive despite GC.
    287 [ 283: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 37): Expect subobject expando to survive despite GC.
    288 [ 284: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 37): Expect extra expando to survive despite GC.
    289 [ 285: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    290 [ 286: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 38): Expect basic expando to survive despite GC.
    291 [ 287: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 38): Expect subobject expando to survive despite GC.
    292 [ 288: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 38): Expect extra expando to survive despite GC.
    293 [ 289: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    294 [ 290: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 39): Expect basic expando to survive despite GC.
    295 [ 291: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 39): Expect subobject expando to survive despite GC.
    296 [ 292: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 39): Expect extra expando to survive despite GC.
    297 [ 293: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    298 [ 294: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 40): Expect basic expando to survive despite GC.
    299 [ 295: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 40): Expect subobject expando to survive despite GC.
    300 [ 296: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 40): Expect extra expando to survive despite GC.
    301 [ 297: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    302 [ 298: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 41): Expect basic expando to survive despite GC.
    303 [ 299: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 41): Expect subobject expando to survive despite GC.
    304 [ 300: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 41): Expect extra expando to survive despite GC.
    305 [ 301: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    306 [ 302: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 42): Expect basic expando to survive despite GC.
    307 [ 303: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 42): Expect subobject expando to survive despite GC.
    308 [ 304: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 42): Expect extra expando to survive despite GC.
    309 [ 305: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    310 [ 306: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 43): Expect basic expando to survive despite GC.
    311 [ 307: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 43): Expect subobject expando to survive despite GC.
    312 [ 308: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 43): Expect extra expando to survive despite GC.
    313 [ 309: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    314 [ 310: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 44): Expect basic expando to survive despite GC.
    315 [ 311: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 44): Expect subobject expando to survive despite GC.
    316 [ 312: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 44): Expect extra expando to survive despite GC.
    317 [ 313: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    318 [ 314: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 45): Expect basic expando to survive despite GC.
    319 [ 315: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 45): Expect subobject expando to survive despite GC.
    320 [ 316: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 45): Expect extra expando to survive despite GC.
    321 [ 317: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    322 [ 318: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 46): Expect basic expando to survive despite GC.
    323 [ 319: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 46): Expect subobject expando to survive despite GC.
    324 [ 320: FAIL ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 46): Expect extra expando to survive despite GC.
    325 [ 321: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    326 [ 322: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 47): Expect basic expando to survive despite GC.
    327 [ 323: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 47): Expect subobject expando to survive despite GC.
    328 [ 324: PASS ] getIndexedParameter(UNIFORM_BUFFER_BINDING, 47): Expect extra expando to survive despite GC.
    329 [ 325: PASS ] [object WebGLBuffer] is an instance of WebGLBuffer
    330 [ 326: PASS ] CURRENT_QUERY returns instance that was bound.
    331 [ 327: PASS ] CURRENT_QUERY returns instance that was bound.
    332 [ 328: FAIL ] Query: Expect basic expando to survive despite GC.
    333 [ 329: FAIL ] Query: Expect subobject expando to survive despite GC.
    334 [ 330: PASS ] Query: Expect extra expando to survive despite GC.
    335 [ 331: PASS ] [object WebGLQuery] is an instance of WebGLQuery
    336 [ 332: FAIL ] Query: Expect basic expando to survive despite GC.
    337 [ 333: FAIL ] Query: Expect subobject expando to survive despite GC.
    338 [ 334: PASS ] Query: Expect extra expando to survive despite GC.
    339 [ 335: PASS ] [object WebGLQuery] is an instance of WebGLQuery
    340 [ 336: PASS ] successfullyParsed is true
    341 [ FAIL ] 180 failures reported
     4[ PASS ] All tests passed

  • trunk/LayoutTests/webgl/2.0.0/resources/webgl_test_files/js/js-test-pre.js

    r265523 r265708  
    709709    }
    710710
     711    // WebKit's MiniBrowser
     712    if (window.$vm) {
     713        window.$vm.gc();
     714        return;
     715    }
     716
    711717    function gcRec(n) {
    712718        if (n < 1)

  • trunk/Source/WebCore/ChangeLog

    r265705 r265708  
     12020-08-14  Kenneth Russell  <kbr@chromium.org>
     2
     3        [WebGL2] expando-loss and expando-loss-2 conformance tests are failing
     4        https://bugs.webkit.org/show_bug.cgi?id=214765
     5
     6        Reviewed by Yusuke Suzuki.
     7
     8        Re-land with locking fixes ysuzuki@ pointed out as necessary, and
     9        advised heavily on.
     10
     11        Use JSWebGLRenderingContext's and JSWebGL2RenderingContext's
     12        existing visitAdditionalChildren hook, via JSCustomMarkFunction in
     13        their IDL, to add opaque roots for all WebGLObjects latched in to
     14        the context state, and all WebGLObjects they refer to. Extensions
     15        were already previously handled.
     16
     17        In order to support JSC's concurrent marking, grab a
     18        per-WebGL-context lock in visitAdditionalChildren, and in all
     19        WebGL context- and object-related methods which modify compound
     20        data structures like HashMaps and Vectors that are traversed by
     21        visitAdditionalChildren and its callees. Add "const
     22        AbstractLocker&" throughout WebGL's call hierarchy to guarantee
     23        that this lock is held where needed. Add needed exception in
     24        WebGLObjects' destructors to avoid recursive locking, and in
     25        WebGLContextGroup destruction to avoid mutating objects that GC
     26        might be traversing when a lock is no longer available on the
     27        application's thread.
     28
     29        Add "GenerateIsReachable=Impl" to the IDL files of needed WebGL
     30        objects (WebGLBuffer, WebGLTexture, etc.) so that they pay
     31        attention to the opaque root state when determining liveness of
     32        their JavaScript wrappers. Add a FIXME to objectGraphLock in
     33        WebGLRenderingContextBase to consider rewriting this in a
     34        lock-free manner.
     35
     36        Covered by existing WebGL conformance tests.
     37
     38        * bindings/js/JSWebGL2RenderingContextCustom.cpp:
     39        (WebCore::JSWebGL2RenderingContext::visitAdditionalChildren):
     40        * bindings/js/JSWebGLRenderingContextCustom.cpp:
     41        (WebCore::JSWebGLRenderingContext::visitAdditionalChildren):
     42        * html/canvas/OESVertexArrayObject.cpp:
     43        (WebCore::OESVertexArrayObject::deleteVertexArrayOES):
     44        (WebCore::OESVertexArrayObject::bindVertexArrayOES):
     45        * html/canvas/WebGL2RenderingContext.cpp:
     46        (WebCore::WebGL2RenderingContext::validateAndCacheBufferBinding):
     47        (WebCore::WebGL2RenderingContext::bindFramebuffer):
     48        (WebCore::WebGL2RenderingContext::deleteFramebuffer):
     49        (WebCore::WebGL2RenderingContext::deleteQuery):
     50        (WebCore::WebGL2RenderingContext::beginQuery):
     51        (WebCore::WebGL2RenderingContext::endQuery):
     52        (WebCore::WebGL2RenderingContext::deleteSampler):
     53        (WebCore::WebGL2RenderingContext::bindSampler):
     54        (WebCore::WebGL2RenderingContext::deleteSync):
     55        (WebCore::WebGL2RenderingContext::deleteTransformFeedback):
     56        (WebCore::WebGL2RenderingContext::bindTransformFeedback):
     57        (WebCore::WebGL2RenderingContext::beginTransformFeedback):
     58        (WebCore::WebGL2RenderingContext::setIndexedBufferBinding):
     59        (WebCore::WebGL2RenderingContext::deleteVertexArray):
     60        (WebCore::WebGL2RenderingContext::bindVertexArray):
     61        (WebCore::WebGL2RenderingContext::addMembersToOpaqueRoots):
     62        (WebCore::WebGL2RenderingContext::uncacheDeletedBuffer):
     63        * html/canvas/WebGL2RenderingContext.h:
     64        * html/canvas/WebGLBuffer.cpp:
     65        (WebCore::WebGLBuffer::~WebGLBuffer):
     66        (WebCore::WebGLBuffer::deleteObjectImpl):
     67        * html/canvas/WebGLBuffer.h:
     68        * html/canvas/WebGLBuffer.idl:
     69        * html/canvas/WebGLContextGroup.cpp:
     70        (WebCore::WebGLContextGroup::hasAContext const):
     71        (WebCore::WebGLContextGroup::objectGraphLockForAContext):
     72        (WebCore::WebGLContextGroup::detachAndRemoveAllObjects):
     73        * html/canvas/WebGLContextGroup.h:
     74        * html/canvas/WebGLContextObject.cpp:
     75        (WebCore::WebGLContextObject::detachContext):
     76        (WebCore::WebGLContextObject::objectGraphLockForContext):
     77        * html/canvas/WebGLContextObject.h:
     78        * html/canvas/WebGLFramebuffer.cpp:
     79        (WebCore::WebGLFramebuffer::~WebGLFramebuffer):
     80        (WebCore::WebGLFramebuffer::removeAttachmentFromBoundFramebuffer):
     81        (WebCore::WebGLFramebuffer::deleteObjectImpl):
     82        (WebCore::WebGLFramebuffer::initializeAttachments):
     83        (WebCore::WebGLFramebuffer::addMembersToOpaqueRoots):
     84        (WebCore::WebGLFramebuffer::setAttachmentInternal):
     85        (WebCore::WebGLFramebuffer::removeAttachmentInternal):
     86        * html/canvas/WebGLFramebuffer.h:
     87        * html/canvas/WebGLFramebuffer.idl:
     88        * html/canvas/WebGLObject.cpp:
     89        (WebCore::WebGLObject::runDestructor):
     90        (WebCore::WebGLObject::deleteObject):
     91        * html/canvas/WebGLObject.h:
     92        * html/canvas/WebGLProgram.cpp:
     93        (WebCore::WebGLProgram::~WebGLProgram):
     94        (WebCore::WebGLProgram::deleteObjectImpl):
     95        (WebCore::WebGLProgram::attachShader):
     96        (WebCore::WebGLProgram::detachShader):
     97        (WebCore::WebGLProgram::addMembersToOpaqueRoots):
     98        * html/canvas/WebGLProgram.h:
     99        * html/canvas/WebGLProgram.idl:
     100        * html/canvas/WebGLQuery.cpp:
     101        (WebCore::WebGLQuery::~WebGLQuery):
     102        (WebCore::WebGLQuery::deleteObjectImpl):
     103        * html/canvas/WebGLQuery.h:
     104        * html/canvas/WebGLQuery.idl:
     105        * html/canvas/WebGLRenderbuffer.cpp:
     106        (WebCore::WebGLRenderbuffer::~WebGLRenderbuffer):
     107        (WebCore::WebGLRenderbuffer::deleteObjectImpl):
     108        * html/canvas/WebGLRenderbuffer.h:
     109        * html/canvas/WebGLRenderbuffer.idl:
     110        * html/canvas/WebGLRenderingContextBase.cpp:
     111        (WebCore::WebGLRenderingContextBase::attachShader):
     112        (WebCore::WebGLRenderingContextBase::validateAndCacheBufferBinding):
     113        (WebCore::WebGLRenderingContextBase::bindBuffer):
     114        (WebCore::WebGLRenderingContextBase::bindFramebuffer):
     115        (WebCore::WebGLRenderingContextBase::bindRenderbuffer):
     116        (WebCore::WebGLRenderingContextBase::bindTexture):
     117        (WebCore::WebGLRenderingContextBase::deleteObject):
     118        (WebCore::WebGLRenderingContextBase::uncacheDeletedBuffer):
     119        (WebCore::WebGLRenderingContextBase::setBoundVertexArrayObject):
     120        (WebCore::WebGLRenderingContextBase::deleteBuffer):
     121        (WebCore::WebGLRenderingContextBase::deleteFramebuffer):
     122        (WebCore::WebGLRenderingContextBase::deleteProgram):
     123        (WebCore::WebGLRenderingContextBase::deleteRenderbuffer):
     124        (WebCore::WebGLRenderingContextBase::deleteShader):
     125        (WebCore::WebGLRenderingContextBase::deleteTexture):
     126        (WebCore::WebGLRenderingContextBase::detachShader):
     127        (WebCore::WebGLRenderingContextBase::useProgram):
     128        (WebCore::WebGLRenderingContextBase::vertexAttribPointer):
     129        (WebCore::WebGLRenderingContextBase::detachAndRemoveAllObjects):
     130        (WebCore::WebGLRenderingContextBase::setFramebuffer):
     131        (WebCore::WebGLRenderingContextBase::addMembersToOpaqueRoots):
     132        (WebCore::WebGLRenderingContextBase::objectGraphLock):
     133        * html/canvas/WebGLRenderingContextBase.h:
     134        (WebCore::WebGLRenderingContextBase::setBoundVertexArrayObject): Deleted.
     135        * html/canvas/WebGLSampler.cpp:
     136        (WebCore::WebGLSampler::~WebGLSampler):
     137        (WebCore::WebGLSampler::deleteObjectImpl):
     138        * html/canvas/WebGLSampler.h:
     139        * html/canvas/WebGLSampler.idl:
     140        * html/canvas/WebGLShader.cpp:
     141        (WebCore::WebGLShader::~WebGLShader):
     142        (WebCore::WebGLShader::deleteObjectImpl):
     143        * html/canvas/WebGLShader.h:
     144        * html/canvas/WebGLShader.idl:
     145        * html/canvas/WebGLSharedObject.cpp:
     146        (WebCore::WebGLSharedObject::detachContextGroup):
     147        (WebCore::WebGLSharedObject::detachContextGroupWithoutDeletingObject):
     148        (WebCore::WebGLSharedObject::hasGroupOrContext const):
     149        (WebCore::WebGLSharedObject::objectGraphLockForContext):
     150        * html/canvas/WebGLSharedObject.h:
     151        * html/canvas/WebGLSync.cpp:
     152        (WebCore::WebGLSync::~WebGLSync):
     153        (WebCore::WebGLSync::deleteObjectImpl):
     154        * html/canvas/WebGLSync.h:
     155        * html/canvas/WebGLTexture.cpp:
     156        (WebCore::WebGLTexture::~WebGLTexture):
     157        (WebCore::WebGLTexture::deleteObjectImpl):
     158        * html/canvas/WebGLTexture.h:
     159        * html/canvas/WebGLTexture.idl:
     160        * html/canvas/WebGLTransformFeedback.cpp:
     161        (WebCore::WebGLTransformFeedback::~WebGLTransformFeedback):
     162        (WebCore::WebGLTransformFeedback::deleteObjectImpl):
     163        (WebCore::WebGLTransformFeedback::setProgram):
     164        (WebCore::WebGLTransformFeedback::setBoundIndexedTransformFeedbackBuffer):
     165        (WebCore::WebGLTransformFeedback::addMembersToOpaqueRoots):
     166        (WebCore::WebGLTransformFeedback::unbindBuffer):
     167        * html/canvas/WebGLTransformFeedback.h:
     168        * html/canvas/WebGLTransformFeedback.idl:
     169        * html/canvas/WebGLVertexArrayObject.cpp:
     170        (WebCore::WebGLVertexArrayObject::~WebGLVertexArrayObject):
     171        (WebCore::WebGLVertexArrayObject::deleteObjectImpl):
     172        * html/canvas/WebGLVertexArrayObject.h:
     173        * html/canvas/WebGLVertexArrayObject.idl:
     174        * html/canvas/WebGLVertexArrayObjectBase.cpp:
     175        (WebCore::WebGLVertexArrayObjectBase::setElementArrayBuffer):
     176        (WebCore::WebGLVertexArrayObjectBase::setVertexAttribState):
     177        (WebCore::WebGLVertexArrayObjectBase::unbindBuffer):
     178        (WebCore::WebGLVertexArrayObjectBase::addMembersToOpaqueRoots):
     179        * html/canvas/WebGLVertexArrayObjectBase.h:
     180        * html/canvas/WebGLVertexArrayObjectOES.cpp:
     181        (WebCore::WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES):
     182        (WebCore::WebGLVertexArrayObjectOES::deleteObjectImpl):
     183        * html/canvas/WebGLVertexArrayObjectOES.h:
     184        * html/canvas/WebGLVertexArrayObjectOES.idl:
     185
    11862020-08-14  Andres Gonzalez  <andresg_22@apple.com>
    2187

  • trunk/Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp

    r265523 r265708  
    3737{
    3838    visitor.addOpaqueRoot(&wrapped());
     39    wrapped().addMembersToOpaqueRoots(visitor);
    3940}
    4041

  • trunk/Source/WebCore/bindings/js/JSWebGLRenderingContextCustom.cpp

    r265523 r265708  
    3737{
    3838    visitor.addOpaqueRoot(&wrapped());
     39    wrapped().addMembersToOpaqueRoots(visitor);
    3940}
    4041

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

    r254214 r265708  
    3131#include "ExtensionsGL.h"
    3232#include "WebGLRenderingContext.h"
     33#include <wtf/Lock.h>
     34#include <wtf/Locker.h>
    3335
    3436namespace WebCore {
    … …  
    5658void OESVertexArrayObject::deleteVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
    5759{
     60    auto locker = holdLock(m_context.objectGraphLock());
     61
    5862    if (!arrayObject || m_context.isContextLost())
    5963        return;
    6064
    6165    if (!arrayObject->isDefaultObject() && arrayObject == static_cast<WebGLRenderingContext&>(m_context).m_boundVertexArrayObject)
    62         static_cast<WebGLRenderingContext&>(m_context).setBoundVertexArrayObject(nullptr);
     66        static_cast<WebGLRenderingContext&>(m_context).setBoundVertexArrayObject(locker, nullptr);
    6367
    64     arrayObject->deleteObject(m_context.graphicsContextGL());
     68    arrayObject->deleteObject(locker, m_context.graphicsContextGL());
    6569}
    6670
    … …  
    7377void OESVertexArrayObject::bindVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
    7478{
     79    auto locker = holdLock(m_context.objectGraphLock());
     80
    7581    if (m_context.isContextLost())
    7682        return;
    … …  
    8692        extensions.bindVertexArrayOES(arrayObject->object());
    8793        arrayObject->setHasEverBeenBound();
    88         context.setBoundVertexArrayObject(arrayObject);
     94        context.setBoundVertexArrayObject(locker, arrayObject);
    8995    } else {
    9096        extensions.bindVertexArrayOES(0);
    91         context.setBoundVertexArrayObject(nullptr);
     97        context.setBoundVertexArrayObject(locker, nullptr);
    9298    }
    9399}

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

    r265523 r265708  
    6767#include <JavaScriptCore/HeapInlines.h>
    6868#include <JavaScriptCore/JSGenericTypedArrayViewInlines.h>
     69#include <JavaScriptCore/SlotVisitor.h>
     70#include <JavaScriptCore/SlotVisitorInlines.h>
    6971#include <JavaScriptCore/TypedArrayType.h>
    7072#include <wtf/IsoMallocInlines.h>
     73#include <wtf/Lock.h>
     74#include <wtf/Locker.h>
    7175
    7276namespace WebCore {
    … …  
    350354}
    351355
    352 bool WebGL2RenderingContext::validateAndCacheBufferBinding(const char* functionName, GCGLenum target, WebGLBuffer* buffer)
     356bool WebGL2RenderingContext::validateAndCacheBufferBinding(const AbstractLocker& locker, const char* functionName, GCGLenum target, WebGLBuffer* buffer)
    353357{
    354358    if (!validateBufferTarget(functionName, target))
    … …  
    369373        break;
    370374    case GraphicsContextGL::ELEMENT_ARRAY_BUFFER:
    371         m_boundVertexArrayObject->setElementArrayBuffer(buffer);
     375        m_boundVertexArrayObject->setElementArrayBuffer(locker, buffer);
    372376        break;
    373377    case GraphicsContextGL::PIXEL_PACK_BUFFER:
    … …  
    694698void WebGL2RenderingContext::bindFramebuffer(GCGLenum target, WebGLFramebuffer* buffer)
    695699{
     700    auto locker = holdLock(objectGraphLock());
     701
    696702    if (!checkObjectToBeBound("bindFramebuffer", buffer))
    697703        return;
    … …  
    709715    }
    710716
    711     setFramebuffer(target, buffer);
     717    setFramebuffer(locker, target, buffer);
    712718}
    713719
    … …  
    722728void WebGL2RenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)
    723729{
    724     if (!deleteObject(framebuffer))
     730    auto locker = holdLock(objectGraphLock());
     731
     732    if (!deleteObject(locker, framebuffer))
    725733        return;
    726734
    … …  
    18411849void WebGL2RenderingContext::deleteQuery(WebGLQuery* query)
    18421850{
     1851    auto locker = holdLock(objectGraphLock());
     1852
    18431853    if (isContextLostOrPending() || !query || !query->object() || !validateWebGLObject("deleteQuery", query))
    18441854        return;
    … …  
    18471857        m_activeQueries.remove(query->target());
    18481858    }
    1849     deleteObject(query);
     1859    deleteObject(locker, query);
    18501860}
    18511861
    … …  
    18701880void WebGL2RenderingContext::beginQuery(GCGLenum target, WebGLQuery& query)
    18711881{
     1882    auto locker = holdLock(objectGraphLock());
     1883
    18721884    GCGLenum targetKey;
    18731885    if (isContextLostOrPending() || !validateWebGLObject("beginQuery", &query) || !validateQueryTarget("beginQuery", target, &targetKey))
    … …  
    18931905void WebGL2RenderingContext::endQuery(GCGLenum target)
    18941906{
     1907    auto locker = holdLock(objectGraphLock());
     1908
    18951909    GCGLenum targetKey;
    18961910    if (isContextLostOrPending() || !scriptExecutionContext() || !validateQueryTarget("beginQuery", target, &targetKey))
    … …  
    19641978void WebGL2RenderingContext::deleteSampler(WebGLSampler* sampler)
    19651979{
     1980    auto locker = holdLock(objectGraphLock());
     1981
    19661982    if (isContextLostOrPending())
    19671983        return;
    … …  
    19751991    }
    19761992
    1977     deleteObject(sampler);
     1993    deleteObject(locker, sampler);
    19781994}
    19791995
    … …  
    19882004void WebGL2RenderingContext::bindSampler(GCGLuint unit, WebGLSampler* sampler)
    19892005{
     2006    auto locker = holdLock(objectGraphLock());
     2007
    19902008    if (isContextLostOrPending())
    19912009        return;
    … …  
    20782096void WebGL2RenderingContext::deleteSync(WebGLSync* sync)
    20792097{
     2098    auto locker = holdLock(objectGraphLock());
     2099
    20802100    if (isContextLostOrPending() || !sync || sync->isDeleted() || !validateWebGLObject("deleteSync", sync))
    20812101        return;
    2082     deleteObject(sync);
     2102    deleteObject(locker, sync);
    20832103}
    20842104
    … …  
    21492169void WebGL2RenderingContext::deleteTransformFeedback(WebGLTransformFeedback* feedbackObject)
    21502170{
     2171    auto locker = holdLock(objectGraphLock());
     2172
    21512173    if (isContextLostOrPending() || !feedbackObject || feedbackObject->isDeleted() || !validateWebGLObject("deleteTransformFeedback", feedbackObject))
    21522174        return;
    … …  
    21622184        m_boundTransformFeedback = m_defaultTransformFeedback;
    21632185
    2164     deleteObject(feedbackObject);
     2186    deleteObject(locker, feedbackObject);
    21652187}
    21662188
    … …  
    21752197void WebGL2RenderingContext::bindTransformFeedback(GCGLenum target, WebGLTransformFeedback* feedbackObject)
    21762198{
     2199    auto locker = holdLock(objectGraphLock());
     2200
    21772201    if (isContextLostOrPending())
    21782202        return;
    … …  
    22432267    m_context->beginTransformFeedback(primitiveMode);
    22442268
    2245     m_boundTransformFeedback->setProgram(*m_currentProgram);
     2269    auto locker = holdLock(objectGraphLock());
     2270    m_boundTransformFeedback->setProgram(locker, *m_currentProgram);
    22462271    m_boundTransformFeedback->setActive(true);
    22472272    m_boundTransformFeedback->setPaused(false);
    … …  
    23402365bool WebGL2RenderingContext::setIndexedBufferBinding(const char *functionName, GCGLenum target, GCGLuint index, WebGLBuffer* buffer)
    23412366{
     2367    auto locker = holdLock(objectGraphLock());
     2368
    23422369    if (isContextLostOrPending())
    23432370        return false;
    … …  
    23642391    }
    23652392
    2366     if (!validateAndCacheBufferBinding(functionName, target, buffer))
     2393    if (!validateAndCacheBufferBinding(locker, functionName, target, buffer))
    23672394        return false;
    23682395
    23692396    switch (target) {
    23702397    case GraphicsContextGL::TRANSFORM_FEEDBACK_BUFFER:
    2371         m_boundTransformFeedback->setBoundIndexedTransformFeedbackBuffer(index, buffer);
     2398        m_boundTransformFeedback->setBoundIndexedTransformFeedbackBuffer(locker, index, buffer);
    23722399        break;
    23732400    case GraphicsContextGL::UNIFORM_BUFFER:
    … …  
    25742601void WebGL2RenderingContext::deleteVertexArray(WebGLVertexArrayObject* arrayObject)
    25752602{
     2603    auto locker = holdLock(objectGraphLock());
     2604
    25762605    if (!arrayObject || isContextLost())
    25772606        return;
    … …  
    25802609        return;
    25812610
    2582     if (!arrayObject->isDefaultObject() && arrayObject == m_boundVertexArrayObject)
     2611    if (!arrayObject->isDefaultObject() && arrayObject == m_boundVertexArrayObject) {
    25832612#if USE(OPENGL_ES)
    2584         setBoundVertexArrayObject(nullptr);
     2613        setBoundVertexArrayObject(locker, nullptr);
    25852614#else
     2615        // bindVertexArray grabs the lock internally.
     2616        locker.unlockEarly();
    25862617        bindVertexArray(nullptr); // The default VAO was removed in OpenGL 3.3 but not from WebGL 2; bind the default for WebGL to use.
     2618        locker = holdLock(objectGraphLock());
    25872619#endif
    2588 
    2589     arrayObject->deleteObject(graphicsContextGL());
     2620    }
     2621
     2622    arrayObject->deleteObject(locker, graphicsContextGL());
    25902623}
    25912624
    … …  
    26032636void WebGL2RenderingContext::bindVertexArray(WebGLVertexArrayObject* arrayObject)
    26042637{
     2638    auto locker = holdLock(objectGraphLock());
     2639
    26052640    if (isContextLost())
    26062641        return;
    … …  
    26142649
    26152650        arrayObject->setHasEverBeenBound();
    2616         setBoundVertexArrayObject(arrayObject);
     2651        setBoundVertexArrayObject(locker, arrayObject);
    26172652    } else {
    26182653        m_context->bindVertexArray(m_defaultVertexArrayObject->object());
    2619         setBoundVertexArrayObject(m_defaultVertexArrayObject.get());
     2654        setBoundVertexArrayObject(locker, m_defaultVertexArrayObject.get());
    26202655    }
    26212656}
    … …  
    30093044    }
    30103045    return true;
     3046}
     3047
     3048void WebGL2RenderingContext::addMembersToOpaqueRoots(JSC::SlotVisitor& visitor)
     3049{
     3050    WebGLRenderingContextBase::addMembersToOpaqueRoots(visitor);
     3051
     3052    auto locker = holdLock(objectGraphLock());
     3053    visitor.addOpaqueRoot(m_readFramebufferBinding.get());
     3054    if (m_readFramebufferBinding)
     3055        m_readFramebufferBinding->addMembersToOpaqueRoots(locker, visitor);
     3056
     3057    visitor.addOpaqueRoot(m_boundTransformFeedback.get());
     3058    if (m_boundTransformFeedback)
     3059        m_boundTransformFeedback->addMembersToOpaqueRoots(locker, visitor);
     3060
     3061    visitor.addOpaqueRoot(m_boundCopyReadBuffer.get());
     3062    visitor.addOpaqueRoot(m_boundCopyWriteBuffer.get());
     3063    visitor.addOpaqueRoot(m_boundPixelPackBuffer.get());
     3064    visitor.addOpaqueRoot(m_boundPixelUnpackBuffer.get());
     3065    visitor.addOpaqueRoot(m_boundTransformFeedbackBuffer.get());
     3066    visitor.addOpaqueRoot(m_boundUniformBuffer.get());
     3067
     3068    for (auto& buffer : m_boundIndexedUniformBuffers)
     3069        visitor.addOpaqueRoot(buffer.get());
     3070
     3071    for (auto& entry : m_activeQueries)
     3072        visitor.addOpaqueRoot(entry.value.get());
     3073
     3074    for (auto& entry : m_boundSamplers)
     3075        visitor.addOpaqueRoot(entry.get());
    30113076}
    30123077
    … …  
    34923557        binding = nullptr;
    34933558
    3494 void WebGL2RenderingContext::uncacheDeletedBuffer(WebGLBuffer* buffer)
     3559void WebGL2RenderingContext::uncacheDeletedBuffer(const AbstractLocker& locker, WebGLBuffer* buffer)
    34953560{
    34963561    ASSERT(buffer);
    … …  
    35023567    REMOVE_BUFFER_FROM_BINDING(m_boundTransformFeedbackBuffer);
    35033568    REMOVE_BUFFER_FROM_BINDING(m_boundUniformBuffer);
    3504     m_boundTransformFeedback->unbindBuffer(*buffer);
    3505 
    3506     WebGLRenderingContextBase::uncacheDeletedBuffer(buffer);
     3569    m_boundTransformFeedback->unbindBuffer(locker, *buffer);
     3570
     3571    WebGLRenderingContextBase::uncacheDeletedBuffer(locker, buffer);
    35073572}
    35083573

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h

    r265523 r265708  
    262262    bool checkAndTranslateAttachments(const char* functionName, GCGLenum, Vector<GCGLenum>&);
    263263
     264    void addMembersToOpaqueRoots(JSC::SlotVisitor&) override;
     265
    264266private:
    265267    WebGL2RenderingContext(CanvasBase&, GraphicsContextGLAttributes);
    … …  
    285287    WebGLBuffer* validateBufferDataParameters(const char* functionName, GCGLenum target, GCGLenum usage) final;
    286288    WebGLBuffer* validateBufferDataTarget(const char* functionName, GCGLenum target) final;
    287     bool validateAndCacheBufferBinding(const char* functionName, GCGLenum target, WebGLBuffer*) final;
     289    bool validateAndCacheBufferBinding(const WTF::AbstractLocker&, const char* functionName, GCGLenum target, WebGLBuffer*) final;
    288290    GCGLint getMaxDrawBuffers() final;
    289291    GCGLint getMaxColorAttachments() final;
    … …  
    322324#endif
    323325
    324     void uncacheDeletedBuffer(WebGLBuffer*) final;
     326    void uncacheDeletedBuffer(const WTF::AbstractLocker&, WebGLBuffer*) final;
    325327
    326328    enum class ClearBufferCaller : uint8_t {

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

    r261413 r265708  
    3232#include "WebGLRenderingContextBase.h"
    3333#include <JavaScriptCore/ArrayBuffer.h>
     34#include <wtf/Lock.h>
     35#include <wtf/Locker.h>
    3436
    3537namespace WebCore {
    … …  
    4951WebGLBuffer::~WebGLBuffer()
    5052{
    51     deleteObject(0);
    52 }
    53 
    54 void WebGLBuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     53    if (!hasGroupOrContext())
     54        return;
     55
     56    runDestructor();
     57}
     58
     59void WebGLBuffer::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5560{
    5661    context3d->deleteBuffer(object);

  • trunk/Source/WebCore/html/canvas/WebGLBuffer.h

    r261413 r265708  
    6868    WebGLBuffer(WebGLRenderingContextBase&);
    6969
    70     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     70    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    7171
    7272    GCGLenum m_target { 0 };

  • trunk/Source/WebCore/html/canvas/WebGLBuffer.idl

    r265523 r265708  
    2626[
    2727    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLBuffer {
    2930};

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

    r254064 r265708  
    4545}
    4646
     47bool WebGLContextGroup::hasAContext() const
     48{
     49    return !m_contexts.isEmpty();
     50}
     51
    4752GraphicsContextGLOpenGL& WebGLContextGroup::getAGraphicsContextGL()
    4853{
    4954    ASSERT(!m_contexts.isEmpty());
    5055    return *(*m_contexts.begin())->graphicsContextGL();
     56}
     57
     58WTF::Lock& WebGLContextGroup::objectGraphLockForAContext()
     59{
     60    ASSERT(!m_contexts.isEmpty());
     61    // Since the WEBGL_shared_objects extension never shipped, and is
     62    // unlikely to, this is equivalent to WebGLContextObject's
     63    // implementation. If there were the possibility of WebGL objects
     64    // being shared between multiple contexts, this would have to be
     65    // rethought.
     66    return (*m_contexts.begin())->objectGraphLock();
    5167}
    5268
    … …  
    7793void WebGLContextGroup::detachAndRemoveAllObjects()
    7894{
     95    if (m_contexts.isEmpty()) {
     96        // No objectGraphLock is available to cover the calls to
     97        // WebGLObject::deleteObject.
     98        while (!m_groupObjects.isEmpty())
     99            (*m_groupObjects.begin())->detachContextGroupWithoutDeletingObject();
     100        return;
     101    }
     102
     103    auto locker = holdLock(objectGraphLockForAContext());
    79104    while (!m_groupObjects.isEmpty())
    80         (*m_groupObjects.begin())->detachContextGroup();
     105        (*m_groupObjects.begin())->detachContextGroup(locker);
    81106}
    82107

  • trunk/Source/WebCore/html/canvas/WebGLContextGroup.h

    r254064 r265708  
    2929
    3030#include "WebGLRenderingContextBase.h"
     31#include <wtf/Lock.h>
    3132
    3233namespace WebCore {
    … …  
    4344    void removeObject(WebGLSharedObject&);
    4445
     46    bool hasAContext() const;
    4547    GraphicsContextGLOpenGL& getAGraphicsContextGL();
     48    Lock& objectGraphLockForAContext();
    4649
    4750    void loseContextGroup(WebGLRenderingContextBase::LostContextMode);

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

    r254064 r265708  
    3030
    3131#include "WebGLRenderingContextBase.h"
     32#include <wtf/Lock.h>
    3233
    3334namespace WebCore {
    … …  
    4445}
    4546
    46 void WebGLContextObject::detachContext()
     47void WebGLContextObject::detachContext(const AbstractLocker& locker)
    4748{
    4849    detach();
    4950    if (m_context) {
    50         deleteObject(m_context->graphicsContextGL());
     51        deleteObject(locker, m_context->graphicsContextGL());
    5152        m_context->removeContextObject(*this);
    5253        m_context = nullptr;
    5354    }
     55}
     56
     57WTF::Lock& WebGLContextObject::objectGraphLockForContext()
     58{
     59    // Should not call this if the object or context has been deleted.
     60    ASSERT(m_context);
     61    return m_context->objectGraphLock();
    5462}
    5563

  • trunk/Source/WebCore/html/canvas/WebGLContextObject.h

    r254064 r265708  
    4848    }
    4949
    50     void detachContext();
     50    void detachContext(const WTF::AbstractLocker&);
     51
     52    WTF::Lock& objectGraphLockForContext() override;
    5153
    5254protected:

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

    r265523 r265708  
    3333#include "WebGLDrawBuffers.h"
    3434#include "WebGLRenderingContextBase.h"
     35#include <JavaScriptCore/SlotVisitor.h>
     36#include <JavaScriptCore/SlotVisitorInlines.h>
     37#include <wtf/Lock.h>
     38#include <wtf/Locker.h>
    3539
    3640namespace WebCore {
    … …  
    5458        bool isInitialized() const override;
    5559        void setInitialized() override;
    56         void onDetached(GraphicsContextGLOpenGL*) override;
     60        void onDetached(const AbstractLocker&, GraphicsContextGLOpenGL*) override;
    5761        void attach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) override;
    5862        void unattach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) override;
     63        void addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor&) override;
    5964
    6065        WebGLRenderbufferAttachment() { };
    … …  
    116121    }
    117122
    118     void WebGLRenderbufferAttachment::onDetached(GraphicsContextGLOpenGL* context)
    119     {
    120         m_renderbuffer->onDetached(context);
     123    void WebGLRenderbufferAttachment::onDetached(const AbstractLocker& locker, GraphicsContextGLOpenGL* context)
     124    {
     125        m_renderbuffer->onDetached(locker, context);
    121126    }
    122127
    … …  
    136141#endif
    137142            context->framebufferRenderbuffer(target, attachment, GraphicsContextGL::RENDERBUFFER, 0);
     143    }
     144
     145    void WebGLRenderbufferAttachment::addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor& visitor)
     146    {
     147        visitor.addOpaqueRoot(m_renderbuffer.get());
    138148    }
    139149
    … …  
    154164        bool isInitialized() const override;
    155165        void setInitialized() override;
    156         void onDetached(GraphicsContextGLOpenGL*) override;
     166        void onDetached(const AbstractLocker&, GraphicsContextGLOpenGL*) override;
    157167        void attach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) override;
    158168        void unattach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) override;
     169        void addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor&) override;
    159170
    160171        WebGLTextureAttachment() { };
    … …  
    222233    }
    223234
    224     void WebGLTextureAttachment::onDetached(GraphicsContextGLOpenGL* context)
    225     {
    226         m_texture->onDetached(context);
     235    void WebGLTextureAttachment::onDetached(const AbstractLocker& locker, GraphicsContextGLOpenGL* context)
     236    {
     237        m_texture->onDetached(locker, context);
    227238    }
    228239
    … …  
    254265    }
    255266
     267    void WebGLTextureAttachment::addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor& visitor)
     268    {
     269        visitor.addOpaqueRoot(m_texture.get());
     270    }
     271
    256272#if !USE(ANGLE)
    257273    bool isAttachmentComplete(WebGLFramebuffer::WebGLAttachment* attachedObject, GCGLenum attachment, const char** reason)
    … …  
    300316WebGLFramebuffer::~WebGLFramebuffer()
    301317{
    302     deleteObject(0);
     318    if (!context())
     319        return;
     320
     321    runDestructor();
    303322}
    304323
    … …  
    372391}
    373392
    374 void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GCGLenum target, GCGLenum attachment)
    375 {
     393void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(const AbstractLocker& locker, GCGLenum target, GCGLenum attachment)
     394{
     395    if (!context()) {
     396        // Context has been deleted - should not be calling this.
     397        return;
     398    }
     399
    376400#if ASSERT_ENABLED
    377401    ASSERT(isBound(target));
    … …  
    384408    RefPtr<WebGLAttachment> attachmentObject = getAttachment(attachment);
    385409    if (attachmentObject) {
    386         attachmentObject->onDetached(context()->graphicsContextGL());
     410        attachmentObject->onDetached(locker, context()->graphicsContextGL());
    387411        m_attachments.remove(attachment);
    388412        drawBuffersIfNecessary(false);
    … …  
    404428}
    405429
    406 void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GCGLenum target, WebGLSharedObject* attachment)
     430void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(const AbstractLocker& locker, GCGLenum target, WebGLSharedObject* attachment)
    407431{
    408432    ASSERT(isBound(target));
    … …  
    420444                GCGLenum attachmentType = entry.key;
    421445                attachmentObject->unattach(context()->graphicsContextGL(), target, attachmentType);
    422                 removeAttachmentFromBoundFramebuffer(target, attachmentType);
     446                removeAttachmentFromBoundFramebuffer(locker, target, attachmentType);
    423447                checkMore = true;
    424448                break;
    … …  
    540564}
    541565
    542 void WebGLFramebuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     566void WebGLFramebuffer::deleteObjectImpl(const AbstractLocker& locker, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    543567{
    544568    for (auto& attachment : m_attachments.values())
    545         attachment->onDetached(context3d);
     569        attachment->onDetached(locker, context3d);
    546570
    547571    context3d->deleteFramebuffer(object);
    548572}
    549573
     574#if !USE(ANGLE)
    550575bool WebGLFramebuffer::initializeAttachments(GraphicsContextGLOpenGL* g3d, const char** reason)
    551576{
     577    if (!context()) {
     578        // Context has been deleted - should not be calling this.
     579        return false;
     580    }
     581    auto locker = holdLock(objectGraphLockForContext());
     582
    552583    ASSERT(object());
    553584    GCGLbitfield mask = 0;
    … …  
    634665    return true;
    635666}
     667#endif
    636668
    637669bool WebGLFramebuffer::isBound(GCGLenum target) const
    … …  
    690722}
    691723
     724void WebGLFramebuffer::addMembersToOpaqueRoots(const AbstractLocker& locker, JSC::SlotVisitor& visitor)
     725{
     726    for (auto& entry : m_attachments)
     727        entry.value->addMembersToOpaqueRoots(locker, visitor);
     728}
     729
    692730void WebGLFramebuffer::setAttachmentInternal(GCGLenum attachment, GCGLenum texTarget, WebGLTexture* texture, GCGLint level, GCGLint layer)
    693731{
    694     removeAttachmentInternal(attachment);
     732    if (!context()) {
     733        // Context has been deleted - should not be calling this.
     734        return;
     735    }
     736    auto locker = holdLock(objectGraphLockForContext());
     737
     738    removeAttachmentInternal(locker, attachment);
    695739    if (texture && texture->object()) {
    696740        m_attachments.set(attachment, WebGLTextureAttachment::create(texture, texTarget, level, layer));
    … …  
    702746void WebGLFramebuffer::setAttachmentInternal(GCGLenum attachment, WebGLRenderbuffer* renderbuffer)
    703747{
    704     removeAttachmentInternal(attachment);
     748    if (!context()) {
     749        // Context has been deleted - should not be calling this.
     750        return;
     751    }
     752    auto locker = holdLock(objectGraphLockForContext());
     753
     754    removeAttachmentInternal(locker, attachment);
    705755    if (renderbuffer && renderbuffer->object()) {
    706756        m_attachments.set(attachment, WebGLRenderbufferAttachment::create(renderbuffer));
    … …  
    710760}
    711761
    712 void WebGLFramebuffer::removeAttachmentInternal(GCGLenum attachment)
     762void WebGLFramebuffer::removeAttachmentInternal(const AbstractLocker& locker, GCGLenum attachment)
    713763{
    714764    WebGLAttachment* attachmentObject = getAttachment(attachment);
    715765    if (attachmentObject) {
    716         attachmentObject->onDetached(context()->graphicsContextGL());
     766        attachmentObject->onDetached(locker, context()->graphicsContextGL());
    717767        m_attachments.remove(attachment);
    718768        drawBuffersIfNecessary(false);

  • trunk/Source/WebCore/html/canvas/WebGLFramebuffer.h

    r265523 r265708  
    3434#include <wtf/Vector.h>
    3535
     36namespace JSC {
     37class SlotVisitor;
     38}
     39
     40namespace WTF {
     41class AbstractLocker;
     42}
     43
    3644namespace WebCore {
    3745
    … …  
    5563        virtual bool isInitialized() const = 0;
    5664        virtual void setInitialized() = 0;
    57         virtual void onDetached(GraphicsContextGLOpenGL*) = 0;
     65        virtual void onDetached(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*) = 0;
    5866        virtual void attach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) = 0;
    5967        virtual void unattach(GraphicsContextGLOpenGL*, GCGLenum target, GCGLenum attachment) = 0;
     68        virtual void addMembersToOpaqueRoots(const WTF::AbstractLocker&, JSC::SlotVisitor&) = 0;
    6069
    6170    protected:
    … …  
    7079    void setAttachmentForBoundFramebuffer(GCGLenum target, GCGLenum attachment, WebGLRenderbuffer*);
    7180    // If an object is attached to the currently bound framebuffer, remove it.
    72     void removeAttachmentFromBoundFramebuffer(GCGLenum target, WebGLSharedObject*);
     81    void removeAttachmentFromBoundFramebuffer(const WTF::AbstractLocker&, GCGLenum target, WebGLSharedObject*);
    7382    // If a given attachment point for the currently bound framebuffer is not null, remove the attached object.
    74     void removeAttachmentFromBoundFramebuffer(GCGLenum target, GCGLenum attachment);
     83    void removeAttachmentFromBoundFramebuffer(const WTF::AbstractLocker&, GCGLenum target, GCGLenum attachment);
    7584    WebGLSharedObject* getAttachmentObject(GCGLenum) const;
    7685
    … …  
    106115    GCGLenum getDrawBuffer(GCGLenum);
    107116
     117    void addMembersToOpaqueRoots(const WTF::AbstractLocker&, JSC::SlotVisitor&);
     118
    108119private:
    109120    WebGLFramebuffer(WebGLRenderingContextBase&);
    110121
    111     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     122    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    112123
    113124    WebGLAttachment* getAttachment(GCGLenum) const;
    114125
     126#if !USE(ANGLE)
    115127    // Return false if framebuffer is incomplete.
    116128    bool initializeAttachments(GraphicsContextGLOpenGL*, const char** reason);
     129#endif
    117130
    118131    // Check if the framebuffer is currently bound to the given target.
    … …  
    129142    // If a given attachment point for the currently bound framebuffer is not
    130143    // null, remove the attached object.
    131     void removeAttachmentInternal(GCGLenum attachment);
     144    void removeAttachmentInternal(const WTF::AbstractLocker&, GCGLenum attachment);
    132145
    133146    typedef WTF::HashMap<GCGLenum, RefPtr<WebGLAttachment>> AttachmentMap;

  • trunk/Source/WebCore/html/canvas/WebGLFramebuffer.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLFramebuffer {
    2930};

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

    r256758 r265708  
    4545}
    4646
    47 void WebGLObject::deleteObject(GraphicsContextGLOpenGL* context3d)
     47void WebGLObject::runDestructor()
     48{
     49    auto& lock = objectGraphLockForContext();
     50    if (lock.isHeld()) {
     51        // Destruction of WebGLObjects can happen in chains triggered from GC.
     52        // The lock must be held only once, at the beginning of the chain.
     53        auto locker = AbstractLocker(NoLockingNecessary);
     54        deleteObject(locker, nullptr);
     55    } else {
     56        auto locker = holdLock(lock);
     57        deleteObject(locker, nullptr);
     58    }
     59}
     60
     61void WebGLObject::deleteObject(const AbstractLocker& locker, GraphicsContextGLOpenGL* context3d)
    4862{
    4963    m_deleted = true;
    … …  
    6781
    6882        if (context3d)
    69             deleteObjectImpl(context3d, m_object);
     83            deleteObjectImpl(locker, context3d, m_object);
    7084    }
    7185
    … …  
    7993}
    8094
    81 void WebGLObject::onDetached(GraphicsContextGLOpenGL* context3d)
     95void WebGLObject::onDetached(const AbstractLocker& locker, GraphicsContextGLOpenGL* context3d)
    8296{
    8397    if (m_attachmentCount)
    8498        --m_attachmentCount;
    8599    if (m_deleted)
    86         deleteObject(context3d);
     100        deleteObject(locker, context3d);
    87101}
    88102

  • trunk/Source/WebCore/html/canvas/WebGLObject.h

    r256758 r265708  
    3131#include <wtf/RefCounted.h>
    3232
     33namespace WTF {
     34class AbstractLocker;
     35class Lock;
     36}
     37
    3338namespace WebCore {
    3439
    … …  
    4651    // shaders, deletion is delayed until they are no longer attached.
    4752    // FIXME: revisit this when resource sharing between contexts are implemented.
    48     void deleteObject(GraphicsContextGLOpenGL*);
     53    // The AbstractLocker argument enforces at compile time that the objectGraphLock
     54    // is held. This isn't necessary for all object types, but enough of them that
     55    // it's done for all of them.
     56    void deleteObject(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*);
    4957
    5058    void onAttached() { ++m_attachmentCount; }
    51     void onDetached(GraphicsContextGLOpenGL*);
     59    void onDetached(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*);
    5260
    5361    // This indicates whether the client side issue a delete call already, not
    … …  
    5967    virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContextBase&) const = 0;
    6068
     69    // Returns the object graph lock associated with the context most
     70    // closely associated with this object. Since the
     71    // WEBGL_shared_objects extension specification never shipped (and
     72    // is unlikely to), this basically returns the same result for
     73    // both context objects and shared objects.
     74    virtual WTF::Lock& objectGraphLockForContext() = 0;
     75
    6176protected:
    6277    WebGLObject() = default;
    … …  
    6580    void setObject(PlatformGLObject);
    6681
     82    void runDestructor();
     83
    6784    // deleteObjectImpl should be only called once to delete the OpenGL resource.
    68     virtual void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) = 0;
     85    virtual void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) = 0;
    6986
    7087    virtual bool hasGroupOrContext() const = 0;

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

    r265523 r265708  
    3434#include "WebGLRenderingContextBase.h"
    3535#include "WebGLShader.h"
     36#include <JavaScriptCore/SlotVisitor.h>
     37#include <JavaScriptCore/SlotVisitorInlines.h>
    3638#include <wtf/Lock.h>
     39#include <wtf/Locker.h>
    3740#include <wtf/NeverDestroyed.h>
    3841
    … …  
    7376{
    7477    InspectorInstrumentation::willDestroyWebGLProgram(*this);
    75 
    76     deleteObject(0);
    7778
    7879    {
    … …  
    8182        instances(lock).remove(this);
    8283    }
     84
     85    if (!hasGroupOrContext())
     86        return;
     87
     88    runDestructor();
    8389}
    8490
    … …  
    9096}
    9197
    92 void WebGLProgram::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject obj)
     98void WebGLProgram::deleteObjectImpl(const AbstractLocker& locker, GraphicsContextGLOpenGL* context3d, PlatformGLObject obj)
    9399{
    94100    context3d->deleteProgram(obj);
    95101    if (m_vertexShader) {
    96         m_vertexShader->onDetached(context3d);
     102        m_vertexShader->onDetached(locker, context3d);
    97103        m_vertexShader = nullptr;
    98104    }
    99105    if (m_fragmentShader) {
    100         m_fragmentShader->onDetached(context3d);
     106        m_fragmentShader->onDetached(locker, context3d);
    101107        m_fragmentShader = nullptr;
    102108    }
    … …  
    157163}
    158164
    159 bool WebGLProgram::attachShader(WebGLShader* shader)
     165bool WebGLProgram::attachShader(const AbstractLocker&, WebGLShader* shader)
    160166{
    161167    if (!shader || !shader->object())
    … …  
    177183}
    178184
    179 bool WebGLProgram::detachShader(WebGLShader* shader)
     185bool WebGLProgram::detachShader(const AbstractLocker&, WebGLShader* shader)
    180186{
    181187    if (!shader || !shader->object())
    … …  
    195201        return false;
    196202    }
     203}
     204
     205void WebGLProgram::addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor& visitor)
     206{
     207    visitor.addOpaqueRoot(m_vertexShader.get());
     208    visitor.addOpaqueRoot(m_fragmentShader.get());
    197209}
    198210

  • trunk/Source/WebCore/html/canvas/WebGLProgram.h

    r265523 r265708  
    3535#include <wtf/Vector.h>
    3636
     37namespace JSC {
     38class SlotVisitor;
     39}
     40
     41namespace WTF {
     42class AbstractLocker;
     43};
     44
    3745namespace WebCore {
    3846
    … …  
    6876
    6977    WebGLShader* getAttachedShader(GCGLenum);
    70     bool attachShader(WebGLShader*);
    71     bool detachShader(WebGLShader*);
     78    bool attachShader(const WTF::AbstractLocker&, WebGLShader*);
     79    bool detachShader(const WTF::AbstractLocker&, WebGLShader*);
    7280   
    7381    void setRequiredTransformFeedbackBufferCount(int count)
    … …  
    8189    }
    8290
     91    void addMembersToOpaqueRoots(const WTF::AbstractLocker&, JSC::SlotVisitor&);
     92
    8393private:
    8494    WebGLProgram(WebGLRenderingContextBase&);
    8595
    86     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     96    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    8797
    8898    void cacheActiveAttribLocations(GraphicsContextGLOpenGL*);

  • trunk/Source/WebCore/html/canvas/WebGLProgram.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLProgram {
    2930};

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

    r264807 r265708  
    3131#include "WebGLContextGroup.h"
    3232#include "WebGLRenderingContextBase.h"
     33#include <wtf/Lock.h>
     34#include <wtf/Locker.h>
    3335
    3436namespace WebCore {
    … …  
    4143WebGLQuery::~WebGLQuery()
    4244{
    43     deleteObject(0);
     45    if (!contextGroup())
     46        return;
     47
     48    runDestructor();
    4449}
    4550
    … …  
    5055}
    5156
    52 void WebGLQuery::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     57void WebGLQuery::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5358{
    5459    context3d->deleteQuery(object);

  • trunk/Source/WebCore/html/canvas/WebGLQuery.h

    r264807 r265708  
    3030#include "WebGLSharedObject.h"
    3131
     32namespace WTF {
     33class AbstractLocker;
     34}
     35
    3236namespace WebCore {
    3337
    … …  
    4650private:
    4751    explicit WebGLQuery(WebGLRenderingContextBase&);
    48     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     52    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    4953
    5054    bool m_isResultAvailable { false };

  • trunk/Source/WebCore/html/canvas/WebGLQuery.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLQuery {
    2930};

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

    r254214 r265708  
    3232#include "WebGLContextGroup.h"
    3333#include "WebGLRenderingContextBase.h"
     34#include <wtf/Lock.h>
     35#include <wtf/Locker.h>
    3436
    3537namespace WebCore {
    … …  
    4244WebGLRenderbuffer::~WebGLRenderbuffer()
    4345{
    44     deleteObject(0);
     46    if (!hasGroupOrContext())
     47        return;
     48
     49    runDestructor();
    4550}
    4651
    … …  
    5762}
    5863
    59 void WebGLRenderbuffer::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     64void WebGLRenderbuffer::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    6065{
    6166    context3d->deleteRenderbuffer(object);

  • trunk/Source/WebCore/html/canvas/WebGLRenderbuffer.h

    r260415 r265708  
    6666    WebGLRenderbuffer(WebGLRenderingContextBase&);
    6767
    68     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     68    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    6969
    7070    bool isRenderbuffer() const override { return true; }

  • trunk/Source/WebCore/html/canvas/WebGLRenderbuffer.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLRenderbuffer {
    2930};

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

    r265540 r265708  
    103103#include <JavaScriptCore/ScriptCallStack.h>
    104104#include <JavaScriptCore/ScriptCallStackFactory.h>
     105#include <JavaScriptCore/SlotVisitor.h>
     106#include <JavaScriptCore/SlotVisitorInlines.h>
    105107#include <JavaScriptCore/TypedArrayInlines.h>
    106108#include <JavaScriptCore/Uint32Array.h>
    … …  
    110112#include <wtf/IsoMallocInlines.h>
    111113#include <wtf/Lock.h>
     114#include <wtf/Locker.h>
    112115#include <wtf/Scope.h>
    113116#include <wtf/StdLibExtras.h>
    … …  
    13201323void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader)
    13211324{
     1325    auto locker = holdLock(objectGraphLock());
     1326
    13221327    if (isContextLostOrPending() || !validateWebGLProgramOrShader("attachShader", program) || !validateWebGLProgramOrShader("attachShader", shader))
    13231328        return;
    1324     if (!program->attachShader(shader)) {
     1329    if (!program->attachShader(locker, shader)) {
    13251330        synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "attachShader", "shader attachment already has shader");
    13261331        return;
    … …  
    13991404}
    14001405
    1401 bool WebGLRenderingContextBase::validateAndCacheBufferBinding(const char* functionName, GCGLenum target, WebGLBuffer* buffer)
     1406bool WebGLRenderingContextBase::validateAndCacheBufferBinding(const AbstractLocker& locker, const char* functionName, GCGLenum target, WebGLBuffer* buffer)
    14021407{
    14031408    if (!validateBufferTarget(functionName, target))
    … …  
    14131418    else {
    14141419        ASSERT(target == GraphicsContextGL::ELEMENT_ARRAY_BUFFER);
    1415         m_boundVertexArrayObject->setElementArrayBuffer(buffer);
     1420        m_boundVertexArrayObject->setElementArrayBuffer(locker, buffer);
    14161421    }
    14171422
    … …  
    14231428void WebGLRenderingContextBase::bindBuffer(GCGLenum target, WebGLBuffer* buffer)
    14241429{
     1430    auto locker = holdLock(objectGraphLock());
     1431
    14251432    if (!checkObjectToBeBound("bindBuffer", buffer))
    14261433        return;
    14271434
    1428     if (!validateAndCacheBufferBinding("bindBuffer", target, buffer))
     1435    if (!validateAndCacheBufferBinding(locker, "bindBuffer", target, buffer))
    14291436        return;
    14301437
    … …  
    14341441void WebGLRenderingContextBase::bindFramebuffer(GCGLenum target, WebGLFramebuffer* buffer)
    14351442{
     1443    auto locker = holdLock(objectGraphLock());
     1444
    14361445    if (!checkObjectToBeBound("bindFramebuffer", buffer))
    14371446        return;
    … …  
    14421451    }
    14431452
    1444     setFramebuffer(target, buffer);
     1453    setFramebuffer(locker, target, buffer);
    14451454}
    14461455
    14471456void WebGLRenderingContextBase::bindRenderbuffer(GCGLenum target, WebGLRenderbuffer* renderBuffer)
    14481457{
     1458    auto locker = holdLock(objectGraphLock());
     1459
    14491460    if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer))
    14501461        return;
    … …  
    14611472void WebGLRenderingContextBase::bindTexture(GCGLenum target, WebGLTexture* texture)
    14621473{
     1474    auto locker = holdLock(objectGraphLock());
     1475
    14631476    if (!checkObjectToBeBound("bindTexture", texture))
    14641477        return;
    … …  
    19801993}
    19811994
    1982 bool WebGLRenderingContextBase::deleteObject(WebGLObject* object)
     1995bool WebGLRenderingContextBase::deleteObject(const AbstractLocker& locker, WebGLObject* object)
    19831996{
    19841997    if (isContextLostOrPending() || !object)
    … …  
    19932006        // We need to pass in context here because we want
    19942007        // things in this context unbound.
    1995         object->deleteObject(graphicsContextGL());
     2008        object->deleteObject(locker, graphicsContextGL());
    19962009    return true;
    19972010}
    … …  
    20012014        binding = nullptr;
    20022015
    2003 void WebGLRenderingContextBase::uncacheDeletedBuffer(WebGLBuffer* buffer)
     2016void WebGLRenderingContextBase::uncacheDeletedBuffer(const AbstractLocker& locker, WebGLBuffer* buffer)
    20042017{
    20052018    REMOVE_BUFFER_FROM_BINDING(m_boundArrayBuffer);
    20062019
    2007     m_boundVertexArrayObject->unbindBuffer(*buffer);
     2020    m_boundVertexArrayObject->unbindBuffer(locker, *buffer);
     2021}
     2022
     2023void WebGLRenderingContextBase::setBoundVertexArrayObject(const AbstractLocker&, WebGLVertexArrayObjectBase* arrayObject)
     2024{
     2025    m_boundVertexArrayObject = arrayObject ? arrayObject : m_defaultVertexArrayObject;
    20082026}
    20092027
    … …  
    20122030void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)
    20132031{
    2014     if (!deleteObject(buffer))
    2015         return;
    2016 
    2017     uncacheDeletedBuffer(buffer);
     2032    auto locker = holdLock(objectGraphLock());
     2033
     2034    if (!deleteObject(locker, buffer))
     2035        return;
     2036
     2037    uncacheDeletedBuffer(locker, buffer);
    20182038}
    20192039
    20202040void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
    20212041{
    2022     if (!deleteObject(framebuffer))
     2042    auto locker = holdLock(objectGraphLock());
     2043
     2044    if (!deleteObject(locker, framebuffer))
    20232045        return;
    20242046
    … …  
    20342056        InspectorInstrumentation::willDestroyWebGLProgram(*program);
    20352057
    2036     deleteObject(program);
     2058    auto locker = holdLock(objectGraphLock());
     2059
     2060    deleteObject(locker, program);
    20372061    // We don't reset m_currentProgram to 0 here because the deletion of the
    20382062    // current program is delayed.
    … …  
    20412065void WebGLRenderingContextBase::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)
    20422066{
    2043     if (!deleteObject(renderbuffer))
     2067    auto locker = holdLock(objectGraphLock());
     2068
     2069    if (!deleteObject(locker, renderbuffer))
    20442070        return;
    20452071    if (renderbuffer == m_renderbufferBinding)
    20462072        m_renderbufferBinding = nullptr;
    20472073    if (m_framebufferBinding)
    2048         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GraphicsContextGL::FRAMEBUFFER, renderbuffer);
     2074        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(locker, GraphicsContextGL::FRAMEBUFFER, renderbuffer);
    20492075    auto readFramebufferBinding = getFramebufferBinding(GraphicsContextGL::READ_FRAMEBUFFER);
    20502076    if (readFramebufferBinding)
    2051         readFramebufferBinding->removeAttachmentFromBoundFramebuffer(GraphicsContextGL::READ_FRAMEBUFFER, renderbuffer);
     2077        readFramebufferBinding->removeAttachmentFromBoundFramebuffer(locker, GraphicsContextGL::READ_FRAMEBUFFER, renderbuffer);
    20522078}
    20532079
    20542080void WebGLRenderingContextBase::deleteShader(WebGLShader* shader)
    20552081{
    2056     deleteObject(shader);
     2082    auto locker = holdLock(objectGraphLock());
     2083    deleteObject(locker, shader);
    20572084}
    20582085
    20592086void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture)
    20602087{
    2061     if (!deleteObject(texture))
     2088    auto locker = holdLock(objectGraphLock());
     2089
     2090    if (!deleteObject(locker, texture))
    20622091        return;
    20632092
    … …  
    20852114    }
    20862115    if (m_framebufferBinding)
    2087         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GraphicsContextGL::FRAMEBUFFER, texture);
     2116        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(locker, GraphicsContextGL::FRAMEBUFFER, texture);
    20882117    auto readFramebufferBinding = getFramebufferBinding(GraphicsContextGL::READ_FRAMEBUFFER);
    20892118    if (readFramebufferBinding)
    2090         readFramebufferBinding->removeAttachmentFromBoundFramebuffer(GraphicsContextGL::READ_FRAMEBUFFER, texture);
     2119        readFramebufferBinding->removeAttachmentFromBoundFramebuffer(locker, GraphicsContextGL::READ_FRAMEBUFFER, texture);
    20912120}
    20922121
    … …  
    21192148void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader)
    21202149{
     2150    auto locker = holdLock(objectGraphLock());
     2151
    21212152    if (isContextLostOrPending() || !validateWebGLProgramOrShader("detachShader", program) || !validateWebGLProgramOrShader("detachShader", shader))
    21222153        return;
    2123     if (!program->detachShader(shader)) {
     2154    if (!program->detachShader(locker, shader)) {
    21242155        synthesizeGLError(GraphicsContextGL::INVALID_OPERATION, "detachShader", "shader not attached");
    21252156        return;
    21262157    }
    21272158    m_context->detachShader(objectOrZero(program), objectOrZero(shader));
    2128     shader->onDetached(graphicsContextGL());
     2159    shader->onDetached(locker, graphicsContextGL());
    21292160}
    21302161
    … …  
    58965927void WebGLRenderingContextBase::useProgram(WebGLProgram* program)
    58975928{
     5929    auto locker = holdLock(objectGraphLock());
     5930
    58985931    if (!checkObjectToBeBound("useProgram", program))
    58995932        return;
    … …  
    59045937    if (m_currentProgram != program) {
    59055938        if (m_currentProgram)
    5906             m_currentProgram->onDetached(graphicsContextGL());
     5939            m_currentProgram->onDetached(locker, graphicsContextGL());
    59075940        m_currentProgram = program;
    59085941        m_context->useProgram(objectOrZero(program));
    … …  
    59615994void WebGLRenderingContextBase::vertexAttribPointer(GCGLuint index, GCGLint size, GCGLenum type, GCGLboolean normalized, GCGLsizei stride, long long offset)
    59625995{
     5996    auto locker = holdLock(objectGraphLock());
     5997
    59635998    if (isContextLostOrPending())
    59645999        return;
    … …  
    60246059    GCGLsizei bytesPerElement = size * typeSize;
    60256060
    6026     m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GCGLintptr>(offset), m_boundArrayBuffer.get());
     6061    m_boundVertexArrayObject->setVertexAttribState(locker, index, bytesPerElement, size, type, normalized, stride, static_cast<GCGLintptr>(offset), m_boundArrayBuffer.get());
    60276062    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GCGLintptr>(offset));
    60286063}
    … …  
    61536188        return;
    61546189
     6190    auto locker = holdLock(objectGraphLock());
     6191
    61556192    while (m_contextObjects.size() > 0) {
    61566193        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();
    6157         (*it)->detachContext();
     6194        (*it)->detachContext(locker);
    61586195    }
    61596196}
    … …  
    75597596}
    75607597
    7561 void WebGLRenderingContextBase::setFramebuffer(GCGLenum target, WebGLFramebuffer* buffer)
     7598void WebGLRenderingContextBase::setFramebuffer(const AbstractLocker&, GCGLenum target, WebGLFramebuffer* buffer)
    75627599{
    75637600    if (buffer)
    … …  
    77657802}
    77667803
     7804void WebGLRenderingContextBase::addMembersToOpaqueRoots(JSC::SlotVisitor& visitor)
     7805{
     7806    auto locker = holdLock(objectGraphLock());
     7807
     7808    visitor.addOpaqueRoot(m_boundArrayBuffer.get());
     7809
     7810    visitor.addOpaqueRoot(m_boundVertexArrayObject.get());
     7811    if (m_boundVertexArrayObject)
     7812        m_boundVertexArrayObject->addMembersToOpaqueRoots(locker, visitor);
     7813
     7814    visitor.addOpaqueRoot(m_currentProgram.get());
     7815    if (m_currentProgram)
     7816        m_currentProgram->addMembersToOpaqueRoots(locker, visitor);
     7817
     7818    visitor.addOpaqueRoot(m_framebufferBinding.get());
     7819    if (m_framebufferBinding)
     7820        m_framebufferBinding->addMembersToOpaqueRoots(locker, visitor);
     7821
     7822    visitor.addOpaqueRoot(m_renderbufferBinding.get());
     7823
     7824    for (auto& unit : m_textureUnits) {
     7825        visitor.addOpaqueRoot(unit.texture2DBinding.get());
     7826        visitor.addOpaqueRoot(unit.textureCubeMapBinding.get());
     7827        visitor.addOpaqueRoot(unit.texture3DBinding.get());
     7828        visitor.addOpaqueRoot(unit.texture2DArrayBinding.get());
     7829    }
     7830
     7831    // Extensions' IDL files use GenerateIsReachable=ImplWebGLRenderingContext,
     7832    // which checks to see whether the context is in the opaque root set (it is;
     7833    // it's added in JSWebGLRenderingContext / JSWebGL2RenderingContext's custom
     7834    // bindings code). For this reason it's unnecessary to explicitly add opaque
     7835    // roots for extensions.
     7836}
     7837
     7838Lock& WebGLRenderingContextBase::objectGraphLock()
     7839{
     7840    return m_objectGraphLock;
     7841}
     7842
    77677843void WebGLRenderingContextBase::prepareForDisplay()
    77687844{

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

    r265523 r265708  
    4848#include <memory>
    4949#include <wtf/CheckedArithmetic.h>
     50#include <wtf/Lock.h>
    5051
    5152#if ENABLE(WEBGL2)
    … …  
    5657#include "JSDOMPromiseDeferred.h"
    5758#endif
     59
     60namespace JSC {
     61class SlotVisitor;
     62}
     63
     64namespace WTF {
     65class AbstractLocker;
     66}
    5867
    5968namespace WebCore {
    … …  
    399408    void dispatchContextChangedNotification() override;
    400409
     410    virtual void addMembersToOpaqueRoots(JSC::SlotVisitor&);
     411    // This lock must be held across all mutations of containers like
     412    // Vectors, HashSets, etc. which contain RefPtr<WebGLObject>, and
     413    // which are traversed by addMembersToOpaqueRoots() or any of the
     414    // similarly-named methods in WebGLObject subclasses.
     415    //
     416    // FIXME: consider changing this mechanism to instead record when
     417    // individual WebGLObjects are latched / unlatched in the
     418    // context's state, either directly, or indirectly through
     419    // container objects. If that were done, then the
     420    // "GenerateIsReachable=Impl" in various WebGL objects' IDL files
     421    // would need to be changed to instead query whether the object is
     422    // currently latched into the context - without traversing all of
     423    // the latched objects to find the current one, which would be
     424    // prohibitively expensive.
     425    Lock& objectGraphLock();
     426
    401427protected:
    402428    WebGLRenderingContextBase(CanvasBase&, WebGLContextAttributes);
    … …  
    492518    bool enableSupportedExtension(ASCIILiteral extensionNameLiteral);
    493519
    494     virtual void uncacheDeletedBuffer(WebGLBuffer*);
     520    virtual void uncacheDeletedBuffer(const WTF::AbstractLocker&, WebGLBuffer*);
    495521
    496522    RefPtr<GraphicsContextGLOpenGL> m_context;
    497523    RefPtr<WebGLContextGroup> m_contextGroup;
     524    Lock m_objectGraphLock;
    498525
    499526    bool m_restoreAllowed { false };
    … …  
    510537    RefPtr<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
    511538
    512     void setBoundVertexArrayObject(WebGLVertexArrayObjectBase* arrayObject)
    513     {
    514         m_boundVertexArrayObject = arrayObject ? arrayObject : m_defaultVertexArrayObject;
    515     }
     539    void setBoundVertexArrayObject(const WTF::AbstractLocker&, WebGLVertexArrayObjectBase*);
    516540   
    517541    class VertexAttribValue {
    … …  
    9931017    // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
    9941018    // Return false if caller should return without further processing.
    995     bool deleteObject(WebGLObject*);
     1019    bool deleteObject(const WTF::AbstractLocker&, WebGLObject*);
    9961020
    9971021    // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.
    … …  
    10071031    virtual WebGLBuffer* validateBufferDataTarget(const char* functionName, GCGLenum target);
    10081032
    1009     virtual bool validateAndCacheBufferBinding(const char* functionName, GCGLenum target, WebGLBuffer*);
     1033    virtual bool validateAndCacheBufferBinding(const WTF::AbstractLocker&, const char* functionName, GCGLenum target, WebGLBuffer*);
    10101034
    10111035#if !USE(ANGLE)
    … …  
    10361060
    10371061    void setBackDrawBuffer(GCGLenum);
    1038     void setFramebuffer(GCGLenum, WebGLFramebuffer*);
     1062    void setFramebuffer(const WTF::AbstractLocker&, GCGLenum, WebGLFramebuffer*);
    10391063
    10401064    virtual void restoreCurrentFramebuffer();

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

    r254869 r265708  
    3131#include "WebGLContextGroup.h"
    3232#include "WebGLRenderingContextBase.h"
     33#include <wtf/Lock.h>
     34#include <wtf/Locker.h>
    3335
    3436namespace WebCore {
    … …  
    4143WebGLSampler::~WebGLSampler()
    4244{
    43     deleteObject(0);
     45    if (!hasGroupOrContext())
     46        return;
     47
     48    runDestructor();
    4449}
    4550
    … …  
    5055}
    5156
    52 void WebGLSampler::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     57void WebGLSampler::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5358{
    5459    context3d->deleteSampler(object);

  • trunk/Source/WebCore/html/canvas/WebGLSampler.h

    r260415 r265708  
    3030#include "WebGLSharedObject.h"
    3131
     32namespace WTF {
     33class AbstractLocker;
     34}
     35
    3236namespace WebCore {
    3337
    … …  
    3943private:
    4044    explicit WebGLSampler(WebGLRenderingContextBase&);
    41     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
     45    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) final;
    4246};
    4347

  • trunk/Source/WebCore/html/canvas/WebGLSampler.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLSampler {
    2930};

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

    r254214 r265708  
    3232#include "WebGLContextGroup.h"
    3333#include "WebGLRenderingContextBase.h"
     34#include <wtf/Lock.h>
     35#include <wtf/Locker.h>
    3436
    3537namespace WebCore {
    … …  
    5153WebGLShader::~WebGLShader()
    5254{
    53     deleteObject(0);
     55    if (!hasGroupOrContext())
     56        return;
     57
     58    runDestructor();
    5459}
    5560
    56 void WebGLShader::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     61void WebGLShader::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5762{
    5863    context3d->deleteShader(object);

  • trunk/Source/WebCore/html/canvas/WebGLShader.h

    r254214 r265708  
    4949    WebGLShader(WebGLRenderingContextBase&, GCGLenum);
    5050
    51     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
     51    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) final;
    5252
    5353    GCGLenum m_type;

  • trunk/Source/WebCore/html/canvas/WebGLShader.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLShader {
    2930};

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

    r254064 r265708  
    3131#include "WebGLContextGroup.h"
    3232#include "WebGLRenderingContextBase.h"
     33#include <wtf/Lock.h>
    3334
    3435namespace WebCore {
    … …  
    4546}
    4647
    47 void WebGLSharedObject::detachContextGroup()
     48void WebGLSharedObject::detachContextGroup(const AbstractLocker& locker)
    4849{
    4950    detach();
    5051    if (m_contextGroup) {
    51         deleteObject(nullptr);
     52        deleteObject(locker, nullptr);
    5253        m_contextGroup->removeObject(*this);
    5354        m_contextGroup = nullptr;
    5455    }
     56}
     57
     58void WebGLSharedObject::detachContextGroupWithoutDeletingObject()
     59{
     60    // This can be called during context teardown if the sole context
     61    // in the share group has already been removed. In this case, the
     62    // underlying WebGL object has already been implicitly deleted, so
     63    // it's not necessary to call deleteObject on it - which couldn't
     64    // be protected by the objectGraphLock.
     65    detach();
     66    if (m_contextGroup) {
     67        m_contextGroup->removeObject(*this);
     68        m_contextGroup = nullptr;
     69    }
     70}
     71
     72bool WebGLSharedObject::hasGroupOrContext() const
     73{
     74    // Returning true from this implies that there's at least one (or,
     75    // since context sharing isn't currently implemented, exactly one)
     76    // viable context from which to grab the objectGraphLock.
     77    return m_contextGroup && m_contextGroup->hasAContext();
    5578}
    5679
    … …  
    6083}
    6184
     85WTF::Lock& WebGLSharedObject::objectGraphLockForContext()
     86{
     87    // Should not call this if the object or context has been deleted.
     88    ASSERT(m_contextGroup);
     89    return m_contextGroup->objectGraphLockForAContext();
     90}
     91
    6292}
    6393

  • trunk/Source/WebCore/html/canvas/WebGLSharedObject.h

    r254064 r265708  
    3030#include "WebGLObject.h"
    3131
     32namespace WTF {
     33class AbstractLocker;
     34class Lock;
     35}
     36
    3237namespace WebCore {
    3338
    … …  
    5156    }
    5257
    53     void detachContextGroup();
     58    void detachContextGroup(const WTF::AbstractLocker&);
     59
     60    void detachContextGroupWithoutDeletingObject();
     61
     62    WTF::Lock& objectGraphLockForContext() override;
    5463
    5564protected:
    5665    WebGLSharedObject(WebGLRenderingContextBase&);
    5766
    58     bool hasGroupOrContext() const override
    59     {
    60         return m_contextGroup;
    61     }
     67    bool hasGroupOrContext() const override;
    6268
    6369    GraphicsContextGLOpenGL* getAGraphicsContextGL() const override;

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

    r264587 r265708  
    3232#include "WebGLContextGroup.h"
    3333#include "WebGLRenderingContextBase.h"
     34#include <wtf/Lock.h>
     35#include <wtf/Locker.h>
    3436
    3537namespace WebCore {
    … …  
    4244WebGLSync::~WebGLSync()
    4345{
    44     deleteObject(0);
     46    if (!hasGroupOrContext())
     47        return;
     48
     49    runDestructor();
    4550}
    4651
    … …  
    5459}
    5560
    56 void WebGLSync::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     61void WebGLSync::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5762{
    5863    UNUSED_PARAM(object);

  • trunk/Source/WebCore/html/canvas/WebGLSync.h

    r264587 r265708  
    5151    GCGLsync m_sync;
    5252
    53     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     53    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    5454};
    5555

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

    r259139 r265708  
    6363WebGLTexture::~WebGLTexture()
    6464{
    65     deleteObject(0);
     65    if (!hasGroupOrContext())
     66        return;
     67
     68    runDestructor();
    6669}
    6770
    … …  
    9396}
    9497
    95 void WebGLTexture::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     98void WebGLTexture::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    9699{
    97100    context3d->deleteTexture(object);

  • trunk/Source/WebCore/html/canvas/WebGLTexture.h

    r259139 r265708  
    9191    WebGLTexture(WebGLRenderingContextBase&);
    9292
    93     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     93    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    9494
    9595    bool isTexture() const override { return true; }

  • trunk/Source/WebCore/html/canvas/WebGLTexture.idl

    r265523 r265708  
    2525
    2626[
    27     Conditional=WEBGL
     27    Conditional=WEBGL,
     28    GenerateIsReachable=Impl
    2829] interface WebGLTexture {
    2930};

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

    r265523 r265708  
    3131#include "WebGLContextGroup.h"
    3232#include "WebGLRenderingContextBase.h"
     33#include <JavaScriptCore/SlotVisitor.h>
     34#include <JavaScriptCore/SlotVisitorInlines.h>
     35#include <wtf/Lock.h>
     36#include <wtf/Locker.h>
    3337
    3438namespace WebCore {
    … …  
    4145WebGLTransformFeedback::~WebGLTransformFeedback()
    4246{
    43     deleteObject(0);
     47    if (!hasGroupOrContext())
     48        return;
     49
     50    runDestructor();
    4451}
    4552
    … …  
    5158}
    5259
    53 void WebGLTransformFeedback::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     60void WebGLTransformFeedback::deleteObjectImpl(const AbstractLocker&, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5461{
    5562    context3d->deleteTransformFeedback(object);
    5663}
    5764
    58 void WebGLTransformFeedback::setProgram(WebGLProgram& program)
     65void WebGLTransformFeedback::setProgram(const AbstractLocker&, WebGLProgram& program)
    5966{
    6067    m_program = &program;
    … …  
    6269}
    6370
    64 void WebGLTransformFeedback::setBoundIndexedTransformFeedbackBuffer(GCGLuint index, WebGLBuffer* buffer)
     71void WebGLTransformFeedback::setBoundIndexedTransformFeedbackBuffer(const AbstractLocker&, GCGLuint index, WebGLBuffer* buffer)
    6572{
    6673    ASSERT(index < m_boundIndexedTransformFeedbackBuffers.size());
    … …  
    8794}
    8895
    89 void WebGLTransformFeedback::unbindBuffer(WebGLBuffer& buffer)
     96void WebGLTransformFeedback::addMembersToOpaqueRoots(const AbstractLocker& locker, JSC::SlotVisitor& visitor)
     97{
     98    for (auto& buffer : m_boundIndexedTransformFeedbackBuffers)
     99        visitor.addOpaqueRoot(buffer.get());
     100
     101    visitor.addOpaqueRoot(m_program.get());
     102    if (m_program)
     103        m_program->addMembersToOpaqueRoots(locker, visitor);
     104}
     105
     106void WebGLTransformFeedback::unbindBuffer(const AbstractLocker&, WebGLBuffer& buffer)
    90107{
    91108    for (auto& boundBuffer : m_boundIndexedTransformFeedbackBuffers) {

  • trunk/Source/WebCore/html/canvas/WebGLTransformFeedback.h

    r265523 r265708  
    3131#include "WebGLSharedObject.h"
    3232
     33namespace JSC {
     34class SlotVisitor;
     35}
     36
     37namespace WTF {
     38class AbstractLocker;
     39}
     40
    3341namespace WebCore {
    3442
    … …  
    4856    // Returns false if index is out of range and the caller should
    4957    // synthesize a GL error.
    50     void setBoundIndexedTransformFeedbackBuffer(GCGLuint index, WebGLBuffer*);
     58    void setBoundIndexedTransformFeedbackBuffer(const WTF::AbstractLocker&, GCGLuint index, WebGLBuffer*);
    5159    bool getBoundIndexedTransformFeedbackBuffer(GCGLuint index, WebGLBuffer** outBuffer);
    5260   
    … …  
    5765   
    5866    WebGLProgram* program() const { return m_program.get(); }
    59     void setProgram(WebGLProgram&);
     67    void setProgram(const WTF::AbstractLocker&, WebGLProgram&);
    6068   
    61     void unbindBuffer(WebGLBuffer&);
     69    void unbindBuffer(const AbstractLocker&, WebGLBuffer&);
    6270   
    6371    bool hasEnoughBuffers(GCGLuint numRequired) const;
     72
     73    void addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor&);
     74
    6475private:
    6576    WebGLTransformFeedback(WebGL2RenderingContext&);
    6677
    67     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override;
     78    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override;
    6879   
    6980    bool m_active { false };

  • trunk/Source/WebCore/html/canvas/WebGLTransformFeedback.idl

    r265523 r265708  
    2626[
    2727    Conditional=WEBGL2,
    28     EnabledAtRuntime=WebGL2
     28    EnabledAtRuntime=WebGL2,
     29    GenerateIsReachable=Impl
    2930] interface WebGLTransformFeedback {
    3031};

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

    r265205 r265708  
    3131#include "WebGL2RenderingContext.h"
    3232#include "WebGLContextGroup.h"
     33#include <wtf/Lock.h>
     34#include <wtf/Locker.h>
    3335
    3436namespace WebCore {
    … …  
    4143WebGLVertexArrayObject::~WebGLVertexArrayObject()
    4244{
    43     deleteObject(nullptr);
     45    if (!context())
     46        return;
     47
     48    runDestructor();
    4449}
    4550
    … …  
    5459}
    5560
    56 void WebGLVertexArrayObject::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     61void WebGLVertexArrayObject::deleteObjectImpl(const AbstractLocker& locker, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    5762{
    5863    switch (m_type) {
    … …  
    6570   
    6671    if (m_boundElementArrayBuffer)
    67         m_boundElementArrayBuffer->onDetached(context3d);
     72        m_boundElementArrayBuffer->onDetached(locker, context3d);
    6873   
    6974    for (auto& state : m_vertexAttribState) {
    7075        if (state.bufferBinding)
    71             state.bufferBinding->onDetached(context3d);
     76            state.bufferBinding->onDetached(locker, context3d);
    7277    }
    7378}

  • trunk/Source/WebCore/html/canvas/WebGLVertexArrayObject.h

    r254214 r265708  
    3030#include "WebGLVertexArrayObjectBase.h"
    3131
     32namespace WTF {
     33class AbstractLocker;
     34}
     35
    3236namespace WebCore {
    3337
    … …  
    4044private:
    4145    WebGLVertexArrayObject(WebGLRenderingContextBase&, Type);
    42     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
     46    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) final;
    4347};
    4448

  • trunk/Source/WebCore/html/canvas/WebGLVertexArrayObject.idl

    r265523 r265708  
    2626[
    2727    Conditional=WEBGL2,
    28     EnabledAtRuntime=WebGL2
     28    EnabledAtRuntime=WebGL2,
     29    GenerateIsReachable=Impl
    2930] interface WebGLVertexArrayObject {
    3031};

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

    r265523 r265708  
    3030
    3131#include "WebGLRenderingContextBase.h"
     32#include <JavaScriptCore/SlotVisitor.h>
     33#include <JavaScriptCore/SlotVisitorInlines.h>
     34#include <wtf/Locker.h>
    3235
    3336namespace WebCore {
    … …  
    4043}
    4144
    42 void WebGLVertexArrayObjectBase::setElementArrayBuffer(WebGLBuffer* buffer)
     45void WebGLVertexArrayObjectBase::setElementArrayBuffer(const AbstractLocker& locker, WebGLBuffer* buffer)
    4346{
    4447    if (buffer)
    4548        buffer->onAttached();
    4649    if (m_boundElementArrayBuffer)
    47         m_boundElementArrayBuffer->onDetached(context()->graphicsContextGL());
     50        m_boundElementArrayBuffer->onDetached(locker, context()->graphicsContextGL());
    4851    m_boundElementArrayBuffer = buffer;
    4952   
    5053}
    5154
    52 void WebGLVertexArrayObjectBase::setVertexAttribState(GCGLuint index, GCGLsizei bytesPerElement, GCGLint size, GCGLenum type, GCGLboolean normalized, GCGLsizei stride, GCGLintptr offset, WebGLBuffer* buffer)
     55void WebGLVertexArrayObjectBase::setVertexAttribState(const AbstractLocker& locker, GCGLuint index, GCGLsizei bytesPerElement, GCGLint size, GCGLenum type, GCGLboolean normalized, GCGLsizei stride, GCGLintptr offset, WebGLBuffer* buffer)
    5356{
    5457    GCGLsizei validatedStride = stride ? stride : bytesPerElement;
    … …  
    5962        buffer->onAttached();
    6063    if (state.bufferBinding)
    61         state.bufferBinding->onDetached(context()->graphicsContextGL());
     64        state.bufferBinding->onDetached(locker, context()->graphicsContextGL());
    6265   
    6366    state.bufferBinding = buffer;
    … …  
    7174}
    7275
    73 void WebGLVertexArrayObjectBase::unbindBuffer(WebGLBuffer& buffer)
     76void WebGLVertexArrayObjectBase::unbindBuffer(const AbstractLocker& locker, WebGLBuffer& buffer)
    7477{
    7578    if (m_boundElementArrayBuffer == &buffer) {
    76         m_boundElementArrayBuffer->onDetached(context()->graphicsContextGL());
     79        m_boundElementArrayBuffer->onDetached(locker, context()->graphicsContextGL());
    7780        m_boundElementArrayBuffer = nullptr;
    7881    }
    … …  
    8184        auto& state = m_vertexAttribState[i];
    8285        if (state.bufferBinding == &buffer) {
    83             buffer.onDetached(context()->graphicsContextGL());
     86            buffer.onDetached(locker, context()->graphicsContextGL());
    8487           
    8588#if !USE(ANGLE)
    … …  
    105108    m_vertexAttribState[index].divisor = divisor;
    106109}
    107    
     110
     111void WebGLVertexArrayObjectBase::addMembersToOpaqueRoots(const AbstractLocker&, JSC::SlotVisitor& visitor)
     112{
     113    visitor.addOpaqueRoot(m_boundElementArrayBuffer.get());
     114    for (auto& state : m_vertexAttribState)
     115        visitor.addOpaqueRoot(state.bufferBinding.get());
     116}
     117
    108118}
    109119

  • trunk/Source/WebCore/html/canvas/WebGLVertexArrayObjectBase.h

    r265523 r265708  
    3232#include "WebGLContextObject.h"
    3333
     34namespace JSC {
     35class SlotVisitor;
     36}
     37
     38namespace WTF {
     39class AbstractLocker;
     40}
     41
    3442namespace WebCore {
    3543
    … …  
    6169
    6270    WebGLBuffer* getElementArrayBuffer() const { return m_boundElementArrayBuffer.get(); }
    63     void setElementArrayBuffer(WebGLBuffer*);
     71    void setElementArrayBuffer(const WTF::AbstractLocker&, WebGLBuffer*);
    6472
    6573    VertexAttribState& getVertexAttribState(int index) { return m_vertexAttribState[index]; }
    66     void setVertexAttribState(GCGLuint, GCGLsizei, GCGLint, GCGLenum, GCGLboolean, GCGLsizei, GCGLintptr, WebGLBuffer*);
    67     void unbindBuffer(WebGLBuffer&);
     74    void setVertexAttribState(const WTF::AbstractLocker&, GCGLuint, GCGLsizei, GCGLint, GCGLenum, GCGLboolean, GCGLsizei, GCGLintptr, WebGLBuffer*);
     75    void unbindBuffer(const WTF::AbstractLocker&, WebGLBuffer&);
    6876
    6977    void setVertexAttribDivisor(GCGLuint index, GCGLuint divisor);
    7078
     79    void addMembersToOpaqueRoots(const WTF::AbstractLocker&, JSC::SlotVisitor&);
     80
    7181protected:
    7282    WebGLVertexArrayObjectBase(WebGLRenderingContextBase&, Type);
    73     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) override = 0;
     83    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) override = 0;
    7484
    7585    Type m_type;

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

    r254214 r265708  
    5454WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES()
    5555{
    56     deleteObject(nullptr);
     56    if (!context())
     57        return;
     58
     59    runDestructor();
    5760}
    5861
    59 void WebGLVertexArrayObjectOES::deleteObjectImpl(GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
     62void WebGLVertexArrayObjectOES::deleteObjectImpl(const WTF::AbstractLocker& locker, GraphicsContextGLOpenGL* context3d, PlatformGLObject object)
    6063{
    6164    switch (m_type) {
    … …  
    6871
    6972    if (m_boundElementArrayBuffer)
    70         m_boundElementArrayBuffer->onDetached(context3d);
     73        m_boundElementArrayBuffer->onDetached(locker, context3d);
    7174
    7275    for (auto& state : m_vertexAttribState) {
    7376        if (state.bufferBinding)
    74             state.bufferBinding->onDetached(context3d);
     77            state.bufferBinding->onDetached(locker, context3d);
    7578    }
    7679}

  • trunk/Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.h

    r254214 r265708  
    3838private:
    3939    WebGLVertexArrayObjectOES(WebGLRenderingContextBase&, Type);
    40     void deleteObjectImpl(GraphicsContextGLOpenGL*, PlatformGLObject) final;
     40    void deleteObjectImpl(const WTF::AbstractLocker&, GraphicsContextGLOpenGL*, PlatformGLObject) final;
    4141};
    4242

  • trunk/Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.idl

    r265523 r265708  
    2626[
    2727    NoInterfaceObject,
    28     Conditional=WEBGL
     28    Conditional=WEBGL,
     29    GenerateIsReachable=Impl
    2930] interface WebGLVertexArrayObjectOES {
    3031};
Note: See TracChangeset for help on using the changeset viewer.