kc3-lang/angle/src/tests/gl_tests/WebGLCompatibilityTest.cpp

• Show log

  Commit

• Hash : 327411e8
  Author :
  Date : 2016-12-09T11:09:17
  

  WebGL_compatibility: disallow client-side arrays
  
  BUG=angleproject:1523
  
  Change-Id: Icd207b2d94c1375c6f3189af42d55eac52b99603
  Reviewed-on: https://chromium-review.googlesource.com/418398
  Commit-Queue: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/gl_tests/WebGLCompatibilityTest.cpp

• //
  // 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.
  //
  
  // WebGLCompatibilityTest.cpp : Tests of the GL_ANGLE_webgl_compatibility extension.
  
  #include "test_utils/ANGLETest.h"
  
  #include "test_utils/gl_raii.h"
  
  namespace angle
  {
  
  class WebGLCompatibilityTest : public ANGLETest
  {
    protected:
      WebGLCompatibilityTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
          setWebGLCompatibilityEnabled(true);
      }
  
      void SetUp() override
      {
          ANGLETest::SetUp();
          glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
              eglGetProcAddress("glRequestExtensionANGLE"));
      }
  
      void TearDown() override { ANGLETest::TearDown(); }
  
      PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
  };
  
  // Context creation would fail if EGL_ANGLE_create_context_webgl_compatibility was not available so
  // the GL extension should always be present
  TEST_P(WebGLCompatibilityTest, ExtensionStringExposed)
  {
      EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));
  }
  
  // Verify that all extension entry points are available
  TEST_P(WebGLCompatibilityTest, EntryPoints)
  {
      if (extensionEnabled("GL_ANGLE_request_extension"))
      {
          EXPECT_NE(nullptr, eglGetProcAddress("glRequestExtensionANGLE"));
      }
  }
  
  // WebGL 1 allows GL_DEPTH_STENCIL_ATTACHMENT as a valid binding point.  Make sure it is usable,
  // even in ES2 contexts.
  TEST_P(WebGLCompatibilityTest, DepthStencilBindingPoint)
  {
      GLRenderbuffer renderbuffer;
      glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer.get());
      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 32, 32);
  
      GLFramebuffer framebuffer;
      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.get());
      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                                renderbuffer.get());
  
      EXPECT_GL_NO_ERROR();
  }
  
  // Test that attempting to enable an extension that doesn't exist generates GL_INVALID_OPERATION
  TEST_P(WebGLCompatibilityTest, EnableExtensionValidation)
  {
      glRequestExtensionANGLE("invalid_extension_string");
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  }
  
  // Test enabling the GL_OES_element_index_uint extension
  TEST_P(WebGLCompatibilityTest, EnableExtensionUintIndices)
  {
      if (getClientMajorVersion() != 2)
      {
          // This test only works on ES2 where uint indices are not available by default
          return;
      }
  
      EXPECT_FALSE(extensionEnabled("GL_OES_element_index_uint"));
  
      GLBuffer indexBuffer;
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.get());
  
      GLuint data[] = {0, 1, 2, 1, 3, 2};
      glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
  
      ANGLE_GL_PROGRAM(program, "void main() { gl_Position = vec4(0, 0, 0, 1); }",
                       "void main() { gl_FragColor = vec4(0, 1, 0, 1); }")
      glUseProgram(program.get());
  
      glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
      EXPECT_GL_ERROR(GL_INVALID_ENUM);
  
      if (extensionRequestable("GL_OES_element_index_uint"))
      {
          glRequestExtensionANGLE("GL_OES_element_index_uint");
          EXPECT_GL_NO_ERROR();
          EXPECT_TRUE(extensionEnabled("GL_OES_element_index_uint"));
  
          glDrawElements(GL_TRIANGLES, 2, GL_UNSIGNED_INT, nullptr);
          EXPECT_GL_NO_ERROR();
      }
  }
  
  // Verify that shaders are of a compatible spec when the extension is enabled.
  TEST_P(WebGLCompatibilityTest, ExtensionCompilerSpec)
  {
      EXPECT_TRUE(extensionEnabled("GL_ANGLE_webgl_compatibility"));
  
      // Use of reserved _webgl prefix should fail when the shader specification is for WebGL.
      const std::string &vert =
          "struct Foo {\n"
          "    int _webgl_bar;\n"
          "};\n"
          "void main()\n"
          "{\n"
          "    Foo foo = Foo(1);\n"
          "}";
  
      // Default fragement shader.
      const std::string &frag =
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
          "}";
  
      GLuint program = CompileProgram(vert, frag);
      EXPECT_EQ(0u, program);
      glDeleteProgram(program);
  }
  
  // Test that client-side array buffers are forbidden in WebGL mode
  TEST_P(WebGLCompatibilityTest, ForbidsClientSideArrayBuffer)
  {
      const std::string &vert =
          "attribute vec3 a_pos;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(a_pos, 1.0);\n"
          "}\n";
  
      const std::string &frag =
          "precision highp float;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(1.0);\n"
          "}\n";
  
      ANGLE_GL_PROGRAM(program, vert, frag);
  
      GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
      ASSERT_NE(-1, posLocation);
      glUseProgram(program.get());
  
      const auto &vertices = GetQuadVertices();
      glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices.data());
      glEnableVertexAttribArray(posLocation);
  
      ASSERT_GL_NO_ERROR();
      glDrawArrays(GL_TRIANGLES, 0, 6);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  }
  
  // Test that client-side element array buffers are forbidden in WebGL mode
  TEST_P(WebGLCompatibilityTest, ForbidsClientSideElementBuffer)
  {
      const std::string &vert =
          "attribute vec3 a_pos;\n"
          "void main()\n"
          "{\n"
          "    gl_Position = vec4(a_pos, 1.0);\n"
          "}\n";
  
      const std::string &frag =
          "precision highp float;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(1.0);\n"
          "}\n";
  
      ANGLE_GL_PROGRAM(program, vert, frag);
  
      GLint posLocation = glGetAttribLocation(program.get(), "a_pos");
      ASSERT_NE(-1, posLocation);
      glUseProgram(program.get());
  
      const auto &vertices = GetQuadVertices();
  
      GLBuffer vertexBuffer;
      glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.get());
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                   GL_STATIC_DRAW);
  
      glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(posLocation);
  
      const GLubyte indices[] = {0, 1, 2, 3, 4, 5};
  
      ASSERT_GL_NO_ERROR();
      glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices);
      EXPECT_GL_ERROR(GL_INVALID_OPERATION);
  }
  
  // Use this to select which configurations (e.g. which renderer, which GLES major version) these
  // tests should be run against.
  ANGLE_INSTANTIATE_TEST(WebGLCompatibilityTest,
                         ES2_D3D9(),
                         ES2_D3D11(),
                         ES3_D3D11(),
                         ES2_D3D11_FL9_3(),
                         ES2_OPENGL(),
                         ES3_OPENGL(),
                         ES2_OPENGLES(),
                         ES3_OPENGLES());
  
  }  // namespace
  

Download