Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder_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/gles2_cmd_decoder_unittest.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.h"
 #include "gpu/command_buffer/service/image_manager.h"
@@ skipping 425 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd3));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindRenderbuffer cmd4;
   cmd4.Init(GL_RENDERBUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd4));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderTest, EnableFeatureCHROMIUMBadBucket) {
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   EnableFeatureCHROMIUM cmd;
   cmd.Init(kBadBucketId, shared_memory_id_, shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderTest, RequestExtensionCHROMIUMBadBucket) {
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   RequestExtensionCHROMIUM cmd;
   cmd.Init(kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderTest, BeginQueryEXTDisabled) {
   // Test something fails if off.
 }
 
 TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXT) {
@@ skipping 105 matching lines @@
         .RetiresOnSaturation();
   }
 }
 
 static error::Error ExecuteBeginQueryCmd(GLES2DecoderTestBase* test,
                                          ::gfx::MockGLInterface* gl,
                                          ::gfx::GPUTimingFake* timing_queries,
                                          GLenum target,
                                          GLuint client_id,
                                          GLuint service_id,
-                                         int32 shm_id,
-                                         uint32 shm_offset) {
+                                         int32_t shm_id,
+                                         uint32_t shm_offset) {
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(*gl, BeginQuery(target, service_id))
         .Times(1)
         .RetiresOnSaturation();
   } else if (GL_TIME_ELAPSED == target) {
     timing_queries->ExpectGPUTimerQuery(*gl, true);
   }
 
   BeginQueryEXT begin_cmd;
   begin_cmd.Init(target, client_id, shm_id, shm_offset);
@@ skipping 22 matching lines @@
         .WillRepeatedly(Return(GL_TRUE));
 #endif
   }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(target, submit_count);
   return test->ExecuteCmd(end_cmd);
 }
 
 static error::Error ExecuteQueryCounterCmd(GLES2DecoderTestBase* test,
-                                         ::gfx::MockGLInterface* gl,
-                                         ::gfx::GPUTimingFake* timing_queries,
-                                         GLenum target,
-                                         GLuint client_id,
-                                         GLuint service_id,
-                                         int32 shm_id,
-                                         uint32 shm_offset,
-                                         uint32_t submit_count) {
+                                           ::gfx::MockGLInterface* gl,
+                                           ::gfx::GPUTimingFake* timing_queries,
+                                           GLenum target,
+                                           GLuint client_id,
+                                           GLuint service_id,
+                                           int32_t shm_id,
+                                           uint32_t shm_offset,
+                                           uint32_t submit_count) {
   if (GL_TIMESTAMP == target) {
     timing_queries->ExpectGPUTimeStampQuery(*gl, false);
   }
 
   QueryCounterEXT query_counter_cmd;
   query_counter_cmd.Init(client_id,
                          target,
                          shm_id,
                          shm_offset,
                          submit_count);
@@ skipping 24 matching lines @@
   if (!query_manager)
     return false;
 
   return query_manager->ProcessPendingQueries(false);
 }
 
 static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
                                              GLuint client_id,
                                              GLuint service_id,
                                              const QueryType& query_type,
-                                             int32 shm_id,
-                                             uint32 shm_offset) {
+                                             int32_t shm_id,
+                                             uint32_t shm_offset) {
   // We need to reset the decoder on each iteration, because we lose the
   // context every time.
   GLES2DecoderTestBase::InitState init;
   init.extensions = "GL_EXT_occlusion_query_boolean"
                     " GL_ARB_sync"
                     " GL_ARB_timer_query";
   init.gl_version = "opengl es 3.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
@@ skipping 852 matching lines @@
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES3DecoderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES3DecoderWithESSL3ShaderTest,
                         ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu