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 db28358..10d5bc1 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 0a6d3d3..d6165cf 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 b330ff2..9926a50 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 3669545..1634041 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 fb2bbec..bf1f00e 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 a26d706..cea525c 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 997dba5..fc6d408 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 0157ece..849c358 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 d1af518..3683f13 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 110f513..66a1ffa 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 7b629a6..fd9930f 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 44cc36f..841d0f9 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 d3efda4..f68543c 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 0dd3ba0..1505011 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 93b9165..daaf9d4 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 4b47bf5..e169e2e 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 dcb1818..fc6fdbd 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 8f1efd9..5f63cf1 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 59695e4..35068eb 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 1d7a10c..92d1d1c 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 e8e8bf8..9ad58b4 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 6bd1272..d1db951 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 d14c96c..4aa03b8 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 f49a780..75ae42f 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; }