Revert of Multi-string shaders

src/gpu/gl/builders/GrGLSLPrettyPrint.cpp

Index: src/gpu/gl/builders/GrGLSLPrettyPrint.cpp
diff --git a/src/gpu/gl/builders/GrGLSLPrettyPrint.cpp b/src/gpu/gl/builders/GrGLSLPrettyPrint.cpp
index 02802987c6007f58496920e03410cd6b176ba53b..27f4b44e66b87258d7f9131a7fed789aefd5485e 100644
--- a/src/gpu/gl/builders/GrGLSLPrettyPrint.cpp
+++ b/src/gpu/gl/builders/GrGLSLPrettyPrint.cpp
@@ -12,86 +12,69 @@
 public:
     GLSLPrettyPrint() {}
 
-    SkString prettify(const char** strings,
-                      int* lengths,
-                      int count,
-                      bool countlines) {
+    SkString prettify(const SkString& input, bool countlines) {
+        // setup pretty state
+        fIndex = 0;
+        fLength = input.size();
+        fInput = input;
         fCountlines = countlines;
         fTabs = 0;
         fLinecount = 1;
         fFreshline = true;
 
-        // If a string breaks while in the middle 'parse until' we need to continue parsing on the
-        // next string
-        fInParseUntilNewline = false;
-        fInParseUntil = false;
-
         int parensDepth = 0;
-
         // number 1st line
         this->lineNumbering();
-        for (int i = 0; i < count; i++) {
-            // setup pretty state
-            fIndex = 0;
-            fLength = lengths[i];
-            fInput = strings[i];
-
-            while (fLength > fIndex) {
-                /* the heart and soul of our prettification algorithm.  The rules should hopefully
-                 * be self explanatory.  For '#' and '//' tokens we parse until we reach a newline.
-                 *
-                 * For long style comments like this one, we search for the ending token.  We also
-                 * preserve whitespace in these comments WITH THE CAVEAT that we do the newlines
-                 * ourselves.  This allows us to remain in control of line numbers, and matching
-                 * tabs Existing tabs in the input string are copied over too, but this will look
-                 *  funny
-                 *
-                 * '{' and '}' are handled in basically the same way.  We add a newline if we aren't
-                 * on a fresh line, dirty the line, then add a second newline, ie braces are always
-                 * on their own lines indented properly.  The one funkiness here is structs print
-                 * with the semicolon on its own line.  Its not a problem for a glsl compiler though
-                 *
-                 * '(' and ')' are basically ignored, except as a sign we need to ignore ';' ala
-                 * in for loops.
-                 *
-                 * ';' means add a new line
-                 *
-                 * '\t' and '\n' are ignored in general parsing for backwards compatability with
-                 * existing shader code and we also have a special case for handling whitespace
-                 * at the beginning of fresh lines.
-                 *
-                 * Otherwise just add the new character to the pretty string, indenting if necessary.
-                 */
-                if (fInParseUntilNewline) {
-                    this->parseUntilNewline();
-                } else if (fInParseUntil) {
-                    this->parseUntil(fInParseUntilToken);
-                } else if (this->hasToken("#") || this->hasToken("//")) {
-                    this->parseUntilNewline();
-                } else if (this->hasToken("/*")) {
-                    this->parseUntil("*/");
-                } else if ('{' == fInput[fIndex]) {
-                    this->newline();
-                    this->appendChar('{');
-                    fTabs++;
-                    this->newline();
-                } else if ('}' == fInput[fIndex]) {
-                    fTabs--;
-                    this->newline();
-                    this->appendChar('}');
-                    this->newline();
-                } else if (this->hasToken(")")) {
-                    parensDepth--;
-                } else if (this->hasToken("(")) {
-                    parensDepth++;
-                } else if (!parensDepth && this->hasToken(";")) {
-                    this->newline();
-                } else if ('\t' == fInput[fIndex] || '\n' == fInput[fIndex] ||
-                        (fFreshline && ' ' == fInput[fIndex])) {
-                    fIndex++;
-                } else {
-                    this->appendChar(fInput[fIndex]);
-                }
+        while (fLength > fIndex) {
+            /* the heart and soul of our prettification algorithm.  The rules should hopefully be
+             * self explanatory.  For '#' and '//' tokens we parse until we reach a newline.
+             *
+             * For long style comments like this one, we search for the ending token.  We also
+             * preserve whitespace in these comments WITH THE CAVEAT that we do the newlines
+             * ourselves.  This allows us to remain in control of line numbers, and matching tabs
+             * Existing tabs in the input string are copied over too, but this will look funny
+             *
+             * '{' and '}' are handled in basically the same way.  We add a newline if we aren't
+             * on a fresh line, dirty the line, then add a second newline, ie braces are always
+             * on their own lines indented properly.  The one funkiness here is structs print with
+             * the semicolon on its own line.  Its not a problem for a glsl compiler though
+             *
+             * '(' and ')' are basically ignored, except as a sign we need to ignore ';' ala
+             * in for loops.
+             *
+             * ';' means add a new line
+             *
+             * '\t' and '\n' are ignored in general parsing for backwards compatability with
+             * existing shader code and we also have a special case for handling whitespace
+             * at the beginning of fresh lines.
+             *
+             * Otherwise just add the new character to the pretty string, indenting if necessary.
+             */
+            if (this->hasToken("#") || this->hasToken("//")) {
+                this->parseUntilNewline();
+            } else if (this->hasToken("/*")) {
+                this->parseUntil("*/");
+            } else if ('{' == fInput[fIndex]) {
+                this->newline();
+                this->appendChar('{');
+                fTabs++;
+                this->newline();
+            } else if ('}' == fInput[fIndex]) {
+                fTabs--;
+                this->newline();
+                this->appendChar('}');
+                this->newline();
+            } else if (this->hasToken(")")) {
+                parensDepth--;
+            } else if (this->hasToken("(")) {
+                parensDepth++;
+            } else if (!parensDepth && this->hasToken(";")) {
+                this->newline();
+            } else if ('\t' == fInput[fIndex] || '\n' == fInput[fIndex] ||
+                    (fFreshline && ' ' == fInput[fIndex])) {
+                fIndex++;
+            } else {
+                this->appendChar(input[fIndex]);
             }
         }
         return fPretty;
@@ -124,11 +107,9 @@
             if ('\n' == fInput[fIndex]) {
                 fIndex++;
                 this->newline();
-                fInParseUntilNewline = false;
                 break;
             }
             fPretty.appendf("%c", fInput[fIndex++]);
-            fInParseUntilNewline = true;
         }
     }
 
@@ -146,13 +127,10 @@
                 fIndex++;
             }
             if (this->hasToken(token)) {
-                fInParseUntil = false;
                 break;
             }
             fFreshline = false;
             fPretty.appendf("%c", fInput[fIndex++]);
-            fInParseUntil = true;
-            fInParseUntilToken = token;
         }
     }
 
@@ -184,21 +162,12 @@
     bool fCountlines, fFreshline;
     int fTabs, fLinecount;
     size_t fIndex, fLength;
-    const char* fInput;
-    SkString fPretty;
-
-    // Some helpers for parseUntil when we go over a string length
-    bool fInParseUntilNewline;
-    bool fInParseUntil;
-    const char* fInParseUntilToken;
+    SkString fInput, fPretty;
 };
 
-SkString PrettyPrintGLSL(const char** strings,
-                         int* lengths,
-                         int count,
-                         bool countlines) {
+SkString PrettyPrintGLSL(const SkString& input, bool countlines) {
     GLSLPrettyPrint pp;
-    return pp.prettify(strings, lengths, count, countlines);
+    return pp.prettify(input, countlines);
 }
 
 } // end namespace