Switch to standard integer types in gpu/.

gpu/command_buffer/tests/gl_chromium_path_rendering_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.
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <cmath>
 
 #include "base/command_line.h"
 #include "gpu/command_buffer/service/gpu_switches.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
@@ skipping 123 matching lines @@
     glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM,
                              GL_ROUND_CHROMIUM);
     glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM,
                              GL_SQUARE_CHROMIUM);
   }
 
   void VerifyTestPatternFill(float x, float y) {
     SCOPED_TRACE(testing::Message() << "Verifying fill at " << x << "," << y);
     static const float kFillCoords[] = {55.0f, 54.0f, 50.0f,
                                         28.0f, 66.0f, 63.0f};
-    static const uint8 kBlue[] = {0, 0, 255, 255};
+    static const uint8_t kBlue[] = {0, 0, 255, 255};
 
     for (size_t i = 0; i < arraysize(kFillCoords); i += 2) {
       float fx = kFillCoords[i];
       float fy = kFillCoords[i + 1];
 
       EXPECT_TRUE(GLTestHelper::CheckPixels(x + fx, y + fy, 1, 1, 0, kBlue));
     }
   }
 
   void VerifyTestPatternBg(float x, float y) {
     SCOPED_TRACE(testing::Message() << "Verifying background at " << x << ","
                                     << y);
     const float kBackgroundCoords[] = {80.0f, 80.0f, 20.0f, 20.0f, 90.0f, 1.0f};
-    const uint8 kExpectedColor[] = {0, 0, 0, 0};
+    const uint8_t kExpectedColor[] = {0, 0, 0, 0};
 
     for (size_t i = 0; i < arraysize(kBackgroundCoords); i += 2) {
       float bx = kBackgroundCoords[i];
       float by = kBackgroundCoords[i + 1];
 
       EXPECT_TRUE(
           GLTestHelper::CheckPixels(x + bx, y + by, 1, 1, 0, kExpectedColor));
     }
   }
 
   void VerifyTestPatternStroke(float x, float y) {
     SCOPED_TRACE(testing::Message() << "Verifying stroke at " << x << "," << y);
     // Inside the stroke we should have green.
-    const uint8 kGreen[] = {0, 255, 0, 255};
+    const uint8_t kGreen[] = {0, 255, 0, 255};
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 50, y + 53, 1, 1, 0, kGreen));
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 26, y + 76, 1, 1, 0, kGreen));
 
     // Outside the path we should have black.
-    const uint8 black[] = {0, 0, 0, 0};
+    const uint8_t black[] = {0, 0, 0, 0};
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 10, y + 10, 1, 1, 0, black));
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 80, y + 80, 1, 1, 0, black));
   }
   static const GLfloat kProjectionMatrix[16];
   GLint color_loc_;
 };
 
 const GLfloat CHROMIUMPathRenderingDrawTest::kProjectionMatrix[16] = {
     2.0f / (CHROMIUMPathRenderingTest::kResolution - 1),
     0.0f,
@@ skipping 252 matching lines @@
   // Document a bit of an inconsistency: "clearing" a used path name causes
   // path to acquire state.
   path = glGenPathsCHROMIUM(1);
   EXPECT_FALSE(glIsPathCHROMIUM(path));
   glPathCommandsCHROMIUM(path, 0, NULL, 0, GL_FLOAT, NULL);
   EXPECT_TRUE(glIsPathCHROMIUM(path));  // The surprise.
   glDeletePathsCHROMIUM(path, 1);
 
   // Make sure nothing got drawn by the drawing commands that should not produce
   // anything.
-  const uint8 black[] = {0, 0, 0, 0};
+  const uint8_t black[] = {0, 0, 0, 0};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, kResolution, kResolution, 0, black));
 }
 
 TEST_F(CHROMIUMPathRenderingTest, TestUnnamedPathsErrors) {
   if (!IsApplicable())
     return;
 
   // Unnamed paths: Trying to create a path object with non-existing path name
   // produces error.  (Not a error in real NV_path_rendering).
@@ skipping 604 matching lines @@
   for (int j = 0; j < kTestRows; ++j) {
     for (int i = 0; i < kTestColumns; ++i) {
       for (size_t k = 0; k < arraysize(kFillCoords); k += 2) {
         SCOPED_TRACE(testing::Message() << "Verifying fill for shape " << i
                                         << ", " << j << " coord " << k);
         float fx = kFillCoords[k];
         float fy = kFillCoords[k + 1];
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4];
+        uint8_t color[4];
         color[0] = roundf((px + fx) / kResolution * 255.0f);
         color[1] = roundf((py + fy) / kResolution * 255.0f);
         color[2] = 0;
         color[3] = 255;
 
         EXPECT_TRUE(
             GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
       }
     }
   }
@@ skipping 79 matching lines @@
   for (int j = 0; j < kTestRows; ++j) {
     for (int i = 0; i < kTestColumns; ++i) {
       for (size_t k = 0; k < arraysize(kFillCoords); k += 2) {
         SCOPED_TRACE(testing::Message() << "Verifying fill for shape " << i
                                         << ", " << j << " coord " << k);
         float fx = kFillCoords[k];
         float fy = kFillCoords[k + 1];
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4];
+        uint8_t color[4];
         color[0] = roundf(fx / kShapeWidth * 255.0f);
         color[1] = roundf(fy / kShapeHeight * 255.0f);
         color[2] = 0;
         color[3] = 255;
 
         EXPECT_TRUE(
             GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
       }
     }
   }
@@ skipping 382 matching lines @@
     for (int j = 0; j < kTestRows; ++j) {
       for (int i = 0; i < kTestColumns; ++i) {
         for (size_t k = 0; k < arraysize(kFillCoords); k += 2) {
           SCOPED_TRACE(testing::Message() << "Verifying fill for shape " << i
                                           << ", " << j << " coord " << k);
           float fx = kFillCoords[k];
           float fy = kFillCoords[k + 1];
           float px = i * kShapeWidth;
           float py = j * kShapeHeight;
 
-          uint8 color[4] = {0, 255, 0, 255};
+          uint8_t color[4] = {0, 255, 0, 255};
 
           EXPECT_TRUE(
               GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
         }
       }
     }
     TeardownStateForTestPattern();
   }
 
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
@@ skipping 73 matching lines @@
   for (int j = 0; j < kTestRows; ++j) {
     for (int i = 0; i < kTestColumns; ++i) {
       for (size_t k = 0; k < arraysize(kFillCoords); k += 2) {
         SCOPED_TRACE(testing::Message() << "Verifying fill for shape " << i
                                         << ", " << j << " coord " << k);
         float fx = kFillCoords[k];
         float fy = kFillCoords[k + 1];
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4] = {0, 255, 0, 255};
+        uint8_t color[4] = {0, 255, 0, 255};
 
         EXPECT_TRUE(
             GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
       }
     }
   }
 
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   TeardownStateForTestPattern();
 }
@@ skipping 81 matching lines @@
   glProgramPathFragmentInputGenCHROMIUM(program, kUnboundLocation,
                                         GL_CONSTANT_CHROMIUM, 4, kColor);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
 }
 
 INSTANTIATE_TEST_CASE_P(WithAndWithoutShaderNameMapping,
                         CHROMIUMPathRenderingWithTexturingTest,
                         ::testing::Bool());
 
 }  // namespace gpu