Oilpan: move 2D Canvas and WebGL objects to the heap.

Source/core/html/canvas/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 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
@@ skipping 49 matching lines @@
 #include "core/html/canvas/WebGLDebugRendererInfo.h"
 #include "core/html/canvas/WebGLDebugShaders.h"
 #include "core/html/canvas/WebGLDepthTexture.h"
 #include "core/html/canvas/WebGLDrawBuffers.h"
 #include "core/html/canvas/WebGLFramebuffer.h"
 #include "core/html/canvas/WebGLLoseContext.h"
 #include "core/html/canvas/WebGLProgram.h"
 #include "core/html/canvas/WebGLRenderbuffer.h"
 #include "core/html/canvas/WebGLShader.h"
 #include "core/html/canvas/WebGLShaderPrecisionFormat.h"
+#include "core/html/canvas/WebGLSharedWebGraphicsContext3D.h"
 #include "core/html/canvas/WebGLTexture.h"
 #include "core/html/canvas/WebGLUniformLocation.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/rendering/RenderBox.h"
 #include "platform/CheckedInt.h"
 #include "platform/NotImplemented.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "public/platform/Platform.h"
 
 #include "wtf/PassOwnPtr.h"
 #include "wtf/Uint32Array.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
 const double secondsBetweenRestoreAttempts = 1.0;
 const int maxGLErrorsAllowedToConsole = 256;
 const unsigned maxGLActiveContexts = 16;
 
+// FIXME: Oilpan: static vectors to heap allocated WebGLRenderingContextBase objects
+// are kept here. This relies on the WebGLRenderingContextBase finalization to
+// explicitly retire themselves from these vectors, but it'd be preferable if
+// the references were traced as per usual.
 Vector<WebGLRenderingContextBase*>& WebGLRenderingContextBase::activeContexts()
 {
     DEFINE_STATIC_LOCAL(Vector<WebGLRenderingContextBase*>, activeContexts, ());
     return activeContexts;
 }
 
 Vector<WebGLRenderingContextBase*>& WebGLRenderingContextBase::forciblyEvictedContexts()
 {
     DEFINE_STATIC_LOCAL(Vector<WebGLRenderingContextBase*>, forciblyEvictedContexts, ());
     return forciblyEvictedContexts;
@@ skipping 112 matching lines @@
         WebGLRenderingContextBase::forciblyLoseOldestContext(reason);
     };
     IntSize oldestContextSize() {
         return WebGLRenderingContextBase::oldestContextSize();
     };
 };
 
 namespace {
 
     class ScopedDrawingBufferBinder {
+        STACK_ALLOCATED();
     public:
         ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)
             : m_drawingBuffer(drawingBuffer)
             , m_framebufferBinding(framebufferBinding)
         {
             // Commit DrawingBuffer if needed (e.g., for multisampling)
             if (!m_framebufferBinding && m_drawingBuffer)
                 m_drawingBuffer->commit();
         }
 
         ~ScopedDrawingBufferBinder()
         {
             // Restore DrawingBuffer if needed
             if (!m_framebufferBinding && m_drawingBuffer)
                 m_drawingBuffer->bind();
         }
 
     private:
         DrawingBuffer* m_drawingBuffer;
-        WebGLFramebuffer* m_framebufferBinding;
+        RawPtrWillBeMember<WebGLFramebuffer> m_framebufferBinding;
     };
 
     Platform3DObject objectOrZero(WebGLObject* object)
     {
         return object ? object->object() : 0;
     }
 
     GLint clamp(GLint value, GLint min, GLint max)
     {
         if (value < min)
@@ skipping 204 matching lines @@
 
             // Swallow all other characters. Unclear whether we may
             // want or need to just emit a space per character to try
             // to preserve column numbers for debugging purposes.
             break;
         }
     }
 } // namespace anonymous
 
 class ScopedTexture2DRestorer {
+    STACK_ALLOCATED();
 public:
-    ScopedTexture2DRestorer(WebGLRenderingContextBase* context)
+    explicit ScopedTexture2DRestorer(WebGLRenderingContextBase* context)
         : m_context(context)
     {
     }
 
     ~ScopedTexture2DRestorer()
     {
         m_context->restoreCurrentTexture2D();
     }
 
 private:
-    WebGLRenderingContextBase* m_context;
+    RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextLostCallback : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
-    WTF_MAKE_FAST_ALLOCATED;
+class WebGLRenderingContextLostCallback FINAL : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
-    explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* cb) : m_context(cb) { }
+    static PassOwnPtrWillBeRawPtr<WebGLRenderingContextLostCallback> create(WebGLRenderingContextBase* context)
+    {
+        return adoptPtrWillBeNoop(new WebGLRenderingContextLostCallback(context));
+    }
+
+    virtual ~WebGLRenderingContextLostCallback() { }
+
     virtual void onContextLost() { m_context->forceLostContext(WebGLRenderingContextBase::RealLostContext); }
-    virtual ~WebGLRenderingContextLostCallback() {}
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_context);
+    }
+
 private:
-    WebGLRenderingContextBase* m_context;
+    explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* context)
+        : m_context(context) { }
+
+    RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextErrorMessageCallback : public blink::WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
-    WTF_MAKE_FAST_ALLOCATED;
+class WebGLRenderingContextErrorMessageCallback FINAL : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public blink::WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
-    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* cb) : m_context(cb) { }
+    static PassOwnPtrWillBeRawPtr<WebGLRenderingContextErrorMessageCallback> create(WebGLRenderingContextBase* context)
+    {
+        return adoptPtrWillBeNoop(new WebGLRenderingContextErrorMessageCallback(context));
+    }
+
+    virtual ~WebGLRenderingContextErrorMessageCallback() { }
+
     virtual void onErrorMessage(const blink::WebString& message, blink::WGC3Dint)
     {
         if (m_context->m_synthesizedErrorsToConsole)
             m_context->printGLErrorToConsole(message);
         InspectorInstrumentation::didFireWebGLErrorOrWarning(m_context->canvas(), message);
     }
-    virtual ~WebGLRenderingContextErrorMessageCallback() { }
+
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_context);
+    }
+
 private:
-    WebGLRenderingContextBase* m_context;
+    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* context)
+        : m_context(context) { }
+
+    RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<blink::WebGraphicsContext3D> context, WebGLContextAttributes* requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
     , ActiveDOMObject(&passedCanvas->document())
     , m_drawingBuffer(nullptr)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
     , m_generatedImageCache(4)
@@ skipping 13 matching lines @@
     m_contextGroup = WebGLContextGroup::create();
     m_contextGroup->addContext(this);
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
     context->getIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
     m_drawingBuffer = createDrawingBuffer(context);
     if (!m_drawingBuffer)
         return;
 
+#if ENABLE(OILPAN)
+    m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(m_drawingBuffer);
+#endif
+
     m_drawingBuffer->bind();
     setupFlags();
     initializeNewContext();
 }
 
 PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(PassOwnPtr<blink::WebGraphicsContext3D> context)
 {
     RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
 
     blink::WebGraphicsContext3D::Attributes attrs;
@@ skipping 66 matching lines @@
     addContextObject(m_defaultVertexArrayObject.get());
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribValue.resize(m_maxVertexAttribs);
 
     createFallbackBlackTextures1x1();
 
     webContext()->viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
     webContext()->scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
 
-    m_contextLostCallbackAdapter = adoptPtr(new WebGLRenderingContextLostCallback(this));
-    m_errorMessageCallbackAdapter = adoptPtr(new WebGLRenderingContextErrorMessageCallback(this));
+    m_contextLostCallbackAdapter = WebGLRenderingContextLostCallback::create(this);
+    m_errorMessageCallbackAdapter = WebGLRenderingContextErrorMessageCallback::create(this);
 
     webContext()->setContextLostCallback(m_contextLostCallbackAdapter.get());
     webContext()->setErrorMessageCallback(m_errorMessageCallbackAdapter.get());
 
     // This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
     webContext()->flush();
 
     for (int i = 0; i < WebGLExtensionNameCount; ++i)
         m_extensionEnabled[i] = false;
 
@@ skipping 31 matching lines @@
 // Helper function for V8 bindings to identify what version of WebGL a CanvasRenderingContext supports.
 unsigned WebGLRenderingContextBase::getWebGLVersion(const CanvasRenderingContext* context)
 {
     if (!context->is3d())
         return 0;
     return static_cast<const WebGLRenderingContextBase*>(context)->version();
 }
 
 WebGLRenderingContextBase::~WebGLRenderingContextBase()
 {
+#if !ENABLE(OILPAN)
     // 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 = nullptr;
     m_defaultVertexArrayObject = nullptr;
     m_boundVertexArrayObject = nullptr;
     m_vertexAttrib0Buffer = nullptr;
     m_currentProgram = nullptr;
     m_framebufferBinding = nullptr;
     m_renderbufferBinding = nullptr;
 
     for (size_t i = 0; i < m_textureUnits.size(); ++i) {
-      m_textureUnits[i].m_texture2DBinding = nullptr;
-      m_textureUnits[i].m_textureCubeMapBinding = nullptr;
+        m_textureUnits[i].m_texture2DBinding = nullptr;
+        m_textureUnits[i].m_textureCubeMapBinding = nullptr;
     }
 
     m_blackTexture2D = nullptr;
     m_blackTextureCubeMap = nullptr;
 
     detachAndRemoveAllObjects();
 
-    // release all extensions
-    for (size_t i = 0; i < m_extensions.size(); ++i)
-        delete m_extensions[i];
+    // Release all extensions now.
+    m_extensions.clear();
+#endif
 
     // Context must be removed from the group prior to the destruction of the
     // WebGraphicsContext3D, otherwise shared objects may not be properly deleted.
     m_contextGroup->removeContext(this);
 
     destroyContext();
 
 #if !ENABLE(OILPAN)
-    if (m_multisamplingObserverRegistered) {
-        Page* page = canvas()->document().page();
-        if (page)
+    if (m_multisamplingObserverRegistered)
+        if (Page* page = canvas()->document().page())
             page->removeMultisamplingChangedObserver(this);
-    }
 #endif
 
     willDestroyContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     m_contextLost = true;
 
     if (!m_drawingBuffer)
         return;
 
     m_extensionsUtil.clear();
 
     webContext()->setContextLostCallback(0);
     webContext()->setErrorMessageCallback(0);
 
     ASSERT(m_drawingBuffer);
+#if ENABLE(OILPAN)
+    // The DrawingBuffer ref pointers are cleared, but the
+    // WebGLSharedWebGraphicsContext3D object will hold onto the
+    // DrawingBuffer for as long as needed (== until all
+    // context objects have been finalized), at which point
+    // DrawingBuffer destruction happens.
+    m_drawingBuffer.clear();
+    m_sharedWebGraphicsContext3D.clear();

[haraken, 2014/07/15 15:04:56]

Just to confirm: This can drop the last ref to the DrawingBuffer. There is no
problem to call DrawingBuffer's destructor in WebGLRenderingContextBase's
destructor, right?

[sof, 2014/07/15 16:23:00]

None; this is where it happens non-Oilpan (right below.)

+#else
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
+#endif
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
     m_drawingBuffer->markContentsChanged();
 
     m_layerCleared = false;
@@ skipping 12 matching lines @@
 
 bool WebGLRenderingContextBase::clearIfComposited(GLbitfield mask)
 {
     if (isContextLost())
         return false;
 
     if (!m_drawingBuffer->layerComposited() || m_layerCleared
         || m_requestedAttributes->preserveDrawingBuffer() || (mask && m_framebufferBinding))
         return false;
 
-    RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();
+    RefPtrWillBeRawPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();
 
     // Determine if it's possible to combine the clear the user asked for and this clear.
     bool combinedClear = mask && !m_scissorEnabled;
 
     webContext()->disable(GL_SCISSOR_TEST);
     if (combinedClear && (mask & GL_COLOR_BUFFER_BIT)) {
         webContext()->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,
             m_colorMask[1] ? m_clearColor[1] : 0,
             m_colorMask[2] ? m_clearColor[2] : 0,
             m_colorMask[3] ? m_clearColor[3] : 0);
@@ skipping 706 matching lines @@
     const char* reason = "framebuffer incomplete";
     if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);
         return;
     }
     clearIfComposited();
     ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());
     webContext()->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
-PassRefPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()
+PassRefPtrWillBeRawPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);
+    RefPtrWillBeRawPtr<WebGLBuffer> o = WebGLBuffer::create(this);
     addSharedObject(o.get());
-    return o;
+    return o.release();
 }
 
-PassRefPtr<WebGLFramebuffer> WebGLRenderingContextBase::createFramebuffer()
+PassRefPtrWillBeRawPtr<WebGLFramebuffer> WebGLRenderingContextBase::createFramebuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
+    RefPtrWillBeRawPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
     addContextObject(o.get());
-    return o;
+    return o.release();
 }
 
-PassRefPtr<WebGLTexture> WebGLRenderingContextBase::createTexture()
+PassRefPtrWillBeRawPtr<WebGLTexture> WebGLRenderingContextBase::createTexture()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLTexture> o = WebGLTexture::create(this);
+    RefPtrWillBeRawPtr<WebGLTexture> o = WebGLTexture::create(this);
     addSharedObject(o.get());
-    return o;
+    return o.release();
 }
 
-PassRefPtr<WebGLProgram> WebGLRenderingContextBase::createProgram()
+PassRefPtrWillBeRawPtr<WebGLProgram> WebGLRenderingContextBase::createProgram()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLProgram> o = WebGLProgram::create(this);
+    RefPtrWillBeRawPtr<WebGLProgram> o = WebGLProgram::create(this);
     addSharedObject(o.get());
-    return o;
+    return o.release();
 }
 
-PassRefPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()
+PassRefPtrWillBeRawPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
+    RefPtrWillBeRawPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
     addSharedObject(o.get());
-    return o;
+    return o.release();
 }
 
 WebGLRenderbuffer* WebGLRenderingContextBase::ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer* renderbuffer)
 {
     if (isContextLost())
         return 0;
     if (!renderbuffer->emulatedStencilBuffer()) {
         renderbuffer->setEmulatedStencilBuffer(createRenderbuffer());
         webContext()->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
         webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
     }
     return renderbuffer->emulatedStencilBuffer();
 }
 
-PassRefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GLenum type)
+PassRefPtrWillBeRawPtr<WebGLShader> WebGLRenderingContextBase::createShader(GLenum type)
 {
     if (isContextLost())
         return nullptr;
     if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
         synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
         return nullptr;
     }
 
-    RefPtr<WebGLShader> o = WebGLShader::create(this, type);
+    RefPtrWillBeRawPtr<WebGLShader> o = WebGLShader::create(this, type);
     addSharedObject(o.get());
-    return o;
+    return o.release();
 }
 
 void WebGLRenderingContextBase::cullFace(GLenum mode)
 {
     if (isContextLost())
         return;
     switch (mode) {
     case GL_FRONT_AND_BACK:
     case GL_FRONT:
     case GL_BACK:
@@ skipping 425 matching lines @@
     }
 #endif
     webContext()->generateMipmap(target);
 #if OS(MACOSX)
     if (needToResetMinFilter)
         webContext()->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
 #endif
     tex->generateMipmapLevelInfo();
 }
 
-PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
+PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveAttrib(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
+PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveUniform(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-Nullable<Vector<RefPtr<WebGLShader> > > WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
+Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader> > > WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
-        return Nullable<Vector<RefPtr<WebGLShader> > >();
+        return Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader> > >();
 
-    Vector<RefPtr<WebGLShader> > shaderObjects;
+    WillBeHeapVector<RefPtrWillBeMember<WebGLShader> > shaderObjects;
     const GLenum shaderType[] = {
         GL_VERTEX_SHADER,
         GL_FRAGMENT_SHADER
     };
     for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GLenum); ++i) {
         WebGLShader* shader = program->getAttachedShader(shaderType[i]);
         if (shader)
             shaderObjects.append(shader);
     }
     return shaderObjects;
@@ skipping 30 matching lines @@
         return WebGLGetInfo();
     }
 
     GLint value = 0;
     webContext()->getBufferParameteriv(target, pname, &value);
     if (pname == GL_BUFFER_SIZE)
         return WebGLGetInfo(value);
     return WebGLGetInfo(static_cast<unsigned>(value));
 }
 
-PassRefPtr<WebGLContextAttributes> WebGLRenderingContextBase::getContextAttributes()
+PassRefPtrWillBeRawPtr<WebGLContextAttributes> WebGLRenderingContextBase::getContextAttributes()
 {
     if (isContextLost())
         return nullptr;
     // We always need to return a new WebGLContextAttributes object to
     // prevent the user from mutating any cached version.
     blink::WebGraphicsContext3D::Attributes attrs = m_drawingBuffer->getActualAttributes();
-    RefPtr<WebGLContextAttributes> attributes = m_requestedAttributes->clone();
+    RefPtrWillBeRawPtr<WebGLContextAttributes> attributes = m_requestedAttributes->clone();
     // Some requested attributes may not be honored, so we need to query the underlying
     // context/drawing buffer and adjust accordingly.
     if (m_requestedAttributes->depth() && !attrs.depth)
         attributes->setDepth(false);
     if (m_requestedAttributes->stencil() && !attrs.stencil)
         attributes->setStencil(false);
     attributes->setAntialias(m_drawingBuffer->multisample());
     return attributes.release();
 }
 
@@ skipping 32 matching lines @@
 bool WebGLRenderingContextBase::extensionSupportedAndAllowed(const ExtensionTracker* tracker)
 {
     if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
         return false;
     if (!tracker->supported(this))
         return false;
     return true;
 }
 
 
-PassRefPtr<WebGLExtension> WebGLRenderingContextBase::getExtension(const String& name)
+PassRefPtrWillBeRawPtr<WebGLExtension> WebGLRenderingContextBase::getExtension(const String& name)
 {
     if (isContextLost())
         return nullptr;
 
     for (size_t i = 0; i < m_extensions.size(); ++i) {
-        ExtensionTracker* tracker = m_extensions[i];
+        ExtensionTracker* tracker = m_extensions[i].get();
         if (tracker->matchesNameWithPrefixes(name)) {
             if (!extensionSupportedAndAllowed(tracker))
                 return nullptr;
 
-            RefPtr<WebGLExtension> extension = tracker->getExtension(this);
+            RefPtrWillBeRawPtr<WebGLExtension> extension = tracker->getExtension(this);
             if (extension)
                 m_extensionEnabled[extension->name()] = true;
             return extension.release();
         }
     }
 
     return nullptr;
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname)
@@ skipping 15 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 
     ASSERT(object->isTexture() || object->isRenderbuffer());
     if (object->isTexture()) {
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             return WebGLGetInfo(GL_TEXTURE);
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-            return WebGLGetInfo(PassRefPtr<WebGLTexture>(static_cast<WebGLTexture*>(object)));
+            return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLTexture>(static_cast<WebGLTexture*>(object)));
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
             {
                 GLint value = 0;
                 webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
                 return WebGLGetInfo(value);
             }
         default:
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");
             return WebGLGetInfo();
         }
     } else {
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             return WebGLGetInfo(GL_RENDERBUFFER);
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-            return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(static_cast<WebGLRenderbuffer*>(object)));
+            return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLRenderbuffer>(static_cast<WebGLRenderbuffer*>(object)));
         default:
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
             return WebGLGetInfo();
         }
     }
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getParameter(GLenum pname)
 {
     if (isContextLost())
         return WebGLGetInfo();
     const int intZero = 0;
     switch (pname) {
     case GL_ACTIVE_TEXTURE:
         return getUnsignedIntParameter(pname);
     case GL_ALIASED_LINE_WIDTH_RANGE:
         return getWebGLFloatArrayParameter(pname);
     case GL_ALIASED_POINT_SIZE_RANGE:
         return getWebGLFloatArrayParameter(pname);
     case GL_ALPHA_BITS:
         return getIntParameter(pname);
     case GL_ARRAY_BUFFER_BINDING:
-        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLBuffer>(m_boundArrayBuffer.get()));
     case GL_BLEND:
         return getBooleanParameter(pname);
     case GL_BLEND_COLOR:
         return getWebGLFloatArrayParameter(pname);
     case GL_BLEND_DST_ALPHA:
         return getUnsignedIntParameter(pname);
     case GL_BLEND_DST_RGB:
         return getUnsignedIntParameter(pname);
     case GL_BLEND_EQUATION_ALPHA:
         return getUnsignedIntParameter(pname);
     case GL_BLEND_EQUATION_RGB:
         return getUnsignedIntParameter(pname);
     case GL_BLEND_SRC_ALPHA:
         return getUnsignedIntParameter(pname);
     case GL_BLEND_SRC_RGB:
         return getUnsignedIntParameter(pname);
     case GL_BLUE_BITS:
         return getIntParameter(pname);
     case GL_COLOR_CLEAR_VALUE:
         return getWebGLFloatArrayParameter(pname);
     case GL_COLOR_WRITEMASK:
         return getBooleanArrayParameter(pname);
     case GL_COMPRESSED_TEXTURE_FORMATS:
         return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));
     case GL_CULL_FACE:
         return getBooleanParameter(pname);
     case GL_CULL_FACE_MODE:
         return getUnsignedIntParameter(pname);
     case GL_CURRENT_PROGRAM:
-        return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLProgram>(m_currentProgram.get()));
     case GL_DEPTH_BITS:
         if (!m_framebufferBinding && !m_requestedAttributes->depth())
             return WebGLGetInfo(intZero);
         return getIntParameter(pname);
     case GL_DEPTH_CLEAR_VALUE:
         return getFloatParameter(pname);
     case GL_DEPTH_FUNC:
         return getUnsignedIntParameter(pname);
     case GL_DEPTH_RANGE:
         return getWebGLFloatArrayParameter(pname);
     case GL_DEPTH_TEST:
         return getBooleanParameter(pname);
     case GL_DEPTH_WRITEMASK:
         return getBooleanParameter(pname);
     case GL_DITHER:
         return getBooleanParameter(pname);
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->boundElementArrayBuffer()));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLBuffer>(m_boundVertexArrayObject->boundElementArrayBuffer()));
     case GL_FRAMEBUFFER_BINDING:
-        return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLFramebuffer>(m_framebufferBinding.get()));
     case GL_FRONT_FACE:
         return getUnsignedIntParameter(pname);
     case GL_GENERATE_MIPMAP_HINT:
         return getUnsignedIntParameter(pname);
     case GL_GREEN_BITS:
         return getIntParameter(pname);
     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
         return getIntParameter(pname);
     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
         return getIntParameter(pname);
@@ skipping 28 matching lines @@
         return getIntParameter(pname);
     case GL_POLYGON_OFFSET_FACTOR:
         return getFloatParameter(pname);
     case GL_POLYGON_OFFSET_FILL:
         return getBooleanParameter(pname);
     case GL_POLYGON_OFFSET_UNITS:
         return getFloatParameter(pname);
     case GL_RED_BITS:
         return getIntParameter(pname);
     case GL_RENDERBUFFER_BINDING:
-        return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLRenderbuffer>(m_renderbufferBinding.get()));
     case GL_RENDERER:
         return WebGLGetInfo(String("WebKit WebGL"));
     case GL_SAMPLE_BUFFERS:
         return getIntParameter(pname);
     case GL_SAMPLE_COVERAGE_INVERT:
         return getBooleanParameter(pname);
     case GL_SAMPLE_COVERAGE_VALUE:
         return getFloatParameter(pname);
     case GL_SAMPLES:
         return getIntParameter(pname);
@@ skipping 35 matching lines @@
         return getIntParameter(pname);
     case GL_STENCIL_TEST:
         return getBooleanParameter(pname);
     case GL_STENCIL_VALUE_MASK:
         return getUnsignedIntParameter(pname);
     case GL_STENCIL_WRITEMASK:
         return getUnsignedIntParameter(pname);
     case GL_SUBPIXEL_BITS:
         return getIntParameter(pname);
     case GL_TEXTURE_BINDING_2D:
-        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].m_texture2DBinding));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
     case GL_TEXTURE_BINDING_CUBE_MAP:
-        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding.get()));
     case GL_UNPACK_ALIGNMENT:
         return getIntParameter(pname);
     case GC3D_UNPACK_FLIP_Y_WEBGL:
         return WebGLGetInfo(m_unpackFlipY);
     case GC3D_UNPACK_PREMULTIPLY_ALPHA_WEBGL:
         return WebGLGetInfo(m_unpackPremultiplyAlpha);
     case GC3D_UNPACK_COLORSPACE_CONVERSION_WEBGL:
         return WebGLGetInfo(m_unpackColorspaceConversion);
     case GL_VENDOR:
         return WebGLGetInfo(String("WebKit"));
@@ skipping 12 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return WebGLGetInfo();
     case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:
         if (extensionEnabled(WebGLDebugRendererInfoName))
             return WebGLGetInfo(webContext()->getString(GL_VENDOR));
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return WebGLGetInfo();
     case GL_VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object
         if (extensionEnabled(OESVertexArrayObjectName)) {
             if (!m_boundVertexArrayObject->isDefaultObject())
-                return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject));
+                return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject.get()));
             return WebGLGetInfo();
         }
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");
         return WebGLGetInfo();
     case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
         if (extensionEnabled(EXTTextureFilterAnisotropicName))
             return getUnsignedIntParameter(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
         return WebGLGetInfo();
     case GL_MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN
@@ skipping 119 matching lines @@
 
 String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader)
 {
     if (isContextLost())
         return String();
     if (!validateWebGLObject("getShaderInfoLog", shader))
         return "";
     return ensureNotNull(webContext()->getShaderInfoLog(objectOrZero(shader)));
 }
 
-PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
+PassRefPtrWillBeRawPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
 {
     if (isContextLost())
         return nullptr;
     switch (shaderType) {
     case GL_VERTEX_SHADER:
     case GL_FRAGMENT_SHADER:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");
         return nullptr;
@@ skipping 27 matching lines @@
 }
 
 Nullable<Vector<String> > WebGLRenderingContextBase::getSupportedExtensions()
 {
     if (isContextLost())
         return Nullable<Vector<String> >();
 
     Vector<String> result;
 
     for (size_t i = 0; i < m_extensions.size(); ++i) {
-        ExtensionTracker* tracker = m_extensions[i];
+        ExtensionTracker* tracker = m_extensions[i].get();
         if (extensionSupportedAndAllowed(tracker)) {
             const char* const* prefixes = tracker->prefixes();
             for (; *prefixes; ++prefixes) {
                 String prefixedName = String(*prefixes) + tracker->extensionName();
                 result.append(prefixedName);
             }
         }
     }
 
     return result;
@@ skipping 168 matching lines @@
                     notImplemented();
                 }
             }
         }
     }
     // If we get here, something went wrong in our unfortunately complex logic above
     synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unknown error");
     return WebGLGetInfo();
 }
 
-PassRefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name)
+PassRefPtrWillBeRawPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("getUniformLocation", program))
         return nullptr;
     if (!validateLocationLength("getUniformLocation", name))
         return nullptr;
     if (!validateString("getUniformLocation", name))
         return nullptr;
     if (isPrefixReserved(name))
         return nullptr;
     if (!program->linkStatus()) {
@@ skipping 16 matching lines @@
     }
     const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
 
     if (extensionEnabled(ANGLEInstancedArraysName) && pname == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)
         return WebGLGetInfo(state.divisor);
 
     switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
         if (!state.bufferBinding || !state.bufferBinding->object())
             return WebGLGetInfo();
-        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));
+        return WebGLGetInfo(PassRefPtrWillBeRawPtr<WebGLBuffer>(state.bufferBinding.get()));
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
         return WebGLGetInfo(state.enabled);
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
         return WebGLGetInfo(state.normalized);
     case GL_VERTEX_ATTRIB_ARRAY_SIZE:
         return WebGLGetInfo(state.size);
     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
         return WebGLGetInfo(state.originalStride);
     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
         return WebGLGetInfo(state.type);
@@ skipping 1356 matching lines @@
     }
 
     // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.
     m_drawingBuffer->setTexture2DBinding(0);
     m_drawingBuffer->setFramebufferBinding(0);
 
     detachAndRemoveAllObjects();
 
     // Lose all the extensions.
     for (size_t i = 0; i < m_extensions.size(); ++i) {
-        ExtensionTracker* tracker = m_extensions[i];
+        ExtensionTracker* tracker = m_extensions[i].get();
         tracker->loseExtension();
     }
 
     for (size_t i = 0; i < WebGLExtensionNameCount; ++i)
         m_extensionEnabled[i] = false;
 
     removeAllCompressedTextureFormats();
 
     if (mode != RealLostContext)
         destroyContext();
@@ skipping 58 matching lines @@
 
 void WebGLRenderingContextBase::addContextObject(WebGLContextObject* object)
 {
     ASSERT(!isContextLost());
     m_contextObjects.add(object);
 }
 
 void WebGLRenderingContextBase::detachAndRemoveAllObjects()
 {
     while (m_contextObjects.size() > 0) {
-        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();
+        WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject> >::iterator it = m_contextObjects.begin();
         (*it)->detachContext();
     }
 }
 
 bool WebGLRenderingContextBase::hasPendingActivity() const
 {
     return false;
 }
 
 void WebGLRenderingContextBase::stop()
@@ skipping 1163 matching lines @@
     if (!frame)
         return;
 
     Settings* settings = frame->settings();
 
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled()))
         return;
 
     // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
     if (m_drawingBuffer) {
+#if ENABLE(OILPAN)
+        if (m_sharedWebGraphicsContext3D)
+            m_sharedWebGraphicsContext3D->reset();
+#endif
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();

[haraken, 2014/07/15 15:04:56]

It's a pain that we have to manage both m_sharedWebGraphicsContext3D and
m_drawingBuffer. Also we don't want to have different logic between oilpan and
non-oilpan as much as possible.

Can we remove m_drawingBuffer from WebGLRenderingContextBase and have the
WebGLRenderingContextBase hold m_sharedWebGraphicsContext3D in both oilpan and
non-oilpan? We can call methods of the DrawingBuffer through the
m_sharedWebGraphicsContext3D. (Probably we can add a helper method like
WebGLRenderingContextBase::drawingBuffer(), which returns
m_sharedWebGraphicsContext3D->drawingBuffer()).

[sof, 2014/07/15 16:23:00]

It's not that bad, is it? We access the m_shared* separately when tearing down a
drawingbuffer in two spots here.

I can rephrase the code to access the DrawingBuffer via an accessor instead, and
not keep a separate m_drawingBuffer with Oilpan enabled. Unless there are other
reasons for exposing WebGLSharedWebGraphicsContext3D object in non-Oilpan, I'd
be quite hesitant to impose it.

[sof, 2014/07/15 21:49:07]

Added drawingBuffer() accessor.

     }
 
     blink::WebGraphicsContext3D::Attributes attributes = m_requestedAttributes->attributes(canvas()->document().topDocument().url().string(), settings, version());
     OwnPtr<blink::WebGraphicsContext3D> context = adoptPtr(blink::Platform::current()->createOffscreenGraphicsContext3D(attributes, 0));
     RefPtr<DrawingBuffer> drawingBuffer;
     // Even if a non-null WebGraphicsContext3D is created, until it's made current, it isn't known whether the context is still lost.
     if (context) {
         // Construct a new drawing buffer with the new WebGraphicsContext3D.
         drawingBuffer = createDrawingBuffer(context.release());
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!drawingBuffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, FROM_HERE);
         } else {
             // This likely shouldn't happen but is the best way to report it to the WebGL app.
             synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
         }
         return;
     }
 
     m_drawingBuffer = drawingBuffer.release();
+#if ENABLE(OILPAN)
+    if (m_sharedWebGraphicsContext3D)
+        m_sharedWebGraphicsContext3D->update(m_drawingBuffer);
+    else
+        m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(m_drawingBuffer);
+#endif
+
     m_drawingBuffer->bind();
     m_lostContextErrors.clear();
     m_contextLost = false;
 
     setupFlags();
     initializeNewContext();
     markContextChanged(CanvasContextChanged);
     canvas()->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextrestored, false, true, ""));
 }
 
@@ skipping 89 matching lines @@
     InspectorInstrumentation::didFireWebGLWarning(canvas());
 }
 
 void WebGLRenderingContextBase::applyStencilTest()
 {
     bool haveStencilBuffer = false;
 
     if (m_framebufferBinding)
         haveStencilBuffer = m_framebufferBinding->hasStencilBuffer();
     else {
-        RefPtr<WebGLContextAttributes> attributes = getContextAttributes();
+        RefPtrWillBeRawPtr<WebGLContextAttributes> attributes = getContextAttributes();
         haveStencilBuffer = attributes->stencil();
     }
     enableOrDisable(GL_STENCIL_TEST,
                     m_stencilEnabled && haveStencilBuffer);
 }
 
 void WebGLRenderingContextBase::enableOrDisable(GLenum capability, bool enable)
 {
     if (isContextLost())
         return;
@@ skipping 73 matching lines @@
     for (int i = startIndex; i >= 0; --i) {
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
+void WebGLRenderingContextBase::TextureUnitState::trace(Visitor* visitor)
+{
+    visitor->trace(m_texture2DBinding);
+    visitor->trace(m_textureCubeMapBinding);
+}
+
+void WebGLRenderingContextBase::trace(Visitor* visitor)
+{
+    visitor->trace(m_contextObjects);
+    visitor->trace(m_contextLostCallbackAdapter);
+    visitor->trace(m_errorMessageCallbackAdapter);
+    visitor->trace(m_boundArrayBuffer);
+    visitor->trace(m_defaultVertexArrayObject);
+    visitor->trace(m_boundVertexArrayObject);
+    visitor->trace(m_vertexAttrib0Buffer);
+    visitor->trace(m_currentProgram);
+    visitor->trace(m_framebufferBinding);
+    visitor->trace(m_renderbufferBinding);
+    visitor->trace(m_textureUnits);
+    visitor->trace(m_blackTexture2D);
+    visitor->trace(m_blackTextureCubeMap);
+    visitor->trace(m_requestedAttributes);
+    visitor->trace(m_extensions);
+    CanvasRenderingContext::trace(visitor);
+}
+
+#if ENABLE(OILPAN)
+PassRefPtr<WebGLSharedWebGraphicsContext3D> WebGLRenderingContextBase::sharedWebGraphicsContext3D()
+{
+    return m_sharedWebGraphicsContext3D;
+}
+#endif
+
 } // namespace WebCore