Rename gl::Shader::Data to gl::ShaderState.

src/libANGLE/Shader.cpp

@@ -72,11 +72,11 @@ bool CompareShaderVar(const sh::ShaderVariable &x, const sh::ShaderVariable &y)
     return gl::VariableSortOrder(x.type) < gl::VariableSortOrder(y.type);
 }
 
-Shader::Data::Data(GLenum shaderType) : mLabel(), mShaderType(shaderType), mShaderVersion(100)
+ShaderState::ShaderState(GLenum shaderType) : mLabel(), mShaderType(shaderType), mShaderVersion(100)
 {
 }
 
-Shader::Data::~Data()
+ShaderState::~ShaderState()
 {
 }
 
@@ -85,8 +85,8 @@ Shader::Shader(ResourceManager *manager,
                const gl::Limitations &rendererLimitations,
                GLenum type,
                GLuint handle)
-    : mData(type),
-      mImplementation(implFactory->createShader(mData)),
+    : mState(type),
+      mImplementation(implFactory->createShader(mState)),
       mRendererLimitations(rendererLimitations),
       mHandle(handle),
       mType(type),
@@ -105,12 +105,12 @@ Shader::~Shader()
 
 void Shader::setLabel(const std::string &label)
 {
-    mData.mLabel = label;
+    mState.mLabel = label;
 }
 
 const std::string &Shader::getLabel() const
 {
-    return mData.mLabel;
+    return mState.mLabel;
 }
 
 GLuint Shader::getHandle() const
@@ -134,7 +134,7 @@ void Shader::setSource(GLsizei count, const char *const *string, const GLint *le
         }
     }
 
-    mData.mSource = stream.str();
+    mState.mSource = stream.str();
 }
 
 int Shader::getInfoLogLength() const
@@ -167,17 +167,17 @@ void Shader::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
 
 int Shader::getSourceLength() const
 {
-    return mData.mSource.empty() ? 0 : (static_cast<int>(mData.mSource.length()) + 1);
+    return mState.mSource.empty() ? 0 : (static_cast<int>(mState.mSource.length()) + 1);
 }
 
 int Shader::getTranslatedSourceLength() const
 {
-    if (mData.mTranslatedSource.empty())
+    if (mState.mTranslatedSource.empty())
     {
         return 0;
     }
 
-    return (static_cast<int>(mData.mTranslatedSource.length()) + 1);
+    return (static_cast<int>(mState.mTranslatedSource.length()) + 1);
 }
 
 int Shader::getTranslatedSourceWithDebugInfoLength() const
@@ -211,12 +211,12 @@ void Shader::getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *
 
 void Shader::getSource(GLsizei bufSize, GLsizei *length, char *buffer) const
 {
-    getSourceImpl(mData.mSource, bufSize, length, buffer);
+    getSourceImpl(mState.mSource, bufSize, length, buffer);
 }
 
 void Shader::getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const
 {
-    getSourceImpl(mData.mTranslatedSource, bufSize, length, buffer);
+    getSourceImpl(mState.mTranslatedSource, bufSize, length, buffer);
 }
 
 void Shader::getTranslatedSourceWithDebugInfo(GLsizei bufSize, GLsizei *length, char *buffer) const
@@ -227,16 +227,16 @@ void Shader::getTranslatedSourceWithDebugInfo(GLsizei bufSize, GLsizei *length,
 
 void Shader::compile(Compiler *compiler)
 {
-    mData.mTranslatedSource.clear();
+    mState.mTranslatedSource.clear();
     mInfoLog.clear();
-    mData.mShaderVersion = 100;
-    mData.mVaryings.clear();
-    mData.mUniforms.clear();
-    mData.mInterfaceBlocks.clear();
-    mData.mActiveAttributes.clear();
-    mData.mActiveOutputVariables.clear();
+    mState.mShaderVersion = 100;
+    mState.mVaryings.clear();
+    mState.mUniforms.clear();
+    mState.mInterfaceBlocks.clear();
+    mState.mActiveAttributes.clear();
+    mState.mActiveOutputVariables.clear();
 
-    ShHandle compilerHandle = compiler->getCompilerHandle(mData.mShaderType);
+    ShHandle compilerHandle = compiler->getCompilerHandle(mState.mShaderType);
 
     std::stringstream sourceStream;
 
@@ -274,7 +274,7 @@ void Shader::compile(Compiler *compiler)
         return;
     }
 
-    mData.mTranslatedSource = ShGetObjectCode(compilerHandle);
+    mState.mTranslatedSource = ShGetObjectCode(compilerHandle);
 
 #ifndef NDEBUG
     // Prefix translated shader with commented out un-translated shader.
@@ -286,40 +286,40 @@ void Shader::compile(Compiler *compiler)
     size_t curPos = 0;
     while (curPos != std::string::npos)
     {
-        size_t nextLine = mData.mSource.find("\n", curPos);
+        size_t nextLine = mState.mSource.find("\n", curPos);
         size_t len      = (nextLine == std::string::npos) ? std::string::npos : (nextLine - curPos + 1);
 
-        shaderStream << "// " << mData.mSource.substr(curPos, len);
+        shaderStream << "// " << mState.mSource.substr(curPos, len);
 
         curPos = (nextLine == std::string::npos) ? std::string::npos : (nextLine + 1);
     }
     shaderStream << "\n\n";
-    shaderStream << mData.mTranslatedSource;
-    mData.mTranslatedSource = shaderStream.str();
+    shaderStream << mState.mTranslatedSource;
+    mState.mTranslatedSource = shaderStream.str();
 #endif
 
     // Gather the shader information
-    mData.mShaderVersion = ShGetShaderVersion(compilerHandle);
+    mState.mShaderVersion = ShGetShaderVersion(compilerHandle);
 
-    mData.mVaryings        = GetShaderVariables(ShGetVaryings(compilerHandle));
-    mData.mUniforms        = GetShaderVariables(ShGetUniforms(compilerHandle));
-    mData.mInterfaceBlocks = GetShaderVariables(ShGetInterfaceBlocks(compilerHandle));
+    mState.mVaryings        = GetShaderVariables(ShGetVaryings(compilerHandle));
+    mState.mUniforms        = GetShaderVariables(ShGetUniforms(compilerHandle));
+    mState.mInterfaceBlocks = GetShaderVariables(ShGetInterfaceBlocks(compilerHandle));
 
-    if (mData.mShaderType == GL_VERTEX_SHADER)
+    if (mState.mShaderType == GL_VERTEX_SHADER)
     {
-        mData.mActiveAttributes = GetActiveShaderVariables(ShGetAttributes(compilerHandle));
+        mState.mActiveAttributes = GetActiveShaderVariables(ShGetAttributes(compilerHandle));
     }
     else
     {
-        ASSERT(mData.mShaderType == GL_FRAGMENT_SHADER);
+        ASSERT(mState.mShaderType == GL_FRAGMENT_SHADER);
 
         // TODO(jmadill): Figure out why we only sort in the FS, and if we need to.
-        std::sort(mData.mVaryings.begin(), mData.mVaryings.end(), CompareShaderVar);
-        mData.mActiveOutputVariables =
+        std::sort(mState.mVaryings.begin(), mState.mVaryings.end(), CompareShaderVar);
+        mState.mActiveOutputVariables =
             GetActiveShaderVariables(ShGetOutputVariables(compilerHandle));
     }
 
-    ASSERT(!mData.mTranslatedSource.empty());
+    ASSERT(!mState.mTranslatedSource.empty());
 
     mCompiled = mImplementation->postTranslateCompile(compiler, &mInfoLog);
 }
@@ -356,39 +356,39 @@ void Shader::flagForDeletion()
 
 int Shader::getShaderVersion() const
 {
-    return mData.mShaderVersion;
+    return mState.mShaderVersion;
 }
 
 const std::vector<sh::Varying> &Shader::getVaryings() const
 {
-    return mData.getVaryings();
+    return mState.getVaryings();
 }
 
 const std::vector<sh::Uniform> &Shader::getUniforms() const
 {
-    return mData.getUniforms();
+    return mState.getUniforms();
 }
 
 const std::vector<sh::InterfaceBlock> &Shader::getInterfaceBlocks() const
 {
-    return mData.getInterfaceBlocks();
+    return mState.getInterfaceBlocks();
 }
 
 const std::vector<sh::Attribute> &Shader::getActiveAttributes() const
 {
-    return mData.getActiveAttributes();
+    return mState.getActiveAttributes();
 }
 
 const std::vector<sh::OutputVariable> &Shader::getActiveOutputVariables() const
 {
-    return mData.getActiveOutputVariables();
+    return mState.getActiveOutputVariables();
 }
 
 int Shader::getSemanticIndex(const std::string &attributeName) const
 {
     if (!attributeName.empty())
     {
-        const auto &activeAttributes = mData.getActiveAttributes();
+        const auto &activeAttributes = mState.getActiveAttributes();
 
         int semanticIndex = 0;
         for (size_t attributeIndex = 0; attributeIndex < activeAttributes.size(); attributeIndex++)

src/libANGLE/Shader.h

@@ -37,52 +37,49 @@ struct ContextState;
 struct Limitations;
 class ResourceManager;
 
-class Shader final : angle::NonCopyable, public LabeledObject
+class ShaderState final : angle::NonCopyable
 {
   public:
-    class Data final : angle::NonCopyable
+    ShaderState(GLenum shaderType);
+    ~ShaderState();
+
+    const std::string &getLabel() const { return mLabel; }
+
+    const std::string &getSource() const { return mSource; }
+    const std::string &getTranslatedSource() const { return mTranslatedSource; }
+
+    GLenum getShaderType() const { return mShaderType; }
+    int getShaderVersion() const { return mShaderVersion; }
+
+    const std::vector<sh::Varying> &getVaryings() const { return mVaryings; }
+    const std::vector<sh::Uniform> &getUniforms() const { return mUniforms; }
+    const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const { return mInterfaceBlocks; }
+    const std::vector<sh::Attribute> &getActiveAttributes() const { return mActiveAttributes; }
+    const std::vector<sh::OutputVariable> &getActiveOutputVariables() const
     {
-      public:
-        Data(GLenum shaderType);
-        ~Data();
-
-        const std::string &getLabel() const { return mLabel; }
-
-        const std::string &getSource() const { return mSource; }
-        const std::string &getTranslatedSource() const { return mTranslatedSource; }
-
-        GLenum getShaderType() const { return mShaderType; }
-        int getShaderVersion() const { return mShaderVersion; }
-
-        const std::vector<sh::Varying> &getVaryings() const { return mVaryings; }
-        const std::vector<sh::Uniform> &getUniforms() const { return mUniforms; }
-        const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const
-        {
-            return mInterfaceBlocks;
-        }
-        const std::vector<sh::Attribute> &getActiveAttributes() const { return mActiveAttributes; }
-        const std::vector<sh::OutputVariable> &getActiveOutputVariables() const
-        {
-            return mActiveOutputVariables;
-        }
-
-      private:
-        friend class Shader;
-
-        std::string mLabel;
-
-        GLenum mShaderType;
-        int mShaderVersion;
-        std::string mTranslatedSource;
-        std::string mSource;
-
-        std::vector<sh::Varying> mVaryings;
-        std::vector<sh::Uniform> mUniforms;
-        std::vector<sh::InterfaceBlock> mInterfaceBlocks;
-        std::vector<sh::Attribute> mActiveAttributes;
-        std::vector<sh::OutputVariable> mActiveOutputVariables;
-    };
+        return mActiveOutputVariables;
+    }
+
+  private:
+    friend class Shader;
 
+    std::string mLabel;
+
+    GLenum mShaderType;
+    int mShaderVersion;
+    std::string mTranslatedSource;
+    std::string mSource;
+
+    std::vector<sh::Varying> mVaryings;
+    std::vector<sh::Uniform> mUniforms;
+    std::vector<sh::InterfaceBlock> mInterfaceBlocks;
+    std::vector<sh::Attribute> mActiveAttributes;
+    std::vector<sh::OutputVariable> mActiveOutputVariables;
+};
+
+class Shader final : angle::NonCopyable, public LabeledObject
+{
+  public:
     Shader(ResourceManager *manager,
            rx::ImplFactory *implFactory,
            const gl::Limitations &rendererLimitations,
@@ -107,7 +104,7 @@ class Shader final : angle::NonCopyable, public LabeledObject
     void getSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
     int getTranslatedSourceLength() const;
     int getTranslatedSourceWithDebugInfoLength() const;
-    const std::string &getTranslatedSource() const { return mData.getTranslatedSource(); }
+    const std::string &getTranslatedSource() const { return mState.getTranslatedSource(); }
     void getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
     void getTranslatedSourceWithDebugInfo(GLsizei bufSize, GLsizei *length, char *buffer) const;
 
@@ -133,7 +130,7 @@ class Shader final : angle::NonCopyable, public LabeledObject
   private:
     static void getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer);
 
-    Data mData;
+    ShaderState mState;
     rx::ShaderImpl *mImplementation;
     const gl::Limitations &mRendererLimitations;
     const GLuint mHandle;

src/libANGLE/renderer/ImplFactory.h

@@ -39,7 +39,7 @@ class ImplFactory : angle::NonCopyable
 
     // Shader creation
     virtual CompilerImpl *createCompiler() = 0;
-    virtual ShaderImpl *createShader(const gl::Shader::Data &data) = 0;
+    virtual ShaderImpl *createShader(const gl::ShaderState &data) = 0;
     virtual ProgramImpl *createProgram(const gl::ProgramState &data) = 0;
 
     // Framebuffer creation

src/libANGLE/renderer/ShaderImpl.h

@@ -18,7 +18,7 @@ namespace rx
 class ShaderImpl : angle::NonCopyable
 {
   public:
-    ShaderImpl(const gl::Shader::Data &data) : mData(data) {}
+    ShaderImpl(const gl::ShaderState &data) : mData(data) {}
     virtual ~ShaderImpl() { }
 
     // Returns additional ShCompile options.
@@ -29,10 +29,10 @@ class ShaderImpl : angle::NonCopyable
 
     virtual std::string getDebugInfo() const = 0;
 
-    const gl::Shader::Data &getData() const { return mData; }
+    const gl::ShaderState &getData() const { return mData; }
 
   protected:
-    const gl::Shader::Data &mData;
+    const gl::ShaderState &mData;
 };
 
 }

src/libANGLE/renderer/d3d/ShaderD3D.cpp

@@ -40,7 +40,7 @@ const char *GetShaderTypeString(GLenum type)
 namespace rx
 {
 
-ShaderD3D::ShaderD3D(const gl::Shader::Data &data) : ShaderImpl(data)
+ShaderD3D::ShaderD3D(const gl::ShaderState &data) : ShaderImpl(data)
 {
     uncompile();
 }

src/libANGLE/renderer/d3d/ShaderD3D.h

@@ -23,7 +23,7 @@ struct D3DUniform;
 class ShaderD3D : public ShaderImpl
 {
   public:
-    ShaderD3D(const gl::Shader::Data &data);
+    ShaderD3D(const gl::ShaderState &data);
     virtual ~ShaderD3D();
 
     // ShaderImpl implementation

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

@@ -3364,7 +3364,7 @@ FramebufferImpl *Renderer11::createFramebuffer(const gl::FramebufferState &data)
     return new Framebuffer11(data, this);
 }
 
-ShaderImpl *Renderer11::createShader(const gl::Shader::Data &data)
+ShaderImpl *Renderer11::createShader(const gl::ShaderState &data)
 {
     return new ShaderD3D(data);
 }

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

@@ -193,7 +193,7 @@ class Renderer11 : public RendererD3D
     FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override;
 
     // Shader creation
-    ShaderImpl *createShader(const gl::Shader::Data &data) override;
+    ShaderImpl *createShader(const gl::ShaderState &data) override;
     ProgramImpl *createProgram(const gl::ProgramState &data) override;
 
     // Shader operations

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

@@ -2479,7 +2479,7 @@ FramebufferImpl *Renderer9::createFramebuffer(const gl::FramebufferState &data)
     return new Framebuffer9(data, this);
 }
 
-ShaderImpl *Renderer9::createShader(const gl::Shader::Data &data)
+ShaderImpl *Renderer9::createShader(const gl::ShaderState &data)
 {
     return new ShaderD3D(data);
 }

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

@@ -189,7 +189,7 @@ class Renderer9 : public RendererD3D
     FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override;
 
     // Shader creation
-    ShaderImpl *createShader(const gl::Shader::Data &data) override;
+    ShaderImpl *createShader(const gl::ShaderState &data) override;
     ProgramImpl *createProgram(const gl::ProgramState &data) override;
 
     // Shader operations

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -267,7 +267,7 @@ CompilerImpl *RendererGL::createCompiler()
     return new CompilerGL(mFunctions);
 }
 
-ShaderImpl *RendererGL::createShader(const gl::Shader::Data &data)
+ShaderImpl *RendererGL::createShader(const gl::ShaderState &data)
 {
     return new ShaderGL(data, mFunctions, mWorkarounds);
 }

src/libANGLE/renderer/gl/RendererGL.h

@@ -62,7 +62,7 @@ class RendererGL : public Renderer
 
     // Shader creation
     CompilerImpl *createCompiler() override;
-    ShaderImpl *createShader(const gl::Shader::Data &data) override;
+    ShaderImpl *createShader(const gl::ShaderState &data) override;
     ProgramImpl *createProgram(const gl::ProgramState &data) override;
 
     // Framebuffer creation

src/libANGLE/renderer/gl/ShaderGL.cpp

@@ -19,7 +19,7 @@
 namespace rx
 {
 
-ShaderGL::ShaderGL(const gl::Shader::Data &data,
+ShaderGL::ShaderGL(const gl::ShaderState &data,
                    const FunctionsGL *functions,
                    const WorkaroundsGL &workarounds)
     : ShaderImpl(data), mFunctions(functions), mWorkarounds(workarounds), mShaderID(0)

src/libANGLE/renderer/gl/ShaderGL.h

@@ -19,7 +19,7 @@ struct WorkaroundsGL;
 class ShaderGL : public ShaderImpl
 {
   public:
-    ShaderGL(const gl::Shader::Data &data,
+    ShaderGL(const gl::ShaderState &data,
              const FunctionsGL *functions,
              const WorkaroundsGL &workarounds);
     ~ShaderGL() override;

src/tests/angle_unittests_utils.h

@@ -22,7 +22,7 @@ class NullFactory : public ImplFactory
 
     // Shader creation
     CompilerImpl *createCompiler() override { return nullptr; }
-    ShaderImpl *createShader(const gl::Shader::Data &data) override { return nullptr; }
+    ShaderImpl *createShader(const gl::ShaderState &data) override { return nullptr; }
     ProgramImpl *createProgram(const gl::ProgramState &data) override { return nullptr; }
 
     // Framebuffer creation
@@ -60,7 +60,7 @@ class MockFactory : public ImplFactory
 {
   public:
     MOCK_METHOD0(createCompiler, CompilerImpl *());
-    MOCK_METHOD1(createShader, ShaderImpl *(const gl::Shader::Data &));
+    MOCK_METHOD1(createShader, ShaderImpl *(const gl::ShaderState &));
     MOCK_METHOD1(createProgram, ProgramImpl *(const gl::ProgramState &));
     MOCK_METHOD1(createFramebuffer, FramebufferImpl *(const gl::FramebufferState &));
     MOCK_METHOD1(createTexture, TextureImpl *(GLenum target));