Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.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/common/id_allocator.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 676 matching lines @@
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(
       texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexImage3DBucket) {
-  const uint32 kBucketId = 123;
-  const uint32 kBadBucketId = 99;
+  const uint32_t kBucketId = 123;
+  const uint32_t kBadBucketId = 99;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLsizei kDepth = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   const GLsizei kImageSize = 32;
@@ skipping 25 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_P(GLES2DecoderTest, CompressedTexImage3DFailsOnES2) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   const GLsizei kDepth = 4;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   const GLsizei kImageSize = 32;
   bucket->SetSize(kImageSize);
@@ skipping 18 matching lines @@
              kWidth,
              kHeight,
              kDepth,
              kInternalFormat,
              kBucketId);
     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
   }
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexImage3DFailsWithBadImageSize) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 8;
   const GLsizei kDepth = 4;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   const GLsizei kBadImageSize = 64;
   bucket->SetSize(kBadImageSize);
 
   DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
 
   CompressedTexImage3DBucket cmd;
   cmd.Init(kTarget,
            kLevel,
            kInternalFormat,
            kWidth,
            kHeight,
            kDepth,
            kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexSubImage3DFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 8;
   const GLsizei kDepth = 4;
   const GLint kBorder = 0;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   const GLsizei kImageSize = 128;
@@ skipping 118 matching lines @@
            kSubHeight + 3,
            kSubDepth,
            kFormat,
            kBucketId);
   const GLsizei kSubImageSize2 = 128;
   bucket->SetSize(kSubImageSize2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Bad bucket id.
-  const uint32 kBadBucketId = 444;
+  const uint32_t kBadBucketId = 444;
   cmd.Init(kTarget,
            kLevel,
            kXOffset,
            kYOffset,
            kZOffset,
            kSubWidth,
            kSubHeight,
            kSubDepth,
            kFormat,
            kBadBucketId);
   bucket->SetSize(kSubImageSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   CompressedTexImage2DBucket cmd;
   cmd.Init(GL_TEXTURE_2D,
            0,
            GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
            4,
            4,
            kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   CompressedTexSubImage2DBucket cmd2;
@@ skipping 15 matching lines @@
   size_t block_size;
 };
 
 }  // anonymous namespace.
 
 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   InitDecoder(init);
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   static const S3TCTestData test_data[] = {
       {
        GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 8,
       },
       {
@@ skipping 137 matching lines @@
     }
   }
 }
 
 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   InitState init;
   init.extensions = "GL_OES_compressed_ETC1_RGB8_texture";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   const GLenum kFormat = GL_ETC1_RGB8_OES;
   const size_t kBlockSize = 8;
 
   CompressedTexImage2DBucket cmd;
   // test small width.
@@ skipping 97 matching lines @@
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_EXTERNAL_OES,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
                 GL_TEXTURE_BINDING_EXTERNAL_OES),
             result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
+  EXPECT_EQ(client_texture_id_, (uint32_t)result->GetData()[0]);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
@@ skipping 384 matching lines @@
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_RECTANGLE_ARB,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
                 GL_TEXTURE_BINDING_RECTANGLE_ARB),
             result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
+  EXPECT_EQ(client_texture_id_, (uint32_t)result->GetData()[0]);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
@@ skipping 1155 matching lines @@
                GL_UNSIGNED_BYTE,
                kSharedMemoryId,
                kSharedMemoryOffset);
 
   TextureRef* texture_ref =
       group().texture_manager()->GetTexture(client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
-  const int32 kImageId = 1;
+  const int32_t kImageId = 1;
   scoped_refptr<MockGLImage> image(new MockGLImage);
   GetImageManager()->AddImage(image.get(), kImageId);
 
   // Bind image to texture.
   EXPECT_CALL(*image.get(), BindTexImage(GL_TEXTURE_2D))
       .Times(1)
       .WillOnce(Return(false))
       .RetiresOnSaturation();
   EXPECT_CALL(*image.get(), GetSize())
       .Times(1)
@@ skipping 484 matching lines @@
 // TODO(gman): CompressedTexSubImage2DImmediate
 
 // TODO(gman): TexImage2D
 
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 }  // namespace gles2
 }  // namespace gpu