Add WebGLContextGroup as step toward sharing WebGL resources
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2012 19:02:16 +0000 (19:02 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2012 19:02:16 +0000 (19:02 +0000)
https://bugs.webkit.org/show_bug.cgi?id=75906

The WebGL Working Group will soon add the ability to share
WebGL resources among WebGL contexts. This is the necessary
prep work. NO API changes.

Added WebGLSharedObject for objects that are shared vs
WebGLContextObject for objects that are not.

Patch by Gregg Tavares <gman@google.com> on 2012-01-13
Reviewed by Kenneth Russell.

No new tests. No change in behavior.

* GNUmakefile.list.am:
* WebCore.gypi:
* html/canvas/OESVertexArrayObject.cpp:
(WebCore::OESVertexArrayObject::createVertexArrayOES):
(WebCore::OESVertexArrayObject::deleteVertexArrayOES):
(WebCore::OESVertexArrayObject::isVertexArrayOES):
(WebCore::OESVertexArrayObject::bindVertexArrayOES):
* html/canvas/WebGLBuffer.cpp:
(WebCore::WebGLBuffer::WebGLBuffer):
(WebCore::WebGLBuffer::~WebGLBuffer):
(WebCore::WebGLBuffer::deleteObjectImpl):
* html/canvas/WebGLBuffer.h:
* html/canvas/WebGLContextGroup.cpp: Added.
(WebCore::WebGLContextGroup::create):
(WebCore::WebGLContextGroup::WebGLContextGroup):
(WebCore::WebGLContextGroup::~WebGLContextGroup):
(WebCore::WebGLContextGroup::getAGraphicsContext3D):
(WebCore::WebGLContextGroup::addContext):
(WebCore::WebGLContextGroup::removeContext):
(WebCore::WebGLContextGroup::removeObject):
(WebCore::WebGLContextGroup::addObject):
(WebCore::WebGLContextGroup::detachAndRemoveAllObjects):
(WebCore::WebGLContextGroup::loseContextGroup):
* html/canvas/WebGLContextGroup.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
* html/canvas/WebGLContextObject.cpp: Copied from Source/WebCore/html/canvas/WebGLShader.cpp.
(WebCore::WebGLContextObject::WebGLContextObject):
(WebCore::WebGLContextObject::~WebGLContextObject):
(WebCore::WebGLContextObject::detachContext):
(WebCore::WebGLContextObject::getAGraphicsContext3D):
* html/canvas/WebGLContextObject.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
(WebCore::WebGLContextObject::context):
(WebCore::WebGLContextObject::validate):
(WebCore::WebGLContextObject::hasGroupOrContext):
* html/canvas/WebGLFramebuffer.cpp:
(WebCore::WebGLFramebuffer::WebGLFramebuffer):
(WebCore::WebGLFramebuffer::~WebGLFramebuffer):
(WebCore::WebGLFramebuffer::setAttachmentForBoundFramebuffer):
(WebCore::WebGLFramebuffer::getAttachment):
(WebCore::WebGLFramebuffer::removeAttachmentFromBoundFramebuffer):
(WebCore::WebGLFramebuffer::checkStatus):
(WebCore::WebGLFramebuffer::onAccess):
(WebCore::WebGLFramebuffer::deleteObjectImpl):
(WebCore::WebGLFramebuffer::initializeRenderbuffers):
* html/canvas/WebGLFramebuffer.h:
* html/canvas/WebGLObject.cpp:
(WebCore::WebGLObject::WebGLObject):
(WebCore::WebGLObject::~WebGLObject):
(WebCore::WebGLObject::deleteObject):
(WebCore::WebGLObject::detach):
(WebCore::WebGLObject::onDetached):
* html/canvas/WebGLObject.h:
* html/canvas/WebGLProgram.cpp:
(WebCore::WebGLProgram::WebGLProgram):
(WebCore::WebGLProgram::~WebGLProgram):
(WebCore::WebGLProgram::deleteObjectImpl):
(WebCore::WebGLProgram::cacheActiveAttribLocations):
* html/canvas/WebGLProgram.h:
* html/canvas/WebGLRenderbuffer.cpp:
(WebCore::WebGLRenderbuffer::~WebGLRenderbuffer):
(WebCore::WebGLRenderbuffer::WebGLRenderbuffer):
(WebCore::WebGLRenderbuffer::deleteObjectImpl):
* html/canvas/WebGLRenderbuffer.h:
* html/canvas/WebGLRenderingContext.cpp:
(WebCore::WebGLRenderingContext::WebGLRenderingContext):
(WebCore::WebGLRenderingContext::initializeNewContext):
(WebCore::WebGLRenderingContext::~WebGLRenderingContext):
(WebCore::WebGLRenderingContext::clearIfComposited):
(WebCore::WebGLRenderingContext::checkObjectToBeBound):
(WebCore::WebGLRenderingContext::clear):
(WebCore::WebGLRenderingContext::copyTexImage2D):
(WebCore::WebGLRenderingContext::copyTexSubImage2D):
(WebCore::WebGLRenderingContext::createBuffer):
(WebCore::WebGLRenderingContext::createFramebuffer):
(WebCore::WebGLRenderingContext::createTexture):
(WebCore::WebGLRenderingContext::createProgram):
(WebCore::WebGLRenderingContext::createRenderbuffer):
(WebCore::WebGLRenderingContext::createShader):
(WebCore::WebGLRenderingContext::deleteObject):
(WebCore::WebGLRenderingContext::deleteRenderbuffer):
(WebCore::WebGLRenderingContext::deleteTexture):
(WebCore::WebGLRenderingContext::detachShader):
(WebCore::WebGLRenderingContext::validateElementArraySize):
(WebCore::WebGLRenderingContext::validateIndexArrayConservative):
(WebCore::WebGLRenderingContext::validateIndexArrayPrecise):
(WebCore::WebGLRenderingContext::validateWebGLObject):
(WebCore::WebGLRenderingContext::drawArrays):
(WebCore::WebGLRenderingContext::drawElements):
(WebCore::WebGLRenderingContext::framebufferRenderbuffer):
(WebCore::WebGLRenderingContext::framebufferTexture2D):
(WebCore::WebGLRenderingContext::getFramebufferAttachmentParameter):
(WebCore::WebGLRenderingContext::linkProgram):
(WebCore::WebGLRenderingContext::readPixels):
(WebCore::WebGLRenderingContext::useProgram):
(WebCore::WebGLRenderingContext::removeSharedObject):
(WebCore::WebGLRenderingContext::addSharedObject):
(WebCore::WebGLRenderingContext::removeContextObject):
(WebCore::WebGLRenderingContext::addContextObject):
(WebCore::WebGLRenderingContext::detachAndRemoveAllObjects):
(WebCore::WebGLRenderingContext::initVertexAttrib0):
(WebCore::WebGLRenderingContext::loseContext):
(WebCore::WebGLRenderingContext::loseContextImpl):
* html/canvas/WebGLRenderingContext.h:
(WebCore::WebGLRenderingContext::contextGroup):
* html/canvas/WebGLShader.cpp:
(WebCore::WebGLShader::WebGLShader):
(WebCore::WebGLShader::~WebGLShader):
(WebCore::WebGLShader::deleteObjectImpl):
* html/canvas/WebGLShader.h:
* html/canvas/WebGLSharedObject.cpp: Copied from Source/WebCore/html/canvas/WebGLRenderbuffer.cpp.
(WebCore::WebGLSharedObject::WebGLSharedObject):
(WebCore::WebGLSharedObject::~WebGLSharedObject):
(WebCore::WebGLSharedObject::detachContextGroup):
(WebCore::WebGLSharedObject::getAGraphicsContext3D):
* html/canvas/WebGLSharedObject.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
(WebCore::WebGLSharedObject::contextGroup):
(WebCore::WebGLSharedObject::isBuffer):
(WebCore::WebGLSharedObject::isFramebuffer):
(WebCore::WebGLSharedObject::isProgram):
(WebCore::WebGLSharedObject::isRenderbuffer):
(WebCore::WebGLSharedObject::isShader):
(WebCore::WebGLSharedObject::isTexture):
(WebCore::WebGLSharedObject::validate):
(WebCore::WebGLSharedObject::hasGroupOrContext):
* html/canvas/WebGLTexture.cpp:
(WebCore::WebGLTexture::WebGLTexture):
(WebCore::WebGLTexture::~WebGLTexture):
(WebCore::WebGLTexture::deleteObjectImpl):
* html/canvas/WebGLTexture.h:
* html/canvas/WebGLVertexArrayObjectOES.cpp:
(WebCore::WebGLVertexArrayObjectOES::WebGLVertexArrayObjectOES):
(WebCore::WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES):
(WebCore::WebGLVertexArrayObjectOES::deleteObjectImpl):
* html/canvas/WebGLVertexArrayObjectOES.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@104954 268f45cc-cd09-0410-ab3c-d52691b4dbfc

30 files changed:
ChangeLog
Source/WebCore/CMakeLists.txt
Source/WebCore/GNUmakefile.list.am
Source/WebCore/Target.pri
Source/WebCore/WebCore.gypi
Source/WebCore/html/canvas/OESVertexArrayObject.cpp
Source/WebCore/html/canvas/WebGLBuffer.cpp
Source/WebCore/html/canvas/WebGLBuffer.h
Source/WebCore/html/canvas/WebGLContextGroup.cpp [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLContextGroup.h [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLContextObject.cpp [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLContextObject.h [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLFramebuffer.cpp
Source/WebCore/html/canvas/WebGLFramebuffer.h
Source/WebCore/html/canvas/WebGLObject.cpp
Source/WebCore/html/canvas/WebGLObject.h
Source/WebCore/html/canvas/WebGLProgram.cpp
Source/WebCore/html/canvas/WebGLProgram.h
Source/WebCore/html/canvas/WebGLRenderbuffer.cpp
Source/WebCore/html/canvas/WebGLRenderbuffer.h
Source/WebCore/html/canvas/WebGLRenderingContext.cpp
Source/WebCore/html/canvas/WebGLRenderingContext.h
Source/WebCore/html/canvas/WebGLShader.cpp
Source/WebCore/html/canvas/WebGLShader.h
Source/WebCore/html/canvas/WebGLSharedObject.cpp [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLSharedObject.h [new file with mode: 0644]
Source/WebCore/html/canvas/WebGLTexture.cpp
Source/WebCore/html/canvas/WebGLTexture.h
Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.cpp
Source/WebCore/html/canvas/WebGLVertexArrayObjectOES.h

index db283583b9daca575625fb7938aab00c4386b9ee..10d5bc1362be3b811c6b2204d87e830e87732ac3 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,153 @@
+2012-01-13  Gregg Tavares  <gman@google.com>
+
+        Add WebGLContextGroup as step toward sharing WebGL resources
+        https://bugs.webkit.org/show_bug.cgi?id=75906
+
+        The WebGL Working Group will soon add the ability to share
+        WebGL resources among WebGL contexts. This is the necessary
+        prep work. NO API changes.
+
+        Added WebGLSharedObject for objects that are shared vs
+        WebGLContextObject for objects that are not.
+
+        Reviewed by Kenneth Russell.
+
+        No new tests. No change in behavior.
+
+        * GNUmakefile.list.am:
+        * WebCore.gypi:
+        * html/canvas/OESVertexArrayObject.cpp:
+        (WebCore::OESVertexArrayObject::createVertexArrayOES):
+        (WebCore::OESVertexArrayObject::deleteVertexArrayOES):
+        (WebCore::OESVertexArrayObject::isVertexArrayOES):
+        (WebCore::OESVertexArrayObject::bindVertexArrayOES):
+        * html/canvas/WebGLBuffer.cpp:
+        (WebCore::WebGLBuffer::WebGLBuffer):
+        (WebCore::WebGLBuffer::~WebGLBuffer):
+        (WebCore::WebGLBuffer::deleteObjectImpl):
+        * html/canvas/WebGLBuffer.h:
+        * html/canvas/WebGLContextGroup.cpp: Added.
+        (WebCore::WebGLContextGroup::create):
+        (WebCore::WebGLContextGroup::WebGLContextGroup):
+        (WebCore::WebGLContextGroup::~WebGLContextGroup):
+        (WebCore::WebGLContextGroup::getAGraphicsContext3D):
+        (WebCore::WebGLContextGroup::addContext):
+        (WebCore::WebGLContextGroup::removeContext):
+        (WebCore::WebGLContextGroup::removeObject):
+        (WebCore::WebGLContextGroup::addObject):
+        (WebCore::WebGLContextGroup::detachAndRemoveAllObjects):
+        (WebCore::WebGLContextGroup::loseContextGroup):
+        * html/canvas/WebGLContextGroup.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
+        * html/canvas/WebGLContextObject.cpp: Copied from Source/WebCore/html/canvas/WebGLShader.cpp.
+        (WebCore::WebGLContextObject::WebGLContextObject):
+        (WebCore::WebGLContextObject::~WebGLContextObject):
+        (WebCore::WebGLContextObject::detachContext):
+        (WebCore::WebGLContextObject::getAGraphicsContext3D):
+        * html/canvas/WebGLContextObject.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
+        (WebCore::WebGLContextObject::context):
+        (WebCore::WebGLContextObject::validate):
+        (WebCore::WebGLContextObject::hasGroupOrContext):
+        * html/canvas/WebGLFramebuffer.cpp:
+        (WebCore::WebGLFramebuffer::WebGLFramebuffer):
+        (WebCore::WebGLFramebuffer::~WebGLFramebuffer):
+        (WebCore::WebGLFramebuffer::setAttachmentForBoundFramebuffer):
+        (WebCore::WebGLFramebuffer::getAttachment):
+        (WebCore::WebGLFramebuffer::removeAttachmentFromBoundFramebuffer):
+        (WebCore::WebGLFramebuffer::checkStatus):
+        (WebCore::WebGLFramebuffer::onAccess):
+        (WebCore::WebGLFramebuffer::deleteObjectImpl):
+        (WebCore::WebGLFramebuffer::initializeRenderbuffers):
+        * html/canvas/WebGLFramebuffer.h:
+        * html/canvas/WebGLObject.cpp:
+        (WebCore::WebGLObject::WebGLObject):
+        (WebCore::WebGLObject::~WebGLObject):
+        (WebCore::WebGLObject::deleteObject):
+        (WebCore::WebGLObject::detach):
+        (WebCore::WebGLObject::onDetached):
+        * html/canvas/WebGLObject.h:
+        * html/canvas/WebGLProgram.cpp:
+        (WebCore::WebGLProgram::WebGLProgram):
+        (WebCore::WebGLProgram::~WebGLProgram):
+        (WebCore::WebGLProgram::deleteObjectImpl):
+        (WebCore::WebGLProgram::cacheActiveAttribLocations):
+        * html/canvas/WebGLProgram.h:
+        * html/canvas/WebGLRenderbuffer.cpp:
+        (WebCore::WebGLRenderbuffer::~WebGLRenderbuffer):
+        (WebCore::WebGLRenderbuffer::WebGLRenderbuffer):
+        (WebCore::WebGLRenderbuffer::deleteObjectImpl):
+        * html/canvas/WebGLRenderbuffer.h:
+        * html/canvas/WebGLRenderingContext.cpp:
+        (WebCore::WebGLRenderingContext::WebGLRenderingContext):
+        (WebCore::WebGLRenderingContext::initializeNewContext):
+        (WebCore::WebGLRenderingContext::~WebGLRenderingContext):
+        (WebCore::WebGLRenderingContext::clearIfComposited):
+        (WebCore::WebGLRenderingContext::checkObjectToBeBound):
+        (WebCore::WebGLRenderingContext::clear):
+        (WebCore::WebGLRenderingContext::copyTexImage2D):
+        (WebCore::WebGLRenderingContext::copyTexSubImage2D):
+        (WebCore::WebGLRenderingContext::createBuffer):
+        (WebCore::WebGLRenderingContext::createFramebuffer):
+        (WebCore::WebGLRenderingContext::createTexture):
+        (WebCore::WebGLRenderingContext::createProgram):
+        (WebCore::WebGLRenderingContext::createRenderbuffer):
+        (WebCore::WebGLRenderingContext::createShader):
+        (WebCore::WebGLRenderingContext::deleteObject):
+        (WebCore::WebGLRenderingContext::deleteRenderbuffer):
+        (WebCore::WebGLRenderingContext::deleteTexture):
+        (WebCore::WebGLRenderingContext::detachShader):
+        (WebCore::WebGLRenderingContext::validateElementArraySize):
+        (WebCore::WebGLRenderingContext::validateIndexArrayConservative):
+        (WebCore::WebGLRenderingContext::validateIndexArrayPrecise):
+        (WebCore::WebGLRenderingContext::validateWebGLObject):
+        (WebCore::WebGLRenderingContext::drawArrays):
+        (WebCore::WebGLRenderingContext::drawElements):
+        (WebCore::WebGLRenderingContext::framebufferRenderbuffer):
+        (WebCore::WebGLRenderingContext::framebufferTexture2D):
+        (WebCore::WebGLRenderingContext::getFramebufferAttachmentParameter):
+        (WebCore::WebGLRenderingContext::linkProgram):
+        (WebCore::WebGLRenderingContext::readPixels):
+        (WebCore::WebGLRenderingContext::useProgram):
+        (WebCore::WebGLRenderingContext::removeSharedObject):
+        (WebCore::WebGLRenderingContext::addSharedObject):
+        (WebCore::WebGLRenderingContext::removeContextObject):
+        (WebCore::WebGLRenderingContext::addContextObject):
+        (WebCore::WebGLRenderingContext::detachAndRemoveAllObjects):
+        (WebCore::WebGLRenderingContext::initVertexAttrib0):
+        (WebCore::WebGLRenderingContext::loseContext):
+        (WebCore::WebGLRenderingContext::loseContextImpl):
+        * html/canvas/WebGLRenderingContext.h:
+        (WebCore::WebGLRenderingContext::contextGroup):
+        * html/canvas/WebGLShader.cpp:
+        (WebCore::WebGLShader::WebGLShader):
+        (WebCore::WebGLShader::~WebGLShader):
+        (WebCore::WebGLShader::deleteObjectImpl):
+        * html/canvas/WebGLShader.h:
+        * html/canvas/WebGLSharedObject.cpp: Copied from Source/WebCore/html/canvas/WebGLRenderbuffer.cpp.
+        (WebCore::WebGLSharedObject::WebGLSharedObject):
+        (WebCore::WebGLSharedObject::~WebGLSharedObject):
+        (WebCore::WebGLSharedObject::detachContextGroup):
+        (WebCore::WebGLSharedObject::getAGraphicsContext3D):
+        * html/canvas/WebGLSharedObject.h: Copied from Source/WebCore/html/canvas/WebGLShader.h.
+        (WebCore::WebGLSharedObject::contextGroup):
+        (WebCore::WebGLSharedObject::isBuffer):
+        (WebCore::WebGLSharedObject::isFramebuffer):
+        (WebCore::WebGLSharedObject::isProgram):
+        (WebCore::WebGLSharedObject::isRenderbuffer):
+        (WebCore::WebGLSharedObject::isShader):
+        (WebCore::WebGLSharedObject::isTexture):
+        (WebCore::WebGLSharedObject::validate):
+        (WebCore::WebGLSharedObject::hasGroupOrContext):
+        * html/canvas/WebGLTexture.cpp:
+        (WebCore::WebGLTexture::WebGLTexture):
+        (WebCore::WebGLTexture::~WebGLTexture):
+        (WebCore::WebGLTexture::deleteObjectImpl):
+        * html/canvas/WebGLTexture.h:
+        * html/canvas/WebGLVertexArrayObjectOES.cpp:
+        (WebCore::WebGLVertexArrayObjectOES::WebGLVertexArrayObjectOES):
+        (WebCore::WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES):
+        (WebCore::WebGLVertexArrayObjectOES::deleteObjectImpl):
+        * html/canvas/WebGLVertexArrayObjectOES.h:
+
 2012-01-12  Sheriff Bot  <webkit.review.bot@gmail.com>
 
         Unreviewed, rolling out r104805.
index 0a6d3d3beaa3f1e70694d676f938e82eca2bb623..d6165cf1c3ca26cc31b13c13943a80bc19994c3b 100644 (file)
@@ -2171,6 +2171,8 @@ IF (ENABLE_WEBGL)
         html/canvas/WebGLCompressedTextures.cpp
         html/canvas/WebGLContextAttributes.cpp
         html/canvas/WebGLContextEvent.cpp
+        html/canvas/WebGLContextGroup.cpp
+        html/canvas/WebGLContextObject.cpp
         html/canvas/WebGLDebugRendererInfo.cpp
         html/canvas/WebGLDebugShaders.cpp
         html/canvas/WebGLFramebuffer.cpp
@@ -2181,6 +2183,7 @@ IF (ENABLE_WEBGL)
         html/canvas/WebGLRenderbuffer.cpp
         html/canvas/WebGLRenderingContext.cpp
         html/canvas/WebGLShader.cpp
+        html/canvas/WebGLSharedObject.cpp
         html/canvas/WebGLTexture.cpp
         html/canvas/WebGLUniformLocation.cpp
         html/canvas/WebGLVertexArrayObjectOES.cpp
index b330ff22eb244b4fe9a8a656d05d0199dfc765db..9926a5057e81c7dca840a274a737dd3757af083b 100644 (file)
@@ -5569,6 +5569,10 @@ webcore_sources += \
        Source/WebCore/html/canvas/WebGLContextAttributes.h \
        Source/WebCore/html/canvas/WebGLContextEvent.cpp \
        Source/WebCore/html/canvas/WebGLContextEvent.h \
+       Source/WebCore/html/canvas/WebGLContextGroup.cpp \
+       Source/WebCore/html/canvas/WebGLContextGroup.h \
+       Source/WebCore/html/canvas/WebGLContextObject.cpp \
+       Source/WebCore/html/canvas/WebGLContextObject.h \
        Source/WebCore/html/canvas/WebGLDebugRendererInfo.cpp \
        Source/WebCore/html/canvas/WebGLDebugRendererInfo.h \
        Source/WebCore/html/canvas/WebGLDebugShaders.cpp \
@@ -5589,6 +5593,8 @@ webcore_sources += \
        Source/WebCore/html/canvas/WebGLRenderingContext.h \
        Source/WebCore/html/canvas/WebGLShader.cpp \
        Source/WebCore/html/canvas/WebGLShader.h \
+       Source/WebCore/html/canvas/WebGLSharedObject.cpp \
+       Source/WebCore/html/canvas/WebGLSharedObject.h \
        Source/WebCore/html/canvas/WebGLTexture.cpp \
        Source/WebCore/html/canvas/WebGLTexture.h \
        Source/WebCore/html/canvas/WebGLUniformLocation.cpp \
index 366954516df35166f535db8354f830538d2abeaf..163404122a52caada237403df3d4b7b171ad3cb7 100644 (file)
@@ -3674,6 +3674,8 @@ contains(DEFINES, ENABLE_WEBGL=1) {
         html/canvas/WebGLCompressedTextures.h \
         html/canvas/WebGLContextAttributes.h \
         html/canvas/WebGLContextEvent.h \
+        html/canvas/WebGLContextGroup.h \
+        html/canvas/WebGLContextObject.h \
         html/canvas/WebGLDebugRendererInfo.h \
         html/canvas/WebGLDebugShaders.h \
         html/canvas/WebGLExtension.h \
@@ -3684,6 +3686,7 @@ contains(DEFINES, ENABLE_WEBGL=1) {
         html/canvas/WebGLRenderbuffer.h \
         html/canvas/WebGLRenderingContext.h \
         html/canvas/WebGLShader.h \
+        html/canvas/WebGLSharedObject.h \
         html/canvas/OESStandardDerivatives.h \
         html/canvas/OESTextureFloat.h \
         html/canvas/OESVertexArrayObject.h \
@@ -3711,6 +3714,8 @@ contains(DEFINES, ENABLE_WEBGL=1) {
         html/canvas/WebGLCompressedTextures.cpp \
         html/canvas/WebGLContextAttributes.cpp \
         html/canvas/WebGLContextEvent.cpp \
+        html/canvas/WebGLContextGroup.cpp \
+        html/canvas/WebGLContextObject.cpp \
         html/canvas/WebGLDebugRendererInfo.cpp \
         html/canvas/WebGLDebugShaders.cpp \
         html/canvas/WebGLExtension.cpp \
@@ -3721,6 +3726,7 @@ contains(DEFINES, ENABLE_WEBGL=1) {
         html/canvas/WebGLRenderbuffer.cpp \
         html/canvas/WebGLRenderingContext.cpp \
         html/canvas/WebGLShader.cpp \
+        html/canvas/WebGLSharedObject.cpp \
         html/canvas/OESStandardDerivatives.cpp \
         html/canvas/OESTextureFloat.cpp \
         html/canvas/OESVertexArrayObject.cpp \
index fb2bbecb643d433f6c01def4035a53a341ef059c..bf1f00e16248f14c883cde679d67b804fccaafa8 100644 (file)
             'html/canvas/WebGLContextAttributes.h',
             'html/canvas/WebGLContextEvent.cpp',
             'html/canvas/WebGLContextEvent.h',
+            'html/canvas/WebGLContextGroup.cpp',
+            'html/canvas/WebGLContextGroup.h',
+            'html/canvas/WebGLContextObject.cpp',
+            'html/canvas/WebGLContextObject.h',
             'html/canvas/WebGLDebugRendererInfo.cpp',
             'html/canvas/WebGLDebugRendererInfo.h',
             'html/canvas/WebGLDebugShaders.cpp',
             'html/canvas/WebGLRenderingContext.h',
             'html/canvas/WebGLShader.cpp',
             'html/canvas/WebGLShader.h',
+            'html/canvas/WebGLSharedObject.cpp',
+            'html/canvas/WebGLSharedObject.h',
             'html/canvas/WebGLTexture.cpp',
             'html/canvas/WebGLTexture.h',
             'html/canvas/WebGLUniformLocation.cpp',
index a26d7069f6ecd5a8b418b9ace822cad322aa5bf3..cea525c399013d526e4ceb73b9915534e105f259 100644 (file)
@@ -60,7 +60,7 @@ PassRefPtr<WebGLVertexArrayObjectOES> OESVertexArrayObject::createVertexArrayOES
         return 0;
     
     RefPtr<WebGLVertexArrayObjectOES> o = WebGLVertexArrayObjectOES::create(m_context, WebGLVertexArrayObjectOES::VaoTypeUser);
-    m_context->addObject(o.get());
+    m_context->addContextObject(o.get());
     return o.release();
 }
 
@@ -69,7 +69,7 @@ void OESVertexArrayObject::deleteVertexArrayOES(WebGLVertexArrayObjectOES* array
     if (!arrayObject || m_context->isContextLost())
         return;
     
-    arrayObject->deleteObject();
+    arrayObject->deleteObject(m_context->graphicsContext3D());
 }
 
 GC3Dboolean OESVertexArrayObject::isVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
@@ -90,7 +90,7 @@ void OESVertexArrayObject::bindVertexArrayOES(WebGLVertexArrayObjectOES* arrayOb
     if (m_context->isContextLost())
         return;
     
-    if (arrayObject && arrayObject->context() != m_context) {
+    if (arrayObject && !arrayObject->validate(0, context())) {
         m_context->graphicsContext3D()->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
index 997dba500ed50383c643e8e1f09065db0f6b6861..fc6d40860675d6f16a9634c2c616d56aecb51f31 100644 (file)
@@ -30,6 +30,7 @@
 #include "WebGLBuffer.h"
 
 #include "CheckedInt.h"
+#include "WebGLContextGroup.h"
 #include "WebGLRenderingContext.h"
 #include <wtf/ArrayBufferView.h>
 
@@ -41,18 +42,23 @@ PassRefPtr<WebGLBuffer> WebGLBuffer::create(WebGLRenderingContext* ctx)
 }
 
 WebGLBuffer::WebGLBuffer(WebGLRenderingContext* ctx)
-    : WebGLObject(ctx)
+    : WebGLSharedObject(ctx)
     , m_target(0)
     , m_byteLength(0)
     , m_nextAvailableCacheEntry(0)
 {
-    setObject(context()->graphicsContext3D()->createBuffer());
+    setObject(ctx->graphicsContext3D()->createBuffer());
     clearCachedMaxIndices();
 }
 
-void WebGLBuffer::deleteObjectImpl(Platform3DObject object)
+WebGLBuffer::~WebGLBuffer()
 {
-    context()->graphicsContext3D()->deleteBuffer(object);
+    deleteObject(0);
+}
+
+void WebGLBuffer::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
+{
+      context3d->deleteBuffer(object);
 }
 
 bool WebGLBuffer::associateBufferDataImpl(ArrayBuffer* array, GC3Dintptr byteOffset, GC3Dsizeiptr byteLength)
index 0157ece65f0ce4b7c407b7bcb59d796875140c07..849c3582bd79ca8c1505147530fd90e7dcb5e996 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef WebGLBuffer_h
 #define WebGLBuffer_h
 
-#include "WebGLObject.h"
+#include "WebGLSharedObject.h"
 
 #include <wtf/ArrayBuffer.h>
 #include <wtf/Forward.h>
@@ -35,9 +35,9 @@
 
 namespace WebCore {
 
-class WebGLBuffer : public WebGLObject {
+class WebGLBuffer : public WebGLSharedObject {
 public:
-    virtual ~WebGLBuffer() { deleteObject(); }
+    virtual ~WebGLBuffer();
 
     static PassRefPtr<WebGLBuffer> create(WebGLRenderingContext*);
 
@@ -64,7 +64,7 @@ public:
 protected:
     WebGLBuffer(WebGLRenderingContext*);
 
-    virtual void deleteObjectImpl(Platform3DObject o);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
 private:
     virtual bool isBuffer() const { return true; }
diff --git a/Source/WebCore/html/canvas/WebGLContextGroup.cpp b/Source/WebCore/html/canvas/WebGLContextGroup.cpp
new file mode 100644 (file)
index 0000000..d3af2bb
--- /dev/null
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(WEBGL)
+
+#include "WebGLContextGroup.h"
+
+#include "GraphicsContext3D.h"
+#include "WebGLRenderingContext.h"
+#include "WebGLSharedObject.h"
+
+#if PLATFORM(QT)
+#undef emit
+#endif
+
+namespace WebCore {
+
+PassRefPtr<WebGLContextGroup> WebGLContextGroup::create()
+{
+    RefPtr<WebGLContextGroup> contextGroup = adoptRef(new WebGLContextGroup());
+    return contextGroup.release();
+}
+
+WebGLContextGroup::WebGLContextGroup()
+{
+}
+
+WebGLContextGroup::~WebGLContextGroup()
+{
+    detachAndRemoveAllObjects();
+}
+
+GraphicsContext3D* WebGLContextGroup::getAGraphicsContext3D()
+{
+    ASSERT(!m_contexts.isEmpty());
+    HashSet<WebGLRenderingContext*>::iterator it = m_contexts.begin();
+    return (*it)->graphicsContext3D();
+}
+
+void WebGLContextGroup::addContext(WebGLRenderingContext* context)
+{
+    m_contexts.add(context);
+}
+
+void WebGLContextGroup::removeContext(WebGLRenderingContext* context)
+{
+    // We must call detachAndRemoveAllObjects before removing the last context.
+    if (m_contexts.size() == 1 && m_contexts.contains(context))
+        detachAndRemoveAllObjects();
+
+    m_contexts.remove(context);
+}
+
+void WebGLContextGroup::removeObject(WebGLSharedObject* object)
+{
+    m_groupObjects.remove(object);
+}
+
+void WebGLContextGroup::addObject(WebGLSharedObject* object)
+{
+    m_groupObjects.add(object);
+}
+
+void WebGLContextGroup::detachAndRemoveAllObjects()
+{
+    while (!m_groupObjects.isEmpty()) {
+        HashSet<WebGLSharedObject*>::iterator it = m_groupObjects.begin();
+        (*it)->detachContextGroup();
+    }
+}
+
+void WebGLContextGroup::loseContextGroup(WebGLRenderingContext::LostContextMode mode)
+{
+    for (HashSet<WebGLRenderingContext*>::iterator it = m_contexts.begin(); it != m_contexts.end(); ++it)
+        (*it)->loseContextImpl(mode);
+
+    detachAndRemoveAllObjects();
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(WEBGL)
diff --git a/Source/WebCore/html/canvas/WebGLContextGroup.h b/Source/WebCore/html/canvas/WebGLContextGroup.h
new file mode 100644 (file)
index 0000000..aa7036a
--- /dev/null
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebGLContextGroup_h
+#define WebGLContextGroup_h
+
+#include <WebGLRenderingContext.h>
+#include <wtf/HashSet.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
+
+namespace WebCore {
+
+class GraphicsContext3D;
+class WebGLExtension;
+class WebGLSharedObject;
+class WebGLRenderingContext;
+
+typedef int ExceptionCode;
+
+class WebGLContextGroup : public RefCounted<WebGLContextGroup> {
+public:
+    static PassRefPtr<WebGLContextGroup> create();
+    virtual ~WebGLContextGroup();
+
+    void addContext(WebGLRenderingContext*);
+    void removeContext(WebGLRenderingContext*);
+
+    void addObject(WebGLSharedObject*);
+    void removeObject(WebGLSharedObject*);
+
+    GraphicsContext3D* getAGraphicsContext3D();
+
+    void loseContextGroup(WebGLRenderingContext::LostContextMode);
+
+  private:
+    friend class WebGLObject;
+
+    WebGLContextGroup();
+
+    void detachAndRemoveAllObjects();
+
+    HashSet<WebGLRenderingContext*> m_contexts;
+    HashSet<WebGLSharedObject*> m_groupObjects;
+};
+
+} // namespace WebCore
+
+#endif // WebGLContextGroup_h
diff --git a/Source/WebCore/html/canvas/WebGLContextObject.cpp b/Source/WebCore/html/canvas/WebGLContextObject.cpp
new file mode 100644 (file)
index 0000000..9b3ab0b
--- /dev/null
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(WEBGL)
+
+#include "WebGLContextObject.h"
+
+#include "WebGLRenderingContext.h"
+
+namespace WebCore {
+
+WebGLContextObject::WebGLContextObject(WebGLRenderingContext* context)
+    : WebGLObject(context)
+    , m_context(context)
+{
+}
+
+WebGLContextObject::~WebGLContextObject()
+{
+    if (m_context)
+        m_context->removeContextObject(this);
+}
+
+void WebGLContextObject::detachContext()
+{
+    detach();
+    if (m_context) {
+        deleteObject(m_context->graphicsContext3D());
+        m_context->removeContextObject(this);
+        m_context = 0;
+    }
+}
+
+GraphicsContext3D* WebGLContextObject::getAGraphicsContext3D() const
+{
+    return m_context ? m_context->graphicsContext3D() : 0;
+}
+
+}
+
+#endif // ENABLE(WEBGL)
diff --git a/Source/WebCore/html/canvas/WebGLContextObject.h b/Source/WebCore/html/canvas/WebGLContextObject.h
new file mode 100644 (file)
index 0000000..e67f507
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebGLContextObject_h
+#define WebGLContextObject_h
+
+#include "GraphicsContext3D.h"
+#include "WebGLObject.h"
+
+namespace WebCore {
+
+class GraphicsContext3D;
+class WebGLRenderingContext;
+
+// WebGLContextObject the base class for objects that are owned by a specific
+// WebGLRenderingContext.
+class WebGLContextObject : public WebGLObject {
+public:
+    virtual ~WebGLContextObject();
+
+    WebGLRenderingContext* context() const { return m_context; }
+
+    virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContext* context) const
+    {
+        return context == m_context;
+    }
+
+    void detachContext();
+
+protected:
+    WebGLContextObject(WebGLRenderingContext*);
+
+    virtual bool hasGroupOrContext() const
+    {
+        return m_context;
+    }
+
+    virtual GraphicsContext3D* getAGraphicsContext3D() const;
+
+private:
+    Platform3DObject m_object;
+    WebGLRenderingContext* m_context;
+};
+
+} // namespace WebCore
+
+#endif // WebGLContextObject_h
index d1af518c051655f9341d2dfbbac169c631b562bf..3683f139bff6d88e5582d690985b63703dbd872b 100644 (file)
 
 #include "WebGLFramebuffer.h"
 
+#include "WebGLContextGroup.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
 
 namespace {
 
-    bool isAttachmentComplete(WebGLObject* attachedObject, GC3Denum attachment)
+    bool isAttachmentComplete(WebGLSharedObject* attachedObject, GC3Denum attachment)
     {
         ASSERT(attachedObject && attachedObject->object());
         ASSERT(attachedObject->isRenderbuffer());
@@ -62,7 +63,7 @@ namespace {
         return true;
     }
 
-    GC3Dsizei getImageWidth(WebGLObject* attachedObject)
+    GC3Dsizei getImageWidth(WebGLSharedObject* attachedObject)
     {
         ASSERT(attachedObject && attachedObject->object());
         ASSERT(attachedObject->isRenderbuffer());
@@ -70,7 +71,7 @@ namespace {
         return buffer->getWidth();
     }
 
-    GC3Dsizei getImageHeight(WebGLObject* attachedObject)
+    GC3Dsizei getImageHeight(WebGLSharedObject* attachedObject)
     {
         ASSERT(attachedObject && attachedObject->object());
         ASSERT(attachedObject->isRenderbuffer());
@@ -78,7 +79,7 @@ namespace {
         return buffer->getHeight();
     }
 
-    bool isUninitialized(WebGLObject* attachedObject)
+    bool isUninitialized(WebGLSharedObject* attachedObject)
     {
         if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer()
             && !(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->isInitialized())
@@ -86,13 +87,13 @@ namespace {
         return false;
     }
 
-    void setInitialized(WebGLObject* attachedObject)
+    void setInitialized(WebGLSharedObject* attachedObject)
     {
         if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer())
             (reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->setInitialized();
     }
 
-    bool isValid(WebGLObject* attachedObject)
+    bool isValidRenderbuffer(WebGLSharedObject* attachedObject)
     {
         if (attachedObject && attachedObject->object() && attachedObject->isRenderbuffer()) {
             if (!(reinterpret_cast<WebGLRenderbuffer*>(attachedObject))->isValid())
@@ -109,12 +110,17 @@ PassRefPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContext* ctx
 }
 
 WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContext* ctx)
-    : WebGLObject(ctx)
+    : WebGLContextObject(ctx)
     , m_hasEverBeenBound(false)
     , m_texTarget(0)
     , m_texLevel(-1)
 {
-    setObject(context()->graphicsContext3D()->createFramebuffer());
+    setObject(ctx->graphicsContext3D()->createFramebuffer());
+}
+
+WebGLFramebuffer::~WebGLFramebuffer()
+{
+    deleteObject(0);
 }
 
 void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3Denum texTarget, WebGLTexture* texture, GC3Dint level)
@@ -179,7 +185,7 @@ void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GC3Denum attachment, Web
         renderbuffer->onAttached();
 }
 
-WebGLObject* WebGLFramebuffer::getAttachment(GC3Denum attachment) const
+WebGLSharedObject* WebGLFramebuffer::getAttachment(GC3Denum attachment) const
 {
     if (!object())
         return 0;
@@ -203,10 +209,12 @@ void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GC3Denum attachment)
     ASSERT(isBound());
     if (!object())
         return;
+
+    GraphicsContext3D* context3d = context()->graphicsContext3D();
     switch (attachment) {
     case GraphicsContext3D::COLOR_ATTACHMENT0:
         if (m_colorAttachment) {
-            m_colorAttachment->onDetached();
+            m_colorAttachment->onDetached(context3d);
             m_colorAttachment = 0;
             m_texTarget = 0;
             m_texLevel = -1;
@@ -214,19 +222,19 @@ void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GC3Denum attachment)
         break;
     case GraphicsContext3D::DEPTH_ATTACHMENT:
         if (m_depthAttachment) {
-            m_depthAttachment->onDetached();
+            m_depthAttachment->onDetached(context3d);
             m_depthAttachment = 0;
         }
         break;
     case GraphicsContext3D::STENCIL_ATTACHMENT:
         if (m_stencilAttachment) {
-            m_stencilAttachment->onDetached();
+            m_stencilAttachment->onDetached(context3d);
             m_stencilAttachment = 0;
         }
         break;
     case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
         if (m_depthStencilAttachment) {
-            m_depthStencilAttachment->onDetached();
+            m_depthStencilAttachment->onDetached(context3d);
             m_depthStencilAttachment = 0;
         }
         break;
@@ -236,14 +244,16 @@ void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GC3Denum attachment)
     }
 }
 
-void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLObject* attachment)
+void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(WebGLSharedObject* attachment)
 {
     ASSERT(isBound());
     if (!object())
         return;
     if (!attachment)
         return;
+
     GraphicsContext3D* gc3d = context()->graphicsContext3D();
+
     if (attachment == m_colorAttachment.get()) {
         if (attachment->isRenderbuffer())
             gc3d->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::RENDERBUFFER, 0);
@@ -337,7 +347,7 @@ GC3Denum WebGLFramebuffer::checkStatus() const
     if (isDepthStencilAttached()) {
         if (!isAttachmentComplete(m_depthStencilAttachment.get(), GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT))
             return GraphicsContext3D::FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
-        if (!isValid(m_depthStencilAttachment.get()))
+        if (!isValidRenderbuffer(m_depthStencilAttachment.get()))
             return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;
         if (!count) {
             width = getImageWidth(m_depthStencilAttachment.get());
@@ -369,29 +379,29 @@ GC3Denum WebGLFramebuffer::checkStatus() const
     return GraphicsContext3D::FRAMEBUFFER_COMPLETE;
 }
 
-bool WebGLFramebuffer::onAccess(bool needToInitializeRenderbuffers)
+bool WebGLFramebuffer::onAccess(GraphicsContext3D* context3d, bool needToInitializeRenderbuffers)
 {
     if (checkStatus() != GraphicsContext3D::FRAMEBUFFER_COMPLETE)
         return false;
     if (needToInitializeRenderbuffers)
-        return initializeRenderbuffers();
+        return initializeRenderbuffers(context3d);
     return true;
 }
 
-void WebGLFramebuffer::deleteObjectImpl(Platform3DObject object)
+void WebGLFramebuffer::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
 {
     if (m_colorAttachment)
-        m_colorAttachment->onDetached();
+        m_colorAttachment->onDetached(context3d);
     if (m_depthAttachment)
-        m_depthAttachment->onDetached();
+        m_depthAttachment->onDetached(context3d);
     if (m_stencilAttachment)
-        m_stencilAttachment->onDetached();
+        m_stencilAttachment->onDetached(context3d);
     if (m_depthStencilAttachment)
-        m_depthStencilAttachment->onDetached();
-    context()->graphicsContext3D()->deleteFramebuffer(object);
+        m_depthStencilAttachment->onDetached(context3d);
+    context3d->deleteFramebuffer(object);
 }
 
-bool WebGLFramebuffer::initializeRenderbuffers()
+bool WebGLFramebuffer::initializeRenderbuffers(GraphicsContext3D* g3d)
 {
     ASSERT(object());
     bool initColor = false, initDepth = false, initStencil = false;
@@ -418,7 +428,6 @@ bool WebGLFramebuffer::initializeRenderbuffers()
 
     // We only clear un-initialized renderbuffers when they are ready to be
     // read, i.e., when the framebuffer is complete.
-    GraphicsContext3D* g3d = context()->graphicsContext3D();
     if (g3d->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE)
         return false;
 
index 110f51395f9b78441b819d934559603281d0b4fd..66a1ffa49e0e9314b52d2a99d6c4dc017fa41f36 100644 (file)
@@ -26,7 +26,8 @@
 #ifndef WebGLFramebuffer_h
 #define WebGLFramebuffer_h
 
-#include "WebGLObject.h"
+#include "WebGLContextObject.h"
+#include "WebGLSharedObject.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
@@ -36,19 +37,19 @@ namespace WebCore {
 class WebGLRenderbuffer;
 class WebGLTexture;
 
-class WebGLFramebuffer : public WebGLObject {
+class WebGLFramebuffer : public WebGLContextObject {
 public:
-    virtual ~WebGLFramebuffer() { deleteObject(); }
+    virtual ~WebGLFramebuffer();
 
     static PassRefPtr<WebGLFramebuffer> create(WebGLRenderingContext*);
 
     void setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3Denum texTarget, WebGLTexture*, GC3Dint level);
     void setAttachmentForBoundFramebuffer(GC3Denum attachment, WebGLRenderbuffer*);
     // If an object is attached to the currently bound framebuffer, remove it.
-    void removeAttachmentFromBoundFramebuffer(WebGLObject*);
+    void removeAttachmentFromBoundFramebuffer(WebGLSharedObject*);
     // If a given attachment point for the currently bound framebuffer is not null, remove the attached object.
     void removeAttachmentFromBoundFramebuffer(GC3Denum);
-    WebGLObject* getAttachment(GC3Denum) const;
+    WebGLSharedObject* getAttachment(GC3Denum) const;
 
     GC3Denum getColorBufferFormat() const;
     GC3Dsizei getColorBufferWidth() const;
@@ -60,7 +61,7 @@ public:
     // Return false if the framebuffer is incomplete; otherwise initialize
     // the buffers if they haven't been initialized and
     // needToInitializeRenderbuffers is true.
-    bool onAccess(bool needToInitializeRenderbuffers);
+    bool onAccess(GraphicsContext3D*, bool needToInitializeRenderbuffers);
 
     // Software version of glCheckFramebufferStatus(), except that when
     // FRAMEBUFFER_COMPLETE is returned, it is still possible for
@@ -75,13 +76,13 @@ public:
 protected:
     WebGLFramebuffer(WebGLRenderingContext*);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
 private:
     virtual bool isFramebuffer() const { return true; }
 
     // Return false if framebuffer is incomplete.
-    bool initializeRenderbuffers();
+    bool initializeRenderbuffers(GraphicsContext3D*);
 
     // Check if the framebuffer is currently bound.
     bool isBound() const;
@@ -91,10 +92,10 @@ private:
     bool isStencilAttached() const { return (m_stencilAttachment && m_stencilAttachment->object()); }
     bool isDepthStencilAttached() const { return (m_depthStencilAttachment && m_depthStencilAttachment->object()); }
 
-    RefPtr<WebGLObject> m_colorAttachment;
-    RefPtr<WebGLObject> m_depthAttachment;
-    RefPtr<WebGLObject> m_stencilAttachment;
-    RefPtr<WebGLObject> m_depthStencilAttachment;
+    RefPtr<WebGLSharedObject> m_colorAttachment;
+    RefPtr<WebGLSharedObject> m_depthAttachment;
+    RefPtr<WebGLSharedObject> m_stencilAttachment;
+    RefPtr<WebGLSharedObject> m_depthStencilAttachment;
 
     bool m_hasEverBeenBound;
 
index 7b629a69c7436c0909c39673b0b5041a438e21e1..fd9930f3ac046d525c7e2f9eac17a2ed5fda52da 100644 (file)
 
 #include "WebGLObject.h"
 
+#include "OESStandardDerivatives.h"
+#include "OESTextureFloat.h"
+#include "OESVertexArrayObject.h"
+#include "WebGLCompressedTextures.h"
+#include "WebGLContextGroup.h"
+#include "WebGLDebugRendererInfo.h"
+#include "WebGLDebugShaders.h"
+#include "WebGLLoseContext.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
 
 WebGLObject::WebGLObject(WebGLRenderingContext* context)
     : m_object(0)
-    , m_context(context)
     , m_attachmentCount(0)
     , m_deleted(false)
 {
@@ -43,8 +50,6 @@ WebGLObject::WebGLObject(WebGLRenderingContext* context)
 
 WebGLObject::~WebGLObject()
 {
-    if (m_context)
-        m_context->removeObject(this);
 }
 
 void WebGLObject::setObject(Platform3DObject object)
@@ -54,26 +59,38 @@ void WebGLObject::setObject(Platform3DObject object)
     m_object = object;
 }
 
-void WebGLObject::deleteObject()
+void WebGLObject::deleteObject(GraphicsContext3D* context3d)
 {
     m_deleted = true;
-    if (!m_context || !m_object)
+    if (!m_object)
         return;
+
+    if (!hasGroupOrContext())
+        return;
+
     if (!m_attachmentCount) {
-        m_context->graphicsContext3D()->makeContextCurrent();
-        deleteObjectImpl(m_object);
+        if (!context3d)
+            context3d = getAGraphicsContext3D();
+
+        if (context3d)
+            deleteObjectImpl(context3d, m_object);
+
         m_object = 0;
     }
 }
 
-void WebGLObject::detachContext()
+void WebGLObject::detach()
 {
     m_attachmentCount = 0; // Make sure OpenGL resource is deleted.
-    if (m_context) {
-        deleteObject();
-        m_context->removeObject(this);
-        m_context = 0;
     }
+
+
+void WebGLObject::onDetached(GraphicsContext3D* context3d)
+{
+    if (m_attachmentCount)
+        --m_attachmentCount;
+    if (m_deleted)
+        deleteObject(context3d);
 }
 
 }
index 44cc36f6bfe24ac04fe91de68c88104b49d0763a..841d0f9fc8cfbca8826d421b3bb6b46cdf311301 100644 (file)
@@ -33,6 +33,8 @@
 
 namespace WebCore {
 
+class GraphicsContext3D;
+class WebGLContextGroup;
 class WebGLRenderingContext;
 
 class WebGLObject : public RefCounted<WebGLObject> {
@@ -44,33 +46,19 @@ public:
     // deleteObject may not always delete the OpenGL resource.  For programs and
     // shaders, deletion is delayed until they are no longer attached.
     // FIXME: revisit this when resource sharing between contexts are implemented.
-    void deleteObject();
-
-    void detachContext();
-
-    WebGLRenderingContext* context() const { return m_context; }
-
-    virtual bool isBuffer() const { return false; }
-    virtual bool isFramebuffer() const { return false; }
-    virtual bool isProgram() const { return false; }
-    virtual bool isRenderbuffer() const { return false; }
-    virtual bool isShader() const { return false; }
-    virtual bool isTexture() const { return false; }
+    void deleteObject(GraphicsContext3D*);
 
     void onAttached() { ++m_attachmentCount; }
-    void onDetached()
-    {
-        if (m_attachmentCount)
-            --m_attachmentCount;
-        if (m_deleted)
-            deleteObject();
-    }
+    void onDetached(GraphicsContext3D*);
 
     // This indicates whether the client side issue a delete call already, not
     // whether the OpenGL resource is deleted.
     // object()==0 indicates the OpenGL resource is deleted.
     bool isDeleted() { return m_deleted; }
 
+    // True if this object belongs to the group or context.
+    virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContext*) const = 0;
+
 protected:
     WebGLObject(WebGLRenderingContext*);
 
@@ -78,11 +66,16 @@ protected:
     void setObject(Platform3DObject);
 
     // deleteObjectImpl should be only called once to delete the OpenGL resource.
-    virtual void deleteObjectImpl(Platform3DObject) = 0;
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) = 0;
+
+    virtual bool hasGroupOrContext() const = 0;
+
+    virtual void detach();
+
+    virtual GraphicsContext3D* getAGraphicsContext3D() const = 0;
 
 private:
     Platform3DObject m_object;
-    WebGLRenderingContext* m_context;
     unsigned m_attachmentCount;
     bool m_deleted;
 };
index d3efda47dee4636554dbc07789d432d398acc20f..f68543ce4d990db58e157e034ec2705d425567c9 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "WebGLProgram.h"
 
+#include "WebGLContextGroup.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
@@ -39,32 +40,36 @@ PassRefPtr<WebGLProgram> WebGLProgram::create(WebGLRenderingContext* ctx)
 }
 
 WebGLProgram::WebGLProgram(WebGLRenderingContext* ctx)
-    : WebGLObject(ctx)
+    : WebGLSharedObject(ctx)
     , m_linkStatus(false)
     , m_linkCount(0)
 {
-    setObject(context()->graphicsContext3D()->createProgram());
+    setObject(ctx->graphicsContext3D()->createProgram());
 }
 
-void WebGLProgram::deleteObjectImpl(Platform3DObject obj)
+WebGLProgram::~WebGLProgram()
 {
-    context()->graphicsContext3D()->deleteProgram(obj);
+    deleteObject(0);
+}
+
+void WebGLProgram::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject obj)
+{
+    context3d->deleteProgram(obj);
     if (m_vertexShader) {
-        m_vertexShader->onDetached();
+        m_vertexShader->onDetached(context3d);
         m_vertexShader = 0;
     }
     if (m_fragmentShader) {
-        m_fragmentShader->onDetached();
+        m_fragmentShader->onDetached(context3d);
         m_fragmentShader = 0;
     }
 }
 
-bool WebGLProgram::cacheActiveAttribLocations()
+bool WebGLProgram::cacheActiveAttribLocations(GraphicsContext3D* context3d)
 {
     m_activeAttribLocations.clear();
     if (!object())
         return false;
-    GraphicsContext3D* context3d = context()->graphicsContext3D();
 
     // Assume link status has already been cached.
     if (!m_linkStatus)
index 0dd3ba0faafb9d706ac9361d19a5f08931696236..1505011005d4f89cfdd653bdcb855754491190cc 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef WebGLProgram_h
 #define WebGLProgram_h
 
-#include "WebGLObject.h"
+#include "WebGLSharedObject.h"
 
 #include "WebGLShader.h"
 
 
 namespace WebCore {
 
-class WebGLProgram : public WebGLObject {
+class WebGLProgram : public WebGLSharedObject {
 public:
-    virtual ~WebGLProgram() { deleteObject(); }
+    virtual ~WebGLProgram();
 
     static PassRefPtr<WebGLProgram> create(WebGLRenderingContext*);
 
     // cacheActiveAttribLocation() is only called once after linkProgram()
     // succeeds.
-    bool cacheActiveAttribLocations();
+    bool cacheActiveAttribLocations(GraphicsContext3D*);
     unsigned numActiveAttribLocations() const;
     GC3Dint getActiveAttribLocation(GC3Duint index) const;
 
@@ -67,7 +67,7 @@ public:
 protected:
     WebGLProgram(WebGLRenderingContext*);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
 private:
     virtual bool isProgram() const { return true; }
index 93b9165c994749f63dc503a36208c51fbedb6470..daaf9d4ee59b3ca66b1cdcc87ab00a197f017b16 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "WebGLRenderbuffer.h"
 
+#include "WebGLContextGroup.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
@@ -38,8 +39,13 @@ PassRefPtr<WebGLRenderbuffer> WebGLRenderbuffer::create(WebGLRenderingContext* c
     return adoptRef(new WebGLRenderbuffer(ctx));
 }
 
+WebGLRenderbuffer::~WebGLRenderbuffer()
+{
+    deleteObject(0);
+}
+
 WebGLRenderbuffer::WebGLRenderbuffer(WebGLRenderingContext* ctx)
-    : WebGLObject(ctx)
+    : WebGLSharedObject(ctx)
     , m_internalFormat(GraphicsContext3D::RGBA4)
     , m_initialized(false)
     , m_width(0)
@@ -47,12 +53,12 @@ WebGLRenderbuffer::WebGLRenderbuffer(WebGLRenderingContext* ctx)
     , m_isValid(true)
     , m_hasEverBeenBound(false)
 {
-    setObject(context()->graphicsContext3D()->createRenderbuffer());
+    setObject(ctx->graphicsContext3D()->createRenderbuffer());
 }
 
-void WebGLRenderbuffer::deleteObjectImpl(Platform3DObject object)
+void WebGLRenderbuffer::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
 {
-    context()->graphicsContext3D()->deleteRenderbuffer(object);
+    context3d->deleteRenderbuffer(object);
 }
 
 }
index 4b47bf5d32e8468d0f92ea91e5a8d6433ccfcf19..e169e2e8bbfe5f167ecf52803be2ef7d9bf7c875 100644 (file)
 #ifndef WebGLRenderbuffer_h
 #define WebGLRenderbuffer_h
 
-#include "WebGLObject.h"
+#include "WebGLSharedObject.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 
 namespace WebCore {
 
-class WebGLRenderbuffer : public WebGLObject {
+class WebGLRenderbuffer : public WebGLSharedObject {
 public:
-    virtual ~WebGLRenderbuffer() { deleteObject(); }
+    virtual ~WebGLRenderbuffer();
 
     static PassRefPtr<WebGLRenderbuffer> create(WebGLRenderingContext*);
 
@@ -67,7 +67,7 @@ public:
 protected:
     WebGLRenderbuffer(WebGLRenderingContext*);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
 private:
     virtual bool isRenderbuffer() const { return true; }
index dcb18188345baf94a056349763ab35e8d301f800..fc6fdbda5e623d54383e5825957150a97fc1c8b0 100644 (file)
@@ -57,6 +57,7 @@
 #include "WebGLCompressedTextures.h"
 #include "WebGLContextAttributes.h"
 #include "WebGLContextEvent.h"
+#include "WebGLContextGroup.h"
 #include "WebGLDebugRendererInfo.h"
 #include "WebGLDebugShaders.h"
 #include "WebGLFramebuffer.h"
@@ -416,6 +417,8 @@ WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, Pa
     , m_attributes(attributes)
 {
     ASSERT(m_context);
+    m_contextGroup = WebGLContextGroup::create();
+    m_contextGroup->addContext(this);
 
 #if PLATFORM(CHROMIUM)
     // Create the DrawingBuffer and initialize the platform layer.
@@ -480,7 +483,7 @@ void WebGLRenderingContext::initializeNewContext()
     m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
     m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);
-    addObject(m_defaultVertexArrayObject.get());
+    addContextObject(m_defaultVertexArrayObject.get());
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
     
     m_vertexAttribValue.resize(m_maxVertexAttribs);
@@ -525,8 +528,27 @@ bool WebGLRenderingContext::allowPrivilegedExtensions() const
 
 WebGLRenderingContext::~WebGLRenderingContext()
 {
+    // Remove all references to WebGLObjects so if they are the last reference
+    // they will be freed before the last context is removed from the context group.
+    m_boundArrayBuffer = 0;
+    m_defaultVertexArrayObject = 0;
+    m_boundVertexArrayObject = 0;
+    m_vertexAttrib0Buffer = 0;
+    m_currentProgram = 0;
+    m_framebufferBinding = 0;
+    m_renderbufferBinding = 0;
+
+    for (size_t i = 0; i < m_textureUnits.size(); ++i) {
+      m_textureUnits[i].m_texture2DBinding = 0;
+      m_textureUnits[i].m_textureCubeMapBinding = 0;
+    }
+
+    m_blackTexture2D = 0;
+    m_blackTextureCubeMap = 0;
+
     detachAndRemoveAllObjects();
     m_context->setContextLostCallback(nullptr);
+    m_contextGroup->removeContext(this);
 }
 
 void WebGLRenderingContext::markContextChanged()
@@ -798,7 +820,7 @@ bool WebGLRenderingContext::checkObjectToBeBound(WebGLObject* object, bool& dele
     if (isContextLost())
         return false;
     if (object) {
-        if (object->context() != this) {
+        if (!object->validate(contextGroup(), this)) {
             m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
             return false;
         }
@@ -1105,7 +1127,7 @@ void WebGLRenderingContext::clear(GC3Dbitfield mask)
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);
         return;
     }
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -1190,7 +1212,7 @@ void WebGLRenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3De
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);
         return;
     }
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -1236,7 +1258,7 @@ void WebGLRenderingContext::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -1284,7 +1306,7 @@ PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()
     if (isContextLost())
         return 0;
     RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);
-    addObject(o.get());
+    addSharedObject(o.get());
     return o;
 }
 
@@ -1293,7 +1315,7 @@ PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()
     if (isContextLost())
         return 0;
     RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
-    addObject(o.get());
+    addContextObject(o.get());
     return o;
 }
 
@@ -1302,7 +1324,7 @@ PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()
     if (isContextLost())
         return 0;
     RefPtr<WebGLTexture> o = WebGLTexture::create(this);
-    addObject(o.get());
+    addSharedObject(o.get());
     return o;
 }
 
@@ -1311,7 +1333,7 @@ PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()
     if (isContextLost())
         return 0;
     RefPtr<WebGLProgram> o = WebGLProgram::create(this);
-    addObject(o.get());
+    addSharedObject(o.get());
     return o;
 }
 
@@ -1320,7 +1342,7 @@ PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()
     if (isContextLost())
         return 0;
     RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
-    addObject(o.get());
+    addSharedObject(o.get());
     return o;
 }
 
@@ -1335,7 +1357,7 @@ PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(GC3Denum type, Excep
     }
 
     RefPtr<WebGLShader> o = WebGLShader::create(this, type);
-    addObject(o.get());
+    addSharedObject(o.get());
     return o;
 }
 
@@ -1351,12 +1373,14 @@ bool WebGLRenderingContext::deleteObject(WebGLObject* object)
 {
     if (isContextLost() || !object)
         return false;
-    if (object->context() != this) {
+    if (!object->validate(contextGroup(), this)) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return false;
     }
     if (object->object())
-        object->deleteObject();
+        // We need to pass in context here because we want
+        // things in this context unbound.
+        object->deleteObject(graphicsContext3D());
     return true;
 }
 
@@ -1473,7 +1497,7 @@ void WebGLRenderingContext::detachShader(WebGLProgram* program, WebGLShader* sha
         return;
     }
     m_context->detachShader(objectOrZero(program), objectOrZero(shader));
-    shader->onDetached();
+    shader->onDetached(graphicsContext3D());
     cleanupAfterGraphicsCall(false);
 }
 
@@ -1685,7 +1709,7 @@ bool WebGLRenderingContext::validateWebGLObject(WebGLObject* object)
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);
         return false;
     }
-    if (object->context() != this) {
+    if (!object->validate(contextGroup(), this)) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return false;
     }
@@ -1726,7 +1750,7 @@ void WebGLRenderingContext::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei c
         }
     }
 
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -1800,7 +1824,7 @@ void WebGLRenderingContext::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denu
         }
     }
 
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -1877,7 +1901,7 @@ void WebGLRenderingContext::framebufferRenderbuffer(GC3Denum target, GC3Denum at
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);
         return;
     }
-    if (buffer && buffer->context() != this) {
+    if (buffer && !buffer->validate(contextGroup(), this)) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
@@ -1948,7 +1972,7 @@ void WebGLRenderingContext::framebufferTexture2D(GC3Denum target, GC3Denum attac
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);
         return;
     }
-    if (texture && texture->context() != this) {
+    if (texture && !texture->validate(contextGroup(), this)) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
@@ -2164,7 +2188,7 @@ WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum t
         return WebGLGetInfo();
     }
 
-    WebGLObject* object = m_framebufferBinding->getAttachment(attachment);
+    WebGLSharedObject* object = m_framebufferBinding->getAttachment(attachment);
     if (!object) {
         if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)
             return WebGLGetInfo(GraphicsContext3D::NONE);
@@ -2940,7 +2964,7 @@ void WebGLRenderingContext::linkProgram(WebGLProgram* program, ExceptionCode& ec
     m_context->getProgramiv(objectOrZero(program), GraphicsContext3D::LINK_STATUS, &value);
     program->setLinkStatus(static_cast<bool>(value));
     // Need to cache link status before caching active attribute locations.
-    program->cacheActiveAttribLocations();
+    program->cacheActiveAttribLocations(graphicsContext3D());
     cleanupAfterGraphicsCall(false);
 }
 
@@ -3031,7 +3055,7 @@ void WebGLRenderingContext::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(!isResourceSafe())) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe())) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION);
         return;
     }
@@ -3940,7 +3964,7 @@ void WebGLRenderingContext::useProgram(WebGLProgram* program, ExceptionCode& ec)
     }
     if (m_currentProgram != program) {
         if (m_currentProgram)
-            m_currentProgram->onDetached();
+            m_currentProgram->onDetached(graphicsContext3D());
         m_currentProgram = program;
         m_context->useProgram(objectOrZero(program));
         if (program)
@@ -4090,6 +4114,14 @@ void WebGLRenderingContext::forceLostContext(WebGLRenderingContext::LostContextM
         return;
     }
 
+    m_contextGroup->loseContextGroup(mode);
+}
+
+void WebGLRenderingContext::loseContextImpl(WebGLRenderingContext::LostContextMode mode)
+{
+    if (isContextLost())
+        return;
+
     m_contextLost = true;
     m_contextLostMode = mode;
 
@@ -4143,22 +4175,32 @@ PlatformLayer* WebGLRenderingContext::platformLayer() const
 }
 #endif
 
-void WebGLRenderingContext::removeObject(WebGLObject* object)
+void WebGLRenderingContext::removeSharedObject(WebGLSharedObject* object)
+{
+    m_contextGroup->removeObject(object);
+}
+
+void WebGLRenderingContext::addSharedObject(WebGLSharedObject* object)
+{
+    ASSERT(!isContextLost());
+    m_contextGroup->addObject(object);
+}
+
+void WebGLRenderingContext::removeContextObject(WebGLContextObject* object)
 {
-    m_canvasObjects.remove(object);
+    m_contextObjects.remove(object);
 }
 
-void WebGLRenderingContext::addObject(WebGLObject* object)
+void WebGLRenderingContext::addContextObject(WebGLContextObject* object)
 {
     ASSERT(!isContextLost());
-    removeObject(object);
-    m_canvasObjects.add(object);
+    m_contextObjects.add(object);
 }
 
 void WebGLRenderingContext::detachAndRemoveAllObjects()
 {
-    while (m_canvasObjects.size() > 0) {
-        HashSet<WebGLObject*>::iterator it = m_canvasObjects.begin();
+    while (m_contextObjects.size() > 0) {
+        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();
         (*it)->detachContext();
     }
 }
index 8f1efd9b044bfc00ead4aa4409f4a083bb4f8f15..5f63cf1ae6cfda8058abdb6b6171d0fd0cbda664 100644 (file)
@@ -50,6 +50,8 @@ class OESTextureFloat;
 class OESVertexArrayObject;
 class WebGLActiveInfo;
 class WebGLBuffer;
+class WebGLContextGroup;
+class WebGLContextObject;
 class WebGLCompressedTextures;
 class WebGLContextAttributes;
 class WebGLDebugRendererInfo;
@@ -61,6 +63,7 @@ class WebGLObject;
 class WebGLProgram;
 class WebGLRenderbuffer;
 class WebGLShader;
+class WebGLSharedObject;
 class WebGLTexture;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
@@ -292,8 +295,10 @@ public:
     };
     void forceLostContext(LostContextMode);
     void forceRestoreContext();
+    void loseContextImpl(LostContextMode);
 
     GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
+    WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
 #if USE(ACCELERATED_COMPOSITING)
     virtual PlatformLayer* platformLayer() const;
 #endif
@@ -304,7 +309,8 @@ public:
     virtual void paintRenderingResultsToCanvas();
     virtual PassRefPtr<ImageData> paintRenderingResultsToImageData();
 
-    void removeObject(WebGLObject*);
+    void removeSharedObject(WebGLSharedObject*);
+    void removeContextObject(WebGLContextObject*);
     
     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
 
@@ -319,7 +325,8 @@ public:
     void initializeNewContext();
     void setupFlags();
 
-    void addObject(WebGLObject*);
+    void addSharedObject(WebGLSharedObject*);
+    void addContextObject(WebGLContextObject*);
     void detachAndRemoveAllObjects();
 
     void markContextChanged();
@@ -362,6 +369,7 @@ public:
 #endif
 
     RefPtr<GraphicsContext3D> m_context;
+    RefPtr<WebGLContextGroup> m_contextGroup;
 
     // Optional structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
@@ -378,7 +386,7 @@ public:
 
     bool m_needsUpdate;
     bool m_markedCanvasDirty;
-    HashSet<WebGLObject*> m_canvasObjects;
+    HashSet<WebGLContextObject*> m_contextObjects;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
     RefPtr<WebGLBuffer> m_boundArrayBuffer;
index 59695e4c93bf54c9820a5a77eed98362f19420b6..35068ebcdca2ee6657aa6bb11aad8248e259e354 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "WebGLShader.h"
 
+#include "WebGLContextGroup.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
@@ -39,16 +40,21 @@ PassRefPtr<WebGLShader> WebGLShader::create(WebGLRenderingContext* ctx, GC3Denum
 }
 
 WebGLShader::WebGLShader(WebGLRenderingContext* ctx, GC3Denum type)
-    : WebGLObject(ctx)
+    : WebGLSharedObject(ctx)
     , m_type(type)
     , m_source("")
 {
-    setObject(context()->graphicsContext3D()->createShader(type));
+    setObject(ctx->graphicsContext3D()->createShader(type));
 }
 
-void WebGLShader::deleteObjectImpl(Platform3DObject object)
+WebGLShader::~WebGLShader()
 {
-    context()->graphicsContext3D()->deleteShader(object);
+    deleteObject(0);
+}
+
+void WebGLShader::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
+{
+    context3d->deleteShader(object);
 }
 
 }
index 1d7a10c1c4b9d99af0cac7f21ecc4f978f934a48..92d1d1c48a19c1c9d0b60610fefc25bae678b405 100644 (file)
 #ifndef WebGLShader_h
 #define WebGLShader_h
 
-#include "WebGLObject.h"
+#include "WebGLSharedObject.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 
 namespace WebCore {
 
-class WebGLShader : public WebGLObject {
+class WebGLShader : public WebGLSharedObject {
 public:
-    virtual ~WebGLShader() { deleteObject(); }
+    virtual ~WebGLShader();
 
     static PassRefPtr<WebGLShader> create(WebGLRenderingContext*, GC3Denum);
 
@@ -47,7 +47,7 @@ public:
 private:
     WebGLShader(WebGLRenderingContext*, GC3Denum);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
     virtual bool isShader() const { return true; }
 
diff --git a/Source/WebCore/html/canvas/WebGLSharedObject.cpp b/Source/WebCore/html/canvas/WebGLSharedObject.cpp
new file mode 100644 (file)
index 0000000..9f76cae
--- /dev/null
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(WEBGL)
+
+#include "WebGLSharedObject.h"
+
+#include "WebGLContextGroup.h"
+#include "WebGLRenderingContext.h"
+
+namespace WebCore {
+
+WebGLSharedObject::WebGLSharedObject(WebGLRenderingContext* context)
+    : WebGLObject(context),
+      m_contextGroup(context->contextGroup())
+{
+}
+
+WebGLSharedObject::~WebGLSharedObject()
+{
+    if (m_contextGroup)
+        m_contextGroup->removeObject(this);
+}
+
+void WebGLSharedObject::detachContextGroup()
+{
+    detach();
+    if (m_contextGroup) {
+        deleteObject(0);
+        m_contextGroup->removeObject(this);
+        m_contextGroup = 0;
+    }
+}
+
+GraphicsContext3D* WebGLSharedObject::getAGraphicsContext3D() const
+{
+    return m_contextGroup ? m_contextGroup->getAGraphicsContext3D() : 0;
+}
+
+}
+
+#endif // ENABLE(WEBGL)
diff --git a/Source/WebCore/html/canvas/WebGLSharedObject.h b/Source/WebCore/html/canvas/WebGLSharedObject.h
new file mode 100644 (file)
index 0000000..5596613
--- /dev/null
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebGLSharedObject_h
+#define WebGLSharedObject_h
+
+#include "WebGLObject.h"
+
+namespace WebCore {
+
+class GraphicsContext3D;
+class WebGLContextGroup;
+class WebGLRenderingContext;
+
+// WebGLSharedObject the base class for objects that can be shared by multiple
+// WebGLRenderingContexts.
+class WebGLSharedObject : public WebGLObject {
+public:
+    virtual ~WebGLSharedObject();
+
+    WebGLContextGroup* contextGroup() const { return m_contextGroup; }
+
+    virtual bool isBuffer() const { return false; }
+    virtual bool isFramebuffer() const { return false; }
+    virtual bool isProgram() const { return false; }
+    virtual bool isRenderbuffer() const { return false; }
+    virtual bool isShader() const { return false; }
+    virtual bool isTexture() const { return false; }
+
+    virtual bool validate(const WebGLContextGroup* contextGroup, const WebGLRenderingContext*) const
+    {
+        return contextGroup == m_contextGroup;
+    }
+
+    void detachContextGroup();
+
+protected:
+    WebGLSharedObject(WebGLRenderingContext*);
+
+    virtual bool hasGroupOrContext() const
+    {
+        return m_contextGroup;
+    }
+
+    virtual GraphicsContext3D* getAGraphicsContext3D() const;
+
+private:
+    WebGLContextGroup* m_contextGroup;
+};
+
+} // namespace WebCore
+
+#endif // WebGLSharedObject_h
index e8e8bf8245d03400723e72766f203972e43b182f..9ad58b4bc16470ea04f648980b7695126a3bd2b6 100644 (file)
@@ -29,6 +29,7 @@
 
 #include "WebGLTexture.h"
 
+#include "WebGLContextGroup.h"
 #include "WebGLFramebuffer.h"
 #include "WebGLRenderingContext.h"
 
@@ -40,7 +41,7 @@ PassRefPtr<WebGLTexture> WebGLTexture::create(WebGLRenderingContext* ctx)
 }
 
 WebGLTexture::WebGLTexture(WebGLRenderingContext* ctx)
-    : WebGLObject(ctx)
+    : WebGLSharedObject(ctx)
     , m_target(0)
     , m_minFilter(GraphicsContext3D::NEAREST_MIPMAP_LINEAR)
     , m_magFilter(GraphicsContext3D::LINEAR)
@@ -50,7 +51,12 @@ WebGLTexture::WebGLTexture(WebGLRenderingContext* ctx)
     , m_isComplete(false)
     , m_needToUseBlackTexture(false)
 {
-    setObject(context()->graphicsContext3D()->createTexture());
+    setObject(ctx->graphicsContext3D()->createTexture());
+}
+
+WebGLTexture::~WebGLTexture()
+{
+    deleteObject(0);
 }
 
 void WebGLTexture::setTarget(GC3Denum target, GC3Dint maxLevel)
@@ -225,9 +231,9 @@ bool WebGLTexture::needToUseBlackTexture() const
     return m_needToUseBlackTexture;
 }
 
-void WebGLTexture::deleteObjectImpl(Platform3DObject object)
+void WebGLTexture::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
 {
-    context()->graphicsContext3D()->deleteTexture(object);
+    context3d->deleteTexture(object);
 }
 
 int WebGLTexture::mapTargetToIndex(GC3Denum target) const
index 6bd12723cc74afd227a1cbfc3a6ffc14e597d9d8..d1db951ffc20d1978719950350521318d1f60c77 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef WebGLTexture_h
 #define WebGLTexture_h
 
-#include "WebGLObject.h"
+#include "WebGLSharedObject.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
@@ -34,9 +34,9 @@
 
 namespace WebCore {
 
-class WebGLTexture : public WebGLObject {
+class WebGLTexture : public WebGLSharedObject {
 public:
-    virtual ~WebGLTexture() { deleteObject(); }
+    virtual ~WebGLTexture();
 
     static PassRefPtr<WebGLTexture> create(WebGLRenderingContext*);
 
@@ -73,7 +73,7 @@ public:
 protected:
     WebGLTexture(WebGLRenderingContext*);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
 private:
     class LevelInfo {
index d14c96c01f6147ef4e80a9b81ef9bbcb06193750..4aa03b8fea1519b97223704cafbfa7638132af22 100644 (file)
@@ -40,7 +40,7 @@ PassRefPtr<WebGLVertexArrayObjectOES> WebGLVertexArrayObjectOES::create(WebGLRen
 }
 
 WebGLVertexArrayObjectOES::WebGLVertexArrayObjectOES(WebGLRenderingContext* ctx, VaoType type)
-    : WebGLObject(ctx)
+    : WebGLContextObject(ctx)
     , m_type(type)
     , m_hasEverBeenBound(false)
     , m_boundElementArrayBuffer(0)
@@ -57,9 +57,14 @@ WebGLVertexArrayObjectOES::WebGLVertexArrayObjectOES(WebGLRenderingContext* ctx,
     }
 }
 
-void WebGLVertexArrayObjectOES::deleteObjectImpl(Platform3DObject object)
+WebGLVertexArrayObjectOES::~WebGLVertexArrayObjectOES()
 {
-    Extensions3D* extensions = context()->graphicsContext3D()->getExtensions();
+    deleteObject(0);
+}
+
+void WebGLVertexArrayObjectOES::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObject object)
+{
+    Extensions3D* extensions = context3d->getExtensions();
     switch (m_type) {
     case VaoTypeDefault:
         break;
index f49a78069308349b1650eb4bedd8247682b82012..75ae42ff725acd1dfedbce6a0bc92d3c4028f435 100644 (file)
 #define WebGLVertexArrayObjectOES_h
 
 #include "WebGLBuffer.h"
-#include "WebGLObject.h"
+#include "WebGLContextObject.h"
 
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 
 namespace WebCore {
 
-class WebGLVertexArrayObjectOES : public WebGLObject {
+class WebGLVertexArrayObjectOES : public WebGLContextObject {
 public:
     enum VaoType {
         VaoTypeDefault,
         VaoTypeUser,
     };
     
-    virtual ~WebGLVertexArrayObjectOES() { deleteObject(); }
+    virtual ~WebGLVertexArrayObjectOES();
 
     static PassRefPtr<WebGLVertexArrayObjectOES> create(WebGLRenderingContext*, VaoType);
     
@@ -83,7 +83,7 @@ public:
 private:
     WebGLVertexArrayObjectOES(WebGLRenderingContext*, VaoType);
 
-    virtual void deleteObjectImpl(Platform3DObject);
+    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject);
 
     virtual bool isVertexArray() const { return true; }