Removed most calls to GraphicsContext3D from DrawingBuffer

Source/core/html/canvas/WebGLRenderingContext.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 WebGLRenderingContext::oldestContextIndex()
 {
     if (!activeContexts().size())
         return maxGLActiveContexts;
 
     WebGLRenderingContext* candidate = activeContexts().first();
     size_t candidateID = 0;
     for (size_t ii = 1; ii < activeContexts().size(); ++ii) {
         WebGLRenderingContext* context = activeContexts()[ii];
-        if (context->graphicsContext3D() && candidate->graphicsContext3D() && context->graphicsContext3D()->lastFlushID() < candidate->graphicsContext3D()->lastFlushID()) {
+        if (context->webGraphicsContext3D() && candidate->webGraphicsContext3D() && context->webGraphicsContext3D()->lastFlushID() < candidate->webGraphicsContext3D()->lastFlushID()) {
             candidate = context;
             candidateID = ii;
         }
     }
 
     return candidateID;
 }
 
 IntSize WebGLRenderingContext::oldestContextSize()
 {
@@ skipping 382 matching lines @@
     }
 
     RefPtr<GraphicsContext3D> contextSupport(GraphicsContext3D::createContextSupport(context.get()));
 
     if (!contextSupport) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Could not create a WebGL context."));
         return nullptr;
     }
 
     if (contextSupport->supportsExtension("GL_EXT_debug_marker"))
-        contextSupport->webContext()->pushGroupMarkerEXT("WebGLRenderingContext");
+        context->pushGroupMarkerEXT("WebGLRenderingContext");
 
     OwnPtr<WebGLRenderingContext> renderingContext = adoptPtr(new WebGLRenderingContext(canvas, context.release(), contextSupport, attributes, requestedAttributes, preserveDrawingBuffer));
     renderingContext->suspendIfNeeded();
 
     if (renderingContext->m_drawingBuffer->isZeroSized()) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Could not create a WebGL context."));
         return nullptr;
     }
 
     return renderingContext.release();
@@ skipping 27 matching lines @@
     m_contextGroup = WebGLContextGroup::create();
     m_contextGroup->addContext(this);
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
     m_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 = preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-    m_drawingBuffer = DrawingBuffer::create(m_contextSupport.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
+    m_drawingBuffer = DrawingBuffer::create(m_context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
 
     if (!m_drawingBuffer->isZeroSized()) {
         m_drawingBuffer->bind();
         setupFlags();
         initializeNewContext();
     }
 
     // Register extensions.
     static const char* const webkitPrefix[] = { "WEBKIT_", 0, };
     static const char* const bothPrefixes[] = { "", "WEBKIT_", 0, };
@@ skipping 205 matching lines @@
         m_context->setErrorMessageCallback(0);
         m_context.clear();
     }
 }
 
 void WebGLRenderingContext::markContextChanged()
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
-    m_contextSupport->markContextChanged();
     m_drawingBuffer->markContentsChanged();
 
     m_layerCleared = false;
     RenderBox* renderBox = canvas()->renderBox();
     if (renderBox && renderBox->hasAcceleratedCompositing()) {
         m_markedCanvasDirty = true;
         canvas()->clearCopiedImage();
         renderBox->contentChanged(CanvasChanged);
     } else {
         if (!m_markedCanvasDirty) {
             m_markedCanvasDirty = true;
             canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
         }
     }
 }
 
 bool WebGLRenderingContext::clearIfComposited(GLbitfield mask)
 {
     if (isContextLost())
         return false;
 
-    if (!m_contextSupport->layerComposited() || m_layerCleared
+    if (!m_drawingBuffer->layerComposited() || m_layerCleared
         || m_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))
@@ skipping 44 matching lines @@
                          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);
 }
 
 void WebGLRenderingContext::markLayerComposited()
 {
     if (!isContextLost())
-        m_contextSupport->markLayerComposited();
+        m_drawingBuffer->markLayerComposited();
 }
 
 void WebGLRenderingContext::paintRenderingResultsToCanvas()
 {
     if (isContextLost()) {
         canvas()->clearPresentationCopy();
         return;
     }
 
     if (canvas()->document().printing())
         canvas()->clearPresentationCopy();
 
     // Until the canvas is written to by the application, the clear that
     // happened after it was composited should be ignored by the compositor.
-    if (m_contextSupport->layerComposited() && !m_preserveDrawingBuffer) {
+    if (m_drawingBuffer->layerComposited() && !m_preserveDrawingBuffer) {
         m_drawingBuffer->paintCompositedResultsToCanvas(canvas()->buffer());
 
         canvas()->makePresentationCopy();
     } else
         canvas()->clearPresentationCopy();
     clearIfComposited();
 
     if (!m_markedCanvasDirty && !m_layerCleared)
         return;
 
     canvas()->clearCopiedImage();
     m_markedCanvasDirty = false;
 
     m_drawingBuffer->commit();
     if (!(canvas()->buffer())->copyRenderingResultsFromDrawingBuffer(m_drawingBuffer.get()))
-        m_contextSupport->paintRenderingResultsToCanvas(canvas()->buffer(), m_drawingBuffer.get());
+        m_drawingBuffer->paintRenderingResultsToCanvas(canvas()->buffer());
 
     if (m_framebufferBinding)
         m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 }
 
 PassRefPtr<ImageData> WebGLRenderingContext::paintRenderingResultsToImageData()
 {
     if (isContextLost())
         return 0;
 
     clearIfComposited();
     m_drawingBuffer->commit();
     int width, height;
-    RefPtr<Uint8ClampedArray> imageDataPixels = m_contextSupport->paintRenderingResultsToImageData(m_drawingBuffer.get(), width, height);
+    RefPtr<Uint8ClampedArray> imageDataPixels = m_drawingBuffer->paintRenderingResultsToImageData(width, height);
     if (!imageDataPixels)
         return 0;
 
     if (m_framebufferBinding)
         m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 
     return ImageData::create(IntSize(width, height), imageDataPixels);
 }
@@ skipping 2073 matching lines @@
         } else {
             synthesizeGLError(GL_INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");
             return;
         }
         break;
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
         if (param == 1 || param == 2 || param == 4 || param == 8) {
             if (pname == GL_PACK_ALIGNMENT) {
                 m_packAlignment = param;
-                m_contextSupport->setPackAlignment(param);
+                m_drawingBuffer->setPackAlignment(param);
             } else { // GL_UNPACK_ALIGNMENT:
                 m_unpackAlignment = param;
             }
             m_context->pixelStorei(pname, param);
         } else {
             synthesizeGLError(GL_INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");
             return;
         }
         break;
     default:
@@ skipping 2382 matching lines @@
             synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
         }
         return;
     }
 
     RefPtr<WebGLRenderingContextEvictionManager> contextEvictionManager = adoptRef(new WebGLRenderingContextEvictionManager());
 
     // Construct a new drawing buffer with the new GraphicsContext3D.
     m_drawingBuffer->releaseResources();
     DrawingBuffer::PreserveDrawingBuffer preserve = m_preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
-    m_drawingBuffer = DrawingBuffer::create(contextSupport.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
+    m_drawingBuffer = DrawingBuffer::create(context.get(), clampedCanvasSize(), preserve, contextEvictionManager.release());
 
     if (m_drawingBuffer->isZeroSized())
         return;
 
     m_drawingBuffer->bind();
 
     m_lostContextErrors.clear();
 
     m_contextSupport = contextSupport;
     m_context = context.release();
@@ skipping 191 matching lines @@
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 } // namespace WebCore