Switch to standard integer types in gpu/.

gpu/command_buffer/tests/gl_ext_multisample_compatibility_unittest.cc

 // Copyright (c) 2015 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 <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "gpu/config/gpu_test_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define SHADER0(Src) #Src
 
 namespace gpu {
 
@@ skipping 128 matching lines @@
   }
 
   static const float kBlue[] = {0.0f, 0.0f, 1.0f, 1.0f};
   static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
   static const float kRed[] = {1.0f, 0.0f, 0.0f, 1.0f};
 
   // Different drivers seem to behave differently with respect to resulting
   // values. These might be due to different MSAA sample counts causing
   // different samples to hit.  Other option is driver bugs. Just test that
   // disabling multisample causes a difference.
-  scoped_ptr<uint8[]> results[3];
+  scoped_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
   for (int pass = 0; pass < 3; pass++) {
     PrepareForDraw();
     // Green: from top right to bottom left.
     glUniform4fv(color_loc_, 1, kGreen);
     glDrawArrays(GL_TRIANGLES, 0, 3);
 
     // Blue: from top left to bottom right.
     glUniform4fv(color_loc_, 1, kBlue);
     glDrawArrays(GL_TRIANGLES, 3, 3);
 
     // Red, with and without MSAA: from bottom left to top right.
     if (pass == 1) {
       glDisable(GL_MULTISAMPLE_EXT);
     }
     glUniform4fv(color_loc_, 1, kRed);
     glDrawArrays(GL_TRIANGLES, 6, 3);
     if (pass == 1) {
       glEnable(GL_MULTISAMPLE_EXT);
     }
     PrepareForVerify();
-    results[pass].reset(new uint8[kResultSize]);
+    results[pass].reset(new uint8_t[kResultSize]);
     memset(results[pass].get(), GLTestHelper::kCheckClearValue, kResultSize);
     glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                  results[pass].get());
   }
   EXPECT_NE(0, memcmp(results[0].get(), results[1].get(), kResultSize));
   // Verify that rendering is deterministic, so that the pass above does not
   // come from non-deterministic rendering.
   EXPECT_EQ(0, memcmp(results[0].get(), results[2].get(), kResultSize));
 }
 
 TEST_F(EXTMultisampleCompatibilityTest, DrawAlphaOneAndResolve) {
   // Test that enabling GL_SAMPLE_ALPHA_TO_ONE_EXT affects rendering.
   if (!IsApplicable()) {
     return;
   }
 
   // SAMPLE_ALPHA_TO_ONE is specified to transform alpha values of
   // covered samples to 1.0. In order to detect it, we use non-1.0
   // alpha.
   static const float kBlue[] = {0.0f, 0.0f, 1.0f, 0.5f};
   static const float kGreen[] = {0.0f, 1.0f, 0.0f, 0.5f};
   static const float kRed[] = {1.0f, 0.0f, 0.0f, 0.5f};
 
   // Different drivers seem to behave differently with respect to resulting
   // alpha value. These might be due to different MSAA sample counts causing
   // different samples to hit.  Other option is driver bugs. Testing exact or
   // even approximate sample values is not that easy.  Thus, just test
   // representative positions which have fractional pixels, inspecting that
   // normal rendering is different to SAMPLE_ALPHA_TO_ONE rendering.
-  scoped_ptr<uint8[]> results[3];
+  scoped_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
 
   for (int pass = 0; pass < 3; ++pass) {
     PrepareForDraw();
     if (pass == 1) {
       glEnable(GL_SAMPLE_ALPHA_TO_ONE_EXT);
     }
     glEnable(GL_MULTISAMPLE_EXT);
     glUniform4fv(color_loc_, 1, kGreen);
     glDrawArrays(GL_TRIANGLES, 0, 3);
 
     glUniform4fv(color_loc_, 1, kBlue);
     glDrawArrays(GL_TRIANGLES, 3, 3);
 
     glDisable(GL_MULTISAMPLE_EXT);
     glUniform4fv(color_loc_, 1, kRed);
     glDrawArrays(GL_TRIANGLES, 6, 3);
 
     PrepareForVerify();
-    results[pass].reset(new uint8[kResultSize]);
+    results[pass].reset(new uint8_t[kResultSize]);
     memset(results[pass].get(), GLTestHelper::kCheckClearValue, kResultSize);
     glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                  results[pass].get());
     if (pass == 1) {
       glDisable(GL_SAMPLE_ALPHA_TO_ONE_EXT);
     }
   }
   EXPECT_NE(0, memcmp(results[0].get(), results[1].get(), kResultSize));
   // Verify that rendering is deterministic, so that the pass above does not
   // come from non-deterministic rendering.
   EXPECT_EQ(0, memcmp(results[0].get(), results[2].get(), kResultSize));
 }
 
 }  // namespace gpu