Switch to standard integer types in gpu/.

gpu/command_buffer/service/program_manager_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 "gpu/command_buffer/service/program_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ skipping 14 matching lines @@
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
-const uint32 kMaxVaryingVectors = 8;
-const uint32 kMaxDrawBuffers = 8;
-const uint32 kMaxDualSourceDrawBuffers = 8;
+const uint32_t kMaxVaryingVectors = 8;
+const uint32_t kMaxDrawBuffers = 8;
+const uint32_t kMaxDualSourceDrawBuffers = 8;
 
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
 
-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);
 }
 
 }  // namespace anonymous
 
 class ProgramManagerTestBase : public GpuServiceTest {
  protected:
   virtual void SetupProgramManager() {
     manager_.reset(new ProgramManager(nullptr, kMaxVaryingVectors,
                                       kMaxDualSourceDrawBuffers,
                                       feature_info_.get()));
@@ skipping 995 matching lines @@
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(1u, header->link_status);
   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
       sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   ASSERT_TRUE(inputs != NULL);
   const ProgramInput* input = inputs;
   // TODO(gman): Don't assume these are in order.
-  for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_attribs; ++ii) {
     const AttribInfo& expected = kAttribs[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
-    const int32* location = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32));
+    const int32_t* location = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t));
     ASSERT_TRUE(location != NULL);
     EXPECT_EQ(expected.location, *location);
     const char* name_buf = bucket.GetDataAs<const char*>(
         input->name_offset, input->name_length);
     ASSERT_TRUE(name_buf != NULL);
     std::string name(name_buf, input->name_length);
     EXPECT_STREQ(expected.name, name.c_str());
     ++input;
   }
   // TODO(gman): Don't assume these are in order.
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
-    const int32* locations = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32) * input->size);
+    const int32_t* locations = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t) * input->size);
     ASSERT_TRUE(locations != NULL);
-    for (int32 jj = 0; jj < input->size; ++jj) {
+    for (int32_t jj = 0; jj < input->size; ++jj) {
       EXPECT_EQ(
           ProgramManager::MakeFakeLocation(expected.fake_location, jj),
           locations[jj]);
     }
     const char* name_buf = bucket.GetDataAs<const char*>(
         input->name_offset, input->name_length);
     ASSERT_TRUE(name_buf != NULL);
     std::string name(name_buf, input->name_length);
     EXPECT_STREQ(expected.good_name, name.c_str());
     ++input;
   }
   EXPECT_EQ(header->num_attribs + header->num_uniforms,
-            static_cast<uint32>(input - inputs));
+            static_cast<uint32_t>(input - inputs));
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetUniformBlocksNone) {
   CommonDecoder::Bucket bucket;
   const Program* program = SetupDefaultProgram();
   ASSERT_TRUE(program != NULL);
   // The program's previous link failed.
   EXPECT_CALL(*(gl_.get()),
               GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
       .WillOnce(SetArgPointee<2>(GL_FALSE))
@@ skipping 375 matching lines @@
       bucket.GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(1u, header->link_status);
   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
       sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   ASSERT_TRUE(inputs != NULL);
   const ProgramInput* input = inputs + header->num_attribs;
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
-    const int32* locations = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32) * input->size);
+    const int32_t* locations = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t) * input->size);
     ASSERT_TRUE(locations != NULL);
     EXPECT_EQ(
         ProgramManager::MakeFakeLocation(expected.fake_location, 0),
         locations[0]);
-    for (int32 jj = 1; jj < input->size; ++jj)
+    for (int32_t jj = 1; jj < input->size; ++jj)
       EXPECT_EQ(-1, locations[jj]);
     ++input;
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, BindAttribLocationConflicts) {
   // Set up shader
   AttributeMap attrib_map;
-  for (uint32 ii = 0; ii < kNumAttribs; ++ii) {
+  for (uint32_t ii = 0; ii < kNumAttribs; ++ii) {
     attrib_map[kAttribs[ii].name] = TestHelper::ConstructAttribute(
         kAttribs[ii].type,
         kAttribs[ii].size,
         GL_MEDIUM_FLOAT,
         kAttribStaticUse,
         kAttribs[ii].name);
   }
   const char kAttribMatName[] = "matAttrib";
   attrib_map[kAttribMatName] = TestHelper::ConstructAttribute(
       GL_FLOAT_MAT2,
@@ skipping 863 matching lines @@
     ProgramManagerDualSourceBlendingES2Test,
     testing::Values(
         make_gl_ext_tuple("3.2",
                           "GL_ARB_draw_buffers GL_ARB_blend_func_extended "
                           "GL_ARB_program_interface_query"),
         make_gl_ext_tuple("opengl es 3.1",
                           "GL_EXT_draw_buffers GL_EXT_blend_func_extended")));
 
 }  // namespace gles2
 }  // namespace gpu