Switch to standard integer types in gpu/.

gpu/command_buffer/tests/gl_readback_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 <stddef.h>
+#include <stdint.h>
 
 #include <cmath>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.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"
 
@@ skipping 57 matching lines @@
   EXPECT_EQ(data[0], 0);   // red
   EXPECT_EQ(data[1], 0);   // green
   EXPECT_EQ(data[2], 255); // blue
   glUnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
   glBindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
   glDeleteBuffers(1, &b);
   glDeleteQueriesEXT(1, &q);
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
 
-static float HalfToFloat32(uint16 value) {
-  int32 s = (value >> 15) & 0x00000001;
-  int32 e = (value >> 10) & 0x0000001f;
-  int32 m =  value        & 0x000003ff;
+static float HalfToFloat32(uint16_t value) {
+  int32_t s = (value >> 15) & 0x00000001;
+  int32_t e = (value >> 10) & 0x0000001f;
+  int32_t m = value & 0x000003ff;
 
   if (e == 0) {
     if (m == 0) {
-      uint32 result = s << 31;
+      uint32_t result = s << 31;
       return bit_cast<float>(result);
     } else {
       while (!(m & 0x00000400)) {
         m <<= 1;
         e -=  1;
       }
 
       e += 1;
       m &= ~0x00000400;
     }
   } else if (e == 31) {
     if (m == 0) {
-      uint32 result = (s << 31) | 0x7f800000;
+      uint32_t result = (s << 31) | 0x7f800000;
       return bit_cast<float>(result);
     } else {
-      uint32 result = (s << 31) | 0x7f800000 | (m << 13);
+      uint32_t result = (s << 31) | 0x7f800000 | (m << 13);
       return bit_cast<float>(result);
     }
   }
 
   e = e + (127 - 15);
   m = m << 13;
 
-  uint32 result = (s << 31) | (e << 23) | m;
+  uint32_t result = (s << 31) | (e << 23) | m;
   return bit_cast<float>(result);
 }
 
 static GLuint CompileShader(GLenum type, const char *data) {
   const char *shaderStrings[1] = { data };
 
   GLuint shader = glCreateShader(type);
   glShaderSource(shader, 1, shaderStrings, NULL);
   glCompileShader(shader);
 
   GLint compile_status = 0;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (compile_status != GL_TRUE) {
     glDeleteShader(shader);
     shader = 0;
   }
 
   return shader;
 }
 
 TEST_F(GLReadbackTest, ReadPixelsFloat) {
   const GLsizei kTextureSize = 4;
   const GLfloat kDrawColor[4] = { -10.9f, 0.5f, 10.5f, 100.12f };
   const GLfloat kEpsilon = 0.01f;
 
   struct TestFormat {
     GLint format;
     GLint type;
-    uint32 comp_count;
+    uint32_t comp_count;
   };
   TestFormat test_formats[4];
   size_t test_count = 0;
   const char *extensions = reinterpret_cast<const char*>(
       glGetString(GL_EXTENSIONS));
   if (strstr(extensions, "GL_OES_texture_half_float") != NULL) {
       TestFormat rgb16f = { GL_RGB, GL_HALF_FLOAT_OES, 3 };
       test_formats[test_count++] = rgb16f;
 
       TestFormat rgba16f = { GL_RGBA, GL_HALF_FLOAT_OES, 4 };
@@ skipping 93 matching lines @@
       GLint read_type = 0;
       glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &read_type);
 
       EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
 
       if ((read_format == GL_RGB || read_format == GL_RGBA) &&
           read_type == test_formats[ii].type) {
         glClear(GL_COLOR_BUFFER_BIT);
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-        uint32 read_comp_count = 0;
+        uint32_t read_comp_count = 0;
         switch (read_format) {
           case GL_RGB:
             read_comp_count = 3;
             break;
           case GL_RGBA:
             read_comp_count = 4;
             break;
         }
 
         switch (read_type) {
           case GL_HALF_FLOAT_OES: {
             scoped_ptr<GLushort[]> buf(
                 new GLushort[kTextureSize * kTextureSize * read_comp_count]);
             glReadPixels(
                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
                 buf.get());
             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
-            for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
-              for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
+            for (uint32_t jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
+              for (uint32_t kk = 0; kk < test_formats[ii].comp_count; ++kk) {
                 EXPECT_LE(
                     std::abs(HalfToFloat32(buf[jj * read_comp_count + kk]) -
                         kDrawColor[kk]),
                     std::abs(kDrawColor[kk] * kEpsilon));
               }
             }
             break;
           }
           case GL_FLOAT: {
             scoped_ptr<GLfloat[]> buf(
                 new GLfloat[kTextureSize * kTextureSize * read_comp_count]);
             glReadPixels(
                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
                 buf.get());
             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
-            for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
-              for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
+            for (uint32_t jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
+              for (uint32_t kk = 0; kk < test_formats[ii].comp_count; ++kk) {
                 EXPECT_LE(
                     std::abs(buf[jj * read_comp_count + kk] - kDrawColor[kk]),
                     std::abs(kDrawColor[kk] * kEpsilon));
               }
             }
             break;
           }
         }
       }
     }
 
     glDeleteFramebuffers(1, &framebuffer);
     glDeleteTextures(1, &texture_id);
   }
 
   glDeleteBuffers(1, &vertex_buffer);
   glDeleteProgram(program);
 }
 
 }  // namespace gpu