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 blink {
 
 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)
     , m_contextLost(false)
     , m_contextLostMode(SyntheticLostContext)
     , m_requestedAttributes(requestedAttributes->clone())
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
     , m_multisamplingAllowed(false)
     , m_multisamplingObserverRegistered(false)
     , m_onePlusMaxEnabledAttribIndex(0)
     , m_onePlusMaxNonDefaultTextureUnit(0)
     , m_savingImage(false)
 {
     ASSERT(context);
 
     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)
+    RefPtr<DrawingBuffer> buffer = createDrawingBuffer(context);
+    if (!buffer)
         return;
 
-    m_drawingBuffer->bind();
+#if ENABLE(OILPAN)
+    m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(buffer.release());
+#else
+    m_drawingBuffer = buffer.release();
+#endif
+
+    drawingBuffer()->bind();
     setupFlags();
     initializeNewContext();
 }
 
 PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(PassOwnPtr<blink::WebGraphicsContext3D> context)
 {
     RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
 
     blink::WebGraphicsContext3D::Attributes attrs;
     attrs.alpha = m_requestedAttributes->alpha();
@@ skipping 65 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;
 
     activateContext(this);
 }
 
 void WebGLRenderingContextBase::setupFlags()
 {
-    ASSERT(m_drawingBuffer);
+    ASSERT(drawingBuffer());
     if (Page* p = canvas()->document().page()) {
         m_synthesizedErrorsToConsole = p->settings().webGLErrorsToConsoleEnabled();
 
         if (!m_multisamplingObserverRegistered && m_requestedAttributes->antialias()) {
-            m_multisamplingAllowed = m_drawingBuffer->multisample();
+            m_multisamplingAllowed = drawingBuffer()->multisample();
             p->addMultisamplingChangedObserver(this);
             m_multisamplingObserverRegistered = true;
         }
     }
 
     m_isGLES2NPOTStrict = !extensionsUtil()->isExtensionEnabled("GL_OES_texture_npot");
     m_isDepthStencilSupported = extensionsUtil()->isExtensionEnabled("GL_OES_packed_depth_stencil");
 }
 
 void WebGLRenderingContextBase::addCompressedTextureFormat(GLenum format)
@@ skipping 10 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)
+    if (!drawingBuffer())
         return;
 
     m_extensionsUtil.clear();
 
     webContext()->setContextLostCallback(0);
     webContext()->setErrorMessageCallback(0);
 
-    ASSERT(m_drawingBuffer);
+    ASSERT(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_sharedWebGraphicsContext3D.clear();
+#else
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
+#endif
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
-    m_drawingBuffer->markContentsChanged();
+    drawingBuffer()->markContentsChanged();
 
     m_layerCleared = false;
     RenderBox* renderBox = canvas()->renderBox();
     if (renderBox && renderBox->hasAcceleratedCompositing()) {
         m_markedCanvasDirty = true;
         canvas()->clearCopiedImage();
         renderBox->contentChanged(changeType);
     } else {
         if (!m_markedCanvasDirty) {
             m_markedCanvasDirty = true;
             canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
         }
     }
 }
 
 bool WebGLRenderingContextBase::clearIfComposited(GLbitfield mask)
 {
     if (isContextLost())
         return false;
 
-    if (!m_drawingBuffer->layerComposited() || m_layerCleared
+    if (!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 10 matching lines @@
     }
     if (contextAttributes->stencil()) {
         if (combinedClear && (mask & GL_STENCIL_BUFFER_BIT))
             webContext()->clearStencil(m_clearStencil & m_stencilMask);
         else
             webContext()->clearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
         webContext()->stencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
-    m_drawingBuffer->clearFramebuffers(clearMask);
+    drawingBuffer()->clearFramebuffers(clearMask);
 
     restoreStateAfterClear();
     if (m_framebufferBinding)
         webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     m_layerCleared = true;
 
     return combinedClear;
 }
 
 void WebGLRenderingContextBase::restoreStateAfterClear()
@@ skipping 10 matching lines @@
         m_colorMask[2], m_colorMask[3]);
     webContext()->clearDepth(m_clearDepth);
     webContext()->clearStencil(m_clearStencil);
     webContext()->stencilMaskSeparate(GL_FRONT, m_stencilMask);
     webContext()->depthMask(m_depthMask);
 }
 
 void WebGLRenderingContextBase::markLayerComposited()
 {
     if (!isContextLost())
-        m_drawingBuffer->markLayerComposited();
+        drawingBuffer()->markLayerComposited();
 }
 
 void WebGLRenderingContextBase::paintRenderingResultsToCanvas()
 {
     if (isContextLost()) {
         canvas()->clearPresentationCopy();
         return;
     }
 
     if (canvas()->document().printing())
         canvas()->clearPresentationCopy();
 
     // Until the canvas is written to by the application, the clear that
     // happened after it was composited should be ignored by the compositor.
-    if (m_drawingBuffer->layerComposited() && !m_requestedAttributes->preserveDrawingBuffer()) {
-        m_drawingBuffer->paintCompositedResultsToCanvas(canvas()->buffer());
+    if (drawingBuffer()->layerComposited() && !m_requestedAttributes->preserveDrawingBuffer()) {
+        drawingBuffer()->paintCompositedResultsToCanvas(canvas()->buffer());
 
         canvas()->makePresentationCopy();
     } else
         canvas()->clearPresentationCopy();
 
     clearIfComposited();
 
     if (!m_markedCanvasDirty && !m_layerCleared)
         return;
 
     canvas()->clearCopiedImage();
     m_markedCanvasDirty = false;
 
     ScopedTexture2DRestorer restorer(this);
 
-    m_drawingBuffer->commit();
-    if (!(canvas()->buffer())->copyRenderingResultsFromDrawingBuffer(m_drawingBuffer.get(), m_savingImage)) {
+    drawingBuffer()->commit();
+    if (!(canvas()->buffer())->copyRenderingResultsFromDrawingBuffer(drawingBuffer(), m_savingImage)) {
         canvas()->ensureUnacceleratedImageBuffer();
         if (canvas()->hasImageBuffer())
-            m_drawingBuffer->paintRenderingResultsToCanvas(canvas()->buffer());
+            drawingBuffer()->paintRenderingResultsToCanvas(canvas()->buffer());
     }
 
     if (m_framebufferBinding)
         webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
-        m_drawingBuffer->bind();
+        drawingBuffer()->bind();
 }
 
 PassRefPtrWillBeRawPtr<ImageData> WebGLRenderingContextBase::paintRenderingResultsToImageData()
 {
     if (isContextLost())
         return nullptr;
 
     clearIfComposited();
-    m_drawingBuffer->commit();
+    drawingBuffer()->commit();
     int width, height;
-    RefPtr<Uint8ClampedArray> imageDataPixels = m_drawingBuffer->paintRenderingResultsToImageData(width, height);
+    RefPtr<Uint8ClampedArray> imageDataPixels = drawingBuffer()->paintRenderingResultsToImageData(width, height);
     if (!imageDataPixels)
         return nullptr;
 
     if (m_framebufferBinding)
         webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
-        m_drawingBuffer->bind();
+        drawingBuffer()->bind();
 
     return ImageData::create(IntSize(width, height), imageDataPixels);
 }
 
 void WebGLRenderingContextBase::reshape(int width, int height)
 {
     if (isContextLost())
         return;
 
     // This is an approximation because at WebGLRenderingContextBase level we don't
     // know if the underlying FBO uses textures or renderbuffers.
     GLint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
     // Limit drawing buffer size to 4k to avoid memory exhaustion.
     const int sizeUpperLimit = 4096;
     maxSize = std::min(maxSize, sizeUpperLimit);
     GLint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
     GLint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
     width = clamp(width, 1, maxWidth);
     height = clamp(height, 1, maxHeight);
 
     if (m_needsUpdate) {
         RenderBox* renderBox = canvas()->renderBox();
         if (renderBox && renderBox->hasAcceleratedCompositing())
             renderBox->contentChanged(CanvasChanged);
         m_needsUpdate = false;
     }
 
     // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off
     // clear (and this matches what reshape will do).
-    m_drawingBuffer->reset(IntSize(width, height));
+    drawingBuffer()->reset(IntSize(width, height));
     restoreStateAfterClear();
 
     webContext()->bindTexture(GL_TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
     webContext()->bindRenderbuffer(GL_RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
     if (m_framebufferBinding)
         webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
 }
 
 int WebGLRenderingContextBase::drawingBufferWidth() const
 {
-    return isContextLost() ? 0 : m_drawingBuffer->size().width();
+    return isContextLost() ? 0 : drawingBuffer()->size().width();
 }
 
 int WebGLRenderingContextBase::drawingBufferHeight() const
 {
-    return isContextLost() ? 0 : m_drawingBuffer->size().height();
+    return isContextLost() ? 0 : drawingBuffer()->size().height();
 }
 
 unsigned WebGLRenderingContextBase::sizeInBytes(GLenum type)
 {
     switch (type) {
     case GL_BYTE:
         return sizeof(GLbyte);
     case GL_UNSIGNED_BYTE:
         return sizeof(GLubyte);
     case GL_SHORT:
@@ skipping 15 matching lines @@
 {
     if (isContextLost())
         return;
     if (texture - GL_TEXTURE0 >= m_textureUnits.size()) {
         synthesizeGLError(GL_INVALID_ENUM, "activeTexture", "texture unit out of range");
         return;
     }
     m_activeTextureUnit = texture - GL_TEXTURE0;
     webContext()->activeTexture(texture);
 
-    m_drawingBuffer->setActiveTextureUnit(texture);
+    drawingBuffer()->setActiveTextureUnit(texture);
 
 }
 
 void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))
         return;
     if (!program->attachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "attachShader", "shader attachment already has shader");
         return;
@@ skipping 66 matching lines @@
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
         return;
     if (deleted)
         buffer = 0;
     if (target != GL_FRAMEBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindFramebuffer", "invalid target");
         return;
     }
     m_framebufferBinding = buffer;
-    m_drawingBuffer->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));
+    drawingBuffer()->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));
     if (!m_framebufferBinding) {
         // Instead of binding fb 0, bind the drawing buffer.
-        m_drawingBuffer->bind();
+        drawingBuffer()->bind();
     } else {
         webContext()->bindFramebuffer(target, objectOrZero(buffer));
     }
     if (buffer)
         buffer->setHasEverBeenBound();
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::bindRenderbuffer(GLenum target, WebGLRenderbuffer* renderBuffer)
 {
@@ skipping 22 matching lines @@
     if (texture && texture->getTarget() && texture->getTarget() != target) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
         return;
     }
     GLint maxLevel = 0;
     if (target == GL_TEXTURE_2D) {
         m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
         maxLevel = m_maxTextureLevel;
 
         if (!m_activeTextureUnit)
-            m_drawingBuffer->setTexture2DBinding(objectOrZero(texture));
+            drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
 
     } else if (target == GL_TEXTURE_CUBE_MAP) {
         m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
         maxLevel = m_maxCubeMapTextureLevel;
     } else {
         synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
         return;
     }
 
     webContext()->bindTexture(target, objectOrZero(texture));
@@ skipping 322 matching lines @@
     if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {
         synthesizeGLError(GL_INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");
         return;
     }
     const char* reason = "framebuffer incomplete";
     if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);
         return;
     }
     clearIfComposited();
-    ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());
+    ScopedDrawingBufferBinder binder(drawingBuffer(), m_framebufferBinding.get());
     webContext()->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
     // FIXME: if the framebuffer is not complete, none of the below should be executed.
     tex->setLevelInfo(target, level, internalformat, width, height, GL_UNSIGNED_BYTE);
 }
 
 void WebGLRenderingContextBase::copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
     if (!validateTexFuncLevel("copyTexSubImage2D", target, level))
@@ skipping 22 matching lines @@
     if (!isTexInternalFormatColorBufferCombinationValid(internalformat, boundFramebufferColorFormat())) {
         synthesizeGLError(GL_INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");
         return;
     }
     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());
+    ScopedDrawingBufferBinder binder(drawingBuffer(), 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 30 matching lines @@
 
     m_boundVertexArrayObject->unbindBuffer(buffer);
 }
 
 void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!deleteObject(framebuffer))
         return;
     if (framebuffer == m_framebufferBinding) {
         m_framebufferBinding = nullptr;
-        m_drawingBuffer->setFramebufferBinding(0);
+        drawingBuffer()->setFramebufferBinding(0);
         // Have to call bindFramebuffer here to bind back to internal fbo.
-        m_drawingBuffer->bind();
+        drawingBuffer()->bind();
     }
 }
 
 void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program)
 {
     deleteObject(program);
     // We don't reset m_currentProgram to 0 here because the deletion of the
     // current program is delayed.
 }
 
@@ skipping 16 matching lines @@
 {
     if (!deleteObject(texture))
         return;
 
     int maxBoundTextureIndex = -1;
     for (size_t i = 0; i < m_onePlusMaxNonDefaultTextureUnit; ++i) {
         if (texture == m_textureUnits[i].m_texture2DBinding) {
             m_textureUnits[i].m_texture2DBinding = nullptr;
             maxBoundTextureIndex = i;
             if (!i)
-                m_drawingBuffer->setTexture2DBinding(0);
+                drawingBuffer()->setTexture2DBinding(0);
         }
         if (texture == m_textureUnits[i].m_textureCubeMapBinding) {
             m_textureUnits[i].m_textureCubeMapBinding = nullptr;
             maxBoundTextureIndex = i;
         }
     }
     if (m_framebufferBinding)
         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);
 
     // If the deleted was bound to the the current maximum index, trace backwards to find the new max texture index
@@ skipping 46 matching lines @@
 {
     if (isContextLost() || !validateCapability("disable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = false;
         applyStencilTest();
         return;
     }
     if (cap == GL_SCISSOR_TEST) {
         m_scissorEnabled = false;
-        m_drawingBuffer->setScissorEnabled(m_scissorEnabled);
+        drawingBuffer()->setScissorEnabled(m_scissorEnabled);
     }
     webContext()->disable(cap);
 }
 
 void WebGLRenderingContextBase::disableVertexAttribArray(GLuint index)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "disableVertexAttribArray", "index out of range");
@@ skipping 106 matching lines @@
 {
     if (isContextLost() || !validateCapability("enable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = true;
         applyStencilTest();
         return;
     }
     if (cap == GL_SCISSOR_TEST) {
         m_scissorEnabled = true;
-        m_drawingBuffer->setScissorEnabled(m_scissorEnabled);
+        drawingBuffer()->setScissorEnabled(m_scissorEnabled);
     }
     webContext()->enable(cap);
 }
 
 void WebGLRenderingContextBase::enableVertexAttribArray(GLuint index)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "enableVertexAttribArray", "index out of range");
@@ skipping 141 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();
+    blink::WebGraphicsContext3D::Attributes attrs = drawingBuffer()->getActualAttributes();
+    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());
+    attributes->setAntialias(drawingBuffer()->multisample());
     return attributes.release();
 }
 
 GLenum WebGLRenderingContextBase::getError()
 {
     if (m_lostContextErrors.size()) {
         GLenum err = m_lostContextErrors.first();
         m_lostContextErrors.remove(0);
         return err;
     }
@@ skipping 25 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 145 matching lines @@
         } else {
             synthesizeGLError(GL_INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");
             return;
         }
         break;
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
         if (param == 1 || param == 2 || param == 4 || param == 8) {
             if (pname == GL_PACK_ALIGNMENT) {
                 m_packAlignment = param;
-                m_drawingBuffer->setPackAlignment(param);
+                drawingBuffer()->setPackAlignment(param);
             } else { // GL_UNPACK_ALIGNMENT:
                 m_unpackAlignment = param;
             }
             webContext()->pixelStorei(pname, param);
         } else {
             synthesizeGLError(GL_INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");
             return;
         }
         break;
     default:
@@ skipping 82 matching lines @@
     }
     if (pixels->byteLength() < totalBytesRequired) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");
         return;
     }
 
     clearIfComposited();
     void* data = pixels->baseAddress();
 
     {
-        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());
+        ScopedDrawingBufferBinder binder(drawingBuffer(), m_framebufferBinding.get());
         webContext()->readPixels(x, y, width, height, format, type, data);
     }
 
 #if OS(MACOSX)
     // FIXME: remove this section when GL driver bug on Mac is fixed, i.e.,
     // when alpha is off, readPixels should set alpha to 255 instead of 0.
-    if (!m_framebufferBinding && !m_drawingBuffer->getActualAttributes().alpha) {
+    if (!m_framebufferBinding && !drawingBuffer()->getActualAttributes().alpha) {
         unsigned char* pixels = reinterpret_cast<unsigned char*>(data);
         for (GLsizei iy = 0; iy < height; ++iy) {
             for (GLsizei ix = 0; ix < width; ++ix) {
                 pixels[3] = 255;
                 pixels += 4;
             }
             pixels += padding;
         }
     }
 #endif
@@ skipping 370 matching lines @@
         if (!canvas->is3D()) {
             ImageBuffer* buffer = canvas->buffer();
             if (buffer && buffer->copyToPlatformTexture(webContext(), texture->object(), internalformat, type,
                 level, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                 texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);
                 return;
             }
         } else {
             WebGLRenderingContextBase* gl = toWebGLRenderingContextBase(canvas->renderingContext());
             ScopedTexture2DRestorer restorer(gl);
-            if (gl && gl->m_drawingBuffer->copyToPlatformTexture(webContext(), texture->object(), internalformat, type,
+            if (gl && gl->drawingBuffer()->copyToPlatformTexture(webContext(), texture->object(), internalformat, type,
                 level, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                 texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);
                 return;
             }
         }
     }
 
     RefPtrWillBeRawPtr<ImageData> imageData = canvas->getImageData();
     if (imageData)
         texImage2D(target, level, internalformat, format, type, imageData.get(), exceptionState);
@@ skipping 682 matching lines @@
     m_contextLostMode = mode;
 
     if (mode == RealLostContext) {
         // Inform the embedder that a lost context was received. In response, the embedder might
         // decide to take action such as asking the user for permission to use WebGL again.
         if (LocalFrame* frame = canvas()->document().frame())
             frame->loader().client()->didLoseWebGLContext(webContext()->getGraphicsResetStatusARB());
     }
 
     // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.
-    m_drawingBuffer->setTexture2DBinding(0);
-    m_drawingBuffer->setFramebufferBinding(0);
+    drawingBuffer()->setTexture2DBinding(0);
+    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 22 matching lines @@
             synthesizeGLError(GL_INVALID_OPERATION, "restoreContext", "context restoration not allowed");
         return;
     }
 
     if (!m_restoreTimer.isActive())
         m_restoreTimer.startOneShot(0, FROM_HERE);
 }
 
 blink::WebLayer* WebGLRenderingContextBase::platformLayer() const
 {
-    return isContextLost() ? 0 : m_drawingBuffer->platformLayer();
+    return isContextLost() ? 0 : drawingBuffer()->platformLayer();
 }
 
 Extensions3DUtil* WebGLRenderingContextBase::extensionsUtil()
 {
     ASSERT(!isContextLost());
     if (!m_extensionsUtil)
         m_extensionsUtil = Extensions3DUtil::create(webContext());
     return m_extensionsUtil.get();
 }
 
@@ skipping 15 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 1162 matching lines @@
     LocalFrame* frame = canvas()->document().frame();
     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 (drawingBuffer()) {
+#if ENABLE(OILPAN)
+        m_sharedWebGraphicsContext3D->dispose();
+#else
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();
+#endif
     }
 
     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;
+    RefPtr<DrawingBuffer> buffer;
     // 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());
+        buffer = createDrawingBuffer(context.release());
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
-    if (!drawingBuffer) {
+    if (!buffer) {
         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();
-    m_drawingBuffer->bind();
+#if ENABLE(OILPAN)
+    if (m_sharedWebGraphicsContext3D)
+        m_sharedWebGraphicsContext3D->update(buffer.release());
+    else
+        m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(buffer.release());
+#else
+    m_drawingBuffer = buffer.release();
+#endif
+
+    drawingBuffer()->bind();
     m_lostContextErrors.clear();
     m_contextLost = false;
 
     setupFlags();
     initializeNewContext();
     markContextChanged(CanvasContextChanged);
     canvas()->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextrestored, false, true, ""));
 }
 
 String WebGLRenderingContextBase::ensureNotNull(const String& text) const
@@ skipping 88 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)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_contextObjects);
+#endif
+    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() const
+{
+    return m_sharedWebGraphicsContext3D;
+}
+
+DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
+{
+    return m_sharedWebGraphicsContext3D ? m_sharedWebGraphicsContext3D->drawingBuffer() : 0;
+}
+#else
+DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
+{
+    return m_drawingBuffer.get();
+}
+#endif
+
 } // namespace blink