Refactor DrawTextureQuad and CheckPixels in gl_tests util

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc

 // Copyright (c) 2012 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.
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 325 matching lines @@
   // Check the FB is still bound.
   GLint value = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
   GLuint fb_id = value;
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels, nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_P(GLCopyTextureCHROMIUMES3Test, FormatCombinations) {
   if (ShouldSkipTest())
     return;
   CopyType copy_type = GetParam();
 
   struct FormatType {
     GLenum internal_format;
@@ skipping 130 matching lines @@
       glBindTexture(GL_TEXTURE_2D, texture);
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
       CreateBackingForTexture(GL_TEXTURE_2D, kWidth, kHeight);
       glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                              GL_TEXTURE_2D, texture, 0);
       EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
                 glCheckFramebufferStatus(GL_FRAMEBUFFER));
       glViewport(0, 0, kWidth, kHeight);
 
+      glBindTexture(GL_TEXTURE_2D, textures_[1]);
       std::string fragment_shader_source =
           GetFragmentShaderSource(dest_format_type.internal_format);
-      GLuint program = GLTestHelper::LoadProgram(
-          kSimpleVertexShaderES3, fragment_shader_source.c_str());
-      EXPECT_NE(program, 0u);
-      GLint position_loc = glGetAttribLocation(program, "a_position");
-      GLint texture_loc = glGetUniformLocation(program, "u_texture");
-      ASSERT_NE(position_loc, -1);
-      ASSERT_NE(texture_loc, -1);
-      glUseProgram(program);
+      GLTestHelper::DrawTextureQuad(kSimpleVertexShaderES3,
+                                    fragment_shader_source.c_str(),
+                                    "a_position", "u_texture");
 
-      GLuint vbo = GLTestHelper::SetupUnitQuad(position_loc);
-      ASSERT_NE(vbo, 0u);
-
-      glActiveTexture(GL_TEXTURE0);
-      glBindTexture(GL_TEXTURE_2D, textures_[1]);
-
-      glDrawArrays(GL_TRIANGLES, 0, 6);
-
+      uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
+      EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, kWidth, kHeight, tolerance,
+                                            expected_color, mask))
+          << " src_internal_format: "
+          << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
+          << " dest_internal_format: "
+          << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
-      GLsizei size = kWidth * kHeight * 4;
-      std::unique_ptr<uint8_t[]> result(new uint8_t[size]);
-      glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
-                   result.get());
-      uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
-      for (GLint yy = 0; yy < kHeight; ++yy) {
-        for (GLint xx = 0; xx < kWidth; ++xx) {
-          int offset = yy * kWidth * 4 + xx * 4;
-          for (int jj = 0; jj < 4; ++jj) {
-            uint8_t actual = result[offset + jj];
-            uint8_t expected = expected_color[jj];
-            int diff = actual - expected;
-            diff = diff < 0 ? -diff : diff;
-            if (mask[jj] && diff > tolerance) {
-              EXPECT_EQ(expected, actual)
-                  << " at " << xx << ", " << yy << " channel " << jj
-                  << " src_internal_format: "
-                  << gles2::GLES2Util::GetStringEnum(
-                         src_format_type.internal_format)
-                  << " dest_internal_format: "
-                  << gles2::GLES2Util::GetStringEnum(
-                         dest_format_type.internal_format);
-            }
-          }
-        }
-      }
-
       glDeleteTextures(1, &texture);
       glDeleteFramebuffers(1, &framebuffer);
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
@@ skipping 37 matching lines @@
         // Check the FB is still bound.
         GLint value = 0;
         glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
         GLuint fb_id = value;
         EXPECT_EQ(framebuffer_id_, fb_id);
 
         // Check that FB is complete.
         EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
                   glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
-        GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
+        GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels, nullptr);
         EXPECT_TRUE(GL_NO_ERROR == glGetError());
       }
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormat) {
   CopyType copy_type = GetParam();
   GLint src_formats[] = {GL_ALPHA,     GL_RGB,             GL_RGBA,
                          GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_BGRA_EXT};
@@ skipping 125 matching lines @@
   // Check the FB is still bound.
   GLint value = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
   GLuint fb_id = value;
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
-  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, &pixels[12]);
+  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, &pixels[12], nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 namespace {
 
 void glEnableDisable(GLint param, GLboolean value) {
   if (value)
     glEnable(param);
   else
     glDisable(param);
@@ skipping 154 matching lines @@
                          texture_id, 0);
   glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                             GL_RENDERBUFFER, renderbuffer_id);
   EXPECT_TRUE(
       GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   // Test that we can write to the bound framebuffer
   uint8_t expected_color[4] = {255u, 255u, 0, 255u};
   glClearColor(1.0, 1.0, 0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color, nullptr);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
                              0, 1, 1, false, false, false);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   EXPECT_TRUE(glIsFramebuffer(framebuffer_id));
 
   // Ensure that reading from the framebuffer produces correct pixels.
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color, nullptr);
 
   uint8_t expected_color2[4] = {255u, 0, 255u, 255u};
   glClearColor(1.0, 0, 1.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color2);
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color2, nullptr);
 
   GLint bound_fbo = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo);
   EXPECT_EQ(framebuffer_id, static_cast<GLuint>(bound_fbo));
 
   GLint fbo_params = 0;
   glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                         GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
                                         &fbo_params);
   EXPECT_EQ(GL_TEXTURE, fbo_params);
@@ skipping 66 matching lines @@
   GLTestHelper::SetupUnitQuad(position_loc);
 
   // test using program before
   uint8_t expected[] = {
       0, 255, 0, 255,
   };
   uint8_t zero[] = {
       0, 0, 0, 0,
   };
   glClear(GL_COLOR_BUFFER_BIT);
-  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero, nullptr));
   glDrawArrays(GL_TRIANGLES, 0, 6);
-  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected, nullptr));
 
   // Call copyTextureCHROMIUM
   uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
     glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
                              0, 1, 1, false, false, false);
   }
 
   // test using program after
   glClear(GL_COLOR_BUFFER_BIT);
-  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero, nullptr));
   glDrawArrays(GL_TRIANGLES, 0, 6);
-  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected, nullptr));
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   gl2.MakeCurrent();
   gl2.Destroy();
   gl_.MakeCurrent();
 }
 
 // Test that glCopyTextureCHROMIUM doesn't leak uninitialized textures.
 TEST_P(GLCopyTextureCHROMIUMTest, UninitializedSource) {
@@ skipping 145 matching lines @@
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   uint8_t transparent[1 * 4] = {0u, 0u, 0u, 0u};
   uint8_t red[1 * 4] = {255u, 0u, 0u, 255u};
   uint8_t green[1 * 4] = {0u, 255u, 0u, 255u};
   uint8_t blue[1 * 4] = {0u, 0u, 255u, 255u};
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent);
-  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red);
-  GLTestHelper::CheckPixels(1, 0, 1, 1, 0, green);
-  GLTestHelper::CheckPixels(0, 1, 1, 1, 0, blue);
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent, nullptr);
+  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red, nullptr);
+  GLTestHelper::CheckPixels(1, 0, 1, 1, 0, green, nullptr);
+  GLTestHelper::CheckPixels(0, 1, 1, 1, 0, blue, nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopyTextureBetweenTexture2DAndRectangleArb) {
   if (!GLTestHelper::HasExtension("GL_ARB_texture_rectangle")) {
     LOG(INFO) <<
         "GL_ARB_texture_rectangle not supported. Skipping test...";
     return;
   }
 
@@ skipping 60 matching lines @@
       glClear(GL_COLOR_BUFFER_BIT);
       glCopySubTextureCHROMIUM(textures_[0], textures_[1], copy_region_x,
                                copy_region_y, 13, 6, copy_region_width,
                                copy_region_height, false, false, false);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
       for (GLint x = 0; x < dest_width; ++x) {
         for (GLint y = 0; y < dest_height; ++y) {
           if (x < copy_region_x || x >= copy_region_x + copy_region_width ||
               y < copy_region_y || y >= copy_region_y + copy_region_height) {
-            GLTestHelper::CheckPixels(x, y, 1, 1, 0, grey);
+            GLTestHelper::CheckPixels(x, y, 1, 1, 0, grey, nullptr);
             continue;
           }
 
           uint8_t* expected_color;
           if (x < copy_region_x + 2) {
             expected_color = y < copy_region_y + 1 ? red : green;
           } else {
             expected_color = y < copy_region_y + 1 ? blue : white;
           }
-          GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color);
+          GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color, nullptr);
         }
       }
     }
   }
 }
 
 }  // namespace gpu