Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/gl_surface_mock.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
 
@@ skipping 380 matching lines @@
   ReadPixelsEmulator(GLsizei width,
                      GLsizei height,
                      GLint bytes_per_pixel,
                      const void* src_pixels,
                      const void* expected_pixels,
                      GLint pack_alignment)
       : width_(width),
         height_(height),
         pack_alignment_(pack_alignment),
         bytes_per_pixel_(bytes_per_pixel),
-        src_pixels_(reinterpret_cast<const int8*>(src_pixels)),
-        expected_pixels_(reinterpret_cast<const int8*>(expected_pixels)) {}
+        src_pixels_(reinterpret_cast<const int8_t*>(src_pixels)),
+        expected_pixels_(reinterpret_cast<const int8_t*>(expected_pixels)) {}
 
   void ReadPixels(GLint x,
                   GLint y,
                   GLsizei width,
                   GLsizei height,
                   GLenum format,
                   GLenum type,
                   void* pixels) const {
     DCHECK_GE(x, 0);
     DCHECK_GE(y, 0);
     DCHECK_LE(x + width, width_);
     DCHECK_LE(y + height, height_);
     for (GLint yy = 0; yy < height; ++yy) {
-      const int8* src = GetPixelAddress(src_pixels_, x, y + yy);
+      const int8_t* src = GetPixelAddress(src_pixels_, x, y + yy);
       const void* dst = ComputePackAlignmentAddress(0, yy, width, pixels);
       memcpy(const_cast<void*>(dst), src, width * bytes_per_pixel_);
     }
   }
 
   bool CompareRowSegment(GLint x,
                          GLint y,
                          GLsizei width,
                          const void* data) const {
     DCHECK(x + width <= width_ || width == 0);
     return memcmp(data,
                   GetPixelAddress(expected_pixels_, x, y),
                   width * bytes_per_pixel_) == 0;
   }
 
   // Helper to compute address of pixel in pack aligned data.
   const void* ComputePackAlignmentAddress(GLint x,
                                           GLint y,
                                           GLsizei width,
                                           const void* address) const {
     GLint unpadded_row_size = ComputeImageDataSize(width, 1);
     GLint two_rows_size = ComputeImageDataSize(width, 2);
     GLsizei padded_row_size = two_rows_size - unpadded_row_size;
     GLint offset = y * padded_row_size + x * bytes_per_pixel_;
-    return static_cast<const int8*>(address) + offset;
+    return static_cast<const int8_t*>(address) + offset;
   }
 
   GLint ComputeImageDataSize(GLint width, GLint height) const {
     GLint row_size = width * bytes_per_pixel_;
     if (height > 1) {
       GLint temp = row_size + pack_alignment_ - 1;
       GLint padded_row_size = (temp / pack_alignment_) * pack_alignment_;
       GLint size_of_all_but_last_row = (height - 1) * padded_row_size;
       return size_of_all_but_last_row + row_size;
     } else {
       return height * row_size;
     }
   }
 
  private:
-  const int8* GetPixelAddress(const int8* base, GLint x, GLint y) const {
+  const int8_t* GetPixelAddress(const int8_t* base, GLint x, GLint y) const {
     return base + (width_ * y + x) * bytes_per_pixel_;
   }
 
   GLsizei width_;
   GLsizei height_;
   GLint pack_alignment_;
   GLint bytes_per_pixel_;
-  const int8* src_pixels_;
-  const int8* expected_pixels_;
+  const int8_t* src_pixels_;
+  const int8_t* expected_pixels_;
 };
 
 }  // anonymous namespace
 
 void GLES2DecoderTest::CheckReadPixelsOutOfRange(GLint in_read_x,
                                                  GLint in_read_y,
                                                  GLsizei in_read_width,
                                                  GLsizei in_read_height,
                                                  bool init) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
   const GLenum kFormat = GL_RGBA;
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 18, 19, 18, 255, 19, 12, 13, 255, 14, 18, 19, 255,
       18, 19, 13, 255, 29, 28, 23, 255, 22, 21, 22, 255, 21, 29, 28, 255,
       23, 22, 21, 255, 22, 21, 28, 255, 31, 34, 39, 255, 37, 32, 37, 255,
-      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255
-  };
+      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255};
 
   ClearSharedMemory();
 
   // We need to setup an FBO so we can know the max size that ReadPixels will
   // access
   if (init) {
     DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
     DoTexImage2D(GL_TEXTURE_2D,
                  0,
                  kFormat,
@@ skipping 15 matching lines @@
                            GL_NO_ERROR);
     EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
         .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
         .RetiresOnSaturation();
   }
 
   ReadPixelsEmulator emu(
       kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   // ReadPixels will be called for valid size only even though the command
   // is requesting a larger size.
   GLint read_x = std::max(0, in_read_x);
   GLint read_y = std::max(0, in_read_y);
   GLint read_end_x = std::max(0, std::min(kWidth, in_read_x + in_read_width));
@@ skipping 17 matching lines @@
            kFormat,
            GL_UNSIGNED_BYTE,
            pixels_shm_id,
            pixels_shm_offset,
            result_shm_id,
            result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   GLint unpadded_row_size = emu.ComputeImageDataSize(in_read_width, 1);
-  scoped_ptr<int8[]> zero(new int8[unpadded_row_size]);
-  scoped_ptr<int8[]> pack(new int8[kPackAlignment]);
+  scoped_ptr<int8_t[]> zero(new int8_t[unpadded_row_size]);
+  scoped_ptr<int8_t[]> pack(new int8_t[kPackAlignment]);
   memset(zero.get(), 0, unpadded_row_size);
   memset(pack.get(), kInitialMemoryValue, kPackAlignment);
   for (GLint yy = 0; yy < in_read_height; ++yy) {
-    const int8* row = static_cast<const int8*>(
+    const int8_t* row = static_cast<const int8_t*>(
         emu.ComputePackAlignmentAddress(0, yy, in_read_width, dest));
     GLint y = in_read_y + yy;
     if (y < 0 || y >= kHeight) {
       EXPECT_EQ(0, memcmp(zero.get(), row, unpadded_row_size));
     } else {
       // check off left.
       GLint num_left_pixels = std::max(-in_read_x, 0);
       GLint num_left_bytes = num_left_pixels * kBytesPerPixel;
       EXPECT_EQ(0, memcmp(zero.get(), row, num_left_bytes));
 
@@ skipping 24 matching lines @@
       }
     }
   }
 }
 
 TEST_P(GLES2DecoderTest, ReadPixels) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 18, 19, 18, 255, 19, 12, 13, 255, 14, 18, 19, 255,
       18, 19, 13, 255, 29, 28, 23, 255, 22, 21, 22, 255, 21, 29, 28, 255,
       23, 22, 21, 255, 22, 21, 28, 255, 31, 34, 39, 255, 37, 32, 37, 255,
-      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255
-  };
+      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255};
 
   surface_->SetSize(gfx::Size(INT_MAX, INT_MAX));
 
   ReadPixelsEmulator emu(
       kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               ReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, _))
       .WillOnce(Invoke(&emu, &ReadPixelsEmulator::ReadPixels));
   ReadPixels cmd;
   cmd.Init(0,
@@ skipping 34 matching lines @@
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_P(GLES3DecoderTest, ReadPixelsBufferBound) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   GLint size = kWidth * kHeight * kBytesPerPixel;
   EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(ReadPixels::Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(ReadPixels::Result);
 
   DoBindBuffer(GL_PIXEL_PACK_BUFFER, client_buffer_id_, kServiceBufferId);
   DoBufferData(GL_PIXEL_PACK_BUFFER, size);
 
   ReadPixels cmd;
   cmd.Init(0,
            0,
            kWidth,
            kHeight,
            GL_RGBA,
@@ skipping 102 matching lines @@
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
-  static const uint8 kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 19, 18, 19, 255, 13, 14, 18, 255,
       29, 28, 23, 255, 21, 22, 21, 255, 28, 23, 22, 255,
       31, 34, 39, 255, 32, 37, 32, 255, 34, 39, 37, 255,
   };
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 29, 28, 23, 22, 21, 22,
       21, 29, 28, 23, 22, 21, 31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32,
   };
 
   surface_->SetSize(gfx::Size(INT_MAX, INT_MAX));
 
   ReadPixelsEmulator emu(kWidth,
                          kHeight,
                          kBytesPerPixel,
                          kSrcPixels,
                          kExpectedPixels,
                          kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               ReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, _))
       .WillOnce(Invoke(&emu, &ReadPixelsEmulator::ReadPixels));
   ReadPixels cmd;
   cmd.Init(0,
@@ skipping 40 matching lines @@
   };
 
   for (size_t tt = 0; tt < arraysize(tests); ++tt) {
     CheckReadPixelsOutOfRange(
         tests[tt][0], tests[tt][1], tests[tt][2], tests[tt][3], tt == 0);
   }
 }
 
 TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
   ReadPixels cmd;
   cmd.Init(0,
            0,
            -1,
            1,
            GL_RGB,
            GL_UNSIGNED_BYTE,
            pixels_shm_id,
            pixels_shm_offset,
@@ skipping 84 matching lines @@
   init.gl_version = "opengl es 3.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   typedef ReadPixels::Result Result;
 
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
 
   EXPECT_CALL(*gl_, GetError())
       // first error check must pass to get to the test
       .WillOnce(Return(GL_NO_ERROR))
       // second check is after BufferData, simulate fail here
       .WillOnce(Return(GL_INVALID_OPERATION))
       // third error check is fall-through call to sync ReadPixels
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
 
@@ skipping 963 matching lines @@
                                         true);
 }
 
 TEST_P(GLES2DecoderTest, ReadPixelsGLError) {
   GLenum kFormat = GL_RGBA;
   GLint x = 0;
   GLint y = 0;
   GLsizei width = 2;
   GLsizei height = 4;
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_,
               ReadPixels(x, y, width, height, kFormat, GL_UNSIGNED_BYTE, _))
       .Times(1)
       .RetiresOnSaturation();
   ReadPixels cmd;
   cmd.Init(x,
@@ skipping 107 matching lines @@
                                           0, 0, 1, 1);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, _))
       .Times(1)
       .RetiresOnSaturation();
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   ReadPixels cmd;
   cmd.Init(0,
            0,
            1,
            1,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            pixels_shm_id,
            pixels_shm_offset,
            result_shm_id,
@@ skipping 305 matching lines @@
       0, 0, 32, 32);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, _))
       .Times(1)
       .RetiresOnSaturation();
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   ReadPixels cmd;
   cmd.Init(0,
            0,
            1,
            1,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            pixels_shm_id,
            pixels_shm_offset,
            result_shm_id,
@@ skipping 596 matching lines @@
   EXPECT_EQ(1, result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // TODO(gman): PixelStorei
 
 // TODO(gman): SwapBuffers
 
 }  // namespace gles2
 }  // namespace gpu