Add stubs for a NULL renderer.

BUILD.gn

@@ -313,6 +313,9 @@ config("libANGLE_config") {
   if (angle_enable_vulkan) {
     defines += [ "ANGLE_ENABLE_VULKAN" ]
   }
+  if (angle_enable_null) {
+    defines += [ "ANGLE_ENABLE_NULL" ]
+  }
   defines += [
     "GL_GLEXT_PROTOTYPES",
     "EGL_EGLEXT_PROTOTYPES",
@@ -417,6 +420,10 @@ static_library("libANGLE") {
     sources += rebase_path(gles_gypi.libangle_vulkan_sources, ".", "src")
   }
 
+  if (angle_enable_null) {
+    sources += rebase_path(gles_gypi.libangle_null_sources, ".", "src")
+  }
+
   if (is_debug) {
     defines += [ "ANGLE_GENERATE_SHADER_DEBUG_INFO" ]
   }

build/angle_common.gni

@@ -8,6 +8,7 @@ angle_enable_d3d9 = false
 angle_enable_d3d11 = false
 angle_enable_gl = false
 angle_enable_vulkan = false
+angle_enable_null = true
 
 if (is_win) {
   angle_enable_d3d9 = true

build/gyp_angle

@@ -53,6 +53,7 @@ def generateWinRTProjects(generate_args, generation_dir, msvs_version, app_type_
     args.append('-Dangle_enable_d3d9=0')
     args.append('-Dangle_enable_gl=0')
     args.append('-Dangle_enable_vulkan=0')
+    args.append('-Dangle_enable_null=0')
     args.append('-Dangle_enable_essl=0')
     args.append('-Dangle_enable_glsl=0')
     # Add all.gyp as the main gyp file to be generated.

scripts/generate_new_renderer.py

@@ -41,6 +41,7 @@ impl_classes = [
     'FenceSync',
     'Framebuffer',
     'Image',
+    'Path',
     'Program',
     'Query',
     'Renderbuffer',

src/angle.gyp

@@ -45,6 +45,7 @@
                 'angle_enable_gl%': 1,
             }],
         ],
+        'angle_enable_null%': 1, # Available on all platforms
     },
     'includes':
     [

src/libANGLE/renderer/FramebufferAttachmentObjectImpl.h

@@ -23,7 +23,11 @@ class FramebufferAttachmentObjectImpl : angle::NonCopyable
     virtual ~FramebufferAttachmentObjectImpl() {}
 
     virtual gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                                FramebufferAttachmentRenderTarget **rtOut) = 0;
+                                                FramebufferAttachmentRenderTarget **rtOut)
+    {
+        UNIMPLEMENTED();
+        return gl::Error(GL_OUT_OF_MEMORY, "getAttachmentRenderTarget not supported.");
+    }
 };
 
 }  // namespace rx

src/libANGLE/renderer/gl/RenderbufferGL.h

@@ -38,12 +38,6 @@ class RenderbufferGL : public RenderbufferImpl
 
     GLuint getRenderbufferID() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
   private:
     const FunctionsGL *mFunctions;
     const WorkaroundsGL &mWorkarounds;

src/libANGLE/renderer/gl/SurfaceGL.h

@@ -22,12 +22,6 @@ class SurfaceGL : public SurfaceImpl
     SurfaceGL(const egl::SurfaceState &state, RendererGL *renderer);
     ~SurfaceGL() override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &data) override;
 
     virtual egl::Error makeCurrent() = 0;

src/libANGLE/renderer/gl/TextureGL.h

@@ -90,12 +90,6 @@ class TextureGL : public TextureImpl
     void syncState(size_t textureUnit) const;
     GLuint getTextureID() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
     void setBaseLevel(GLuint) override {}
 
   private:

src/libANGLE/renderer/null/BufferNULL.cpp

+//
+// Copyright 2016 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.
+//
+// BufferNULL.cpp:
+//    Implements the class methods for BufferNULL.
+//
+
+#include "libANGLE/renderer/null/BufferNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+BufferNULL::BufferNULL() : BufferImpl()
+{
+}
+
+BufferNULL::~BufferNULL()
+{
+}
+
+gl::Error BufferNULL::setData(GLenum target, const void *data, size_t size, GLenum usage)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::setSubData(GLenum target, const void *data, size_t size, size_t offset)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::copySubData(BufferImpl *source,
+                                  GLintptr sourceOffset,
+                                  GLintptr destOffset,
+                                  GLsizeiptr size)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::map(GLenum access, GLvoid **mapPtr)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::unmap(GLboolean *result)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error BufferNULL::getIndexRange(GLenum type,
+                                    size_t offset,
+                                    size_t count,
+                                    bool primitiveRestartEnabled,
+                                    gl::IndexRange *outRange)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/BufferNULL.h

+//
+// Copyright 2016 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.
+//
+// BufferNULL.h:
+//    Defines the class interface for BufferNULL, implementing BufferImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_BUFFERNULL_H_
+#define LIBANGLE_RENDERER_NULL_BUFFERNULL_H_
+
+#include "libANGLE/renderer/BufferImpl.h"
+
+namespace rx
+{
+
+class BufferNULL : public BufferImpl
+{
+  public:
+    BufferNULL();
+    ~BufferNULL() override;
+
+    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
+    gl::Error setSubData(GLenum target, 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(GLenum access, GLvoid **mapPtr) override;
+    gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr) override;
+    gl::Error unmap(GLboolean *result) override;
+
+    gl::Error getIndexRange(GLenum type,
+                            size_t offset,
+                            size_t count,
+                            bool primitiveRestartEnabled,
+                            gl::IndexRange *outRange) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_BUFFERNULL_H_

src/libANGLE/renderer/null/CompilerNULL.cpp

+//
+// Copyright 2016 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.
+//
+// CompilerNULL.cpp:
+//    Implements the class methods for CompilerNULL.
+//
+
+#include "libANGLE/renderer/null/CompilerNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+CompilerNULL::CompilerNULL() : CompilerImpl()
+{
+}
+
+CompilerNULL::~CompilerNULL()
+{
+}
+
+gl::Error CompilerNULL::release()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+ShShaderOutput CompilerNULL::getTranslatorOutputType() const
+{
+    UNIMPLEMENTED();
+    return ShShaderOutput();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/CompilerNULL.h

+//
+// Copyright 2016 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.
+//
+// CompilerNULL.h:
+//    Defines the class interface for CompilerNULL, implementing CompilerImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_COMPILERNULL_H_
+#define LIBANGLE_RENDERER_NULL_COMPILERNULL_H_
+
+#include "libANGLE/renderer/CompilerImpl.h"
+
+namespace rx
+{
+
+class CompilerNULL : public CompilerImpl
+{
+  public:
+    CompilerNULL();
+    ~CompilerNULL() override;
+
+    gl::Error release() override;
+
+    // TODO(jmadill): Expose translator built-in resources init method.
+    ShShaderOutput getTranslatorOutputType() const override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_COMPILERNULL_H_

src/libANGLE/renderer/null/ContextNULL.cpp

+//
+// Copyright 2016 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.
+//
+// ContextNULL.cpp:
+//    Implements the class methods for ContextNULL.
+//
+
+#include "libANGLE/renderer/null/ContextNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ContextNULL::ContextNULL(const gl::ContextState &state) : ContextImpl(state)
+{
+}
+
+ContextNULL::~ContextNULL()
+{
+}
+
+gl::Error ContextNULL::initialize()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::flush()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::finish()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::drawArrays(GLenum mode, GLint first, GLsizei count)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::drawArraysInstanced(GLenum mode,
+                                           GLint first,
+                                           GLsizei count,
+                                           GLsizei instanceCount)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::drawElements(GLenum mode,
+                                    GLsizei count,
+                                    GLenum type,
+                                    const GLvoid *indices,
+                                    const gl::IndexRange &indexRange)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::drawElementsInstanced(GLenum mode,
+                                             GLsizei count,
+                                             GLenum type,
+                                             const GLvoid *indices,
+                                             GLsizei instances,
+                                             const gl::IndexRange &indexRange)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error ContextNULL::drawRangeElements(GLenum mode,
+                                         GLuint start,
+                                         GLuint end,
+                                         GLsizei count,
+                                         GLenum type,
+                                         const GLvoid *indices,
+                                         const gl::IndexRange &indexRange)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+CompilerImpl *ContextNULL::createCompiler()
+{
+    UNIMPLEMENTED();
+    return static_cast<CompilerImpl *>(0);
+}
+
+ShaderImpl *ContextNULL::createShader(const gl::ShaderState &data)
+{
+    UNIMPLEMENTED();
+    return static_cast<ShaderImpl *>(0);
+}
+
+ProgramImpl *ContextNULL::createProgram(const gl::ProgramState &data)
+{
+    UNIMPLEMENTED();
+    return static_cast<ProgramImpl *>(0);
+}
+
+FramebufferImpl *ContextNULL::createFramebuffer(const gl::FramebufferState &data)
+{
+    UNIMPLEMENTED();
+    return static_cast<FramebufferImpl *>(0);
+}
+
+TextureImpl *ContextNULL::createTexture(const gl::TextureState &state)
+{
+    UNIMPLEMENTED();
+    return static_cast<TextureImpl *>(0);
+}
+
+RenderbufferImpl *ContextNULL::createRenderbuffer()
+{
+    UNIMPLEMENTED();
+    return static_cast<RenderbufferImpl *>(0);
+}
+
+BufferImpl *ContextNULL::createBuffer()
+{
+    UNIMPLEMENTED();
+    return static_cast<BufferImpl *>(0);
+}
+
+VertexArrayImpl *ContextNULL::createVertexArray(const gl::VertexArrayState &data)
+{
+    UNIMPLEMENTED();
+    return static_cast<VertexArrayImpl *>(0);
+}
+
+QueryImpl *ContextNULL::createQuery(GLenum type)
+{
+    UNIMPLEMENTED();
+    return static_cast<QueryImpl *>(0);
+}
+
+FenceNVImpl *ContextNULL::createFenceNV()
+{
+    UNIMPLEMENTED();
+    return static_cast<FenceNVImpl *>(0);
+}
+
+FenceSyncImpl *ContextNULL::createFenceSync()
+{
+    UNIMPLEMENTED();
+    return static_cast<FenceSyncImpl *>(0);
+}
+
+TransformFeedbackImpl *ContextNULL::createTransformFeedback(const gl::TransformFeedbackState &state)
+{
+    UNIMPLEMENTED();
+    return static_cast<TransformFeedbackImpl *>(0);
+}
+
+SamplerImpl *ContextNULL::createSampler()
+{
+    UNIMPLEMENTED();
+    return static_cast<SamplerImpl *>(0);
+}
+
+std::vector<PathImpl *> ContextNULL::createPaths(GLsizei range)
+{
+    UNIMPLEMENTED();
+    return std::vector<PathImpl *>();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/ContextNULL.h

+//
+// Copyright 2016 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.
+//
+// ContextNULL.h:
+//    Defines the class interface for ContextNULL, implementing ContextImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_CONTEXTNULL_H_
+#define LIBANGLE_RENDERER_NULL_CONTEXTNULL_H_
+
+#include "libANGLE/renderer/ContextImpl.h"
+
+namespace rx
+{
+
+class ContextNULL : public ContextImpl
+{
+  public:
+    ContextNULL(const gl::ContextState &state);
+    ~ContextNULL() override;
+
+    gl::Error initialize() override;
+
+    // Flush and finish.
+    gl::Error flush() override;
+    gl::Error finish() override;
+
+    // Drawing methods.
+    gl::Error drawArrays(GLenum mode, GLint first, GLsizei count) override;
+    gl::Error drawArraysInstanced(GLenum mode,
+                                  GLint first,
+                                  GLsizei count,
+                                  GLsizei instanceCount) override;
+
+    gl::Error drawElements(GLenum mode,
+                           GLsizei count,
+                           GLenum type,
+                           const GLvoid *indices,
+                           const gl::IndexRange &indexRange) override;
+    gl::Error drawElementsInstanced(GLenum mode,
+                                    GLsizei count,
+                                    GLenum type,
+                                    const GLvoid *indices,
+                                    GLsizei instances,
+                                    const gl::IndexRange &indexRange) override;
+    gl::Error drawRangeElements(GLenum mode,
+                                GLuint start,
+                                GLuint end,
+                                GLsizei count,
+                                GLenum type,
+                                const GLvoid *indices,
+                                const gl::IndexRange &indexRange) override;
+
+    // CHROMIUM_path_rendering path drawing methods.
+
+    // Shader creation
+    CompilerImpl *createCompiler() override;
+    ShaderImpl *createShader(const gl::ShaderState &data) override;
+    ProgramImpl *createProgram(const gl::ProgramState &data) override;
+
+    // Framebuffer creation
+    FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override;
+
+    // Texture creation
+    TextureImpl *createTexture(const gl::TextureState &state) override;
+
+    // Renderbuffer creation
+    RenderbufferImpl *createRenderbuffer() override;
+
+    // Buffer creation
+    BufferImpl *createBuffer() override;
+
+    // Vertex Array creation
+    VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;
+
+    // Query and Fence creation
+    QueryImpl *createQuery(GLenum type) override;
+    FenceNVImpl *createFenceNV() override;
+    FenceSyncImpl *createFenceSync() override;
+
+    // Transform Feedback creation
+    TransformFeedbackImpl *createTransformFeedback(
+        const gl::TransformFeedbackState &state) override;
+
+    // Sampler object creation
+    SamplerImpl *createSampler() override;
+
+    std::vector<PathImpl *> createPaths(GLsizei range) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_CONTEXTNULL_H_

src/libANGLE/renderer/null/DeviceNULL.cpp

+//
+// Copyright 2016 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.
+//
+// DeviceNULL.cpp:
+//    Implements the class methods for DeviceNULL.
+//
+
+#include "libANGLE/renderer/null/DeviceNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+DeviceNULL::DeviceNULL() : DeviceImpl()
+{
+}
+
+DeviceNULL::~DeviceNULL()
+{
+}
+
+egl::Error DeviceNULL::getDevice(void **outValue)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+EGLint DeviceNULL::getType()
+{
+    UNIMPLEMENTED();
+    return EGLint();
+}
+
+void DeviceNULL::generateExtensions(egl::DeviceExtensions *outExtensions) const
+{
+    UNIMPLEMENTED();
+}
+
+bool DeviceNULL::deviceExternallySourced()
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/DeviceNULL.h

+//
+// Copyright 2016 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.
+//
+// DeviceNULL.h:
+//    Defines the class interface for DeviceNULL, implementing DeviceImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_DEVICENULL_H_
+#define LIBANGLE_RENDERER_NULL_DEVICENULL_H_
+
+#include "libANGLE/renderer/DeviceImpl.h"
+
+namespace rx
+{
+
+class DeviceNULL : public DeviceImpl
+{
+  public:
+    DeviceNULL();
+    ~DeviceNULL() override;
+
+    egl::Error getDevice(void **outValue) override;
+    EGLint getType() override;
+    void generateExtensions(egl::DeviceExtensions *outExtensions) const override;
+    bool deviceExternallySourced() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_DEVICENULL_H_

src/libANGLE/renderer/null/DisplayNULL.cpp

+//
+// Copyright 2016 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.
+//
+// DisplayNULL.cpp:
+//    Implements the class methods for DisplayNULL.
+//
+
+#include "libANGLE/renderer/null/DisplayNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+DisplayNULL::DisplayNULL() : DisplayImpl()
+{
+}
+
+DisplayNULL::~DisplayNULL()
+{
+}
+
+egl::Error DisplayNULL::initialize(egl::Display *display)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+void DisplayNULL::terminate()
+{
+    UNIMPLEMENTED();
+}
+
+egl::Error DisplayNULL::makeCurrent(egl::Surface *drawSurface,
+                                    egl::Surface *readSurface,
+                                    gl::Context *context)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::ConfigSet DisplayNULL::generateConfigs()
+{
+    UNIMPLEMENTED();
+    return egl::ConfigSet();
+}
+
+bool DisplayNULL::testDeviceLost()
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+egl::Error DisplayNULL::restoreLostDevice()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+bool DisplayNULL::isValidNativeWindow(EGLNativeWindowType window) const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+std::string DisplayNULL::getVendorString() const
+{
+    UNIMPLEMENTED();
+    return std::string();
+}
+
+egl::Error DisplayNULL::getDevice(DeviceImpl **device)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error DisplayNULL::waitClient() const
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error DisplayNULL::waitNative(EGLint engine,
+                                   egl::Surface *drawSurface,
+                                   egl::Surface *readSurface) const
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+gl::Version DisplayNULL::getMaxSupportedESVersion() const
+{
+    UNIMPLEMENTED();
+    return gl::Version();
+}
+
+SurfaceImpl *DisplayNULL::createWindowSurface(const egl::SurfaceState &state,
+                                              const egl::Config *configuration,
+                                              EGLNativeWindowType window,
+                                              const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<SurfaceImpl *>(0);
+}
+
+SurfaceImpl *DisplayNULL::createPbufferSurface(const egl::SurfaceState &state,
+                                               const egl::Config *configuration,
+                                               const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<SurfaceImpl *>(0);
+}
+
+SurfaceImpl *DisplayNULL::createPbufferFromClientBuffer(const egl::SurfaceState &state,
+                                                        const egl::Config *configuration,
+                                                        EGLClientBuffer shareHandle,
+                                                        const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<SurfaceImpl *>(0);
+}
+
+SurfaceImpl *DisplayNULL::createPixmapSurface(const egl::SurfaceState &state,
+                                              const egl::Config *configuration,
+                                              NativePixmapType nativePixmap,
+                                              const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<SurfaceImpl *>(0);
+}
+
+ImageImpl *DisplayNULL::createImage(EGLenum target,
+                                    egl::ImageSibling *buffer,
+                                    const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<ImageImpl *>(0);
+}
+
+ContextImpl *DisplayNULL::createContext(const gl::ContextState &state)
+{
+    UNIMPLEMENTED();
+    return static_cast<ContextImpl *>(0);
+}
+
+StreamProducerImpl *DisplayNULL::createStreamProducerD3DTextureNV12(
+    egl::Stream::ConsumerType consumerType,
+    const egl::AttributeMap &attribs)
+{
+    UNIMPLEMENTED();
+    return static_cast<StreamProducerImpl *>(0);
+}
+
+void DisplayNULL::generateExtensions(egl::DisplayExtensions *outExtensions) const
+{
+    UNIMPLEMENTED();
+}
+
+void DisplayNULL::generateCaps(egl::Caps *outCaps) const
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/DisplayNULL.h

+//
+// Copyright 2016 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.
+//
+// DisplayNULL.h:
+//    Defines the class interface for DisplayNULL, implementing DisplayImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_
+#define LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_
+
+#include "libANGLE/renderer/DisplayImpl.h"
+
+namespace rx
+{
+
+class DisplayNULL : public DisplayImpl
+{
+  public:
+    DisplayNULL();
+    ~DisplayNULL() override;
+
+    egl::Error initialize(egl::Display *display) override;
+    void terminate() override;
+
+    egl::Error makeCurrent(egl::Surface *drawSurface,
+                           egl::Surface *readSurface,
+                           gl::Context *context) override;
+
+    egl::ConfigSet generateConfigs() override;
+
+    bool testDeviceLost() override;
+    egl::Error restoreLostDevice() override;
+
+    bool isValidNativeWindow(EGLNativeWindowType window) const override;
+
+    std::string getVendorString() const override;
+
+    egl::Error getDevice(DeviceImpl **device) override;
+
+    egl::Error waitClient() const override;
+    egl::Error waitNative(EGLint engine,
+                          egl::Surface *drawSurface,
+                          egl::Surface *readSurface) const override;
+    gl::Version getMaxSupportedESVersion() const override;
+
+    SurfaceImpl *createWindowSurface(const egl::SurfaceState &state,
+                                     const egl::Config *configuration,
+                                     EGLNativeWindowType window,
+                                     const egl::AttributeMap &attribs) override;
+    SurfaceImpl *createPbufferSurface(const egl::SurfaceState &state,
+                                      const egl::Config *configuration,
+                                      const egl::AttributeMap &attribs) override;
+    SurfaceImpl *createPbufferFromClientBuffer(const egl::SurfaceState &state,
+                                               const egl::Config *configuration,
+                                               EGLClientBuffer shareHandle,
+                                               const egl::AttributeMap &attribs) override;
+    SurfaceImpl *createPixmapSurface(const egl::SurfaceState &state,
+                                     const egl::Config *configuration,
+                                     NativePixmapType nativePixmap,
+                                     const egl::AttributeMap &attribs) override;
+
+    ImageImpl *createImage(EGLenum target,
+                           egl::ImageSibling *buffer,
+                           const egl::AttributeMap &attribs) override;
+
+    ContextImpl *createContext(const gl::ContextState &state) override;
+
+    StreamProducerImpl *createStreamProducerD3DTextureNV12(
+        egl::Stream::ConsumerType consumerType,
+        const egl::AttributeMap &attribs) override;
+
+  private:
+    void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
+    void generateCaps(egl::Caps *outCaps) const override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_

src/libANGLE/renderer/null/FenceNVNULL.cpp

+//
+// Copyright 2016 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.
+//
+// FenceNVNULL.cpp:
+//    Implements the class methods for FenceNVNULL.
+//
+
+#include "libANGLE/renderer/null/FenceNVNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FenceNVNULL::FenceNVNULL() : FenceNVImpl()
+{
+}
+
+FenceNVNULL::~FenceNVNULL()
+{
+}
+
+gl::Error FenceNVNULL::set(GLenum condition)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceNVNULL::test(GLboolean *outFinished)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceNVNULL::finish()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/FenceNVNULL.h

+//
+// Copyright 2016 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.
+//
+// FenceNVNULL.h:
+//    Defines the class interface for FenceNVNULL, implementing FenceNVImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_FENCENVNULL_H_
+#define LIBANGLE_RENDERER_NULL_FENCENVNULL_H_
+
+#include "libANGLE/renderer/FenceNVImpl.h"
+
+namespace rx
+{
+
+class FenceNVNULL : public FenceNVImpl
+{
+  public:
+    FenceNVNULL();
+    ~FenceNVNULL() override;
+
+    gl::Error set(GLenum condition) override;
+    gl::Error test(GLboolean *outFinished) override;
+    gl::Error finish() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_FENCENVNULL_H_

src/libANGLE/renderer/null/FenceSyncNULL.cpp

+//
+// Copyright 2016 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.
+//
+// FenceSyncNULL.cpp:
+//    Implements the class methods for FenceSyncNULL.
+//
+
+#include "libANGLE/renderer/null/FenceSyncNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FenceSyncNULL::FenceSyncNULL() : FenceSyncImpl()
+{
+}
+
+FenceSyncNULL::~FenceSyncNULL()
+{
+}
+
+gl::Error FenceSyncNULL::set(GLenum condition, GLbitfield flags)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncNULL::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncNULL::serverWait(GLbitfield flags, GLuint64 timeout)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FenceSyncNULL::getStatus(GLint *outResult)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/FenceSyncNULL.h

+//
+// Copyright 2016 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.
+//
+// FenceSyncNULL.h:
+//    Defines the class interface for FenceSyncNULL, implementing FenceSyncImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_FENCESYNCNULL_H_
+#define LIBANGLE_RENDERER_NULL_FENCESYNCNULL_H_
+
+#include "libANGLE/renderer/FenceSyncImpl.h"
+
+namespace rx
+{
+
+class FenceSyncNULL : public FenceSyncImpl
+{
+  public:
+    FenceSyncNULL();
+    ~FenceSyncNULL() override;
+
+    gl::Error set(GLenum condition, GLbitfield flags) 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;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_FENCESYNCNULL_H_

src/libANGLE/renderer/null/FramebufferNULL.cpp

+//
+// Copyright 2016 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.
+//
+// FramebufferNULL.cpp:
+//    Implements the class methods for FramebufferNULL.
+//
+
+#include "libANGLE/renderer/null/FramebufferNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+FramebufferNULL::FramebufferNULL(const gl::FramebufferState &state) : FramebufferImpl(state)
+{
+}
+
+FramebufferNULL::~FramebufferNULL()
+{
+}
+
+gl::Error FramebufferNULL::discard(size_t count, const GLenum *attachments)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::invalidate(size_t count, const GLenum *attachments)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::invalidateSub(size_t count,
+                                         const GLenum *attachments,
+                                         const gl::Rectangle &area)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::clear(ContextImpl *context, GLbitfield mask)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::clearBufferfv(ContextImpl *context,
+                                         GLenum buffer,
+                                         GLint drawbuffer,
+                                         const GLfloat *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::clearBufferuiv(ContextImpl *context,
+                                          GLenum buffer,
+                                          GLint drawbuffer,
+                                          const GLuint *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::clearBufferiv(ContextImpl *context,
+                                         GLenum buffer,
+                                         GLint drawbuffer,
+                                         const GLint *values)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::clearBufferfi(ContextImpl *context,
+                                         GLenum buffer,
+                                         GLint drawbuffer,
+                                         GLfloat depth,
+                                         GLint stencil)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+GLenum FramebufferNULL::getImplementationColorReadFormat() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+GLenum FramebufferNULL::getImplementationColorReadType() const
+{
+    UNIMPLEMENTED();
+    return GLenum();
+}
+
+gl::Error FramebufferNULL::readPixels(ContextImpl *context,
+                                      const gl::Rectangle &area,
+                                      GLenum format,
+                                      GLenum type,
+                                      GLvoid *pixels) const
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error FramebufferNULL::blit(ContextImpl *context,
+                                const gl::Rectangle &sourceArea,
+                                const gl::Rectangle &destArea,
+                                GLbitfield mask,
+                                GLenum filter)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+bool FramebufferNULL::checkStatus() const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+void FramebufferNULL::syncState(const gl::Framebuffer::DirtyBits &dirtyBits)
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/FramebufferNULL.h

+//
+// Copyright 2016 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.
+//
+// FramebufferNULL.h:
+//    Defines the class interface for FramebufferNULL, implementing FramebufferImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_FRAMEBUFFERNULL_H_
+#define LIBANGLE_RENDERER_NULL_FRAMEBUFFERNULL_H_
+
+#include "libANGLE/renderer/FramebufferImpl.h"
+
+namespace rx
+{
+
+class FramebufferNULL : public FramebufferImpl
+{
+  public:
+    FramebufferNULL(const gl::FramebufferState &state);
+    ~FramebufferNULL() override;
+
+    gl::Error discard(size_t count, const GLenum *attachments) 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(ContextImpl *context, GLbitfield mask) override;
+    gl::Error clearBufferfv(ContextImpl *context,
+                            GLenum buffer,
+                            GLint drawbuffer,
+                            const GLfloat *values) override;
+    gl::Error clearBufferuiv(ContextImpl *context,
+                             GLenum buffer,
+                             GLint drawbuffer,
+                             const GLuint *values) override;
+    gl::Error clearBufferiv(ContextImpl *context,
+                            GLenum buffer,
+                            GLint drawbuffer,
+                            const GLint *values) override;
+    gl::Error clearBufferfi(ContextImpl *context,
+                            GLenum buffer,
+                            GLint drawbuffer,
+                            GLfloat depth,
+                            GLint stencil) override;
+
+    GLenum getImplementationColorReadFormat() const override;
+    GLenum getImplementationColorReadType() const override;
+    gl::Error readPixels(ContextImpl *context,
+                         const gl::Rectangle &area,
+                         GLenum format,
+                         GLenum type,
+                         GLvoid *pixels) const override;
+
+    gl::Error blit(ContextImpl *context,
+                   const gl::Rectangle &sourceArea,
+                   const gl::Rectangle &destArea,
+                   GLbitfield mask,
+                   GLenum filter) override;
+
+    bool checkStatus() const override;
+
+    void syncState(const gl::Framebuffer::DirtyBits &dirtyBits) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_FRAMEBUFFERNULL_H_

src/libANGLE/renderer/null/ImageNULL.cpp

+//
+// Copyright 2016 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.
+//
+// ImageNULL.cpp:
+//    Implements the class methods for ImageNULL.
+//
+
+#include "libANGLE/renderer/null/ImageNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ImageNULL::ImageNULL() : ImageImpl()
+{
+}
+
+ImageNULL::~ImageNULL()
+{
+}
+
+egl::Error ImageNULL::initialize()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+gl::Error ImageNULL::orphan(egl::ImageSibling *sibling)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/ImageNULL.h

+//
+// Copyright 2016 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.
+//
+// ImageNULL.h:
+//    Defines the class interface for ImageNULL, implementing ImageImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_IMAGENULL_H_
+#define LIBANGLE_RENDERER_NULL_IMAGENULL_H_
+
+#include "libANGLE/renderer/ImageImpl.h"
+
+namespace rx
+{
+
+class ImageNULL : public ImageImpl
+{
+  public:
+    ImageNULL();
+    ~ImageNULL() override;
+    egl::Error initialize() override;
+
+    gl::Error orphan(egl::ImageSibling *sibling) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_IMAGENULL_H_

src/libANGLE/renderer/null/PathNULL.cpp

+//
+// Copyright 2016 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.
+//
+// PathNULL.cpp:
+//    Implements the class methods for PathNULL.
+//
+
+#include "libANGLE/renderer/null/PathNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+PathNULL::PathNULL() : PathImpl()
+{
+}
+
+PathNULL::~PathNULL()
+{
+}
+
+gl::Error PathNULL::setCommands(GLsizei numCommands,
+                                const GLubyte *commands,
+                                GLsizei numCoords,
+                                GLenum coordType,
+                                const void *coords)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+void PathNULL::setPathParameter(GLenum pname, GLfloat value)
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/PathNULL.h

+//
+// Copyright 2016 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.
+//
+// PathNULL.h:
+//    Defines the class interface for PathNULL, implementing PathImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_PATHNULL_H_
+#define LIBANGLE_RENDERER_NULL_PATHNULL_H_
+
+#include "libANGLE/renderer/PathImpl.h"
+
+namespace rx
+{
+
+class PathNULL : public PathImpl
+{
+  public:
+    PathNULL();
+    ~PathNULL() override;
+
+    gl::Error setCommands(GLsizei numCommands,
+                          const GLubyte *commands,
+                          GLsizei numCoords,
+                          GLenum coordType,
+                          const void *coords) override;
+
+    void setPathParameter(GLenum pname, GLfloat value) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_PATHNULL_H_

src/libANGLE/renderer/null/ProgramNULL.cpp

+//
+// Copyright 2016 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.
+//
+// ProgramNULL.cpp:
+//    Implements the class methods for ProgramNULL.
+//
+
+#include "libANGLE/renderer/null/ProgramNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ProgramNULL::ProgramNULL(const gl::ProgramState &state) : ProgramImpl(state)
+{
+}
+
+ProgramNULL::~ProgramNULL()
+{
+}
+
+LinkResult ProgramNULL::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
+{
+    UNIMPLEMENTED();
+    return LinkResult(false, gl::Error(GL_INVALID_OPERATION));
+}
+
+gl::Error ProgramNULL::save(gl::BinaryOutputStream *stream)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+void ProgramNULL::setBinaryRetrievableHint(bool retrievable)
+{
+    UNIMPLEMENTED();
+}
+
+LinkResult ProgramNULL::link(const gl::ContextState &data, gl::InfoLog &infoLog)
+{
+    UNIMPLEMENTED();
+    return LinkResult(false, gl::Error(GL_INVALID_OPERATION));
+}
+
+GLboolean ProgramNULL::validate(const gl::Caps &caps, gl::InfoLog *infoLog)
+{
+    UNIMPLEMENTED();
+    return GLboolean();
+}
+
+void ProgramNULL::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform1iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform2iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform3iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform4iv(GLint location, GLsizei count, const GLint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix2fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix3fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix4fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix2x3fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix3x2fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix2x4fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix4x2fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix3x4fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformMatrix4x3fv(GLint location,
+                                        GLsizei count,
+                                        GLboolean transpose,
+                                        const GLfloat *value)
+{
+    UNIMPLEMENTED();
+}
+
+void ProgramNULL::setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+{
+    UNIMPLEMENTED();
+}
+
+bool ProgramNULL::getUniformBlockSize(const std::string &blockName, size_t *sizeOut) const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+bool ProgramNULL::getUniformBlockMemberInfo(const std::string &memberUniformName,
+                                            sh::BlockMemberInfo *memberInfoOut) const
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+void ProgramNULL::setPathFragmentInputGen(const std::string &inputName,
+                                          GLenum genMode,
+                                          GLint components,
+                                          const GLfloat *coeffs)
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/ProgramNULL.h

+//
+// Copyright 2016 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.
+//
+// ProgramNULL.h:
+//    Defines the class interface for ProgramNULL, implementing ProgramImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_PROGRAMNULL_H_
+#define LIBANGLE_RENDERER_NULL_PROGRAMNULL_H_
+
+#include "libANGLE/renderer/ProgramImpl.h"
+
+namespace rx
+{
+
+class ProgramNULL : public ProgramImpl
+{
+  public:
+    ProgramNULL(const gl::ProgramState &state);
+    ~ProgramNULL() override;
+
+    LinkResult load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) override;
+    gl::Error save(gl::BinaryOutputStream *stream) override;
+    void setBinaryRetrievableHint(bool retrievable) override;
+
+    LinkResult link(const gl::ContextState &data, gl::InfoLog &infoLog) override;
+    GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) 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;
+
+    // TODO: synchronize in syncState when dirty bits exist.
+    void setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding) override;
+
+    // May only be called after a successful link operation.
+    // Return false for inactive blocks.
+    bool getUniformBlockSize(const std::string &blockName, size_t *sizeOut) const override;
+
+    // May only be called after a successful link operation.
+    // Returns false for inactive members.
+    bool getUniformBlockMemberInfo(const std::string &memberUniformName,
+                                   sh::BlockMemberInfo *memberInfoOut) const override;
+    // CHROMIUM_path_rendering
+    // Set parameters to control fragment shader input variable interpolation
+    void setPathFragmentInputGen(const std::string &inputName,
+                                 GLenum genMode,
+                                 GLint components,
+                                 const GLfloat *coeffs) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_PROGRAMNULL_H_

src/libANGLE/renderer/null/QueryNULL.cpp

+//
+// Copyright 2016 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.
+//
+// QueryNULL.cpp:
+//    Implements the class methods for QueryNULL.
+//
+
+#include "libANGLE/renderer/null/QueryNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+QueryNULL::QueryNULL(GLenum type) : QueryImpl(type)
+{
+}
+
+QueryNULL::~QueryNULL()
+{
+}
+
+gl::Error QueryNULL::begin()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::end()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::queryCounter()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::getResult(GLint *params)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::getResult(GLuint *params)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::getResult(GLint64 *params)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::getResult(GLuint64 *params)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error QueryNULL::isResultAvailable(bool *available)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/QueryNULL.h

+//
+// Copyright 2016 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.
+//
+// QueryNULL.h:
+//    Defines the class interface for QueryNULL, implementing QueryImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_QUERYNULL_H_
+#define LIBANGLE_RENDERER_NULL_QUERYNULL_H_
+
+#include "libANGLE/renderer/QueryImpl.h"
+
+namespace rx
+{
+
+class QueryNULL : public QueryImpl
+{
+  public:
+    QueryNULL(GLenum type);
+    ~QueryNULL() override;
+
+    gl::Error begin() override;
+    gl::Error end() override;
+    gl::Error queryCounter() override;
+    gl::Error getResult(GLint *params) override;
+    gl::Error getResult(GLuint *params) override;
+    gl::Error getResult(GLint64 *params) override;
+    gl::Error getResult(GLuint64 *params) override;
+    gl::Error isResultAvailable(bool *available) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_QUERYNULL_H_

src/libANGLE/renderer/null/RenderbufferNULL.cpp

+//
+// Copyright 2016 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.
+//
+// RenderbufferNULL.cpp:
+//    Implements the class methods for RenderbufferNULL.
+//
+
+#include "libANGLE/renderer/null/RenderbufferNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+RenderbufferNULL::RenderbufferNULL() : RenderbufferImpl()
+{
+}
+
+RenderbufferNULL::~RenderbufferNULL()
+{
+}
+
+gl::Error RenderbufferNULL::setStorage(GLenum internalformat, size_t width, size_t height)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error RenderbufferNULL::setStorageMultisample(size_t samples,
+                                                  GLenum internalformat,
+                                                  size_t width,
+                                                  size_t height)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error RenderbufferNULL::setStorageEGLImageTarget(egl::Image *image)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/RenderbufferNULL.h

+//
+// Copyright 2016 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.
+//
+// RenderbufferNULL.h:
+//    Defines the class interface for RenderbufferNULL, implementing RenderbufferImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_RENDERBUFFERNULL_H_
+#define LIBANGLE_RENDERER_NULL_RENDERBUFFERNULL_H_
+
+#include "libANGLE/renderer/RenderbufferImpl.h"
+
+namespace rx
+{
+
+class RenderbufferNULL : public RenderbufferImpl
+{
+  public:
+    RenderbufferNULL();
+    ~RenderbufferNULL() override;
+
+    gl::Error setStorage(GLenum internalformat, size_t width, size_t height) override;
+    gl::Error setStorageMultisample(size_t samples,
+                                    GLenum internalformat,
+                                    size_t width,
+                                    size_t height) override;
+    gl::Error setStorageEGLImageTarget(egl::Image *image) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_RENDERBUFFERNULL_H_

src/libANGLE/renderer/null/SamplerNULL.cpp

+//
+// Copyright 2016 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.
+//
+// SamplerNULL.cpp:
+//    Implements the class methods for SamplerNULL.
+//
+
+#include "libANGLE/renderer/null/SamplerNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+SamplerNULL::SamplerNULL() : SamplerImpl()
+{
+}
+
+SamplerNULL::~SamplerNULL()
+{
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/SamplerNULL.h

+//
+// Copyright 2016 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.
+//
+// SamplerNULL.h:
+//    Defines the class interface for SamplerNULL, implementing SamplerImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_SAMPLERNULL_H_
+#define LIBANGLE_RENDERER_NULL_SAMPLERNULL_H_
+
+#include "libANGLE/renderer/SamplerImpl.h"
+
+namespace rx
+{
+
+class SamplerNULL : public SamplerImpl
+{
+  public:
+    SamplerNULL();
+    ~SamplerNULL() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_SAMPLERNULL_H_

src/libANGLE/renderer/null/ShaderNULL.cpp

+//
+// Copyright 2016 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.
+//
+// ShaderNULL.cpp:
+//    Implements the class methods for ShaderNULL.
+//
+
+#include "libANGLE/renderer/null/ShaderNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+ShaderNULL::ShaderNULL(const gl::ShaderState &data) : ShaderImpl(data)
+{
+}
+
+ShaderNULL::~ShaderNULL()
+{
+}
+
+ShCompileOptions ShaderNULL::prepareSourceAndReturnOptions(std::stringstream *sourceStream,
+                                                           std::string *sourcePath)
+{
+    UNIMPLEMENTED();
+    return ShCompileOptions();
+}
+
+bool ShaderNULL::postTranslateCompile(gl::Compiler *compiler, std::string *infoLog)
+{
+    UNIMPLEMENTED();
+    return bool();
+}
+
+std::string ShaderNULL::getDebugInfo() const
+{
+    UNIMPLEMENTED();
+    return std::string();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/ShaderNULL.h

+//
+// Copyright 2016 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.
+//
+// ShaderNULL.h:
+//    Defines the class interface for ShaderNULL, implementing ShaderImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_SHADERNULL_H_
+#define LIBANGLE_RENDERER_NULL_SHADERNULL_H_
+
+#include "libANGLE/renderer/ShaderImpl.h"
+
+namespace rx
+{
+
+class ShaderNULL : public ShaderImpl
+{
+  public:
+    ShaderNULL(const gl::ShaderState &data);
+    ~ShaderNULL() override;
+
+    // Returns additional ShCompile options.
+    ShCompileOptions prepareSourceAndReturnOptions(std::stringstream *sourceStream,
+                                                   std::string *sourcePath) override;
+    // Returns success for compiling on the driver. Returns success.
+    bool postTranslateCompile(gl::Compiler *compiler, std::string *infoLog) override;
+
+    std::string getDebugInfo() const override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_SHADERNULL_H_

src/libANGLE/renderer/null/SurfaceNULL.cpp

+//
+// Copyright 2016 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.
+//
+// SurfaceNULL.cpp:
+//    Implements the class methods for SurfaceNULL.
+//
+
+#include "libANGLE/renderer/null/SurfaceNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+SurfaceNULL::SurfaceNULL(const egl::SurfaceState &surfaceState) : SurfaceImpl(surfaceState)
+{
+}
+
+SurfaceNULL::~SurfaceNULL()
+{
+}
+
+egl::Error SurfaceNULL::initialize()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+FramebufferImpl *SurfaceNULL::createDefaultFramebuffer(const gl::FramebufferState &state)
+{
+    UNIMPLEMENTED();
+    return static_cast<FramebufferImpl *>(0);
+}
+
+egl::Error SurfaceNULL::swap()
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error SurfaceNULL::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error SurfaceNULL::querySurfacePointerANGLE(EGLint attribute, void **value)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error SurfaceNULL::bindTexImage(gl::Texture *texture, EGLint buffer)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+egl::Error SurfaceNULL::releaseTexImage(EGLint buffer)
+{
+    UNIMPLEMENTED();
+    return egl::Error(EGL_BAD_ACCESS);
+}
+
+void SurfaceNULL::setSwapInterval(EGLint interval)
+{
+    UNIMPLEMENTED();
+}
+
+EGLint SurfaceNULL::getWidth() const
+{
+    UNIMPLEMENTED();
+    return EGLint();
+}
+
+EGLint SurfaceNULL::getHeight() const
+{
+    UNIMPLEMENTED();
+    return EGLint();
+}
+
+EGLint SurfaceNULL::isPostSubBufferSupported() const
+{
+    UNIMPLEMENTED();
+    return EGLint();
+}
+
+EGLint SurfaceNULL::getSwapBehavior() const
+{
+    UNIMPLEMENTED();
+    return EGLint();
+}
+
+gl::Error SurfaceNULL::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+                                                 FramebufferAttachmentRenderTarget **rtOut)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/SurfaceNULL.h

+//
+// Copyright 2016 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.
+//
+// SurfaceNULL.h:
+//    Defines the class interface for SurfaceNULL, implementing SurfaceImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_SURFACENULL_H_
+#define LIBANGLE_RENDERER_NULL_SURFACENULL_H_
+
+#include "libANGLE/renderer/SurfaceImpl.h"
+
+namespace rx
+{
+
+class SurfaceNULL : public SurfaceImpl
+{
+  public:
+    SurfaceNULL(const egl::SurfaceState &surfaceState);
+    ~SurfaceNULL() override;
+
+    egl::Error initialize() override;
+    FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) 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(gl::Texture *texture, EGLint buffer) override;
+    egl::Error releaseTexImage(EGLint buffer) override;
+    void setSwapInterval(EGLint interval) override;
+
+    // width and height can change with client window resizing
+    EGLint getWidth() const override;
+    EGLint getHeight() const override;
+
+    EGLint isPostSubBufferSupported() const override;
+    EGLint getSwapBehavior() const override;
+
+    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+                                        FramebufferAttachmentRenderTarget **rtOut) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_SURFACENULL_H_

src/libANGLE/renderer/null/TextureNULL.cpp

+//
+// Copyright 2016 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.
+//
+// TextureNULL.cpp:
+//    Implements the class methods for TextureNULL.
+//
+
+#include "libANGLE/renderer/null/TextureNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+TextureNULL::TextureNULL(const gl::TextureState &state) : TextureImpl(state)
+{
+}
+
+TextureNULL::~TextureNULL()
+{
+}
+
+gl::Error TextureNULL::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 TextureNULL::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 TextureNULL::setCompressedImage(GLenum target,
+                                          size_t level,
+                                          GLenum internalFormat,
+                                          const gl::Extents &size,
+                                          const gl::PixelUnpackState &unpack,
+                                          size_t imageSize,
+                                          const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureNULL::setCompressedSubImage(GLenum target,
+                                             size_t level,
+                                             const gl::Box &area,
+                                             GLenum format,
+                                             const gl::PixelUnpackState &unpack,
+                                             size_t imageSize,
+                                             const uint8_t *pixels)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureNULL::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 TextureNULL::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 TextureNULL::setStorage(GLenum target,
+                                  size_t levels,
+                                  GLenum internalFormat,
+                                  const gl::Extents &size)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureNULL::setEGLImageTarget(GLenum target, egl::Image *image)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureNULL::setImageExternal(GLenum target,
+                                        egl::Stream *stream,
+                                        const egl::Stream::GLTextureDescription &desc)
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+gl::Error TextureNULL::generateMipmap()
+{
+    UNIMPLEMENTED();
+    return gl::Error(GL_INVALID_OPERATION);
+}
+
+void TextureNULL::setBaseLevel(GLuint baseLevel)
+{
+    UNIMPLEMENTED();
+}
+
+void TextureNULL::bindTexImage(egl::Surface *surface)
+{
+    UNIMPLEMENTED();
+}
+
+void TextureNULL::releaseTexImage()
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/TextureNULL.h

+//
+// Copyright 2016 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.
+//
+// TextureNULL.h:
+//    Defines the class interface for TextureNULL, implementing TextureImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_TEXTURENULL_H_
+#define LIBANGLE_RENDERER_NULL_TEXTURENULL_H_
+
+#include "libANGLE/renderer/TextureImpl.h"
+
+namespace rx
+{
+
+class TextureNULL : public TextureImpl
+{
+  public:
+    TextureNULL(const gl::TextureState &state);
+    ~TextureNULL() 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,
+                                 size_t imageSize,
+                                 const uint8_t *pixels) override;
+    gl::Error setCompressedSubImage(GLenum target,
+                                    size_t level,
+                                    const gl::Box &area,
+                                    GLenum format,
+                                    const gl::PixelUnpackState &unpack,
+                                    size_t imageSize,
+                                    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 setEGLImageTarget(GLenum target, egl::Image *image) override;
+
+    gl::Error setImageExternal(GLenum target,
+                               egl::Stream *stream,
+                               const egl::Stream::GLTextureDescription &desc) override;
+
+    gl::Error generateMipmap() override;
+
+    void setBaseLevel(GLuint baseLevel) override;
+
+    void bindTexImage(egl::Surface *surface) override;
+    void releaseTexImage() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_TEXTURENULL_H_

src/libANGLE/renderer/null/TransformFeedbackNULL.cpp

+//
+// Copyright 2016 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.
+//
+// TransformFeedbackNULL.cpp:
+//    Implements the class methods for TransformFeedbackNULL.
+//
+
+#include "libANGLE/renderer/null/TransformFeedbackNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+TransformFeedbackNULL::TransformFeedbackNULL(const gl::TransformFeedbackState &state)
+    : TransformFeedbackImpl(state)
+{
+}
+
+TransformFeedbackNULL::~TransformFeedbackNULL()
+{
+}
+
+void TransformFeedbackNULL::begin(GLenum primitiveMode)
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackNULL::end()
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackNULL::pause()
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackNULL::resume()
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackNULL::bindGenericBuffer(const BindingPointer<gl::Buffer> &binding)
+{
+    UNIMPLEMENTED();
+}
+
+void TransformFeedbackNULL::bindIndexedBuffer(size_t index,
+                                              const OffsetBindingPointer<gl::Buffer> &binding)
+{
+    UNIMPLEMENTED();
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/TransformFeedbackNULL.h

+//
+// Copyright 2016 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.
+//
+// TransformFeedbackNULL.h:
+//    Defines the class interface for TransformFeedbackNULL, implementing TransformFeedbackImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_TRANSFORMFEEDBACKNULL_H_
+#define LIBANGLE_RENDERER_NULL_TRANSFORMFEEDBACKNULL_H_
+
+#include "libANGLE/renderer/TransformFeedbackImpl.h"
+
+namespace rx
+{
+
+class TransformFeedbackNULL : public TransformFeedbackImpl
+{
+  public:
+    TransformFeedbackNULL(const gl::TransformFeedbackState &state);
+    ~TransformFeedbackNULL() override;
+
+    void begin(GLenum primitiveMode) override;
+    void end() override;
+    void pause() override;
+    void resume() override;
+
+    void bindGenericBuffer(const BindingPointer<gl::Buffer> &binding) override;
+    void bindIndexedBuffer(size_t index, const OffsetBindingPointer<gl::Buffer> &binding) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_TRANSFORMFEEDBACKNULL_H_

src/libANGLE/renderer/null/VertexArrayNULL.cpp

+//
+// Copyright 2016 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.
+//
+// VertexArrayNULL.cpp:
+//    Implements the class methods for VertexArrayNULL.
+//
+
+#include "libANGLE/renderer/null/VertexArrayNULL.h"
+
+#include "common/debug.h"
+
+namespace rx
+{
+
+VertexArrayNULL::VertexArrayNULL(const gl::VertexArrayState &data) : VertexArrayImpl(data)
+{
+}
+
+VertexArrayNULL::~VertexArrayNULL()
+{
+}
+
+}  // namespace rx

src/libANGLE/renderer/null/VertexArrayNULL.h

+//
+// Copyright 2016 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.
+//
+// VertexArrayNULL.h:
+//    Defines the class interface for VertexArrayNULL, implementing VertexArrayImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_NULL_VERTEXARRAYNULL_H_
+#define LIBANGLE_RENDERER_NULL_VERTEXARRAYNULL_H_
+
+#include "libANGLE/renderer/VertexArrayImpl.h"
+
+namespace rx
+{
+
+class VertexArrayNULL : public VertexArrayImpl
+{
+  public:
+    VertexArrayNULL(const gl::VertexArrayState &data);
+    ~VertexArrayNULL() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_NULL_VERTEXARRAYNULL_H_

src/libGLESv2.gypi

@@ -617,6 +617,47 @@
             'libANGLE/renderer/vulkan/VertexArrayVk.cpp',
             'libANGLE/renderer/vulkan/VertexArrayVk.h',
         ],
+        'libangle_null_sources':
+        [
+            'libANGLE/renderer/null/BufferNULL.cpp',
+            'libANGLE/renderer/null/BufferNULL.h',
+            'libANGLE/renderer/null/CompilerNULL.cpp',
+            'libANGLE/renderer/null/CompilerNULL.h',
+            'libANGLE/renderer/null/ContextNULL.cpp',
+            'libANGLE/renderer/null/ContextNULL.h',
+            'libANGLE/renderer/null/DeviceNULL.cpp',
+            'libANGLE/renderer/null/DeviceNULL.h',
+            'libANGLE/renderer/null/DisplayNULL.cpp',
+            'libANGLE/renderer/null/DisplayNULL.h',
+            'libANGLE/renderer/null/FenceNVNULL.cpp',
+            'libANGLE/renderer/null/FenceNVNULL.h',
+            'libANGLE/renderer/null/FenceSyncNULL.cpp',
+            'libANGLE/renderer/null/FenceSyncNULL.h',
+            'libANGLE/renderer/null/FramebufferNULL.cpp',
+            'libANGLE/renderer/null/FramebufferNULL.h',
+            'libANGLE/renderer/null/ImageNULL.cpp',
+            'libANGLE/renderer/null/ImageNULL.h',
+            'libANGLE/renderer/null/PathNULL.cpp',
+            'libANGLE/renderer/null/PathNULL.h',
+            'libANGLE/renderer/null/ProgramNULL.cpp',
+            'libANGLE/renderer/null/ProgramNULL.h',
+            'libANGLE/renderer/null/QueryNULL.cpp',
+            'libANGLE/renderer/null/QueryNULL.h',
+            'libANGLE/renderer/null/RenderbufferNULL.cpp',
+            'libANGLE/renderer/null/RenderbufferNULL.h',
+            'libANGLE/renderer/null/SamplerNULL.cpp',
+            'libANGLE/renderer/null/SamplerNULL.h',
+            'libANGLE/renderer/null/ShaderNULL.cpp',
+            'libANGLE/renderer/null/ShaderNULL.h',
+            'libANGLE/renderer/null/SurfaceNULL.cpp',
+            'libANGLE/renderer/null/SurfaceNULL.h',
+            'libANGLE/renderer/null/TextureNULL.cpp',
+            'libANGLE/renderer/null/TextureNULL.h',
+            'libANGLE/renderer/null/TransformFeedbackNULL.cpp',
+            'libANGLE/renderer/null/TransformFeedbackNULL.h',
+            'libANGLE/renderer/null/VertexArrayNULL.cpp',
+            'libANGLE/renderer/null/VertexArrayNULL.h',
+        ],
         'libglesv2_sources':
         [
             'common/angleutils.h',
@@ -961,6 +1002,17 @@
                         'ANGLE_ENABLE_VULKAN',
                     ],
                 }],
+                ['angle_enable_null==1',
+                {
+                    'sources':
+                    [
+                        '<@(libangle_null_sources)',
+                    ],
+                    'defines':
+                    [
+                        'ANGLE_ENABLE_NULL',
+                    ],
+                }],
                 ['angle_build_winrt==0 and OS=="win"',
                 {
                     'dependencies':