Switch to standard integer types in gpu/.

gpu/command_buffer/client/program_info_manager_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 <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+uint32_t ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8_t*>(position) -
+         static_cast<const uint8_t*>(start);
 }
 
 const GLuint kClientProgramId = 321;
 
 }  // namespace anonymous
 
 namespace gpu {
 namespace gles2 {
 
 class ProgramInfoManagerTest : public testing::Test {
@@ skipping 141 matching lines @@
 
   scoped_ptr<ProgramInfoManager> program_info_manager_;
   Program* program_;
 };
 
 TEST_F(ProgramInfoManagerTest, UpdateES2) {
   ProgramES2Data data;
   SetupProgramES2Data(&data);
   const std::string kNames[] = { data.uniform_name0, data.uniform_name1 };
   const int32_t* kLocs[] = { data.uniform_loc0, data.uniform_loc1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES2));
   program_->UpdateES2(result);
   EXPECT_TRUE(program_->IsCached(ProgramInfoManager::kES2));
 
   GLint params = 0;
   EXPECT_TRUE(program_->GetProgramiv(GL_LINK_STATUS, &params));
   EXPECT_TRUE(params);
 
   params = 0;
@@ skipping 25 matching lines @@
       EXPECT_EQ(kLocs[ii][uu], info->element_locations[uu]);
     }
   }
 }
 
 TEST_F(ProgramInfoManagerTest, UpdateES3UniformBlocks) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
   const std::string kName[] = { data.name0, data.name1 };
   const uint32_t* kIndices[] = { data.indices0, data.indices1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES3UniformBlocks));
   program_->UpdateES3UniformBlocks(result);
   EXPECT_TRUE(program_->IsCached(ProgramInfoManager::kES3UniformBlocks));
 
   GLint uniform_block_count = 0;
   EXPECT_TRUE(program_->GetProgramiv(
       GL_ACTIVE_UNIFORM_BLOCKS, &uniform_block_count));
   EXPECT_EQ(data.header.num_uniform_blocks,
             static_cast<uint32_t>(uniform_block_count));
@@ skipping 20 matching lines @@
   }
 
   EXPECT_EQ(GL_INVALID_INDEX, program_->GetUniformBlockIndex("BadName"));
   EXPECT_EQ(NULL, program_->GetUniformBlock(data.header.num_uniform_blocks));
 }
 
 TEST_F(ProgramInfoManagerTest, UpdateES3TransformFeedbackVaryings) {
   TransformFeedbackVaryingsData data;
   SetupTransformFeedbackVaryingsData(&data);
   const std::string kName[] = { data.name0, data.name1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(
       ProgramInfoManager::kES3TransformFeedbackVaryings));
   program_->UpdateES3TransformFeedbackVaryings(result);
   EXPECT_TRUE(program_->IsCached(
       ProgramInfoManager::kES3TransformFeedbackVaryings));
 
   GLint transform_feedback_buffer_mode = 0;
   EXPECT_TRUE(program_->GetProgramiv(
       GL_TRANSFORM_FEEDBACK_BUFFER_MODE, &transform_feedback_buffer_mode));
@@ skipping 17 matching lines @@
     EXPECT_EQ(kName[ii], varying->name);
     EXPECT_GE(max_name_length, static_cast<GLint>(varying->name.size()) + 1);
   }
   EXPECT_EQ(NULL, program_->GetTransformFeedbackVarying(
   data.header.num_transform_feedback_varyings));
 }
 
 TEST_F(ProgramInfoManagerTest, GetUniformBlockIndexCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
 
   EXPECT_EQ(0u, program_info_manager_->GetUniformBlockIndex(
       NULL, kClientProgramId, data.name0));
   EXPECT_EQ(1u, program_info_manager_->GetUniformBlockIndex(
       NULL, kClientProgramId, data.name1));
   EXPECT_EQ(GL_INVALID_INDEX, program_info_manager_->GetUniformBlockIndex(
       NULL, kClientProgramId, "BadName"));
 }
 
 TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockNameCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
 
   GLsizei buf_size = std::max(strlen(data.name0), strlen(data.name1)) + 1;
   std::vector<char> buffer(buf_size);
   GLsizei length = 0;
   EXPECT_EQ(true, program_info_manager_->GetActiveUniformBlockName(
       NULL, kClientProgramId, 0, buf_size, &length, &buffer[0]));
   EXPECT_EQ(static_cast<GLsizei>(strlen(data.name0)), length);
   EXPECT_STREQ(data.name0, &buffer[0]);
@@ skipping 17 matching lines @@
   buf_size = strlen(data.name0);
   EXPECT_EQ(true, program_info_manager_->GetActiveUniformBlockName(
       NULL, kClientProgramId, 0, buf_size, &length, &buffer[0]));
   EXPECT_EQ(buf_size, length + 1);
   EXPECT_STREQ(std::string(data.name0).substr(0, length).c_str(), &buffer[0]);
 }
 
 TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockivCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
   const char* kName[] = { data.name0, data.name1 };
   const uint32_t* kIndices[] = { data.indices0, data.indices1 };
 
   for (uint32_t ii = 0; ii < data.header.num_uniform_blocks; ++ii) {
     ASSERT_GE(2u, data.entry[ii].active_uniforms);
     GLint params[2];
     EXPECT_TRUE(program_info_manager_->GetActiveUniformBlockiv(
         NULL, kClientProgramId, ii, GL_UNIFORM_BLOCK_BINDING, params));
@@ skipping 28 matching lines @@
         NULL, kClientProgramId, ii,
         GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, params));
     EXPECT_EQ(data.entry[ii].referenced_by_fragment_shader,
               static_cast<uint32_t>(params[0]));
   }
 }
 
 TEST_F(ProgramInfoManagerTest, GetTransformFeedbackVaryingCached) {
   TransformFeedbackVaryingsData data;
   SetupTransformFeedbackVaryingsData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3TransformFeedbackVaryings(result);
   const char* kName[] = { data.name0, data.name1 };
   GLsizei buf_size = std::max(strlen(kName[0]), strlen(kName[1])) + 1;
   for (uint32_t ii = 0; ii < data.header.num_transform_feedback_varyings;
        ++ii) {
     std::vector<char> buffer(buf_size);
     GLsizei length = 0;
     GLsizei size = 0;
     GLenum type = 0;
     EXPECT_EQ(true, program_info_manager_->GetTransformFeedbackVarying(
         NULL, kClientProgramId, ii, buf_size,
         &length, &size, &type, &buffer[0]));
     EXPECT_EQ(data.entry[ii].size, static_cast<uint32_t>(size));
     EXPECT_EQ(data.entry[ii].type, static_cast<uint32_t>(type));
     EXPECT_STREQ(kName[ii], &buffer[0]);
     EXPECT_EQ(strlen(kName[ii]), static_cast<size_t>(length));
   }
 }
 
 TEST_F(ProgramInfoManagerTest, GetUniformIndices) {
   ProgramES2Data data;
   SetupProgramES2Data(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES2(result);
 
   {  // Original order.
     const char* kNames[] = { data.uniform_name0, data.uniform_name1 };
     const GLuint kIndices[] = { 0, 1 };
     const GLsizei kCount = 2;
     GLuint indices[kCount];
     EXPECT_TRUE(program_info_manager_->GetUniformIndices(
         NULL, kClientProgramId, kCount, kNames, indices));
@@ skipping 37 matching lines @@
     for (GLsizei ii = 0; ii < kCount; ++ii) {
       EXPECT_EQ(kIndices[ii], indices[ii]);
     }
   }
 }
 
 TEST_F(ProgramInfoManagerTest, GetActiveUniformsivCached) {
   // ES3 only parameters.
   UniformsES3Data data_es3;
   SetupUniformsES3Data(&data_es3);
-  std::vector<int8> result(sizeof(data_es3));
+  std::vector<int8_t> result(sizeof(data_es3));
   memcpy(&result[0], &data_es3, sizeof(data_es3));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES3Uniformsiv));
   program_->UpdateES3Uniformsiv(result);
   EXPECT_TRUE(program_->IsCached(ProgramInfoManager::kES3Uniformsiv));
 
   uint32_t count = data_es3.header.num_uniforms;
   std::vector<GLuint> indices(count);
   for (uint32_t ii = 0; ii < count; ++ii) {
     indices[ii] = ii;
   }
@@ skipping 52 matching lines @@
     EXPECT_EQ(data_es2.uniforms[ii].size, size[ii]);
     EXPECT_EQ(data_es2.uniforms[ii].type, static_cast<uint32_t>(type[ii]));
     EXPECT_EQ(data_es2.uniforms[ii].name_length + 1,
               static_cast<uint32_t>(name_length[ii]));
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu