Re-land "WebGL: Transfer ownership of WebGraphicsContext3D to DrawingBuffer"

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 108 matching lines @@
 
 size_t WebGLRenderingContextBase::oldestContextIndex()
 {
     if (!activeContexts().size())
         return maxGLActiveContexts;
 
     WebGLRenderingContextBase* candidate = activeContexts().first();
     size_t candidateID = 0;
     for (size_t ii = 1; ii < activeContexts().size(); ++ii) {
         WebGLRenderingContextBase* context = activeContexts()[ii];
-        if (context->webGraphicsContext3D() && candidate->webGraphicsContext3D() && context->webGraphicsContext3D()->lastFlushID() < candidate->webGraphicsContext3D()->lastFlushID()) {
+        if (context->webContext() && candidate->webContext() && context->webContext()->lastFlushID() < candidate->webContext()->lastFlushID()) {
             candidate = context;
             candidateID = ii;
         }
     }
 
     return candidateID;
 }
 
 IntSize WebGLRenderingContextBase::oldestContextSize()
 {
@@ skipping 352 matching lines @@
         InspectorInstrumentation::didFireWebGLErrorOrWarning(m_context->canvas(), message);
     }
     virtual ~WebGLRenderingContextErrorMessageCallback() { }
 private:
     WebGLRenderingContextBase* m_context;
 };
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<blink::WebGraphicsContext3D> context, WebGLContextAttributes* requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
     , ActiveDOMObject(&passedCanvas->document())
-    , m_context(context)
     , 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)
 {
-    ASSERT(m_context);
+    ASSERT(context);
 
     m_contextGroup = WebGLContextGroup::create();
     m_contextGroup->addContext(this);
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
-    m_context->getIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
+    context->getIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
     RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
 
     // Create the DrawingBuffer and initialize the platform layer.
     DrawingBuffer::PreserveDrawingBuffer preserve = requestedAttributes->preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-    m_drawingBuffer = DrawingBuffer::create(m_context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
+    m_drawingBuffer = DrawingBuffer::create(context, clampedCanvasSize(), preserve, contextEvictionManager.release());
+    if (!m_drawingBuffer)
+        return;
 
-    if (!m_drawingBuffer->isZeroSized()) {
-        m_drawingBuffer->bind();
-        setupFlags();
-        initializeNewContext();
-    }
+    m_drawingBuffer->bind();
+    setupFlags();
+    initializeNewContext();
 }
 
 void WebGLRenderingContextBase::initializeNewContext()
 {
     ASSERT(!isContextLost());
     m_needsUpdate = true;
     m_markedCanvasDirty = false;
     m_activeTextureUnit = 0;
     m_packAlignment = 4;
     m_unpackAlignment = 4;
@@ skipping 15 matching lines @@
     m_layerCleared = false;
     m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;
 
     m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;
     m_scissorEnabled = false;
     m_clearDepth = 1;
     m_clearStencil = 0;
     m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;
 
     GLint numCombinedTextureImageUnits = 0;
-    m_context->getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
+    webContext()->getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
     m_textureUnits.clear();
     m_textureUnits.resize(numCombinedTextureImageUnits);
 
     GLint numVertexAttribs = 0;
-    m_context->getIntegerv(GL_MAX_VERTEX_ATTRIBS, &numVertexAttribs);
+    webContext()->getIntegerv(GL_MAX_VERTEX_ATTRIBS, &numVertexAttribs);
     m_maxVertexAttribs = numVertexAttribs;
 
     m_maxTextureSize = 0;
-    m_context->getIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
+    webContext()->getIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
     m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);
     m_maxCubeMapTextureSize = 0;
-    m_context->getIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);
+    webContext()->getIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);
     m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);
     m_maxRenderbufferSize = 0;
-    m_context->getIntegerv(GL_MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);
+    webContext()->getIntegerv(GL_MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);
 
     // These two values from EXT_draw_buffers are lazily queried.
     m_maxDrawBuffers = 0;
     m_maxColorAttachments = 0;
 
     m_backDrawBuffer = GL_BACK;
 
     m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);
     addContextObject(m_defaultVertexArrayObject.get());
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribValue.resize(m_maxVertexAttribs);
 
     createFallbackBlackTextures1x1();
 
-    m_drawingBuffer->reset(clampedCanvasSize());
-
-    m_context->viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
-    m_context->scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
+    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_context->setContextLostCallback(m_contextLostCallbackAdapter.get());
-    m_context->setErrorMessageCallback(m_errorMessageCallbackAdapter.get());
+    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.
-    m_context->flush();
+    webContext()->flush();
 
     for (int i = 0; i < WebGLExtensionNameCount; ++i)
         m_extensionEnabled[i] = false;
 
     activateContext(this);
 }
 
 void WebGLRenderingContextBase::setupFlags()
 {
-    ASSERT(m_context);
+    ASSERT(m_drawingBuffer);
     if (Page* p = canvas()->document().page()) {
         m_synthesizedErrorsToConsole = p->settings().webGLErrorsToConsoleEnabled();
 
         if (!m_multisamplingObserverRegistered && m_requestedAttributes->antialias()) {
             m_multisamplingAllowed = m_drawingBuffer->multisample();
             p->addMultisamplingChangedObserver(this);
             m_multisamplingObserverRegistered = true;
         }
     }
 
@@ skipping 70 matching lines @@
             page->removeMultisamplingChangedObserver(this);
     }
 
     willDestroyContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     m_contextLost = true;
 
-    // The drawing buffer holds a context reference. It must also be destroyed
-    // in order for the context to be released.
-    m_drawingBuffer->releaseResources();
+    if (!m_drawingBuffer)
+        return;
 
     m_extensionsUtil.clear();
 
-    if (m_context) {
-        m_context->setContextLostCallback(0);
-        m_context->setErrorMessageCallback(0);
-        m_context.clear();
-    }
+    webContext()->setContextLostCallback(0);
+    webContext()->setErrorMessageCallback(0);
+
+    ASSERT(m_drawingBuffer);
+    m_drawingBuffer.clear();
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
     m_drawingBuffer->markContentsChanged();
 
     m_layerCleared = false;
@@ skipping 17 matching lines @@
 
     if (!m_drawingBuffer->layerComposited() || m_layerCleared
         || m_requestedAttributes->preserveDrawingBuffer() || (mask && m_framebufferBinding))
         return false;
 
     RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();
 
     // Determine if it's possible to combine the clear the user asked for and this clear.
     bool combinedClear = mask && !m_scissorEnabled;
 
-    m_context->disable(GL_SCISSOR_TEST);
-    if (combinedClear && (mask & GL_COLOR_BUFFER_BIT))
-        m_context->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);
-    else
-        m_context->clearColor(0, 0, 0, 0);
-    m_context->colorMask(true, true, true, true);
+    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);
+    } else {
+        webContext()->clearColor(0, 0, 0, 0);
+    }
+    webContext()->colorMask(true, true, true, true);
     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
     if (contextAttributes->depth()) {
         if (!combinedClear || !m_depthMask || !(mask & GL_DEPTH_BUFFER_BIT))
-            m_context->clearDepth(1.0f);
+            webContext()->clearDepth(1.0f);
         clearMask |= GL_DEPTH_BUFFER_BIT;
-        m_context->depthMask(true);
+        webContext()->depthMask(true);
     }
     if (contextAttributes->stencil()) {
         if (combinedClear && (mask & GL_STENCIL_BUFFER_BIT))
-            m_context->clearStencil(m_clearStencil & m_stencilMask);
+            webContext()->clearStencil(m_clearStencil & m_stencilMask);
         else
-            m_context->clearStencil(0);
+            webContext()->clearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
-        m_context->stencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
+        webContext()->stencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
     m_drawingBuffer->clearFramebuffers(clearMask);
 
     restoreStateAfterClear();
     if (m_framebufferBinding)
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
+        webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     m_layerCleared = true;
 
     return combinedClear;
 }
 
 void WebGLRenderingContextBase::restoreStateAfterClear()
 {
     if (isContextLost())
         return;
 
     // Restore the state that the context set.
     if (m_scissorEnabled)
-        m_context->enable(GL_SCISSOR_TEST);
-    m_context->clearColor(m_clearColor[0], m_clearColor[1],
-                          m_clearColor[2], m_clearColor[3]);
-    m_context->colorMask(m_colorMask[0], m_colorMask[1],
-                         m_colorMask[2], m_colorMask[3]);
-    m_context->clearDepth(m_clearDepth);
-    m_context->clearStencil(m_clearStencil);
-    m_context->stencilMaskSeparate(GL_FRONT, m_stencilMask);
-    m_context->depthMask(m_depthMask);
+        webContext()->enable(GL_SCISSOR_TEST);
+    webContext()->clearColor(m_clearColor[0], m_clearColor[1],
+        m_clearColor[2], m_clearColor[3]);
+    webContext()->colorMask(m_colorMask[0], m_colorMask[1],
+        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();
 }
 
 void WebGLRenderingContextBase::paintRenderingResultsToCanvas()
 {
@@ skipping 24 matching lines @@
     ScopedTexture2DRestorer restorer(this);
 
     m_drawingBuffer->commit();
     if (!(canvas()->buffer())->copyRenderingResultsFromDrawingBuffer(m_drawingBuffer.get())) {
         canvas()->ensureUnacceleratedImageBuffer();
         if (canvas()->hasImageBuffer())
             m_drawingBuffer->paintRenderingResultsToCanvas(canvas()->buffer());
     }
 
     if (m_framebufferBinding)
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
+        webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 }
 
 PassRefPtrWillBeRawPtr<ImageData> WebGLRenderingContextBase::paintRenderingResultsToImageData()
 {
     if (isContextLost())
         return nullptr;
 
     clearIfComposited();
     m_drawingBuffer->commit();
     int width, height;
     RefPtr<Uint8ClampedArray> imageDataPixels = m_drawingBuffer->paintRenderingResultsToImageData(width, height);
     if (!imageDataPixels)
         return nullptr;
 
     if (m_framebufferBinding)
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
+        webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 
     return ImageData::create(IntSize(width, height), imageDataPixels);
 }
 
 void WebGLRenderingContextBase::reshape(int width, int height)
 {
     if (isContextLost())
         return;
@@ skipping 14 matching lines @@
         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));
     restoreStateAfterClear();
 
-    m_context->bindTexture(GL_TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
-    m_context->bindRenderbuffer(GL_RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
+    webContext()->bindTexture(GL_TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
+    webContext()->bindRenderbuffer(GL_RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
     if (m_framebufferBinding)
-        m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
+        webContext()->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
 }
 
 int WebGLRenderingContextBase::drawingBufferWidth() const
 {
-    return m_drawingBuffer->size().width();
+    return isContextLost() ? 0 : m_drawingBuffer->size().width();
 }
 
 int WebGLRenderingContextBase::drawingBufferHeight() const
 {
-    return m_drawingBuffer->size().height();
+    return isContextLost() ? 0 : m_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 13 matching lines @@
 
 void WebGLRenderingContextBase::activeTexture(GLenum texture)
 {
     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;
-    m_context->activeTexture(texture);
+    webContext()->activeTexture(texture);
 
     m_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;
     }
-    m_context->attachShader(objectOrZero(program), objectOrZero(shader));
+    webContext()->attachShader(objectOrZero(program), objectOrZero(shader));
     shader->onAttached();
 }
 
 void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GLuint index, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("bindAttribLocation", program))
         return;
     if (!validateLocationLength("bindAttribLocation", name))
         return;
     if (!validateString("bindAttribLocation", name))
         return;
     if (isPrefixReserved(name)) {
         synthesizeGLError(GL_INVALID_OPERATION, "bindAttribLocation", "reserved prefix");
         return;
     }
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "bindAttribLocation", "index out of range");
         return;
     }
-    m_context->bindAttribLocation(objectOrZero(program), index, name.utf8().data());
+    webContext()->bindAttribLocation(objectOrZero(program), index, name.utf8().data());
 }
 
 bool WebGLRenderingContextBase::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)
 {
     deleted = false;
     if (isContextLost())
         return false;
     if (object) {
         if (!object->validate(contextGroup(), this)) {
             synthesizeGLError(GL_INVALID_OPERATION, functionName, "object not from this context");
@@ skipping 17 matching lines @@
     }
     if (target == GL_ARRAY_BUFFER)
         m_boundArrayBuffer = buffer;
     else if (target == GL_ELEMENT_ARRAY_BUFFER)
         m_boundVertexArrayObject->setElementArrayBuffer(buffer);
     else {
         synthesizeGLError(GL_INVALID_ENUM, "bindBuffer", "invalid target");
         return;
     }
 
-    m_context->bindBuffer(target, objectOrZero(buffer));
+    webContext()->bindBuffer(target, objectOrZero(buffer));
     if (buffer)
         buffer->setTarget(target);
 }
 
 void WebGLRenderingContextBase::bindFramebuffer(GLenum target, WebGLFramebuffer* buffer)
 {
     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()));
     if (!m_framebufferBinding) {
         // Instead of binding fb 0, bind the drawing buffer.
         m_drawingBuffer->bind();
-    } else
-        m_context->bindFramebuffer(target, objectOrZero(buffer));
+    } else {
+        webContext()->bindFramebuffer(target, objectOrZero(buffer));
+    }
     if (buffer)
         buffer->setHasEverBeenBound();
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::bindRenderbuffer(GLenum target, WebGLRenderbuffer* renderBuffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
         return;
     if (deleted)
         renderBuffer = 0;
     if (target != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "bindRenderbuffer", "invalid target");
         return;
     }
     m_renderbufferBinding = renderBuffer;
-    m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));
+    webContext()->bindRenderbuffer(target, objectOrZero(renderBuffer));
     if (renderBuffer)
         renderBuffer->setHasEverBeenBound();
 }
 
 void WebGLRenderingContextBase::bindTexture(GLenum target, WebGLTexture* texture)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindTexture", texture, deleted))
         return;
     if (deleted)
@@ skipping 11 matching lines @@
             m_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;
     }
 
-    m_context->bindTexture(target, objectOrZero(texture));
+    webContext()->bindTexture(target, objectOrZero(texture));
     if (texture) {
         texture->setTarget(target, maxLevel);
         m_onePlusMaxNonDefaultTextureUnit = max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
     } else {
         // If the disabled index is the current maximum, trace backwards to find the new max enabled texture index
         if (m_onePlusMaxNonDefaultTextureUnit == m_activeTextureUnit + 1) {
             findNewMaxNonDefaultTextureUnit();
         }
     }
 
     // Note: previously we used to automatically set the TEXTURE_WRAP_R
     // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL
     // ES 2.0 doesn't expose this flag (a bug in the specification) and
     // otherwise the application has no control over the seams in this
     // dimension. However, it appears that supporting this properly on all
     // platforms is fairly involved (will require a HashMap from texture ID
     // in all ports), and we have not had any complaints, so the logic has
     // been removed.
 
 }
 
 void WebGLRenderingContextBase::blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
     if (isContextLost())
         return;
-    m_context->blendColor(red, green, blue, alpha);
+    webContext()->blendColor(red, green, blue, alpha);
 }
 
 void WebGLRenderingContextBase::blendEquation(GLenum mode)
 {
     if (isContextLost() || !validateBlendEquation("blendEquation", mode))
         return;
-    m_context->blendEquation(mode);
+    webContext()->blendEquation(mode);
 }
 
 void WebGLRenderingContextBase::blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
     if (isContextLost() || !validateBlendEquation("blendEquationSeparate", modeRGB) || !validateBlendEquation("blendEquationSeparate", modeAlpha))
         return;
-    m_context->blendEquationSeparate(modeRGB, modeAlpha);
+    webContext()->blendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 void WebGLRenderingContextBase::blendFunc(GLenum sfactor, GLenum dfactor)
 {
     if (isContextLost() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))
         return;
-    m_context->blendFunc(sfactor, dfactor);
+    webContext()->blendFunc(sfactor, dfactor);
 }
 
 void WebGLRenderingContextBase::blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
     // Note: Alpha does not have the same restrictions as RGB.
     if (isContextLost() || !validateBlendFuncFactors("blendFuncSeparate", srcRGB, dstRGB))
         return;
-    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    webContext()->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void WebGLRenderingContextBase::bufferData(GLenum target, long long size, GLenum usage)
 {
     if (isContextLost())
         return;
     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
     if (!buffer)
         return;
     if (size < 0) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "size < 0");
         return;
     }
     if (!size) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "size == 0");
         return;
     }
 
-    m_context->bufferData(target, static_cast<GLsizeiptr>(size), 0, usage);
+    webContext()->bufferData(target, static_cast<GLsizeiptr>(size), 0, usage);
 }
 
 void WebGLRenderingContextBase::bufferData(GLenum target, ArrayBuffer* data, GLenum usage)
 {
     if (isContextLost())
         return;
     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
     if (!buffer)
         return;
     if (!data) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
         return;
     }
-    m_context->bufferData(target, data->byteLength(), data->data(), usage);
+    webContext()->bufferData(target, data->byteLength(), data->data(), usage);
 }
 
 void WebGLRenderingContextBase::bufferData(GLenum target, ArrayBufferView* data, GLenum usage)
 {
     if (isContextLost())
         return;
     WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);
     if (!buffer)
         return;
     if (!data) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
         return;
     }
 
-    m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);
+    webContext()->bufferData(target, data->byteLength(), data->baseAddress(), usage);
 }
 
 void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, ArrayBuffer* data)
 {
     if (isContextLost())
         return;
     WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GL_STATIC_DRAW);
     if (!buffer)
         return;
     if (offset < 0) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "offset < 0");
         return;
     }
     if (!data)
         return;
 
-    m_context->bufferSubData(target, static_cast<GLintptr>(offset), data->byteLength(), data->data());
+    webContext()->bufferSubData(target, static_cast<GLintptr>(offset), data->byteLength(), data->data());
 }
 
 void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, ArrayBufferView* data)
 {
     if (isContextLost())
         return;
     WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GL_STATIC_DRAW);
     if (!buffer)
         return;
     if (offset < 0) {
         synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "offset < 0");
         return;
     }
     if (!data)
         return;
 
-    m_context->bufferSubData(target, static_cast<GLintptr>(offset), data->byteLength(), data->baseAddress());
+    webContext()->bufferSubData(target, static_cast<GLintptr>(offset), data->byteLength(), data->baseAddress());
 }
 
 GLenum WebGLRenderingContextBase::checkFramebufferStatus(GLenum target)
 {
     if (isContextLost())
         return GL_FRAMEBUFFER_UNSUPPORTED;
     if (target != GL_FRAMEBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "checkFramebufferStatus", "invalid target");
         return 0;
     }
     if (!m_framebufferBinding || !m_framebufferBinding->object())
         return GL_FRAMEBUFFER_COMPLETE;
     const char* reason = "framebuffer incomplete";
     GLenum result = m_framebufferBinding->checkStatus(&reason);
     if (result != GL_FRAMEBUFFER_COMPLETE) {
         emitGLWarning("checkFramebufferStatus", reason);
         return result;
     }
-    result = m_context->checkFramebufferStatus(target);
+    result = webContext()->checkFramebufferStatus(target);
     return result;
 }
 
 void WebGLRenderingContextBase::clear(GLbitfield mask)
 {
     if (isContextLost())
         return;
     if (mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) {
         synthesizeGLError(GL_INVALID_VALUE, "clear", "invalid mask");
         return;
     }
     const char* reason = "framebuffer incomplete";
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(m_context.get(), &reason)) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
         return;
     }
     if (!clearIfComposited(mask))
-        m_context->clear(mask);
+        webContext()->clear(mask);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::clearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
 {
     if (isContextLost())
         return;
     if (std::isnan(r))
         r = 0;
     if (std::isnan(g))
         g = 0;
     if (std::isnan(b))
         b = 0;
     if (std::isnan(a))
         a = 1;
     m_clearColor[0] = r;
     m_clearColor[1] = g;
     m_clearColor[2] = b;
     m_clearColor[3] = a;
-    m_context->clearColor(r, g, b, a);
+    webContext()->clearColor(r, g, b, a);
 }
 
 void WebGLRenderingContextBase::clearDepth(GLfloat depth)
 {
     if (isContextLost())
         return;
     m_clearDepth = depth;
-    m_context->clearDepth(depth);
+    webContext()->clearDepth(depth);
 }
 
 void WebGLRenderingContextBase::clearStencil(GLint s)
 {
     if (isContextLost())
         return;
     m_clearStencil = s;
-    m_context->clearStencil(s);
+    webContext()->clearStencil(s);
 }
 
 void WebGLRenderingContextBase::colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
     if (isContextLost())
         return;
     m_colorMask[0] = red;
     m_colorMask[1] = green;
     m_colorMask[2] = blue;
     m_colorMask[3] = alpha;
-    m_context->colorMask(red, green, blue, alpha);
+    webContext()->colorMask(red, green, blue, alpha);
 }
 
 void WebGLRenderingContextBase::compileShader(WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("compileShader", shader))
         return;
-    m_context->compileShader(objectOrZero(shader));
+    webContext()->compileShader(objectOrZero(shader));
 }
 
 void WebGLRenderingContextBase::compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, ArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFuncLevel("compressedTexImage2D", target, level))
         return;
 
     if (!validateCompressedTexFormat(internalformat)) {
@@ skipping 11 matching lines @@
 
     WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);
     if (!tex)
         return;
     if (!isGLES2NPOTStrict()) {
         if (level && WebGLTexture::isNPOT(width, height)) {
             synthesizeGLError(GL_INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");
             return;
         }
     }
-    m_context->compressedTexImage2D(target, level, internalformat, width, height,
-                                              border, data->byteLength(), data->baseAddress());
+    webContext()->compressedTexImage2D(target, level, internalformat, width, height,
+        border, data->byteLength(), data->baseAddress());
     tex->setLevelInfo(target, level, internalformat, width, height, GL_UNSIGNED_BYTE);
 }
 
 void WebGLRenderingContextBase::compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* data)
 {
     if (isContextLost())
         return;
     if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))
         return;
     if (!validateCompressedTexFormat(format)) {
         synthesizeGLError(GL_INVALID_ENUM, "compressedTexSubImage2D", "invalid format");
         return;
     }
     if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))
         return;
 
     WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);
     if (!tex)
         return;
 
     if (format != tex->getInternalFormat(target, level)) {
         synthesizeGLError(GL_INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");
         return;
     }
 
     if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))
         return;
 
-    m_context->compressedTexSubImage2D(target, level, xoffset, yoffset,
-                                                 width, height, format, data->byteLength(), data->baseAddress());
+    webContext()->compressedTexSubImage2D(target, level, xoffset, yoffset,
+        width, height, format, data->byteLength(), data->baseAddress());
 }
 
 bool WebGLRenderingContextBase::validateSettableTexFormat(const char* functionName, GLenum format)
 {
     if (WebGLImageConversion::getClearBitsByFormat(format) & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "format can not be set, only rendered to");
         return false;
     }
     return true;
 }
@@ skipping 11 matching lines @@
         return;
     if (!isTexInternalFormatColorBufferCombinationValid(internalformat, boundFramebufferColorFormat())) {
         synthesizeGLError(GL_INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");
         return;
     }
     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(m_context.get(), &reason)) {
+    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());
-    m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    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))
         return;
@@ skipping 16 matching lines @@
         return;
     }
     GLenum internalformat = tex->getInternalFormat(target, level);
     if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))
         return;
     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(m_context.get(), &reason)) {
+    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());
-    m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    webContext()->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 PassRefPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()
 {
     if (isContextLost())
         return nullptr;
     RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);
     addSharedObject(o.get());
     return o;
 }
@@ skipping 33 matching lines @@
     addSharedObject(o.get());
     return o;
 }
 
 WebGLRenderbuffer* WebGLRenderingContextBase::ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer* renderbuffer)
 {
     if (isContextLost())
         return 0;
     if (!renderbuffer->emulatedStencilBuffer()) {
         renderbuffer->setEmulatedStencilBuffer(createRenderbuffer());
-        m_context->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
-        m_context->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
+        webContext()->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
+        webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
     }
     return renderbuffer->emulatedStencilBuffer();
 }
 
 PassRefPtr<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");
@@ skipping 11 matching lines @@
         return;
     switch (mode) {
     case GL_FRONT_AND_BACK:
     case GL_FRONT:
     case GL_BACK:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "cullFace", "invalid mode");
         return;
     }
-    m_context->cullFace(mode);
+    webContext()->cullFace(mode);
 }
 
 bool WebGLRenderingContextBase::deleteObject(WebGLObject* object)
 {
     if (isContextLost() || !object)
         return false;
     if (!object->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "delete", "object does not belong to this context");
         return false;
     }
     if (object->object()) {
         // We need to pass in context here because we want
         // things in this context unbound.
-        object->deleteObject(m_context.get());
+        object->deleteObject(webContext());
     }
     return true;
 }
 
 void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)
 {
     if (!deleteObject(buffer))
         return;
     if (m_boundArrayBuffer == buffer)
         m_boundArrayBuffer = nullptr;
@@ skipping 61 matching lines @@
         findNewMaxNonDefaultTextureUnit();
     }
 }
 
 void WebGLRenderingContextBase::depthFunc(GLenum func)
 {
     if (isContextLost())
         return;
     if (!validateStencilOrDepthFunc("depthFunc", func))
         return;
-    m_context->depthFunc(func);
+    webContext()->depthFunc(func);
 }
 
 void WebGLRenderingContextBase::depthMask(GLboolean flag)
 {
     if (isContextLost())
         return;
     m_depthMask = flag;
-    m_context->depthMask(flag);
+    webContext()->depthMask(flag);
 }
 
 void WebGLRenderingContextBase::depthRange(GLfloat zNear, GLfloat zFar)
 {
     if (isContextLost())
         return;
     if (zNear > zFar) {
         synthesizeGLError(GL_INVALID_OPERATION, "depthRange", "zNear > zFar");
         return;
     }
-    m_context->depthRange(zNear, zFar);
+    webContext()->depthRange(zNear, zFar);
 }
 
 void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
         return;
     if (!program->detachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "detachShader", "shader not attached");
         return;
     }
-    m_context->detachShader(objectOrZero(program), objectOrZero(shader));
-    shader->onDetached(m_context.get());
+    webContext()->detachShader(objectOrZero(program), objectOrZero(shader));
+    shader->onDetached(webContext());
 }
 
 void WebGLRenderingContextBase::disable(GLenum cap)
 {
     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);
     }
-    m_context->disable(cap);
+    webContext()->disable(cap);
 }
 
 void WebGLRenderingContextBase::disableVertexAttribArray(GLuint index)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "disableVertexAttribArray", "index out of range");
         return;
     }
 
     WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
     state.enabled = false;
 
     // If the disabled index is the current maximum, trace backwards to find the new max enabled attrib index
     if (m_onePlusMaxEnabledAttribIndex == index + 1) {
         findNewMaxEnabledAttribIndex();
     }
 
-    m_context->disableVertexAttribArray(index);
+    webContext()->disableVertexAttribArray(index);
 }
 
 bool WebGLRenderingContextBase::validateRenderingState(const char* functionName)
 {
     if (!m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "no valid shader program in use");
         return false;
     }
 
     // Look in each enabled vertex attrib and check if they've been bound to a buffer.
@@ skipping 23 matching lines @@
 }
 
 void WebGLRenderingContextBase::drawArrays(GLenum mode, GLint first, GLsizei count)
 {
     if (!validateDrawArrays("drawArrays", mode, first, count))
         return;
 
     clearIfComposited();
 
     handleTextureCompleteness("drawArrays", true);
-    m_context->drawArrays(mode, first, count);
+    webContext()->drawArrays(mode, first, count);
     handleTextureCompleteness("drawArrays", false);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawElements(GLenum mode, GLsizei count, GLenum type, long long offset)
 {
     if (!validateDrawElements("drawElements", mode, count, type, offset))
         return;
 
     clearIfComposited();
 
     handleTextureCompleteness("drawElements", true);
-    m_context->drawElements(mode, count, type, static_cast<GLintptr>(offset));
+    webContext()->drawElements(mode, count, type, static_cast<GLintptr>(offset));
     handleTextureCompleteness("drawElements", false);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
 {
     if (!validateDrawArrays("drawArraysInstancedANGLE", mode, first, count))
         return;
 
     if (!validateDrawInstanced("drawArraysInstancedANGLE", primcount))
         return;
 
     clearIfComposited();
 
     handleTextureCompleteness("drawArraysInstancedANGLE", true);
-    m_context->drawArraysInstancedANGLE(mode, first, count, primcount);
+    webContext()->drawArraysInstancedANGLE(mode, first, count, primcount);
     handleTextureCompleteness("drawArraysInstancedANGLE", false);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei primcount)
 {
     if (!validateDrawElements("drawElementsInstancedANGLE", mode, count, type, offset))
         return;
 
     if (!validateDrawInstanced("drawElementsInstancedANGLE", primcount))
         return;
 
     clearIfComposited();
 
     handleTextureCompleteness("drawElementsInstancedANGLE", true);
-    m_context->drawElementsInstancedANGLE(mode, count, type, static_cast<GLintptr>(offset), primcount);
+    webContext()->drawElementsInstancedANGLE(mode, count, type, static_cast<GLintptr>(offset), primcount);
     handleTextureCompleteness("drawElementsInstancedANGLE", false);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::enable(GLenum cap)
 {
     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);
     }
-    m_context->enable(cap);
+    webContext()->enable(cap);
 }
 
 void WebGLRenderingContextBase::enableVertexAttribArray(GLuint index)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "enableVertexAttribArray", "index out of range");
         return;
     }
 
     WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);
     state.enabled = true;
 
     m_onePlusMaxEnabledAttribIndex = max(index + 1, m_onePlusMaxEnabledAttribIndex);
 
-    m_context->enableVertexAttribArray(index);
+    webContext()->enableVertexAttribArray(index);
 }
 
 void WebGLRenderingContextBase::finish()
 {
     if (isContextLost())
         return;
-    m_context->flush(); // Intentionally a flush, not a finish.
+    webContext()->flush(); // Intentionally a flush, not a finish.
 }
 
 void WebGLRenderingContextBase::flush()
 {
     if (isContextLost())
         return;
-    m_context->flush();
+    webContext()->flush();
 }
 
 void WebGLRenderingContextBase::framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
         return;
     if (renderbuffertarget != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "framebufferRenderbuffer", "invalid target");
         return;
     }
     if (buffer && !buffer->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");
         return;
     }
     // Don't allow the default framebuffer to be mutated; all current
     // implementations use an FBO internally in place of the default
     // FBO.
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");
         return;
     }
     Platform3DObject bufferObject = objectOrZero(buffer);
     switch (attachment) {
     case GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL:
         if (isDepthStencilSupported() || !buffer) {
-            m_context->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
-            m_context->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);
+            webContext()->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
+            webContext()->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);
         } else {
             WebGLRenderbuffer* emulatedStencilBuffer = ensureEmulatedStencilBuffer(renderbuffertarget, buffer);
             if (!emulatedStencilBuffer) {
                 synthesizeGLError(GL_OUT_OF_MEMORY, "framebufferRenderbuffer", "out of memory");
                 return;
             }
-            m_context->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
-            m_context->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, objectOrZero(emulatedStencilBuffer));
+            webContext()->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
+            webContext()->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, objectOrZero(emulatedStencilBuffer));
         }
         break;
     default:
-        m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);
+        webContext()->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);
     }
     m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
         return;
     if (level) {
         synthesizeGLError(GL_INVALID_VALUE, "framebufferTexture2D", "level not 0");
         return;
     }
     if (texture && !texture->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");
         return;
     }
     // Don't allow the default framebuffer to be mutated; all current
     // implementations use an FBO internally in place of the default
     // FBO.
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");
         return;
     }
     Platform3DObject textureObject = objectOrZero(texture);
     switch (attachment) {
     case GC3D_DEPTH_STENCIL_ATTACHMENT_WEBGL:
-        m_context->framebufferTexture2D(target, GL_DEPTH_ATTACHMENT, textarget, textureObject, level);
-        m_context->framebufferTexture2D(target, GL_STENCIL_ATTACHMENT, textarget, textureObject, level);
+        webContext()->framebufferTexture2D(target, GL_DEPTH_ATTACHMENT, textarget, textureObject, level);
+        webContext()->framebufferTexture2D(target, GL_STENCIL_ATTACHMENT, textarget, textureObject, level);
         break;
     case GL_DEPTH_ATTACHMENT:
-        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
+        webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
         break;
     case GL_STENCIL_ATTACHMENT:
-        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
+        webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
         break;
     default:
-        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);
+        webContext()->framebufferTexture2D(target, attachment, textarget, textureObject, level);
     }
     m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::frontFace(GLenum mode)
 {
     if (isContextLost())
         return;
     switch (mode) {
     case GL_CW:
     case GL_CCW:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "frontFace", "invalid mode");
         return;
     }
-    m_context->frontFace(mode);
+    webContext()->frontFace(mode);
 }
 
 void WebGLRenderingContextBase::generateMipmap(GLenum target)
 {
     if (isContextLost())
         return;
     WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);
     if (!tex)
         return;
     if (!tex->canGenerateMipmaps()) {
         synthesizeGLError(GL_INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");
         return;
     }
     if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))
         return;
 
     // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR
     // on Mac.  Remove the hack once this driver bug is fixed.
 #if OS(MACOSX)
     bool needToResetMinFilter = false;
     if (tex->getMinFilter() != GL_NEAREST_MIPMAP_LINEAR) {
-        m_context->texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
+        webContext()->texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
         needToResetMinFilter = true;
     }
 #endif
-    m_context->generateMipmap(target);
+    webContext()->generateMipmap(target);
 #if OS(MACOSX)
     if (needToResetMinFilter)
-        m_context->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
+        webContext()->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
 #endif
     tex->generateMipmapLevelInfo();
 }
 
 PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
-    if (!m_context->getActiveAttrib(objectOrZero(program), index, 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)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
-    if (!m_context->getActiveUniform(objectOrZero(program), index, info))
+    if (!webContext()->getActiveUniform(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 bool WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader> >& shaderObjects)
 {
     shaderObjects.clear();
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return false;
 
@@ skipping 16 matching lines @@
     if (!validateLocationLength("getAttribLocation", name))
         return -1;
     if (!validateString("getAttribLocation", name))
         return -1;
     if (isPrefixReserved(name))
         return -1;
     if (!program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getAttribLocation", "program not linked");
         return 0;
     }
-    return m_context->getAttribLocation(objectOrZero(program), name.utf8().data());
+    return webContext()->getAttribLocation(objectOrZero(program), name.utf8().data());
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getBufferParameter(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return WebGLGetInfo();
     if (target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "getBufferParameter", "invalid target");
         return WebGLGetInfo();
     }
 
     if (pname != GL_BUFFER_SIZE && pname != GL_BUFFER_USAGE) {
         synthesizeGLError(GL_INVALID_ENUM, "getBufferParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 
     GLint value = 0;
-    m_context->getBufferParameteriv(target, pname, &value);
+    webContext()->getBufferParameteriv(target, pname, &value);
     if (pname == GL_BUFFER_SIZE)
         return WebGLGetInfo(value);
     return WebGLGetInfo(static_cast<unsigned>(value));
 }
 
 PassRefPtr<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_context->getContextAttributes();
+    blink::WebGraphicsContext3D::Attributes attrs = webContext()->getContextAttributes();
     RefPtr<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();
 }
 
 GLenum WebGLRenderingContextBase::getError()
 {
     if (m_lostContextErrors.size()) {
         GLenum err = m_lostContextErrors.first();
         m_lostContextErrors.remove(0);
         return err;
     }
 
     if (isContextLost())
         return GL_NO_ERROR;
 
-    return m_context->getError();
+    return webContext()->getError();
 }
 
 const char* const* WebGLRenderingContextBase::ExtensionTracker::prefixes() const
 {
     static const char* const unprefixed[] = { "", 0, };
     return m_prefixes ? m_prefixes : unprefixed;
 }
 
 bool WebGLRenderingContextBase::ExtensionTracker::matchesNameWithPrefixes(const String& name) const
 {
@@ skipping 66 matching lines @@
     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)));
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
             {
                 GLint value = 0;
-                m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
+                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);
@@ skipping 125 matching lines @@
         return getBooleanParameter(pname);
     case GL_SAMPLE_COVERAGE_VALUE:
         return getFloatParameter(pname);
     case GL_SAMPLES:
         return getIntParameter(pname);
     case GL_SCISSOR_BOX:
         return getWebGLIntArrayParameter(pname);
     case GL_SCISSOR_TEST:
         return getBooleanParameter(pname);
     case GL_SHADING_LANGUAGE_VERSION:
-        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + String(m_context->getString(GL_SHADING_LANGUAGE_VERSION)) + ")");
+        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + String(webContext()->getString(GL_SHADING_LANGUAGE_VERSION)) + ")");
     case GL_STENCIL_BACK_FAIL:
         return getUnsignedIntParameter(pname);
     case GL_STENCIL_BACK_FUNC:
         return getUnsignedIntParameter(pname);
     case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
         return getUnsignedIntParameter(pname);
     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
         return getUnsignedIntParameter(pname);
     case GL_STENCIL_BACK_REF:
         return getIntParameter(pname);
@@ skipping 33 matching lines @@
         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"));
     case GL_VERSION:
-        return WebGLGetInfo("WebGL 1.0 (" + String(m_context->getString(GL_VERSION)) + ")");
+        return WebGLGetInfo("WebGL 1.0 (" + String(webContext()->getString(GL_VERSION)) + ")");
     case GL_VIEWPORT:
         return getWebGLIntArrayParameter(pname);
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives
         if (extensionEnabled(OESStandardDerivativesName))
             return getUnsignedIntParameter(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");
         return WebGLGetInfo();
     case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:
         if (extensionEnabled(WebGLDebugRendererInfoName))
-            return WebGLGetInfo(m_context->getString(GL_RENDERER));
+            return WebGLGetInfo(webContext()->getString(GL_RENDERER));
         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(m_context->getString(GL_VENDOR));
+            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();
         }
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");
         return WebGLGetInfo();
@@ skipping 31 matching lines @@
 WebGLGetInfo WebGLRenderingContextBase::getProgramParameter(WebGLProgram* program, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getProgramParameter", program))
         return WebGLGetInfo();
 
     GLint value = 0;
     switch (pname) {
     case GL_DELETE_STATUS:
         return WebGLGetInfo(program->isDeleted());
     case GL_VALIDATE_STATUS:
-        m_context->getProgramiv(objectOrZero(program), pname, &value);
+        webContext()->getProgramiv(objectOrZero(program), pname, &value);
         return WebGLGetInfo(static_cast<bool>(value));
     case GL_LINK_STATUS:
         return WebGLGetInfo(program->linkStatus());
     case GL_ATTACHED_SHADERS:
     case GL_ACTIVE_ATTRIBUTES:
     case GL_ACTIVE_UNIFORMS:
-        m_context->getProgramiv(objectOrZero(program), pname, &value);
+        webContext()->getProgramiv(objectOrZero(program), pname, &value);
         return WebGLGetInfo(value);
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getProgramParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 }
 
 String WebGLRenderingContextBase::getProgramInfoLog(WebGLProgram* program)
 {
     if (isContextLost())
         return String();
     if (!validateWebGLObject("getProgramInfoLog", program))
         return "";
-    return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));
+    return ensureNotNull(webContext()->getProgramInfoLog(objectOrZero(program)));
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getRenderbufferParameter(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return WebGLGetInfo();
     if (target != GL_RENDERBUFFER) {
         synthesizeGLError(GL_INVALID_ENUM, "getRenderbufferParameter", "invalid target");
         return WebGLGetInfo();
     }
     if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");
         return WebGLGetInfo();
     }
 
     GLint value = 0;
     switch (pname) {
     case GL_RENDERBUFFER_WIDTH:
     case GL_RENDERBUFFER_HEIGHT:
     case GL_RENDERBUFFER_RED_SIZE:
     case GL_RENDERBUFFER_GREEN_SIZE:
     case GL_RENDERBUFFER_BLUE_SIZE:
     case GL_RENDERBUFFER_ALPHA_SIZE:
     case GL_RENDERBUFFER_DEPTH_SIZE:
-        m_context->getRenderbufferParameteriv(target, pname, &value);
+        webContext()->getRenderbufferParameteriv(target, pname, &value);
         return WebGLGetInfo(value);
     case GL_RENDERBUFFER_STENCIL_SIZE:
         if (m_renderbufferBinding->emulatedStencilBuffer()) {
-            m_context->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding->emulatedStencilBuffer()));
-            m_context->getRenderbufferParameteriv(target, pname, &value);
-            m_context->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
+            webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding->emulatedStencilBuffer()));
+            webContext()->getRenderbufferParameteriv(target, pname, &value);
+            webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
         } else {
-            m_context->getRenderbufferParameteriv(target, pname, &value);
+            webContext()->getRenderbufferParameteriv(target, pname, &value);
         }
         return WebGLGetInfo(value);
     case GL_RENDERBUFFER_INTERNAL_FORMAT:
         return WebGLGetInfo(m_renderbufferBinding->internalFormat());
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getShaderParameter(WebGLShader* shader, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getShaderParameter", shader))
         return WebGLGetInfo();
     GLint value = 0;
     switch (pname) {
     case GL_DELETE_STATUS:
         return WebGLGetInfo(shader->isDeleted());
     case GL_COMPILE_STATUS:
-        m_context->getShaderiv(objectOrZero(shader), pname, &value);
+        webContext()->getShaderiv(objectOrZero(shader), pname, &value);
         return WebGLGetInfo(static_cast<bool>(value));
     case GL_SHADER_TYPE:
-        m_context->getShaderiv(objectOrZero(shader), pname, &value);
+        webContext()->getShaderiv(objectOrZero(shader), pname, &value);
         return WebGLGetInfo(static_cast<unsigned>(value));
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 }
 
 String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader)
 {
     if (isContextLost())
         return String();
     if (!validateWebGLObject("getShaderInfoLog", shader))
         return "";
-    return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));
+    return ensureNotNull(webContext()->getShaderInfoLog(objectOrZero(shader)));
 }
 
 PassRefPtr<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;
     }
     switch (precisionType) {
     case GL_LOW_FLOAT:
     case GL_MEDIUM_FLOAT:
     case GL_HIGH_FLOAT:
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");
         return nullptr;
     }
 
     GLint range[2] = {0, 0};
     GLint precision = 0;
-    m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);
+    webContext()->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);
     return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);
 }
 
 String WebGLRenderingContextBase::getShaderSource(WebGLShader* shader)
 {
     if (isContextLost())
         return String();
     if (!validateWebGLObject("getShaderSource", shader))
         return "";
     return ensureNotNull(shader->source());
@@ skipping 26 matching lines @@
     WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);
     if (!tex)
         return WebGLGetInfo();
     switch (pname) {
     case GL_TEXTURE_MAG_FILTER:
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_WRAP_S:
     case GL_TEXTURE_WRAP_T:
         {
             GLint value = 0;
-            m_context->getTexParameteriv(target, pname, &value);
+            webContext()->getTexParameteriv(target, pname, &value);
             return WebGLGetInfo(static_cast<unsigned>(value));
         }
     case GL_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
         if (extensionEnabled(EXTTextureFilterAnisotropicName)) {
             GLfloat value = 0.f;
-            m_context->getTexParameterfv(target, pname, &value);
+            webContext()->getTexParameterfv(target, pname, &value);
             return WebGLGetInfo(value);
         }
         synthesizeGLError(GL_INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
         return WebGLGetInfo();
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getTexParameter", "invalid parameter name");
         return WebGLGetInfo();
     }
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation)
 {
     if (isContextLost() || !validateWebGLObject("getUniform", program))
         return WebGLGetInfo();
     if (!uniformLocation || uniformLocation->program() != program) {
         synthesizeGLError(GL_INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");
         return WebGLGetInfo();
     }
     GLint location = uniformLocation->location();
 
     // FIXME: make this more efficient using WebGLUniformLocation and caching types in it
     GLint activeUniforms = 0;
-    m_context->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
+    webContext()->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
     for (GLint i = 0; i < activeUniforms; i++) {
         blink::WebGraphicsContext3D::ActiveInfo info;
-        if (!m_context->getActiveUniform(objectOrZero(program), i, info))
+        if (!webContext()->getActiveUniform(objectOrZero(program), i, info))
             return WebGLGetInfo();
         String name = info.name;
         StringBuilder nameBuilder;
         // Strip "[0]" from the name if it's an array.
         if (info.size > 1 && name.endsWith("[0]"))
             info.name = name.left(name.length() - 3);
         // If it's an array, we need to iterate through each element, appending "[index]" to the name.
         for (GLint index = 0; index < info.size; ++index) {
             nameBuilder.clear();
             nameBuilder.append(info.name);
             if (info.size > 1 && index >= 1) {
                 nameBuilder.append('[');
                 nameBuilder.append(String::number(index));
                 nameBuilder.append(']');
             }
             // Now need to look this up by name again to find its location
-            GLint loc = m_context->getUniformLocation(objectOrZero(program), nameBuilder.toString().utf8().data());
+            GLint loc = webContext()->getUniformLocation(objectOrZero(program), nameBuilder.toString().utf8().data());
             if (loc == location) {
                 // Found it. Use the type in the ActiveInfo to determine the return type.
                 GLenum baseType;
                 unsigned length;
                 switch (info.type) {
                 case GL_BOOL:
                     baseType = GL_BOOL;
                     length = 1;
                     break;
                 case GL_BOOL_VEC2:
@@ skipping 58 matching lines @@
                     length = 1;
                     break;
                 default:
                     // Can't handle this type
                     synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unhandled type");
                     return WebGLGetInfo();
                 }
                 switch (baseType) {
                 case GL_FLOAT: {
                     GLfloat value[16] = {0};
-                    m_context->getUniformfv(objectOrZero(program), location, value);
+                    webContext()->getUniformfv(objectOrZero(program), location, value);
                     if (length == 1)
                         return WebGLGetInfo(value[0]);
                     return WebGLGetInfo(Float32Array::create(value, length));
                 }
                 case GL_INT: {
                     GLint value[4] = {0};
-                    m_context->getUniformiv(objectOrZero(program), location, value);
+                    webContext()->getUniformiv(objectOrZero(program), location, value);
                     if (length == 1)
                         return WebGLGetInfo(value[0]);
                     return WebGLGetInfo(Int32Array::create(value, length));
                 }
                 case GL_BOOL: {
                     GLint value[4] = {0};
-                    m_context->getUniformiv(objectOrZero(program), location, value);
+                    webContext()->getUniformiv(objectOrZero(program), location, value);
                     if (length > 1) {
                         bool boolValue[16] = {0};
                         for (unsigned j = 0; j < length; j++)
                             boolValue[j] = static_cast<bool>(value[j]);
                         return WebGLGetInfo(boolValue, length);
                     }
                     return WebGLGetInfo(static_cast<bool>(value[0]));
                 }
                 default:
                     notImplemented();
@@ skipping 13 matching lines @@
     if (!validateLocationLength("getUniformLocation", name))
         return nullptr;
     if (!validateString("getUniformLocation", name))
         return nullptr;
     if (isPrefixReserved(name))
         return nullptr;
     if (!program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getUniformLocation", "program not linked");
         return nullptr;
     }
-    GLint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name.utf8().data());
+    GLint uniformLocation = webContext()->getUniformLocation(objectOrZero(program), name.utf8().data());
     if (uniformLocation == -1)
         return nullptr;
     return WebGLUniformLocation::create(program, uniformLocation);
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getVertexAttrib(GLuint index, GLenum pname)
 {
     if (isContextLost())
         return WebGLGetInfo();
     if (index >= m_maxVertexAttribs) {
@@ skipping 29 matching lines @@
 }
 
 long long WebGLRenderingContextBase::getVertexAttribOffset(GLuint index, GLenum pname)
 {
     if (isContextLost())
         return 0;
     if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER) {
         synthesizeGLError(GL_INVALID_ENUM, "getVertexAttribOffset", "invalid parameter name");
         return 0;
     }
-    GLsizeiptr result = m_context->getVertexAttribOffset(index, pname);
+    GLsizeiptr result = webContext()->getVertexAttribOffset(index, pname);
     return static_cast<long long>(result);
 }
 
 void WebGLRenderingContextBase::hint(GLenum target, GLenum mode)
 {
     if (isContextLost())
         return;
     bool isValid = false;
     switch (target) {
     case GL_GENERATE_MIPMAP_HINT:
         isValid = true;
         break;
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives
         if (extensionEnabled(OESStandardDerivativesName))
             isValid = true;
         break;
     }
     if (!isValid) {
         synthesizeGLError(GL_INVALID_ENUM, "hint", "invalid target");
         return;
     }
-    m_context->hint(target, mode);
+    webContext()->hint(target, mode);
 }
 
 GLboolean WebGLRenderingContextBase::isBuffer(WebGLBuffer* buffer)
 {
     if (!buffer || isContextLost())
         return 0;
 
     if (!buffer->hasEverBeenBound())
         return 0;
 
-    return m_context->isBuffer(buffer->object());
+    return webContext()->isBuffer(buffer->object());
 }
 
-bool WebGLRenderingContextBase::isContextLost()
+bool WebGLRenderingContextBase::isContextLost() const
 {
     return m_contextLost;
 }
 
 GLboolean WebGLRenderingContextBase::isEnabled(GLenum cap)
 {
     if (isContextLost() || !validateCapability("isEnabled", cap))
         return 0;
     if (cap == GL_STENCIL_TEST)
         return m_stencilEnabled;
-    return m_context->isEnabled(cap);
+    return webContext()->isEnabled(cap);
 }
 
 GLboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!framebuffer || isContextLost())
         return 0;
 
     if (!framebuffer->hasEverBeenBound())
         return 0;
 
-    return m_context->isFramebuffer(framebuffer->object());
+    return webContext()->isFramebuffer(framebuffer->object());
 }
 
 GLboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)
 {
     if (!program || isContextLost())
         return 0;
 
-    return m_context->isProgram(program->object());
+    return webContext()->isProgram(program->object());
 }
 
 GLboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderbuffer)
 {
     if (!renderbuffer || isContextLost())
         return 0;
 
     if (!renderbuffer->hasEverBeenBound())
         return 0;
 
-    return m_context->isRenderbuffer(renderbuffer->object());
+    return webContext()->isRenderbuffer(renderbuffer->object());
 }
 
 GLboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)
 {
     if (!shader || isContextLost())
         return 0;
 
-    return m_context->isShader(shader->object());
+    return webContext()->isShader(shader->object());
 }
 
 GLboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)
 {
     if (!texture || isContextLost())
         return 0;
 
     if (!texture->hasEverBeenBound())
         return 0;
 
-    return m_context->isTexture(texture->object());
+    return webContext()->isTexture(texture->object());
 }
 
 void WebGLRenderingContextBase::lineWidth(GLfloat width)
 {
     if (isContextLost())
         return;
-    m_context->lineWidth(width);
+    webContext()->lineWidth(width);
 }
 
 void WebGLRenderingContextBase::linkProgram(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("linkProgram", program))
         return;
 
-    m_context->linkProgram(objectOrZero(program));
+    webContext()->linkProgram(objectOrZero(program));
     program->increaseLinkCount();
 }
 
 void WebGLRenderingContextBase::pixelStorei(GLenum pname, GLint param)
 {
     if (isContextLost())
         return;
     switch (pname) {
     case GC3D_UNPACK_FLIP_Y_WEBGL:
         m_unpackFlipY = param;
@@ skipping 11 matching lines @@
         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);
             } else { // GL_UNPACK_ALIGNMENT:
                 m_unpackAlignment = param;
             }
-            m_context->pixelStorei(pname, param);
+            webContext()->pixelStorei(pname, param);
         } else {
             synthesizeGLError(GL_INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");
             return;
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "pixelStorei", "invalid parameter name");
         return;
     }
 }
 
 void WebGLRenderingContextBase::polygonOffset(GLfloat factor, GLfloat units)
 {
     if (isContextLost())
         return;
-    m_context->polygonOffset(factor, units);
+    webContext()->polygonOffset(factor, units);
 }
 
 void WebGLRenderingContextBase::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     // Due to WebGL's same-origin restrictions, it is not possible to
     // taint the origin using the WebGL API.
     ASSERT(canvas()->originClean());
     // Validate input parameters.
@@ skipping 23 matching lines @@
     if (format != GL_RGBA || type != GL_UNSIGNED_BYTE) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");
         return;
     }
     // Validate array type against pixel type.
     if (pixels->type() != ArrayBufferView::TypeUint8) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");
         return;
     }
     const char* reason = "framebuffer incomplete";
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(m_context.get(), &reason)) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);
         return;
     }
     // Calculate array size, taking into consideration of PACK_ALIGNMENT.
     unsigned totalBytesRequired = 0;
     unsigned padding = 0;
     GLenum error = WebGLImageConversion::computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);
     if (error != GL_NO_ERROR) {
         synthesizeGLError(error, "readPixels", "invalid dimensions");
         return;
     }
     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());
-        m_context->readPixels(x, y, width, height, format, type, data);
+        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_context->getContextAttributes().alpha) {
+    if (!m_framebufferBinding && !webContext()->getContextAttributes().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 12 matching lines @@
         return;
     }
     if (!validateSize("renderbufferStorage", width, height))
         return;
     switch (internalformat) {
     case GL_DEPTH_COMPONENT16:
     case GL_RGBA4:
     case GL_RGB5_A1:
     case GL_RGB565:
     case GL_STENCIL_INDEX8:
-        m_context->renderbufferStorage(target, internalformat, width, height);
+        webContext()->renderbufferStorage(target, internalformat, width, height);
         m_renderbufferBinding->setInternalFormat(internalformat);
         m_renderbufferBinding->setSize(width, height);
-        m_renderbufferBinding->deleteEmulatedStencilBuffer(m_context.get());
+        m_renderbufferBinding->deleteEmulatedStencilBuffer(webContext());
         break;
     case GL_DEPTH_STENCIL_OES:
         if (isDepthStencilSupported()) {
-            m_context->renderbufferStorage(target, GL_DEPTH24_STENCIL8_OES, width, height);
+            webContext()->renderbufferStorage(target, GL_DEPTH24_STENCIL8_OES, width, height);
         } else {
             WebGLRenderbuffer* emulatedStencilBuffer = ensureEmulatedStencilBuffer(target, m_renderbufferBinding.get());
             if (!emulatedStencilBuffer) {
                 synthesizeGLError(GL_OUT_OF_MEMORY, "renderbufferStorage", "out of memory");
                 return;
             }
-            m_context->renderbufferStorage(target, GL_DEPTH_COMPONENT16, width, height);
-            m_context->bindRenderbuffer(target, objectOrZero(emulatedStencilBuffer));
-            m_context->renderbufferStorage(target, GL_STENCIL_INDEX8, width, height);
-            m_context->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
+            webContext()->renderbufferStorage(target, GL_DEPTH_COMPONENT16, width, height);
+            webContext()->bindRenderbuffer(target, objectOrZero(emulatedStencilBuffer));
+            webContext()->renderbufferStorage(target, GL_STENCIL_INDEX8, width, height);
+            webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
             emulatedStencilBuffer->setSize(width, height);
             emulatedStencilBuffer->setInternalFormat(GL_STENCIL_INDEX8);
         }
         m_renderbufferBinding->setSize(width, height);
         m_renderbufferBinding->setInternalFormat(internalformat);
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "renderbufferStorage", "invalid internalformat");
         return;
     }
     applyStencilTest();
 }
 
 void WebGLRenderingContextBase::sampleCoverage(GLfloat value, GLboolean invert)
 {
     if (isContextLost())
         return;
-    m_context->sampleCoverage(value, invert);
+    webContext()->sampleCoverage(value, invert);
 }
 
 void WebGLRenderingContextBase::scissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
     if (!validateSize("scissor", width, height))
         return;
-    m_context->scissor(x, y, width, height);
+    webContext()->scissor(x, y, width, height);
 }
 
 void WebGLRenderingContextBase::shaderSource(WebGLShader* shader, const String& string)
 {
     if (isContextLost() || !validateWebGLObject("shaderSource", shader))
         return;
     String stringWithoutComments = StripComments(string).result();
     if (!validateString("shaderSource", stringWithoutComments))
         return;
     shader->setSource(string);
-    m_context->shaderSource(objectOrZero(shader), stringWithoutComments.utf8().data());
+    webContext()->shaderSource(objectOrZero(shader), stringWithoutComments.utf8().data());
 }
 
 void WebGLRenderingContextBase::stencilFunc(GLenum func, GLint ref, GLuint mask)
 {
     if (isContextLost())
         return;
     if (!validateStencilOrDepthFunc("stencilFunc", func))
         return;
     m_stencilFuncRef = ref;
     m_stencilFuncRefBack = ref;
     m_stencilFuncMask = mask;
     m_stencilFuncMaskBack = mask;
-    m_context->stencilFunc(func, ref, mask);
+    webContext()->stencilFunc(func, ref, mask);
 }
 
 void WebGLRenderingContextBase::stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
     if (isContextLost())
         return;
     if (!validateStencilOrDepthFunc("stencilFuncSeparate", func))
         return;
     switch (face) {
     case GL_FRONT_AND_BACK:
         m_stencilFuncRef = ref;
         m_stencilFuncRefBack = ref;
         m_stencilFuncMask = mask;
         m_stencilFuncMaskBack = mask;
         break;
     case GL_FRONT:
         m_stencilFuncRef = ref;
         m_stencilFuncMask = mask;
         break;
     case GL_BACK:
         m_stencilFuncRefBack = ref;
         m_stencilFuncMaskBack = mask;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "stencilFuncSeparate", "invalid face");
         return;
     }
-    m_context->stencilFuncSeparate(face, func, ref, mask);
+    webContext()->stencilFuncSeparate(face, func, ref, mask);
 }
 
 void WebGLRenderingContextBase::stencilMask(GLuint mask)
 {
     if (isContextLost())
         return;
     m_stencilMask = mask;
     m_stencilMaskBack = mask;
-    m_context->stencilMask(mask);
+    webContext()->stencilMask(mask);
 }
 
 void WebGLRenderingContextBase::stencilMaskSeparate(GLenum face, GLuint mask)
 {
     if (isContextLost())
         return;
     switch (face) {
     case GL_FRONT_AND_BACK:
         m_stencilMask = mask;
         m_stencilMaskBack = mask;
         break;
     case GL_FRONT:
         m_stencilMask = mask;
         break;
     case GL_BACK:
         m_stencilMaskBack = mask;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "stencilMaskSeparate", "invalid face");
         return;
     }
-    m_context->stencilMaskSeparate(face, mask);
+    webContext()->stencilMaskSeparate(face, mask);
 }
 
 void WebGLRenderingContextBase::stencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
     if (isContextLost())
         return;
-    m_context->stencilOp(fail, zfail, zpass);
+    webContext()->stencilOp(fail, zfail, zpass);
 }
 
 void WebGLRenderingContextBase::stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
     if (isContextLost())
         return;
-    m_context->stencilOpSeparate(face, fail, zfail, zpass);
+    webContext()->stencilOpSeparate(face, fail, zfail, zpass);
 }
 
 GLenum WebGLRenderingContextBase::convertTexInternalFormat(GLenum internalformat, GLenum type)
 {
     // Convert to sized internal formats that are renderable with GL_CHROMIUM_color_buffer_float_rgb(a).
     if (type == GL_FLOAT && internalformat == GL_RGBA
         && extensionsUtil()->isExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgba"))
         return GL_RGBA32F_EXT;
     if (type == GL_FLOAT && internalformat == GL_RGB
         && extensionsUtil()->isExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgb"))
         return GL_RGB32F_EXT;
     return internalformat;
 }
 
 void WebGLRenderingContextBase::texImage2DBase(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels, ExceptionState& exceptionState)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     // FIXME: Handle errors.
     WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);
     ASSERT(validateTexFuncParameters("texImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, format, type));
     ASSERT(tex);
     ASSERT(!level || !WebGLTexture::isNPOT(width, height));
     ASSERT(!pixels || validateSettableTexFormat("texImage2D", internalformat));
-    m_context->texImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, pixels);
+    webContext()->texImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, pixels);
     tex->setLevelInfo(target, level, internalformat, width, height, type);
 }
 
 void WebGLRenderingContextBase::texImage2DImpl(GLenum target, GLint level, GLenum internalformat, GLenum format, GLenum type, Image* image, WebGLImageConversion::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionState& exceptionState)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     Vector<uint8_t> data;
     WebGLImageConversion::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GL_NONE);
     if (!imageExtractor.extractSucceeded()) {
         synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "bad image data");
         return;
     }
     WebGLImageConversion::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();
     WebGLImageConversion::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
     const void* imagePixelData = imageExtractor.imagePixelData();
 
     bool needConversion = true;
     if (type == GL_UNSIGNED_BYTE && sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 && format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing && !flipY)
         needConversion = false;
     else {
         if (!WebGLImageConversion::packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "packImage error");
             return;
         }
     }
 
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texImage2DBase(target, level, internalformat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 0, format, type, needConversion ? data.data() : imagePixelData, exceptionState);
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLint xoffset, GLint yoffset)
 {
     if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))
         return false;
 
     WebGLTexture* texture = validateTextureBinding(functionName, target, true);
     if (!texture)
         return false;
@@ skipping 57 matching lines @@
     void* data = pixels ? pixels->baseAddress() : 0;
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (!WebGLImageConversion::extractTextureData(width, height, format, type, m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
             return;
         data = tempData.data();
         changeUnpackAlignment = true;
     }
     if (changeUnpackAlignment)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texImage2DBase(target, level, internalformat, width, height, border, format, type, data, exceptionState);
     if (changeUnpackAlignment)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLenum internalformat,
     GLenum format, GLenum type, ImageData* pixels, ExceptionState& exceptionState)
 {
     if (isContextLost() || !pixels || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))
         return;
     Vector<uint8_t> data;
     bool needConversion = true;
     // The data from ImageData is always of format RGBA8.
     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
     if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GL_RGBA && type == GL_UNSIGNED_BYTE)
         needConversion = false;
     else {
         if (!WebGLImageConversion::extractImageData(pixels->data()->data(), pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "bad image data");
             return;
         }
     }
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), exceptionState);
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLenum internalformat,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateHTMLImageElement("texImage2D", image, exceptionState))
         return;
 
     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
     if (imageForRender->isSVGImage())
@@ skipping 13 matching lines @@
 
     WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);
 
     // If possible, copy from the canvas element directly to the texture
     // via the GPU, without a read-back to system memory.
     if (GL_TEXTURE_2D == target && texture) {
         ScopedTexture2DRestorer restorer(this);
 
         if (!canvas->is3D()) {
             ImageBuffer* buffer = canvas->buffer();
-            if (buffer && buffer->copyToPlatformTexture(m_context.get(), texture->object(), internalformat, type,
+            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(m_context.get(), texture->object(), internalformat, type,
+            if (gl && gl->m_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 19 matching lines @@
     GLenum format, GLenum type, HTMLVideoElement* video, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateHTMLVideoElement("texImage2D", video, exceptionState)
         || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))
         return;
 
     // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.
     // Otherwise, it will fall back to the normal SW path.
     WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);
     if (GL_TEXTURE_2D == target && texture) {
-        if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
+        if (video->copyVideoTextureToPlatformTexture(webContext(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
             texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);
             return;
         }
     }
 
     // Normal pure SW path.
     RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode());
     if (!image)
         return;
     texImage2DImpl(target, level, internalformat, format, type, image.get(), WebGLImageConversion::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, exceptionState);
@@ skipping 23 matching lines @@
             synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");
             return;
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter name");
         return;
     }
     if (isFloat) {
         tex->setParameterf(pname, paramf);
-        m_context->texParameterf(target, pname, paramf);
+        webContext()->texParameterf(target, pname, paramf);
     } else {
         tex->setParameteri(pname, parami);
-        m_context->texParameteri(target, pname, parami);
+        webContext()->texParameteri(target, pname, parami);
     }
 }
 
 void WebGLRenderingContextBase::texParameterf(GLenum target, GLenum pname, GLfloat param)
 {
     texParameter(target, pname, param, 0, true);
 }
 
 void WebGLRenderingContextBase::texParameteri(GLenum target, GLenum pname, GLint param)
 {
@@ skipping 11 matching lines @@
     if (!tex) {
         ASSERT_NOT_REACHED();
         return;
     }
     ASSERT((xoffset + width) >= 0);
     ASSERT((yoffset + height) >= 0);
     ASSERT(tex->getWidth(target, level) >= (xoffset + width));
     ASSERT(tex->getHeight(target, level) >= (yoffset + height));
     ASSERT(tex->getInternalFormat(target, level) == format);
     ASSERT(tex->getType(target, level) == type);
-    m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    webContext()->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void WebGLRenderingContextBase::texSubImage2DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, Image* image, WebGLImageConversion::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionState& exceptionState)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     Vector<uint8_t> data;
     WebGLImageConversion::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GL_NONE);
     if (!imageExtractor.extractSucceeded()) {
         synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "bad image");
         return;
     }
     WebGLImageConversion::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();
     WebGLImageConversion::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
     const void* imagePixelData = imageExtractor.imagePixelData();
 
     bool needConversion = true;
     if (type == GL_UNSIGNED_BYTE && sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 && format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing && !flipY)
         needConversion = false;
     else {
         if (!WebGLImageConversion::packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "bad image data");
             return;
         }
     }
 
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texSubImage2DBase(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData, exceptionState);
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height,
     GLenum format, GLenum type, ArrayBufferView* pixels, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)
         || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))
         return;
     void* data = pixels->baseAddress();
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (!WebGLImageConversion::extractTextureData(width, height, format, type,
                                            m_unpackAlignment,
                                            m_unpackFlipY, m_unpackPremultiplyAlpha,
                                            data,
                                            tempData))
             return;
         data = tempData.data();
         changeUnpackAlignment = true;
     }
     if (changeUnpackAlignment)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, exceptionState);
     if (changeUnpackAlignment)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, ImageData* pixels, ExceptionState& exceptionState)
 {
     if (isContextLost() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))
         return;
 
     Vector<uint8_t> data;
     bool needConversion = true;
     // The data from ImageData is always of format RGBA8.
     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
     if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)
         needConversion = false;
     else {
         if (!WebGLImageConversion::extractImageData(pixels->data()->data(), pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "bad image data");
             return;
         }
     }
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, 1);
     texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data(), exceptionState);
     if (m_unpackAlignment != 1)
-        m_context->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
+        webContext()->pixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (isContextLost() || !validateHTMLImageElement("texSubImage2D", image, exceptionState))
         return;
 
     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
     if (imageForRender->isSVGImage())
@@ skipping 35 matching lines @@
 void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GLfloat x)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1f", "location not for current program");
         return;
     }
 
-    m_context->uniform1f(location->location(), x);
+    webContext()->uniform1f(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1fv", location, v, 1))
         return;
 
-    m_context->uniform1fv(location->location(), v->length(), v->data());
+    webContext()->uniform1fv(location->location(), v->length(), v->data());
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform1fv", location, v, size, 1))
         return;
 
-    m_context->uniform1fv(location->location(), size, v);
+    webContext()->uniform1fv(location->location(), size, v);
 }
 
 void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GLint x)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1i", "location not for current program");
         return;
     }
 
-    m_context->uniform1i(location->location(), x);
+    webContext()->uniform1i(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1iv", location, v, 1))
         return;
 
-    m_context->uniform1iv(location->location(), v->length(), v->data());
+    webContext()->uniform1iv(location->location(), v->length(), v->data());
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform1iv", location, v, size, 1))
         return;
 
-    m_context->uniform1iv(location->location(), size, v);
+    webContext()->uniform1iv(location->location(), size, v);
 }
 
 void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GLfloat x, GLfloat y)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform2f", "location not for current program");
         return;
     }
 
-    m_context->uniform2f(location->location(), x, y);
+    webContext()->uniform2f(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2fv", location, v, 2))
         return;
 
-    m_context->uniform2fv(location->location(), v->length() / 2, v->data());
+    webContext()->uniform2fv(location->location(), v->length() / 2, v->data());
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform2fv", location, v, size, 2))
         return;
 
-    m_context->uniform2fv(location->location(), size / 2, v);
+    webContext()->uniform2fv(location->location(), size / 2, v);
 }
 
 void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GLint x, GLint y)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform2i", "location not for current program");
         return;
     }
 
-    m_context->uniform2i(location->location(), x, y);
+    webContext()->uniform2i(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2iv", location, v, 2))
         return;
 
-    m_context->uniform2iv(location->location(), v->length() / 2, v->data());
+    webContext()->uniform2iv(location->location(), v->length() / 2, v->data());
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform2iv", location, v, size, 2))
         return;
 
-    m_context->uniform2iv(location->location(), size / 2, v);
+    webContext()->uniform2iv(location->location(), size / 2, v);
 }
 
 void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GLfloat x, GLfloat y, GLfloat z)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform3f", "location not for current program");
         return;
     }
 
-    m_context->uniform3f(location->location(), x, y, z);
+    webContext()->uniform3f(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3fv", location, v, 3))
         return;
 
-    m_context->uniform3fv(location->location(), v->length() / 3, v->data());
+    webContext()->uniform3fv(location->location(), v->length() / 3, v->data());
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform3fv", location, v, size, 3))
         return;
 
-    m_context->uniform3fv(location->location(), size / 3, v);
+    webContext()->uniform3fv(location->location(), size / 3, v);
 }
 
 void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GLint x, GLint y, GLint z)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform3i", "location not for current program");
         return;
     }
 
-    m_context->uniform3i(location->location(), x, y, z);
+    webContext()->uniform3i(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3iv", location, v, 3))
         return;
 
-    m_context->uniform3iv(location->location(), v->length() / 3, v->data());
+    webContext()->uniform3iv(location->location(), v->length() / 3, v->data());
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform3iv", location, v, size, 3))
         return;
 
-    m_context->uniform3iv(location->location(), size / 3, v);
+    webContext()->uniform3iv(location->location(), size / 3, v);
 }
 
 void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform4f", "location not for current program");
         return;
     }
 
-    m_context->uniform4f(location->location(), x, y, z, w);
+    webContext()->uniform4f(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4fv", location, v, 4))
         return;
 
-    m_context->uniform4fv(location->location(), v->length() / 4, v->data());
+    webContext()->uniform4fv(location->location(), v->length() / 4, v->data());
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform4fv", location, v, size, 4))
         return;
 
-    m_context->uniform4fv(location->location(), size / 4, v);
+    webContext()->uniform4fv(location->location(), size / 4, v);
 }
 
 void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GLint x, GLint y, GLint z, GLint w)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform4i", "location not for current program");
         return;
     }
 
-    m_context->uniform4i(location->location(), x, y, z, w);
+    webContext()->uniform4i(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32Array* v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4iv", location, v, 4))
         return;
 
-    m_context->uniform4iv(location->location(), v->length() / 4, v->data());
+    webContext()->uniform4iv(location->location(), v->length() / 4, v->data());
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, GLint* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformParameters("uniform4iv", location, v, size, 4))
         return;
 
-    m_context->uniform4iv(location->location(), size / 4, v);
+    webContext()->uniform4iv(location->location(), size / 4, v);
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
         return;
-    m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());
+    webContext()->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))
         return;
-    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);
+    webContext()->uniformMatrix2fv(location->location(), size / 4, transpose, v);
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))
         return;
-    m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
+    webContext()->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))
         return;
-    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);
+    webContext()->uniformMatrix3fv(location->location(), size / 9, transpose, v);
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, Float32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
         return;
-    m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());
+    webContext()->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, GLfloat* v, GLsizei size)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))
         return;
-    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);
+    webContext()->uniformMatrix4fv(location->location(), size / 16, transpose, v);
 }
 
 void WebGLRenderingContextBase::useProgram(WebGLProgram* program)
 {
     bool deleted;
     if (!checkObjectToBeBound("useProgram", program, deleted))
         return;
     if (deleted)
         program = 0;
     if (program && !program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "program not valid");
         return;
     }
     if (m_currentProgram != program) {
         if (m_currentProgram)
-            m_currentProgram->onDetached(m_context.get());
+            m_currentProgram->onDetached(webContext());
         m_currentProgram = program;
-        m_context->useProgram(objectOrZero(program));
+        webContext()->useProgram(objectOrZero(program));
         if (program)
             program->onAttached();
     }
 }
 
 void WebGLRenderingContextBase::validateProgram(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("validateProgram", program))
         return;
-    m_context->validateProgram(objectOrZero(program));
+    webContext()->validateProgram(objectOrZero(program));
 }
 
 void WebGLRenderingContextBase::vertexAttrib1f(GLuint index, GLfloat v0)
 {
     vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);
 }
 
 void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, Float32Array* v)
 {
     vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);
@@ skipping 82 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "vertexAttribPointer", "invalid type");
         return;
     }
     if ((stride % typeSize) || (static_cast<GLintptr>(offset) % typeSize)) {
         synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");
         return;
     }
     GLsizei bytesPerElement = size * typeSize;
 
     m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GLintptr>(offset), m_boundArrayBuffer);
-    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GLintptr>(offset));
+    webContext()->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GLintptr>(offset));
 }
 
 void WebGLRenderingContextBase::vertexAttribDivisorANGLE(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisorANGLE", "index out of range");
         return;
     }
 
     m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);
-    m_context->vertexAttribDivisorANGLE(index, divisor);
+    webContext()->vertexAttribDivisorANGLE(index, divisor);
 }
 
 void WebGLRenderingContextBase::viewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
     if (!validateSize("viewport", width, height))
         return;
-    m_context->viewport(x, y, width, height);
+    webContext()->viewport(x, y, width, height);
 }
 
 void WebGLRenderingContextBase::forceLostContext(WebGLRenderingContextBase::LostContextMode mode)
 {
     if (isContextLost()) {
         synthesizeGLError(GL_INVALID_OPERATION, "loseContext", "context already lost");
         return;
     }
 
     m_contextGroup->loseContextGroup(mode);
 }
 
 void WebGLRenderingContextBase::loseContextImpl(WebGLRenderingContextBase::LostContextMode mode)
 {
     if (isContextLost())
         return;
 
     m_contextLost = true;
     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(m_context->getGraphicsResetStatusARB());
+            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);
 
     detachAndRemoveAllObjects();
 
     // Lose all the extensions.
     for (size_t i = 0; i < m_extensions.size(); ++i) {
@@ skipping 33 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 m_drawingBuffer->platformLayer();
+    return isContextLost() ? 0 : m_drawingBuffer->platformLayer();
 }
 
 Extensions3DUtil* WebGLRenderingContextBase::extensionsUtil()
 {
+    ASSERT(!isContextLost());
     if (!m_extensionsUtil)
-        m_extensionsUtil = adoptPtr(new Extensions3DUtil(m_context.get()));
+        m_extensionsUtil = adoptPtr(new Extensions3DUtil(webContext()));
     return m_extensionsUtil.get();
 }
 
 void WebGLRenderingContextBase::removeSharedObject(WebGLSharedObject* object)
 {
     m_contextGroup->removeObject(object);
 }
 
 void WebGLRenderingContextBase::addSharedObject(WebGLSharedObject* object)
 {
@@ skipping 30 matching lines @@
     if (!isContextLost()) {
         forceLostContext(SyntheticLostContext);
         destroyContext();
     }
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getBooleanParameter(GLenum pname)
 {
     GLboolean value = 0;
     if (!isContextLost())
-        m_context->getBooleanv(pname, &value);
+        webContext()->getBooleanv(pname, &value);
     return WebGLGetInfo(static_cast<bool>(value));
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getBooleanArrayParameter(GLenum pname)
 {
     if (pname != GL_COLOR_WRITEMASK) {
         notImplemented();
         return WebGLGetInfo(0, 0);
     }
     GLboolean value[4] = {0};
     if (!isContextLost())
-        m_context->getBooleanv(pname, value);
+        webContext()->getBooleanv(pname, value);
     bool boolValue[4];
     for (int ii = 0; ii < 4; ++ii)
         boolValue[ii] = static_cast<bool>(value[ii]);
     return WebGLGetInfo(boolValue, 4);
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getFloatParameter(GLenum pname)
 {
     GLfloat value = 0;
     if (!isContextLost())
-        m_context->getFloatv(pname, &value);
+        webContext()->getFloatv(pname, &value);
     return WebGLGetInfo(value);
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getIntParameter(GLenum pname)
 {
     GLint value = 0;
     if (!isContextLost())
-        m_context->getIntegerv(pname, &value);
+        webContext()->getIntegerv(pname, &value);
     return WebGLGetInfo(value);
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getUnsignedIntParameter(GLenum pname)
 {
     GLint value = 0;
     if (!isContextLost())
-        m_context->getIntegerv(pname, &value);
+        webContext()->getIntegerv(pname, &value);
     return WebGLGetInfo(static_cast<unsigned>(value));
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getWebGLFloatArrayParameter(GLenum pname)
 {
     GLfloat value[4] = {0};
     if (!isContextLost())
-        m_context->getFloatv(pname, value);
+        webContext()->getFloatv(pname, value);
     unsigned length = 0;
     switch (pname) {
     case GL_ALIASED_POINT_SIZE_RANGE:
     case GL_ALIASED_LINE_WIDTH_RANGE:
     case GL_DEPTH_RANGE:
         length = 2;
         break;
     case GL_BLEND_COLOR:
     case GL_COLOR_CLEAR_VALUE:
         length = 4;
         break;
     default:
         notImplemented();
     }
     return WebGLGetInfo(Float32Array::create(value, length));
 }
 
 WebGLGetInfo WebGLRenderingContextBase::getWebGLIntArrayParameter(GLenum pname)
 {
     GLint value[4] = {0};
     if (!isContextLost())
-        m_context->getIntegerv(pname, value);
+        webContext()->getIntegerv(pname, value);
     unsigned length = 0;
     switch (pname) {
     case GL_MAX_VIEWPORT_DIMS:
         length = 2;
         break;
     case GL_SCISSOR_BOX:
     case GL_VIEWPORT:
         length = 4;
         break;
     default:
         notImplemented();
     }
     return WebGLGetInfo(Int32Array::create(value, length));
 }
 
 void WebGLRenderingContextBase::handleTextureCompleteness(const char* functionName, bool prepareToDraw)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     bool resetActiveUnit = false;
     WebGLTexture::TextureExtensionFlag flag = static_cast<WebGLTexture::TextureExtensionFlag>((extensionEnabled(OESTextureFloatLinearName) ? WebGLTexture::TextureFloatLinearExtensionEnabled : 0)
         | (extensionEnabled(OESTextureHalfFloatLinearName) ? WebGLTexture::TextureHalfFloatLinearExtensionEnabled : 0));
     for (unsigned ii = 0; ii < m_onePlusMaxNonDefaultTextureUnit; ++ii) {
         if ((m_textureUnits[ii].m_texture2DBinding.get() && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
             || (m_textureUnits[ii].m_textureCubeMapBinding.get() && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture(flag))) {
             if (ii != m_activeTextureUnit) {
-                m_context->activeTexture(ii);
+                webContext()->activeTexture(ii);
                 resetActiveUnit = true;
             } else if (resetActiveUnit) {
-                m_context->activeTexture(ii);
+                webContext()->activeTexture(ii);
                 resetActiveUnit = false;
             }
             WebGLTexture* tex2D;
             WebGLTexture* texCubeMap;
             if (prepareToDraw) {
                 String msg(String("texture bound to texture unit ") + String::number(ii)
                     + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete'."
                     + " Or the texture is Float or Half Float type with linear filtering while OES_float_linear or OES_half_float_linear extension is not enabled.");
                 emitGLWarning(functionName, msg.utf8().data());
                 tex2D = m_blackTexture2D.get();
                 texCubeMap = m_blackTextureCubeMap.get();
             } else {
                 tex2D = m_textureUnits[ii].m_texture2DBinding.get();
                 texCubeMap = m_textureUnits[ii].m_textureCubeMapBinding.get();
             }
             if (m_textureUnits[ii].m_texture2DBinding && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
-                m_context->bindTexture(GL_TEXTURE_2D, objectOrZero(tex2D));
+                webContext()->bindTexture(GL_TEXTURE_2D, objectOrZero(tex2D));
             if (m_textureUnits[ii].m_textureCubeMapBinding && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture(flag))
-                m_context->bindTexture(GL_TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));
+                webContext()->bindTexture(GL_TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));
         }
     }
     if (resetActiveUnit)
-        m_context->activeTexture(m_activeTextureUnit);
+        webContext()->activeTexture(m_activeTextureUnit);
 }
 
 void WebGLRenderingContextBase::createFallbackBlackTextures1x1()
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     unsigned char black[] = {0, 0, 0, 255};
     m_blackTexture2D = createTexture();
-    m_context->bindTexture(GL_TEXTURE_2D, m_blackTexture2D->object());
-    m_context->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1,
+    webContext()->bindTexture(GL_TEXTURE_2D, m_blackTexture2D->object());
+    webContext()->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->bindTexture(GL_TEXTURE_2D, 0);
+    webContext()->bindTexture(GL_TEXTURE_2D, 0);
     m_blackTextureCubeMap = createTexture();
-    m_context->bindTexture(GL_TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 1, 1,
+    webContext()->bindTexture(GL_TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, 1, 1,
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, 1, 1,
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, 1, 1,
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, 1, 1,
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, 1, 1,
+    webContext()->texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, 1, 1,
         0, GL_RGBA, GL_UNSIGNED_BYTE, black);
-    m_context->bindTexture(GL_TEXTURE_CUBE_MAP, 0);
+    webContext()->bindTexture(GL_TEXTURE_CUBE_MAP, 0);
 }
 
 bool WebGLRenderingContextBase::isTexInternalFormatColorBufferCombinationValid(GLenum texInternalFormat, GLenum colorBufferFormat)
 {
     unsigned need = WebGLImageConversion::getChannelBitsByFormat(texInternalFormat);
     unsigned have = WebGLImageConversion::getChannelBitsByFormat(colorBufferFormat);
     return (need & have) == need;
 }
 
 GLenum WebGLRenderingContextBase::boundFramebufferColorFormat()
@@ skipping 756 matching lines @@
     if (!count) {
         markContextChanged(CanvasChanged);
         return false;
     }
 
     if (!validateRenderingState(functionName)) {
         return false;
     }
 
     const char* reason = "framebuffer incomplete";
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(m_context.get(), &reason)) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
         return false;
     }
 
     return true;
 }
 
 bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, GLenum mode, GLsizei count, GLenum type, long long offset)
 {
     if (isContextLost() || !validateDrawMode(functionName, mode))
@@ skipping 29 matching lines @@
     if (!m_boundVertexArrayObject->boundElementArrayBuffer()) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");
         return false;
     }
 
     if (!validateRenderingState(functionName)) {
         return false;
     }
 
     const char* reason = "framebuffer incomplete";
-    if (m_framebufferBinding && !m_framebufferBinding->onAccess(m_context.get(), &reason)) {
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(webContext(), &reason)) {
         synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
         return false;
     }
 
     return true;
 }
 
 // Helper function to validate draw*Instanced calls
 bool WebGLRenderingContextBase::validateDrawInstanced(const char* functionName, GLsizei primcount)
 {
@@ skipping 17 matching lines @@
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "index out of range");
         return;
     }
     // In GL, we skip setting vertexAttrib0 values.
     switch (expectedSize) {
     case 1:
-        m_context->vertexAttrib1f(index, v0);
+        webContext()->vertexAttrib1f(index, v0);
         break;
     case 2:
-        m_context->vertexAttrib2f(index, v0, v1);
+        webContext()->vertexAttrib2f(index, v0, v1);
         break;
     case 3:
-        m_context->vertexAttrib3f(index, v0, v1, v2);
+        webContext()->vertexAttrib3f(index, v0, v1, v2);
         break;
     case 4:
-        m_context->vertexAttrib4f(index, v0, v1, v2, v3);
+        webContext()->vertexAttrib4f(index, v0, v1, v2, v3);
         break;
     }
     VertexAttribValue& attribValue = m_vertexAttribValue[index];
     attribValue.value[0] = v0;
     attribValue.value[1] = v1;
     attribValue.value[2] = v2;
     attribValue.value[3] = v3;
 }
 
 void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GLuint index, Float32Array* v, GLsizei expectedSize)
@@ skipping 19 matching lines @@
         synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid size");
         return;
     }
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "index out of range");
         return;
     }
     // In GL, we skip setting vertexAttrib0 values.
     switch (expectedSize) {
     case 1:
-        m_context->vertexAttrib1fv(index, v);
+        webContext()->vertexAttrib1fv(index, v);
         break;
     case 2:
-        m_context->vertexAttrib2fv(index, v);
+        webContext()->vertexAttrib2fv(index, v);
         break;
     case 3:
-        m_context->vertexAttrib3fv(index, v);
+        webContext()->vertexAttrib3fv(index, v);
         break;
     case 4:
-        m_context->vertexAttrib4fv(index, v);
+        webContext()->vertexAttrib4fv(index, v);
         break;
     }
     VertexAttribValue& attribValue = m_vertexAttribValue[index];
     attribValue.initValue();
     for (int ii = 0; ii < expectedSize; ++ii)
         attribValue.value[ii] = v[ii];
 }
 
 void WebGLRenderingContextBase::dispatchContextLostEvent(Timer<WebGLRenderingContextBase>*)
 {
@@ skipping 20 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 destruct the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.

[Ken Russell (switch to Gerrit), 2014/04/06 06:07:24]

destruct -> destroy

+    m_drawingBuffer.clear();
+
     blink::WebGraphicsContext3D::Attributes attributes = m_requestedAttributes->attributes(canvas()->document().topDocument().url().string(), settings);
     OwnPtr<blink::WebGraphicsContext3D> context = adoptPtr(blink::Platform::current()->createOffscreenGraphicsContext3D(attributes, 0));
     RefPtr<DrawingBuffer> drawingBuffer;
     if (context) {
-        // If the context was lost due to RealLostContext, we need to release FBOs before creating new DrawingBuffer to ensure resource budget enough.
-        m_drawingBuffer->releaseResources();
         RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
 
         // Construct a new drawing buffer with the new WebGraphicsContext3D.
         DrawingBuffer::PreserveDrawingBuffer preserve = m_requestedAttributes->preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-        drawingBuffer = DrawingBuffer::create(context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
-
-        if (drawingBuffer->isZeroSized()) {
-            drawingBuffer.clear();
-            context.clear();
-        }
+        drawingBuffer = DrawingBuffer::create(context.release(), clampedCanvasSize(), preserve, contextEvictionManager.release());
+        // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
-    if (!context) {
+    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();
     m_drawingBuffer->bind();
-
     m_lostContextErrors.clear();
-
-    m_context = context.release();
     m_contextLost = false;
 
     setupFlags();
     initializeNewContext();
     markContextChanged(CanvasContextChanged);
     canvas()->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextrestored, false, true, ""));
 }
 
 String WebGLRenderingContextBase::ensureNotNull(const String& text) const
 {
@@ skipping 63 matching lines @@
 } // namespace anonymous
 
 void WebGLRenderingContextBase::synthesizeGLError(GLenum error, const char* functionName, const char* description, ConsoleDisplayPreference display)
 {
     String errorType = GetErrorString(error);
     if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {
         String message = String("WebGL: ") + errorType +  ": " + String(functionName) + ": " + String(description);
         printGLErrorToConsole(message);
     }
     if (!isContextLost())
-        m_context->synthesizeGLError(error);
+        webContext()->synthesizeGLError(error);
     else {
         if (m_lostContextErrors.find(error) == WTF::kNotFound)
             m_lostContextErrors.append(error);
     }
     InspectorInstrumentation::didFireWebGLError(canvas(), errorType);
 }
 
 void WebGLRenderingContextBase::emitGLWarning(const char* functionName, const char* description)
 {
     if (m_synthesizedErrorsToConsole) {
@@ skipping 15 matching lines @@
     }
     enableOrDisable(GL_STENCIL_TEST,
                     m_stencilEnabled && haveStencilBuffer);
 }
 
 void WebGLRenderingContextBase::enableOrDisable(GLenum capability, bool enable)
 {
     if (isContextLost())
         return;
     if (enable)
-        m_context->enable(capability);
+        webContext()->enable(capability);
     else
-        m_context->disable(capability);
+        webContext()->disable(capability);
 }
 
 IntSize WebGLRenderingContextBase::clampedCanvasSize()
 {
     return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),
                    clamp(canvas()->height(), 1, m_maxViewportDims[1]));
 }
 
 GLint WebGLRenderingContextBase::maxDrawBuffers()
 {
     if (isContextLost() || !extensionEnabled(WebGLDrawBuffersName))
         return 0;
     if (!m_maxDrawBuffers)
-        m_context->getIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);
+        webContext()->getIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);
     if (!m_maxColorAttachments)
-        m_context->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
+        webContext()->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
     // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.
     return std::min(m_maxDrawBuffers, m_maxColorAttachments);
 }
 
 GLint WebGLRenderingContextBase::maxColorAttachments()
 {
     if (isContextLost() || !extensionEnabled(WebGLDrawBuffersName))
         return 0;
     if (!m_maxColorAttachments)
-        m_context->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
+        webContext()->getIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);
     return m_maxColorAttachments;
 }
 
 void WebGLRenderingContextBase::setBackDrawBuffer(GLenum buf)
 {
     m_backDrawBuffer = buf;
 }
 
 void WebGLRenderingContextBase::restoreCurrentFramebuffer()
 {
@@ skipping 34 matching lines @@
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 } // namespace WebCore