Switch to standard integer types in gpu/.

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>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.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"
 
 namespace gpu {
 
 namespace {
 enum CopyType { TexImage, TexSubImage };
@@ skipping 38 matching lines @@
   GLuint framebuffer_id_;
 };
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMTest,
                         ::testing::ValuesIn(kCopyTypes));
 
 // Test to ensure that the basic functionality of the extension works.
 TEST_P(GLCopyTextureCHROMIUMTest, Basic) {
   CopyType copy_type = GetParam();
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  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(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
@@ skipping 19 matching lines @@
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
     LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test...";
     return;
   }
   CopyType copy_type = GetParam();
 
-  uint8 pixels[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 1, 1);
   glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
                   pixels);
 
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 1, 1);
   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                          textures_[1], 0);
@@ skipping 82 matching lines @@
                                0, 0, 1, 1, false, false, false);
     }
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
 }
 
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
-  uint8 pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
-                         255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
+  uint8_t pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
+                           255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_BGRA_EXT,
                1,
@@ skipping 48 matching lines @@
   else
     glDisable(param);
 }
 
 }  // unnamed namespace
 
 // Validate that some basic GL state is not touched upon execution of
 // the extension.
 TEST_P(GLCopyTextureCHROMIUMTest, BasicStatePreservation) {
   CopyType copy_type = GetParam();
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
   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 == TexSubImage) {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
@@ skipping 45 matching lines @@
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 };
 
 // Verify that invocation of the extension does not modify the bound
 // texture state.
 TEST_P(GLCopyTextureCHROMIUMTest, TextureStatePreserved) {
   CopyType copy_type = GetParam();
   // Setup the texture used for the extension invocation.
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  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 == TexSubImage) {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
   }
 
@@ skipping 33 matching lines @@
   glDeleteTextures(2, texture_ids);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 // Verify that invocation of the extension does not perturb the currently
 // bound FBO state.
 TEST_P(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
   CopyType copy_type = GetParam();
   // Setup the texture used for the extension invocation.
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  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 == TexSubImage) {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
   }
 
@@ skipping 12 matching lines @@
   glGenFramebuffers(1, &framebuffer_id);
   glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                          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 expected_color[4] = { 255u, 255u, 0, 255u };
+  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);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glCopySubTextureCHROMIUM(GL_TEXTURE_2D, 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);
 
-  uint8 expected_color2[4] = { 255u, 0, 255u, 255u };
+  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);
 
   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,
@@ skipping 62 matching lines @@
   glDeleteProgram(program);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
   glFlush();
 
   // Program should still be usable on this context.
   gl_.MakeCurrent();
 
   GLTestHelper::SetupUnitQuad(position_loc);
 
   // test using program before
-  uint8 expected[] = { 0, 255, 0, 255, };
-  uint8 zero[] = { 0, 0, 0, 0, };
+  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));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
 
   // Call copyTextureCHROMIUM
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  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(GL_TEXTURE_2D, 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);
@@ skipping 27 matching lines @@
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
                  GL_UNSIGNED_BYTE, nullptr);
     glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
                              0, kWidth, kHeight, false, false, false);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
-  uint8 pixels[kHeight][kWidth][4] = {{{1}}};
+  uint8_t pixels[kHeight][kWidth][4] = {{{1}}};
   glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   for (int x = 0; x < kWidth; ++x) {
     for (int y = 0; y < kHeight; ++y) {
       EXPECT_EQ(0, pixels[y][x][0]);
       EXPECT_EQ(0, pixels[y][x][1]);
       EXPECT_EQ(0, pixels[y][x][2]);
       EXPECT_EQ(0, pixels[y][x][3]);
     }
   }
 
@@ skipping 80 matching lines @@
   glCopySubTextureCHROMIUM(GL_TEXTURE_2D, 99995, 99996, 1, 1, 0, 0, 1, 1, false,
                            false, false);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
   glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1, 0,
                            0, 1, 1, false, false, false);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
-  uint8 rgba_pixels[4 * 4] = {255u,
-                              0u,
-                              0u,
-                              255u,
-                              0u,
-                              255u,
-                              0u,
-                              255u,
-                              0u,
-                              0u,
-                              255u,
-                              255u,
-                              0u,
-                              0u,
-                              0u,
-                              255u};
+  uint8_t rgba_pixels[4 * 4] = {255u, 0u, 0u,   255u, 0u, 255u, 0u, 255u,
+                                0u,   0u, 255u, 255u, 0u, 0u,   0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                rgba_pixels);
 
-  uint8 transparent_pixels[4 * 4] = {
-      0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
+  uint8_t transparent_pixels[4 * 4] = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                                       0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                transparent_pixels);
 
   glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1, 0,
                            0, 1, 1, false, false, false);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
   glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 0, 1,
                            0, 1, 1, false, false, false);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
   glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 1, 0,
                            1, 1, 1, false, false, false);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
   // 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));
 
-  uint8 transparent[1 * 4] = {0u, 0u, 0u, 0u};
-  uint8 red[1 * 4] = {255u, 0u, 0u, 255u};
-  uint8 green[1 * 4] = {0u, 255u, 0u, 255u};
-  uint8 blue[1 * 4] = {0u, 0u, 255u, 255u};
+  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);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 }  // namespace gpu