webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

15 files changed, 1534 insertions, 332 deletions

diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.cpp b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.cpp
index f8321cac0..5da632035 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.cpp
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.cpp
@@ -25,20 +25,17 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 
 #include "Extensions3DOpenGL.h"
 
 #include "GraphicsContext3D.h"
-#include <wtf/Vector.h>
 
 #if PLATFORM(IOS)
-#include "ANGLE/ShaderLang.h"
 #include <OpenGLES/ES2/glext.h>
 #elif PLATFORM(MAC)
-#include "ANGLE/ShaderLang.h"
 #include <OpenGL/gl.h>
-#elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN)
+#elif PLATFORM(GTK) || PLATFORM(WIN)
 #include "OpenGLShims.h"
 #endif
 
@@ -48,8 +45,8 @@
 
 namespace WebCore {
 
-Extensions3DOpenGL::Extensions3DOpenGL(GraphicsContext3D* context)
-    : Extensions3DOpenGLCommon(context)
+Extensions3DOpenGL::Extensions3DOpenGL(GraphicsContext3D* context, bool useIndexedGetString)
+    : Extensions3DOpenGLCommon(context, useIndexedGetString)
 {
 }
 
@@ -86,7 +83,7 @@ Platform3DObject Extensions3DOpenGL::createVertexArrayOES()
 {
     m_context->makeContextCurrent();
     GLuint array = 0;
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
     if (isVertexArrayObjectSupported())
         glGenVertexArrays(1, &array);
 #elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
@@ -101,7 +98,7 @@ void Extensions3DOpenGL::deleteVertexArrayOES(Platform3DObject array)
         return;
 
     m_context->makeContextCurrent();
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
     if (isVertexArrayObjectSupported())
         glDeleteVertexArrays(1, &array);
 #elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
@@ -115,7 +112,7 @@ GC3Dboolean Extensions3DOpenGL::isVertexArrayOES(Platform3DObject array)
         return GL_FALSE;
 
     m_context->makeContextCurrent();
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
     if (isVertexArrayObjectSupported())
         return glIsVertexArray(array);
 #elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
@@ -126,12 +123,8 @@ GC3Dboolean Extensions3DOpenGL::isVertexArrayOES(Platform3DObject array)
 
 void Extensions3DOpenGL::bindVertexArrayOES(Platform3DObject array)
 {
-#if PLATFORM(IOS)
-    UNUSED_PARAM(array);
-#endif
-
     m_context->makeContextCurrent();
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
     if (isVertexArrayObjectSupported())
         glBindVertexArray(array);
 #elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
@@ -141,12 +134,6 @@ void Extensions3DOpenGL::bindVertexArrayOES(Platform3DObject array)
 #endif
 }
 
-void Extensions3DOpenGL::copyTextureCHROMIUM(GC3Denum, Platform3DObject, Platform3DObject, GC3Dint, GC3Denum)
-{
-    // FIXME: implement this function and add GL_CHROMIUM_copy_texture in supports().
-    return;
-}
-
 void Extensions3DOpenGL::insertEventMarkerEXT(const String&)
 {
     // FIXME: implement this function and add GL_EXT_debug_marker in supports().
@@ -168,25 +155,50 @@ void Extensions3DOpenGL::popGroupMarkerEXT(void)
 bool Extensions3DOpenGL::supportsExtension(const String& name)
 {
     // GL_ANGLE_framebuffer_blit and GL_ANGLE_framebuffer_multisample are "fake". They are implemented using other
-    // extensions. In particular GL_EXT_framebuffer_blit and GL_EXT_framebuffer_multisample
+    // extensions. In particular GL_EXT_framebuffer_blit and GL_EXT_framebuffer_multisample/GL_APPLE_framebuffer_multisample.
     if (name == "GL_ANGLE_framebuffer_blit")
         return m_availableExtensions.contains("GL_EXT_framebuffer_blit");
     if (name == "GL_ANGLE_framebuffer_multisample")
+#if PLATFORM(IOS)
+        return m_availableExtensions.contains("GL_APPLE_framebuffer_multisample");
+#else
         return m_availableExtensions.contains("GL_EXT_framebuffer_multisample");
+#endif
+
+    if (name == "GL_ANGLE_instanced_arrays") {
+        return (m_availableExtensions.contains("GL_ARB_instanced_arrays") || m_availableExtensions.contains("GL_EXT_instanced_arrays"))
+            && (m_availableExtensions.contains("GL_ARB_draw_instanced") || m_availableExtensions.contains("GL_EXT_draw_instanced"));
+    }
+
+    if (name == "GL_EXT_sRGB")
+#if PLATFORM(IOS)
+        return m_availableExtensions.contains("GL_EXT_sRGB");
+#else
+        return m_availableExtensions.contains("GL_EXT_texture_sRGB") && (m_availableExtensions.contains("GL_EXT_framebuffer_sRGB") || m_availableExtensions.contains("GL_ARB_framebuffer_sRGB"));
+#endif
+
+    if (name == "GL_EXT_frag_depth")
+#if PLATFORM(MAC)
+        return true;
+#else
+        return m_availableExtensions.contains("GL_EXT_frag_depth");
+#endif
 
     // Desktop GL always supports GL_OES_rgb8_rgba8.
     if (name == "GL_OES_rgb8_rgba8")
         return true;
 
-    // If GL_ARB_texture_float is available then we report GL_OES_texture_float,
+    // If GL_ARB_texture_float or GL_OES_texture_float is available then we report
     // GL_OES_texture_half_float, GL_OES_texture_float_linear and GL_OES_texture_half_float_linear as available.
     if (name == "GL_OES_texture_float" || name == "GL_OES_texture_half_float" || name == "GL_OES_texture_float_linear" || name == "GL_OES_texture_half_float_linear")
-        return m_availableExtensions.contains("GL_ARB_texture_float");
+        return m_availableExtensions.contains("GL_ARB_texture_float") || m_availableExtensions.contains("GL_OES_texture_float");
 
     // GL_OES_vertex_array_object
     if (name == "GL_OES_vertex_array_object") {
-#if (PLATFORM(GTK) || PLATFORM(EFL))
+#if (PLATFORM(GTK))
         return m_availableExtensions.contains("GL_ARB_vertex_array_object");
+#elif PLATFORM(IOS)
+        return m_availableExtensions.contains("GL_OES_vertex_array_object");
 #else
         return m_availableExtensions.contains("GL_APPLE_vertex_array_object");
 #endif
@@ -199,12 +211,17 @@ bool Extensions3DOpenGL::supportsExtension(const String& name)
     // Desktop GL always supports UNSIGNED_INT indices
     if (name == "GL_OES_element_index_uint")
         return true;
-
+    
+    if (name == "GL_EXT_shader_texture_lod")
+        return m_availableExtensions.contains("GL_EXT_shader_texture_lod");
+    
     if (name == "GL_EXT_texture_filter_anisotropic")
         return m_availableExtensions.contains("GL_EXT_texture_filter_anisotropic");
 
     if (name == "GL_EXT_draw_buffers") {
-#if PLATFORM(MAC)
+#if PLATFORM(IOS)
+        return m_availableExtensions.contains(name);
+#elif PLATFORM(MAC) || PLATFORM(GTK)
         return m_availableExtensions.contains("GL_ARB_draw_buffers");
 #else
         // FIXME: implement support for other platforms.
@@ -223,20 +240,67 @@ bool Extensions3DOpenGL::supportsExtension(const String& name)
 void Extensions3DOpenGL::drawBuffersEXT(GC3Dsizei n, const GC3Denum* bufs)
 {
     //  FIXME: implement support for other platforms.
-#if PLATFORM(MAC) && !PLATFORM(IOS)
+#if PLATFORM(MAC)
     ::glDrawBuffersARB(n, bufs);
+#elif PLATFORM(GTK)
+    ::glDrawBuffers(n, bufs);
 #else
     UNUSED_PARAM(n);
     UNUSED_PARAM(bufs);
 #endif
 }
 
+void Extensions3DOpenGL::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+{
+    m_context->makeContextCurrent();
+#if PLATFORM(GTK)
+    ::glDrawArraysInstanced(mode, first, count, primcount);
+#elif PLATFORM(COCOA)
+    ::glDrawArraysInstancedARB(mode, first, count, primcount);
+#else
+    UNUSED_PARAM(mode);
+    UNUSED_PARAM(first);
+    UNUSED_PARAM(count);
+    UNUSED_PARAM(primcount);
+#endif
+}
+
+void Extensions3DOpenGL::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)
+{
+    m_context->makeContextCurrent();
+#if PLATFORM(GTK)
+    ::glDrawElementsInstanced(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)), primcount);
+#elif PLATFORM(COCOA)
+    ::glDrawElementsInstancedARB(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)), primcount);
+#else
+    UNUSED_PARAM(mode);
+    UNUSED_PARAM(count);
+    UNUSED_PARAM(type);
+    UNUSED_PARAM(offset);
+    UNUSED_PARAM(primcount);
+#endif
+}
+
+void Extensions3DOpenGL::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+{
+    m_context->makeContextCurrent();
+#if PLATFORM(GTK)
+    ::glVertexAttribDivisor(index, divisor);
+#elif PLATFORM(COCOA)
+    ::glVertexAttribDivisorARB(index, divisor);
+#else
+    UNUSED_PARAM(index);
+    UNUSED_PARAM(divisor);
+#endif
+}
+
 String Extensions3DOpenGL::getExtensions()
 {
+    ASSERT(!m_useIndexedGetString);
     return String(reinterpret_cast<const char*>(::glGetString(GL_EXTENSIONS)));
 }
 
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
 bool Extensions3DOpenGL::isVertexArrayObjectSupported()
 {
     static const bool supportsVertexArrayObject = supports("GL_OES_vertex_array_object");
@@ -246,4 +310,4 @@ bool Extensions3DOpenGL::isVertexArrayObjectSupported()
 
 } // namespace WebCore
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.h b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.h
index 81c5e49d5..c3fe83eb5 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.h
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGL.h
@@ -23,8 +23,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef Extensions3DOpenGL_h
-#define Extensions3DOpenGL_h
+#pragma once
 
 #include "Extensions3DOpenGLCommon.h"
 
@@ -37,35 +36,35 @@ namespace WebCore {
 class Extensions3DOpenGL : public Extensions3DOpenGLCommon {
     WTF_MAKE_FAST_ALLOCATED;
 public:
+    // This class only needs to be instantiated by GraphicsContext3D implementations.
+    Extensions3DOpenGL(GraphicsContext3D*, bool useIndexedGetString);
     virtual ~Extensions3DOpenGL();
 
     // Extensions3D methods.
-    virtual void blitFramebuffer(long srcX0, long srcY0, long srcX1, long srcY1, long dstX0, long dstY0, long dstX1, long dstY1, unsigned long mask, unsigned long filter);
-    virtual void renderbufferStorageMultisample(unsigned long target, unsigned long samples, unsigned long internalformat, unsigned long width, unsigned long height);
+    void blitFramebuffer(long srcX0, long srcY0, long srcX1, long srcY1, long dstX0, long dstY0, long dstX1, long dstY1, unsigned long mask, unsigned long filter) override;
+    void renderbufferStorageMultisample(unsigned long target, unsigned long samples, unsigned long internalformat, unsigned long width, unsigned long height) override;
+
+    Platform3DObject createVertexArrayOES() override;
+    void deleteVertexArrayOES(Platform3DObject) override;
+    GC3Dboolean isVertexArrayOES(Platform3DObject) override;
+    void bindVertexArrayOES(Platform3DObject) override;
+    void insertEventMarkerEXT(const String&) override;
+    void pushGroupMarkerEXT(const String&) override;
+    void popGroupMarkerEXT(void) override;
+    void drawBuffersEXT(GC3Dsizei, const GC3Denum*) override;
 
-    virtual Platform3DObject createVertexArrayOES();
-    virtual void deleteVertexArrayOES(Platform3DObject);
-    virtual GC3Dboolean isVertexArrayOES(Platform3DObject);
-    virtual void bindVertexArrayOES(Platform3DObject);
-    virtual void copyTextureCHROMIUM(GC3Denum, Platform3DObject, Platform3DObject, GC3Dint, GC3Denum);
-    virtual void insertEventMarkerEXT(const String&);
-    virtual void pushGroupMarkerEXT(const String&);
-    virtual void popGroupMarkerEXT(void);
-    virtual void drawBuffersEXT(GC3Dsizei, const GC3Denum*);
+    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount) override;
+    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount) override;
+    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor) override;
 
 protected:
-    // This class only needs to be instantiated by GraphicsContext3D implementations.
-    friend class GraphicsContext3D;
-    Extensions3DOpenGL(GraphicsContext3D*);
+    bool supportsExtension(const WTF::String&) override;
+    String getExtensions() override;
 
-    virtual bool supportsExtension(const WTF::String&);
-    virtual String getExtensions();
-#if (PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN))
 private:
+#if (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
     bool isVertexArrayObjectSupported();
 #endif
 };
 
 } // namespace WebCore
-
-#endif // Extensions3DOpenGL_h
diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp
index 9b7c5ab65..d28d765df 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.cpp
@@ -26,7 +26,7 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 #include "Extensions3DOpenGLCommon.h"
 
 #include "ANGLEWebKitBridge.h"
@@ -34,14 +34,18 @@
 
 #if PLATFORM(IOS)
 #include <OpenGLES/ES2/glext.h>
+#include <OpenGLES/ES3/gl.h>
 #else
 #if USE(OPENGL_ES_2)
 #include "OpenGLESShims.h"
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #elif PLATFORM(MAC)
+#define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
 #include <OpenGL/gl.h>
-#elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN)
+#include <OpenGL/gl3.h>
+#undef GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
+#elif PLATFORM(GTK) || PLATFORM(WIN)
 #include "OpenGLShims.h"
 #endif
 #endif
@@ -49,54 +53,39 @@
 #include <wtf/MainThread.h>
 #include <wtf/Vector.h>
 
-#if PLATFORM(WIN) || (PLATFORM(GTK) && OS(WINDOWS))
-#undef NO_ERROR
-#endif
-
 namespace WebCore {
 
-Extensions3DOpenGLCommon::Extensions3DOpenGLCommon(GraphicsContext3D* context)
+Extensions3DOpenGLCommon::Extensions3DOpenGLCommon(GraphicsContext3D* context, bool useIndexedGetString)
     : m_initializedAvailableExtensions(false)
     , m_context(context)
     , m_isNVIDIA(false)
     , m_isAMD(false)
     , m_isIntel(false)
-    , m_maySupportMultisampling(true)
+    , m_isImagination(false)
     , m_requiresBuiltInFunctionEmulation(false)
+    , m_requiresRestrictedMaximumTextureSize(false)
+    , m_useIndexedGetString(useIndexedGetString)
 {
     m_vendor = String(reinterpret_cast<const char*>(::glGetString(GL_VENDOR)));
+    m_renderer = String(reinterpret_cast<const char*>(::glGetString(GL_RENDERER)));
 
     Vector<String> vendorComponents;
-    m_vendor.lower().split(' ', vendorComponents);
+    m_vendor.convertToASCIILowercase().split(' ', vendorComponents);
     if (vendorComponents.contains("nvidia"))
         m_isNVIDIA = true;
     if (vendorComponents.contains("ati") || vendorComponents.contains("amd"))
         m_isAMD = true;
     if (vendorComponents.contains("intel"))
         m_isIntel = true;
+    if (vendorComponents.contains("imagination"))
+        m_isImagination = true;
 
-#if PLATFORM(MAC) && !PLATFORM(IOS)
+#if PLATFORM(MAC)
     if (m_isAMD || m_isIntel)
         m_requiresBuiltInFunctionEmulation = true;
 
-    // Currently in Mac we only allow multisampling if the vendor is NVIDIA,
-    // or if the vendor is AMD/ATI and the system is 10.7.2 and above.
-
-    bool systemSupportsMultisampling = true;
-#if !PLATFORM(IOS) && __MAC_OS_X_VERSION_MIN_REQUIRED < 1080
-    ASSERT(isMainThread());
-    static SInt32 version;
-    if (!version) {
-        if (Gestalt(gestaltSystemVersion, &version) != noErr)
-            systemSupportsMultisampling = false;
-    }
-    // See https://bugs.webkit.org/show_bug.cgi?id=77922 for more details
-    if (systemSupportsMultisampling)
-        systemSupportsMultisampling = version >= 0x1072;
-#endif // SNOW_LEOPARD and LION
-
-    if (m_isAMD && !systemSupportsMultisampling)
-        m_maySupportMultisampling = false;
+    // Intel HD 3000 devices have problems with large textures. <rdar://problem/16649140>
+    m_requiresRestrictedMaximumTextureSize = m_renderer.startsWith("Intel HD Graphics 3000");
 #endif
 }
 
@@ -109,6 +98,12 @@ bool Extensions3DOpenGLCommon::supports(const String& name)
     if (!m_initializedAvailableExtensions)
         initializeAvailableExtensions();
 
+    // We explicitly do not support this extension until
+    // we fix the following bug:
+    // https://bugs.webkit.org/show_bug.cgi?id=149734
+    if (name == "GL_ANGLE_translated_shader_source")
+        return false;
+
     return supportsExtension(name);
 }
 
@@ -131,6 +126,22 @@ void Extensions3DOpenGLCommon::ensureEnabled(const String& name)
             m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &ANGLEResources.MaxDrawBuffers);
             compiler.setResources(ANGLEResources);
         }
+    } else if (name == "GL_EXT_shader_texture_lod") {
+        // Enable support in ANGLE (if not enabled already)
+        ANGLEWebKitBridge& compiler = m_context->m_compiler;
+        ShBuiltInResources ANGLEResources = compiler.getResources();
+        if (!ANGLEResources.EXT_shader_texture_lod) {
+            ANGLEResources.EXT_shader_texture_lod = 1;
+            compiler.setResources(ANGLEResources);
+        }
+    } else if (name == "GL_EXT_frag_depth") {
+        // Enable support in ANGLE (if not enabled already)
+        ANGLEWebKitBridge& compiler = m_context->m_compiler;
+        ShBuiltInResources ANGLEResources = compiler.getResources();
+        if (!ANGLEResources.EXT_frag_depth) {
+            ANGLEResources.EXT_frag_depth = 1;
+            compiler.setResources(ANGLEResources);
+        }
     }
 }
 
@@ -174,22 +185,20 @@ String Extensions3DOpenGLCommon::getTranslatedShaderSourceANGLE(Platform3DObject
 
     String translatedShaderSource;
     String shaderInfoLog;
-    int extraCompileOptions = SH_MAP_LONG_VARIABLE_NAMES | SH_CLAMP_INDIRECT_ARRAY_BOUNDS | SH_UNFOLD_SHORT_CIRCUIT | SH_ENFORCE_PACKING_RESTRICTIONS;
+    int extraCompileOptions = SH_CLAMP_INDIRECT_ARRAY_BOUNDS | SH_UNFOLD_SHORT_CIRCUIT | SH_INIT_OUTPUT_VARIABLES | SH_ENFORCE_PACKING_RESTRICTIONS | SH_LIMIT_EXPRESSION_COMPLEXITY | SH_LIMIT_CALL_STACK_DEPTH;
 
     if (m_requiresBuiltInFunctionEmulation)
-        extraCompileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
+        extraCompileOptions |= SH_EMULATE_ABS_INT_FUNCTION;
 
-    Vector<ANGLEShaderSymbol> symbols;
+    Vector<std::pair<ANGLEShaderSymbolType, sh::ShaderVariable>> symbols;
     bool isValid = compiler.compileShaderSource(entry.source.utf8().data(), shaderType, translatedShaderSource, shaderInfoLog, symbols, extraCompileOptions);
 
     entry.log = shaderInfoLog;
     entry.isValid = isValid;
 
-    size_t numSymbols = symbols.size();
-    for (size_t i = 0; i < numSymbols; ++i) {
-        ANGLEShaderSymbol shaderSymbol = symbols[i];
-        GraphicsContext3D::SymbolInfo symbolInfo(shaderSymbol.dataType, shaderSymbol.size, shaderSymbol.mappedName, shaderSymbol.precision, shaderSymbol.staticUse);
-        entry.symbolMap(shaderSymbol.symbolType).set(shaderSymbol.name, symbolInfo);
+    for (const std::pair<ANGLEShaderSymbolType, sh::ShaderVariable>& pair : symbols) {
+        const std::string& name = pair.second.name;
+        entry.symbolMap(pair.first).set(String(name.c_str(), name.length()), pair.second);
     }
 
     if (!isValid)
@@ -200,11 +209,30 @@ String Extensions3DOpenGLCommon::getTranslatedShaderSourceANGLE(Platform3DObject
 
 void Extensions3DOpenGLCommon::initializeAvailableExtensions()
 {
-    String extensionsString = getExtensions();
-    Vector<String> availableExtensions;
-    extensionsString.split(" ", availableExtensions);
-    for (size_t i = 0; i < availableExtensions.size(); ++i)
-        m_availableExtensions.add(availableExtensions[i]);
+#if PLATFORM(MAC) || (PLATFORM(GTK) && !USE(OPENGL_ES_2))
+    if (m_useIndexedGetString) {
+        GLint numExtensions = 0;
+        ::glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
+        for (GLint i = 0; i < numExtensions; ++i)
+            m_availableExtensions.add(glGetStringi(GL_EXTENSIONS, i));
+
+        if (!m_availableExtensions.contains(ASCIILiteral("GL_ARB_texture_storage"))) {
+            GLint majorVersion;
+            glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
+            GLint minorVersion;
+            glGetIntegerv(GL_MINOR_VERSION, &minorVersion);
+            if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 2))
+                m_availableExtensions.add(ASCIILiteral("GL_ARB_texture_storage"));
+        }
+    } else
+#endif
+    {
+        String extensionsString = getExtensions();
+        Vector<String> availableExtensions;
+        extensionsString.split(' ', availableExtensions);
+        for (size_t i = 0; i < availableExtensions.size(); ++i)
+            m_availableExtensions.add(availableExtensions[i]);
+    }
     m_initializedAvailableExtensions = true;
 }
 
@@ -225,4 +253,4 @@ void Extensions3DOpenGLCommon::getnUniformivEXT(GC3Duint, int, GC3Dsizei, int *)
 
 } // namespace WebCore
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h
index 4cc8dbac1..7c614fb40 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLCommon.h
@@ -24,8 +24,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef Extensions3DOpenGLCommon_h
-#define Extensions3DOpenGLCommon_h
+#pragma once
 
 #include "Extensions3D.h"
 
@@ -40,36 +39,37 @@ public:
     virtual ~Extensions3DOpenGLCommon();
 
     // Extensions3D methods.
-    virtual bool supports(const String&);
-    virtual void ensureEnabled(const String&);
-    virtual bool isEnabled(const String&);
-    virtual int getGraphicsResetStatusARB();
+    bool supports(const String&) override;
+    void ensureEnabled(const String&) override;
+    bool isEnabled(const String&) override;
+    int getGraphicsResetStatusARB() override;
 
-    virtual Platform3DObject createVertexArrayOES() = 0;
-    virtual void deleteVertexArrayOES(Platform3DObject) = 0;
-    virtual GC3Dboolean isVertexArrayOES(Platform3DObject) = 0;
-    virtual void bindVertexArrayOES(Platform3DObject) = 0;
+    Platform3DObject createVertexArrayOES() override = 0;
+    void deleteVertexArrayOES(Platform3DObject) override = 0;
+    GC3Dboolean isVertexArrayOES(Platform3DObject) override = 0;
+    void bindVertexArrayOES(Platform3DObject) override = 0;
 
-    virtual void drawBuffersEXT(GC3Dsizei, const GC3Denum*) = 0;
+    void drawBuffersEXT(GC3Dsizei, const GC3Denum*) override = 0;
 
-    virtual String getTranslatedShaderSourceANGLE(Platform3DObject);
+    String getTranslatedShaderSourceANGLE(Platform3DObject) override;
 
     // EXT Robustness - uses getGraphicsResetStatusARB()
-    virtual void readnPixelsEXT(int x, int y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, GC3Dsizei bufSize, void *data);
-    virtual void getnUniformfvEXT(GC3Duint program, int location, GC3Dsizei bufSize, float *params);
-    virtual void getnUniformivEXT(GC3Duint program, int location, GC3Dsizei bufSize, int *params);
+    void readnPixelsEXT(int x, int y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, GC3Dsizei bufSize, void *data) override;
+    void getnUniformfvEXT(GC3Duint program, int location, GC3Dsizei bufSize, float *params) override;
+    void getnUniformivEXT(GC3Duint program, int location, GC3Dsizei bufSize, int *params) override;
 
-    virtual bool isNVIDIA() { return m_isNVIDIA; }
-    virtual bool isAMD() { return m_isAMD; }
-    virtual bool isIntel() { return m_isIntel; }
-    virtual String vendor() { return m_vendor; }
+    bool isNVIDIA() override { return m_isNVIDIA; }
+    bool isAMD() override { return m_isAMD; }
+    bool isIntel() override { return m_isIntel; }
+    bool isImagination() override { return m_isImagination; }
+    String vendor() override { return m_vendor; }
 
-    virtual bool maySupportMultisampling() { return m_maySupportMultisampling; }
-    virtual bool requiresBuiltInFunctionEmulation() { return m_requiresBuiltInFunctionEmulation; }
+    bool requiresBuiltInFunctionEmulation() override { return m_requiresBuiltInFunctionEmulation; }
+    bool requiresRestrictedMaximumTextureSize() override { return m_requiresRestrictedMaximumTextureSize; }
 
 protected:
     friend class Extensions3DOpenGLES;
-    Extensions3DOpenGLCommon(GraphicsContext3D*);
+    Extensions3DOpenGLCommon(GraphicsContext3D*, bool useIndexedGetString);
 
     virtual bool supportsExtension(const String&) = 0;
     virtual String getExtensions() = 0;
@@ -84,12 +84,14 @@ protected:
     bool m_isNVIDIA;
     bool m_isAMD;
     bool m_isIntel;
-    bool m_maySupportMultisampling;
+    bool m_isImagination;
     bool m_requiresBuiltInFunctionEmulation;
+    bool m_requiresRestrictedMaximumTextureSize;
+
+    bool m_useIndexedGetString { false };
 
     String m_vendor;
+    String m_renderer;
 };
 
 } // namespace WebCore
-
-#endif // Extensions3DOpenGLCommon_h
diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.cpp b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.cpp
index dc9e59252..958e09383 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.cpp
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
+ * Copyright (C) 2014 Collabora Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -25,21 +26,23 @@
  */
 
 #include "config.h"
-#if USE(3D_GRAPHICS)
+
+#if USE(OPENGL_ES_2)
 #include "Extensions3DOpenGLES.h"
 
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 #include "GraphicsContext3D.h"
 #include "NotImplemented.h"
 #include <EGL/egl.h>
-#include <wtf/Vector.h>
 
 namespace WebCore {
 
-Extensions3DOpenGLES::Extensions3DOpenGLES(GraphicsContext3D* context)
-    : Extensions3DOpenGLCommon(context)
+Extensions3DOpenGLES::Extensions3DOpenGLES(GraphicsContext3D* context, bool useIndexedGetString)
+    : Extensions3DOpenGLCommon(context, useIndexedGetString)
     , m_contextResetStatus(GL_NO_ERROR)
     , m_supportsOESvertexArrayObject(false)
     , m_supportsIMGMultisampledRenderToTexture(false)
+    , m_supportsANGLEinstancedArrays(false)
     , m_glFramebufferTexture2DMultisampleIMG(0)
     , m_glRenderbufferStorageMultisampleIMG(0)
     , m_glBindVertexArrayOES(0)
@@ -50,6 +53,9 @@ Extensions3DOpenGLES::Extensions3DOpenGLES(GraphicsContext3D* context)
     , m_glReadnPixelsEXT(0)
     , m_glGetnUniformfvEXT(0)
     , m_glGetnUniformivEXT(0)
+    , m_glVertexAttribDivisorANGLE(nullptr)
+    , m_glDrawArraysInstancedANGLE(nullptr)
+    , m_glDrawElementsInstancedANGLE(nullptr)
 {
 }
 
@@ -73,7 +79,7 @@ void Extensions3DOpenGLES::renderbufferStorageMultisampleIMG(unsigned long targe
         m_context->synthesizeGLError(GL_INVALID_OPERATION);
 }
 
-void Extensions3DOpenGLES::blitFramebuffer(long srcX0, long srcY0, long srcX1, long srcY1, long dstX0, long dstY0, long dstX1, long dstY1, unsigned long mask, unsigned long filter)
+void Extensions3DOpenGLES::blitFramebuffer(long /* srcX0 */, long /* srcY0 */, long /* srcX1 */, long /* srcY1 */, long /* dstX0 */, long /* dstY0 */, long /* dstX1 */, long /* dstY1 */, unsigned long /* mask */, unsigned long /* filter */)
 {
     notImplemented();
 }
@@ -86,11 +92,6 @@ void Extensions3DOpenGLES::renderbufferStorageMultisample(unsigned long target,
         notImplemented();
 }
 
-void Extensions3DOpenGLES::copyTextureCHROMIUM(GC3Denum, Platform3DObject, Platform3DObject, GC3Dint, GC3Denum)
-{
-    notImplemented();
-}
-
 void Extensions3DOpenGLES::insertEventMarkerEXT(const String&)
 {
     notImplemented();
@@ -156,9 +157,10 @@ void Extensions3DOpenGLES::bindVertexArrayOES(Platform3DObject array)
         m_context->synthesizeGLError(GL_INVALID_OPERATION);
 }
 
-void Extensions3DOpenGLES::drawBuffersEXT(GC3Dsizei n, const GC3Denum* bufs)
+void Extensions3DOpenGLES::drawBuffersEXT(GC3Dsizei /* n */, const GC3Denum* /* bufs */)
 {
     // FIXME: implement the support.
+    notImplemented();
 }
 
 int Extensions3DOpenGLES::getGraphicsResetStatusARB()
@@ -184,9 +186,9 @@ int Extensions3DOpenGLES::getGraphicsResetStatusARB()
     return false;
 }
 
-void Extensions3DOpenGLES::setEXTContextLostCallback(PassOwnPtr<GraphicsContext3D::ContextLostCallback> callback)
+void Extensions3DOpenGLES::setEXTContextLostCallback(std::unique_ptr<GraphicsContext3D::ContextLostCallback> callback)
 {
-    m_contextLostCallback = callback;
+    m_contextLostCallback = WTFMove(callback);
 }
 
 void Extensions3DOpenGLES::readnPixelsEXT(int x, int y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, GC3Dsizei bufSize, void *data)
@@ -228,6 +230,39 @@ void Extensions3DOpenGLES::getnUniformivEXT(GC3Duint program, int location, GC3D
     m_context->synthesizeGLError(GL_INVALID_OPERATION);
 }
 
+void Extensions3DOpenGLES::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+{
+    if (!m_glDrawArraysInstancedANGLE) {
+        m_context->synthesizeGLError(GL_INVALID_OPERATION);
+        return;
+    }
+
+    m_context->makeContextCurrent();
+    m_glDrawArraysInstancedANGLE(mode, first, count, primcount);
+}
+
+void Extensions3DOpenGLES::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)
+{
+    if (!m_glDrawElementsInstancedANGLE) {
+        m_context->synthesizeGLError(GL_INVALID_OPERATION);
+        return;
+    }
+
+    m_context->makeContextCurrent();
+    m_glDrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)), primcount);
+}
+
+void Extensions3DOpenGLES::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+{
+    if (!m_glVertexAttribDivisorANGLE) {
+        m_context->synthesizeGLError(GL_INVALID_OPERATION);
+        return;
+    }
+
+    m_context->makeContextCurrent();
+    m_glVertexAttribDivisorANGLE(index, divisor);
+}
+
 bool Extensions3DOpenGLES::supportsExtension(const String& name)
 {
     if (m_availableExtensions.contains(name)) {
@@ -238,14 +273,19 @@ bool Extensions3DOpenGLES::supportsExtension(const String& name)
             m_glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOESPROC>(eglGetProcAddress("glIsVertexArrayOES"));
             m_supportsOESvertexArrayObject = true;
         } else if (!m_supportsIMGMultisampledRenderToTexture && name == "GL_IMG_multisampled_render_to_texture") {
-            m_glFramebufferTexture2DMultisampleIMG = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG>(eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"));
-            m_glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG>(eglGetProcAddress("glRenderbufferStorageMultisampleIMG"));
+            m_glFramebufferTexture2DMultisampleIMG = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC>(eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"));
+            m_glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC>(eglGetProcAddress("glRenderbufferStorageMultisampleIMG"));
             m_supportsIMGMultisampledRenderToTexture = true;
         } else if (!m_glGetGraphicsResetStatusEXT && name == "GL_EXT_robustness") {
             m_glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>(eglGetProcAddress("glGetGraphicsResetStatusEXT"));
             m_glReadnPixelsEXT = reinterpret_cast<PFNGLREADNPIXELSEXTPROC>(eglGetProcAddress("glReadnPixelsEXT"));
             m_glGetnUniformfvEXT = reinterpret_cast<PFNGLGETNUNIFORMFVEXTPROC>(eglGetProcAddress("glGetnUniformfvEXT"));
             m_glGetnUniformivEXT = reinterpret_cast<PFNGLGETNUNIFORMIVEXTPROC>(eglGetProcAddress("glGetnUniformivEXT"));
+        } else if (!m_supportsANGLEinstancedArrays && name == "GL_ANGLE_instanced_arrays") {
+            m_glVertexAttribDivisorANGLE = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORANGLEPROC>(eglGetProcAddress("glVertexAttribDivisorANGLE"));
+            m_glDrawArraysInstancedANGLE = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawArraysInstancedANGLE"));
+            m_glDrawElementsInstancedANGLE = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawElementsInstancedANGLE"));
+            m_supportsANGLEinstancedArrays = true;
         } else if (name == "GL_EXT_draw_buffers") {
             // FIXME: implement the support.
             return false;
@@ -263,4 +303,6 @@ String Extensions3DOpenGLES::getExtensions()
 
 } // namespace WebCore
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
+
+#endif // USE(OPENGL_ES_2)
diff --git a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.h b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.h
index 7c40566e9..316e5e9b5 100644
--- a/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.h
+++ b/Source/WebCore/platform/graphics/opengl/Extensions3DOpenGLES.h
@@ -24,11 +24,12 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef Extensions3DOpenGLES_h
-#define Extensions3DOpenGLES_h
+#pragma once
 
 #include "Extensions3DOpenGLCommon.h"
 
+#if USE(OPENGL_ES_2)
+
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
@@ -61,6 +62,8 @@ namespace WebCore {
 
 class Extensions3DOpenGLES : public Extensions3DOpenGLCommon {
 public:
+    // This class only needs to be instantiated by GraphicsContext3D implementations.
+    Extensions3DOpenGLES(GraphicsContext3D*, bool useIndexedGetString);
     virtual ~Extensions3DOpenGLES();
 
     virtual void framebufferTexture2DMultisampleIMG(unsigned long target, unsigned long attachment, unsigned long textarget, unsigned int texture, int level, unsigned long samples);
@@ -69,7 +72,6 @@ public:
     // Extension3D methods
     virtual void blitFramebuffer(long srcX0, long srcY0, long srcX1, long srcY1, long dstX0, long dstY0, long dstX1, long dstY1, unsigned long mask, unsigned long filter);
     virtual void renderbufferStorageMultisample(unsigned long target, unsigned long samples, unsigned long internalformat, unsigned long width, unsigned long height);
-    virtual void copyTextureCHROMIUM(GC3Denum, Platform3DObject, Platform3DObject, GC3Dint, GC3Denum);
     virtual void insertEventMarkerEXT(const String&);
     virtual void pushGroupMarkerEXT(const String&);
     virtual void popGroupMarkerEXT(void);
@@ -80,9 +82,13 @@ public:
     virtual void bindVertexArrayOES(Platform3DObject);
     virtual void drawBuffersEXT(GC3Dsizei, const GC3Denum*);
 
+    virtual void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
+    virtual void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);
+    virtual void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
+
     // EXT Robustness - reset
     virtual int getGraphicsResetStatusARB();
-    void setEXTContextLostCallback(PassOwnPtr<GraphicsContext3D::ContextLostCallback>);
+    void setEXTContextLostCallback(std::unique_ptr<GraphicsContext3D::ContextLostCallback>);
 
     // EXT Robustness - etc
     virtual void readnPixelsEXT(int x, int y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, GC3Dsizei bufSize, void *data);
@@ -90,10 +96,6 @@ public:
     virtual void getnUniformivEXT(GC3Duint program, int location, GC3Dsizei bufSize, int *params);
 
 protected:
-    // This class only needs to be instantiated by GraphicsContext3D implementations.
-    friend class GraphicsContext3D;
-    Extensions3DOpenGLES(GraphicsContext3D*);
-
     virtual bool supportsExtension(const String&);
     virtual String getExtensions();
 
@@ -101,9 +103,10 @@ protected:
 
     bool m_supportsOESvertexArrayObject;
     bool m_supportsIMGMultisampledRenderToTexture;
+    bool m_supportsANGLEinstancedArrays;
 
-    PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG m_glFramebufferTexture2DMultisampleIMG;
-    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG m_glRenderbufferStorageMultisampleIMG;
+    PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC m_glFramebufferTexture2DMultisampleIMG;
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC m_glRenderbufferStorageMultisampleIMG;
     PFNGLBINDVERTEXARRAYOESPROC m_glBindVertexArrayOES;
     PFNGLDELETEVERTEXARRAYSOESPROC m_glDeleteVertexArraysOES;
     PFNGLGENVERTEXARRAYSOESPROC m_glGenVertexArraysOES;
@@ -112,10 +115,13 @@ protected:
     PFNGLREADNPIXELSEXTPROC m_glReadnPixelsEXT;
     PFNGLGETNUNIFORMFVEXTPROC m_glGetnUniformfvEXT;
     PFNGLGETNUNIFORMIVEXTPROC m_glGetnUniformivEXT;
+    PFNGLVERTEXATTRIBDIVISORANGLEPROC m_glVertexAttribDivisorANGLE;
+    PFNGLDRAWARRAYSINSTANCEDANGLEPROC m_glDrawArraysInstancedANGLE;
+    PFNGLDRAWELEMENTSINSTANCEDANGLEPROC m_glDrawElementsInstancedANGLE;
 
-    OwnPtr<GraphicsContext3D::ContextLostCallback> m_contextLostCallback;
+    std::unique_ptr<GraphicsContext3D::ContextLostCallback> m_contextLostCallback;
 };
 
 } // namespace WebCore
 
-#endif // Extensions3DOpenGLES_h
+#endif // USE(OPENGL_ES_2)
diff --git a/Source/WebCore/platform/graphics/opengl/GLDefs.h b/Source/WebCore/platform/graphics/opengl/GLDefs.h
new file mode 100644
index 000000000..9a2c2fffd
--- /dev/null
+++ b/Source/WebCore/platform/graphics/opengl/GLDefs.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2012 Intel Corporation. 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
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef GLDefs_h
+#define GLDefs_h
+
+#define GL_GLEXT_PROTOTYPES 1
+
+#if USE(OPENGL_ES_2)
+#include "Extensions3DOpenGLES.h"
+#include "OpenGLESShims.h"
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#else
+#include "Extensions3DOpenGL.h"
+#include "OpenGLShims.h"
+#include <GL/gl.h>
+#include <GL/glext.h>
+#if USE(GLX)
+#define GLX_GLXEXT_PROTOTYPES 1
+#include <GL/glx.h>
+#include <GL/glxext.h>
+#endif
+#endif
+
+#if USE(EGL)
+#define EGL_EGLEXT_PROTOTYPES 1
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#endif
+
+namespace WebCore {
+
+typedef uint32_t PlatformBufferHandle;
+
+#if USE(GLX)
+typedef GLXContext PlatformContext;
+typedef GLXFBConfig PlatformSurfaceConfig;
+typedef GLXDrawable PlatformDrawable;
+#elif USE(EGL)
+typedef EGLContext PlatformContext;
+typedef EGLConfig PlatformSurfaceConfig;
+typedef EGLSurface PlatformDrawable;
+#else
+typedef void* PlatformContext;
+typedef void* PlatformSurfaceConfig;
+typedef void* PlatformDrawable;
+#endif
+
+}
+
+#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp
new file mode 100644
index 000000000..5219a2391
--- /dev/null
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2012 Intel Corporation. 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
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(GRAPHICS_CONTEXT_3D)
+#include "GLPlatformContext.h"
+
+#if USE(GLX)
+#include "GLXContext.h"
+#elif USE(EGL)
+#include "EGLContext.h"
+#endif
+
+#include "NotImplemented.h"
+
+namespace WebCore {
+
+#if USE(OPENGL_ES_2)
+static PFNGLGETGRAPHICSRESETSTATUSEXTPROC glGetGraphicsResetStatus = 0;
+#else
+static PFNGLGETGRAPHICSRESETSTATUSARBPROC glGetGraphicsResetStatus = 0;
+#endif
+
+class GLCurrentContextWrapper : public GLPlatformContext {
+
+public:
+    GLCurrentContextWrapper()
+        : GLPlatformContext()
+    {
+#if USE(GLX)
+        m_contextHandle = glXGetCurrentContext();
+#elif USE(EGL)
+        m_contextHandle = eglGetCurrentContext();
+#endif
+    }
+
+    virtual ~GLCurrentContextWrapper() { }
+
+    bool isCurrentContext() const override
+    {
+        return true;
+    }
+};
+
+static std::unique_ptr<GLPlatformContext> createOffScreenContext()
+{
+#if USE(GLX)
+    return std::make_unique<GLXOffScreenContext>();
+#elif USE(EGL)
+    return std::make_unique<EGLOffScreenContext>();
+#else
+    return nullptr;
+#endif
+}
+
+static HashSet<String> parseExtensions(const String& extensionsString)
+{
+    Vector<String> extNames;
+    extensionsString.split(' ', extNames);
+    HashSet<String> splitExtNames;
+    unsigned size = extNames.size();
+    for (unsigned i = 0; i < size; ++i)
+        splitExtNames.add(extNames[i]);
+    extNames.clear();
+
+    return splitExtNames;
+}
+
+static void resolveResetStatusExtension()
+{
+    static bool resolvedRobustnessExtension = false;
+    if (!resolvedRobustnessExtension) {
+        resolvedRobustnessExtension = true;
+#if USE(OPENGL_ES_2)
+        glGetGraphicsResetStatus = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>(eglGetProcAddress("glGetGraphicsResetStatusEXT"));
+#elif USE(EGL)
+        glGetGraphicsResetStatus = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSARBPROC>(eglGetProcAddress("glGetGraphicsResetStatusARB"));
+#elif USE(GLX)
+        glGetGraphicsResetStatus = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSARBPROC>(glXGetProcAddressARB(reinterpret_cast<const GLubyte*>("glGetGraphicsResetStatusARB")));
+#endif
+    }
+}
+
+std::unique_ptr<GLPlatformContext> GLPlatformContext::createContext(GraphicsContext3D::RenderStyle renderStyle)
+{
+#if !USE(OPENGL_ES_2)
+    if (!initializeOpenGLShims())
+        return nullptr;
+#endif
+
+    switch (renderStyle) {
+    case GraphicsContext3D::RenderOffscreen:
+        return createOffScreenContext();
+    case GraphicsContext3D::RenderToCurrentGLContext:
+        return std::make_unique<GLCurrentContextWrapper>();
+    case GraphicsContext3D::RenderDirectlyToHostWindow:
+        ASSERT_NOT_REACHED();
+        break;
+    }
+
+    return nullptr;
+}
+
+bool GLPlatformContext::supportsGLExtension(const String& name)
+{
+    static HashSet<String> supportedExtensions;
+
+    if (!supportedExtensions.size()) {
+        String rawExtensions = reinterpret_cast<const char*>(::glGetString(GL_EXTENSIONS));
+        supportedExtensions = parseExtensions(rawExtensions);
+    }
+
+    if (supportedExtensions.contains(name))
+        return true;
+
+    return false;
+}
+
+#if USE(EGL)
+bool GLPlatformContext::supportsEGLExtension(EGLDisplay display, const String& name)
+{
+    static HashSet<String> supportedExtensions;
+
+    if (!supportedExtensions.size()) {
+        if (display == EGL_NO_DISPLAY)
+            return false;
+
+        String rawExtensions = reinterpret_cast<const char*>(eglQueryString(display, EGL_EXTENSIONS));
+        supportedExtensions = parseExtensions(rawExtensions);
+    }
+
+    if (supportedExtensions.contains(name))
+        return true;
+
+    return false;
+}
+#endif
+
+#if USE(GLX)
+bool GLPlatformContext::supportsGLXExtension(Display* display, const String& name)
+{
+    static HashSet<String> supportedExtensions;
+
+    if (!supportedExtensions.size()) {
+        if (!display)
+            return false;
+
+        String rawExtensions = glXQueryExtensionsString(display, DefaultScreen(display));
+        supportedExtensions = parseExtensions(rawExtensions);
+    }
+
+    if (supportedExtensions.contains(name))
+        return true;
+
+    return false;
+}
+#endif
+
+GLPlatformContext::GLPlatformContext()
+    : m_contextHandle(0)
+    , m_resetLostContext(false)
+{
+}
+
+GLPlatformContext::~GLPlatformContext()
+{
+}
+
+bool GLPlatformContext::makeCurrent(GLPlatformSurface* surface)
+{
+    m_contextLost = false;
+
+    if (isCurrentContext() && (!surface || surface->isCurrentDrawable()))
+        return true;
+
+    GLPlatformContext* currentContext = 0;
+
+    if (!surface || (surface && !surface->drawable()))
+        platformReleaseCurrent();
+    else if (platformMakeCurrent(surface)) {
+        currentContext = this;
+        surface->onMakeCurrent();
+    }
+
+    if (m_resetLostContext) {
+        resolveResetStatusExtension();
+
+        if (glGetGraphicsResetStatus) {
+            GLenum status = glGetGraphicsResetStatus();
+
+            switch (status) {
+            case PLATFORMCONTEXT_NO_ERROR:
+                break;
+            case PLATFORMCONTEXT_GUILTY_CONTEXT_RESET:
+                m_contextLost = true;
+                break;
+            case PLATFORMCONTEXT_INNOCENT_CONTEXT_RESET:
+                break;
+            case PLATFORMCONTEXT_UNKNOWN_CONTEXT_RESET:
+                m_contextLost = true;
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    return currentContext;
+}
+
+bool GLPlatformContext::isValid() const
+{
+    return !m_contextLost;
+}
+
+void GLPlatformContext::releaseCurrent()
+{
+    if (isCurrentContext())
+        platformReleaseCurrent();
+}
+
+PlatformContext GLPlatformContext::handle() const
+{
+    return m_contextHandle;
+}
+
+bool GLPlatformContext::initialize(GLPlatformSurface*, PlatformContext)
+{
+    return true;
+}
+
+bool GLPlatformContext::platformMakeCurrent(GLPlatformSurface*)
+{
+    return true;
+}
+
+void GLPlatformContext::platformReleaseCurrent()
+{
+    notImplemented();
+}
+
+void GLPlatformContext::destroy()
+{
+    m_contextHandle = 0;
+    m_resetLostContext = false;
+}
+
+} // namespace WebCore
+
+#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h
new file mode 100644
index 000000000..a999cc0cf
--- /dev/null
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformContext.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2012 Intel Corporation. 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
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef GLPlatformContext_h
+#define GLPlatformContext_h
+
+#include "GLDefs.h"
+#include "GLPlatformSurface.h"
+#include "GraphicsContext3D.h"
+#include <wtf/Noncopyable.h>
+
+// Encapsulates an OpenGL context, hiding platform specific management.
+namespace WebCore {
+
+class GLPlatformContext {
+    WTF_MAKE_NONCOPYABLE(GLPlatformContext);
+
+public:
+    // From http://www.khronos.org/registry/gles/extensions/EXT/EXT_robustness.txt
+    enum PlatformContextReset {
+        PLATFORMCONTEXT_NO_ERROR = 0x0000,
+        PLATFORMCONTEXT_GUILTY_CONTEXT_RESET = 0x8253,
+        PLATFORMCONTEXT_INNOCENT_CONTEXT_RESET = 0x8254,
+        PLATFORMCONTEXT_UNKNOWN_CONTEXT_RESET = 0x8255,
+    };
+
+    static std::unique_ptr<GLPlatformContext> createContext(GraphicsContext3D::RenderStyle);
+
+    static bool supportsGLExtension(const String&);
+
+#if USE(EGL)
+    static bool supportsEGLExtension(EGLDisplay, const String&);
+#endif
+
+#if USE(GLX)
+    static bool supportsGLXExtension(Display*, const String&);
+#endif
+
+    virtual ~GLPlatformContext();
+
+    virtual bool initialize(GLPlatformSurface*, PlatformContext = 0);
+
+    // Makes this and surface as current context and drawable.
+    // Calling this function with no surface is same as calling releaseCurrent.
+    // Does nothing if this is already current Context.
+    bool makeCurrent(GLPlatformSurface* = 0);
+
+    // Sets Current Context and Drawable as Null.
+    // Doesn't have any effect if this is not the current Context.
+    void releaseCurrent();
+
+    virtual PlatformContext handle() const;
+
+    virtual bool isCurrentContext() const = 0;
+
+    bool isValid() const;
+
+    // Destroys any GL resources associated with this context.
+    virtual void destroy();
+
+protected:
+    GLPlatformContext();
+    virtual bool platformMakeCurrent(GLPlatformSurface*);
+    virtual void platformReleaseCurrent();
+    PlatformContext m_contextHandle;
+    bool m_resetLostContext;
+    bool m_contextLost;
+};
+
+} // namespace WebCore
+
+#endif // GLNativeContext_H
diff --git a/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h
new file mode 100644
index 000000000..2d99d6f2d
--- /dev/null
+++ b/Source/WebCore/platform/graphics/opengl/GLPlatformSurface.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2012 Intel Corporation. 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
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef GLPlatformSurface_h
+#define GLPlatformSurface_h
+
+#include "GLDefs.h"
+#include "IntRect.h"
+#include <wtf/Noncopyable.h>
+
+// Encapsulates a surface that can be rendered to with GL, hiding platform
+// specific management.
+namespace WebCore {
+
+class GLPlatformSurface {
+    WTF_MAKE_NONCOPYABLE(GLPlatformSurface);
+
+public:
+    enum Attributes {
+        Default = 0x00, // No Alpha channel. Only R,G,B values set.
+        SupportAlpha = 0x01,
+        DoubleBuffered = 0x02
+    };
+
+    typedef unsigned SurfaceAttributes;
+    // Creates a GL surface used for offscreen rendering.
+    static std::unique_ptr<GLPlatformSurface> createOffScreenSurface(SurfaceAttributes = GLPlatformSurface::Default);
+
+    virtual ~GLPlatformSurface();
+
+    const IntRect& geometry() const;
+
+    // Get the underlying platform specific buffer handle.
+    // The handle will be null if surface doesn't support
+    // buffer sharing.
+    PlatformBufferHandle handle() const;
+
+    PlatformDrawable drawable() const;
+
+    virtual SurfaceAttributes attributes() const;
+
+    virtual void swapBuffers();
+
+    virtual bool isCurrentDrawable() const = 0;
+
+    virtual void onMakeCurrent();
+
+    // Convenience Function to update surface backbuffer with texture contents.
+    // Note that the function doesn't track or restore any GL states.
+    // Function does the following(in order):
+    // a) Blits texture contents to back buffer.
+    // b) Calls Swap Buffers.
+    virtual void updateContents(const uint32_t);
+
+    virtual void setGeometry(const IntRect&);
+
+    virtual PlatformSurfaceConfig configuration();
+
+    virtual void destroy();
+
+protected:
+    GLPlatformSurface(SurfaceAttributes);
+
+    PlatformDrawable m_drawable;
+    PlatformBufferHandle m_bufferHandle;
+    IntRect m_rect;
+};
+
+}
+
+#endif
diff --git a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp
index 02e1b9ec8..25c9a221c 100644
--- a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp
+++ b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp
@@ -11,10 +11,10 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -26,7 +26,7 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 
 #include "GraphicsContext3D.h"
 #if PLATFORM(IOS)
@@ -44,14 +44,21 @@
 #include <wtf/MainThread.h>
 #include <wtf/text/CString.h>
 
+#if USE(ACCELERATE)
+#include <Accelerate/Accelerate.h>
+#endif
+
 #if PLATFORM(IOS)
 #import <OpenGLES/ES2/glext.h>
 // From <OpenGLES/glext.h>
 #define GL_RGBA32F_ARB                      0x8814
 #define GL_RGB32F_ARB                       0x8815
 #elif PLATFORM(MAC)
+#define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
 #include <OpenGL/gl.h>
-#elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN)
+#include <OpenGL/gl3.h>
+#undef GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
+#elif PLATFORM(GTK) || PLATFORM(WIN)
 #include "OpenGLShims.h"
 #endif
 
@@ -65,7 +72,32 @@ void GraphicsContext3D::releaseShaderCompiler()
 
 void GraphicsContext3D::readPixelsAndConvertToBGRAIfNecessary(int x, int y, int width, int height, unsigned char* pixels)
 {
-    ::glReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
+    // NVIDIA drivers have a bug where calling readPixels in BGRA can return the wrong values for the alpha channel when the alpha is off for the context.
+    if (!m_attrs.alpha && getExtensions().isNVIDIA()) {
+        ::glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+#if USE(ACCELERATE)
+        vImage_Buffer src;
+        src.height = height;
+        src.width = width;
+        src.rowBytes = width * 4;
+        src.data = pixels;
+
+        vImage_Buffer dest;
+        dest.height = height;
+        dest.width = width;
+        dest.rowBytes = width * 4;
+        dest.data = pixels;
+
+        // Swap pixel channels from RGBA to BGRA.
+        const uint8_t map[4] = { 2, 1, 0, 3 };
+        vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags);
+#else
+        int totalBytes = width * height * 4;
+        for (int i = 0; i < totalBytes; i += 4)
+            std::swap(pixels[i], pixels[i + 2]);
+#endif
+    } else
+        ::glReadPixels(x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
 }
 
 void GraphicsContext3D::validateAttributes()
@@ -89,9 +121,9 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
         // We don't allow the logic where stencil is required and depth is not.
         // See GraphicsContext3D::validateAttributes.
 
-        Extensions3D* extensions = getExtensions();
+        Extensions3D& extensions = getExtensions();
         // Use a 24 bit depth buffer where we know we have it.
-        if (extensions->supports("GL_EXT_packed_depth_stencil"))
+        if (extensions.supports("GL_EXT_packed_depth_stencil"))
             internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
         else
 #if PLATFORM(IOS)
@@ -110,7 +142,11 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
             sampleCount = maxSampleCount;
         ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
         ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
+#if PLATFORM(IOS)
+        ::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, GL_RGBA8_OES, width, height);
+#else
         ::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, m_internalColorFormat, width, height);
+#endif
         ::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
         if (m_attrs.stencil || m_attrs.depth) {
             ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
@@ -143,9 +179,31 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
         ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture);
         ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
         ::glBindTexture(GL_TEXTURE_2D, 0);
+#if USE(COORDINATED_GRAPHICS_THREADED)
+        ::glBindTexture(GL_TEXTURE_2D, m_intermediateTexture);
+        ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
+        ::glBindTexture(GL_TEXTURE_2D, 0);
+#endif
     }
 #endif
 
+    attachDepthAndStencilBufferIfNeeded(internalDepthStencilFormat, width, height);
+
+    bool mustRestoreFBO = true;
+    if (m_attrs.antialias) {
+        ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
+        if (m_state.boundFBO == m_multisampleFBO)
+            mustRestoreFBO = false;
+    } else {
+        if (m_state.boundFBO == m_fbo)
+            mustRestoreFBO = false;
+    }
+
+    return mustRestoreFBO;
+}
+
+void GraphicsContext3D::attachDepthAndStencilBufferIfNeeded(GLuint internalDepthStencilFormat, int width, int height)
+{
     if (!m_attrs.antialias && (m_attrs.stencil || m_attrs.depth)) {
         ::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
         ::glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
@@ -160,18 +218,6 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
         // FIXME: cleanup
         notImplemented();
     }
-
-    bool mustRestoreFBO = true;
-    if (m_attrs.antialias) {
-        ::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
-        if (m_state.boundFBO == m_multisampleFBO)
-            mustRestoreFBO = false;
-    } else {
-        if (m_state.boundFBO == m_fbo)
-            mustRestoreFBO = false;
-    }
-
-    return mustRestoreFBO;
 }
 
 void GraphicsContext3D::resolveMultisamplingIfNecessary(const IntRect& rect)
@@ -181,11 +227,20 @@ void GraphicsContext3D::resolveMultisamplingIfNecessary(const IntRect& rect)
     TemporaryOpenGLSetting scopedDepth(GL_DEPTH_TEST, GL_FALSE);
     TemporaryOpenGLSetting scopedStencil(GL_STENCIL_TEST, GL_FALSE);
 
+#if PLATFORM(IOS)
+    GLint boundFrameBuffer;
+    ::glGetIntegerv(GL_FRAMEBUFFER_BINDING, &boundFrameBuffer);
+#endif
+
     ::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
     ::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
 #if PLATFORM(IOS)
     UNUSED_PARAM(rect);
+    ::glFlush();
     ::glResolveMultisampleFramebufferAPPLE();
+    const GLenum discards[] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT };
+    ::glDiscardFramebufferEXT(GL_READ_FRAMEBUFFER_APPLE, 2, discards);
+    ::glBindFramebuffer(GL_FRAMEBUFFER, boundFrameBuffer);
 #else
     IntRect resolveRect = rect;
     if (rect.isEmpty())
@@ -236,10 +291,29 @@ void GraphicsContext3D::getIntegerv(GC3Denum pname, GC3Dint* value)
         *value /= 4;
         break;
     case MAX_VARYING_VECTORS:
-        ::glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
-        *value /= 4;
+        if (isGLES2Compliant()) {
+            ASSERT(::glGetError() == GL_NO_ERROR);
+            ::glGetIntegerv(GL_MAX_VARYING_VECTORS, value);
+            if (::glGetError() == GL_INVALID_ENUM) {
+                ::glGetIntegerv(GL_MAX_VARYING_COMPONENTS, value);
+                *value /= 4;
+            }
+        } else {
+            ::glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
+            *value /= 4;
+        }
         break;
 #endif
+    case MAX_TEXTURE_SIZE:
+        ::glGetIntegerv(MAX_TEXTURE_SIZE, value);
+        if (getExtensions().requiresRestrictedMaximumTextureSize())
+            *value = std::min(4096, *value);
+        break;
+    case MAX_CUBE_MAP_TEXTURE_SIZE:
+        ::glGetIntegerv(MAX_CUBE_MAP_TEXTURE_SIZE, value);
+        if (getExtensions().requiresRestrictedMaximumTextureSize())
+            *value = std::min(1024, *value);
+        break;
     default:
         ::glGetIntegerv(pname, value);
     }
@@ -283,14 +357,15 @@ bool GraphicsContext3D::texImage2D(GC3Denum target, GC3Dint level, GC3Denum inte
         return false;
     }
 
+    GC3Denum openGLFormat = format;
     GC3Denum openGLInternalFormat = internalformat;
+#if !PLATFORM(IOS)
     if (type == GL_FLOAT) {
         if (format == GL_RGBA)
             openGLInternalFormat = GL_RGBA32F_ARB;
         else if (format == GL_RGB)
             openGLInternalFormat = GL_RGB32F_ARB;
     } else if (type == HALF_FLOAT_OES) {
-#if !PLATFORM(IOS)
         if (format == GL_RGBA)
             openGLInternalFormat = GL_RGBA16F_ARB;
         else if (format == GL_RGB)
@@ -302,9 +377,25 @@ bool GraphicsContext3D::texImage2D(GC3Denum target, GC3Dint level, GC3Denum inte
         else if (format == GL_LUMINANCE_ALPHA)
             openGLInternalFormat = GL_LUMINANCE_ALPHA16F_ARB;
         type = GL_HALF_FLOAT_ARB;
+    }
+
+    ASSERT(format != Extensions3D::SRGB8_ALPHA8_EXT);
+    if (format == Extensions3D::SRGB_ALPHA_EXT)
+        openGLFormat = GL_RGBA;
+    else if (format == Extensions3D::SRGB_EXT)
+        openGLFormat = GL_RGB;
 #endif
+
+    if (m_usingCoreProfile && openGLInternalFormat == ALPHA) {
+        // We are using a core profile. This means that GL_ALPHA, which is a valid format in WebGL for texImage2D
+        // is not supported in OpenGL. It needs to be backed with a GL_RED plane. We change the formats to GL_RED
+        // (both need to be GL_ALPHA in WebGL) and instruct the texture to swizzle the red component values with
+        // the the alpha component values.
+        openGLInternalFormat = openGLFormat = RED;
+        texParameteri(target, TEXTURE_SWIZZLE_A, RED);
     }
-    texImage2DDirect(target, level, openGLInternalFormat, width, height, border, format, type, pixels);
+
+    texImage2DDirect(target, level, openGLInternalFormat, width, height, border, openGLFormat, type, pixels);
     return true;
 }
 
@@ -328,12 +419,14 @@ void GraphicsContext3D::clearDepth(GC3Dclampf depth)
 #endif
 }
 
-Extensions3D* GraphicsContext3D::getExtensions()
+#if !PLATFORM(GTK)
+Extensions3D& GraphicsContext3D::getExtensions()
 {
     if (!m_extensions)
-        m_extensions = adoptPtr(new Extensions3DOpenGL(this));
-    return m_extensions.get();
+        m_extensions = std::make_unique<Extensions3DOpenGL>(this, isGLES2Compliant());
+    return *m_extensions;
 }
+#endif
 
 void GraphicsContext3D::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data)
 {
@@ -351,31 +444,6 @@ void GraphicsContext3D::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsi
         ::glBindFramebufferEXT(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
 }
 
-#if !PLATFORM(MAC)
-void GraphicsContext3D::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
-{
-    UNUSED_PARAM(mode);
-    UNUSED_PARAM(first);
-    UNUSED_PARAM(count);
-    UNUSED_PARAM(primcount);
-}
-
-void GraphicsContext3D::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset, GC3Dsizei primcount)
-{
-    UNUSED_PARAM(mode);
-    UNUSED_PARAM(count);
-    UNUSED_PARAM(type);
-    UNUSED_PARAM(offset);
-    UNUSED_PARAM(primcount);
-}
-
-void GraphicsContext3D::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
-{
-    UNUSED_PARAM(index);
-    UNUSED_PARAM(divisor);
-}
-#endif
-
 }
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
diff --git a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp
index c1356a0e9..1536faf42 100644
--- a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp
+++ b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp
@@ -13,10 +13,10 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -28,7 +28,7 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 
 #include "GraphicsContext3D.h"
 #if PLATFORM(IOS)
@@ -40,26 +40,26 @@
 #else
 #include "Extensions3DOpenGL.h"
 #endif
+#include "ANGLEWebKitBridge.h"
 #include "GraphicsContext.h"
 #include "ImageBuffer.h"
 #include "ImageData.h"
 #include "IntRect.h"
 #include "IntSize.h"
 #include "Logging.h"
-#include "NotImplemented.h"
 #include "TemporaryOpenGLSetting.h"
+#include "WebGLRenderingContextBase.h"
 #include <cstring>
-#include <runtime/ArrayBuffer.h>
-#include <runtime/ArrayBufferView.h>
-#include <runtime/Float32Array.h>
-#include <runtime/Int32Array.h>
-#include <runtime/Uint8Array.h>
+#include <wtf/HexNumber.h>
 #include <wtf/MainThread.h>
+#include <wtf/ThreadSpecific.h>
 #include <wtf/text/CString.h>
+#include <wtf/text/StringBuilder.h>
 #include <yarr/RegularExpression.h>
 
 #if PLATFORM(IOS)
 #import <OpenGLES/ES2/glext.h>
+#import <OpenGLES/ES3/gl.h>
 // From <OpenGLES/glext.h>
 #define GL_RGBA32F_ARB                      0x8814
 #define GL_RGB32F_ARB                       0x8815
@@ -67,15 +67,35 @@
 #if USE(OPENGL_ES_2)
 #include "OpenGLESShims.h"
 #elif PLATFORM(MAC)
+#define GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
 #include <OpenGL/gl.h>
-#elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN)
+#include <OpenGL/gl3.h>
+#include <OpenGL/gl3ext.h>
+#undef GL_DO_NOT_WARN_IF_MULTI_GL_VERSION_HEADERS_INCLUDED
+#elif PLATFORM(GTK) || PLATFORM(WIN)
 #include "OpenGLShims.h"
 #endif
 #endif
 
+using namespace WTF;
+
 namespace WebCore {
 
-static ShaderNameHash* currentNameHashMapForShader;
+static ThreadSpecific<ShaderNameHash*>& getCurrentNameHashMapForShader()
+{
+    static std::once_flag onceFlag;
+    static ThreadSpecific<ShaderNameHash*>* sharedNameHash;
+    std::call_once(onceFlag, [] {
+        sharedNameHash = new ThreadSpecific<ShaderNameHash*>;
+    });
+
+    return *sharedNameHash;
+}
+
+static void setCurrentNameHashMapForShader(ShaderNameHash* shaderNameHash)
+{
+    *getCurrentNameHashMapForShader() = shaderNameHash;
+}
 
 // Hash function used by the ANGLE translator/compiler to do
 // symbol name mangling. Since this is a static method, before
@@ -90,11 +110,10 @@ static uint64_t nameHashForShader(const char* name, size_t length)
     CString nameAsCString = CString(name);
 
     // Look up name in our local map.
-    if (currentNameHashMapForShader) {
-        ShaderNameHash::iterator result = currentNameHashMapForShader->find(nameAsCString);
-        if (result != currentNameHashMapForShader->end())
-            return result->value;
-    }
+    ShaderNameHash*& currentNameHashMapForShader = *getCurrentNameHashMapForShader();
+    ShaderNameHash::iterator findResult = currentNameHashMapForShader->find(nameAsCString);
+    if (findResult != currentNameHashMapForShader->end())
+        return findResult->value;
 
     unsigned hashValue = nameAsCString.hash();
 
@@ -111,37 +130,39 @@ static uint64_t nameHashForShader(const char* name, size_t length)
     return result;
 }
 
-PassRefPtr<GraphicsContext3D> GraphicsContext3D::createForCurrentGLContext()
+RefPtr<GraphicsContext3D> GraphicsContext3D::createForCurrentGLContext()
 {
-    RefPtr<GraphicsContext3D> context = adoptRef(new GraphicsContext3D(Attributes(), 0, GraphicsContext3D::RenderToCurrentGLContext));
-    return context->m_private ? context.release() : 0;
+    auto context = adoptRef(*new GraphicsContext3D({ }, 0, GraphicsContext3D::RenderToCurrentGLContext));
+#if USE(TEXTURE_MAPPER)
+    if (!context->m_texmapLayer)
+        return nullptr;
+#else
+    if (!context->m_private)
+        return nullptr;
+#endif
+    return WTFMove(context);
 }
 
 void GraphicsContext3D::validateDepthStencil(const char* packedDepthStencilExtension)
 {
-    Extensions3D* extensions = getExtensions();
+    Extensions3D& extensions = getExtensions();
     if (m_attrs.stencil) {
-        if (extensions->supports(packedDepthStencilExtension)) {
-            extensions->ensureEnabled(packedDepthStencilExtension);
+        if (extensions.supports(packedDepthStencilExtension)) {
+            extensions.ensureEnabled(packedDepthStencilExtension);
             // Force depth if stencil is true.
             m_attrs.depth = true;
         } else
             m_attrs.stencil = false;
     }
     if (m_attrs.antialias) {
-        if (!extensions->maySupportMultisampling() || !extensions->supports("GL_ANGLE_framebuffer_multisample") || isGLES2Compliant())
+        if (!extensions.supports("GL_ANGLE_framebuffer_multisample") || isGLES2Compliant())
             m_attrs.antialias = false;
         else
-            extensions->ensureEnabled("GL_ANGLE_framebuffer_multisample");
+            extensions.ensureEnabled("GL_ANGLE_framebuffer_multisample");
     }
 }
 
-bool GraphicsContext3D::isResourceSafe()
-{
-    return false;
-}
-
-void GraphicsContext3D::paintRenderingResultsToCanvas(ImageBuffer* imageBuffer, DrawingBuffer*)
+void GraphicsContext3D::paintRenderingResultsToCanvas(ImageBuffer* imageBuffer)
 {
     int rowBytes = m_currentWidth * 4;
     int totalBytes = rowBytes * m_currentHeight;
@@ -165,8 +186,7 @@ void GraphicsContext3D::paintRenderingResultsToCanvas(ImageBuffer* imageBuffer,
     paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight,
                   imageBuffer->internalSize().width(), imageBuffer->internalSize().height(), imageBuffer->context());
 #else
-    paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight,
-                  imageBuffer->internalSize().width(), imageBuffer->internalSize().height(), imageBuffer->context()->platformContext());
+    paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight, imageBuffer->internalSize().width(), imageBuffer->internalSize().height(), imageBuffer->context().platformContext());
 #endif
 
 #if PLATFORM(IOS)
@@ -180,14 +200,14 @@ bool GraphicsContext3D::paintCompositedResultsToCanvas(ImageBuffer*)
     return false;
 }
 
-PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData(DrawingBuffer*)
+RefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData()
 {
     // Reading premultiplied alpha would involve unpremultiplying, which is
     // lossy.
     if (m_attrs.premultipliedAlpha)
-        return 0;
+        return nullptr;
 
-    RefPtr<ImageData> imageData = ImageData::create(IntSize(m_currentWidth, m_currentHeight));
+    auto imageData = ImageData::create(IntSize(m_currentWidth, m_currentHeight));
     unsigned char* pixels = imageData->data()->data();
     int totalBytes = 4 * m_currentWidth * m_currentHeight;
 
@@ -197,7 +217,7 @@ PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData(Drawin
     for (int i = 0; i < totalBytes; i += 4)
         std::swap(pixels[i], pixels[i + 2]);
 
-    return imageData.release();
+    return imageData;
 }
 
 void GraphicsContext3D::prepareTexture()
@@ -207,12 +227,28 @@ void GraphicsContext3D::prepareTexture()
 
     makeContextCurrent();
 
+#if !USE(COORDINATED_GRAPHICS_THREADED)
     TemporaryOpenGLSetting scopedScissor(GL_SCISSOR_TEST, GL_FALSE);
     TemporaryOpenGLSetting scopedDither(GL_DITHER, GL_FALSE);
-    
+#endif
+
     if (m_attrs.antialias)
         resolveMultisamplingIfNecessary();
 
+#if USE(COORDINATED_GRAPHICS_THREADED)
+    std::swap(m_texture, m_compositorTexture);
+    std::swap(m_texture, m_intermediateTexture);
+    ::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+    ::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_texture, 0);
+    glFlush();
+
+    if (m_state.boundFBO != m_fbo)
+        ::glBindFramebufferEXT(GraphicsContext3D::FRAMEBUFFER, m_state.boundFBO);
+    else
+        ::glBindFramebufferEXT(GraphicsContext3D::FRAMEBUFFER, m_fbo);
+    return;
+#endif
+
     ::glBindFramebufferEXT(GraphicsContext3D::FRAMEBUFFER, m_fbo);
     ::glActiveTexture(GL_TEXTURE0);
     ::glBindTexture(GL_TEXTURE_2D, m_compositorTexture);
@@ -221,8 +257,7 @@ void GraphicsContext3D::prepareTexture()
     ::glActiveTexture(m_state.activeTexture);
     if (m_state.boundFBO != m_fbo)
         ::glBindFramebufferEXT(GraphicsContext3D::FRAMEBUFFER, m_state.boundFBO);
-    ::glFinish();
-    m_layerComposited = true;
+    ::glFlush();
 }
 
 void GraphicsContext3D::readRenderingResults(unsigned char *pixels, int pixelsSize)
@@ -271,11 +306,6 @@ void GraphicsContext3D::reshape(int width, int height)
 
     markContextChanged();
 
-#if PLATFORM(EFL) && USE(GRAPHICS_SURFACE)
-    ::glFlush(); // Make sure all GL calls have been committed before resizing.
-    createGraphicsSurfaces(IntSize(width, height));
-#endif
-
     m_currentWidth = width;
     m_currentHeight = height;
 
@@ -334,6 +364,49 @@ void GraphicsContext3D::reshape(int width, int height)
     ::glFlush();
 }
 
+bool GraphicsContext3D::checkVaryingsPacking(Platform3DObject vertexShader, Platform3DObject fragmentShader) const
+{
+    ASSERT(m_shaderSourceMap.contains(vertexShader));
+    ASSERT(m_shaderSourceMap.contains(fragmentShader));
+    const auto& vertexEntry = m_shaderSourceMap.find(vertexShader)->value;
+    const auto& fragmentEntry = m_shaderSourceMap.find(fragmentShader)->value;
+
+    HashMap<String, sh::ShaderVariable> combinedVaryings;
+    for (const auto& vertexSymbol : vertexEntry.varyingMap) {
+        const String& symbolName = vertexSymbol.key;
+        // The varying map includes variables for each index of an array variable.
+        // We only want a single variable to represent the array.
+        if (symbolName.endsWith("]"))
+            continue;
+
+        // Don't count built in varyings.
+        if (symbolName == "gl_FragCoord" || symbolName == "gl_FrontFacing" || symbolName == "gl_PointCoord")
+            continue;
+
+        const auto& fragmentSymbol = fragmentEntry.varyingMap.find(symbolName);
+        if (fragmentSymbol != fragmentEntry.varyingMap.end())
+            combinedVaryings.add(symbolName, fragmentSymbol->value);
+    }
+
+    size_t numVaryings = combinedVaryings.size();
+    if (!numVaryings)
+        return true;
+
+    std::vector<sh::ShaderVariable> variables;
+    variables.reserve(combinedVaryings.size());
+    for (const auto& varyingSymbol : combinedVaryings.values())
+        variables.push_back(varyingSymbol);
+
+    GC3Dint maxVaryingVectors = 0;
+#if !PLATFORM(IOS) && !((PLATFORM(WIN) || PLATFORM(GTK)) && USE(OPENGL_ES_2))
+    GC3Dint maxVaryingFloats = 0;
+    ::glGetIntegerv(GL_MAX_VARYING_FLOATS, &maxVaryingFloats);
+    maxVaryingVectors = maxVaryingFloats / 4;
+#else
+    ::glGetIntegerv(MAX_VARYING_VECTORS, &maxVaryingVectors);
+#endif
+    return ShCheckVariablesWithinPackingLimits(maxVaryingVectors, variables);
+}
 
 bool GraphicsContext3D::precisionsMatch(Platform3DObject vertexShader, Platform3DObject fragmentShader) const
 {
@@ -342,13 +415,16 @@ bool GraphicsContext3D::precisionsMatch(Platform3DObject vertexShader, Platform3
     const auto& vertexEntry = m_shaderSourceMap.find(vertexShader)->value;
     const auto& fragmentEntry = m_shaderSourceMap.find(fragmentShader)->value;
 
-    HashMap<String, ShPrecisionType> vertexSymbolPrecisionMap;
+    HashMap<String, sh::GLenum> vertexSymbolPrecisionMap;
 
-    for (const auto& entry : vertexEntry.uniformMap)
-        vertexSymbolPrecisionMap.add(entry.value.mappedName, entry.value.precision);
+    for (const auto& entry : vertexEntry.uniformMap) {
+        const std::string& mappedName = entry.value.mappedName;
+        vertexSymbolPrecisionMap.add(String(mappedName.c_str(), mappedName.length()), entry.value.precision);
+    }
 
     for (const auto& entry : fragmentEntry.uniformMap) {
-        const auto& vertexSymbol = vertexSymbolPrecisionMap.find(entry.value.mappedName);
+        const std::string& mappedName = entry.value.mappedName;
+        const auto& vertexSymbol = vertexSymbolPrecisionMap.find(String(mappedName.c_str(), mappedName.length()));
         if (vertexSymbol != vertexSymbolPrecisionMap.end() && vertexSymbol->value != entry.value.precision)
             return false;
     }
@@ -373,6 +449,7 @@ void GraphicsContext3D::attachShader(Platform3DObject program, Platform3DObject
     ASSERT(program);
     ASSERT(shader);
     makeContextCurrent();
+    m_shaderProgramSymbolCountMap.remove(program);
     ::glAttachShader(program, shader);
 }
 
@@ -470,6 +547,38 @@ void GraphicsContext3D::bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsi
     ::glBufferSubData(target, offset, size, data);
 }
 
+#if PLATFORM(MAC) || PLATFORM(IOS)
+void* GraphicsContext3D::mapBufferRange(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr length, GC3Dbitfield access)
+{
+    makeContextCurrent();
+    return ::glMapBufferRange(target, offset, length, access);
+}
+
+GC3Dboolean GraphicsContext3D::unmapBuffer(GC3Denum target)
+{
+    makeContextCurrent();
+    return ::glUnmapBuffer(target);
+}
+
+void GraphicsContext3D::copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dintptr readOffset, GC3Dintptr writeOffset, GC3Dsizeiptr size)
+{
+    makeContextCurrent();
+    ::glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+}
+
+void GraphicsContext3D::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
+{
+    makeContextCurrent();
+    ::glTexStorage2D(target, levels, internalformat, width, height);
+}
+
+void GraphicsContext3D::texStorage3D(GC3Denum target, GC3Dsizei levels, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dsizei depth)
+{
+    makeContextCurrent();
+    ::glTexStorage3D(target, levels, internalformat, width, height, depth);
+}
+#endif
+
 GC3Denum GraphicsContext3D::checkFramebufferStatus(GC3Denum target)
 {
     makeContextCurrent();
@@ -512,15 +621,15 @@ void GraphicsContext3D::compileShader(Platform3DObject shader)
     ANGLEResources.HashFunction = nameHashForShader;
 
     if (!nameHashMapForShaders)
-        nameHashMapForShaders = adoptPtr(new ShaderNameHash);
-    currentNameHashMapForShader = nameHashMapForShaders.get();
+        nameHashMapForShaders = std::make_unique<ShaderNameHash>();
+    setCurrentNameHashMapForShader(nameHashMapForShaders.get());
     m_compiler.setResources(ANGLEResources);
 
     String translatedShaderSource = m_extensions->getTranslatedShaderSourceANGLE(shader);
 
     ANGLEResources.HashFunction = previousHashFunction;
     m_compiler.setResources(ANGLEResources);
-    currentNameHashMapForShader = nullptr;
+    setCurrentNameHashMapForShader(nullptr);
 
     if (!translatedShaderSource.length())
         return;
@@ -560,8 +669,6 @@ void GraphicsContext3D::compileShader(Platform3DObject shader)
         entry.isValid = false;
         LOG(WebGL, "Error: shader translator produced a shader that OpenGL would not compile.");
     }
-
-    m_shaderSymbolCount = nullptr;
 }
 
 void GraphicsContext3D::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
@@ -611,6 +718,7 @@ void GraphicsContext3D::detachShader(Platform3DObject program, Platform3DObject
     ASSERT(program);
     ASSERT(shader);
     makeContextCurrent();
+    m_shaderProgramSymbolCountMap.remove(program);
     ::glDetachShader(program, shader);
 }
 
@@ -630,12 +738,14 @@ void GraphicsContext3D::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count
 {
     makeContextCurrent();
     ::glDrawArrays(mode, first, count);
+    checkGPUStatusIfNecessary();
 }
 
 void GraphicsContext3D::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
 {
     makeContextCurrent();
     ::glDrawElements(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)));
+    checkGPUStatusIfNecessary();
 }
 
 void GraphicsContext3D::enable(GC3Denum cap)
@@ -718,8 +828,15 @@ bool GraphicsContext3D::getActiveAttribImpl(Platform3DObject program, GC3Duint i
 
 bool GraphicsContext3D::getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 {
-    ASSERT(!m_shaderSymbolCount || index < m_shaderSymbolCount->filteredToActualAttributeIndexMap.size());
-    GC3Duint rawIndex = (m_shaderSymbolCount) ? m_shaderSymbolCount->filteredToActualAttributeIndexMap[index] : index;
+    GC3Dint symbolCount;
+    auto result = m_shaderProgramSymbolCountMap.find(program);
+    if (result == m_shaderProgramSymbolCountMap.end()) {
+        getNonBuiltInActiveSymbolCount(program, GraphicsContext3D::ACTIVE_ATTRIBUTES, &symbolCount);
+        result = m_shaderProgramSymbolCountMap.find(program);
+    }
+    
+    ActiveShaderSymbolCounts& symbolCounts = result->value;
+    GC3Duint rawIndex = (index < symbolCounts.filteredToActualAttributeIndexMap.size()) ? symbolCounts.filteredToActualAttributeIndexMap[index] : -1;
 
     return getActiveAttribImpl(program, rawIndex, info);
 }
@@ -758,8 +875,15 @@ bool GraphicsContext3D::getActiveUniformImpl(Platform3DObject program, GC3Duint
 
 bool GraphicsContext3D::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 {
-    ASSERT(!m_shaderSymbolCount || index < m_shaderSymbolCount->filteredToActualUniformIndexMap.size());
-    GC3Duint rawIndex = (m_shaderSymbolCount) ? m_shaderSymbolCount->filteredToActualUniformIndexMap[index] : index;
+    GC3Dint symbolCount;
+    auto result = m_shaderProgramSymbolCountMap.find(program);
+    if (result == m_shaderProgramSymbolCountMap.end()) {
+        getNonBuiltInActiveSymbolCount(program, GraphicsContext3D::ACTIVE_UNIFORMS, &symbolCount);
+        result = m_shaderProgramSymbolCountMap.find(program);
+    }
+    
+    ActiveShaderSymbolCounts& symbolCounts = result->value;
+    GC3Duint rawIndex = (index < symbolCounts.filteredToActualUniformIndexMap.size()) ? symbolCounts.filteredToActualUniformIndexMap[index] : -1;
     
     return getActiveUniformImpl(program, rawIndex, info);
 }
@@ -774,10 +898,21 @@ void GraphicsContext3D::getAttachedShaders(Platform3DObject program, GC3Dsizei m
     ::glGetAttachedShaders(program, maxCount, count, shaders);
 }
 
+static String generateHashedName(const String& name)
+{
+    if (name.isEmpty())
+        return name;
+    uint64_t number = nameHashForShader(name.utf8().data(), name.length());
+    StringBuilder builder;
+    builder.appendLiteral("webgl_");
+    appendUnsigned64AsHex(number, builder, Lowercase);
+    return builder.toString();
+}
+
 String GraphicsContext3D::mappedSymbolName(Platform3DObject program, ANGLEShaderSymbolType symbolType, const String& name)
 {
-    GC3Dsizei count;
-    Platform3DObject shaders[2];
+    GC3Dsizei count = 0;
+    Platform3DObject shaders[2] = { };
     getAttachedShaders(program, 2, &count, shaders);
 
     for (GC3Dsizei i = 0; i < count; ++i) {
@@ -787,9 +922,28 @@ String GraphicsContext3D::mappedSymbolName(Platform3DObject program, ANGLEShader
 
         const ShaderSymbolMap& symbolMap = result->value.symbolMap(symbolType);
         ShaderSymbolMap::const_iterator symbolEntry = symbolMap.find(name);
-        if (symbolEntry != symbolMap.end())
-            return symbolEntry->value.mappedName;
+        if (symbolEntry != symbolMap.end()) {
+            const std::string& mappedName = symbolEntry->value.mappedName;
+            return String(mappedName.c_str(), mappedName.length());
+        }
     }
+
+    if (symbolType == SHADER_SYMBOL_TYPE_ATTRIBUTE && !name.isEmpty()) {
+        // Attributes are a special case: they may be requested before any shaders have been compiled,
+        // and aren't even required to be used in any shader program.
+        if (!nameHashMapForShaders)
+            nameHashMapForShaders = std::make_unique<ShaderNameHash>();
+        setCurrentNameHashMapForShader(nameHashMapForShaders.get());
+
+        String generatedName = generateHashedName(name);
+
+        setCurrentNameHashMapForShader(nullptr);
+
+        m_possiblyUnusedAttributeMap.set(generatedName, name);
+
+        return generatedName;
+    }
+
     return name;
 }
     
@@ -806,10 +960,20 @@ String GraphicsContext3D::originalSymbolName(Platform3DObject program, ANGLEShad
         
         const ShaderSymbolMap& symbolMap = result->value.symbolMap(symbolType);
         for (const auto& symbolEntry : symbolMap) {
-            if (symbolEntry.value.mappedName == name)
+            if (name == symbolEntry.value.mappedName.c_str())
                 return symbolEntry.key;
         }
     }
+
+    if (symbolType == SHADER_SYMBOL_TYPE_ATTRIBUTE && !name.isEmpty()) {
+        // Attributes are a special case: they may be requested before any shaders have been compiled,
+        // and aren't even required to be used in any shader program.
+
+        const auto& cached = m_possiblyUnusedAttributeMap.find(name);
+        if (cached != m_possiblyUnusedAttributeMap.end())
+            return cached->value;
+    }
+
     return name;
 }
 
@@ -823,7 +987,7 @@ String GraphicsContext3D::mappedSymbolName(Platform3DObject shaders[2], size_t c
             
             const ShaderSymbolMap& symbolMap = result->value.symbolMap(static_cast<enum ANGLEShaderSymbolType>(symbolType));
             for (const auto& symbolEntry : symbolMap) {
-                if (symbolEntry.value.mappedName == name)
+                if (name == symbolEntry.value.mappedName.c_str())
                     return symbolEntry.key;
             }
         }
@@ -843,18 +1007,38 @@ int GraphicsContext3D::getAttribLocation(Platform3DObject program, const String&
     return ::glGetAttribLocation(program, mappedName.utf8().data());
 }
 
-GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes()
+GraphicsContext3DAttributes GraphicsContext3D::getContextAttributes()
 {
     return m_attrs;
 }
 
+bool GraphicsContext3D::moveErrorsToSyntheticErrorList()
+{
+    makeContextCurrent();
+    bool movedAnError = false;
+
+    // Set an arbitrary limit of 100 here to avoid creating a hang if
+    // a problem driver has a bug that causes it to never clear the error.
+    // Otherwise, we would just loop until we got NO_ERROR.
+    for (unsigned i = 0; i < 100; ++i) {
+        GC3Denum error = glGetError();
+        if (error == NO_ERROR)
+            break;
+        m_syntheticErrors.add(error);
+        movedAnError = true;
+    }
+
+    return movedAnError;
+}
+
 GC3Denum GraphicsContext3D::getError()
 {
-    if (m_syntheticErrors.size() > 0) {
-        ListHashSet<GC3Denum>::iterator iter = m_syntheticErrors.begin();
-        GC3Denum err = *iter;
-        m_syntheticErrors.remove(iter);
-        return err;
+    if (!m_syntheticErrors.isEmpty()) {
+        // Need to move the current errors to the synthetic error list in case
+        // that error is already there, since the expected behavior of both
+        // glGetError and getError is to only report each error code once.
+        moveErrorsToSyntheticErrorList();
+        return m_syntheticErrors.takeFirst();
     }
 
     makeContextCurrent();
@@ -1228,6 +1412,57 @@ void GraphicsContext3D::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsize
     ::glViewport(x, y, width, height);
 }
 
+Platform3DObject GraphicsContext3D::createVertexArray()
+{
+    makeContextCurrent();
+    GLuint array = 0;
+#if !USE(OPENGL_ES_2) && (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
+    glGenVertexArrays(1, &array);
+#elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
+    glGenVertexArraysAPPLE(1, &array);
+#endif
+    return array;
+}
+
+void GraphicsContext3D::deleteVertexArray(Platform3DObject array)
+{
+    if (!array)
+        return;
+    
+    makeContextCurrent();
+#if !USE(OPENGL_ES_2) && (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
+    glDeleteVertexArrays(1, &array);
+#elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
+    glDeleteVertexArraysAPPLE(1, &array);
+#endif
+}
+
+GC3Dboolean GraphicsContext3D::isVertexArray(Platform3DObject array)
+{
+    if (!array)
+        return GL_FALSE;
+    
+    makeContextCurrent();
+#if !USE(OPENGL_ES_2) && (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
+    return glIsVertexArray(array);
+#elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
+    return glIsVertexArrayAPPLE(array);
+#endif
+    return GL_FALSE;
+}
+
+void GraphicsContext3D::bindVertexArray(Platform3DObject array)
+{
+    makeContextCurrent();
+#if !USE(OPENGL_ES_2) && (PLATFORM(GTK) || PLATFORM(WIN) || PLATFORM(IOS))
+    glBindVertexArray(array);
+#elif defined(GL_APPLE_vertex_array_object) && GL_APPLE_vertex_array_object
+    glBindVertexArrayAPPLE(array);
+#else
+    UNUSED_PARAM(array);
+#endif
+}
+
 void GraphicsContext3D::getBooleanv(GC3Denum pname, GC3Dboolean* value)
 {
     makeContextCurrent();
@@ -1245,6 +1480,15 @@ void GraphicsContext3D::getFloatv(GC3Denum pname, GC3Dfloat* value)
     makeContextCurrent();
     ::glGetFloatv(pname, value);
 }
+    
+void GraphicsContext3D::getInteger64v(GC3Denum pname, GC3Dint64* value)
+{
+    UNUSED_PARAM(pname);
+    makeContextCurrent();
+    *value = 0;
+    // FIXME 141178: Before enabling this we must first switch over to using gl3.h and creating and initialing the WebGL2 context using OpenGL ES 3.0.
+    // ::glGetInteger64v(pname, value);
+}
 
 void GraphicsContext3D::getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum pname, GC3Dint* value)
 {
@@ -1267,13 +1511,14 @@ void GraphicsContext3D::getNonBuiltInActiveSymbolCount(Platform3DObject program,
         return;
 
     makeContextCurrent();
-
-    if (m_shaderSymbolCount) {
-        *value = m_shaderSymbolCount->countForType(pname);
+    const auto& result = m_shaderProgramSymbolCountMap.find(program);
+    if (result != m_shaderProgramSymbolCountMap.end()) {
+        *value = result->value.countForType(pname);
         return;
     }
 
-    m_shaderSymbolCount = std::make_unique<ActiveShaderSymbolCounts>();
+    m_shaderProgramSymbolCountMap.set(program, ActiveShaderSymbolCounts());
+    ActiveShaderSymbolCounts& symbolCounts = m_shaderProgramSymbolCountMap.find(program)->value;
 
     // Retrieve the active attributes, build a filtered count, and a mapping of
     // our internal attributes indexes to the real unfiltered indexes inside OpenGL.
@@ -1285,7 +1530,7 @@ void GraphicsContext3D::getNonBuiltInActiveSymbolCount(Platform3DObject program,
         if (info.name.startsWith("gl_"))
             continue;
 
-        m_shaderSymbolCount->filteredToActualAttributeIndexMap.append(i);
+        symbolCounts.filteredToActualAttributeIndexMap.append(i);
     }
     
     // Do the same for uniforms.
@@ -1297,10 +1542,10 @@ void GraphicsContext3D::getNonBuiltInActiveSymbolCount(Platform3DObject program,
         if (info.name.startsWith("gl_"))
             continue;
         
-        m_shaderSymbolCount->filteredToActualUniformIndexMap.append(i);
+        symbolCounts.filteredToActualUniformIndexMap.append(i);
     }
     
-    *value = m_shaderSymbolCount->countForType(pname);
+    *value = symbolCounts.countForType(pname);
 }
 
 String GraphicsContext3D::getUnmangledInfoLog(Platform3DObject shaders[2], GC3Dsizei count, const String& log)
@@ -1309,7 +1554,7 @@ String GraphicsContext3D::getUnmangledInfoLog(Platform3DObject shaders[2], GC3Ds
 
     JSC::Yarr::RegularExpression regExp("webgl_[0123456789abcdefABCDEF]+", TextCaseSensitive);
 
-    String processedLog;
+    StringBuilder processedLog;
     
     int startFrom = 0;
     int matchedLength = 0;
@@ -1329,8 +1574,8 @@ String GraphicsContext3D::getUnmangledInfoLog(Platform3DObject shaders[2], GC3Ds
 
     processedLog.append(log.substring(startFrom, log.length() - startFrom));
 
-    LOG(WebGL, "-->: %s", processedLog.utf8().data());
-    return processedLog;
+    LOG(WebGL, "-->: %s", processedLog.toString().utf8().data());
+    return processedLog.toString();
 }
 
 String GraphicsContext3D::getProgramInfoLog(Platform3DObject program)
@@ -1501,6 +1746,12 @@ void GraphicsContext3D::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xo
         type = GL_HALF_FLOAT_ARB;
 #endif
 
+    if (m_usingCoreProfile && format == ALPHA) {
+        // We are using a core profile. This means that GL_ALPHA, which is a valid format in WebGL for texSubImage2D
+        // is not supported in OpenGL. We are using GL_RED to back GL_ALPHA, so do it here as well.
+        format = RED;
+    }
+
     // FIXME: we will need to deal with PixelStore params when dealing with image buffers that differ from the subimage size.
     ::glTexSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels);
 }
@@ -1606,6 +1857,10 @@ void GraphicsContext3D::deleteTexture(Platform3DObject texture)
 
 void GraphicsContext3D::synthesizeGLError(GC3Denum error)
 {
+    // Need to move the current errors to the synthetic error list to
+    // preserve the order of errors, so a caller to getError will get
+    // any errors from glError before the error we are synthesizing.
+    moveErrorsToSyntheticErrorList();
     m_syntheticErrors.add(error);
 }
 
@@ -1624,12 +1879,43 @@ bool GraphicsContext3D::layerComposited() const
     return m_layerComposited;
 }
 
+void GraphicsContext3D::forceContextLost()
+{
+#if ENABLE(WEBGL)
+    if (m_webglContext)
+        m_webglContext->forceLostContext(WebGLRenderingContextBase::RealLostContext);
+#endif
+}
+
+void GraphicsContext3D::recycleContext()
+{
+#if ENABLE(WEBGL)
+    if (m_webglContext)
+        m_webglContext->recycleContext();
+#endif
+}
+
 void GraphicsContext3D::texImage2DDirect(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
 {
     makeContextCurrent();
     ::glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
+void GraphicsContext3D::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+{
+    getExtensions().drawArraysInstanced(mode, first, count, primcount);
+}
+
+void GraphicsContext3D::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset, GC3Dsizei primcount)
+{
+    getExtensions().drawElementsInstanced(mode, count, type, offset, primcount);
+}
+
+void GraphicsContext3D::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+{
+    getExtensions().vertexAttribDivisor(index, divisor);
+}
+
 }
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
diff --git a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLES.cpp b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLES.cpp
index 546b2d433..6b608c66d 100644
--- a/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLES.cpp
+++ b/Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLES.cpp
@@ -13,10 +13,10 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -28,7 +28,7 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 
 #include "GraphicsContext3D.h"
 
@@ -37,6 +37,12 @@
 #include "IntSize.h"
 #include "NotImplemented.h"
 
+#if PLATFORM(WIN)
+#include <GLSLANG/ShaderLang.h>
+#else
+#include <ANGLE/ShaderLang.h>
+#endif
+
 namespace WebCore {
 
 void GraphicsContext3D::releaseShaderCompiler()
@@ -90,7 +96,7 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
 
     // We don't allow the logic where stencil is required and depth is not.
     // See GraphicsContext3D::validateAttributes.
-    bool supportPackedDepthStencilBuffer = (m_attrs.stencil || m_attrs.depth) && getExtensions()->supports("GL_OES_packed_depth_stencil");
+    bool supportPackedDepthStencilBuffer = (m_attrs.stencil || m_attrs.depth) && getExtensions().supports("GL_OES_packed_depth_stencil");
 
     // Resize regular FBO.
     bool mustRestoreFBO = false;
@@ -110,29 +116,64 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
         ::glBindTexture(GL_TEXTURE_2D, 0);
     }
 
-    // We don't support antialiasing yet. See GraphicsContext3D::validateAttributes.
-    ASSERT(!m_attrs.antialias);
-
-    if (m_attrs.stencil || m_attrs.depth) {
-        // Use a 24 bit depth buffer where we know we have it.
-        if (supportPackedDepthStencilBuffer) {
-            ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
-            ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, width, height);
-            if (m_attrs.stencil)
-                ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
-            if (m_attrs.depth)
-                ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
-            ::glBindRenderbuffer(GL_RENDERBUFFER, 0);
-        } else {
-            if (m_attrs.stencil) {
-                ::glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBuffer);
-                ::glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
-                ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer);
+#if USE(COORDINATED_GRAPHICS_THREADED)
+        ::glBindTexture(GL_TEXTURE_2D, m_intermediateTexture);
+        ::glTexImage2D(GL_TEXTURE_2D, 0, m_internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
+        ::glBindTexture(GL_TEXTURE_2D, 0);
+#endif
+
+    Extensions3DOpenGLES& extensions = static_cast<Extensions3DOpenGLES&>(getExtensions());
+    if (extensions.isImagination() && m_attrs.antialias) {
+        GLint maxSampleCount;
+        ::glGetIntegerv(Extensions3D::MAX_SAMPLES_IMG, &maxSampleCount); 
+        GLint sampleCount = std::min(8, maxSampleCount);
+
+        extensions.framebufferTexture2DMultisampleIMG(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0, sampleCount);
+
+        if (m_attrs.stencil || m_attrs.depth) {
+            // Use a 24 bit depth buffer where we know we have it.
+            if (supportPackedDepthStencilBuffer) {
+                ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
+                extensions.renderbufferStorageMultisample(GL_RENDERBUFFER, sampleCount, GL_DEPTH24_STENCIL8_OES, width, height);
+                if (m_attrs.stencil)
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
+                if (m_attrs.depth)
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
+            } else {
+                if (m_attrs.stencil) {
+                    ::glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBuffer);
+                    extensions.renderbufferStorageMultisample(GL_RENDERBUFFER, sampleCount, GL_STENCIL_INDEX8, width, height);
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer);
+                }
+                if (m_attrs.depth) {
+                    ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthBuffer);
+                    extensions.renderbufferStorageMultisample(GL_RENDERBUFFER, sampleCount, GL_DEPTH_COMPONENT16, width, height);
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthBuffer);
+                }
             }
-            if (m_attrs.depth) {
-                ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthBuffer);
-                ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
-                ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthBuffer);
+            ::glBindRenderbuffer(GL_RENDERBUFFER, 0);
+        }
+    } else {
+        if (m_attrs.stencil || m_attrs.depth) {
+            // Use a 24 bit depth buffer where we know we have it.
+            if (supportPackedDepthStencilBuffer) {
+                ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
+                ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, width, height);
+                if (m_attrs.stencil)
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
+                if (m_attrs.depth)
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
+            } else {
+                if (m_attrs.stencil) {
+                    ::glBindRenderbuffer(GL_RENDERBUFFER, m_stencilBuffer);
+                    ::glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilBuffer);
+                }
+                if (m_attrs.depth) {
+                    ::glBindRenderbuffer(GL_RENDERBUFFER, m_depthBuffer);
+                    ::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+                    ::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthBuffer);
+                }
             }
             ::glBindRenderbuffer(GL_RENDERBUFFER, 0);
         }
@@ -145,7 +186,7 @@ bool GraphicsContext3D::reshapeFBOs(const IntSize& size)
     return mustRestoreFBO;
 }
 
-void GraphicsContext3D::resolveMultisamplingIfNecessary(const IntRect& rect)
+void GraphicsContext3D::resolveMultisamplingIfNecessary(const IntRect&)
 {
     // FIXME: We don't support antialiasing yet.
     notImplemented();
@@ -187,11 +228,8 @@ void GraphicsContext3D::validateAttributes()
 {
     validateDepthStencil("GL_OES_packed_depth_stencil");
 
-    if (m_attrs.antialias) {
-        Extensions3D* extensions = getExtensions();
-        if (!extensions->supports("GL_IMG_multisampled_render_to_texture"))
-            m_attrs.antialias = false;
-    }
+    if (m_attrs.antialias && !getExtensions().supports("GL_IMG_multisampled_render_to_texture"))
+        m_attrs.antialias = false;
 }
 
 void GraphicsContext3D::depthRange(GC3Dclampf zNear, GC3Dclampf zFar)
@@ -206,36 +244,171 @@ void GraphicsContext3D::clearDepth(GC3Dclampf depth)
     ::glClearDepthf(depth);
 }
 
-void GraphicsContext3D::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)
+#if !PLATFORM(GTK)
+Extensions3D& GraphicsContext3D::getExtensions()
+{
+    if (!m_extensions)
+        m_extensions = std::make_unique<Extensions3DOpenGLES>(this, isGLES2Compliant());
+    return *m_extensions;
+}
+#endif
+
+#if PLATFORM(WIN) && !USE(CAIRO)
+RefPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3DAttributes attributes, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
 {
-    UNUSED_PARAM(mode);
-    UNUSED_PARAM(first);
-    UNUSED_PARAM(count);
-    UNUSED_PARAM(primcount);
+    // This implementation doesn't currently support rendering directly to the HostWindow.
+    if (renderStyle == RenderDirectlyToHostWindow)
+        return nullptr;
+    
+    static bool initialized = false;
+    static bool success = true;
+    if (!initialized) {
+#if !USE(OPENGL_ES_2)
+        success = initializeOpenGLShims();
+#endif
+        initialized = true;
+    }
+    if (!success)
+        return nullptr;
+    
+    return adoptRef(new GraphicsContext3D(attributes, hostWindow, renderStyle));
 }
 
-void GraphicsContext3D::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset, GC3Dsizei primcount)
+GraphicsContext3D::GraphicsContext3D(GraphicsContext3DAttributes attributes, HostWindow*, GraphicsContext3D::RenderStyle renderStyle)
+    : m_currentWidth(0)
+    , m_currentHeight(0)
+    , m_compiler(isGLES2Compliant() ? SH_ESSL_OUTPUT : SH_GLSL_COMPATIBILITY_OUTPUT)
+    , m_attrs(attributes)
+    , m_texture(0)
+    , m_fbo(0)
+    , m_depthStencilBuffer(0)
+    , m_multisampleFBO(0)
+    , m_multisampleDepthStencilBuffer(0)
+    , m_multisampleColorBuffer(0)
+    , m_private(std::make_unique<GraphicsContext3DPrivate>(this, renderStyle))
 {
-    UNUSED_PARAM(mode);
-    UNUSED_PARAM(count);
-    UNUSED_PARAM(type);
-    UNUSED_PARAM(offset);
-    UNUSED_PARAM(primcount);
+    makeContextCurrent();
+    
+    validateAttributes();
+
+    if (renderStyle == RenderOffscreen) {
+        // Create a texture to render into.
+        ::glGenTextures(1, &m_texture);
+        ::glBindTexture(GL_TEXTURE_2D, m_texture);
+        ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        ::glBindTexture(GL_TEXTURE_2D, 0);
+        
+        // Create an FBO.
+        ::glGenFramebuffers(1, &m_fbo);
+        ::glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+        
+        m_state.boundFBO = m_fbo;
+        if (!m_attrs.antialias && (m_attrs.stencil || m_attrs.depth))
+            ::glGenRenderbuffers(1, &m_depthStencilBuffer);
+        
+        // Create a multisample FBO.
+        if (m_attrs.antialias) {
+            ::glGenFramebuffers(1, &m_multisampleFBO);
+            ::glBindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+            m_state.boundFBO = m_multisampleFBO;
+            ::glGenRenderbuffers(1, &m_multisampleColorBuffer);
+            if (m_attrs.stencil || m_attrs.depth)
+                ::glGenRenderbuffers(1, &m_multisampleDepthStencilBuffer);
+        }
+    }
+    
+    // ANGLE initialization.
+    ShBuiltInResources ANGLEResources;
+    ShInitBuiltInResources(&ANGLEResources);
+    
+    getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &ANGLEResources.MaxVertexAttribs);
+    getIntegerv(GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS, &ANGLEResources.MaxVertexUniformVectors);
+    getIntegerv(GraphicsContext3D::MAX_VARYING_VECTORS, &ANGLEResources.MaxVaryingVectors);
+    getIntegerv(GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxVertexTextureImageUnits);
+    getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxCombinedTextureImageUnits);
+    getIntegerv(GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxTextureImageUnits);
+    getIntegerv(GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS, &ANGLEResources.MaxFragmentUniformVectors);
+    
+    // Always set to 1 for OpenGL ES.
+    ANGLEResources.MaxDrawBuffers = 1;
+    
+    GC3Dint range[2], precision;
+    getShaderPrecisionFormat(GraphicsContext3D::FRAGMENT_SHADER, GraphicsContext3D::HIGH_FLOAT, range, &precision);
+    ANGLEResources.FragmentPrecisionHigh = (range[0] || range[1] || precision);
+    
+    m_compiler.setResources(ANGLEResources);
+    
+#if !USE(OPENGL_ES_2)
+    ::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
+    ::glEnable(GL_POINT_SPRITE);
+#endif
+    
+    ::glClearColor(0, 0, 0, 0);
 }
 
-void GraphicsContext3D::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+GraphicsContext3D::~GraphicsContext3D()
 {
-    UNUSED_PARAM(index);
-    UNUSED_PARAM(divisor);
+    makeContextCurrent();
+    ::glDeleteTextures(1, &m_texture);
+    if (m_attrs.antialias) {
+        ::glDeleteRenderbuffers(1, &m_multisampleColorBuffer);
+        if (m_attrs.stencil || m_attrs.depth)
+            ::glDeleteRenderbuffers(1, &m_multisampleDepthStencilBuffer);
+        ::glDeleteFramebuffers(1, &m_multisampleFBO);
+    } else {
+        if (m_attrs.stencil || m_attrs.depth)
+            ::glDeleteRenderbuffers(1, &m_depthStencilBuffer);
+    }
+    ::glDeleteFramebuffers(1, &m_fbo);
 }
 
-Extensions3D* GraphicsContext3D::getExtensions()
+void GraphicsContext3D::setContextLostCallback(std::unique_ptr<ContextLostCallback>)
 {
-    if (!m_extensions)
-        m_extensions = adoptPtr(new Extensions3DOpenGLES(this));
-    return m_extensions.get();
 }
 
+void GraphicsContext3D::setErrorMessageCallback(std::unique_ptr<ErrorMessageCallback>)
+{
+}
+
+bool GraphicsContext3D::makeContextCurrent()
+{
+    if (!m_private)
+        return false;
+    return m_private->makeContextCurrent();
+}
+
+void GraphicsContext3D::checkGPUStatusIfNecessary()
+{
+}
+
+PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D()
+{
+    return m_private->platformContext();
+}
+
+Platform3DObject GraphicsContext3D::platformTexture() const
+{
+    return m_texture;
+}
+
+bool GraphicsContext3D::isGLES2Compliant() const
+{
+#if USE(OPENGL_ES_2)
+    return true;
+#else
+    return false;
+#endif
+}
+
+PlatformLayer* GraphicsContext3D::platformLayer() const
+{
+    return m_webGLLayer->platformLayer();
+}
+#endif
+
 }
 
-#endif // USE(3D_GRAPHICS)
+#endif // ENABLE(GRAPHICS_CONTEXT_3D)
diff --git a/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.cpp b/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.cpp
index a0163770c..7438d9e14 100644
--- a/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.cpp
+++ b/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.cpp
@@ -26,7 +26,7 @@
 
 #include "config.h"
 
-#if USE(3D_GRAPHICS)
+#if ENABLE(GRAPHICS_CONTEXT_3D)
 #include "TemporaryOpenGLSetting.h"
 
 #if USE(OPENGL_ES_2)
@@ -36,7 +36,7 @@
 #include <OpenGLES/ES2/gl.h>
 #elif PLATFORM(MAC)
 #include <OpenGL/gl.h>
-#elif PLATFORM(GTK) || PLATFORM(EFL) || PLATFORM(WIN)
+#elif PLATFORM(GTK) || PLATFORM(WIN)
 #include "OpenGLShims.h"
 #endif
 
diff --git a/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.h b/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.h
index 833f8b6be..cb51695b7 100644
--- a/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.h
+++ b/Source/WebCore/platform/graphics/opengl/TemporaryOpenGLSetting.h
@@ -38,7 +38,7 @@ namespace WebCore {
 // value upon destruction, making it an alternative to checking, clearing, and resetting each flag
 // at all of a block's exit points.
 //
-// Based on WTF::TemporaryChange<>
+// Based on WTF::SetForScope<>
 
 class TemporaryOpenGLSetting {
     WTF_MAKE_NONCOPYABLE(TemporaryOpenGLSetting);