Add GL and WGL renderer stubs.

src/angle.gyp

@@ -15,6 +15,7 @@
         'angle_use_commit_id%': '<!(python <(angle_id_script_base) check ..)',
         'angle_enable_d3d9%': 0,
         'angle_enable_d3d11%': 0,
+        'angle_enable_gl%': 0,
         'conditions':
         [
             ['OS=="win"',

src/libANGLE/Display.cpp

@@ -12,6 +12,7 @@
 
 #include "common/debug.h"
 #include "common/mathutil.h"
+#include "common/platform.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/DisplayImpl.h"
@@ -28,6 +29,14 @@
 #   include "libANGLE/renderer/d3d/DisplayD3D.h"
 #endif
 
+#if defined(ANGLE_ENABLE_OPENGL)
+#   if defined(ANGLE_PLATFORM_WINDOWS)
+#       include "libANGLE/renderer/gl/wgl/DisplayWGL.h"
+#   else
+#       error Unsupported OpenGL platform.
+#   endif
+#endif
+
 namespace egl
 {
 
@@ -75,6 +84,18 @@ Display *Display::getDisplay(EGLNativeDisplayType displayId, const AttributeMap
 #endif
             break;
 
+          case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+#if defined(ANGLE_ENABLE_OPENGL)
+#if defined(ANGLE_PLATFORM_WINDOWS)
+            impl = new rx::DisplayWGL();
+#else
+#error Unsupported OpenGL platform.
+#endif
+#else
+            UNREACHABLE();
+#endif
+            break;
+
           default:
             UNREACHABLE();
             break;

src/libANGLE/renderer/generate_new_renderer.py

@@ -57,8 +57,8 @@ h_file_template = """//
 
 // $TypedImpl.h: Defines the class interface for $TypedImpl.
 
-#ifndef LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H
-#define LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H
+#ifndef LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H_
+#define LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H_
 
 #include "libANGLE/renderer/$BaseImpl.h"
 
@@ -77,7 +77,7 @@ $PrivateImplMethodDeclarations};
 
 }
 
-#endif // LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H
+#endif // LIBANGLE_RENDERER_${RendererNameCaps}_${TypedImplCaps}_H_
 """
 
 cpp_file_template = """//

src/libANGLE/renderer/gl/BufferGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// BufferGL.cpp: Implements the class methods for BufferGL.
+
+#include "libANGLE/renderer/gl/BufferGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+BufferGL::BufferGL()
+    : BufferImpl()
+{}
+
+BufferGL::~BufferGL()
+{}
+
+gl::Error BufferGL::setData(const void* data, size_t size, GLenum usage)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferGL::setSubData(const void* data, size_t size, size_t offset)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferGL::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferGL::map(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferGL::unmap()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+void BufferGL::markTransformFeedbackUsage()
+{
+    UNIMPLEMENTED();
+}
+
+gl::Error BufferGL::getData(const uint8_t **outData)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/BufferGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// BufferGL.h: Defines the class interface for BufferGL.
+
+#ifndef LIBANGLE_RENDERER_GL_BUFFERGL_H_
+#define LIBANGLE_RENDERER_GL_BUFFERGL_H_
+
+#include "libANGLE/renderer/BufferImpl.h"
+
+namespace rx
+{
+
+class BufferGL : public BufferImpl
+{
+  public:
+    BufferGL();
+    ~BufferGL() override;
+
+    gl::Error setData(const void* data, size_t size, GLenum usage) override;
+    gl::Error setSubData(const void* data, size_t size, size_t offset) override;
+    gl::Error copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size) override;
+    gl::Error map(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr) override;
+    gl::Error unmap() override;
+    void markTransformFeedbackUsage() override;
+
+    // This method may not have a corresponding GL-backed function. It is necessary
+    // for validation, for certain indexed draw calls.
+    gl::Error getData(const uint8_t **outData) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(BufferGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_BUFFERGL_H_

src/libANGLE/renderer/gl/CompilerGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// CompilerGL.cpp: Implements the class methods for CompilerGL.
+
+#include "libANGLE/renderer/gl/CompilerGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+CompilerGL::CompilerGL()
+    : CompilerImpl()
+{}
+
+CompilerGL::~CompilerGL()
+{}
+
+gl::Error CompilerGL::release()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/CompilerGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// CompilerGL.h: Defines the class interface for CompilerGL.
+
+#ifndef LIBANGLE_RENDERER_GL_COMPILERGL_H_
+#define LIBANGLE_RENDERER_GL_COMPILERGL_H_
+
+#include "libANGLE/renderer/CompilerImpl.h"
+
+namespace rx
+{
+
+class CompilerGL : public CompilerImpl
+{
+  public:
+    CompilerGL();
+    ~CompilerGL() override;
+
+    gl::Error release() override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(CompilerGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_COMPILERGL_H_

src/libANGLE/renderer/gl/DefaultAttachmentGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DefaultAttachmentGL.cpp: Implements the class methods for DefaultAttachmentGL.
+
+#include "libANGLE/renderer/gl/DefaultAttachmentGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+DefaultAttachmentGL::DefaultAttachmentGL()
+    : DefaultAttachmentImpl()
+{}
+
+DefaultAttachmentGL::~DefaultAttachmentGL()
+{}
+
+GLsizei DefaultAttachmentGL::getWidth() const
+{
+    UNIMPLEMENTED();
+    return GLsizei();
+}
+
+GLsizei DefaultAttachmentGL::getHeight() const
+{
+    UNIMPLEMENTED();
+    return GLsizei();
+}
+
+GLenum DefaultAttachmentGL::getInternalFormat() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+GLsizei DefaultAttachmentGL::getSamples() const
+{
+    UNIMPLEMENTED();
+    return GLsizei();
+}
+
+}

src/libANGLE/renderer/gl/DefaultAttachmentGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DefaultAttachmentGL.h: Defines the class interface for DefaultAttachmentGL.
+
+#ifndef LIBANGLE_RENDERER_GL_DEFAULTATTACHMENTGL_H_
+#define LIBANGLE_RENDERER_GL_DEFAULTATTACHMENTGL_H_
+
+#include "libANGLE/renderer/DefaultAttachmentImpl.h"
+
+namespace rx
+{
+
+class DefaultAttachmentGL : public DefaultAttachmentImpl
+{
+  public:
+    DefaultAttachmentGL();
+    ~DefaultAttachmentGL() override;
+
+    GLsizei getWidth() const override;
+    GLsizei getHeight() const override;
+    GLenum getInternalFormat() const override;
+    GLsizei getSamples() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(DefaultAttachmentGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_DEFAULTATTACHMENTGL_H_

src/libANGLE/renderer/gl/DisplayGL.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DisplayGL.h: GL implementation of egl::Display
+
+#include "libANGLE/renderer/gl/DisplayGL.h"
+
+#include "libANGLE/AttributeMap.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/renderer/gl/RendererGL.h"
+
+#include <EGL/eglext.h>
+
+namespace rx
+{
+
+DisplayGL::DisplayGL()
+    : mRenderer(nullptr)
+{
+}
+
+DisplayGL::~DisplayGL()
+{
+}
+
+egl::Error DisplayGL::initialize(egl::Display *display)
+{
+    mRenderer = new RendererGL();
+    return egl::Error(EGL_SUCCESS);
+}
+
+void DisplayGL::terminate()
+{
+    SafeDelete(mRenderer);
+}
+
+egl::Error DisplayGL::createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs, gl::Context **outContext)
+{
+    ASSERT(mRenderer != nullptr);
+
+    EGLint clientVersion = attribs.get(EGL_CONTEXT_CLIENT_VERSION, 1);
+    bool notifyResets = (attribs.get(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, EGL_NO_RESET_NOTIFICATION_EXT) == EGL_LOSE_CONTEXT_ON_RESET_EXT);
+    bool robustAccess = (attribs.get(EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT, EGL_FALSE) == EGL_TRUE);
+
+    *outContext = new gl::Context(config, clientVersion, shareContext, mRenderer, notifyResets, robustAccess);
+    return egl::Error(EGL_SUCCESS);
+}
+
+}

src/libANGLE/renderer/gl/DisplayGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DisplayGL.h: Defines the class interface for DisplayGL.
+
+#ifndef LIBANGLE_RENDERER_GL_DISPLAYGL_H_
+#define LIBANGLE_RENDERER_GL_DISPLAYGL_H_
+
+#include "libANGLE/renderer/DisplayImpl.h"
+
+namespace rx
+{
+
+class RendererGL;
+
+class DisplayGL : public DisplayImpl
+{
+  public:
+    DisplayGL();
+    ~DisplayGL() override;
+
+    egl::Error initialize(egl::Display *display) override;
+    void terminate() override;
+
+    egl::Error createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs,
+                             gl::Context **outContext) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(DisplayGL);
+
+    RendererGL *mRenderer;
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_DISPLAYGL_H_

src/libANGLE/renderer/gl/FenceNVGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FenceNVGL.cpp: Implements the class methods for FenceNVGL.
+
+#include "libANGLE/renderer/gl/FenceNVGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FenceNVGL::FenceNVGL()
+    : FenceNVImpl()
+{}
+
+FenceNVGL::~FenceNVGL()
+{}
+
+gl::Error FenceNVGL::set()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceNVGL::test(bool flushCommandBuffer, GLboolean *outFinished)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceNVGL::finishFence(GLboolean *outFinished)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/FenceNVGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FenceNVGL.h: Defines the class interface for FenceNVGL.
+
+#ifndef LIBANGLE_RENDERER_GL_FENCENVGL_H_
+#define LIBANGLE_RENDERER_GL_FENCENVGL_H_
+
+#include "libANGLE/renderer/FenceNVImpl.h"
+
+namespace rx
+{
+
+class FenceNVGL : public FenceNVImpl
+{
+  public:
+    FenceNVGL();
+    ~FenceNVGL() override;
+
+    gl::Error set() override;
+    gl::Error test(bool flushCommandBuffer, GLboolean *outFinished) override;
+    gl::Error finishFence(GLboolean *outFinished) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(FenceNVGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_FENCENVGL_H_

src/libANGLE/renderer/gl/FenceSyncGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FenceSyncGL.cpp: Implements the class methods for FenceSyncGL.
+
+#include "libANGLE/renderer/gl/FenceSyncGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FenceSyncGL::FenceSyncGL()
+    : FenceSyncImpl()
+{}
+
+FenceSyncGL::~FenceSyncGL()
+{}
+
+gl::Error FenceSyncGL::set()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncGL::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncGL::serverWait(GLbitfield flags, GLuint64 timeout)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncGL::getStatus(GLint *outResult)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/FenceSyncGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FenceSyncGL.h: Defines the class interface for FenceSyncGL.
+
+#ifndef LIBANGLE_RENDERER_GL_FENCESYNCGL_H_
+#define LIBANGLE_RENDERER_GL_FENCESYNCGL_H_
+
+#include "libANGLE/renderer/FenceSyncImpl.h"
+
+namespace rx
+{
+
+class FenceSyncGL : public FenceSyncImpl
+{
+  public:
+    FenceSyncGL();
+    ~FenceSyncGL() override;
+
+    gl::Error set() override;
+    gl::Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult) override;
+    gl::Error serverWait(GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(GLint *outResult) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(FenceSyncGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_FENCESYNCGL_H_

src/libANGLE/renderer/gl/FramebufferGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FramebufferGL.cpp: Implements the class methods for FramebufferGL.
+
+#include "libANGLE/renderer/gl/FramebufferGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FramebufferGL::FramebufferGL()
+    : FramebufferImpl()
+{}
+
+FramebufferGL::~FramebufferGL()
+{}
+
+void FramebufferGL::setColorAttachment(size_t index, const gl::FramebufferAttachment *attachment)
+{
+    UNIMPLEMENTED();
+}
+
+void FramebufferGL::setDepthttachment(const gl::FramebufferAttachment *attachment)
+{
+    UNIMPLEMENTED();
+}
+
+void FramebufferGL::setStencilAttachment(const gl::FramebufferAttachment *attachment)
+{
+    UNIMPLEMENTED();
+}
+
+void FramebufferGL::setDepthStencilAttachment(const gl::FramebufferAttachment *attachment)
+{
+    UNIMPLEMENTED();
+}
+
+void FramebufferGL::setDrawBuffers(size_t count, const GLenum *buffers)
+{
+    UNIMPLEMENTED();
+}
+
+void FramebufferGL::setReadBuffer(GLenum buffer)
+{
+    UNIMPLEMENTED();
+}
+
+gl::Error FramebufferGL::invalidate(size_t count, const GLenum *attachments)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::clear(const gl::State &state, GLbitfield mask)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::clearBufferfv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLfloat *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::clearBufferuiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLuint *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::clearBufferiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLint *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::clearBufferfi(const gl::State &state, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+GLenum FramebufferGL::getImplementationColorReadFormat() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+GLenum FramebufferGL::getImplementationColorReadType() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+gl::Error FramebufferGL::readPixels(const gl::State &state, const gl::Rectangle &area, GLenum format, GLenum type, GLvoid *pixels) const
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferGL::blit(const gl::State &state, const gl::Rectangle &sourceArea, const gl::Rectangle &destArea,
+                              GLbitfield mask, GLenum filter, const gl::Framebuffer *sourceFramebuffer)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+GLenum FramebufferGL::checkStatus() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+}

src/libANGLE/renderer/gl/FramebufferGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// FramebufferGL.h: Defines the class interface for FramebufferGL.
+
+#ifndef LIBANGLE_RENDERER_GL_FRAMEBUFFERGL_H_
+#define LIBANGLE_RENDERER_GL_FRAMEBUFFERGL_H_
+
+#include "libANGLE/renderer/FramebufferImpl.h"
+
+namespace rx
+{
+
+class FramebufferGL : public FramebufferImpl
+{
+  public:
+    FramebufferGL();
+    ~FramebufferGL() override;
+
+    void setColorAttachment(size_t index, const gl::FramebufferAttachment *attachment) override;
+    void setDepthttachment(const gl::FramebufferAttachment *attachment) override;
+    void setStencilAttachment(const gl::FramebufferAttachment *attachment) override;
+    void setDepthStencilAttachment(const gl::FramebufferAttachment *attachment) override;
+
+    void setDrawBuffers(size_t count, const GLenum *buffers) override;
+    void setReadBuffer(GLenum buffer) override;
+
+    gl::Error invalidate(size_t count, const GLenum *attachments) override;
+    gl::Error invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area) override;
+
+    gl::Error clear(const gl::State &state, GLbitfield mask) override;
+    gl::Error clearBufferfv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLfloat *values) override;
+    gl::Error clearBufferuiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLuint *values) override;
+    gl::Error clearBufferiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLint *values) override;
+    gl::Error clearBufferfi(const gl::State &state, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override;
+
+    GLenum getImplementationColorReadFormat() const override;
+    GLenum getImplementationColorReadType() const override;
+    gl::Error readPixels(const gl::State &state, const gl::Rectangle &area, GLenum format, GLenum type, GLvoid *pixels) const override;
+
+    gl::Error blit(const gl::State &state, const gl::Rectangle &sourceArea, const gl::Rectangle &destArea,
+                   GLbitfield mask, GLenum filter, const gl::Framebuffer *sourceFramebuffer) override;
+
+    GLenum checkStatus() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(FramebufferGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_FRAMEBUFFERGL_H_

src/libANGLE/renderer/gl/ProgramGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ProgramGL.cpp: Implements the class methods for ProgramGL.
+
+#include "libANGLE/renderer/gl/ProgramGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ProgramGL::ProgramGL()
+    : ProgramImpl()
+{}
+
+ProgramGL::~ProgramGL()
+{}
+
+bool ProgramGL::usesPointSize() const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+int ProgramGL::getShaderVersion() const
+{
+    UNIMPLEMENTED();
+    return int();
+}
+
+GLenum ProgramGL::getTransformFeedbackBufferMode() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+GLenum ProgramGL::getBinaryFormat()
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+LinkResult ProgramGL::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
+{
+    UNIMPLEMENTED();
+    return LinkResult(false, gl::Error(GL_INVALID_OPERATION));
+}
+
+gl::Error ProgramGL::save(gl::BinaryOutputStream *stream)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+LinkResult ProgramGL::link(const gl::Data &data, gl::InfoLog &infoLog,
+                           gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                           const std::vector<std::string> &transformFeedbackVaryings,
+                           GLenum transformFeedbackBufferMode,
+                           int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+                           std::map<int, gl::VariableLocation> *outputVariables)
+{
+    UNIMPLEMENTED();
+    return LinkResult(false, gl::Error(GL_INVALID_OPERATION));
+}
+
+void ProgramGL::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform1iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform2iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform3iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform4iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::getUniformfv(GLint location, GLfloat *params)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::getUniformiv(GLint location, GLint *params)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramGL::getUniformuiv(GLint location, GLuint *params)
+{
+    UNIMPLEMENTED();
+}
+
+GLint ProgramGL::getSamplerMapping(gl::SamplerType type, unsigned int samplerIndex, const gl::Caps &caps) const
+{
+    UNIMPLEMENTED();
+    return GLint();
+}
+
+GLenum ProgramGL::getSamplerTextureType(gl::SamplerType type, unsigned int samplerIndex) const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+GLint ProgramGL::getUsedSamplerRange(gl::SamplerType type) const
+{
+    UNIMPLEMENTED();
+    return GLint();
+}
+
+void ProgramGL::updateSamplerMapping()
+{
+    UNIMPLEMENTED();
+}
+
+bool ProgramGL::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+LinkResult ProgramGL::compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                                int registers)
+{
+    UNIMPLEMENTED();
+    return LinkResult(false, gl::Error(GL_INVALID_OPERATION));
+}
+
+bool ProgramGL::linkUniforms(gl::InfoLog &infoLog, const gl::Shader &vertexShader, const gl::Shader &fragmentShader,
+                             const gl::Caps &caps)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+bool ProgramGL::defineUniformBlock(gl::InfoLog &infoLog, const gl::Shader &shader, const sh::InterfaceBlock &interfaceBlock,
+                                   const gl::Caps &caps)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+gl::Error ProgramGL::applyUniforms()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ProgramGL::applyUniformBuffers(const std::vector<gl::Buffer*> boundBuffers, const gl::Caps &caps)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+bool ProgramGL::assignUniformBlockRegister(gl::InfoLog &infoLog, gl::UniformBlock *uniformBlock, GLenum shader,
+                                           unsigned int registerIndex, const gl::Caps &caps)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+}

src/libANGLE/renderer/gl/ProgramGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ProgramGL.h: Defines the class interface for ProgramGL.
+
+#ifndef LIBANGLE_RENDERER_GL_PROGRAMGL_H_
+#define LIBANGLE_RENDERER_GL_PROGRAMGL_H_
+
+#include "libANGLE/renderer/ProgramImpl.h"
+
+namespace rx
+{
+
+class ProgramGL : public ProgramImpl
+{
+  public:
+    ProgramGL();
+    ~ProgramGL() override;
+
+    bool usesPointSize() const override;
+    int getShaderVersion() const override;
+    GLenum getTransformFeedbackBufferMode() const override;
+
+    GLenum getBinaryFormat() override;
+    LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) override;
+    gl::Error save(gl::BinaryOutputStream *stream) override;
+
+    LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
+                    gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                    const std::vector<std::string> &transformFeedbackVaryings,
+                    GLenum transformFeedbackBufferMode,
+                    int *registers, std::vector<gl::LinkedVarying> *linkedVaryings,
+                    std::map<int, gl::VariableLocation> *outputVariables) override;
+
+    void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) override;
+    void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) override;
+    void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) override;
+    void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) override;
+    void setUniform1iv(GLint location, GLsizei count, const GLint *v) override;
+    void setUniform2iv(GLint location, GLsizei count, const GLint *v) override;
+    void setUniform3iv(GLint location, GLsizei count, const GLint *v) override;
+    void setUniform4iv(GLint location, GLsizei count, const GLint *v) override;
+    void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) override;
+    void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) override;
+    void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) override;
+    void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) override;
+    void setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+    void setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) override;
+
+    void getUniformfv(GLint location, GLfloat *params) override;
+    void getUniformiv(GLint location, GLint *params) override;
+    void getUniformuiv(GLint location, GLuint *params) override;
+
+    GLint getSamplerMapping(gl::SamplerType type, unsigned int samplerIndex, const gl::Caps &caps) const override;
+    GLenum getSamplerTextureType(gl::SamplerType type, unsigned int samplerIndex) const override;
+    GLint getUsedSamplerRange(gl::SamplerType type) const override;
+    void updateSamplerMapping() override;
+    bool validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps) override;
+
+    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                         int registers) override;
+
+    bool linkUniforms(gl::InfoLog &infoLog, const gl::Shader &vertexShader, const gl::Shader &fragmentShader,
+                      const gl::Caps &caps) override;
+    bool defineUniformBlock(gl::InfoLog &infoLog, const gl::Shader &shader, const sh::InterfaceBlock &interfaceBlock,
+                            const gl::Caps &caps) override;
+
+    gl::Error applyUniforms() override;
+    gl::Error applyUniformBuffers(const std::vector<gl::Buffer*> boundBuffers, const gl::Caps &caps) override;
+    bool assignUniformBlockRegister(gl::InfoLog &infoLog, gl::UniformBlock *uniformBlock, GLenum shader,
+                                    unsigned int registerIndex, const gl::Caps &caps) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(ProgramGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_PROGRAMGL_H_

src/libANGLE/renderer/gl/QueryGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// QueryGL.cpp: Implements the class methods for QueryGL.
+
+#include "libANGLE/renderer/gl/QueryGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+QueryGL::QueryGL(GLenum type)
+    : QueryImpl(type)
+{}
+
+QueryGL::~QueryGL()
+{}
+
+gl::Error QueryGL::begin()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryGL::end()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryGL::getResult(GLuint *params)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryGL::isResultAvailable(GLuint *available)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/QueryGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// QueryGL.h: Defines the class interface for QueryGL.
+
+#ifndef LIBANGLE_RENDERER_GL_QUERYGL_H_
+#define LIBANGLE_RENDERER_GL_QUERYGL_H_
+
+#include "libANGLE/renderer/QueryImpl.h"
+
+namespace rx
+{
+
+class QueryGL : public QueryImpl
+{
+  public:
+    QueryGL(GLenum type);
+    ~QueryGL() override;
+
+    gl::Error begin() override;
+    gl::Error end() override;
+    gl::Error getResult(GLuint *params) override;
+    gl::Error isResultAvailable(GLuint *available) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(QueryGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_QUERYGL_H_

src/libANGLE/renderer/gl/RenderbufferGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RenderbufferGL.cpp: Implements the class methods for RenderbufferGL.
+
+#include "libANGLE/renderer/gl/RenderbufferGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+RenderbufferGL::RenderbufferGL()
+    : RenderbufferImpl()
+{}
+
+RenderbufferGL::~RenderbufferGL()
+{}
+
+gl::Error RenderbufferGL::setStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}

src/libANGLE/renderer/gl/RenderbufferGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RenderbufferGL.h: Defines the class interface for RenderbufferGL.
+
+#ifndef LIBANGLE_RENDERER_GL_RENDERBUFFERGL_H_
+#define LIBANGLE_RENDERER_GL_RENDERBUFFERGL_H_
+
+#include "libANGLE/renderer/RenderbufferImpl.h"
+
+namespace rx
+{
+
+class RenderbufferGL : public RenderbufferImpl
+{
+  public:
+    RenderbufferGL();
+    ~RenderbufferGL() override;
+
+    gl::Error setStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(RenderbufferGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_RENDERBUFFERGL_H_

src/libANGLE/renderer/gl/RendererGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RendererGL.cpp: Implements the class methods for RendererGL.
+
+#include "libANGLE/renderer/gl/RendererGL.h"
+
+#include "common/debug.h"
+#include "libANGLE/renderer/gl/BufferGL.h"
+#include "libANGLE/renderer/gl/CompilerGL.h"
+#include "libANGLE/renderer/gl/DefaultAttachmentGL.h"
+#include "libANGLE/renderer/gl/FenceNVGL.h"
+#include "libANGLE/renderer/gl/FenceSyncGL.h"
+#include "libANGLE/renderer/gl/FramebufferGL.h"
+#include "libANGLE/renderer/gl/ProgramGL.h"
+#include "libANGLE/renderer/gl/QueryGL.h"
+#include "libANGLE/renderer/gl/RenderbufferGL.h"
+#include "libANGLE/renderer/gl/ShaderGL.h"
+#include "libANGLE/renderer/gl/TextureGL.h"
+#include "libANGLE/renderer/gl/TransformFeedbackGL.h"
+#include "libANGLE/renderer/gl/VertexArrayGL.h"
+
+namespace rx
+{
+
+RendererGL::RendererGL()
+    : Renderer()
+{}
+
+RendererGL::~RendererGL()
+{}
+
+gl::Error RendererGL::flush()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error RendererGL::finish()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error RendererGL::drawArrays(const gl::Data &data, GLenum mode,
+                                 GLint first, GLsizei count, GLsizei instances)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error RendererGL::drawElements(const gl::Data &data, GLenum mode, GLsizei count, GLenum type,
+                                   const GLvoid *indices, GLsizei instances,
+                                   const RangeUI &indexRange)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+CompilerImpl *RendererGL::createCompiler(const gl::Data &data)
+{
+    return new CompilerGL();
+}
+
+ShaderImpl *RendererGL::createShader(GLenum type)
+{
+    return new ShaderGL();
+}
+
+ProgramImpl *RendererGL::createProgram()
+{
+    return new ProgramGL();
+}
+
+DefaultAttachmentImpl *RendererGL::createDefaultAttachment(GLenum type, egl::Surface *surface)
+{
+    return new DefaultAttachmentGL();
+}
+
+FramebufferImpl *RendererGL::createFramebuffer()
+{
+    return new FramebufferGL();
+}
+
+TextureImpl *RendererGL::createTexture(GLenum target)
+{
+    return new TextureGL();
+}
+
+RenderbufferImpl *RendererGL::createRenderbuffer()
+{
+    return new RenderbufferGL();
+}
+
+BufferImpl *RendererGL::createBuffer()
+{
+    return new BufferGL();
+}
+
+VertexArrayImpl *RendererGL::createVertexArray()
+{
+    return new VertexArrayGL();
+}
+
+QueryImpl *RendererGL::createQuery(GLenum type)
+{
+    return new QueryGL(type);
+}
+
+FenceNVImpl *RendererGL::createFenceNV()
+{
+    return new FenceNVGL();
+}
+
+FenceSyncImpl *RendererGL::createFenceSync()
+{
+    return new FenceSyncGL();
+}
+
+TransformFeedbackImpl *RendererGL::createTransformFeedback()
+{
+    return new TransformFeedbackGL();
+}
+
+void RendererGL::notifyDeviceLost()
+{
+    UNIMPLEMENTED();
+}
+
+bool RendererGL::isDeviceLost() const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+bool RendererGL::testDeviceLost()
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+bool RendererGL::testDeviceResettable()
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+VendorID RendererGL::getVendorId() const
+{
+    UNIMPLEMENTED();
+    return VendorID();
+}
+
+std::string RendererGL::getVendorString() const
+{
+    UNIMPLEMENTED();
+    return std::string();
+}
+
+std::string RendererGL::getRendererDescription() const
+{
+    UNIMPLEMENTED();
+    return std::string();
+}
+
+void RendererGL::generateCaps(gl::Caps *outCaps, gl::TextureCapsMap* outTextureCaps, gl::Extensions *outExtensions) const
+{
+    // Set some minimum GLES2 caps, TODO: query for real GL caps
+    outCaps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max());
+    outCaps->max3DTextureSize = 0;
+    outCaps->max2DTextureSize = 1024;
+    outCaps->maxCubeMapTextureSize = outCaps->max2DTextureSize;
+    outCaps->maxArrayTextureLayers = 1;
+    outCaps->maxLODBias = 0.0f;
+    outCaps->maxRenderbufferSize = outCaps->max2DTextureSize;
+    outCaps->maxDrawBuffers = 1;
+    outCaps->maxColorAttachments = 1;
+    outCaps->maxViewportWidth = outCaps->max2DTextureSize;
+    outCaps->maxViewportHeight = outCaps->maxViewportWidth;
+    outCaps->minAliasedPointSize = 1.0f;
+    outCaps->maxAliasedPointSize = 1.0f;
+    outCaps->minAliasedLineWidth = 1.0f;
+    outCaps->maxAliasedLineWidth = 1.0f;
+    outCaps->maxElementsIndices = 0;
+    outCaps->maxElementsVertices = 0;
+    outCaps->maxServerWaitTimeout = 0;
+    outCaps->maxVertexAttributes = 16;
+    outCaps->maxVertexUniformVectors = 256;
+    outCaps->maxVertexUniformVectors = outCaps->maxVertexUniformVectors * 4;
+    outCaps->maxVertexUniformBlocks = 0;
+    outCaps->maxVertexOutputComponents = 16;
+    outCaps->maxVertexTextureImageUnits = outCaps->maxTextureImageUnits;
+    outCaps->maxFragmentUniformVectors = 256;
+    outCaps->maxFragmentUniformComponents = outCaps->maxFragmentUniformVectors * 4;
+    outCaps->maxFragmentUniformBlocks = 0;
+    outCaps->maxFragmentInputComponents = outCaps->maxVertexOutputComponents;
+    outCaps->maxTextureImageUnits = 16;
+    outCaps->minProgramTexelOffset = 0;
+    outCaps->maxProgramTexelOffset = 0;
+    outCaps->maxUniformBufferBindings = 0;
+    outCaps->maxUniformBlockSize = 0;
+    outCaps->uniformBufferOffsetAlignment = 0;
+    outCaps->maxCombinedUniformBlocks = 0;
+    outCaps->maxCombinedVertexUniformComponents = 0;
+    outCaps->maxCombinedFragmentUniformComponents = 0;
+    outCaps->maxVaryingComponents = 0;
+    outCaps->maxVaryingVectors = outCaps->maxVertexOutputComponents / 4;
+    outCaps->maxCombinedTextureImageUnits = outCaps->maxVertexTextureImageUnits + outCaps->maxTextureImageUnits;
+    outCaps->maxTransformFeedbackInterleavedComponents = 0;
+    outCaps->maxTransformFeedbackSeparateAttributes = 0;
+    outCaps->maxTransformFeedbackSeparateComponents = 0;
+
+    gl::TextureCaps supportedTextureFormat;
+    supportedTextureFormat.texturable = true;
+    supportedTextureFormat.filterable = true;
+    supportedTextureFormat.renderable = true;
+
+    outTextureCaps->insert(GL_RGB565, supportedTextureFormat);
+    outTextureCaps->insert(GL_RGBA4, supportedTextureFormat);
+    outTextureCaps->insert(GL_RGB5_A1, supportedTextureFormat);
+    outTextureCaps->insert(GL_RGB8_OES, supportedTextureFormat);
+    outTextureCaps->insert(GL_RGBA8_OES, supportedTextureFormat);
+
+    outTextureCaps->insert(GL_DEPTH_COMPONENT16, supportedTextureFormat);
+    outTextureCaps->insert(GL_STENCIL_INDEX8, supportedTextureFormat);
+
+    outExtensions->setTextureExtensionSupport(*outTextureCaps);
+    outExtensions->textureNPOT = true;
+    outExtensions->textureStorage = true;
+}
+
+Workarounds RendererGL::generateWorkarounds() const
+{
+    Workarounds workarounds;
+    return workarounds;
+}
+
+}

src/libANGLE/renderer/gl/RendererGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// RendererGL.h: Defines the class interface for RendererGL.
+
+#ifndef LIBANGLE_RENDERER_GL_RENDERERGL_H_
+#define LIBANGLE_RENDERER_GL_RENDERERGL_H_
+
+#include "libANGLE/renderer/Renderer.h"
+
+namespace rx
+{
+
+class RendererGL : public Renderer
+{
+  public:
+    RendererGL();
+    ~RendererGL() override;
+
+    gl::Error flush() override;
+    gl::Error finish() override;
+
+    gl::Error drawArrays(const gl::Data &data, GLenum mode,
+                         GLint first, GLsizei count, GLsizei instances) override;
+    gl::Error drawElements(const gl::Data &data, GLenum mode, GLsizei count, GLenum type,
+                           const GLvoid *indices, GLsizei instances,
+                           const RangeUI &indexRange) override;
+
+    // Shader creation
+    CompilerImpl *createCompiler(const gl::Data &data) override;
+    ShaderImpl *createShader(GLenum type) override;
+    ProgramImpl *createProgram() override;
+
+    // Framebuffer creation
+    DefaultAttachmentImpl *createDefaultAttachment(GLenum type, egl::Surface *surface) override;
+    FramebufferImpl *createFramebuffer() override;
+
+    // Texture creation
+    TextureImpl *createTexture(GLenum target) override;
+
+    // Renderbuffer creation
+    RenderbufferImpl *createRenderbuffer() override;
+
+    // Buffer creation
+    BufferImpl *createBuffer() override;
+
+    // Vertex Array creation
+    VertexArrayImpl *createVertexArray() override;
+
+    // Query and Fence creation
+    QueryImpl *createQuery(GLenum type) override;
+    FenceNVImpl *createFenceNV() override;
+    FenceSyncImpl *createFenceSync() override;
+
+    // Transform Feedback creation
+    TransformFeedbackImpl *createTransformFeedback() override;
+
+    // lost device
+    void notifyDeviceLost() override;
+    bool isDeviceLost() const override;
+    bool testDeviceLost() override;
+    bool testDeviceResettable() override;
+
+    VendorID getVendorId() const override;
+    std::string getVendorString() const override;
+    std::string getRendererDescription() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(RendererGL);
+
+    void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap* outTextureCaps, gl::Extensions *outExtensions) const override;
+    Workarounds generateWorkarounds() const override;
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_RENDERERGL_H_

src/libANGLE/renderer/gl/ShaderGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ShaderGL.cpp: Implements the class methods for ShaderGL.
+
+#include "libANGLE/renderer/gl/ShaderGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ShaderGL::ShaderGL()
+    : ShaderImpl()
+{}
+
+ShaderGL::~ShaderGL()
+{}
+
+bool ShaderGL::compile(gl::Compiler *compiler, const std::string &source)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+std::string ShaderGL::getDebugInfo() const
+{
+    UNIMPLEMENTED();
+    return std::string();
+}
+
+}

src/libANGLE/renderer/gl/ShaderGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ShaderGL.h: Defines the class interface for ShaderGL.
+
+#ifndef LIBANGLE_RENDERER_GL_SHADERGL_H_
+#define LIBANGLE_RENDERER_GL_SHADERGL_H_
+
+#include "libANGLE/renderer/ShaderImpl.h"
+
+namespace rx
+{
+
+class ShaderGL : public ShaderImpl
+{
+  public:
+    ShaderGL();
+    ~ShaderGL() override;
+
+    bool compile(gl::Compiler *compiler, const std::string &source) override;
+    std::string getDebugInfo() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(ShaderGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_SHADERGL_H_

src/libANGLE/renderer/gl/SurfaceGL.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SurfaceGL.cpp: OpenGL implementation of egl::Surface
+
+#include "libANGLE/renderer/gl/SurfaceGL.h"
+
+namespace rx
+{
+
+SurfaceGL::SurfaceGL(egl::Display *display, const egl::Config *config,
+                     EGLint fixedSize, EGLint postSubBufferSupported, EGLenum textureFormat,
+                     EGLenum textureType)
+    : SurfaceImpl(display, config, fixedSize, postSubBufferSupported, textureFormat, textureType)
+{
+}
+
+SurfaceGL::~SurfaceGL()
+{
+}
+
+}

src/libANGLE/renderer/gl/SurfaceGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SurfaceGL.h: Defines the class interface for SurfaceGL.
+
+#ifndef LIBANGLE_RENDERER_GL_SURFACEGL_H_
+#define LIBANGLE_RENDERER_GL_SURFACEGL_H_
+
+#include "libANGLE/renderer/SurfaceImpl.h"
+
+namespace rx
+{
+
+class SurfaceGL : public SurfaceImpl
+{
+  public:
+    SurfaceGL(egl::Display *display, const egl::Config *config,
+              EGLint fixedSize, EGLint postSubBufferSupported, EGLenum textureFormat,
+              EGLenum textureType);
+    ~SurfaceGL() override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(SurfaceGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_SURFACEGL_H_

src/libANGLE/renderer/gl/TextureGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// TextureGL.cpp: Implements the class methods for TextureGL.
+
+#include "libANGLE/renderer/gl/TextureGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+TextureGL::TextureGL()
+    : TextureImpl()
+{}
+
+TextureGL::~TextureGL()
+{}
+
+void TextureGL::setUsage(GLenum usage)
+{
+    UNIMPLEMENTED();
+}
+
+gl::Error TextureGL::setImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, GLenum format, GLenum type,
+                              const gl::PixelUnpackState &unpack, const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type,
+                                 const gl::PixelUnpackState &unpack, const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size,
+                                        const gl::PixelUnpackState &unpack, const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
+                                           const gl::PixelUnpackState &unpack, const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::copyImage(GLenum target, size_t level, const gl::Rectangle &sourceArea, GLenum internalFormat,
+                               const gl::Framebuffer *source)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea,
+                                  const gl::Framebuffer *source)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureGL::generateMipmaps()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+void TextureGL::bindTexImage(egl::Surface *surface)
+{
+    UNIMPLEMENTED();
+}
+
+void TextureGL::releaseTexImage()
+{
+    UNIMPLEMENTED();
+}
+
+}

src/libANGLE/renderer/gl/TextureGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// TextureGL.h: Defines the class interface for TextureGL.
+
+#ifndef LIBANGLE_RENDERER_GL_TEXTUREGL_H_
+#define LIBANGLE_RENDERER_GL_TEXTUREGL_H_
+
+#include "libANGLE/renderer/TextureImpl.h"
+
+namespace rx
+{
+
+class TextureGL : public TextureImpl
+{
+  public:
+    TextureGL();
+    ~TextureGL() override;
+
+    void setUsage(GLenum usage) override;
+
+    gl::Error setImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size, GLenum format, GLenum type,
+                       const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
+    gl::Error setSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format, GLenum type,
+                          const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
+
+    gl::Error setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const gl::Extents &size,
+                                 const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
+    gl::Error setCompressedSubImage(GLenum target, size_t level, const gl::Box &area, GLenum format,
+                                    const gl::PixelUnpackState &unpack, const uint8_t *pixels) override;
+
+    gl::Error copyImage(GLenum target, size_t level, const gl::Rectangle &sourceArea, GLenum internalFormat,
+                        const gl::Framebuffer *source) override;
+    gl::Error copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea,
+                           const gl::Framebuffer *source) override;
+
+    gl::Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const gl::Extents &size) override;
+
+    gl::Error generateMipmaps() override;
+
+    void bindTexImage(egl::Surface *surface) override;
+    void releaseTexImage() override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_TEXTUREGL_H_

src/libANGLE/renderer/gl/TransformFeedbackGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// TransformFeedbackGL.cpp: Implements the class methods for TransformFeedbackGL.
+
+#include "libANGLE/renderer/gl/TransformFeedbackGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+TransformFeedbackGL::TransformFeedbackGL()
+    : TransformFeedbackImpl()
+{}
+
+TransformFeedbackGL::~TransformFeedbackGL()
+{}
+
+void TransformFeedbackGL::begin(GLenum primitiveMode)
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackGL::end()
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackGL::pause()
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackGL::resume()
+{
+    UNIMPLEMENTED();
+}
+
+}

src/libANGLE/renderer/gl/TransformFeedbackGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// TransformFeedbackGL.h: Defines the class interface for TransformFeedbackGL.
+
+#ifndef LIBANGLE_RENDERER_GL_TRANSFORMFEEDBACKGL_H_
+#define LIBANGLE_RENDERER_GL_TRANSFORMFEEDBACKGL_H_
+
+#include "libANGLE/renderer/TransformFeedbackImpl.h"
+
+namespace rx
+{
+
+class TransformFeedbackGL : public TransformFeedbackImpl
+{
+  public:
+    TransformFeedbackGL();
+    ~TransformFeedbackGL() override;
+
+    void begin(GLenum primitiveMode) override;
+    void end() override;
+    void pause() override;
+    void resume() override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TransformFeedbackGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_TRANSFORMFEEDBACKGL_H_

src/libANGLE/renderer/gl/VertexArrayGL.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// VertexArrayGL.cpp: Implements the class methods for VertexArrayGL.
+
+#include "libANGLE/renderer/gl/VertexArrayGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+VertexArrayGL::VertexArrayGL()
+    : VertexArrayImpl()
+{}
+
+VertexArrayGL::~VertexArrayGL()
+{}
+
+void VertexArrayGL::setElementArrayBuffer(const gl::Buffer *buffer)
+{
+    UNIMPLEMENTED();
+}
+
+void VertexArrayGL::setAttribute(size_t idx, const gl::VertexAttribute &attr)
+{
+    UNIMPLEMENTED();
+}
+
+void VertexArrayGL::setAttributeDivisor(size_t idx, GLuint divisor)
+{
+    UNIMPLEMENTED();
+}
+
+void VertexArrayGL::enableAttribute(size_t idx, bool enabledState)
+{
+    UNIMPLEMENTED();
+}
+
+}

src/libANGLE/renderer/gl/VertexArrayGL.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// VertexArrayGL.h: Defines the class interface for VertexArrayGL.
+
+#ifndef LIBANGLE_RENDERER_GL_VERTEXARRAYGL_H_
+#define LIBANGLE_RENDERER_GL_VERTEXARRAYGL_H_
+
+#include "libANGLE/renderer/VertexArrayImpl.h"
+
+namespace rx
+{
+
+class VertexArrayGL : public VertexArrayImpl
+{
+  public:
+    VertexArrayGL();
+    ~VertexArrayGL() override;
+
+    void setElementArrayBuffer(const gl::Buffer *buffer) override;
+    void setAttribute(size_t idx, const gl::VertexAttribute &attr) override;
+    void setAttributeDivisor(size_t idx, GLuint divisor) override;
+    void enableAttribute(size_t idx, bool enabledState) override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(VertexArrayGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_VERTEXARRAYGL_H_

src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DisplayWGL.h: WGL implementation of egl::Display
+
+#include "libANGLE/renderer/gl/wgl/DisplayWGL.h"
+
+#include "common/debug.h"
+#include "libANGLE/Config.h"
+
+namespace rx
+{
+
+DisplayWGL::DisplayWGL()
+    : DisplayGL()
+{
+}
+
+DisplayWGL::~DisplayWGL()
+{
+}
+
+egl::Error DisplayWGL::initialize(egl::Display *display)
+{
+    return DisplayGL::initialize(display);
+}
+
+void DisplayWGL::terminate()
+{
+    DisplayGL::terminate();
+}
+
+egl::Error DisplayWGL::createWindowSurface(const egl::Config *configuration, EGLNativeWindowType window,
+                                           const egl::AttributeMap &attribs, SurfaceImpl **outSurface)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error DisplayWGL::createPbufferSurface(const egl::Config *configuration, const egl::AttributeMap &attribs,
+                                            SurfaceImpl **outSurface)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_DISPLAY);
+}
+
+egl::Error DisplayWGL::createPbufferFromClientBuffer(const egl::Config *configuration, EGLClientBuffer shareHandle,
+                                                     const egl::AttributeMap &attribs, SurfaceImpl **outSurface)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_DISPLAY);
+}
+
+egl::Error DisplayWGL::makeCurrent(egl::Surface *drawSurface, egl::Surface *readSurface, gl::Context *context)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::ConfigSet DisplayWGL::generateConfigs() const
+{
+    UNIMPLEMENTED();
+    egl::ConfigSet configs;
+    return configs;
+}
+
+bool DisplayWGL::isDeviceLost() const
+{
+    UNIMPLEMENTED();
+    return false;
+}
+
+bool DisplayWGL::testDeviceLost()
+{
+    UNIMPLEMENTED();
+    return false;
+}
+
+egl::Error DisplayWGL::restoreLostDevice()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_DISPLAY);
+}
+
+bool DisplayWGL::isValidNativeWindow(EGLNativeWindowType window) const
+{
+    UNIMPLEMENTED();
+    return true;
+}
+
+std::string DisplayWGL::getVendorString() const
+{
+    UNIMPLEMENTED();
+    return "";
+}
+
+void DisplayWGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
+{
+    UNIMPLEMENTED();
+}
+
+void DisplayWGL::generateCaps(egl::Caps *outCaps) const
+{
+    outCaps->textureNPOT = true;
+}
+
+}

src/libANGLE/renderer/gl/wgl/DisplayWGL.h

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// DisplayWGL.h: WGL implementation of egl::Display
+
+#ifndef LIBANGLE_RENDERER_GL_WGL_DISPLAYWGL_H_
+#define LIBANGLE_RENDERER_GL_WGL_DISPLAYWGL_H_
+
+#include "libANGLE/renderer/gl/DisplayGL.h"
+
+namespace rx
+{
+
+class DisplayWGL : public DisplayGL
+{
+  public:
+    DisplayWGL();
+    ~DisplayWGL() override;
+
+    egl::Error initialize(egl::Display *display) override;
+    void terminate() override;
+
+    egl::Error createWindowSurface(const egl::Config *configuration, EGLNativeWindowType window, const egl::AttributeMap &attribs,
+                                   SurfaceImpl **outSurface) override;
+    egl::Error createPbufferSurface(const egl::Config *configuration, const egl::AttributeMap &attribs,
+                                    SurfaceImpl **outSurface) override;
+    egl::Error createPbufferFromClientBuffer(const egl::Config *configuration, EGLClientBuffer shareHandle,
+                                             const egl::AttributeMap &attribs, SurfaceImpl **outSurface) override;
+
+    egl::Error makeCurrent(egl::Surface *drawSurface, egl::Surface *readSurface, gl::Context *context) override;
+
+    egl::ConfigSet generateConfigs() const override;
+
+    bool isDeviceLost() const override;
+    bool testDeviceLost() override;
+    egl::Error restoreLostDevice() override;
+
+    bool isValidNativeWindow(EGLNativeWindowType window) const override;
+
+    std::string getVendorString() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(DisplayWGL);
+
+    void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
+    void generateCaps(egl::Caps *outCaps) const override;
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_WGL_DISPLAYWGL_H_

src/libANGLE/renderer/gl/wgl/SurfaceWGL.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SurfaceWGL.cpp: WGL implementation of egl::Surface
+
+#include "libANGLE/renderer/gl/wgl/SurfaceWGL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+SurfaceWGL::SurfaceWGL(egl::Display *display, const egl::Config *config, EGLint fixedSize, EGLint postSubBufferSupported,
+                       EGLenum textureFormat, EGLenum textureType)
+    : SurfaceGL(display, config, fixedSize, postSubBufferSupported, textureFormat, textureType)
+{
+}
+
+SurfaceWGL::~SurfaceWGL()
+{
+}
+
+egl::Error SurfaceWGL::swap()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error SurfaceWGL::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error SurfaceWGL::querySurfacePointerANGLE(EGLint attribute, void **value)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error SurfaceWGL::bindTexImage(EGLint buffer)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error SurfaceWGL::releaseTexImage(EGLint buffer)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_SUCCESS);
+}
+
+void SurfaceWGL::setSwapInterval(EGLint interval)
+{
+    UNIMPLEMENTED();
+}
+
+EGLint SurfaceWGL::getWidth() const
+{
+    UNIMPLEMENTED();
+    return 0;
+}
+
+EGLint SurfaceWGL::getHeight() const
+{
+    UNIMPLEMENTED();
+    return 0;
+}
+
+EGLNativeWindowType SurfaceWGL::getWindowHandle() const
+{
+    UNIMPLEMENTED();
+    return NULL;
+}
+
+}

src/libANGLE/renderer/gl/wgl/SurfaceWGL.h

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SurfaceWGL.h: WGL implementation of egl::Surface
+
+#ifndef LIBANGLE_RENDERER_GL_WGL_SURFACEWGL_H_
+#define LIBANGLE_RENDERER_GL_WGL_SURFACEWGL_H_
+
+#include "libANGLE/renderer/gl/SurfaceGL.h"
+
+namespace rx
+{
+
+class SurfaceWGL : public SurfaceGL
+{
+  public:
+    SurfaceWGL(egl::Display *display, const egl::Config *config, EGLint fixedSize, EGLint postSubBufferSupported,
+               EGLenum textureFormat, EGLenum textureType);
+
+    ~SurfaceWGL() override;
+
+    egl::Error swap() override;
+    egl::Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height) override;
+    egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
+    egl::Error bindTexImage(EGLint buffer) override;
+    egl::Error releaseTexImage(EGLint buffer) override;
+    void setSwapInterval(EGLint interval) override;
+
+    EGLint getWidth() const override;
+    EGLint getHeight() const override;
+
+    EGLNativeWindowType getWindowHandle() const override;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(SurfaceWGL);
+};
+
+}
+
+#endif // LIBANGLE_RENDERER_GL_WGL_SURFACEWGL_H_

src/libGLESv2.gypi

@@ -359,6 +359,48 @@
             'libANGLE/renderer/d3d/d3d11/winrt/InspectableNativeWindow.cpp',
             'libANGLE/renderer/d3d/d3d11/winrt/InspectableNativeWindow.h',
         ],
+        'libangle_gl_sources':
+        [
+            'libANGLE/renderer/gl/BufferGL.cpp',
+            'libANGLE/renderer/gl/BufferGL.h',
+            'libANGLE/renderer/gl/CompilerGL.cpp',
+            'libANGLE/renderer/gl/CompilerGL.h',
+            'libANGLE/renderer/gl/DefaultAttachmentGL.cpp',
+            'libANGLE/renderer/gl/DefaultAttachmentGL.h',
+            'libANGLE/renderer/gl/DisplayGL.cpp',
+            'libANGLE/renderer/gl/DisplayGL.h',
+            'libANGLE/renderer/gl/FenceNVGL.cpp',
+            'libANGLE/renderer/gl/FenceNVGL.h',
+            'libANGLE/renderer/gl/FenceSyncGL.cpp',
+            'libANGLE/renderer/gl/FenceSyncGL.h',
+            'libANGLE/renderer/gl/FramebufferGL.cpp',
+            'libANGLE/renderer/gl/FramebufferGL.h',
+            'libANGLE/renderer/gl/ProgramGL.cpp',
+            'libANGLE/renderer/gl/ProgramGL.h',
+            'libANGLE/renderer/gl/QueryGL.cpp',
+            'libANGLE/renderer/gl/QueryGL.h',
+            'libANGLE/renderer/gl/RenderbufferGL.cpp',
+            'libANGLE/renderer/gl/RenderbufferGL.h',
+            'libANGLE/renderer/gl/RendererGL.cpp',
+            'libANGLE/renderer/gl/RendererGL.h',
+            'libANGLE/renderer/gl/ShaderGL.cpp',
+            'libANGLE/renderer/gl/ShaderGL.h',
+            'libANGLE/renderer/gl/SurfaceGL.cpp',
+            'libANGLE/renderer/gl/SurfaceGL.h',
+            'libANGLE/renderer/gl/TextureGL.cpp',
+            'libANGLE/renderer/gl/TextureGL.h',
+            'libANGLE/renderer/gl/TransformFeedbackGL.cpp',
+            'libANGLE/renderer/gl/TransformFeedbackGL.h',
+            'libANGLE/renderer/gl/VertexArrayGL.cpp',
+            'libANGLE/renderer/gl/VertexArrayGL.h',
+        ],
+        'libangle_gl_wgl_sources':
+        [
+            'libANGLE/renderer/gl/wgl/DisplayWGL.cpp',
+            'libANGLE/renderer/gl/wgl/DisplayWGL.h',
+            'libANGLE/renderer/gl/wgl/SurfaceWGL.cpp',
+            'libANGLE/renderer/gl/wgl/SurfaceWGL.h',
+        ],
         'libglesv2_sources':
         [
             'common/angleutils.h',
@@ -453,6 +495,13 @@
                             'ANGLE_ENABLE_D3D11',
                         ],
                     }],
+                    ['angle_enable_gl==1',
+                    {
+                        'defines':
+                        [
+                            'ANGLE_ENABLE_OPENGL',
+                        ],
+                    }],
                 ],
             },
             'conditions':
@@ -543,6 +592,40 @@
                         }],
                     ],
                 }],
+                ['angle_enable_gl==1',
+                {
+                    'sources':
+                    [
+                        '<@(libangle_gl_sources)',
+                    ],
+                    'defines':
+                    [
+                        'ANGLE_ENABLE_OPENGL',
+                    ],
+                    'link_settings':
+                    {
+                        'msvs_settings':
+                        {
+                            'VCLinkerTool':
+                            {
+                                'AdditionalDependencies':
+                                [
+                                    'OpenGL32.lib',
+                                ],
+                            },
+                        },
+                    },
+                    'conditions':
+                    [
+                        ['OS=="win"',
+                        {
+                            'sources':
+                            [
+                                '<@(libangle_gl_wgl_sources)',
+                            ],
+                        }],
+                    ],
+                }],
                 ['angle_build_winrt==0 and OS=="win"',
                 {
                     'dependencies':