Changeset 127063 in webkit

Timestamp:

Aug 29, 2012 4:12:45 PM (12 years ago)

Author:

commit-queue@webkit.org

Message:

[Texmap] Move TextureMapperGL to use GraphicsContext3D
​https://bugs.webkit.org/show_bug.cgi?id=78672

Patch by Roland Takacs <​rtakacs@inf.u-szeged.hu>, Helder Correia <Helder Correia> on 2012-08-29
Reviewed by Noam Rosenthal.

It is based on a previous patch by Helder Correia.

TextureMapperGL (TMGL) includes direct GL calls and
GraphicsContext3D (GC3D) offers many conveniences over the
former approach: using existing CSS shader code, ANGLE for
shader compilation, reusing WebCore::Texture, having shaders and
textures that can delete themselves.

A GC3D object is created by TMGL with the newly introduced
builder createForCurrentGLContext(), which in turn uses
the new RenderToCurrentGLContext flag underneath.

TMGL's dependency on OpenGLShims.h was completely removed.
However, GC3D does not map every single GL constant. Thus, it's
important to document the following:

• GL_FALSE was mapped to false.
• GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_TEXTURE_RECTANGLE_ARB, and GL_UNSIGNED_INT_8_8_8_8_REV were locally defined in TMGL.

The patch was originally developed by Helder Correia and finished
by Roland Takacs.

No new tests, refactoring.

• platform/graphics/GraphicsContext3D.h:
• platform/graphics/texmap/TextureMapperGL.cpp:

(SharedGLData):
(WebCore::TextureMapperGLData::SharedGLData::currentSharedGLData):
(WebCore::TextureMapperGLData::SharedGLData::SharedGLData):
(WebCore::TextureMapperGLData::sharedGLData):
(WebCore::TextureMapperGLData::TextureMapperGLData):
(TextureMapperGLData):
(WebCore::scissorClip):
(WebCore::TextureMapperGL::ClipStack::apply):
(WebCore::TextureMapperGLData::initializeStencil):
(WebCore::TextureMapperGL::TextureMapperGL):
(WebCore::TextureMapperGL::beginPainting):
(WebCore::TextureMapperGL::endPainting):
(WebCore::TextureMapperGL::drawQuad):
(WebCore::TextureMapperGL::drawBorder):
(WebCore):
(WebCore::TextureMapperGL::drawTextureRectangleARB):
(WebCore::TextureMapperGL::drawTexture):
(WebCore::viewportMatrix):
(WebCore::TextureMapperGL::drawTextureWithAntialiasing):
(WebCore::TextureMapperGL::drawTexturedQuadWithProgram):
(WebCore::BitmapTextureGL::didReset):
(WebCore::BitmapTextureGL::updateContents):
(WebCore::TextureMapperGL::drawFiltered):
(WebCore::BitmapTextureGL::initializeStencil):
(WebCore::BitmapTextureGL::clearIfNeeded):
(WebCore::BitmapTextureGL::createFboIfNeeded):
(WebCore::BitmapTextureGL::bind):
(WebCore::BitmapTextureGL::~BitmapTextureGL):
(WebCore::TextureMapperGL::bindDefaultSurface):
(WebCore::TextureMapperGL::beginScissorClip):
(WebCore::TextureMapperGL::beginClip):
(WebCore::TextureMapperGL::endClip):
(WebCore::TextureMapperGL::createTexture):

• platform/graphics/texmap/TextureMapperGL.h:

(WebCore::TextureMapperGL::graphicsContext3D):
(TextureMapperGL):
(ClipStack):
(WebCore::BitmapTextureGL::textureTarget):
(BitmapTextureGL):
(WebCore::BitmapTextureGL::BitmapTextureGL):

• platform/graphics/texmap/TextureMapperShaderManager.cpp:

(WebCore):
(WebCore::TextureMapperShaderManager::getShaderProgram):
(WebCore::TextureMapperShaderProgram::TextureMapperShaderProgram):
(WebCore::TextureMapperShaderProgram::initializeProgram):
(WebCore::TextureMapperShaderProgram::getUniformLocation):
(WebCore::TextureMapperShaderProgram::~TextureMapperShaderProgram):
(WebCore::TextureMapperShaderProgramSimple::TextureMapperShaderProgramSimple):
(WebCore::TextureMapperShaderProgramSolidColor::TextureMapperShaderProgramSolidColor):
(WebCore::TextureMapperShaderProgramRectSimple::TextureMapperShaderProgramRectSimple):
(WebCore::TextureMapperShaderProgramOpacityAndMask::TextureMapperShaderProgramOpacityAndMask):
(WebCore::TextureMapperShaderProgramRectOpacityAndMask::TextureMapperShaderProgramRectOpacityAndMask):
(WebCore::TextureMapperShaderProgramAntialiasingNoMask::TextureMapperShaderProgramAntialiasingNoMask):
(WebCore::TextureMapperShaderManager::TextureMapperShaderManager):
(WebCore::StandardFilterProgram::~StandardFilterProgram):
(WebCore::StandardFilterProgram::StandardFilterProgram):
(WebCore::StandardFilterProgram::create):
(WebCore::StandardFilterProgram::prepare):
(WebCore::TextureMapperShaderManager::getShaderForFilter):

• platform/graphics/texmap/TextureMapperShaderManager.h:

(WebCore::TextureMapperShaderProgram::id):
(WebCore::TextureMapperShaderProgram::vertexAttrib):
(TextureMapperShaderProgram):
(WebCore::TextureMapperShaderProgram::matrixLocation):
(WebCore::TextureMapperShaderProgram::flipLocation):
(WebCore::TextureMapperShaderProgram::textureSizeLocation):
(WebCore::TextureMapperShaderProgram::sourceTextureLocation):
(WebCore::TextureMapperShaderProgram::maskTextureLocation):
(WebCore::TextureMapperShaderProgram::opacityLocation):
(WebCore::TextureMapperShaderProgram::isValidUniformLocation):
(StandardFilterProgram):
(WebCore::StandardFilterProgram::vertexAttrib):
(WebCore::StandardFilterProgram::texCoordAttrib):
(WebCore::StandardFilterProgram::textureUniform):
(WebCore::TextureMapperShaderProgramSimple::create):
(TextureMapperShaderProgramSimple):
(WebCore::TextureMapperShaderProgramRectSimple::create):
(TextureMapperShaderProgramRectSimple):
(WebCore::TextureMapperShaderProgramOpacityAndMask::create):
(TextureMapperShaderProgramOpacityAndMask):
(WebCore::TextureMapperShaderProgramRectOpacityAndMask::create):
(TextureMapperShaderProgramRectOpacityAndMask):
(WebCore::TextureMapperShaderProgramSolidColor::create):
(WebCore::TextureMapperShaderProgramSolidColor::colorLocation):
(TextureMapperShaderProgramSolidColor):
(WebCore::TextureMapperShaderProgramAntialiasingNoMask::create):
(WebCore::TextureMapperShaderProgramAntialiasingNoMask::expandedQuadVerticesInTextureCoordinatesLocation):
(WebCore::TextureMapperShaderProgramAntialiasingNoMask::expandedQuadEdgesInScreenSpaceLocation):
(TextureMapperShaderProgramAntialiasingNoMask):
(WebCore::TextureMapperShaderManager::TextureMapperShaderManager):
(TextureMapperShaderManager):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/GraphicsContext3D.h (modified) (1 diff)
• platform/graphics/texmap/TextureMapperGL.cpp (modified) (41 diffs)
• platform/graphics/texmap/TextureMapperGL.h (modified) (10 diffs)
• platform/graphics/texmap/TextureMapperShaderManager.cpp (modified) (34 diffs)
• platform/graphics/texmap/TextureMapperShaderManager.h (modified) (12 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-08-29  Roland Takacs  <rtakacs@inf.u-szeged.hu>, Helder Correia  <helder.correia@nokia.com>
+
+        [Texmap] Move TextureMapperGL to use GraphicsContext3D
+        https://bugs.webkit.org/show_bug.cgi?id=78672
+
+        Reviewed by Noam Rosenthal.
+
+        It is based on a previous patch by Helder Correia.
+
+        TextureMapperGL (TMGL) includes direct GL calls and
+        GraphicsContext3D (GC3D) offers many conveniences over the
+        former approach: using existing CSS shader code, ANGLE for
+        shader compilation, reusing WebCore::Texture, having shaders and
+        textures that can delete themselves.
+
+        A GC3D object is created by TMGL with the newly introduced
+        builder createForCurrentGLContext(), which in turn uses
+        the new RenderToCurrentGLContext flag underneath.
+
+        TMGL's dependency on OpenGLShims.h was completely removed.
+        However, GC3D does not map every single GL constant. Thus, it's
+        important to document the following:
+            - GL_FALSE was mapped to false.
+            - GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS,
+            GL_UNPACK_SKIP_ROWS, GL_TEXTURE_RECTANGLE_ARB, and
+            GL_UNSIGNED_INT_8_8_8_8_REV were locally defined in TMGL.
+
+        The patch was originally developed by Helder Correia and finished
+        by Roland Takacs.
+
+        No new tests, refactoring.
+
+        * platform/graphics/GraphicsContext3D.h:
+        * platform/graphics/texmap/TextureMapperGL.cpp:
+        (SharedGLData):
+        (WebCore::TextureMapperGLData::SharedGLData::currentSharedGLData):
+        (WebCore::TextureMapperGLData::SharedGLData::SharedGLData):
+        (WebCore::TextureMapperGLData::sharedGLData):
+        (WebCore::TextureMapperGLData::TextureMapperGLData):
+        (TextureMapperGLData):
+        (WebCore::scissorClip):
+        (WebCore::TextureMapperGL::ClipStack::apply):
+        (WebCore::TextureMapperGLData::initializeStencil):
+        (WebCore::TextureMapperGL::TextureMapperGL):
+        (WebCore::TextureMapperGL::beginPainting):
+        (WebCore::TextureMapperGL::endPainting):
+        (WebCore::TextureMapperGL::drawQuad):
+        (WebCore::TextureMapperGL::drawBorder):
+        (WebCore):
+        (WebCore::TextureMapperGL::drawTextureRectangleARB):
+        (WebCore::TextureMapperGL::drawTexture):
+        (WebCore::viewportMatrix):
+        (WebCore::TextureMapperGL::drawTextureWithAntialiasing):
+        (WebCore::TextureMapperGL::drawTexturedQuadWithProgram):
+        (WebCore::BitmapTextureGL::didReset):
+        (WebCore::BitmapTextureGL::updateContents):
+        (WebCore::TextureMapperGL::drawFiltered):
+        (WebCore::BitmapTextureGL::initializeStencil):
+        (WebCore::BitmapTextureGL::clearIfNeeded):
+        (WebCore::BitmapTextureGL::createFboIfNeeded):
+        (WebCore::BitmapTextureGL::bind):
+        (WebCore::BitmapTextureGL::~BitmapTextureGL):
+        (WebCore::TextureMapperGL::bindDefaultSurface):
+        (WebCore::TextureMapperGL::beginScissorClip):
+        (WebCore::TextureMapperGL::beginClip):
+        (WebCore::TextureMapperGL::endClip):
+        (WebCore::TextureMapperGL::createTexture):
+        * platform/graphics/texmap/TextureMapperGL.h:
+        (WebCore::TextureMapperGL::graphicsContext3D):
+        (TextureMapperGL):
+        (ClipStack):
+        (WebCore::BitmapTextureGL::textureTarget):
+        (BitmapTextureGL):
+        (WebCore::BitmapTextureGL::BitmapTextureGL):
+        * platform/graphics/texmap/TextureMapperShaderManager.cpp:
+        (WebCore):
+        (WebCore::TextureMapperShaderManager::getShaderProgram):
+        (WebCore::TextureMapperShaderProgram::TextureMapperShaderProgram):
+        (WebCore::TextureMapperShaderProgram::initializeProgram):
+        (WebCore::TextureMapperShaderProgram::getUniformLocation):
+        (WebCore::TextureMapperShaderProgram::~TextureMapperShaderProgram):
+        (WebCore::TextureMapperShaderProgramSimple::TextureMapperShaderProgramSimple):
+        (WebCore::TextureMapperShaderProgramSolidColor::TextureMapperShaderProgramSolidColor):
+        (WebCore::TextureMapperShaderProgramRectSimple::TextureMapperShaderProgramRectSimple):
+        (WebCore::TextureMapperShaderProgramOpacityAndMask::TextureMapperShaderProgramOpacityAndMask):
+        (WebCore::TextureMapperShaderProgramRectOpacityAndMask::TextureMapperShaderProgramRectOpacityAndMask):
+        (WebCore::TextureMapperShaderProgramAntialiasingNoMask::TextureMapperShaderProgramAntialiasingNoMask):
+        (WebCore::TextureMapperShaderManager::TextureMapperShaderManager):
+        (WebCore::StandardFilterProgram::~StandardFilterProgram):
+        (WebCore::StandardFilterProgram::StandardFilterProgram):
+        (WebCore::StandardFilterProgram::create):
+        (WebCore::StandardFilterProgram::prepare):
+        (WebCore::TextureMapperShaderManager::getShaderForFilter):
+        * platform/graphics/texmap/TextureMapperShaderManager.h:
+        (WebCore::TextureMapperShaderProgram::id):
+        (WebCore::TextureMapperShaderProgram::vertexAttrib):
+        (TextureMapperShaderProgram):
+        (WebCore::TextureMapperShaderProgram::matrixLocation):
+        (WebCore::TextureMapperShaderProgram::flipLocation):
+        (WebCore::TextureMapperShaderProgram::textureSizeLocation):
+        (WebCore::TextureMapperShaderProgram::sourceTextureLocation):
+        (WebCore::TextureMapperShaderProgram::maskTextureLocation):
+        (WebCore::TextureMapperShaderProgram::opacityLocation):
+        (WebCore::TextureMapperShaderProgram::isValidUniformLocation):
+        (StandardFilterProgram):
+        (WebCore::StandardFilterProgram::vertexAttrib):
+        (WebCore::StandardFilterProgram::texCoordAttrib):
+        (WebCore::StandardFilterProgram::textureUniform):
+        (WebCore::TextureMapperShaderProgramSimple::create):
+        (TextureMapperShaderProgramSimple):
+        (WebCore::TextureMapperShaderProgramRectSimple::create):
+        (TextureMapperShaderProgramRectSimple):
+        (WebCore::TextureMapperShaderProgramOpacityAndMask::create):
+        (TextureMapperShaderProgramOpacityAndMask):
+        (WebCore::TextureMapperShaderProgramRectOpacityAndMask::create):
+        (TextureMapperShaderProgramRectOpacityAndMask):
+        (WebCore::TextureMapperShaderProgramSolidColor::create):
+        (WebCore::TextureMapperShaderProgramSolidColor::colorLocation):
+        (TextureMapperShaderProgramSolidColor):
+        (WebCore::TextureMapperShaderProgramAntialiasingNoMask::create):
+        (WebCore::TextureMapperShaderProgramAntialiasingNoMask::expandedQuadVerticesInTextureCoordinatesLocation):
+        (WebCore::TextureMapperShaderProgramAntialiasingNoMask::expandedQuadEdgesInScreenSpaceLocation):
+        (TextureMapperShaderProgramAntialiasingNoMask):
+        (WebCore::TextureMapperShaderManager::TextureMapperShaderManager):
+        (TextureMapperShaderManager):
+
 2012-08-29  Adam Barth  <abarth@webkit.org>
 

trunk/Source/WebCore/platform/graphics/GraphicsContext3D.h

@@ -251 +251 @@
         RGB = 0x1907,
         RGBA = 0x1908,
+        BGRA = 0x80E1,
         LUMINANCE = 0x1909,
         LUMINANCE_ALPHA = 0x190A,

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

@@ -39 +39 @@
 #if PLATFORM(QT)
 #include "NativeImageQt.h"
-#include <QOpenGLContext>
-#elif OS(WINDOWS)
-#include <windows.h>
-#elif OS(MAC_OS_X)
-#include <AGL/agl.h>
-#elif defined(XP_UNIX)
-#include <GL/glx.h>
 #endif
 
@@ -54 +47 @@
 #endif
 
-#define GL_CMD(...) do { __VA_ARGS__; ASSERT_ARG(__VA_ARGS__, !glGetError()); } while (0)
+#if !USE(TEXMAP_OPENGL_ES_2)
+// FIXME: Move to Extensions3D.h.
+#define GL_TEXTURE_RECTANGLE_ARB 0x84F5
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#endif
+
 namespace WebCore {
 struct TextureMapperGLData {
     struct SharedGLData : public RefCounted<SharedGLData> {
-#if PLATFORM(QT)
-        typedef QOpenGLContext* GLContext;
-        static GLContext getCurrentGLContext()
-        {
-            return QOpenGLContext::currentContext();
-        }
-#elif OS(WINDOWS)
-        typedef HGLRC GLContext;
-        static GLContext getCurrentGLContext()
-        {
-            return wglGetCurrentContext();
-        }
-#elif OS(MAC_OS_X)
-        typedef AGLContext GLContext;
-        static GLContext getCurrentGLContext()
-        {
-            return aglGetCurrentContext();
-        }
-#elif defined(XP_UNIX)
-        typedef GLXContext GLContext;
-        static GLContext getCurrentGLContext()
-        {
-            return glXGetCurrentContext();
-        }
-#else
-        // Default implementation for unknown opengl.
-        // Returns always increasing number and disables GL context data sharing.
-        typedef unsigned int GLContext;
-        static GLContext getCurrentGLContext()
-        {
-            static GLContext dummyContextCounter = 0;
-            return ++dummyContextCounter;
-        }
-
-#endif
-
-        typedef HashMap<GLContext, SharedGLData*> GLContextDataMap;
+
+        typedef HashMap<PlatformGraphicsContext3D, SharedGLData*> GLContextDataMap;
         static GLContextDataMap& glContextDataMap()
         {
@@ -101 +67 @@
         }
 
-        static PassRefPtr<SharedGLData> currentSharedGLData()
+        static PassRefPtr<SharedGLData> currentSharedGLData(GraphicsContext3D* context)
         {
-            GLContext currentGLConext = getCurrentGLContext();
-            GLContextDataMap::iterator it = glContextDataMap().find(currentGLConext);
+            GLContextDataMap::iterator it = glContextDataMap().find(context->platformGraphicsContext3D());
             if (it != glContextDataMap().end())
                 return it->second;
 
-            return adoptRef(new SharedGLData(getCurrentGLContext()));
+            return adoptRef(new SharedGLData(context));
         }
 
@@ -115 +80 @@
         TextureMapperShaderManager textureMapperShaderManager;
 
-        SharedGLData(GLContext glContext)
+        SharedGLData(GraphicsContext3D* context)
+            : textureMapperShaderManager(context)
         {
-            glContextDataMap().add(glContext, this);
+            glContextDataMap().add(context->platformGraphicsContext3D(), this);
         }
 
@@ -136 +102 @@
     SharedGLData& sharedGLData() const
     {
-        return *(m_sharedGLData.get());
+        return *m_sharedGLData;
     }
 
     void initializeStencil();
 
-    TextureMapperGLData()
-        : PaintFlags(0)
+    TextureMapperGLData(GraphicsContext3D* context)
+        : context(context)
+        , PaintFlags(0)
         , previousProgram(0)
         , targetFrameBuffer(0)
@@ -148 +115 @@
         , previousScissorState(0)
         , previousDepthState(0)
-        , m_sharedGLData(TextureMapperGLData::SharedGLData::currentSharedGLData())
+        , m_sharedGLData(TextureMapperGLData::SharedGLData::currentSharedGLData(this->context))
     { }
 
+    GraphicsContext3D* context;
     TransformationMatrix projectionMatrix;
     TextureMapper::PaintFlags PaintFlags;
-    GLint previousProgram;
-    GLint targetFrameBuffer;
+    GC3Dint previousProgram;
+    GC3Dint targetFrameBuffer;
     bool didModifyStencil;
-    GLint previousScissorState;
-    GLint previousDepthState;
-    GLint viewport[4];
-    GLint previousScissor[4];
+    GC3Dint previousScissorState;
+    GC3Dint previousDepthState;
+    GC3Dint viewport[4];
+    GC3Dint previousScissor[4];
     RefPtr<SharedGLData> m_sharedGLData;
     RefPtr<BitmapTexture> currentSurface;
@@ -183 +151 @@
 }
 
-static void scissorClip(const IntRect& rect)
+static void scissorClip(GraphicsContext3D* context, const IntRect& rect)
 {
     if (rect.isEmpty())
         return;
 
-    GLint viewport[4];
-    GL_CMD(glGetIntegerv(GL_VIEWPORT, viewport));
-    GL_CMD(glScissor(rect.x(), viewport[3] - rect.maxY(), rect.width(), rect.height()));
-}
-
-void TextureMapperGL::ClipStack::apply()
-{
-    scissorClip(clipState.scissorBox);
-    GL_CMD(glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
-    GL_CMD(glStencilFunc(GL_EQUAL, clipState.stencilIndex - 1, clipState.stencilIndex - 1));
+    GC3Dint viewport[4];
+    context->getIntegerv(GraphicsContext3D::VIEWPORT, viewport);
+    context->scissor(rect.x(), viewport[3] - rect.maxY(), rect.width(), rect.height());
+}
+
+void TextureMapperGL::ClipStack::apply(GraphicsContext3D* context)
+{
+    scissorClip(context, clipState.scissorBox);
+    context->stencilOp(GraphicsContext3D::KEEP, GraphicsContext3D::KEEP, GraphicsContext3D::KEEP);
+    context->stencilFunc(GraphicsContext3D::EQUAL, clipState.stencilIndex - 1, clipState.stencilIndex - 1);
     if (clipState.stencilIndex == 1)
-        GL_CMD(glDisable(GL_STENCIL_TEST));
+        context->disable(GraphicsContext3D::STENCIL_TEST);
     else
-        GL_CMD(glEnable(GL_STENCIL_TEST));
+        context->enable(GraphicsContext3D::STENCIL_TEST);
 }
 
@@ -215 +183 @@
         return;
 
-    GL_CMD(glClearStencil(0));
-    GL_CMD(glClear(GL_STENCIL_BUFFER_BIT));
+    context->clearStencil(0);
+    context->clear(GraphicsContext3D::STENCIL_BUFFER_BIT);
     didModifyStencil = true;
 }
@@ -230 +198 @@
 TextureMapperGL::TextureMapperGL()
     : TextureMapper(OpenGLMode)
-    , m_data(new TextureMapperGLData)
     , m_context(0)
     , m_enableEdgeDistanceAntialiasing(false)
 {
+    m_context3D = GraphicsContext3D::createForCurrentGLContext();
+    m_data = new TextureMapperGLData(m_context3D.get());
 }
 
@@ -243 +212 @@
 void TextureMapperGL::beginPainting(PaintFlags flags)
 {
-    // Make sure that no GL error code stays from previous operations.
-    glGetError();
-
-    if (!initializeOpenGLShims())
-        return;
-
-    GL_CMD(glGetIntegerv(GL_CURRENT_PROGRAM, &data().previousProgram));
-    data().previousScissorState = glIsEnabled(GL_SCISSOR_TEST);
-    data().previousDepthState = glIsEnabled(GL_DEPTH_TEST);
+    m_context3D->getIntegerv(GraphicsContext3D::CURRENT_PROGRAM, &data().previousProgram);
+    data().previousScissorState = m_context3D->isEnabled(GraphicsContext3D::SCISSOR_TEST);
+    data().previousDepthState = m_context3D->isEnabled(GraphicsContext3D::DEPTH_TEST);
 #if PLATFORM(QT)
     if (m_context) {
@@ -259 +222 @@
     }
 #endif
-    glDisable(GL_DEPTH_TEST);
-    glEnable(GL_SCISSOR_TEST);
+    m_context3D->disable(GraphicsContext3D::DEPTH_TEST);
+    m_context3D->enable(GraphicsContext3D::SCISSOR_TEST);
     data().didModifyStencil = false;
-    GL_CMD(glDepthMask(0));
-    GL_CMD(glGetIntegerv(GL_VIEWPORT, data().viewport));
-    GL_CMD(glGetIntegerv(GL_SCISSOR_BOX, data().previousScissor));
+    m_context3D->depthMask(0);
+    m_context3D->getIntegerv(GraphicsContext3D::VIEWPORT, data().viewport);
+    m_context3D->getIntegerv(GraphicsContext3D::SCISSOR_BOX, data().previousScissor);
     m_clipStack.init(IntRect(0, 0, data().viewport[2], data().viewport[3]));
-    GL_CMD(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &data().targetFrameBuffer));
+    m_context3D->getIntegerv(GraphicsContext3D::FRAMEBUFFER_BINDING, &data().targetFrameBuffer);
     data().PaintFlags = flags;
     bindSurface(0);
@@ -274 +237 @@
 {
     if (data().didModifyStencil) {
-        glClearStencil(1);
-        glClear(GL_STENCIL_BUFFER_BIT);
-    }
-
-    glUseProgram(data().previousProgram);
-
-    glScissor(data().previousScissor[0], data().previousScissor[1], data().previousScissor[2], data().previousScissor[3]);
+        m_context3D->clearStencil(1);
+        m_context3D->clear(GraphicsContext3D::STENCIL_BUFFER_BIT);
+    }
+
+    m_context3D->useProgram(data().previousProgram);
+
+    m_context3D->scissor(data().previousScissor[0], data().previousScissor[1], data().previousScissor[2], data().previousScissor[3]);
     if (data().previousScissorState)
-        glEnable(GL_SCISSOR_TEST);
+        m_context3D->enable(GraphicsContext3D::SCISSOR_TEST);
     else
-        glDisable(GL_SCISSOR_TEST);
+        m_context3D->disable(GraphicsContext3D::SCISSOR_TEST);
 
     if (data().previousDepthState)
-        glEnable(GL_DEPTH_TEST);
+        m_context3D->enable(GraphicsContext3D::DEPTH_TEST);
     else
-        glDisable(GL_DEPTH_TEST);
+        m_context3D->disable(GraphicsContext3D::DEPTH_TEST);
 
 #if PLATFORM(QT)
@@ -300 +263 @@
 }
 
-void TextureMapperGL::drawQuad(const DrawQuad& quadToDraw, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram* shaderProgram, GLenum drawingMode, bool needsBlending)
-{
-    GL_CMD(glEnableVertexAttribArray(shaderProgram->vertexAttrib()));
-    GL_CMD(glBindBuffer(GL_ARRAY_BUFFER, 0));
-
-    const GLfloat quad[] = {
+void TextureMapperGL::drawQuad(const DrawQuad& quadToDraw, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram* shaderProgram, GC3Denum drawingMode, bool needsBlending)
+{
+    m_context3D->enableVertexAttribArray(shaderProgram->vertexAttrib());
+    m_context3D->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, 0);
+
+    const GC3Dfloat quad[] = {
         quadToDraw.targetRectMappedToUnitSquare.p1().x(), quadToDraw.targetRectMappedToUnitSquare.p1().y(),
         quadToDraw.targetRectMappedToUnitSquare.p2().x(), quadToDraw.targetRectMappedToUnitSquare.p2().y(),
@@ -311 +274 @@
         quadToDraw.targetRectMappedToUnitSquare.p4().x(), quadToDraw.targetRectMappedToUnitSquare.p4().y()
     };
-    GL_CMD(glVertexAttribPointer(shaderProgram->vertexAttrib(), 2, GL_FLOAT, GL_FALSE, 0, quad));
+    m_context3D->vertexAttribPointer(shaderProgram->vertexAttrib(), 2, GraphicsContext3D::FLOAT, false, 0, GC3Dintptr(quad));
 
     TransformationMatrix matrix = TransformationMatrix(data().projectionMatrix).multiply(modelViewMatrix).multiply(TransformationMatrix(
@@ -318 +281 @@
             0, 0, 1, 0,
             quadToDraw.originalTargetRect.x(), quadToDraw.originalTargetRect.y(), 0, 1));
-    const GLfloat m4[] = {
+    GC3Dfloat m4[] = {
         matrix.m11(), matrix.m12(), matrix.m13(), matrix.m14(),
         matrix.m21(), matrix.m22(), matrix.m23(), matrix.m24(),
@@ -324 +287 @@
         matrix.m41(), matrix.m42(), matrix.m43(), matrix.m44()
     };
-    GL_CMD(glUniformMatrix4fv(shaderProgram->matrixLocation(), 1, GL_FALSE, m4));
+    m_context3D->uniformMatrix4fv(shaderProgram->matrixLocation(), 1, false, m4);
 
     if (needsBlending) {
-        GL_CMD(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
-        GL_CMD(glEnable(GL_BLEND));
+        m_context3D->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA);
+        m_context3D->enable(GraphicsContext3D::BLEND);
     } else
-        GL_CMD(glDisable(GL_BLEND));
-
-    GL_CMD(glDrawArrays(drawingMode, 0, 4));
-    GL_CMD(glDisableVertexAttribArray(shaderProgram->vertexAttrib()));
+        m_context3D->disable(GraphicsContext3D::BLEND);
+
+    m_context3D->drawArrays(drawingMode, 0, 4);
+    m_context3D->disableVertexAttribArray(shaderProgram->vertexAttrib());
 }
 
@@ -342 +305 @@
 
     RefPtr<TextureMapperShaderProgramSolidColor> program = data().sharedGLData().textureMapperShaderManager.solidColorProgram();
-    GL_CMD(glUseProgram(program->id()));
+    m_context3D->useProgram(program->id());
 
     float alpha = color.alpha() / 255.0;
-    GL_CMD(glUniform4f(program->colorLocation(),
+    m_context3D->uniform4f(program->colorLocation(),
                        (color.red() / 255.0) * alpha,
                        (color.green() / 255.0) * alpha,
                        (color.blue() / 255.0) * alpha,
-                       alpha));
-    GL_CMD(glLineWidth(width));
-
-    drawQuad(targetRect, modelViewMatrix, program.get(), GL_LINE_LOOP, color.hasAlpha());
+                       alpha);
+    m_context3D->lineWidth(width);
+
+    drawQuad(targetRect, modelViewMatrix, program.get(), GraphicsContext3D::LINE_LOOP, color.hasAlpha());
 }
 
@@ -399 +362 @@
 }
 
-#if defined(GL_ARB_texture_rectangle)
+#if !USE(TEXMAP_OPENGL_ES_2)
 void TextureMapperGL::drawTextureRectangleARB(uint32_t texture, Flags flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture)
 {
@@ -407 +370 @@
     else
         program = data().sharedGLData().textureMapperShaderManager.getShaderProgram(TextureMapperShaderManager::RectSimple);
-    GL_CMD(glUseProgram(program->id()));
-
-    GL_CMD(glEnableVertexAttribArray(program->vertexAttrib()));
-    GL_CMD(glActiveTexture(GL_TEXTURE0));
-    GL_CMD(glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture));
-    GL_CMD(glUniform1i(program->sourceTextureLocation(), 0));
-
-    GL_CMD(glUniform1f(program->flipLocation(), !!(flags & ShouldFlipTexture)));
-    GL_CMD(glUniform2f(program->textureSizeLocation(), textureSize.width(), textureSize.height()));
+    m_context3D->useProgram(program->id());
+
+    m_context3D->enableVertexAttribArray(program->vertexAttrib());
+    m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);
+    m_context3D->bindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);
+    m_context3D->uniform1i(program->sourceTextureLocation(), 0);
+
+    m_context3D->uniform1f(program->flipLocation(), !!(flags & ShouldFlipTexture));
+    m_context3D->uniform2f(program->textureSizeLocation(), textureSize.width(), textureSize.height());
 
     if (TextureMapperShaderProgram::isValidUniformLocation(program->opacityLocation()))
-        GL_CMD(glUniform1f(program->opacityLocation(), opacity));
+        m_context3D->uniform1f(program->opacityLocation(), opacity);
 
     if (maskTexture && maskTexture->isValid() && TextureMapperShaderProgram::isValidUniformLocation(program->maskTextureLocation())) {
         const BitmapTextureGL* maskTextureGL = static_cast<const BitmapTextureGL*>(maskTexture);
-        GL_CMD(glActiveTexture(GL_TEXTURE1));
-        GL_CMD(glBindTexture(GL_TEXTURE_2D, maskTextureGL->id()));
-        GL_CMD(glUniform1i(program->maskTextureLocation(), 1));
-        GL_CMD(glActiveTexture(GL_TEXTURE0));
+        m_context3D->activeTexture(GraphicsContext3D::TEXTURE1);
+        m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, maskTextureGL->id());
+        m_context3D->uniform1i(program->maskTextureLocation(), 1);
+        m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);
     }
 
     bool needsBlending = (flags & SupportsBlending) || opacity < 0.99 || maskTexture;
-    drawQuad(targetRect, modelViewMatrix, program.get(), GL_TRIANGLE_FAN, needsBlending);
-}
-#endif // defined(GL_ARB_texture_rectangle) 
+    drawQuad(targetRect, modelViewMatrix, program.get(), GraphicsContext3D::TRIANGLE_FAN, needsBlending);
+}
+#endif // !USE(TEXMAP_OPENGL_ES_2)
 
 void TextureMapperGL::drawTexture(uint32_t texture, Flags flags, const IntSize& /* textureSize */, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture, unsigned exposedEdges)
 {
-    bool needsAntiliaing = m_enableEdgeDistanceAntialiasing && !modelViewMatrix.isIntegerTranslation();
-    if (needsAntiliaing && drawTextureWithAntialiasing(texture, flags, targetRect, modelViewMatrix, opacity, maskTexture, exposedEdges))
+    bool needsAntialiasing = m_enableEdgeDistanceAntialiasing && !modelViewMatrix.isIntegerTranslation();
+    if (needsAntialiasing && drawTextureWithAntialiasing(texture, flags, targetRect, modelViewMatrix, opacity, maskTexture, exposedEdges))
        return;
 
@@ -444 +407 @@
     else
         program = data().sharedGLData().textureMapperShaderManager.getShaderProgram(TextureMapperShaderManager::Simple);
-    GL_CMD(glUseProgram(program->id()));
+    m_context3D->useProgram(program->id());
 
     drawTexturedQuadWithProgram(program.get(), texture, flags, targetRect, modelViewMatrix, opacity, maskTexture);
 }
 
-static TransformationMatrix viewportMatrix()
-{
-    GLint viewport[4];
-    GL_CMD(glGetIntegerv(GL_VIEWPORT, viewport));
+static TransformationMatrix viewportMatrix(GraphicsContext3D* context3D)
+{
+    GC3Dint viewport[4];
+    context3D->getIntegerv(GraphicsContext3D::VIEWPORT, viewport);
 
     TransformationMatrix matrix;
@@ -549 +512 @@
     // translates from normalized device coordinates to screen coordinates), because these
     // values are consumed in the fragment shader, which works in screen coordinates.
-    TransformationMatrix screenSpaceTransform = viewportMatrix().multiply(TransformationMatrix(data().projectionMatrix)).multiply(modelViewMatrix).to2dTransform();
+    TransformationMatrix screenSpaceTransform = viewportMatrix(m_context3D.get()).multiply(TransformationMatrix(data().projectionMatrix)).multiply(modelViewMatrix).to2dTransform();
     if (!screenSpaceTransform.isInvertible())
         return false;
@@ -573 +536 @@
 
     RefPtr<TextureMapperShaderProgramAntialiasingNoMask> program = data().sharedGLData().textureMapperShaderManager.antialiasingNoMaskProgram();
-    GL_CMD(glUseProgram(program->id()));
-    GL_CMD(glUniform3fv(program->expandedQuadEdgesInScreenSpaceLocation(), 8, targetQuadEdges));
+    m_context3D->useProgram(program->id());
+    m_context3D->uniform3fv(program->expandedQuadEdgesInScreenSpaceLocation(), 8, targetQuadEdges);
 
     drawTexturedQuadWithProgram(program.get(), texture, flags, DrawQuad(originalTargetRect, expandedQuadInTextureCoordinates), modelViewMatrix, opacity, 0 /* maskTexture */);
@@ -582 +545 @@
 void TextureMapperGL::drawTexturedQuadWithProgram(TextureMapperShaderProgram* program, uint32_t texture, Flags flags, const DrawQuad& quadToDraw, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture)
 {
-    GL_CMD(glEnableVertexAttribArray(program->vertexAttrib()));
-    GL_CMD(glActiveTexture(GL_TEXTURE0));
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, texture));
-    GL_CMD(glUniform1i(program->sourceTextureLocation(), 0));
-
-    GL_CMD(glUniform1f(program->flipLocation(), !!(flags & ShouldFlipTexture)));
+    m_context3D->enableVertexAttribArray(program->vertexAttrib());
+    m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);
+    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, texture);
+    m_context3D->uniform1i(program->sourceTextureLocation(), 0);
+
+    m_context3D->uniform1f(program->flipLocation(), !!(flags & ShouldFlipTexture));
 
     if (TextureMapperShaderProgram::isValidUniformLocation(program->opacityLocation()))
-        GL_CMD(glUniform1f(program->opacityLocation(), opacity));
+        m_context3D->uniform1f(program->opacityLocation(), opacity);
 
     if (maskTexture && maskTexture->isValid() && TextureMapperShaderProgram::isValidUniformLocation(program->maskTextureLocation())) {
         const BitmapTextureGL* maskTextureGL = static_cast<const BitmapTextureGL*>(maskTexture);
-        GL_CMD(glActiveTexture(GL_TEXTURE1));
-        GL_CMD(glBindTexture(GL_TEXTURE_2D, maskTextureGL->id()));
-        GL_CMD(glUniform1i(program->maskTextureLocation(), 1));
-        GL_CMD(glActiveTexture(GL_TEXTURE0));
+        m_context3D->activeTexture(GraphicsContext3D::TEXTURE1);
+        m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, maskTextureGL->id());
+        m_context3D->uniform1i(program->maskTextureLocation(), 1);
+        m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);
     }
 
     bool needsBlending = (flags & SupportsBlending) || opacity < 0.99 || maskTexture;
-    drawQuad(quadToDraw, modelViewMatrix, program, GL_TRIANGLE_FAN, needsBlending);
+    drawQuad(quadToDraw, modelViewMatrix, program, GraphicsContext3D::TRIANGLE_FAN, needsBlending);
 }
 
@@ -612 +575 @@
 #define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
 #else
-#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GL_UNSIGNED_BYTE
+#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GraphicsContext3D::UNSIGNED_BYTE
 #endif
 
@@ -647 +610 @@
 void BitmapTextureGL::didReset()
 {
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+
     if (!m_id)
-        GL_CMD(glGenTextures(1, &m_id));
+        m_id = context3D->createTexture();
 
     m_shouldClear = true;
@@ -654 +619 @@
         return;
 
-    GLuint format = driverSupportsBGRASwizzling() ? GL_BGRA : GL_RGBA;
+    Platform3DObject format = driverSupportsBGRASwizzling() ? GraphicsContext3D::BGRA : GraphicsContext3D::RGBA;
 
     m_textureSize = contentSize();
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, m_id));
-    GL_CMD(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-    GL_CMD(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-    GL_CMD(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
-    GL_CMD(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-    GL_CMD(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_textureSize.width(), m_textureSize.height(), 0, format, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, 0));
+    context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
+    context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
+    context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
+    context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
+    context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
+    context3D->texImage2DDirect(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, m_textureSize.width(), m_textureSize.height(), 0, format, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, 0);
 }
 
@@ -668 +633 @@
 void BitmapTextureGL::updateContents(const void* data, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine)
 {
-    GLuint glFormat = GL_RGBA;
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, m_id));
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+
+    Platform3DObject glFormat = GraphicsContext3D::RGBA;
+    context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
 
     const unsigned bytesPerPixel = 4;
     if (driverSupportsBGRASwizzling())
-        glFormat = GL_BGRA;
+        glFormat = GraphicsContext3D::BGRA;
     else
         swizzleBGRAToRGBA(reinterpret_cast<uint32_t*>(const_cast<void*>(data)), IntRect(sourceOffset, targetRect.size()), bytesPerLine / bytesPerPixel);
 
     if (bytesPerLine == targetRect.width() / 4 && sourceOffset == IntPoint::zero()) {
-        GL_CMD(glTexSubImage2D(GL_TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, (const char*)data));
+        context3D->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, (const char*)data);
         return;
     }
@@ -696 +663 @@
         }
 
-        GL_CMD(glTexSubImage2D(GL_TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, temporaryData.data()));
+        context3D->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, temporaryData.data());
         return;
     }
@@ -702 +669 @@
 #if !defined(TEXMAP_OPENGL_ES_2)
     // Use the OpenGL sub-image extension, now that we know it's available.
-    GL_CMD(glPixelStorei(GL_UNPACK_ROW_LENGTH, bytesPerLine / bytesPerPixel));
-    GL_CMD(glPixelStorei(GL_UNPACK_SKIP_ROWS, sourceOffset.y()));
-    GL_CMD(glPixelStorei(GL_UNPACK_SKIP_PIXELS, sourceOffset.x()));
-    GL_CMD(glTexSubImage2D(GL_TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, (const char*)data));
-    GL_CMD(glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
-    GL_CMD(glPixelStorei(GL_UNPACK_SKIP_ROWS, 0));
-    GL_CMD(glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0));
+    context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, bytesPerLine / bytesPerPixel);
+    context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, sourceOffset.y());
+    context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, sourceOffset.x());
+    context3D->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, (const char*)data);
+    context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
 #endif
 }
@@ -744 +711 @@
     program->prepare(filter, pass, sourceTexture.contentSize(), static_cast<const BitmapTextureGL&>(contentTexture).id());
 
-    GL_CMD(glEnableVertexAttribArray(program->vertexAttrib()));
-    GL_CMD(glEnableVertexAttribArray(program->texCoordAttrib()));
-    GL_CMD(glActiveTexture(GL_TEXTURE0));
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, static_cast<const BitmapTextureGL&>(sourceTexture).id()));
-    glUniform1i(program->textureUniform(), 0);
-    const GLfloat targetVertices[] = {-1, -1, 1, -1, 1, 1, -1, 1};
-    const GLfloat sourceVertices[] = {0, 0, 1, 0, 1, 1, 0, 1};
-    GL_CMD(glVertexAttribPointer(program->vertexAttrib(), 2, GL_FLOAT, GL_FALSE, 0, targetVertices));
-    GL_CMD(glVertexAttribPointer(program->texCoordAttrib(), 2, GL_FLOAT, GL_FALSE, 0, sourceVertices));
-    GL_CMD(glDisable(GL_BLEND));
-    GL_CMD(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
-    GL_CMD(glDisableVertexAttribArray(program->vertexAttrib()));
-    GL_CMD(glDisableVertexAttribArray(program->texCoordAttrib()));
+    m_context3D->enableVertexAttribArray(program->vertexAttrib());
+    m_context3D->enableVertexAttribArray(program->texCoordAttrib());
+    m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);
+    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, static_cast<const BitmapTextureGL&>(sourceTexture).id());
+    m_context3D->uniform1i(program->textureUniform(), 0);
+    const GC3Dfloat targetVertices[] = {-1, -1, 1, -1, 1, 1, -1, 1};
+    const GC3Dfloat sourceVertices[] = {0, 0, 1, 0, 1, 1, 0, 1};
+    m_context3D->vertexAttribPointer(program->vertexAttrib(), 2, GraphicsContext3D::FLOAT, false, 0, GC3Dintptr(targetVertices));
+    m_context3D->vertexAttribPointer(program->texCoordAttrib(), 2, GraphicsContext3D::FLOAT, false, 0, GC3Dintptr(sourceVertices));
+    m_context3D->disable(GraphicsContext3D::BLEND);
+    m_context3D->drawArrays(GraphicsContext3D::TRIANGLE_FAN, 0, 4);
+    m_context3D->disableVertexAttribArray(program->vertexAttrib());
+    m_context3D->disableVertexAttribArray(program->texCoordAttrib());
 }
 
@@ -797 +764 @@
     if (m_rbo)
         return;
-    GL_CMD(glGenRenderbuffers(1, &m_rbo));
-    GL_CMD(glBindRenderbuffer(GL_RENDERBUFFER, m_rbo));
+
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+    m_rbo = context3D->createRenderbuffer();
+    context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_rbo);
 #ifdef TEXMAP_OPENGL_ES_2
-    GL_CMD(glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, m_textureSize.width(), m_textureSize.height()));
+    context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX8, m_textureSize.width(), m_textureSize.height());
 #else
-    GL_CMD(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_textureSize.width(), m_textureSize.height()));
-#endif
-    GL_CMD(glBindRenderbuffer(GL_RENDERBUFFER, 0));
-    GL_CMD(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_rbo));
-    GL_CMD(glClearStencil(0));
-    GL_CMD(glClear(GL_STENCIL_BUFFER_BIT));
+    context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_STENCIL, m_textureSize.width(), m_textureSize.height());
+#endif
+    context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
+    context3D->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_rbo);
+    context3D->clearStencil(0);
+    context3D->clear(GraphicsContext3D::STENCIL_BUFFER_BIT);
 }
 
@@ -815 +784 @@
         return;
 
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+
     m_clipStack.init(IntRect(IntPoint::zero(), m_textureSize));
-    m_clipStack.apply();
-    GL_CMD(glClearColor(0, 0, 0, 0));
-    GL_CMD(glClear(GL_COLOR_BUFFER_BIT));
+    m_clipStack.apply(context3D);
+    context3D->clearColor(0, 0, 0, 0);
+    context3D->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
     m_shouldClear = false;
 }
@@ -827 +798 @@
         return;
 
-    GL_CMD(glGenFramebuffers(1, &m_fbo));
-    GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo));
-    GL_CMD(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id(), 0));
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+    m_fbo = context3D->createFramebuffer();
+    context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
+    context3D->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, id(), 0);
     m_shouldClear = true;
 }
@@ -835 +807 @@
 void BitmapTextureGL::bind()
 {
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, 0));
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+    context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);
     createFboIfNeeded();
-    GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo));
-    GL_CMD(glViewport(0, 0, m_textureSize.width(), m_textureSize.height()));
+    context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
+    context3D->viewport(0, 0, m_textureSize.width(), m_textureSize.height());
     clearIfNeeded();
     m_textureMapper->data().projectionMatrix = createProjectionMatrix(m_textureSize, true /* mirrored */);
-    m_clipStack.apply();
+    m_clipStack.apply(context3D);
 }
 
 BitmapTextureGL::~BitmapTextureGL()
 {
+    GraphicsContext3D* context3D = m_textureMapper->graphicsContext3D();
+
     if (m_id)
-        GL_CMD(glDeleteTextures(1, &m_id));
+        context3D->deleteTexture(m_id);
 
     if (m_fbo)
-        GL_CMD(glDeleteFramebuffers(1, &m_fbo));
+        context3D->deleteFramebuffer(m_fbo);
 
     if (m_rbo)
-        GL_CMD(glDeleteRenderbuffers(1, &m_rbo));
+        context3D->deleteRenderbuffer(m_rbo);
 }
 
@@ -873 +848 @@
 void TextureMapperGL::bindDefaultSurface()
 {
-    GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, data().targetFrameBuffer));
+    m_context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, data().targetFrameBuffer);
     IntSize viewportSize(data().viewport[2], data().viewport[3]);
     data().projectionMatrix = createProjectionMatrix(viewportSize, data().PaintFlags & PaintingMirrored);
-    GL_CMD(glViewport(data().viewport[0], data().viewport[1], viewportSize.width(), viewportSize.height()));
-    m_clipStack.apply();
+    m_context3D->viewport(data().viewport[0], data().viewport[1], viewportSize.width(), viewportSize.height());
+    m_clipStack.apply(m_context3D.get());
     data().currentSurface.clear();
 }
@@ -907 +882 @@
 
     clipStack().current().scissorBox.intersect(rect);
-    clipStack().apply();
+    clipStack().apply(m_context3D.get());
     return true;
 }
@@ -921 +896 @@
     RefPtr<TextureMapperShaderProgram> program = data().sharedGLData().textureMapperShaderManager.getShaderProgram(TextureMapperShaderManager::Simple);
 
-    GL_CMD(glUseProgram(program->id()));
-    GL_CMD(glEnableVertexAttribArray(program->vertexAttrib()));
-    const GLfloat unitRect[] = {0, 0, 1, 0, 1, 1, 0, 1};
-    GL_CMD(glVertexAttribPointer(program->vertexAttrib(), 2, GL_FLOAT, GL_FALSE, 0, unitRect));
+    m_context3D->useProgram(program->id());
+    m_context3D->enableVertexAttribArray(program->vertexAttrib());
+    const GC3Dfloat unitRect[] = {0, 0, 1, 0, 1, 1, 0, 1};
+    m_context3D->vertexAttribPointer(program->vertexAttrib(), 2, GraphicsContext3D::FLOAT, false, 0, GC3Dintptr(unitRect));
 
     TransformationMatrix matrix = TransformationMatrix(data().projectionMatrix)
@@ -933 +908 @@
                 targetRect.x(), targetRect.y(), 0, 1));
 
-    const GLfloat m4[] = {
+    const GC3Dfloat m4[] = {
         matrix.m11(), matrix.m12(), matrix.m13(), matrix.m14(),
         matrix.m21(), matrix.m22(), matrix.m23(), matrix.m24(),
@@ -940 +915 @@
     };
 
-    const GLfloat m4all[] = {
+    const GC3Dfloat m4all[] = {
         2, 0, 0, 0,
         0, 2, 0, 0,
@@ -949 +924 @@
     int& stencilIndex = clipStack().current().stencilIndex;
 
-    GL_CMD(glEnable(GL_STENCIL_TEST));
+    m_context3D->enable(GraphicsContext3D::STENCIL_TEST);
 
     // Make sure we don't do any actual drawing.
-    GL_CMD(glStencilFunc(GL_NEVER, stencilIndex, stencilIndex));
+    m_context3D->stencilFunc(GraphicsContext3D::NEVER, stencilIndex, stencilIndex);
 
     // Operate only on the stencilIndex and above.
-    GL_CMD(glStencilMask(0xff & ~(stencilIndex - 1)));
+    m_context3D->stencilMask(0xff & ~(stencilIndex - 1));
 
     // First clear the entire buffer at the current index.
-    GL_CMD(glUniformMatrix4fv(program->matrixLocation(), 1, GL_FALSE, m4all));
-    GL_CMD(glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO));
-    GL_CMD(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+    m_context3D->uniformMatrix4fv(program->matrixLocation(), 1, false, const_cast<GC3Dfloat*>(m4all));
+    m_context3D->stencilOp(GraphicsContext3D::ZERO, GraphicsContext3D::ZERO, GraphicsContext3D::ZERO);
+    m_context3D->drawArrays(GraphicsContext3D::TRIANGLE_FAN, 0, 4);
 
     // Now apply the current index to the new quad.
-    GL_CMD(glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE));
-    GL_CMD(glUniformMatrix4fv(program->matrixLocation(), 1, GL_FALSE, m4));
-    GL_CMD(glDrawArrays(GL_TRIANGLE_FAN, 0, 4));
+    m_context3D->stencilOp(GraphicsContext3D::REPLACE, GraphicsContext3D::REPLACE, GraphicsContext3D::REPLACE);
+    m_context3D->uniformMatrix4fv(program->matrixLocation(), 1, false, const_cast<GC3Dfloat*>(m4));
+    m_context3D->drawArrays(GraphicsContext3D::TRIANGLE_FAN, 0, 4);
 
     // Clear the state.
-    GL_CMD(glDisableVertexAttribArray(program->vertexAttrib()));
-    GL_CMD(glStencilMask(0));
+    m_context3D->disableVertexAttribArray(program->vertexAttrib());
+    m_context3D->stencilMask(0);
 
     // Increase stencilIndex and apply stencil testing.
     stencilIndex *= 2;
-    clipStack().apply();
+    clipStack().apply(m_context3D.get());
 }
 
@@ -979 +954 @@
 {
     clipStack().pop();
-    clipStack().apply();
+    clipStack().apply(m_context3D.get());
 }
 
 PassRefPtr<BitmapTexture> TextureMapperGL::createTexture()
 {
-    BitmapTextureGL* texture = new BitmapTextureGL();
-    texture->setTextureMapper(this);
+    BitmapTextureGL* texture = new BitmapTextureGL(this);
     return adoptRef(texture);
 }

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h

@@ -24 +24 @@
 
 #include "FloatQuad.h"
+#include "GraphicsContext3D.h"
 #include "IntSize.h"
-#include "OpenGLShims.h"
 #include "TextureMapper.h"
 #include "TransformationMatrix.h"
@@ -39 +39 @@
 public:
     static PassOwnPtr<TextureMapperGL> create() { return adoptPtr(new TextureMapperGL); }
-    TextureMapperGL();
     virtual ~TextureMapperGL();
 
@@ -55 +54 @@
     virtual void drawTexture(uint32_t texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture, unsigned exposedEdges = AllEdges);
 
-#if defined(GL_ARB_texture_rectangle)
+#if !USE(TEXMAP_OPENGL_ES_2)
     virtual void drawTextureRectangleARB(uint32_t texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture);
 #endif
@@ -67 +66 @@
     virtual PassRefPtr<BitmapTexture> createTexture() OVERRIDE;
     virtual GraphicsContext* graphicsContext() OVERRIDE { return m_context; }
+    inline GraphicsContext3D* graphicsContext3D() const { return m_context3D.get(); }
     virtual void setGraphicsContext(GraphicsContext* context) OVERRIDE { m_context = context; }
 
@@ -76 +76 @@
 
 private:
-
     struct ClipState {
         IntRect scissorBox;
@@ -90 +89 @@
         void push();
         void pop();
-        void apply();
+        void apply(GraphicsContext3D*);
         inline ClipState& current() { return clipState; }
         void init(const IntRect&);
@@ -110 +109 @@
     };
 
+    TextureMapperGL();
+
     bool drawTextureWithAntialiasing(uint32_t texture, Flags, const FloatRect& originalTargetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture, unsigned exposedEdges);
     void drawTexturedQuadWithProgram(TextureMapperShaderProgram*, uint32_t texture, Flags, const DrawQuad&, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture);
-    void drawQuad(const DrawQuad&, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram*, GLenum drawingMode, bool needsBlending);
+    void drawQuad(const DrawQuad&, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram*, GC3Denum drawingMode, bool needsBlending);
 
     bool beginScissorClip(const TransformationMatrix&, const FloatRect&);
@@ -118 +119 @@
     ClipStack& clipStack();
     inline TextureMapperGLData& data() { return *m_data; }
+    GraphicsContext* m_context;
+    RefPtr<GraphicsContext3D> m_context3D;
     TextureMapperGLData* m_data;
-    GraphicsContext* m_context;
     ClipStack m_clipStack;
     bool m_enableEdgeDistanceAntialiasing;
@@ -136 +138 @@
     ~BitmapTextureGL();
     virtual uint32_t id() const { return m_id; }
-    uint32_t textureTarget() const { return GL_TEXTURE_2D; }
+    uint32_t textureTarget() const { return GraphicsContext3D::TEXTURE_2D; }
     IntSize textureSize() const { return m_textureSize; }
     void setTextureMapper(TextureMapperGL* texmap) { m_textureMapper = texmap; }
@@ -148 +150 @@
 
 private:
-    GLuint m_id;
+    Platform3DObject m_id;
     IntSize m_textureSize;
     IntRect m_dirtyRect;
-    GLuint m_fbo;
-    GLuint m_rbo;
+    Platform3DObject m_fbo;
+    Platform3DObject m_rbo;
     bool m_shouldClear;
+    TextureMapperGL::ClipStack m_clipStack;
     TextureMapperGL* m_textureMapper;
-    TextureMapperGL::ClipStack m_clipStack;
-    BitmapTextureGL()
+
+    BitmapTextureGL();
+    BitmapTextureGL(TextureMapperGL* textureMapper)
         : m_id(0)
         , m_fbo(0)
         , m_rbo(0)
         , m_shouldClear(true)
-        , m_textureMapper(0)
+        , m_textureMapper(textureMapper)
     {
     }

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperShaderManager.cpp

@@ -31 +31 @@
 namespace WebCore {
 
-#ifndef TEXMAP_OPENGL_ES_2
-#define OES2_PRECISION_DEFINITIONS \
-    "#define lowp\n#define highp\n"
-#define OES2_FRAGMENT_SHADER_DEFAULT_PRECISION
-#else
-#define OES2_PRECISION_DEFINITIONS
-#define OES2_FRAGMENT_SHADER_DEFAULT_PRECISION \
-    "precision mediump float; \n"
-#endif
-
-#define STRINGIFY_VAL(src...) #src
-#define VERTEX_SHADER(src...) OES2_PRECISION_DEFINITIONS\
-                              STRINGIFY_VAL(src)
-#define FRAGMENT_SHADER(src...) OES2_PRECISION_DEFINITIONS\
-                                OES2_FRAGMENT_SHADER_DEFAULT_PRECISION\
-                                STRINGIFY_VAL(src)
+#define STRINGIFY(src...) #src
 
 static const char* fragmentShaderSourceOpacityAndMask =
-    FRAGMENT_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform sampler2D s_source;
         uniform sampler2D s_mask;
@@ -65 +51 @@
 
 static const char* fragmentShaderSourceRectOpacityAndMask =
-    FRAGMENT_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform sampler2DRect s_source;
         uniform sampler2DRect s_mask;
@@ -81 +68 @@
 
 static const char* vertexShaderSourceOpacityAndMask =
-    VERTEX_SHADER(
+    STRINGIFY(
         uniform mat4 u_matrix;
         uniform lowp float u_flip;
@@ -96 +83 @@
 
 static const char* fragmentShaderSourceSimple =
-    FRAGMENT_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform sampler2D s_source;
         uniform lowp float u_opacity;
@@ -108 +96 @@
 
 static const char* fragmentShaderSourceAntialiasingNoMask =
-    FRAGMENT_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform sampler2D s_source;
         varying highp vec2 v_sourceTexCoord;
@@ -146 +135 @@
 
 static const char* fragmentShaderSourceRectSimple =
-    FRAGMENT_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform sampler2DRect s_source;
         uniform lowp vec2 u_textureSize;
@@ -159 +149 @@
 
 static const char* vertexShaderSourceSimple =
-    VERTEX_SHADER(
+    STRINGIFY(
         uniform mat4 u_matrix;
         uniform lowp float u_flip;
@@ -172 +162 @@
 
 static const char* vertexShaderSourceSolidColor =
-    VERTEX_SHADER(
+    STRINGIFY(
         uniform mat4 u_matrix;
         attribute vec4 a_vertex;
@@ -183 +173 @@
 
 static const char* fragmentShaderSourceSolidColor =
-    VERTEX_SHADER(
+    STRINGIFY(
+        precision mediump float;
         uniform vec4 u_color;
         void main(void)
@@ -213 +204 @@
     switch (shaderType) {
     case Simple:
-        program = TextureMapperShaderProgramSimple::create();
+        program = TextureMapperShaderProgramSimple::create(m_context);
         break;
     case RectSimple:
-        program = TextureMapperShaderProgramRectSimple::create();
+        program = TextureMapperShaderProgramRectSimple::create(m_context);
         break;
     case AntialiasingNoMask:
-        program = TextureMapperShaderProgramAntialiasingNoMask::create();
+        program = TextureMapperShaderProgramAntialiasingNoMask::create(m_context);
         break;
     case OpacityAndMask:
-        program = TextureMapperShaderProgramOpacityAndMask::create();
+        program = TextureMapperShaderProgramOpacityAndMask::create(m_context);
         break;
     case RectOpacityAndMask:
-        program = TextureMapperShaderProgramRectOpacityAndMask::create();
+        program = TextureMapperShaderProgramRectOpacityAndMask::create(m_context);
         break;
     case SolidColor:
-        program = TextureMapperShaderProgramSolidColor::create();
+        program = TextureMapperShaderProgramSolidColor::create(m_context);
         break;
     case Invalid:
@@ -237 +228 @@
 }
 
-TextureMapperShaderProgram::TextureMapperShaderProgram(const char* vertexShaderSource, const char* fragmentShaderSource)
-    : m_id(0)
+TextureMapperShaderProgram::TextureMapperShaderProgram(GraphicsContext3D* context, const char* vertexShaderSource, const char* fragmentShaderSource)
+    : m_context(context)
+    , m_id(0)
     , m_vertexAttrib(0)
     , m_vertexShader(0)
@@ -257 +249 @@
     const char* vertexShaderSourceProgram = vertexShaderSource();
     const char* fragmentShaderSourceProgram = fragmentShaderSource();
-    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
-    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(vertexShader, 1, &vertexShaderSourceProgram, 0);
-    glShaderSource(fragmentShader, 1, &fragmentShaderSourceProgram, 0);
-    GLuint programID = glCreateProgram();
-    glCompileShader(vertexShader);
-    glCompileShader(fragmentShader);
-
-    glAttachShader(programID, vertexShader);
-    glAttachShader(programID, fragmentShader);
-    glLinkProgram(programID);
-
-    m_vertexAttrib = glGetAttribLocation(programID, "a_vertex");
+    Platform3DObject vertexShader = m_context->createShader(GraphicsContext3D::VERTEX_SHADER);
+    Platform3DObject fragmentShader = m_context->createShader(GraphicsContext3D::FRAGMENT_SHADER);
+    m_context->shaderSource(vertexShader, vertexShaderSourceProgram);
+    m_context->shaderSource(fragmentShader, fragmentShaderSourceProgram);
+    Platform3DObject programID = m_context->createProgram();
+    m_context->compileShader(vertexShader);
+    m_context->compileShader(fragmentShader);
+
+    m_context->attachShader(programID, vertexShader);
+    m_context->attachShader(programID, fragmentShader);
+    m_context->linkProgram(programID);
+
+    m_vertexAttrib = m_context->getAttribLocation(programID, "a_vertex");
 
     m_id = programID;
@@ -276 +268 @@
 }
 
-void TextureMapperShaderProgram::getUniformLocation(GLint &variable, const char* name)
-{
-    variable = glGetUniformLocation(m_id, name);
+void TextureMapperShaderProgram::getUniformLocation(GC3Dint &variable, const char* name)
+{
+    variable = m_context->getUniformLocation(m_id, name);
     ASSERT(variable >= 0);
 }
@@ -284 +276 @@
 TextureMapperShaderProgram::~TextureMapperShaderProgram()
 {
-    GLuint programID = m_id;
+    Platform3DObject programID = m_id;
     if (!programID)
         return;
 
-    glDetachShader(programID, m_vertexShader);
-    glDeleteShader(m_vertexShader);
-    glDetachShader(programID, m_fragmentShader);
-    glDeleteShader(m_fragmentShader);
-    glDeleteProgram(programID);
-}
-
-TextureMapperShaderProgramSimple::TextureMapperShaderProgramSimple()
-    : TextureMapperShaderProgram(vertexShaderSourceSimple, fragmentShaderSourceSimple)
+    m_context->detachShader(programID, m_vertexShader);
+    m_context->deleteShader(m_vertexShader);
+    m_context->detachShader(programID, m_fragmentShader);
+    m_context->deleteShader(m_fragmentShader);
+    m_context->deleteProgram(programID);
+}
+
+TextureMapperShaderProgramSimple::TextureMapperShaderProgramSimple(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceSimple, fragmentShaderSourceSimple)
 {
     initializeProgram();
@@ -305 +297 @@
 }
 
-TextureMapperShaderProgramSolidColor::TextureMapperShaderProgramSolidColor()
-    : TextureMapperShaderProgram(vertexShaderSourceSolidColor, fragmentShaderSourceSolidColor)
+TextureMapperShaderProgramSolidColor::TextureMapperShaderProgramSolidColor(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceSolidColor, fragmentShaderSourceSolidColor)
 {
     initializeProgram();
@@ -313 +305 @@
 }
 
-TextureMapperShaderProgramRectSimple::TextureMapperShaderProgramRectSimple()
-    : TextureMapperShaderProgram(vertexShaderSourceSimple, fragmentShaderSourceRectSimple)
+TextureMapperShaderProgramRectSimple::TextureMapperShaderProgramRectSimple(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceSimple, fragmentShaderSourceRectSimple)
 {
     initializeProgram();
@@ -324 +316 @@
 }
 
-TextureMapperShaderProgramOpacityAndMask::TextureMapperShaderProgramOpacityAndMask()
-    : TextureMapperShaderProgram(vertexShaderSourceOpacityAndMask, fragmentShaderSourceOpacityAndMask)
+TextureMapperShaderProgramOpacityAndMask::TextureMapperShaderProgramOpacityAndMask(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceOpacityAndMask, fragmentShaderSourceOpacityAndMask)
 {
     initializeProgram();
@@ -335 +327 @@
 }
 
-TextureMapperShaderProgramRectOpacityAndMask::TextureMapperShaderProgramRectOpacityAndMask()
-    : TextureMapperShaderProgram(vertexShaderSourceOpacityAndMask, fragmentShaderSourceRectOpacityAndMask)
+TextureMapperShaderProgramRectOpacityAndMask::TextureMapperShaderProgramRectOpacityAndMask(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceOpacityAndMask, fragmentShaderSourceRectOpacityAndMask)
 {
     initializeProgram();
@@ -346 +338 @@
 }
 
-TextureMapperShaderProgramAntialiasingNoMask::TextureMapperShaderProgramAntialiasingNoMask()
-    : TextureMapperShaderProgram(vertexShaderSourceSimple, fragmentShaderSourceAntialiasingNoMask)
+TextureMapperShaderProgramAntialiasingNoMask::TextureMapperShaderProgramAntialiasingNoMask(GraphicsContext3D* context)
+    : TextureMapperShaderProgram(context, vertexShaderSourceSimple, fragmentShaderSourceAntialiasingNoMask)
 {
     initializeProgram();
@@ -357 +349 @@
 }
 
-TextureMapperShaderManager::TextureMapperShaderManager()
-{
-    ASSERT(initializeOpenGLShims());
+TextureMapperShaderManager::TextureMapperShaderManager(GraphicsContext3D* context)
+    : m_context(context)
+{
 }
 
@@ -374 +366 @@
 StandardFilterProgram::~StandardFilterProgram()
 {
-    glDetachShader(m_id, m_vertexShader);
-    glDeleteShader(m_vertexShader);
-    glDetachShader(m_id, m_fragmentShader);
-    glDeleteShader(m_fragmentShader);
-    glDeleteProgram(m_id);
-}
-
-StandardFilterProgram::StandardFilterProgram(FilterOperation::OperationType type, unsigned pass)
-    : m_id(0)
+    m_context->detachShader(m_id, m_vertexShader);
+    m_context->deleteShader(m_vertexShader);
+    m_context->detachShader(m_id, m_fragmentShader);
+    m_context->deleteShader(m_fragmentShader);
+    m_context->deleteProgram(m_id);
+}
+
+StandardFilterProgram::StandardFilterProgram(GraphicsContext3D* context, FilterOperation::OperationType type, unsigned pass)
+    : m_context(context)
+    , m_id(0)
 {
     const char* vertexShaderSource =
-            VERTEX_SHADER(
+            STRINGIFY(
                 attribute vec4 a_vertex;
                 attribute vec4 a_texCoord;
@@ -397 +390 @@
 
 #define STANDARD_FILTER(x...) \
-        OES2_PRECISION_DEFINITIONS\
-        OES2_FRAGMENT_SHADER_DEFAULT_PRECISION\
+        "precision mediump float;\n"\
         "varying highp vec2 v_texCoord;\n"\
         "uniform highp float u_amount;\n"\
@@ -491 +483 @@
         break;
     case FilterOperation::BLUR:
-        fragmentShaderSource = FRAGMENT_SHADER(
+        fragmentShaderSource = STRINGIFY(
+            precision mediump float;
             varying highp vec2 v_texCoord;
             uniform lowp vec2 u_blurRadius;
@@ -524 +517 @@
         case 0: {
             // First pass: horizontal alpha blur.
-            fragmentShaderSource = FRAGMENT_SHADER(
+            fragmentShaderSource = STRINGIFY(
+                precision mediump float;
                 varying highp vec2 v_texCoord;
                 uniform lowp float u_shadowBlurRadius;
@@ -557 +551 @@
         case 1: {
             // Second pass: vertical alpha blur and composite with origin.
-            fragmentShaderSource = FRAGMENT_SHADER(
+            fragmentShaderSource = STRINGIFY(
+                precision mediump float;
                 varying highp vec2 v_texCoord;
                 uniform lowp float u_shadowBlurRadius;
@@ -603 +598 @@
     if (!fragmentShaderSource)
         return;
-    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
-    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(vertexShader, 1, &vertexShaderSource, 0);
-    glShaderSource(fragmentShader, 1, &fragmentShaderSource, 0);
-    GLuint programID = glCreateProgram();
-    glCompileShader(vertexShader);
-    glCompileShader(fragmentShader);
+    Platform3DObject vertexShader = m_context->createShader(GraphicsContext3D::VERTEX_SHADER);
+    Platform3DObject fragmentShader = m_context->createShader(GraphicsContext3D::FRAGMENT_SHADER);
+    m_context->shaderSource(vertexShader, vertexShaderSource);
+    m_context->shaderSource(fragmentShader, fragmentShaderSource);
+    Platform3DObject programID = m_context->createProgram();
+    m_context->compileShader(vertexShader);
+    m_context->compileShader(fragmentShader);
 #if !LOG_DISABLED
-    GLchar log[100];
-    GLint len;
-    glGetShaderInfoLog(fragmentShader, 100, &len, log);
+    String log;
+    m_context->getShaderInfoLog(fragmentShader);
     WTFLog(&LogCompositing, "%s\n", log);
 #endif
-    glAttachShader(programID, vertexShader);
-    glAttachShader(programID, fragmentShader);
-    glLinkProgram(programID);
-
-    m_vertexAttrib = glGetAttribLocation(programID, "a_vertex");
-    m_texCoordAttrib = glGetAttribLocation(programID, "a_texCoord");
-    m_textureUniformLocation = glGetUniformLocation(programID, "u_texture");
+    m_context->attachShader(programID, vertexShader);
+    m_context->attachShader(programID, fragmentShader);
+    m_context->linkProgram(programID);
+
+    m_vertexAttrib = m_context->getAttribLocation(programID, "a_vertex");
+    m_texCoordAttrib = m_context->getAttribLocation(programID, "a_texCoord");
+    m_textureUniformLocation = m_context->getUniformLocation(programID, "u_texture");
     switch (type) {
     case FilterOperation::GRAYSCALE:
@@ -632 +626 @@
     case FilterOperation::CONTRAST:
     case FilterOperation::OPACITY:
-        m_uniformLocations.amount = glGetUniformLocation(programID, "u_amount");
+        m_uniformLocations.amount = m_context->getUniformLocation(programID, "u_amount");
         break;
     case FilterOperation::BLUR:
-        m_uniformLocations.blur.radius = glGetUniformLocation(programID, "u_blurRadius");
-        m_uniformLocations.blur.gaussianKernel = glGetUniformLocation(programID, "u_gaussianKernel");
+        m_uniformLocations.blur.radius = m_context->getUniformLocation(programID, "u_blurRadius");
+        m_uniformLocations.blur.gaussianKernel = m_context->getUniformLocation(programID, "u_gaussianKernel");
         break;
     case FilterOperation::DROP_SHADOW:
-        m_uniformLocations.shadow.blurRadius = glGetUniformLocation(programID, "u_shadowBlurRadius");
-        m_uniformLocations.shadow.gaussianKernel = glGetUniformLocation(programID, "u_gaussianKernel");
+        m_uniformLocations.shadow.blurRadius = m_context->getUniformLocation(programID, "u_shadowBlurRadius");
+        m_uniformLocations.shadow.gaussianKernel = m_context->getUniformLocation(programID, "u_gaussianKernel");
         if (!pass)
-            m_uniformLocations.shadow.offset = glGetUniformLocation(programID, "u_shadowOffset");
+            m_uniformLocations.shadow.offset = m_context->getUniformLocation(programID, "u_shadowOffset");
         else {
             // We only need the color and the content texture in the second pass, the first pass is only a horizontal alpha blur.
-            m_uniformLocations.shadow.color = glGetUniformLocation(programID, "u_shadowColor");
-            m_uniformLocations.shadow.contentTexture = glGetUniformLocation(programID, "u_contentTexture");
+            m_uniformLocations.shadow.color = m_context->getUniformLocation(programID, "u_shadowColor");
+            m_uniformLocations.shadow.contentTexture = m_context->getUniformLocation(programID, "u_contentTexture");
         }
         break;
@@ -657 +651 @@
 }
 
-PassRefPtr<StandardFilterProgram> StandardFilterProgram::create(FilterOperation::OperationType type, unsigned pass)
-{
-    RefPtr<StandardFilterProgram> program = adoptRef(new StandardFilterProgram(type, pass));
+PassRefPtr<StandardFilterProgram> StandardFilterProgram::create(GraphicsContext3D* context, FilterOperation::OperationType type, unsigned pass)
+{
+    RefPtr<StandardFilterProgram> program = adoptRef(new StandardFilterProgram(context, type, pass));
     if (!program->m_id)
         return 0;
@@ -695 +689 @@
 }
 
-void StandardFilterProgram::prepare(const FilterOperation& operation, unsigned pass, const IntSize& size, GLuint contentTexture)
-{
-    glUseProgram(m_id);
+void StandardFilterProgram::prepare(const FilterOperation& operation, unsigned pass, const IntSize& size, GC3Duint contentTexture)
+{
+    m_context->useProgram(m_id);
     switch (operation.getOperationType()) {
     case FilterOperation::GRAYSCALE:
@@ -703 +697 @@
     case FilterOperation::SATURATE:
     case FilterOperation::HUE_ROTATE:
-        glUniform1f(m_uniformLocations.amount, static_cast<const BasicColorMatrixFilterOperation&>(operation).amount());
+        m_context->uniform1f(m_uniformLocations.amount, static_cast<const BasicColorMatrixFilterOperation&>(operation).amount());
         break;
     case FilterOperation::INVERT:
@@ -709 +703 @@
     case FilterOperation::CONTRAST:
     case FilterOperation::OPACITY:
-        glUniform1f(m_uniformLocations.amount, static_cast<const BasicComponentTransferFilterOperation&>(operation).amount());
+        m_context->uniform1f(m_uniformLocations.amount, static_cast<const BasicComponentTransferFilterOperation&>(operation).amount());
         break;
     case FilterOperation::BLUR: {
@@ -721 +715 @@
             radius.setWidth(floatValueForLength(blur.stdDeviation(), size.width()) / size.width());
 
-        glUniform2f(m_uniformLocations.blur.radius, radius.width(), radius.height());
-        glUniform1fv(m_uniformLocations.blur.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
+        m_context->uniform2f(m_uniformLocations.blur.radius, radius.width(), radius.height());
+        m_context->uniform1fv(m_uniformLocations.blur.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
         break;
     }
@@ -730 +724 @@
         case 0:
             // First pass: vertical alpha blur.
-            glUniform2f(m_uniformLocations.shadow.offset, float(shadow.location().x()) / float(size.width()), float(shadow.location().y()) / float(size.height()));
-            glUniform1f(m_uniformLocations.shadow.blurRadius, shadow.stdDeviation() / float(size.width()));
-            glUniform1fv(m_uniformLocations.shadow.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
+            m_context->uniform2f(m_uniformLocations.shadow.offset, float(shadow.location().x()) / float(size.width()), float(shadow.location().y()) / float(size.height()));
+            m_context->uniform1f(m_uniformLocations.shadow.blurRadius, shadow.stdDeviation() / float(size.width()));
+            m_context->uniform1fv(m_uniformLocations.shadow.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
             break;
         case 1:
             // Second pass: we need the shadow color and the content texture for compositing.
-            glUniform1f(m_uniformLocations.shadow.blurRadius, shadow.stdDeviation() / float(size.height()));
-            glUniform1fv(m_uniformLocations.shadow.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
-            glActiveTexture(GL_TEXTURE1);
-            glBindTexture(GL_TEXTURE_2D, contentTexture);
-            glUniform1i(m_uniformLocations.shadow.contentTexture, 1);
+            m_context->uniform1f(m_uniformLocations.shadow.blurRadius, shadow.stdDeviation() / float(size.height()));
+            m_context->uniform1fv(m_uniformLocations.shadow.gaussianKernel, GAUSSIAN_KERNEL_HALF_WIDTH, gaussianKernel());
+            m_context->activeTexture(GraphicsContext3D::TEXTURE1);
+            m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, contentTexture);
+            m_context->uniform1i(m_uniformLocations.shadow.contentTexture, 1);
             float r, g, b, a;
             shadow.color().getRGBA(r, g, b, a);
-            glUniform4f(m_uniformLocations.shadow.color, r, g, b, a);
+            m_context->uniform4f(m_uniformLocations.shadow.color, r, g, b, a);
             break;
         }
@@ -760 +754 @@
     FilterMap::iterator iterator = m_filterMap.find(key);
     if (iterator == m_filterMap.end()) {
-        program = StandardFilterProgram::create(type, pass);
+        program = StandardFilterProgram::create(m_context, type, pass);
         if (!program)
             return 0;

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperShaderManager.h

@@ -25 +25 @@
 
 #include "FloatQuad.h"
+#include "GraphicsContext3D.h"
 #include "IntSize.h"
-#include "OpenGLShims.h"
-#include "TextureMapper.h"
+#include "TextureMapperGL.h"
 #include "TransformationMatrix.h"
 #include <wtf/HashMap.h>
@@ -45 +45 @@
 class TextureMapperShaderProgram : public RefCounted<TextureMapperShaderProgram> {
 public:
-    GLuint id() { return m_id; }
-    GLuint vertexAttrib() { return m_vertexAttrib; }
-
-    TextureMapperShaderProgram(const char* vertexShaderSource, const char* fragmentShaderSource);
+    Platform3DObject id() { return m_id; }
+    GC3Duint vertexAttrib() { return m_vertexAttrib; }
+
+    TextureMapperShaderProgram(GraphicsContext3D*, const char* vertexShaderSource, const char* fragmentShaderSource);
     virtual ~TextureMapperShaderProgram();
 
     virtual void prepare(float opacity, const BitmapTexture*) { }
-    GLint matrixLocation() const { return m_matrixLocation; }
-    GLint flipLocation() const { return m_flipLocation; }
-    GLint textureSizeLocation() const { return m_textureSizeLocation; }
-    GLint sourceTextureLocation() const { return m_sourceTextureLocation; }
-    GLint maskTextureLocation() const { return m_maskTextureLocation; }
-    GLint opacityLocation() const { return m_opacityLocation; }
-
-    static bool isValidUniformLocation(GLint location) { return location >= 0; }
-
-protected:
-    void getUniformLocation(GLint& var, const char* name);
+    GC3Dint matrixLocation() const { return m_matrixLocation; }
+    GC3Dint flipLocation() const { return m_flipLocation; }
+    GC3Dint textureSizeLocation() const { return m_textureSizeLocation; }
+    GC3Dint sourceTextureLocation() const { return m_sourceTextureLocation; }
+    GC3Dint maskTextureLocation() const { return m_maskTextureLocation; }
+    GC3Dint opacityLocation() const { return m_opacityLocation; }
+
+    static bool isValidUniformLocation(GC3Dint location) { return location >= 0; }
+
+protected:
+    void getUniformLocation(GC3Dint& var, const char* name);
     void initializeProgram();
     virtual void initialize() { }
@@ -68 +68 @@
     const char* fragmentShaderSource() const { return m_fragmentShaderSource.data(); }
 
-    GLuint m_id;
-    GLuint m_vertexAttrib;
-    GLuint m_vertexShader;
-    GLuint m_fragmentShader;
-    GLint m_matrixLocation;
-    GLint m_flipLocation;
-    GLint m_textureSizeLocation;
-    GLint m_sourceTextureLocation;
-    GLint m_opacityLocation;
-    GLint m_maskTextureLocation;
+    GraphicsContext3D* m_context;
+    Platform3DObject m_id;
+    GC3Duint m_vertexAttrib;
+    Platform3DObject m_vertexShader;
+    Platform3DObject m_fragmentShader;
+    GC3Dint m_matrixLocation;
+    GC3Dint m_flipLocation;
+    GC3Dint m_textureSizeLocation;
+    GC3Dint m_sourceTextureLocation;
+    GC3Dint m_opacityLocation;
+    GC3Dint m_maskTextureLocation;
 
 private:
@@ -88 +89 @@
 public:
     virtual ~StandardFilterProgram();
-    virtual void prepare(const FilterOperation&, unsigned pass, const IntSize&, GLuint contentTexture);
-    static PassRefPtr<StandardFilterProgram> create(FilterOperation::OperationType, unsigned pass);
-    GLuint vertexAttrib() const { return m_vertexAttrib; }
-    GLuint texCoordAttrib() const { return m_texCoordAttrib; }
-    GLuint textureUniform() const { return m_textureUniformLocation; }
-private:
-    StandardFilterProgram(FilterOperation::OperationType, unsigned pass);
-    GLuint m_id;
-    GLuint m_vertexShader;
-    GLuint m_fragmentShader;
-    GLuint m_vertexAttrib;
-    GLuint m_texCoordAttrib;
-    GLuint m_textureUniformLocation;
+    virtual void prepare(const FilterOperation&, unsigned pass, const IntSize&, GC3Duint contentTexture);
+    static PassRefPtr<StandardFilterProgram> create(GraphicsContext3D*, FilterOperation::OperationType, unsigned pass);
+    GC3Duint vertexAttrib() const { return m_vertexAttrib; }
+    GC3Duint texCoordAttrib() const { return m_texCoordAttrib; }
+    GC3Duint textureUniform() const { return m_textureUniformLocation; }
+protected:
+    GraphicsContext3D* m_context;
+private:
+    StandardFilterProgram();
+    StandardFilterProgram(GraphicsContext3D*, FilterOperation::OperationType, unsigned pass);
+    Platform3DObject m_id;
+    Platform3DObject m_vertexShader;
+    Platform3DObject m_fragmentShader;
+    GC3Duint m_vertexAttrib;
+    GC3Duint m_texCoordAttrib;
+    GC3Duint m_textureUniformLocation;
     union {
-        GLuint amount;
+        GC3Duint amount;
 
         struct {
-            GLuint radius;
-            GLuint gaussianKernel;
+            GC3Duint radius;
+            GC3Duint gaussianKernel;
         } blur;
 
         struct {
-            GLuint blurRadius;
-            GLuint color;
-            GLuint offset;
-            GLuint contentTexture;
-            GLuint gaussianKernel;
+            GC3Duint blurRadius;
+            GC3Duint color;
+            GC3Duint offset;
+            GC3Duint contentTexture;
+            GC3Duint gaussianKernel;
         } shadow;
     } m_uniformLocations;
@@ -122 +126 @@
 class TextureMapperShaderProgramSimple : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramSimple> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramSimple());
-    }
-
-protected:
+    static PassRefPtr<TextureMapperShaderProgramSimple> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramSimple(context));
+    }
+
+protected:
+    TextureMapperShaderProgramSimple(GraphicsContext3D*);
+private:
     TextureMapperShaderProgramSimple();
 };
@@ -133 +139 @@
 class TextureMapperShaderProgramRectSimple : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramRectSimple> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramRectSimple());
-    }
-
+    static PassRefPtr<TextureMapperShaderProgramRectSimple> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramRectSimple(context));
+    }
+
+protected:
+    TextureMapperShaderProgramRectSimple(GraphicsContext3D*);
 private:
     TextureMapperShaderProgramRectSimple();
@@ -144 +152 @@
 class TextureMapperShaderProgramOpacityAndMask : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramOpacityAndMask> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramOpacityAndMask());
-    }
-
+    static PassRefPtr<TextureMapperShaderProgramOpacityAndMask> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramOpacityAndMask(context));
+    }
+
+protected:
+    TextureMapperShaderProgramOpacityAndMask(GraphicsContext3D*);
 private:
     TextureMapperShaderProgramOpacityAndMask();
@@ -155 +165 @@
 class TextureMapperShaderProgramRectOpacityAndMask : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramRectOpacityAndMask> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramRectOpacityAndMask());
-    }
-
+    static PassRefPtr<TextureMapperShaderProgramRectOpacityAndMask> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramRectOpacityAndMask(context));
+    }
+
+protected:
+    TextureMapperShaderProgramRectOpacityAndMask(GraphicsContext3D*);
 private:
     TextureMapperShaderProgramRectOpacityAndMask();
@@ -166 +178 @@
 class TextureMapperShaderProgramSolidColor : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramSolidColor> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramSolidColor());
-    }
-
-    GLint colorLocation() const { return m_colorLocation; }
-
+    static PassRefPtr<TextureMapperShaderProgramSolidColor> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramSolidColor(context));
+    }
+
+    GC3Dint colorLocation() const { return m_colorLocation; }
+
+protected:
+    TextureMapperShaderProgramSolidColor(GraphicsContext3D*);
 private:
     TextureMapperShaderProgramSolidColor();
-    GLint m_colorLocation;
+    GC3Dint m_colorLocation;
 };
 
 class TextureMapperShaderProgramAntialiasingNoMask : public TextureMapperShaderProgram {
 public:
-    static PassRefPtr<TextureMapperShaderProgramAntialiasingNoMask> create()
-    {
-        return adoptRef(new TextureMapperShaderProgramAntialiasingNoMask());
-    }
-
-    GLint expandedQuadVerticesInTextureCoordinatesLocation() { return m_expandedQuadVerticesInTextureCordinatesLocation; }
-    GLint expandedQuadEdgesInScreenSpaceLocation() { return m_expandedQuadEdgesInScreenSpaceLocation; }
-
+    static PassRefPtr<TextureMapperShaderProgramAntialiasingNoMask> create(GraphicsContext3D* context)
+    {
+        return adoptRef(new TextureMapperShaderProgramAntialiasingNoMask(context));
+    }
+
+    GC3Dint expandedQuadVerticesInTextureCoordinatesLocation() { return m_expandedQuadVerticesInTextureCordinatesLocation; }
+    GC3Dint expandedQuadEdgesInScreenSpaceLocation() { return m_expandedQuadEdgesInScreenSpaceLocation; }
+
+protected:
+    TextureMapperShaderProgramAntialiasingNoMask(GraphicsContext3D*);
 private:
     TextureMapperShaderProgramAntialiasingNoMask();
 
-    GLint m_expandedQuadVerticesInTextureCordinatesLocation;
-    GLint m_expandedQuadEdgesInScreenSpaceLocation;
+    GC3Dint m_expandedQuadVerticesInTextureCordinatesLocation;
+    GC3Dint m_expandedQuadEdgesInScreenSpaceLocation;
 };
 
@@ -207 +223 @@
     };
 
-    TextureMapperShaderManager();
+    TextureMapperShaderManager() { }
+    TextureMapperShaderManager(GraphicsContext3D*);
     virtual ~TextureMapperShaderManager();
 
@@ -222 +239 @@
     typedef HashMap<ShaderType, RefPtr<TextureMapperShaderProgram>, DefaultHash<int>::Hash, HashTraits<int> > TextureMapperShaderProgramMap;
     TextureMapperShaderProgramMap m_textureMapperShaderProgramMap;
+    GraphicsContext3D* m_context;
 
 #if ENABLE(CSS_FILTERS)
@@ -227 +245 @@
     FilterMap m_filterMap;
 #endif
-
 };