Teach GPU command buffer whether a context is webgl.

gpu/command_buffer/tests/gl_program_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define SHADER(Src) #Src
 
 namespace gpu {
 
 class GLProgramTest : public testing::Test {
  protected:
   void SetUp() override { gl_.Initialize(GLManager::Options()); }
 
   void TearDown() override { gl_.Destroy(); }
 
   GLManager gl_;
 };
 
+class WebGLProgramTest : public GLProgramTest {
+ protected:
+  void SetUp() override {
+    GLManager::Options options;
+    options.webgl_version = 1;
+    gl_.Initialize(options);
+  }
+};
+
 TEST_F(GLProgramTest, GetSetUniform) {
   static const char* v_shader_str = SHADER(
       attribute vec4 a_vertex;
       attribute vec3 a_normal;
 
       uniform mat4 u_modelViewProjMatrix;
 
       struct MyStruct
       {
         int x;
@@ skipping 144 matching lines @@
 
   // We specifically don't call UseProgram again.
   GLuint position_loc = glGetAttribLocation(program, "a_position");
   GLTestHelper::SetupUnitQuad(position_loc);
   glDrawArrays(GL_TRIANGLES, 0, 6);
   uint8 expected_color[] = { 0, 0, 255, 255, };
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color));
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
 
-TEST_F(GLProgramTest, DeferCompileWithExt) {
+TEST_F(WebGLProgramTest, DeferCompileWithExt) {
   // This test must have extensions enabled.
   gles2::ContextGroup* context_group = gl_.decoder()->GetContextGroup();
   gles2::FeatureInfo* feature_info = context_group->feature_info();
   const gles2::FeatureInfo::FeatureFlags& flags = feature_info->feature_flags();
   if (!flags.ext_frag_depth)
     return;
 
   static const char* v_shdr_str = R"(
       attribute vec4 vPosition;
       void main()
       {
         gl_Position = vPosition;
       }
   )";
   static const char* f_shdr_str = R"(
       #extension GL_EXT_frag_depth : enable
       void main()
       {
         gl_FragDepthEXT = 1.0;
       }
   )";
 
-  // First compile and link to be shader compiles.
-  GLuint vs_good = GLTestHelper::CompileShader(GL_VERTEX_SHADER, v_shdr_str);
-  GLuint fs_good = GLTestHelper::CompileShader(GL_FRAGMENT_SHADER, f_shdr_str);
-  GLuint program_good = GLTestHelper::LinkProgram(vs_good, fs_good);
-  GLint linked_good = 0;
-  glGetProgramiv(program_good, GL_LINK_STATUS, &linked_good);
-  EXPECT_NE(0, linked_good);
-
-  // Disable extension and be sure shader no longer compiles.
-  ASSERT_TRUE(glEnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation"));
+  // Extension is disabled by default and be sure shader does not compile.
   GLuint vs_bad = GLTestHelper::CompileShader(GL_VERTEX_SHADER, v_shdr_str);
   GLuint fs_bad = GLTestHelper::CompileShader(GL_FRAGMENT_SHADER, f_shdr_str);
   GLuint program_bad = GLTestHelper::LinkProgram(vs_bad, fs_bad);
   GLint linked_bad = 0;
   glGetProgramiv(program_bad, GL_LINK_STATUS, &linked_bad);
   EXPECT_EQ(0, linked_bad);
 
-  // Relinking good compilations without extension disabled should still link.
-  GLuint program_defer_good = GLTestHelper::LinkProgram(vs_good, fs_good);
-  GLint linked_defer_good = 0;
-  glGetProgramiv(program_defer_good, GL_LINK_STATUS, &linked_defer_good);
-  EXPECT_NE(0, linked_defer_good);
-
   // linking bad compilations with extension enabled should still not link.
-  GLuint vs_bad2 = GLTestHelper::CompileShader(GL_VERTEX_SHADER, v_shdr_str);
-  GLuint fs_bad2 = GLTestHelper::CompileShader(GL_FRAGMENT_SHADER, f_shdr_str);
   glRequestExtensionCHROMIUM("GL_EXT_frag_depth");
-  GLuint program_bad2 = GLTestHelper::LinkProgram(vs_bad2, fs_bad2);
-  GLint linked_bad2 = 0;
-  glGetProgramiv(program_bad2, GL_LINK_STATUS, &linked_bad2);
-  EXPECT_EQ(0, linked_bad2);
+  program_bad = GLTestHelper::LinkProgram(vs_bad, fs_bad);
+  linked_bad = 0;
+  glGetProgramiv(program_bad, GL_LINK_STATUS, &linked_bad);
+  EXPECT_EQ(0, linked_bad);
 
   // Be sure extension was actually turned on by recompiling.
-  GLuint vs_good2 = GLTestHelper::LoadShader(GL_VERTEX_SHADER, v_shdr_str);
-  GLuint fs_good2 = GLTestHelper::LoadShader(GL_FRAGMENT_SHADER, f_shdr_str);
-  GLuint program_good2 = GLTestHelper::SetupProgram(vs_good2, fs_good2);
-  EXPECT_NE(0u, program_good2);
+  GLuint vs_good = GLTestHelper::LoadShader(GL_VERTEX_SHADER, v_shdr_str);
+  GLuint fs_good = GLTestHelper::LoadShader(GL_FRAGMENT_SHADER, f_shdr_str);
+  GLuint program_good = GLTestHelper::SetupProgram(vs_good, fs_good);
+  EXPECT_NE(0u, program_good);
 }
 
 TEST_F(GLProgramTest, DeleteAttachedShaderLinks) {
   static const char* v_shdr_str = R"(
       attribute vec4 vPosition;
       void main()
       {
         gl_Position = vPosition;
       }
   )";
@@ skipping 17 matching lines @@
 
   glLinkProgram(program);
 
   GLint linked = 0;
   glGetProgramiv(program, GL_LINK_STATUS, &linked);
   EXPECT_NE(0, linked);
 }
 
 }  // namespace gpu