eliminated GrGLSLExpr

Now that skslc performs all of the optimizations (and then some) that
GrGLSLExpr is responsible for, it's just extra work for no benefit.

Bug: skia:
Change-Id: I40b0629e00a33873ed9fc6c0a9f41d8350221f9a
Reviewed-on: https://skia-review.googlesource.com/14560
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

2 files changed, 0 insertions, 416 deletions

diff --git a/include/private/GrGLSL.h b/include/private/GrGLSL.h
index 66f7be84d1..26954b4f80 100644
--- a/include/private/GrGLSL.h
+++ b/include/private/GrGLSL.h
@@ -138,245 +138,4 @@ static inline const char* GrGLSLTypeString(GrSLType t) {
     return ""; // suppress warning
 }
 
-/** A generic base-class representing a GLSL expression.
- * The instance can be a variable name, expression or vecN(0) or vecN(1). Does simple constant
- * folding with help of 1 and 0.
- *
- * Clients should not use this class, rather the specific instantiations defined
- * later, for example GrGLSLExpr4.
- */
-template <typename Self>
-class GrGLSLExpr {
-public:
-    bool isOnes() const { return kOnes_ExprType == fType; }
-    bool isZeros() const { return kZeros_ExprType == fType; }
-
-    const char* c_str() const {
-        if (kZeros_ExprType == fType) {
-            return Self::ZerosStr();
-        } else if (kOnes_ExprType == fType) {
-            return Self::OnesStr();
-        }
-        SkASSERT(!fExpr.isEmpty()); // Empty expressions should not be used.
-        return fExpr.c_str();
-    }
-
-    bool isValid() const {
-        return kFullExpr_ExprType != fType || !fExpr.isEmpty();
-    }
-
-protected:
-    /** Constructs an invalid expression.
-     * Useful only as a return value from functions that never actually return
-     * this and instances that will be assigned to later. */
-    GrGLSLExpr()
-        : fType(kFullExpr_ExprType) {
-        // The only constructor that is allowed to build an empty expression.
-        SkASSERT(!this->isValid());
-    }
-
-    /** Constructs an expression with all components as value v */
-    explicit GrGLSLExpr(int v) {
-        if (v == 0) {
-            fType = kZeros_ExprType;
-        } else if (v == 1) {
-            fType = kOnes_ExprType;
-        } else {
-            fType = kFullExpr_ExprType;
-            fExpr.appendf(Self::CastIntStr(), v);
-        }
-    }
-
-    /** Constructs an expression from a string.
-     * Argument expr is a simple expression or a parenthesized expression. */
-    // TODO: make explicit once effects input Exprs.
-    GrGLSLExpr(const char expr[]) {
-        if (nullptr == expr) {  // TODO: remove this once effects input Exprs.
-            fType = kOnes_ExprType;
-        } else {
-            fType = kFullExpr_ExprType;
-            fExpr = expr;
-        }
-        SkASSERT(this->isValid());
-    }
-
-    /** Constructs an expression from a string.
-     * Argument expr is a simple expression or a parenthesized expression. */
-    // TODO: make explicit once effects input Exprs.
-    GrGLSLExpr(const SkString& expr) {
-        if (expr.isEmpty()) {  // TODO: remove this once effects input Exprs.
-            fType = kOnes_ExprType;
-        } else {
-            fType = kFullExpr_ExprType;
-            fExpr = expr;
-        }
-        SkASSERT(this->isValid());
-    }
-
-    /** Constructs an expression from a string with one substitution. */
-    GrGLSLExpr(const char format[], const char in0[])
-        : fType(kFullExpr_ExprType) {
-        fExpr.appendf(format, in0);
-    }
-
-    /** Constructs an expression from a string with two substitutions. */
-    GrGLSLExpr(const char format[], const char in0[], const char in1[])
-        : fType(kFullExpr_ExprType) {
-        fExpr.appendf(format, in0, in1);
-    }
-
-    /** Returns expression casted to another type.
-     * Generic implementation that is called for non-trivial cases of casts. */
-    template <typename T>
-    static Self VectorCastImpl(const T& other);
-
-    /** Returns a GLSL multiplication: component-wise or component-by-scalar.
-     * The multiplication will be component-wise or multiply each component by a scalar.
-     *
-     * The returned expression will compute the value of:
-     *    vecN(in0.x * in1.x, ...) if dim(T0) == dim(T1) (component-wise)
-     *    vecN(in0.x * in1, ...) if dim(T1) == 1 (vector by scalar)
-     *    vecN(in0 * in1.x, ...) if dim(T0) == 1 (scalar by vector)
-     */
-    template <typename T0, typename T1>
-    static Self Mul(T0 in0, T1 in1);
-
-    /** Returns a GLSL addition: component-wise or add a scalar to each component.
-     * Return value computes:
-     *   vecN(in0.x + in1.x, ...) or vecN(in0.x + in1, ...) or vecN(in0 + in1.x, ...).
-     */
-    template <typename T0, typename T1>
-    static Self Add(T0 in0, T1 in1);
-
-    /** Returns a GLSL subtraction: component-wise or subtract compoments by a scalar.
-     * Return value computes
-     *   vecN(in0.x - in1.x, ...) or vecN(in0.x - in1, ...) or vecN(in0 - in1.x, ...).
-     */
-    template <typename T0, typename T1>
-    static Self Sub(T0 in0, T1 in1);
-
-    /** Returns expression that accesses component(s) of the expression.
-     * format should be the form "%s.x" where 'x' is the component(s) to access.
-     * Caller is responsible for making sure the amount of components in the
-     * format string is equal to dim(T).
-     */
-    template <typename T>
-    T extractComponents(const char format[]) const;
-
-private:
-    enum ExprType {
-        kZeros_ExprType,
-        kOnes_ExprType,
-        kFullExpr_ExprType,
-    };
-    ExprType fType;
-    SkString fExpr;
-};
-
-class GrGLSLExpr1;
-class GrGLSLExpr4;
-
-/** Class representing a float GLSL expression. */
-class GrGLSLExpr1 : public GrGLSLExpr<GrGLSLExpr1> {
-public:
-    GrGLSLExpr1()
-        : INHERITED() {
-    }
-    explicit GrGLSLExpr1(int v)
-        : INHERITED(v) {
-    }
-    GrGLSLExpr1(const char* expr)
-        : INHERITED(expr) {
-    }
-    GrGLSLExpr1(const SkString& expr)
-        : INHERITED(expr) {
-    }
-
-    static GrGLSLExpr1 VectorCast(const GrGLSLExpr1& expr);
-
-private:
-    GrGLSLExpr1(const char format[], const char in0[])
-        : INHERITED(format, in0) {
-    }
-    GrGLSLExpr1(const char format[], const char in0[], const char in1[])
-        : INHERITED(format, in0, in1) {
-    }
-
-    static const char* ZerosStr();
-    static const char* OnesStr();
-    static const char* CastStr();
-    static const char* CastIntStr();
-
-    friend GrGLSLExpr1 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
-    friend GrGLSLExpr1 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
-    friend GrGLSLExpr1 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr1&in1);
-
-    friend class GrGLSLExpr<GrGLSLExpr1>;
-    friend class GrGLSLExpr<GrGLSLExpr4>;
-
-    typedef GrGLSLExpr<GrGLSLExpr1> INHERITED;
-};
-
-/** Class representing a float vector (vec4) GLSL expression. */
-class GrGLSLExpr4 : public GrGLSLExpr<GrGLSLExpr4> {
-public:
-    GrGLSLExpr4()
-        : INHERITED() {
-    }
-    explicit GrGLSLExpr4(int v)
-        : INHERITED(v) {
-    }
-    GrGLSLExpr4(const char* expr)
-        : INHERITED(expr) {
-    }
-    GrGLSLExpr4(const SkString& expr)
-        : INHERITED(expr) {
-    }
-
-    typedef GrGLSLExpr1 AExpr;
-    AExpr a() const;
-
-    /** GLSL vec4 cast / constructor, eg vec4(floatv) -> vec4(floatv, floatv, floatv, floatv) */
-    static GrGLSLExpr4 VectorCast(const GrGLSLExpr1& expr);
-    static GrGLSLExpr4 VectorCast(const GrGLSLExpr4& expr);
-
-private:
-    GrGLSLExpr4(const char format[], const char in0[])
-        : INHERITED(format, in0) {
-    }
-    GrGLSLExpr4(const char format[], const char in0[], const char in1[])
-        : INHERITED(format, in0, in1) {
-    }
-
-    static const char* ZerosStr();
-    static const char* OnesStr();
-    static const char* CastStr();
-    static const char* CastIntStr();
-
-    // The vector-by-scalar and scalar-by-vector binary operations.
-    friend GrGLSLExpr4 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
-    friend GrGLSLExpr4 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
-    friend GrGLSLExpr4 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr4&in1);
-    friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
-    friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
-    friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr1&in1);
-
-    // The vector-by-vector, i.e. component-wise, binary operations.
-    friend GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
-    friend GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
-    friend GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr4&in1);
-
-    friend class GrGLSLExpr<GrGLSLExpr4>;
-
-    typedef GrGLSLExpr<GrGLSLExpr4> INHERITED;
-};
-
-/**
- * Does an inplace mul, *=, of vec4VarName by mulFactor.
- * A semicolon is added after the assignment.
- */
-void GrGLSLMulVarBy4f(SkString* outAppend, const char* vec4VarName, const GrGLSLExpr4& mulFactor);
-
-#include "GrGLSL_impl.h"
-
 #endif
diff --git a/include/private/GrGLSL_impl.h b/include/private/GrGLSL_impl.h
deleted file mode 100644
index bdd69cc76b..0000000000
--- a/include/private/GrGLSL_impl.h
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrGLSL_impl_DEFINED
-#define GrGLSL_impl_DEFINED
-
-template<typename Self>
-template<typename T>
-inline Self GrGLSLExpr<Self>::VectorCastImpl(const T& expr) {
-    if (expr.isZeros()) {
-        return Self(0);
-    }
-    if (expr.isOnes()) {
-        return Self(1);
-    }
-    return Self(Self::CastStr(), expr.c_str());
-}
-
-template<typename Self>
-template<typename T0, typename T1>
-inline Self GrGLSLExpr<Self>::Mul(T0 in0, T1 in1) {
-    if (in0.isZeros() || in1.isZeros()) {
-        return Self(0);
-    }
-    if (in0.isOnes()) {
-        return Self::VectorCast(in1);
-    }
-    if (in1.isOnes()) {
-        return Self::VectorCast(in0);
-    }
-    return Self("(%s * %s)", in0.c_str(), in1.c_str());
-}
-
-template<typename Self>
-template<typename T0, typename T1>
-inline Self GrGLSLExpr<Self>::Add(T0 in0, T1 in1) {
-    if (in1.isZeros()) {
-        return Self::VectorCast(in0);
-    }
-    if (in0.isZeros()) {
-        return Self::VectorCast(in1);
-    }
-    if (in0.isOnes() && in1.isOnes()) {
-        return Self(2);
-    }
-    return Self("(%s + %s)", in0.c_str(), in1.c_str());
-}
-
-template<typename Self>
-template<typename T0, typename T1>
-inline Self GrGLSLExpr<Self>::Sub(T0 in0, T1 in1) {
-    if (in1.isZeros()) {
-        return Self::VectorCast(in0);
-    }
-    if (in1.isOnes()) {
-        if (in0.isOnes()) {
-            return Self(0);
-        }
-    }
-
-    return Self("(%s - %s)", in0.c_str(), in1.c_str());
-}
-
-template <typename Self>
-template <typename T>
-T GrGLSLExpr<Self>::extractComponents(const char format[]) const {
-    if (this->isZeros()) {
-        return T(0);
-    }
-    if (this->isOnes()) {
-        return T(1);
-    }
-    return T(format, this->c_str());
-}
-
-inline GrGLSLExpr1 GrGLSLExpr1::VectorCast(const GrGLSLExpr1& expr) {
-    return expr;
-}
-
-inline const char* GrGLSLExpr1::ZerosStr() {
-    return "0";
-}
-
-inline const char* GrGLSLExpr1::OnesStr() {
-    return "1.0";
-}
-
-// GrGLSLExpr1::CastStr() is unimplemented because using them is likely an
-// error. This is now caught compile-time.
-
-inline const char* GrGLSLExpr1::CastIntStr() {
-    return "%d";
-}
-
-inline GrGLSLExpr1 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr1::Mul(in0, in1);
-}
-
-inline GrGLSLExpr1 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr1::Add(in0, in1);
-}
-
-inline GrGLSLExpr1 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr1::Sub(in0, in1);
-}
-
-inline const char* GrGLSLExpr4::ZerosStr() {
-    return "vec4(0)";
-}
-
-inline const char* GrGLSLExpr4::OnesStr() {
-    return "vec4(1)";
-}
-
-inline const char* GrGLSLExpr4::CastStr() {
-    return "vec4(%s)";
-}
-
-inline const char* GrGLSLExpr4::CastIntStr() {
-    return "vec4(%d)";
-}
-
-inline GrGLSLExpr4 GrGLSLExpr4::VectorCast(const GrGLSLExpr1& expr) {
-    return INHERITED::VectorCastImpl(expr);
-}
-
-inline GrGLSLExpr4 GrGLSLExpr4::VectorCast(const GrGLSLExpr4& expr) {
-    return expr;
-}
-
-inline GrGLSLExpr4::AExpr GrGLSLExpr4::a() const {
-    return this->extractComponents<GrGLSLExpr4::AExpr>("%s.a");
-}
-
-inline GrGLSLExpr4 operator*(const GrGLSLExpr1& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Mul(in0, in1);
-}
-
-inline GrGLSLExpr4 operator+(const GrGLSLExpr1& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Add(in0, in1);
-}
-
-inline GrGLSLExpr4 operator-(const GrGLSLExpr1& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Sub(in0, in1);
-}
-
-inline GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr4::Mul(in0, in1);
-}
-
-inline GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr4::Add(in0, in1);
-}
-
-inline GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr1& in1) {
-    return GrGLSLExpr4::Sub(in0, in1);
-}
-
-inline GrGLSLExpr4 operator*(const GrGLSLExpr4& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Mul(in0, in1);
-}
-
-inline GrGLSLExpr4 operator+(const GrGLSLExpr4& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Add(in0, in1);
-}
-
-inline GrGLSLExpr4 operator-(const GrGLSLExpr4& in0, const GrGLSLExpr4& in1) {
-    return GrGLSLExpr4::Sub(in0, in1);
-}
-
-#endif