Remove CompilerImpl and merge code to gl::Compiler.

src/libANGLE/Compiler.cpp

@@ -7,32 +7,128 @@
 // Compiler.cpp: implements the gl::Compiler class.
 
 #include "libANGLE/Compiler.h"
-#include "libANGLE/renderer/CompilerImpl.h"
 
 #include "common/debug.h"
+#include "libANGLE/Data.h"
+#include "libANGLE/renderer/CompilerImpl.h"
+#include "libANGLE/renderer/ImplFactory.h"
 
 namespace gl
 {
 
-Compiler::Compiler(rx::CompilerImpl *impl)
-    : mCompiler(impl)
+namespace
+{
+
+// Global count of active shader compiler handles. Needed to know when to call ShInitialize and
+// ShFinalize.
+size_t activeCompilerHandles = 0;
+
+}  // anonymous namespace
+
+Compiler::Compiler(rx::ImplFactory *implFactory, const gl::Data &data)
+    : mImplementation(implFactory->createCompiler()),
+      mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
+      mOutputType(mImplementation->getTranslatorOutputType()),
+      mResources(),
+      mFragmentCompiler(nullptr),
+      mVertexCompiler(nullptr)
 {
-    ASSERT(mCompiler);
+    ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
+
+    const gl::Caps &caps             = *data.caps;
+    const gl::Extensions &extensions = *data.extensions;
+
+    ShInitBuiltInResources(&mResources);
+    mResources.MaxVertexAttribs             = caps.maxVertexAttributes;
+    mResources.MaxVertexUniformVectors      = caps.maxVertexUniformVectors;
+    mResources.MaxVaryingVectors            = caps.maxVaryingVectors;
+    mResources.MaxVertexTextureImageUnits   = caps.maxVertexTextureImageUnits;
+    mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
+    mResources.MaxTextureImageUnits         = caps.maxTextureImageUnits;
+    mResources.MaxFragmentUniformVectors    = caps.maxFragmentUniformVectors;
+    mResources.MaxDrawBuffers               = caps.maxDrawBuffers;
+    mResources.OES_standard_derivatives     = extensions.standardDerivatives;
+    mResources.EXT_draw_buffers             = extensions.drawBuffers;
+    mResources.EXT_shader_texture_lod       = extensions.shaderTextureLOD;
+    // TODO: disabled until the extension is actually supported.
+    mResources.OES_EGL_image_external = 0;
+    // TODO: use shader precision caps to determine if high precision is supported?
+    mResources.FragmentPrecisionHigh = 1;
+    mResources.EXT_frag_depth        = extensions.fragDepth;
+
+    // GLSL ES 3.0 constants
+    mResources.MaxVertexOutputVectors  = caps.maxVertexOutputComponents / 4;
+    mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
+    mResources.MinProgramTexelOffset   = caps.minProgramTexelOffset;
+    mResources.MaxProgramTexelOffset   = caps.maxProgramTexelOffset;
 }
 
 Compiler::~Compiler()
 {
-    SafeDelete(mCompiler);
+    release();
+    SafeDelete(mImplementation);
 }
 
 Error Compiler::release()
 {
-    return mCompiler->release();
+    if (mFragmentCompiler)
+    {
+        ShDestruct(mFragmentCompiler);
+        mFragmentCompiler = nullptr;
+
+        ASSERT(activeCompilerHandles > 0);
+        activeCompilerHandles--;
+    }
+
+    if (mVertexCompiler)
+    {
+        ShDestruct(mVertexCompiler);
+        mVertexCompiler = nullptr;
+
+        ASSERT(activeCompilerHandles > 0);
+        activeCompilerHandles--;
+    }
+
+    if (activeCompilerHandles == 0)
+    {
+        ShFinalize();
+    }
+
+    mImplementation->release();
+
+    return gl::Error(GL_NO_ERROR);
 }
 
-rx::CompilerImpl *Compiler::getImplementation()
+ShHandle Compiler::getCompilerHandle(GLenum type)
 {
-    return mCompiler;
-}
+    ShHandle *compiler = nullptr;
+    switch (type)
+    {
+        case GL_VERTEX_SHADER:
+            compiler = &mVertexCompiler;
+            break;
 
+        case GL_FRAGMENT_SHADER:
+            compiler = &mFragmentCompiler;
+            break;
+
+        default:
+            UNREACHABLE();
+            return nullptr;
+    }
+
+    if (!(*compiler))
+    {
+        if (activeCompilerHandles == 0)
+        {
+            ShInitialize();
+        }
+
+        *compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
+        activeCompilerHandles++;
+    }
+
+    return *compiler;
 }
+
+}  // namespace gl

src/libANGLE/Compiler.h

@@ -11,29 +11,39 @@
 #define LIBANGLE_COMPILER_H_
 
 #include "libANGLE/Error.h"
+#include "GLSLANG/ShaderLang.h"
 
 namespace rx
 {
 class CompilerImpl;
+class ImplFactory;
 }
 
 namespace gl
 {
+struct Data;
 
-class Compiler final
+class Compiler final : angle::NonCopyable
 {
   public:
-    explicit Compiler(rx::CompilerImpl *impl);
+    Compiler(rx::ImplFactory *implFactory, const Data &data);
     ~Compiler();
 
     Error release();
 
-    rx::CompilerImpl *getImplementation();
+    ShHandle getCompilerHandle(GLenum type);
+    ShShaderOutput getShaderOutputType() const { return mOutputType; }
 
   private:
-    rx::CompilerImpl *mCompiler;
+    rx::CompilerImpl *mImplementation;
+    ShShaderSpec mSpec;
+    ShShaderOutput mOutputType;
+    ShBuiltInResources mResources;
+
+    ShHandle mFragmentCompiler;
+    ShHandle mVertexCompiler;
 };
 
-}
+}  // namespace gl
 
 #endif // LIBANGLE_COMPILER_H_

src/libANGLE/Context.cpp

@@ -145,7 +145,7 @@ Context::Context(const egl::Config *config,
     mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT);
     mRobustAccess = robustAccess;
 
-    mCompiler = new Compiler(mRenderer->createCompiler(getData()));
+    mCompiler = new Compiler(mRenderer, getData());
 }
 
 Context::~Context()

src/libANGLE/renderer/CompilerImpl.h

@@ -8,6 +8,7 @@
 //                 for the gl::Compiler object.
 
 #include "common/angleutils.h"
+#include "GLSLANG/ShaderLang.h"
 #include "libANGLE/Error.h"
 
 #ifndef LIBANGLE_RENDERER_COMPILERIMPL_H_
@@ -23,6 +24,9 @@ class CompilerImpl : angle::NonCopyable
     virtual ~CompilerImpl() {}
 
     virtual gl::Error release() = 0;
+
+    // TODO(jmadill): Expose translator built-in resources init method.
+    virtual ShShaderOutput getTranslatorOutputType() const = 0;
 };
 
 }

src/libANGLE/renderer/ImplFactory.h

@@ -36,7 +36,7 @@ class ImplFactory : angle::NonCopyable
     virtual ~ImplFactory() {}
 
     // Shader creation
-    virtual CompilerImpl *createCompiler(const gl::Data &data) = 0;
+    virtual CompilerImpl *createCompiler() = 0;
     virtual ShaderImpl *createShader(GLenum type) = 0;
     virtual ProgramImpl *createProgram(const gl::Program::Data &data) = 0;
 

src/libANGLE/renderer/d3d/CompilerD3D.cpp

 //
-// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// 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.
 //
-
-// CompilerD3D.cpp: Implementation of the rx::CompilerD3D class.
+// CompilerGL:
+//   Implementation of the D3D compiler methods.
+//
 
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
 
-#include "libANGLE/Caps.h"
-#include "libANGLE/Data.h"
-
-#include "common/debug.h"
-
 namespace rx
 {
 
-// Global count of active shader compiler handles. Needed to know when to call ShInitialize and ShFinalize.
-static size_t activeCompilerHandles = 0;
-
-CompilerD3D::CompilerD3D(const gl::Data &data, ShShaderOutput outputType)
-    : mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
-      mOutputType(outputType),
-      mResources(),
-      mFragmentCompiler(NULL),
-      mVertexCompiler(NULL)
+namespace
 {
-    ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
-
-    const gl::Caps &caps = *data.caps;
-    const gl::Extensions &extensions = *data.extensions;
 
-    ShInitBuiltInResources(&mResources);
-    mResources.MaxVertexAttribs = caps.maxVertexAttributes;
-    mResources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
-    mResources.MaxVaryingVectors = caps.maxVaryingVectors;
-    mResources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
-    mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
-    mResources.MaxTextureImageUnits = caps.maxTextureImageUnits;
-    mResources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
-    mResources.MaxDrawBuffers = caps.maxDrawBuffers;
-    mResources.OES_standard_derivatives = extensions.standardDerivatives;
-    mResources.EXT_draw_buffers = extensions.drawBuffers;
-    mResources.EXT_shader_texture_lod = 1;
-    // resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
-    mResources.FragmentPrecisionHigh = 1;   // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
-    mResources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
-
-    // GLSL ES 3.0 constants
-    mResources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
-    mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
-    mResources.MinProgramTexelOffset = caps.minProgramTexelOffset;
-    mResources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
-}
-
-CompilerD3D::~CompilerD3D()
-{
-    release();
-}
-
-gl::Error CompilerD3D::release()
+ShShaderOutput GetShaderOutputType(RendererClass rendererClass)
 {
-    if (mFragmentCompiler)
-    {
-        ShDestruct(mFragmentCompiler);
-        mFragmentCompiler = NULL;
-
-        ASSERT(activeCompilerHandles > 0);
-        activeCompilerHandles--;
-    }
-
-    if (mVertexCompiler)
+    if (rendererClass == RENDERER_D3D11)
     {
-        ShDestruct(mVertexCompiler);
-        mVertexCompiler = NULL;
-
-        ASSERT(activeCompilerHandles > 0);
-        activeCompilerHandles--;
+        return SH_HLSL11_OUTPUT;
     }
-
-    if (activeCompilerHandles == 0)
+    else
     {
-        ShFinalize();
+        ASSERT(rendererClass == RENDERER_D3D9);
+        return SH_HLSL9_OUTPUT;
     }
-
-    return gl::Error(GL_NO_ERROR);
 }
 
-ShHandle CompilerD3D::getCompilerHandle(GLenum type)
-{
-    ShHandle *compiler = NULL;
-    switch (type)
-    {
-      case GL_VERTEX_SHADER:
-        compiler = &mVertexCompiler;
-        break;
+}  // anonymous namespace
 
-      case GL_FRAGMENT_SHADER:
-        compiler = &mFragmentCompiler;
-        break;
-
-      default:
-        UNREACHABLE();
-        return NULL;
-    }
-
-    if (!(*compiler))
-    {
-        if (activeCompilerHandles == 0)
-        {
-            ShInitialize();
-        }
-
-        *compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
-        activeCompilerHandles++;
-    }
-
-    return *compiler;
+CompilerD3D::CompilerD3D(RendererClass rendererClass)
+    : mTranslatorOutputType(GetShaderOutputType(rendererClass))
+{
 }
 
-}
+}  // namespace rx

src/libANGLE/renderer/d3d/CompilerD3D.h

@@ -10,14 +10,7 @@
 #define LIBANGLE_RENDERER_COMPILERD3D_H_
 
 #include "libANGLE/renderer/CompilerImpl.h"
-#include "libANGLE/Caps.h"
-
-#include "GLSLANG/ShaderLang.h"
-
-namespace gl
-{
-struct Data;
-}
+#include "libANGLE/renderer/d3d/RendererD3D.h"
 
 namespace rx
 {
@@ -25,20 +18,14 @@ namespace rx
 class CompilerD3D : public CompilerImpl
 {
   public:
-    CompilerD3D(const gl::Data &data, ShShaderOutput outputType);
-    virtual ~CompilerD3D();
-
-    gl::Error release() override;
+    CompilerD3D(RendererClass rendererClass);
+    ~CompilerD3D() override {}
 
-    ShHandle getCompilerHandle(GLenum type);
+    gl::Error release() override { return gl::Error(GL_NO_ERROR); }
+    ShShaderOutput getTranslatorOutputType() const override { return mTranslatorOutputType; }
 
   private:
-    ShShaderSpec mSpec;
-    ShShaderOutput mOutputType;
-    ShBuiltInResources mResources;
-
-    ShHandle mFragmentCompiler;
-    ShHandle mVertexCompiler;
+    ShShaderOutput mTranslatorOutputType;
 };
 
 }

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -19,6 +19,7 @@
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
+#include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -33,7 +34,7 @@ namespace
 // degenerate case where we are stuck hogging memory.
 const int ScratchMemoryBufferLifetime = 1000;
 
-}
+}  // anonymous namespace
 
 const uintptr_t RendererD3D::DirtyPointer = std::numeric_limits<uintptr_t>::max();
 
@@ -67,6 +68,11 @@ void RendererD3D::cleanup()
     }
 }
 
+CompilerImpl *RendererD3D::createCompiler()
+{
+    return new CompilerD3D(getRendererClass());
+}
+
 gl::Error RendererD3D::drawArrays(const gl::Data &data, GLenum mode, GLint first, GLsizei count)
 {
     return genericDrawArrays(data, mode, first, count, 0);

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -129,6 +129,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     bool isDeviceLost() const override;
     std::string getVendorString() const override;
 
+    CompilerImpl *createCompiler() override;
+
     virtual int getMinorShaderModel() const = 0;
     virtual std::string getShaderModelSuffix() const = 0;
 

src/libANGLE/renderer/d3d/ShaderD3D.cpp

@@ -6,14 +6,13 @@
 
 // ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
 
-#include "libANGLE/Shader.h"
-#include "libANGLE/Compiler.h"
-#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
-#include "libANGLE/renderer/d3d/CompilerD3D.h"
-#include "libANGLE/features.h"
 
 #include "common/utilities.h"
+#include "libANGLE/Compiler.h"
+#include "libANGLE/Shader.h"
+#include "libANGLE/features.h"
+#include "libANGLE/renderer/d3d/RendererD3D.h"
 
 // Definitions local to the translation unit
 namespace
@@ -321,8 +320,7 @@ bool ShaderD3D::compile(gl::Compiler *compiler, const std::string &source)
 {
     uncompile();
 
-    CompilerD3D *compilerD3D = GetImplAs<CompilerD3D>(compiler);
-    ShHandle compilerHandle = compilerD3D->getCompilerHandle(mShaderType);
+    ShHandle compilerHandle = compiler->getCompilerHandle(mShaderType);
 
     mCompilerOutputType = ShGetShaderOutputType(compilerHandle);
 

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -22,7 +22,6 @@
 #include "libANGLE/Surface.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/histogram_macros.h"
-#include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -3004,11 +3003,6 @@ FramebufferImpl *Renderer11::createFramebuffer(const gl::Framebuffer::Data &data
     return new Framebuffer11(data, this);
 }
 
-CompilerImpl *Renderer11::createCompiler(const gl::Data &data)
-{
-    return new CompilerD3D(data, SH_HLSL11_OUTPUT);
-}
-
 ShaderImpl *Renderer11::createShader(GLenum type)
 {
     return new ShaderD3D(type, this);

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -182,7 +182,6 @@ class Renderer11 : public RendererD3D
     FramebufferImpl *createFramebuffer(const gl::Framebuffer::Data &data) override;
 
     // Shader creation
-    virtual CompilerImpl *createCompiler(const gl::Data &data);
     virtual ShaderImpl *createShader(GLenum type);
     virtual ProgramImpl *createProgram(const gl::Program::Data &data);
 

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -21,7 +21,6 @@
 #include "libANGLE/angletypes.h"
 #include "libANGLE/features.h"
 #include "libANGLE/formatutils.h"
-#include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -2714,11 +2713,6 @@ FramebufferImpl *Renderer9::createFramebuffer(const gl::Framebuffer::Data &data)
     return new Framebuffer9(data, this);
 }
 
-CompilerImpl *Renderer9::createCompiler(const gl::Data &data)
-{
-    return new CompilerD3D(data, SH_HLSL9_OUTPUT);
-}
-
 ShaderImpl *Renderer9::createShader(GLenum type)
 {
     return new ShaderD3D(type, this);

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -169,7 +169,6 @@ class Renderer9 : public RendererD3D
     FramebufferImpl *createFramebuffer(const gl::Framebuffer::Data &data) override;
 
     // Shader creation
-    virtual CompilerImpl *createCompiler(const gl::Data &data);
     virtual ShaderImpl *createShader(GLenum type);
     virtual ProgramImpl *createProgram(const gl::Program::Data &data);
 

src/libANGLE/renderer/gl/CompilerGL.cpp

@@ -3,23 +3,21 @@
 // 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.
+// CompilerGL:
+//   Implementation of the GL compiler methods.
+//
 
 #include "libANGLE/renderer/gl/CompilerGL.h"
 
-#include "common/debug.h"
-#include "libANGLE/Caps.h"
-#include "libANGLE/Data.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 
 namespace rx
 {
 
-// Global count of active shader compiler handles. Needed to know when to call ShInitialize and ShFinalize.
-static size_t activeCompilerHandles = 0;
+namespace
+{
 
-static ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
+ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
 {
     ASSERT(functions);
 
@@ -83,105 +81,11 @@ static ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
     }
 }
 
-CompilerGL::CompilerGL(const gl::Data &data, const FunctionsGL *functions)
-    : CompilerImpl(),
-      mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
-      mOutputType(GetShaderOutputType(functions)),
-      mResources(),
-      mFragmentCompiler(nullptr),
-      mVertexCompiler(nullptr)
-{
-    ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
-
-    const gl::Caps &caps = *data.caps;
-    const gl::Extensions &extensions = *data.extensions;
-
-    ShInitBuiltInResources(&mResources);
-    mResources.MaxVertexAttribs = caps.maxVertexAttributes;
-    mResources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
-    mResources.MaxVaryingVectors = caps.maxVaryingVectors;
-    mResources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
-    mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
-    mResources.MaxTextureImageUnits = caps.maxTextureImageUnits;
-    mResources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
-    mResources.MaxDrawBuffers = caps.maxDrawBuffers;
-    mResources.OES_standard_derivatives = extensions.standardDerivatives;
-    mResources.EXT_draw_buffers = extensions.drawBuffers;
-    mResources.EXT_shader_texture_lod = extensions.shaderTextureLOD;
-    mResources.OES_EGL_image_external = 0; // TODO: disabled until the extension is actually supported.
-    mResources.FragmentPrecisionHigh = 1; // TODO: use shader precision caps to determine if high precision is supported?
-    mResources.EXT_frag_depth = extensions.fragDepth;
-
-    // GLSL ES 3.0 constants
-    mResources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
-    mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
-    mResources.MinProgramTexelOffset = caps.minProgramTexelOffset;
-    mResources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
-}
-
-CompilerGL::~CompilerGL()
-{
-    release();
-}
-
-gl::Error CompilerGL::release()
-{
-    if (mFragmentCompiler)
-    {
-        ShDestruct(mFragmentCompiler);
-        mFragmentCompiler = NULL;
-
-        ASSERT(activeCompilerHandles > 0);
-        activeCompilerHandles--;
-    }
-
-    if (mVertexCompiler)
-    {
-        ShDestruct(mVertexCompiler);
-        mVertexCompiler = NULL;
-
-        ASSERT(activeCompilerHandles > 0);
-        activeCompilerHandles--;
-    }
-
-    if (activeCompilerHandles == 0)
-    {
-        ShFinalize();
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
+}  // anonymous namespace
 
-ShHandle CompilerGL::getCompilerHandle(GLenum type)
+CompilerGL::CompilerGL(const FunctionsGL *functions)
+    : mTranslatorOutputType(GetShaderOutputType(functions))
 {
-    ShHandle *compiler = NULL;
-    switch (type)
-    {
-      case GL_VERTEX_SHADER:
-        compiler = &mVertexCompiler;
-        break;
-
-      case GL_FRAGMENT_SHADER:
-        compiler = &mFragmentCompiler;
-        break;
-
-      default:
-        UNREACHABLE();
-        return NULL;
-    }
-
-    if ((*compiler) == nullptr)
-    {
-        if (activeCompilerHandles == 0)
-        {
-            ShInitialize();
-        }
-
-        *compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
-        activeCompilerHandles++;
-    }
-
-    return *compiler;
 }
 
-}
+}  // namespace rx

src/libANGLE/renderer/gl/CompilerGL.h

@@ -11,35 +11,21 @@
 
 #include "libANGLE/renderer/CompilerImpl.h"
 
-#include "GLSLANG/ShaderLang.h"
-
-namespace gl
-{
-struct Data;
-}
-
 namespace rx
 {
-
 class FunctionsGL;
 
 class CompilerGL : public CompilerImpl
 {
   public:
-    CompilerGL(const gl::Data &data, const FunctionsGL *functions);
-    ~CompilerGL() override;
-
-    gl::Error release() override;
+    CompilerGL(const FunctionsGL *functions);
+    ~CompilerGL() override {}
 
-    ShHandle getCompilerHandle(GLenum type);
+    gl::Error release() override { return gl::Error(GL_NO_ERROR); }
+    ShShaderOutput getTranslatorOutputType() const { return mTranslatorOutputType; }
 
   private:
-    ShShaderSpec mSpec;
-    ShShaderOutput mOutputType;
-    ShBuiltInResources mResources;
-
-    ShHandle mFragmentCompiler;
-    ShHandle mVertexCompiler;
+    ShShaderOutput mTranslatorOutputType;
 };
 
 }

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -237,9 +237,9 @@ gl::Error RendererGL::drawRangeElements(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-CompilerImpl *RendererGL::createCompiler(const gl::Data &data)
+CompilerImpl *RendererGL::createCompiler()
 {
-    return new CompilerGL(data, mFunctions);
+    return new CompilerGL(mFunctions);
 }
 
 ShaderImpl *RendererGL::createShader(GLenum type)

src/libANGLE/renderer/gl/RendererGL.h

@@ -58,7 +58,7 @@ class RendererGL : public Renderer
                                 const gl::IndexRange &indexRange) override;
 
     // Shader creation
-    CompilerImpl *createCompiler(const gl::Data &data) override;
+    CompilerImpl *createCompiler() override;
     ShaderImpl *createShader(GLenum type) override;
     ProgramImpl *createProgram(const gl::Program::Data &data) override;
 

src/libANGLE/renderer/gl/ShaderGL.cpp

@@ -10,7 +10,6 @@
 
 #include "common/debug.h"
 #include "libANGLE/Compiler.h"
-#include "libANGLE/renderer/gl/CompilerGL.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 
 template <typename VarT>
@@ -72,8 +71,7 @@ bool ShaderGL::compile(gl::Compiler *compiler, const std::string &source)
     }
 
     // Translate the ESSL into GLSL
-    CompilerGL *compilerGL = GetImplAs<CompilerGL>(compiler);
-    ShHandle compilerHandle = compilerGL->getCompilerHandle(mType);
+    ShHandle compilerHandle = compiler->getCompilerHandle(mType);
 
     int compileOptions = (SH_OBJECT_CODE | SH_VARIABLES | SH_INIT_GL_POSITION);
     const char* sourceCString = source.c_str();

src/tests/angle_unittests_utils.h

@@ -21,7 +21,7 @@ class NullFactory : public ImplFactory
     NullFactory() {}
 
     // Shader creation
-    CompilerImpl *createCompiler(const gl::Data &data) override { return nullptr; }
+    CompilerImpl *createCompiler() override { return nullptr; }
     ShaderImpl *createShader(GLenum type) override { return nullptr; }
     ProgramImpl *createProgram(const gl::Program::Data &data) override { return nullptr; }