Support line-continuation character in WebGL 2.0

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 430 matching lines @@
 
     case InPreprocessorDirective:
         // No matter what the character is, just pass it
         // through. Do not parse comments in this state. This
         // might not be the right thing to do long term, but it
         // should handle the #error preprocessor directive.
         emit(c);
         break;
 
     case InSingleLineComment:
+        // Line-continuation characters are processed before comment processing.
+        // Advance string if a new line character is immediately behind
+        // line-continuation character.
+        if (c == '\\') {
+            if (peek(temp) && isNewline(temp))

[Zhenyao Mo, 2016/06/30 16:10:39]

What if it's "\r\n"? Two characters but still one line

[Zhenyao Mo, 2016/06/30 16:40:55]

Never mind. It doesn't matter.

+                advance();
+        }
+
         // The newline code at the top of this function takes care
         // of resetting our state when we get out of the
         // single-line comment. Swallow all other characters.
         break;
 
     case InMultiLineComment:
         if (c == '*' && peek(temp) && temp == '/') {
             emit('*');
             emit('/');
             m_parseState = MiddleOfLine;
@@ skipping 3388 matching lines @@
     if (isContextLost())
         return;
     contextGL()->Scissor(x, y, width, height);
 }
 
 void WebGLRenderingContextBase::shaderSource(WebGLShader* shader, const String& string)
 {
     if (isContextLost() || !validateWebGLObject("shaderSource", shader))
         return;
     String stringWithoutComments = StripComments(string).result();
-    // TODO(danakj): Make validateString reject characters > 255 (or utf16 Strings)
+    // TODO(danakj): Make validateShaderSource reject characters > 255 (or utf16 Strings)
     // so we don't need to use StringUTF8Adaptor.
-    if (!validateString("shaderSource", stringWithoutComments))
+    if (!validateShaderSource(stringWithoutComments))
         return;
     shader->setSource(string);
     WTF::StringUTF8Adaptor adaptor(stringWithoutComments);
     const GLchar* shaderData = adaptor.data();
     // TODO(danakj): Use base::saturated_cast<GLint>.
     const GLint shaderLength = adaptor.length();
     contextGL()->ShaderSource(objectOrZero(shader), 1, &shaderData, &shaderLength);
 }
 
 void WebGLRenderingContextBase::stencilFunc(GLenum func, GLint ref, GLuint mask)
@@ skipping 1590 matching lines @@
 {
     for (size_t i = 0; i < string.length(); ++i) {
         if (!validateCharacter(string[i])) {
             synthesizeGLError(GL_INVALID_VALUE, functionName, "string not ASCII");
             return false;
         }
     }
     return true;
 }
 
+bool WebGLRenderingContextBase::validateShaderSource(const String& string)
+{
+    for (size_t i = 0; i < string.length(); ++i) {
+        // line-continuation character \ is supported in WebGL 2.0.
+        if (isWebGL2OrHigher() && string[i] == '\\') {
+            if (i + 1 >= string.length() || (string[i + 1] != '\n' && string[i + 1] != '\r')) {
+                synthesizeGLError(GL_INVALID_VALUE, "shaderSource", "line-continuation character is not immediately preceding a new-line");

[Zhenyao Mo, 2016/06/30 16:10:39]

From reading the spec, I am not sure if it's an error when not followed by a
new-line immediately, or it's just retreated as a regular character? Ken?

[Ken Russell (switch to Gerrit), 2016/07/01 00:42:30]

From my reading of the spec, the continuation character should be allowed
anywhere inside comments, but only have the behavior of concatenating the
current and next line if it's at the very end of the current line, followed by
the newline character. So I think this check is too strict.

For the rest of the shader, it seems OK to reject the continuation character if
it doesn't immediately precede a newline.

At least a test of a continuation character in the middle of a single-line
comment is needed.

[qiankun, 2016/07/01 10:32:01]

Comments have already been removed before doing validateShaderSource(). So no
problem here.
Added in https://github.com/KhronosGroup/WebGL/pull/1827

[Zhenyao Mo, 2016/07/01 16:53:50]

Is this behavior (generating INVALID_VALUE if '\\' is not immediately followed
by a new line) tested?  If not, please also add a test case for that.

+                return false;
+            }
+            continue;
+        }
+        if (!validateCharacter(string[i])) {
+            synthesizeGLError(GL_INVALID_VALUE, "shaderSource", "string not ASCII");
+            return false;
+        }
+    }
+    return true;
+}
+
 bool WebGLRenderingContextBase::validateTexFuncFormatAndType(const char* functionName, TexImageFunctionType functionType, GLenum internalformat, GLenum format, GLenum type, GLint level)
 {
     if (!m_isWebGL2FormatsTypesAdded && isWebGL2OrHigher()) {
         ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES3);
         ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsTexImageES3);
         ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES3);
         ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES3);
         m_isWebGL2FormatsTypesAdded = true;
     }
 
@@ skipping 962 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink