Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder.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.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
 #include <list>
 #include <map>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 204 matching lines @@
     PerformanceWarning(__FILE__, __LINE__, msg)
 #define LOCAL_RENDER_WARNING(msg) \
     RenderWarning(__FILE__, __LINE__, msg)
 
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
 // to shared memory, converting the sizes.
-static_assert(sizeof(GLint) == sizeof(uint32),  // NOLINT
-              "GLint should be the same size as uint32");
-static_assert(sizeof(GLsizei) == sizeof(uint32),  // NOLINT
-              "GLsizei should be the same size as uint32");
+static_assert(sizeof(GLint) == sizeof(uint32_t),  // NOLINT
+              "GLint should be the same size as uint32_t");
+static_assert(sizeof(GLsizei) == sizeof(uint32_t),  // NOLINT
+              "GLsizei should be the same size as uint32_t");
 static_assert(sizeof(GLfloat) == sizeof(float),  // NOLINT
               "GLfloat should be the same size as float");
 
 // TODO(kbr): the use of this anonymous namespace core dumps the
 // linker on Mac OS X 10.6 when the symbol ordering file is used
 // namespace {
 
 // Returns the address of the first byte after a struct.
 template <typename T>
 const void* AddressAfterStruct(const T& pod) {
-  return reinterpret_cast<const uint8*>(&pod) + sizeof(pod);
+  return reinterpret_cast<const uint8_t*>(&pod) + sizeof(pod);
 }
 
 // Returns the address of the frst byte after the struct or NULL if size >
 // immediate_data_size.
 template <typename RETURN_TYPE, typename COMMAND_TYPE>
 RETURN_TYPE GetImmediateDataAs(const COMMAND_TYPE& pod,
-                               uint32 size,
-                               uint32 immediate_data_size) {
+                               uint32_t size,
+                               uint32_t immediate_data_size) {
   return (size <= immediate_data_size) ?
       static_cast<RETURN_TYPE>(const_cast<void*>(AddressAfterStruct(pod))) :
       NULL;
 }
 
 // Computes the data size for certain gl commands like glUniform.
-bool ComputeDataSize(
-    GLuint count,
-    size_t size,
-    unsigned int elements_per_unit,
-    uint32* dst) {
-  uint32 value;
+bool ComputeDataSize(GLuint count,
+                     size_t size,
+                     unsigned int elements_per_unit,
+                     uint32_t* dst) {
+  uint32_t value;
   if (!SafeMultiplyUint32(count, size, &value)) {
     return false;
   }
   if (!SafeMultiplyUint32(value, elements_per_unit, &value)) {
     return false;
   }
   *dst = value;
   return true;
 }
 
@@ skipping 217 matching lines @@
   std::vector<base::Closure> callbacks;
   scoped_ptr<gfx::GLFence> fence;
 };
 
 // }  // anonymous namespace.
 
 // static
 const unsigned int GLES2Decoder::kDefaultStencilMask =
     static_cast<unsigned int>(-1);
 
-bool GLES2Decoder::GetServiceTextureId(uint32 client_texture_id,
-                                       uint32* service_texture_id) {
+bool GLES2Decoder::GetServiceTextureId(uint32_t client_texture_id,
+                                       uint32_t* service_texture_id) {
   return false;
 }
 
-uint32 GLES2Decoder::GetAndClearBackbufferClearBitsForTest() {
+uint32_t GLES2Decoder::GetAndClearBackbufferClearBitsForTest() {
   return 0;
 }
 
 GLES2Decoder::GLES2Decoder()
     : initialized_(false),
       debug_(false),
       log_commands_(false),
       unsafe_es3_apis_enabled_(false) {
 }
 
@@ skipping 29 matching lines @@
 
   // Overridden from AsyncAPIInterface.
   const char* GetCommandName(unsigned int command_id) const override;
 
   // Overridden from GLES2Decoder.
   bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
                   const scoped_refptr<gfx::GLContext>& context,
                   bool offscreen,
                   const gfx::Size& offscreen_size,
                   const DisallowedFeatures& disallowed_features,
-                  const std::vector<int32>& attribs) override;
+                  const std::vector<int32_t>& attribs) override;
   void Destroy(bool have_context) override;
   void SetSurface(const scoped_refptr<gfx::GLSurface>& surface) override;
   void ProduceFrontBuffer(const Mailbox& mailbox) override;
   bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
   void UpdateParentTextureInfo();
   bool MakeCurrent() override;
   GLES2Util* GetGLES2Util() override { return &util_; }
   gfx::GLContext* GetGLContext() override { return context_.get(); }
   ContextGroup* GetContextGroup() override { return group_.get(); }
   Capabilities GetCapabilities() override;
@@ skipping 51 matching lines @@
   const ContextState* GetContextState() override { return &state_; }
 
   void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
   void SetWaitSyncPointCallback(const WaitSyncPointCallback& callback) override;
   void SetFenceSyncReleaseCallback(
       const FenceSyncReleaseCallback& callback) override;
   void SetWaitFenceSyncCallback(const WaitFenceSyncCallback& callback) override;
 
   void SetIgnoreCachedStateForTest(bool ignore) override;
   void SetForceShaderNameHashingForTest(bool force) override;
-  uint32 GetAndClearBackbufferClearBitsForTest() override;
+  uint32_t GetAndClearBackbufferClearBitsForTest() override;
   void ProcessFinishedAsyncTransfers();
 
-  bool GetServiceTextureId(uint32 client_texture_id,
-                           uint32* service_texture_id) override;
+  bool GetServiceTextureId(uint32_t client_texture_id,
+                           uint32_t* service_texture_id) override;
 
-  uint32 GetTextureUploadCount() override;
+  uint32_t GetTextureUploadCount() override;
   base::TimeDelta GetTotalTextureUploadTime() override;
   base::TimeDelta GetTotalProcessingCommandsTime() override;
   void AddProcessingCommandsTime(base::TimeDelta) override;
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
 
   // Sets DEPTH_TEST, STENCIL_TEST and color mask for the current framebuffer.
   void ApplyDirtyState();
 
@@ skipping 557 matching lines @@
 
   error::Error DoBindFragDataLocationIndexed(GLuint program_id,
                                              GLuint colorName,
                                              GLuint index,
                                              const std::string& name);
 
   void DoBindUniformLocationCHROMIUM(GLuint client_id,
                                      GLint location,
                                      const std::string& name);
 
-  error::Error GetAttribLocationHelper(
-      GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
-      const std::string& name_str);
+  error::Error GetAttribLocationHelper(GLuint client_id,
+                                       uint32_t location_shm_id,
+                                       uint32_t location_shm_offset,
+                                       const std::string& name_str);
 
-  error::Error GetUniformLocationHelper(
-      GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
-      const std::string& name_str);
+  error::Error GetUniformLocationHelper(GLuint client_id,
+                                        uint32_t location_shm_id,
+                                        uint32_t location_shm_offset,
+                                        const std::string& name_str);
 
-  error::Error GetFragDataLocationHelper(
-      GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
-      const std::string& name_str);
+  error::Error GetFragDataLocationHelper(GLuint client_id,
+                                         uint32_t location_shm_id,
+                                         uint32_t location_shm_offset,
+                                         const std::string& name_str);
 
   error::Error GetFragDataIndexHelper(GLuint program_id,
-                                      uint32 index_shm_id,
-                                      uint32 index_shm_offset,
+                                      uint32_t index_shm_id,
+                                      uint32_t index_shm_offset,
                                       const std::string& name_str);
 
   // Wrapper for glShaderSource.
   void DoShaderSource(
       GLuint client_id, GLsizei count, const char** data, const GLint* length);
 
   // Wrapper for glTransformFeedbackVaryings.
   void DoTransformFeedbackVaryings(
       GLuint client_program_id, GLsizei count, const char* const* varyings,
       GLenum buffer_mode);
@@ skipping 463 matching lines @@
       const char* function_name,
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
 
   // Handle DrawArrays and DrawElements for both instanced and non-instanced
   // cases (primcount is always 1 for non-instanced).
   error::Error DoDrawArrays(
       const char* function_name,
       bool instanced, GLenum mode, GLint first, GLsizei count,
       GLsizei primcount);
-  error::Error DoDrawElements(
-      const char* function_name,
-      bool instanced, GLenum mode, GLsizei count, GLenum type,
-      int32 offset, GLsizei primcount);
+  error::Error DoDrawElements(const char* function_name,
+                              bool instanced,
+                              GLenum mode,
+                              GLsizei count,
+                              GLenum type,
+                              int32_t offset,
+                              GLsizei primcount);
 
   GLenum GetBindTargetForSamplerType(GLenum type) {
     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
            type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
     switch (type) {
       case GL_SAMPLER_2D:
         return GL_TEXTURE_2D;
       case GL_SAMPLER_CUBE:
         return GL_TEXTURE_CUBE_MAP;
       case GL_SAMPLER_EXTERNAL_OES:
@@ skipping 37 matching lines @@
     }
     return renderbuffer;
   }
 
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   template <class T>
   bool GetUniformSetup(GLuint program,
                        GLint fake_location,
-                       uint32 shm_id,
-                       uint32 shm_offset,
+                       uint32_t shm_id,
+                       uint32_t shm_offset,
                        error::Error* error,
                        GLint* real_location,
                        GLuint* service_id,
                        SizedResult<T>** result,
                        GLenum* result_type,
                        GLsizei* result_size);
 
   bool WasContextLost() const override;
   bool WasContextLostByRobustnessExtension() const override;
   void MarkContextLost(error::ContextLostReason reason) override;
@@ skipping 95 matching lines @@
   void ProcessPendingReadPixels(bool did_finish);
   void FinishReadPixels(const cmds::ReadPixels& c, GLuint buffer);
 
   void DoBindFragmentInputLocationCHROMIUM(GLuint program_id,
                                            GLint location,
                                            const std::string& name);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
-  Error Handle##name(uint32 immediate_data_size, const void* data);
+  Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
@@ skipping 75 matching lines @@
   // Tracks read buffer and draw buffer for backbuffer, whether it's onscreen
   // or offscreen.
   // TODO(zmo): when ES3 APIs are exposed to Nacl, make sure read_buffer_
   // setting is set correctly when SwapBuffers().
   GLenum back_buffer_read_buffer_;
   GLenum back_buffer_draw_buffer_;
 
   bool surfaceless_;
 
   // Backbuffer attachments that are currently undefined.
-  uint32 backbuffer_needs_clear_bits_;
+  uint32_t backbuffer_needs_clear_bits_;
 
   // The current decoder error communicates the decoder error through command
   // processing functions that do not return the error value. Should be set only
   // if not returning an error.
   error::Error current_decoder_error_;
 
   scoped_refptr<ShaderTranslatorInterface> vertex_translator_;
   scoped_refptr<ShaderTranslatorInterface> fragment_translator_;
 
   DisallowedFeatures disallowed_features_;
@@ skipping 62 matching lines @@
   bool gpu_debug_commands_;
 
   std::queue<linked_ptr<FenceCallback> > pending_readpixel_fences_;
 
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
   GLuint validation_fbo_;
 
   typedef gpu::gles2::GLES2Decoder::Error (GLES2DecoderImpl::*CmdHandler)(
-      uint32 immediate_data_size,
+      uint32_t immediate_data_size,
       const void* data);
 
   // A struct to hold info about each command.
   struct CommandInfo {
     CmdHandler cmd_handler;
-    uint8 arg_flags;   // How to handle the arguments for this command
-    uint8 cmd_flags;   // How to handle this command
-    uint16 arg_count;  // How many arguments are expected for this command.
+    uint8_t arg_flags;   // How to handle the arguments for this command
+    uint8_t cmd_flags;   // How to handle this command
+    uint16_t arg_count;  // How many arguments are expected for this command.
   };
 
   // A table of CommandInfo for all the commands.
   static const CommandInfo command_info[kNumCommands - kStartPoint];
 
   bool force_shader_name_hashing_for_test;
 
   GLfloat line_width_range_[2];
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
@@ skipping 195 matching lines @@
   bytes_allocated_ = 16u * 16u * 4u;
   memory_tracker_.TrackMemAlloc(bytes_allocated_);
 }
 
 bool BackTexture::AllocateStorage(
     const gfx::Size& size, GLenum format, bool zero) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor("BackTexture::AllocateStorage",
                                      state_->GetErrorState());
   ScopedTextureBinder binder(state_, id_, GL_TEXTURE_2D);
-  uint32 image_size = 0;
+  uint32_t image_size = 0;
   GLES2Util::ComputeImageDataSizes(
       size.width(), size.height(), 1, format, GL_UNSIGNED_BYTE, 8, &image_size,
       NULL, NULL);
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
   scoped_ptr<char[]> zero_data;
   if (zero) {
@@ skipping 77 matching lines @@
 }
 
 bool BackRenderbuffer::AllocateStorage(const FeatureInfo* feature_info,
                                        const gfx::Size& size,
                                        GLenum format,
                                        GLsizei samples) {
   ScopedGLErrorSuppressor suppressor(
       "BackRenderbuffer::AllocateStorage", state_->GetErrorState());
   ScopedRenderBufferBinder binder(state_, id_);
 
-  uint32 estimated_size = 0;
+  uint32_t estimated_size = 0;
   if (!renderbuffer_manager_->ComputeEstimatedRenderbufferSize(
            size.width(), size.height(), samples, format, &estimated_size)) {
     return false;
   }
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(estimated_size)) {
     return false;
   }
 
   if (samples <= 1) {
@@ skipping 161 matching lines @@
       validation_texture_(0),
       validation_fbo_multisample_(0),
       validation_fbo_(0),
       force_shader_name_hashing_for_test(false) {
   DCHECK(group);
 }
 
 GLES2DecoderImpl::~GLES2DecoderImpl() {
 }
 
-bool GLES2DecoderImpl::Initialize(
-    const scoped_refptr<gfx::GLSurface>& surface,
-    const scoped_refptr<gfx::GLContext>& context,
-    bool offscreen,
-    const gfx::Size& offscreen_size,
-    const DisallowedFeatures& disallowed_features,
-    const std::vector<int32>& attribs) {
+bool GLES2DecoderImpl::Initialize(const scoped_refptr<gfx::GLSurface>& surface,
+                                  const scoped_refptr<gfx::GLContext>& context,
+                                  bool offscreen,
+                                  const gfx::Size& offscreen_size,
+                                  const DisallowedFeatures& disallowed_features,
+                                  const std::vector<int32_t>& attribs) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::Initialize");
   DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
   DCHECK(!offscreen || !offscreen_size.IsEmpty());
 
   ContextCreationAttribHelper attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
 
   surfaceless_ = surface->IsSurfaceless() && !offscreen;
@@ skipping 103 matching lines @@
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
 
   state_.texture_units.resize(group_->max_texture_units());
   state_.sampler_units.resize(group_->max_texture_units());
-  for (uint32 tt = 0; tt < state_.texture_units.size(); ++tt) {
+  for (uint32_t tt = 0; tt < state_.texture_units.size(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // We want the last bind to be 2D.
     TextureRef* ref;
     if (features().oes_egl_image_external) {
       ref = texture_manager()->GetDefaultTextureInfo(
           GL_TEXTURE_EXTERNAL_OES);
       state_.texture_units[tt].bound_texture_external_oes = ref;
       glBindTexture(GL_TEXTURE_EXTERNAL_OES, ref ? ref->service_id() : 0);
     }
     if (features().arb_texture_rectangle) {
@@ skipping 1250 matching lines @@
 void GLES2DecoderImpl::SetFenceSyncReleaseCallback(
     const FenceSyncReleaseCallback& callback) {
   fence_sync_release_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetWaitFenceSyncCallback(
     const WaitFenceSyncCallback& callback) {
   wait_fence_sync_callback_ = callback;
 }
 
-bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
-                                           uint32* service_texture_id) {
+bool GLES2DecoderImpl::GetServiceTextureId(uint32_t client_texture_id,
+                                           uint32_t* service_texture_id) {
   TextureRef* texture_ref = texture_manager()->GetTexture(client_texture_id);
   if (texture_ref) {
     *service_texture_id = texture_ref->service_id();
     return true;
   }
   return false;
 }
 
-uint32 GLES2DecoderImpl::GetTextureUploadCount() {
+uint32_t GLES2DecoderImpl::GetTextureUploadCount() {
   return texture_state_.texture_upload_count;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalTextureUploadTime() {
   return texture_state_.total_texture_upload_time;
 }
 
 base::TimeDelta GLES2DecoderImpl::GetTotalProcessingCommandsTime() {
   return total_processing_commands_time_;
 }
@@ skipping 300 matching lines @@
   if (offscreen_resolved_frame_buffer_.get())
     offscreen_resolved_frame_buffer_->Destroy();
   if (offscreen_resolved_color_texture_.get())
     offscreen_resolved_color_texture_->Destroy();
   offscreen_resolved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
 
   return true;
 }
 
-error::Error GLES2DecoderImpl::HandleResizeCHROMIUM(uint32 immediate_data_size,
-                                                    const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleResizeCHROMIUM(
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   const gles2::cmds::ResizeCHROMIUM& c =
       *static_cast<const gles2::cmds::ResizeCHROMIUM*>(cmd_data);
   if (!offscreen_target_frame_buffer_.get() && surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
 
   GLuint width = static_cast<GLuint>(c.width);
   GLuint height = static_cast<GLuint>(c.height);
   GLfloat scale_factor = c.scale_factor;
   GLboolean has_alpha = c.alpha;
   TRACE_EVENT2("gpu", "glResizeChromium", "width", width, "height", height);
@@ skipping 95 matching lines @@
         bool doing_gpu_trace = false;
         if (DebugImpl && gpu_trace_commands_) {
           if (CMD_FLAG_GET_TRACE_LEVEL(info.cmd_flags) <= gpu_trace_level_) {
             doing_gpu_trace = true;
             gpu_tracer_->Begin(TRACE_DISABLED_BY_DEFAULT("gpu_decoder"),
                                GetCommandName(command),
                                kTraceDecoder);
           }
         }
 
-        uint32 immediate_data_size = (arg_count - info_arg_count) *
-                                     sizeof(CommandBufferEntry);  // NOLINT
+        uint32_t immediate_data_size = (arg_count - info_arg_count) *
+                                       sizeof(CommandBufferEntry);  // NOLINT
 
         result = (this->*info.cmd_handler)(immediate_data_size, cmd_data);
 
         if (DebugImpl && doing_gpu_trace)
           gpu_tracer_->End(kTraceDecoder);
 
         if (DebugImpl && debug()) {
           GLenum error;
           while ((error = glGetError()) != GL_NO_ERROR) {
             LOG(ERROR) << "[" << logger_.GetLogPrefix() << "] "
@@ skipping 273 matching lines @@
     RestoreTextureUnitBindings(state_.active_texture_unit);
   }
 }
 
 void GLES2DecoderImpl::ClearAllAttributes() const {
   // Must use native VAO 0, as RestoreAllAttributes can't fully restore
   // other VAOs.
   if (feature_info_->feature_flags().native_vertex_array_object)
     glBindVertexArrayOES(0);
 
-  for (uint32 i = 0; i < group_->max_vertex_attribs(); ++i) {
+  for (uint32_t i = 0; i < group_->max_vertex_attribs(); ++i) {
     if (i != 0)  // Never disable attribute 0
       glDisableVertexAttribArray(i);
     if (features().angle_instanced_arrays)
       glVertexAttribDivisorANGLE(i, 0);
   }
 }
 
 void GLES2DecoderImpl::RestoreAllAttributes() const {
   state_.RestoreVertexAttribs();
 }
 
 void GLES2DecoderImpl::SetIgnoreCachedStateForTest(bool ignore) {
   state_.SetIgnoreCachedStateForTest(ignore);
 }
 
 void GLES2DecoderImpl::SetForceShaderNameHashingForTest(bool force) {
   force_shader_name_hashing_for_test = force;
 }
 
 // Added specifically for testing backbuffer_needs_clear_bits unittests.
-uint32 GLES2DecoderImpl::GetAndClearBackbufferClearBitsForTest() {
-  uint32 clear_bits = backbuffer_needs_clear_bits_;
+uint32_t GLES2DecoderImpl::GetAndClearBackbufferClearBitsForTest() {
+  uint32_t clear_bits = backbuffer_needs_clear_bits_;
   backbuffer_needs_clear_bits_ = 0;
   return clear_bits;
 }
 
 void GLES2DecoderImpl::OnFboChanged() const {
   if (workarounds().restore_scissor_on_fbo_change)
     state_.fbo_binding_for_scissor_workaround_dirty = true;
 
   if (workarounds().gl_begin_gl_end_on_fbo_change_to_backbuffer) {
     GLint bound_fbo_unsigned = -1;
@@ skipping 939 matching lines @@
   // therefore, we may not find the hashed attribute name.
   // glBindAttribLocation call with original name is useless.
   // So instead, we should simply cache the binding, and then call
   // Program::ExecuteBindAttribLocationCalls() right before link.
   program->SetAttribLocationBinding(name, static_cast<GLint>(index));
   // TODO(zmo): Get rid of the following glBindAttribLocation call.
   glBindAttribLocation(program->service_id(), index, name.c_str());
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindAttribLocationBucket& c =
       *static_cast<const gles2::cmds::BindAttribLocationBucket*>(cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint index = static_cast<GLuint>(c.index);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
@@ skipping 23 matching lines @@
   }
   Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   program->SetProgramOutputLocationBinding(name, colorName);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragDataLocationEXTBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
   const gles2::cmds::BindFragDataLocationEXTBucket& c =
       *static_cast<const gles2::cmds::BindFragDataLocationEXTBucket*>(cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint colorNumber = static_cast<GLuint>(c.colorNumber);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
@@ skipping 32 matching lines @@
   }
   Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   program->SetProgramOutputLocationIndexedBinding(name, colorName, index);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragDataLocationIndexedEXTBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
   const gles2::cmds::BindFragDataLocationIndexedEXTBucket& c =
       *static_cast<const gles2::cmds::BindFragDataLocationIndexedEXTBucket*>(
           cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint colorNumber = static_cast<GLuint>(c.colorNumber);
   GLuint index = static_cast<GLuint>(c.index);
@@ skipping 16 matching lines @@
         GL_INVALID_VALUE,
         "glBindUniformLocationCHROMIUM", "Invalid character");
     return;
   }
   if (ProgramManager::HasBuiltInPrefix(name)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindUniformLocationCHROMIUM", "reserved prefix");
     return;
   }
-  if (location < 0 || static_cast<uint32>(location) >=
-      (group_->max_fragment_uniform_vectors() +
-       group_->max_vertex_uniform_vectors()) * 4) {
+  if (location < 0 ||
+      static_cast<uint32_t>(location) >=
+          (group_->max_fragment_uniform_vectors() +
+           group_->max_vertex_uniform_vectors()) *
+              4) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glBindUniformLocationCHROMIUM", "location out of range");
     return;
   }
   Program* program = GetProgramInfoNotShader(
       program_id, "glBindUniformLocationCHROMIUM");
   if (!program) {
     return;
   }
   if (!program->SetUniformLocationBinding(name, location)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glBindUniformLocationCHROMIUM", "location out of range");
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUMBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindUniformLocationCHROMIUMBucket& c =
       *static_cast<const gles2::cmds::BindUniformLocationCHROMIUMBucket*>(
           cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindUniformLocationCHROMIUM(program, location, name_str);
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteShader(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleDeleteShader(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
   const gles2::cmds::DeleteShader& c =
       *static_cast<const gles2::cmds::DeleteShader*>(cmd_data);
   GLuint client_id = c.shader;
   if (client_id) {
     Shader* shader = GetShader(client_id);
     if (shader) {
       if (!shader->IsDeleted()) {
         shader_manager()->Delete(shader);
       }
     } else {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDeleteShader", "unknown shader");
     }
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteProgram(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleDeleteProgram(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::DeleteProgram& c =
       *static_cast<const gles2::cmds::DeleteProgram*>(cmd_data);
   GLuint client_id = c.program;
   if (client_id) {
     Program* program = GetProgram(client_id);
     if (program) {
       if (!program->IsDeleted()) {
         program_manager()->MarkAsDeleted(shader_manager(), program);
       }
@@ skipping 632 matching lines @@
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glRenderbufferStorageMultisample", "dimensions too large");
     return false;
   }
 
-  uint32 estimated_size = 0;
+  uint32_t estimated_size = 0;
   if (!renderbuffer_manager()->ComputeEstimatedRenderbufferSize(
            width, height, samples, internalformat, &estimated_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY,
         "glRenderbufferStorageMultisample", "dimensions too large");
     return false;
   }
 
   if (!EnsureGPUMemoryAvailable(estimated_size)) {
     LOCAL_SET_GL_ERROR(
@@ skipping 206 matching lines @@
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glRenderbufferStorage", "dimensions too large");
     return;
   }
 
-  uint32 estimated_size = 0;
+  uint32_t estimated_size = 0;
   if (!renderbuffer_manager()->ComputeEstimatedRenderbufferSize(
            width, height, 1, internalformat, &estimated_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glRenderbufferStorage", "dimensions too large");
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(estimated_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glRenderbufferStorage", "out of memory");
@@ skipping 978 matching lines @@
   bool attrib_0_used =
       state_.current_program->GetAttribInfoByLocation(0) != NULL;
   if (attrib->enabled() && attrib_0_used) {
     return true;
   }
 
   // Make a buffer with a single repeated vec4 value enough to
   // simulate the constant value that is supposed to be here.
   // This is required to emulate GLES2 on GL.
   GLuint num_vertices = max_vertex_accessed + 1;
-  uint32 size_needed = 0;
+  uint32_t size_needed = 0;
 
   if (num_vertices == 0 ||
       !SafeMultiplyUint32(num_vertices, sizeof(Vec4f), &size_needed) ||
       size_needed > 0x7FFFFFFFU) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
     return false;
   }
 
   LOCAL_PERFORMANCE_WARNING(
       "Attribute 0 is disabled. This has signficant performance penalty");
@@ skipping 106 matching lines @@
                                                     max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         attrib->CanAccess(max_accessed) &&
         attrib->type() == GL_FIXED) {
-      uint32 elements_used = 0;
+      uint32_t elements_used = 0;
       if (!SafeMultiplyUint32(num_vertices, attrib->size(), &elements_used) ||
           !SafeAddUint32(elements_needed, elements_used, &elements_needed)) {
         LOCAL_SET_GL_ERROR(
             GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
         return false;
       }
     }
   }
 
-  const uint32 kSizeOfFloat = sizeof(float);  // NOLINT
-  uint32 size_needed = 0;
+  const uint32_t kSizeOfFloat = sizeof(float);  // NOLINT
+  uint32_t size_needed = 0;
   if (!SafeMultiplyUint32(elements_needed, kSizeOfFloat, &size_needed) ||
       size_needed > 0x7FFFFFFFU) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
     return false;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
 
   glBindBuffer(GL_ARRAY_BUFFER, fixed_attrib_buffer_id_);
@@ skipping 19 matching lines @@
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         attrib->CanAccess(max_accessed) &&
         attrib->type() == GL_FIXED) {
       int num_elements = attrib->size() * num_vertices;
-      const int src_size = num_elements * sizeof(int32);
+      const int src_size = num_elements * sizeof(int32_t);
       const int dst_size = num_elements * sizeof(float);
       scoped_ptr<float[]> data(new float[num_elements]);
-      const int32* src = reinterpret_cast<const int32 *>(
+      const int32_t* src = reinterpret_cast<const int32_t*>(
           attrib->buffer()->GetRange(attrib->offset(), src_size));
-      const int32* end = src + num_elements;
+      const int32_t* end = src + num_elements;
       float* dst = data.get();
       while (src != end) {
         *dst++ = static_cast<float>(*src++) / 65536.0f;
       }
       glBufferSubData(GL_ARRAY_BUFFER, offset, dst_size, data.get());
       glVertexAttribPointer(
           attrib->index(), attrib->size(), GL_FLOAT, false, 0,
           reinterpret_cast<GLvoid*>(offset));
       offset += dst_size;
     }
@@ skipping 81 matching lines @@
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDrawArrays(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleDrawArrays(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   // TODO(zmo): crbug.com/481184
   // On Desktop GL with versions lower than 4.3, we need to emulate
   // GL_PRIMITIVE_RESTART_FIXED_INDEX using glPrimitiveRestartIndex().
   const cmds::DrawArrays& c = *static_cast<const cmds::DrawArrays*>(cmd_data);
   return DoDrawArrays("glDrawArrays",
                       false,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::DrawArraysInstancedANGLE& c =
       *static_cast<const gles2::cmds::DrawArraysInstancedANGLE*>(cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
   return DoDrawArrays("glDrawArraysIntancedANGLE",
                       true,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       static_cast<GLsizei>(c.primcount));
 }
 
-error::Error GLES2DecoderImpl::DoDrawElements(
-    const char* function_name,
-    bool instanced,
-    GLenum mode,
-    GLsizei count,
-    GLenum type,
-    int32 offset,
-    GLsizei primcount) {
+error::Error GLES2DecoderImpl::DoDrawElements(const char* function_name,
+                                              bool instanced,
+                                              GLenum mode,
+                                              GLsizei count,
+                                              GLenum type,
+                                              int32_t offset,
+                                              GLsizei primcount) {
   error::Error error = WillAccessBoundFramebufferForDraw();
   if (error != error::kNoError)
     return error;
   if (!state_.vertex_attrib_manager->element_array_buffer()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "No element array buffer bound");
     return error::kNoError;
   }
 
   if (count < 0) {
@@ skipping 84 matching lines @@
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDrawElements(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleDrawElements(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
   // TODO(zmo): crbug.com/481184
   // On Desktop GL with versions lower than 4.3, we need to emulate
   // GL_PRIMITIVE_RESTART_FIXED_INDEX using glPrimitiveRestartIndex().
   const gles2::cmds::DrawElements& c =
       *static_cast<const gles2::cmds::DrawElements*>(cmd_data);
-  return DoDrawElements("glDrawElements",
-                        false,
-                        static_cast<GLenum>(c.mode),
+  return DoDrawElements("glDrawElements", false, static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
-                        static_cast<int32>(c.index_offset),
-                        1);
+                        static_cast<int32_t>(c.index_offset), 1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::DrawElementsInstancedANGLE& c =
       *static_cast<const gles2::cmds::DrawElementsInstancedANGLE*>(cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
-  return DoDrawElements("glDrawElementsInstancedANGLE",
-                        true,
-                        static_cast<GLenum>(c.mode),
-                        static_cast<GLsizei>(c.count),
-                        static_cast<GLenum>(c.type),
-                        static_cast<int32>(c.index_offset),
-                        static_cast<GLsizei>(c.primcount));
+  return DoDrawElements(
+      "glDrawElementsInstancedANGLE", true, static_cast<GLenum>(c.mode),
+      static_cast<GLsizei>(c.count), static_cast<GLenum>(c.type),
+      static_cast<int32_t>(c.index_offset), static_cast<GLsizei>(c.primcount));
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
   Buffer* buffer = GetBuffer(buffer_id);
   if (!buffer) {
     // TODO(gman): Should this be a GL error or a command buffer error?
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "GetMaxValueInBufferCHROMIUM", "unknown buffer");
@@ skipping 94 matching lines @@
       *params = shader->translated_source().size();
       if (*params)
         ++(*params);
       return;
     default:
       break;
   }
   glGetShaderiv(shader->service_id(), pname, params);
 }
 
-error::Error GLES2DecoderImpl::HandleGetShaderSource(uint32 immediate_data_size,
-                                                     const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleGetShaderSource(
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   const gles2::cmds::GetShaderSource& c =
       *static_cast<const gles2::cmds::GetShaderSource*>(cmd_data);
   GLuint shader_id = c.shader;
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderSource");
   if (!shader || shader->source().empty()) {
     bucket->SetSize(0);
     return error::kNoError;
   }
   bucket->SetFromString(shader->source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetTranslatedShaderSourceANGLE& c =
       *static_cast<const gles2::cmds::GetTranslatedShaderSourceANGLE*>(
           cmd_data);
   GLuint shader_id = c.shader;
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(
       shader_id, "glGetTranslatedShaderSourceANGLE");
   if (!shader) {
     bucket->SetSize(0);
     return error::kNoError;
   }
 
   // Make sure translator has been utilized in compile.
   shader->DoCompile();
 
   bucket->SetFromString(shader->translated_source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetProgramInfoLog& c =
       *static_cast<const gles2::cmds::GetProgramInfoLog*>(cmd_data);
   GLuint program_id = c.program;
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetProgramInfoLog");
   if (!program || !program->log_info()) {
     bucket->SetFromString("");
     return error::kNoError;
   }
   bucket->SetFromString(program->log_info()->c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetShaderInfoLog& c =
       *static_cast<const gles2::cmds::GetShaderInfoLog*>(cmd_data);
   GLuint shader_id = c.shader;
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderInfoLog");
   if (!shader) {
     bucket->SetFromString("");
     return error::kNoError;
   }
 
   // Shader must be compiled in order to get the info log.
   shader->DoCompile();
 
@@ skipping 323 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttribI4uiv(GLuint index, const GLuint* v) {
   if (SetVertexAttribValue("glVertexAttribI4uiv", index, v)) {
     glVertexAttribI4uiv(index, v);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribIPointer(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::VertexAttribIPointer& c =
       *static_cast<const gles2::cmds::VertexAttribIPointer*>(cmd_data);
 
   if (!state_.bound_array_buffer.get() ||
       state_.bound_array_buffer->IsDeleted()) {
     if (state_.vertex_attrib_manager.get() ==
         state_.default_vertex_attrib_manager.get()) {
@@ skipping 67 matching lines @@
                       GL_FALSE,
                       stride,
                       stride != 0 ? stride : component_size * size,
                       offset,
                       GL_TRUE);
   glVertexAttribIPointer(indx, size, type, stride, ptr);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::VertexAttribPointer& c =
       *static_cast<const gles2::cmds::VertexAttribPointer*>(cmd_data);
 
   if (!state_.bound_array_buffer.get() ||
       state_.bound_array_buffer->IsDeleted()) {
     if (state_.vertex_attrib_manager.get() ==
         state_.default_vertex_attrib_manager.get()) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glVertexAttribPointer", "no array buffer bound");
@@ skipping 84 matching lines @@
 void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
                                   GLsizei height) {
   state_.viewport_x = x;
   state_.viewport_y = y;
   state_.viewport_width = std::min(width, viewport_max_width_);
   state_.viewport_height = std::min(height, viewport_max_height_);
   glViewport(x, y, width, height);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::VertexAttribDivisorANGLE& c =
       *static_cast<const gles2::cmds::VertexAttribDivisorANGLE*>(cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glVertexAttribDivisorANGLE", "index out of range");
     return error::kNoError;
   }
 
   state_.vertex_attrib_manager->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 template <typename pixel_data_type>
-static void WriteAlphaData(
-    void* pixels, uint32 row_count, uint32 channel_count,
-    uint32 alpha_channel_index, uint32 unpadded_row_size,
-    uint32 padded_row_size, pixel_data_type alpha_value) {
+static void WriteAlphaData(void* pixels,
+                           uint32_t row_count,
+                           uint32_t channel_count,
+                           uint32_t alpha_channel_index,
+                           uint32_t unpadded_row_size,
+                           uint32_t padded_row_size,
+                           pixel_data_type alpha_value) {
   DCHECK_GT(channel_count, 0U);
   DCHECK_EQ(unpadded_row_size % sizeof(pixel_data_type), 0U);
-  uint32 unpadded_row_size_in_elements =
+  uint32_t unpadded_row_size_in_elements =
       unpadded_row_size / sizeof(pixel_data_type);
   DCHECK_EQ(padded_row_size % sizeof(pixel_data_type), 0U);
-  uint32 padded_row_size_in_elements =
+  uint32_t padded_row_size_in_elements =
       padded_row_size / sizeof(pixel_data_type);
   pixel_data_type* dst =
       static_cast<pixel_data_type*>(pixels) + alpha_channel_index;
-  for (uint32 yy = 0; yy < row_count; ++yy) {
+  for (uint32_t yy = 0; yy < row_count; ++yy) {
     pixel_data_type* end = dst + unpadded_row_size_in_elements;
     for (pixel_data_type* d = dst; d < end; d += channel_count) {
       *d = alpha_value;
     }
     dst += padded_row_size_in_elements;
   }
 }
 
 void GLES2DecoderImpl::FinishReadPixels(
     const cmds::ReadPixels& c,
     GLuint buffer) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::FinishReadPixels");
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   typedef cmds::ReadPixels::Result Result;
-  uint32 pixels_size;
+  uint32_t pixels_size;
   Result* result = NULL;
   if (c.result_shm_id != 0) {
     result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
     if (!result) {
       if (buffer != 0) {
         glDeleteBuffersARB(1, &buffer);
       }
       return;
     }
@@ skipping 29 matching lines @@
     glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB,
                  GetServiceId(state_.bound_pixel_pack_buffer.get()));
     glDeleteBuffersARB(1, &buffer);
   }
 
   if (result != NULL) {
     *result = true;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
+  uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   if ((channels_exist & 0x0008) == 0 &&
       workarounds().clear_alpha_in_readpixels) {
     // Set the alpha to 255 because some drivers are buggy in this regard.
-    uint32 temp_size;
+    uint32_t temp_size;
 
-    uint32 unpadded_row_size;
-    uint32 padded_row_size;
+    uint32_t unpadded_row_size;
+    uint32_t padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
             width, 2, 1, format, type, state_.pack_alignment, &temp_size,
             &unpadded_row_size, &padded_row_size)) {
       return;
     }
 
-    uint32 channel_count = 0;
-    uint32 alpha_channel = 0;
+    uint32_t channel_count = 0;
+    uint32_t alpha_channel = 0;
     switch (format) {
       case GL_RGBA:
       case GL_BGRA_EXT:
         channel_count = 4;
         alpha_channel = 3;
         break;
       case GL_ALPHA:
         channel_count = 1;
         alpha_channel = 0;
         break;
     }
 
     if (channel_count > 0) {
       switch (type) {
         case GL_UNSIGNED_BYTE:
-          WriteAlphaData<uint8>(
-              pixels, height, channel_count, alpha_channel, unpadded_row_size,
-              padded_row_size, 0xFF);
+          WriteAlphaData<uint8_t>(pixels, height, channel_count, alpha_channel,
+                                  unpadded_row_size, padded_row_size, 0xFF);
           break;
         case GL_FLOAT:
           WriteAlphaData<float>(
               pixels, height, channel_count, alpha_channel, unpadded_row_size,
               padded_row_size, 1.0f);
           break;
         case GL_HALF_FLOAT:
-          WriteAlphaData<uint16>(
-              pixels, height, channel_count, alpha_channel, unpadded_row_size,
-              padded_row_size, 0x3C00);
+          WriteAlphaData<uint16_t>(pixels, height, channel_count, alpha_channel,
+                                   unpadded_row_size, padded_row_size, 0x3C00);
           break;
       }
     }
   }
 }
 
-error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleReadPixels(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::ReadPixels& c =
       *static_cast<const gles2::cmds::ReadPixels*>(cmd_data);
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleReadPixels");
   error::Error fbo_error = WillAccessBoundFramebufferForRead();
   if (fbo_error != error::kNoError)
     return fbo_error;
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   GLboolean async = static_cast<GLboolean>(c.async);
   if (width < 0 || height < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
   typedef cmds::ReadPixels::Result Result;
-  uint32 pixels_size = 0;
+  uint32_t pixels_size = 0;
   if (c.pixels_shm_id == 0) {
     PixelStoreParams params = state_.GetPackParams();
     if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1, format, type,
         params, &pixels_size, nullptr, nullptr, nullptr)) {
       return error::kOutOfBounds;
     }
   } else {
     // When reading into client buffer, we actually set pack parameters to 0
     // (except for alignment) before calling glReadPixels. This makes sure we
     // only send back meaningful pixel data to the command buffer client side,
     // and the client side will take the responsibility to take the pixels and
     // write to the client buffer according to the full ES3 pack parameters.
     if (!GLES2Util::ComputeImageDataSizes(width, height, 1, format, type,
         state_.pack_alignment, &pixels_size, nullptr, nullptr)) {
       return error::kOutOfBounds;
     }
   }
 
   void* pixels = nullptr;
   Buffer* buffer = state_.bound_pixel_pack_buffer.get();
   if (c.pixels_shm_id == 0) {
     if (buffer) {
       if (buffer->GetMappedRange()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
             "pixel pack buffer should not be mapped to client memory");
         return error::kNoError;
       }
-      uint32 size = 0;
+      uint32_t size = 0;
       if (!SafeAddUint32(pixels_size, c.pixels_shm_offset, &size)) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_VALUE, "glReadPixels", "size + offset overflow");
         return error::kNoError;
       }
-      if (static_cast<uint32>(buffer->size()) < size) {
+      if (static_cast<uint32_t>(buffer->size()) < size) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
             "pixel pack buffer is not large enough");
         return error::kNoError;
       }
       pixels = reinterpret_cast<void *>(c.pixels_shm_offset);
     } else {
       return error::kInvalidArguments;
     }
   } else {
     if (buffer) {
@@ skipping 118 matching lines @@
         "format and type incompatible with the current read framebuffer");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
-  int32 max_x;
-  int32 max_y;
+  int32_t max_x;
+  int32_t max_y;
   if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
     return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid("glReadPixels")) {
     return error::kNoError;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glReadPixels");
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
 
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // TODO(yunchao): need to handle the out-of-bounds case for reading pixels
     // into PIXEL_PACK buffer.
     if (c.pixels_shm_id == 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
           "read pixels out of bounds into PIXEL_PACK buffer");
       return error::kNoError;
     }
     // The user requested an out of range area. Get the results 1 line
     // at a time.
-    uint32 temp_size;
-    uint32 unpadded_row_size;
-    uint32 padded_row_size;
+    uint32_t temp_size;
+    uint32_t unpadded_row_size;
+    uint32_t padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
         width, 2, 1, format, type, state_.pack_alignment, &temp_size,
         &unpadded_row_size, &padded_row_size)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     GLint dest_x_offset = std::max(-x, 0);
-    uint32 dest_row_offset;
+    uint32_t dest_row_offset;
     if (!GLES2Util::ComputeImageDataSizes(
         dest_x_offset, 1, 1, format, type, state_.pack_alignment,
         &dest_row_offset, NULL, NULL)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     // Copy each row into the larger dest rect.
-    int8* dst = static_cast<int8*>(pixels);
+    int8_t* dst = static_cast<int8_t*>(pixels);
     GLint read_x = std::max(0, x);
     GLint read_end_x = std::max(0, std::min(max_size.width(), max_x));
     GLint read_width = read_end_x - read_x;
     for (GLint yy = 0; yy < height; ++yy) {
       GLint ry = y + yy;
 
       // Clear the row.
       memset(dst, 0, unpadded_row_size);
 
       // If the row is in range, copy it.
@@ skipping 43 matching lines @@
       if (result != NULL) {
         *result = true;
       }
       FinishReadPixels(c, 0);
     }
   }
 
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandlePixelStorei(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandlePixelStorei(uint32_t immediate_data_size,
                                                  const void* cmd_data) {
   const gles2::cmds::PixelStorei& c =
       *static_cast<const gles2::cmds::PixelStorei*>(cmd_data);
   GLenum pname = c.pname;
   GLint param = c.param;
   if (!validators_->pixel_store.IsValid(pname)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glPixelStorei", pname, "pname");
     return error::kNoError;
   }
   switch (pname) {
@@ skipping 79 matching lines @@
       break;
     default:
       // Validation should have prevented us from getting here.
       NOTREACHED();
       break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::PostSubBufferCHROMIUM& c =
       *static_cast<const gles2::cmds::PostSubBufferCHROMIUM*>(cmd_data);
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandlePostSubBufferCHROMIUM");
   {
     TRACE_EVENT_SYNTHETIC_DELAY("gpu.PresentingFrame");
   }
   if (!supports_post_sub_buffer_) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ skipping 16 matching lines @@
         base::Bind(&GLES2DecoderImpl::FinishSwapBuffers,
                    base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->PostSubBuffer(c.x, c.y, c.width, c.height));
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleOverlayPlaneCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::ScheduleOverlayPlaneCHROMIUM& c =
       *static_cast<const gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(cmd_data);
   TextureRef* ref = texture_manager()->GetTexture(c.overlay_texture_id);
   if (!ref) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unknown texture");
     return error::kNoError;
   }
@@ skipping 24 matching lines @@
           gfx::Rect(c.bounds_x, c.bounds_y, c.bounds_width, c.bounds_height),
           gfx::RectF(c.uv_x, c.uv_y, c.uv_width, c.uv_height))) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "failed to schedule overlay");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleCALayerCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::ScheduleCALayerCHROMIUM& c =
       *static_cast<const gles2::cmds::ScheduleCALayerCHROMIUM*>(cmd_data);
   gl::GLImage* image = nullptr;
   if (c.contents_texture_id) {
     TextureRef* ref = texture_manager()->GetTexture(c.contents_texture_id);
     if (!ref) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleCALayerCHROMIUM",
                          "unknown texture");
       return error::kNoError;
@@ skipping 24 matching lines @@
                                  c.background_color, c.edge_aa_mask,
                                  bounds_rect, c.is_clipped ? true : false,
                                  clip_rect, transform)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glScheduleCALayerCHROMIUM",
                        "failed to schedule CALayer");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::GetAttribLocationHelper(
-    GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
+    GLuint client_id,
+    uint32_t location_shm_id,
+    uint32_t location_shm_offset,
     const std::string& name_str) {
   if (!StringIsValidForGLES(name_str)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glGetAttribLocation", "Invalid character");
     return error::kNoError;
   }
   Program* program = GetProgramInfoNotShader(
       client_id, "glGetAttribLocation");
   if (!program) {
     return error::kNoError;
@@ skipping 10 matching lines @@
   }
   // Check that the client initialized the result.
   if (*location != -1) {
     return error::kInvalidArguments;
   }
   *location = program->GetAttribLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocation(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetAttribLocation& c =
       *static_cast<const gles2::cmds::GetAttribLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::GetUniformLocationHelper(
-    GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
+    GLuint client_id,
+    uint32_t location_shm_id,
+    uint32_t location_shm_offset,
     const std::string& name_str) {
   if (!StringIsValidForGLES(name_str)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glGetUniformLocation", "Invalid character");
     return error::kNoError;
   }
   Program* program = GetProgramInfoNotShader(
       client_id, "glGetUniformLocation");
   if (!program) {
     return error::kNoError;
@@ skipping 10 matching lines @@
   }
   // Check that the client initialized the result.
   if (*location != -1) {
     return error::kInvalidArguments;
   }
   *location = program->GetUniformFakeLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocation(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetUniformLocation& c =
       *static_cast<const gles2::cmds::GetUniformLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformIndices(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetUniformIndices& c =
       *static_cast<const gles2::cmds::GetUniformIndices*>(cmd_data);
   Bucket* bucket = GetBucket(c.names_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   GLsizei count = 0;
@@ skipping 31 matching lines @@
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(count);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetUniformIndices", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::GetFragDataLocationHelper(
-    GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
+    GLuint client_id,
+    uint32_t location_shm_id,
+    uint32_t location_shm_offset,
     const std::string& name_str) {
   const char kFunctionName[] = "glGetFragDataLocation";
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (*location != -1) {
     return error::kInvalidArguments;
   }
   Program* program = GetProgramInfoNotShader(client_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   if (!program->IsValid()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "program not linked");
     return error::kNoError;
   }
 
   *location = program->GetFragDataLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataLocation(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetFragDataLocation& c =
       *static_cast<const gles2::cmds::GetFragDataLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataLocationHelper(
       c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::GetFragDataIndexHelper(
     GLuint program_id,
-    uint32 index_shm_id,
-    uint32 index_shm_offset,
+    uint32_t index_shm_id,
+    uint32_t index_shm_offset,
     const std::string& name_str) {
   const char kFunctionName[] = "glGetFragDataIndexEXT";
   GLint* index =
       GetSharedMemoryAs<GLint*>(index_shm_id, index_shm_offset, sizeof(GLint));
   if (!index) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (*index != -1) {
     return error::kInvalidArguments;
   }
   Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   if (!program->IsValid()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "program not linked");
     return error::kNoError;
   }
 
   *index = program->GetFragDataIndex(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataIndexEXT(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
   const gles2::cmds::GetFragDataIndexEXT& c =
       *static_cast<const gles2::cmds::GetFragDataIndexEXT*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataIndexHelper(c.program, c.index_shm_id, c.index_shm_offset,
                                 name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformBlockIndex(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetUniformBlockIndex& c =
       *static_cast<const gles2::cmds::GetUniformBlockIndex*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
@@ skipping 10 matching lines @@
   }
   Program* program = GetProgramInfoNotShader(
       c.program, "glGetUniformBlockIndex");
   if (!program) {
     return error::kNoError;
   }
   *index = glGetUniformBlockIndex(program->service_id(), name_str.c_str());
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGetString(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleGetString(uint32_t immediate_data_size,
                                                const void* cmd_data) {
   const gles2::cmds::GetString& c =
       *static_cast<const gles2::cmds::GetString*>(cmd_data);
   GLenum name = static_cast<GLenum>(c.name);
   if (!validators_->string_type.IsValid(name)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetString", name, "name");
     return error::kNoError;
   }
 
   const char* str = nullptr;
@@ skipping 65 matching lines @@
       break;
     default:
       str = reinterpret_cast<const char*>(glGetString(name));
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleBufferData(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleBufferData(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::BufferData& c =
       *static_cast<const gles2::cmds::BufferData*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
-  uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
-  uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
+  uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
+  uint32_t data_shm_offset = static_cast<uint32_t>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   buffer_manager()->ValidateAndDoBufferData(&state_, target, size, data, usage);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferSubData(
   GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   // Just delegate it. Some validation is actually done before this.
   buffer_manager()->ValidateAndDoBufferSubData(
       &state_, target, offset, size, data);
 }
 
 bool GLES2DecoderImpl::ClearLevel(Texture* texture,
                                   unsigned target,
                                   int level,
                                   unsigned format,
                                   unsigned type,
                                   int xoffset,
                                   int yoffset,
                                   int width,
                                   int height) {
-  uint32 channels = GLES2Util::GetChannelsForFormat(format);
+  uint32_t channels = GLES2Util::GetChannelsForFormat(format);
   if ((feature_info_->feature_flags().angle_depth_texture ||
        feature_info_->IsES3Enabled())
       && (channels & GLES2Util::kDepth) != 0) {
     // It's a depth format and ANGLE doesn't allow texImage2D or texSubImage2D
     // on depth formats.
     GLuint fb = 0;
     glGenFramebuffersEXT(1, &fb);
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb);
 
     bool have_stencil = (channels & GLES2Util::kStencil) != 0;
@@ skipping 20 matching lines @@
 
     glDeleteFramebuffersEXT(1, &fb);
     Framebuffer* framebuffer =
         GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
     GLuint fb_service_id =
         framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb_service_id);
     return true;
   }
 
-  static const uint32 kMaxZeroSize = 1024 * 1024 * 4;
+  static const uint32_t kMaxZeroSize = 1024 * 1024 * 4;
 
-  uint32 size;
-  uint32 padded_row_size;
+  uint32_t size;
+  uint32_t padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, 1, format, type, state_.unpack_alignment, &size,
           NULL, &padded_row_size)) {
     return false;
   }
 
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::ClearLevel", "size", size);
 
   int tile_height;
 
@@ skipping 484 matching lines @@
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
-  scoped_ptr<int8[]> zero;
+  scoped_ptr<int8_t[]> zero;
   if (!data) {
-    zero.reset(new int8[image_size]);
+    zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, 1, border, 0, 0,
                                     gfx::Rect(width, height));
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CompressedTexImage2D& c =
       *static_cast<const gles2::cmds::CompressedTexImage2D*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
-  uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
-  uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
+  uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
+  uint32_t data_shm_offset = static_cast<uint32_t>(c.data_shm_offset);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2DBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CompressedTexImage2DBucket& c =
       *static_cast<const gles2::cmds::CompressedTexImage2DBucket*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
-  uint32 data_size = bucket->size();
+  uint32_t data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border,
       imageSize, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CompressedTexSubImage2DBucket& c =
       *static_cast<const gles2::cmds::CompressedTexSubImage2DBucket*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
-  uint32 data_size = bucket->size();
+  uint32_t data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   if (!validators_->texture_target.IsValid(target)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_ENUM, "glCompressedTexSubImage2D", "target");
     return error::kNoError;
   }
@@ skipping 76 matching lines @@
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage3D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
-  scoped_ptr<int8[]> zero;
+  scoped_ptr<int8_t[]> zero;
   if (!data) {
-    zero.reset(new int8[image_size]);
+    zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage3D");
   glCompressedTexImage3D(target, level, internal_format, width, height, depth,
                          border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage3D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, depth, border, 0, 0,
                                     gfx::Rect(width, height));
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage3D(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
   const gles2::cmds::CompressedTexImage3D& c =
       *static_cast<const gles2::cmds::CompressedTexImage3D*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
-  uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
-  uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
+  uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
+  uint32_t data_shm_offset = static_cast<uint32_t>(c.data_shm_offset);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   return DoCompressedTexImage3D(target, level, internal_format, width, height,
                                 depth, border, image_size, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage3DBucket(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
   const gles2::cmds::CompressedTexImage3DBucket& c =
       *static_cast<const gles2::cmds::CompressedTexImage3DBucket*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLint border = static_cast<GLint>(c.border);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
-  uint32 data_size = bucket->size();
+  uint32_t data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   return DoCompressedTexImage3D(target, level, internal_format, width, height,
                                 depth, border, imageSize, data);
 }
 
 void GLES2DecoderImpl::DoCompressedTexSubImage3D(
@@ skipping 62 matching lines @@
   glCompressedTexSubImage3D(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       image_size, data);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3DBucket(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::CompressedTexSubImage3DBucket& c =
       *static_cast<const gles2::cmds::CompressedTexSubImage3DBucket*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLenum format = static_cast<GLenum>(c.format);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
-  uint32 data_size = bucket->size();
+  uint32_t data_size = bucket->size();
   GLsizei image_size = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   DoCompressedTexSubImage3D(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       image_size, data);
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexImage2D(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleTexImage2D(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::TexImage2D& c =
       *static_cast<const gles2::cmds::TexImage2D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexImage2D",
       "width", c.width, "height", c.height);
   // Set as failed for now, but if it successed, this will be set to not failed.
   texture_state_.tex_image_failed = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   // TODO(kloveless): Change TexImage2D command to use unsigned integer
   // for internalformat.
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
-  uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
-  uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
-  uint32 pixels_size;
+  uint32_t pixels_shm_id = static_cast<uint32_t>(c.pixels_shm_id);
+  uint32_t pixels_shm_offset = static_cast<uint32_t>(c.pixels_shm_offset);
+  uint32_t pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, state_.unpack_alignment, &pixels_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
@@ skipping 15 matching lines @@
     pixels, pixels_size, TextureManager::DoTexImageArguments::kTexImage2D };
   texture_manager()->ValidateAndDoTexImage(
       &texture_state_, &state_, &framebuffer_state_, "glTexImage2D", args);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexImage3D(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleTexImage3D(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
   const gles2::cmds::TexImage3D& c =
       *static_cast<const gles2::cmds::TexImage3D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexImage3D",
       "widthXheight", c.width * c.height, "depth", c.depth);
   // Set as failed for now, but if it successed, this will be set to not failed.
   texture_state_.tex_image_failed = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
-  uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
-  uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
-  uint32 pixels_size;
+  uint32_t pixels_shm_id = static_cast<uint32_t>(c.pixels_shm_id);
+  uint32_t pixels_shm_offset = static_cast<uint32_t>(c.pixels_shm_offset);
+  uint32_t pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, depth, format, type, state_.unpack_alignment, &pixels_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
@@ skipping 126 matching lines @@
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
-  uint32 channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
+  uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
+  uint32_t channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glCopyTexImage2D", "incompatible format");
     return;
   }
 
   if (feature_info_->IsES3Enabled()) {
     GLint color_encoding = GetColorEncodingFromInternalFormat(read_format);
     if (color_encoding != GetColorEncodingFromInternalFormat(internal_format) ||
         GLES2Util::IsFloatFormat(internal_format) ||
         (GLES2Util::IsSignedIntegerFormat(internal_format) !=
          GLES2Util::IsSignedIntegerFormat(read_format)) ||
         (GLES2Util::IsUnsignedIntegerFormat(internal_format) !=
          GLES2Util::IsUnsignedIntegerFormat(read_format))) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION, "glCopyTexImage2D", "incompatible format");
       return;
     }
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCopyTexImage2D", "can not be used with depth or stencil textures");
     return;
   }
 
-  uint32 pixels_size = 0;
+  uint32_t pixels_size = 0;
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
   // Only target image size is validated here.
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type,
       state_.unpack_alignment, &pixels_size, NULL, NULL)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCopyTexImage2D", "dimensions too large");
     return;
@@ skipping 93 matching lines @@
   if (!texture->GetLevelType(target, level, &type, &format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
-  uint32 channels_needed = GLES2Util::GetChannelsForFormat(format);
+  uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
+  uint32_t channels_needed = GLES2Util::GetChannelsForFormat(format);
 
   if (!channels_needed ||
       (channels_needed & channels_exist) != channels_needed) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glCopyTexSubImage2D", "incompatible format");
     return;
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     LOCAL_SET_GL_ERROR(
@@ skipping 48 matching lines @@
   } else {
     // Write all pixels in below.
     texture_manager()->SetLevelCleared(texture_ref, target, level, true);
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
-    uint32 pixels_size = 0;
+    uint32_t pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSizes(
         width, height, 1, format, type, state_.unpack_alignment, &pixels_size,
         NULL, NULL)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glCopyTexSubImage2D", "dimensions too large");
       return;
     }
     scoped_ptr<char[]> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
     GLint dx = copyX - x;
     GLint dy = copyY - y;
     GLint destX = xoffset + dx;
     GLint destY = yoffset + dy;
     glCopyTexSubImage2D(target, level,
                         destX, destY, copyX, copyY,
                         copyWidth, copyHeight);
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
-error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::TexSubImage2D& c =
       *static_cast<const gles2::cmds::TexSubImage2D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage2D",
       "width", c.width, "height", c.height);
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && texture_state_.tex_image_failed)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
-  uint32 data_size;
+  uint32_t data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
 
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!pixels)
     return error::kOutOfBounds;
@@ skipping 40 matching lines @@
     // image is cleared.
     texture_manager()->SetLevelCleared(texture_ref, target, level, true);
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexSubImage3D(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleTexSubImage3D(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
   const gles2::cmds::TexSubImage3D& c =
       *static_cast<const gles2::cmds::TexSubImage3D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage3D",
       "widthXheight", c.width * c.height, "depth", c.depth);
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && texture_state_.tex_image_failed)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
-  uint32 data_size;
+  uint32_t data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, depth, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   return DoTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
                          height, depth, format, type, pixels);
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetVertexAttribPointerv& c =
       *static_cast<const gles2::cmds::GetVertexAttribPointerv*>(cmd_data);
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
@@ skipping 14 matching lines @@
   }
   result->SetNumResults(1);
   *result->GetData() =
       state_.vertex_attrib_manager->GetVertexAttrib(index)->offset();
   return error::kNoError;
 }
 
 template <class T>
 bool GLES2DecoderImpl::GetUniformSetup(GLuint program_id,
                                        GLint fake_location,
-                                       uint32 shm_id,
-                                       uint32 shm_offset,
+                                       uint32_t shm_id,
+                                       uint32_t shm_offset,
                                        error::Error* error,
                                        GLint* real_location,
                                        GLuint* service_id,
                                        SizedResult<T>** result_pointer,
                                        GLenum* result_type,
                                        GLsizei* result_size) {
   DCHECK(error);
   DCHECK(service_id);
   DCHECK(result_pointer);
   DCHECK(result_type);
@@ skipping 26 matching lines @@
   const Program::UniformInfo* uniform_info =
       program->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!uniform_info) {
     // No such location.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glGetUniform", "unknown location");
     return false;
   }
   GLenum type = uniform_info->type;
-  uint32 num_elements = GLES2Util::GetElementCountForUniformType(type);
+  uint32_t num_elements = GLES2Util::GetElementCountForUniformType(type);
   if (num_elements == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGetUniform", "unknown type");
     return false;
   }
   result = GetSharedMemoryAs<SizedResult<T>*>(
       shm_id, shm_offset, SizedResult<T>::ComputeSize(num_elements));
   if (!result) {
     *error = error::kOutOfBounds;
     return false;
   }
   result->SetNumResults(num_elements);
   *result_size = num_elements * sizeof(T);
   *result_type = type;
   return true;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformiv(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleGetUniformiv(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
   const gles2::cmds::GetUniformiv& c =
       *static_cast<const gles2::cmds::GetUniformiv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLenum result_type;
   GLsizei result_size;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformiv::Result* result;
   if (GetUniformSetup<GLint>(program, fake_location, c.params_shm_id,
                              c.params_shm_offset, &error, &real_location,
                              &service_id, &result, &result_type,
                              &result_size)) {
     glGetUniformiv(
         service_id, real_location, result->GetData());
   }
   return error;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformuiv(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleGetUniformuiv(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
   const gles2::cmds::GetUniformuiv& c =
       *static_cast<const gles2::cmds::GetUniformuiv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLenum result_type;
   GLsizei result_size;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformuiv::Result* result;
   if (GetUniformSetup<GLuint>(program, fake_location, c.params_shm_id,
                               c.params_shm_offset, &error, &real_location,
                               &service_id, &result, &result_type,
                               &result_size)) {
     glGetUniformuiv(
         service_id, real_location, result->GetData());
   }
   return error;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformfv(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleGetUniformfv(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
   const gles2::cmds::GetUniformfv& c =
       *static_cast<const gles2::cmds::GetUniformfv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformfv::Result* result;
   GLenum result_type;
@@ skipping 12 matching lines @@
         dst[ii] = (temp[ii] != 0);
       }
     } else {
       glGetUniformfv(service_id, real_location, result->GetData());
     }
   }
   return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetShaderPrecisionFormat& c =
       *static_cast<const gles2::cmds::GetShaderPrecisionFormat*>(cmd_data);
   GLenum shader_type = static_cast<GLenum>(c.shadertype);
   GLenum precision_type = static_cast<GLenum>(c.precisiontype);
   typedef cmds::GetShaderPrecisionFormat::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
@@ skipping 20 matching lines @@
   GetShaderPrecisionFormatImpl(shader_type, precision_type, range, &precision);
 
   result->min_range = range[0];
   result->max_range = range[1];
   result->precision = precision;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetAttachedShaders& c =
       *static_cast<const gles2::cmds::GetAttachedShaders*>(cmd_data);
-  uint32 result_size = c.result_size;
+  uint32_t result_size = c.result_size;
   GLuint program_id = static_cast<GLuint>(c.program);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetAttachedShaders");
   if (!program) {
     return error::kNoError;
   }
   typedef cmds::GetAttachedShaders::Result Result;
-  uint32 max_count = Result::ComputeMaxResults(result_size);
+  uint32_t max_count = Result::ComputeMaxResults(result_size);
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, Result::ComputeSize(max_count));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   GLsizei count = 0;
   glGetAttachedShaders(
       program->service_id(), max_count, &count, result->GetData());
   for (GLsizei ii = 0; ii < count; ++ii) {
     if (!shader_manager()->GetClientId(result->GetData()[ii],
                                        &result->GetData()[ii])) {
       NOTREACHED();
       return error::kGenericError;
     }
   }
   result->SetNumResults(count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniform(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetActiveUniform& c =
       *static_cast<const gles2::cmds::GetActiveUniform*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
-  uint32 name_bucket_id = c.name_bucket_id;
+  uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveUniform::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
@@ skipping 11 matching lines @@
   }
   result->success = 1;  // true.
   result->size = uniform_info->size;
   result->type = uniform_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(uniform_info->name.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockiv(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetActiveUniformBlockiv& c =
       *static_cast<const gles2::cmds::GetActiveUniformBlockiv*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetActiveUniformBlockiv");
   if (!program) {
@@ skipping 36 matching lines @@
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetActiveUniformBlockiv", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockName(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetActiveUniformBlockName& c =
       *static_cast<const gles2::cmds::GetActiveUniformBlockName*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
-  uint32 name_bucket_id = c.name_bucket_id;
+  uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveUniformBlockName::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (*result != 0) {
     return error::kInvalidArguments;
   }
@@ skipping 25 matching lines @@
   }
   *result = 1;
   Bucket* bucket = CreateBucket(name_bucket_id);
   DCHECK_GT(buf_size, length);
   DCHECK_EQ(0, buffer[length]);
   bucket->SetFromString(&buffer[0]);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformsiv(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetActiveUniformsiv& c =
       *static_cast<const gles2::cmds::GetActiveUniformsiv*>(cmd_data);
   GLuint program_id = c.program;
   GLenum pname = static_cast<GLenum>(c.pname);
   Bucket* bucket = GetBucket(c.indices_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
@@ skipping 31 matching lines @@
   glGetActiveUniformsiv(service_id, count, indices, pname, params);
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(count);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetActiveUniformsiv", "");
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGetActiveAttrib(uint32 immediate_data_size,
-                                                     const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleGetActiveAttrib(
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   const gles2::cmds::GetActiveAttrib& c =
       *static_cast<const gles2::cmds::GetActiveAttrib*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
-  uint32 name_bucket_id = c.name_bucket_id;
+  uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveAttrib::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
@@ skipping 10 matching lines @@
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = attrib_info->size;
   result->type = attrib_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(attrib_info->name.c_str());
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleShaderBinary(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleShaderBinary(uint32_t immediate_data_size,
                                                   const void* cmd_data) {
 #if 1  // No binary shader support.
   LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glShaderBinary", "not supported");
   return error::kNoError;
 #else
   GLsizei n = static_cast<GLsizei>(c.n);
   if (n < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "n < 0");
     return error::kNoError;
   }
   GLsizei length = static_cast<GLsizei>(c.length);
   if (length < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "length < 0");
     return error::kNoError;
   }
-  uint32 data_size;
+  uint32_t data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* shaders = GetSharedMemoryAs<const GLuint*>(
       c.shaders_shm_id, c.shaders_shm_offset, data_size);
   GLenum binaryformat = static_cast<GLenum>(c.binaryformat);
   const void* binary = GetSharedMemoryAs<const void*>(
       c.binary_shm_id, c.binary_shm_offset, length);
   if (shaders == NULL || binary == NULL) {
     return error::kOutOfBounds;
@@ skipping 152 matching lines @@
   } else {
     FinishSwapBuffers(surface_->CommitOverlayPlanes());
   }
 }
 
 void GLES2DecoderImpl::DoSwapInterval(int interval) {
   context_->SetSwapInterval(interval);
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::EnableFeatureCHROMIUM& c =
       *static_cast<const gles2::cmds::EnableFeatureCHROMIUM*>(cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   typedef cmds::EnableFeatureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
@@ skipping 26 matching lines @@
     const_cast<Validators*>(validators_)->vertex_attrib_type.AddValue(GL_FIXED);
   } else {
     return error::kNoError;
   }
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetRequestableExtensionsCHROMIUM& c =
       *static_cast<const gles2::cmds::GetRequestableExtensionsCHROMIUM*>(
           cmd_data);
   Bucket* bucket = CreateBucket(c.bucket_id);
   scoped_refptr<FeatureInfo> info(new FeatureInfo());
   info->Initialize(feature_info_->context_type(), disallowed_features_);
   bucket->SetFromString(info->extensions().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::RequestExtensionCHROMIUM& c =
       *static_cast<const gles2::cmds::RequestExtensionCHROMIUM*>(cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
@@ skipping 24 matching lines @@
     shader_texture_lod_explicitly_enabled_ |= desire_shader_texture_lod;
     InitializeShaderTranslator();
   }
 
   UpdateCapabilities();
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetProgramInfoCHROMIUM& c =
       *static_cast<const gles2::cmds::GetProgramInfoCHROMIUM*>(cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
-  uint32 bucket_id = c.bucket_id;
+  uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(ProgramInfoHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetProgramInfo(program_manager(), bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformBlocksCHROMIUM(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetUniformBlocksCHROMIUM& c =
       *static_cast<const gles2::cmds::GetUniformBlocksCHROMIUM*>(cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
-  uint32 bucket_id = c.bucket_id;
+  uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(UniformBlocksHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetUniformBlocks(bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformsES3CHROMIUM(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetUniformsES3CHROMIUM& c =
       *static_cast<const gles2::cmds::GetUniformsES3CHROMIUM*>(cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
-  uint32 bucket_id = c.bucket_id;
+  uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(UniformsES3Header));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetUniformsES3(bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVarying(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetTransformFeedbackVarying& c =
       *static_cast<const gles2::cmds::GetTransformFeedbackVarying*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
-  uint32 name_bucket_id = c.name_bucket_id;
+  uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetTransformFeedbackVarying::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
@@ skipping 30 matching lines @@
   result->size = static_cast<int32_t>(size);
   result->type = static_cast<uint32_t>(type);
   Bucket* bucket = CreateBucket(name_bucket_id);
   DCHECK(length >= 0 && length < max_length);
   buffer[length] = '\0';  // Just to be safe.
   bucket->SetFromString(&buffer[0]);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVaryingsCHROMIUM(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM& c =
       *static_cast<const gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM*>(
           cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
-  uint32 bucket_id = c.bucket_id;
+  uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(TransformFeedbackVaryingsHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetTransformFeedbackVaryings(bucket);
   return error::kNoError;
 }
@@ skipping 73 matching lines @@
         NOTREACHED();
         return false;
     }
     reset_by_robustness_extension_ = true;
     return true;
   }
   return false;
 }
 
 error::Error GLES2DecoderImpl::HandleInsertSyncPointCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitSyncPointCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::WaitSyncPointCHROMIUM& c =
       *static_cast<const gles2::cmds::WaitSyncPointCHROMIUM*>(cmd_data);
-  uint32 sync_point = c.sync_point;
+  uint32_t sync_point = c.sync_point;
   if (wait_sync_point_callback_.is_null())
     return error::kNoError;
 
   return wait_sync_point_callback_.Run(sync_point) ?
       error::kNoError : error::kDeferCommandUntilLater;
 }
 
 error::Error GLES2DecoderImpl::HandleInsertFenceSyncCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::InsertFenceSyncCHROMIUM& c =
       *static_cast<const gles2::cmds::InsertFenceSyncCHROMIUM*>(cmd_data);
 
   const uint64_t release_count = c.release_count();
   if (!fence_sync_release_callback_.is_null())
     fence_sync_release_callback_.Run(release_count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenSyncTokenCHROMIUMImmediate(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
 
 error::Error GLES2DecoderImpl::HandleGenUnverifiedSyncTokenCHROMIUMImmediate(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
 
 error::Error GLES2DecoderImpl::HandleVerifySyncTokensCHROMIUMImmediate(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitSyncTokenCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::WaitSyncTokenCHROMIUM& c =
       *static_cast<const gles2::cmds::WaitSyncTokenCHROMIUM*>(cmd_data);
 
   const gpu::CommandBufferNamespace kMinNamespaceId =
       gpu::CommandBufferNamespace::INVALID;
   const gpu::CommandBufferNamespace kMaxNamespaceId =
       gpu::CommandBufferNamespace::NUM_COMMAND_BUFFER_NAMESPACES;
 
   const gpu::CommandBufferNamespace namespace_id =
       ((c.namespace_id >= static_cast<int32_t>(kMinNamespaceId)) &&
        (c.namespace_id < static_cast<int32_t>(kMaxNamespaceId)))
           ? static_cast<gpu::CommandBufferNamespace>(c.namespace_id)
           : gpu::CommandBufferNamespace::INVALID;
   const uint64_t command_buffer_id = c.command_buffer_id();
   const uint64_t release = c.release_count();
   if (wait_fence_sync_callback_.is_null())
     return error::kNoError;
 
   return wait_fence_sync_callback_.Run(namespace_id, command_buffer_id, release)
              ? error::kNoError
              : error::kDeferCommandUntilLater;
 }
 
 error::Error GLES2DecoderImpl::HandleDiscardBackbufferCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
   if (!surface_->SetBackbufferAllocation(false))
     return error::kLostContext;
   backbuffer_needs_clear_bits_ |= GL_COLOR_BUFFER_BIT;
   backbuffer_needs_clear_bits_ |= GL_DEPTH_BUFFER_BIT;
   backbuffer_needs_clear_bits_ |= GL_STENCIL_BUFFER_BIT;
   return error::kNoError;
 }
@@ skipping 56 matching lines @@
 bool GLES2DecoderImpl::HasMoreIdleWork() const {
   return !pending_readpixel_fences_.empty() ||
          gpu_tracer_->HasTracesToProcess();
 }
 
 void GLES2DecoderImpl::PerformIdleWork() {
   gpu_tracer_->ProcessTraces();
   ProcessPendingReadPixels(false);
 }
 
-error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::BeginQueryEXT& c =
       *static_cast<const gles2::cmds::BeginQueryEXT*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
-  int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
-  uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
+  int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
+  uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
 
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
       break;
     case GL_COMMANDS_COMPLETED_CHROMIUM:
       if (!features().chromium_sync_query) {
         LOCAL_SET_GL_ERROR(
@@ skipping 65 matching lines @@
     return error::kInvalidArguments;
   }
 
   if (!query_manager_->BeginQuery(query)) {
     return error::kOutOfBounds;
   }
 
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleEndQueryEXT(uint32 immediate_data_size,
+error::Error GLES2DecoderImpl::HandleEndQueryEXT(uint32_t immediate_data_size,
                                                  const void* cmd_data) {
   const gles2::cmds::EndQueryEXT& c =
       *static_cast<const gles2::cmds::EndQueryEXT*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
-  uint32 submit_count = static_cast<GLuint>(c.submit_count);
+  uint32_t submit_count = static_cast<GLuint>(c.submit_count);
 
   QueryManager::Query* query = query_manager_->GetActiveQuery(target);
   if (!query) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glEndQueryEXT", "No active query");
     return error::kNoError;
   }
 
   if (!query_manager_->EndQuery(query, submit_count)) {
     return error::kOutOfBounds;
   }
 
   query_manager_->ProcessPendingTransferQueries();
 
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleQueryCounterEXT(uint32 immediate_data_size,
-                                                     const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleQueryCounterEXT(
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   const gles2::cmds::QueryCounterEXT& c =
       *static_cast<const gles2::cmds::QueryCounterEXT*>(cmd_data);
   GLuint client_id = static_cast<GLuint>(c.id);
   GLenum target = static_cast<GLenum>(c.target);
-  int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
-  uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
-  uint32 submit_count = static_cast<GLuint>(c.submit_count);
+  int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
+  uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
+  uint32_t submit_count = static_cast<GLuint>(c.submit_count);
 
   switch (target) {
     case GL_TIMESTAMP:
       if (!query_manager_->GPUTimingAvailable()) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_OPERATION, "glQueryCounterEXT",
             "not enabled for timing queries");
         return error::kNoError;
       }
       break;
@@ skipping 16 matching lines @@
         target, client_id, sync_shm_id, sync_shm_offset);
   }
   if (!query_manager_->QueryCounter(query, submit_count)) {
     return error::kOutOfBounds;
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleSetDisjointValueSyncCHROMIUM(
-    uint32 immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
   const gles2::cmds::SetDisjointValueSyncCHROMIUM& c =
       *static_cast<const gles2::cmds::SetDisjointValueSyncCHROMIUM*>(cmd_data);
-  int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
-  uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
+  int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
+  uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
 
   query_manager_->SetDisjointSync(sync_shm_id, sync_shm_offset);
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GenVertexArraysOESHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetVertexAttribManager(client_ids[ii])) {
       return false;
@@ skipping 57 matching lines @@
     } else {
       GLuint service_id = vao->service_id();
       glBindVertexArrayOES(service_id);
     }
   }
 }
 
 // Used when OES_vertex_array_object isn't natively supported
 void GLES2DecoderImpl::EmulateVertexArrayState() {
   // Setup the Vertex attribute state
-  for (uint32 vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
+  for (uint32_t vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
     RestoreStateForAttrib(vv, true);
   }
 
   // Setup the element buffer
   Buffer* element_array_buffer =
       state_.vertex_attrib_manager->element_array_buffer();
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
       element_array_buffer ? element_array_buffer->service_id() : 0);
 }
 
@@ skipping 974 matching lines @@
     return;
   }
 
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
 
   {
     GLsizei level_width = width;
     GLsizei level_height = height;
-    uint32 estimated_size = 0;
+    uint32_t estimated_size = 0;
     for (int ii = 0; ii < levels; ++ii) {
-      uint32 level_size = 0;
+      uint32_t level_size = 0;
       if (!GLES2Util::ComputeImageDataSizes(
           level_width, level_height, 1, format, type, state_.unpack_alignment,
           &estimated_size, NULL, NULL) ||
           !SafeAddUint32(estimated_size, level_size, &estimated_size)) {
         LOCAL_SET_GL_ERROR(
             GL_OUT_OF_MEMORY, "glTexStorage2DEXT", "dimensions too large");
         return;
       }
       level_width = std::max(1, level_width >> 1);
       level_height = std::max(1, level_height >> 1);
@@ skipping 28 matching lines @@
                                         format, type, gfx::Rect());
       }
       level_width = std::max(1, level_width >> 1);
       level_height = std::max(1, level_height >> 1);
     }
     texture->SetImmutable(true);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
 
 void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum target,
                                                 const GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoProduceTextureCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
 
@@ skipping 354 matching lines @@
     image->ReleaseTexImage(target);
     texture_manager()->SetLevelInfo(texture_ref, target, 0, GL_RGBA, 0, 0, 1, 0,
                                     GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   }
 
   texture_manager()->SetLevelImage(texture_ref, target, 0, nullptr,
                                    Texture::UNBOUND);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::TraceBeginCHROMIUM& c =
       *static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
   Bucket* category_bucket = GetBucket(c.category_bucket_id);
   Bucket* name_bucket = GetBucket(c.name_bucket_id);
   if (!category_bucket || category_bucket->size() == 0 ||
       !name_bucket || name_bucket->size() == 0) {
     return error::kInvalidArguments;
   }
 
@@ skipping 493 matching lines @@
     *out_transform_type = transform_type;
     return true;
   }
   template <typename Cmd>
   bool GetPathNameData(const Cmd& cmd,
                        GLuint num_paths,
                        GLenum path_name_type,
                        PathNameBuffer* out_buffer) {
     DCHECK(validators_->path_name_type.IsValid(path_name_type));
     GLuint path_base = static_cast<GLuint>(cmd.pathBase);
-    uint32 shm_id = static_cast<uint32>(cmd.paths_shm_id);
-    uint32 shm_offset = static_cast<uint32>(cmd.paths_shm_offset);
+    uint32_t shm_id = static_cast<uint32_t>(cmd.paths_shm_id);
+    uint32_t shm_offset = static_cast<uint32_t>(cmd.paths_shm_offset);
     if (shm_id == 0 && shm_offset == 0) {
       error_ = error::kOutOfBounds;
       return false;
     }
     switch (path_name_type) {
       case GL_BYTE:
         return GetPathNameDataImpl<GLbyte>(num_paths, path_base, shm_id,
                                            shm_offset, out_buffer);
       case GL_UNSIGNED_BYTE:
         return GetPathNameDataImpl<GLubyte>(num_paths, path_base, shm_id,
@@ skipping 19 matching lines @@
   }
   template <typename Cmd>
   bool GetTransforms(const Cmd& cmd,
                      GLuint num_paths,
                      GLenum transform_type,
                      const GLfloat** out_transforms) {
     if (transform_type == GL_NONE) {
       *out_transforms = nullptr;
       return true;
     }
-    uint32 transforms_shm_id = static_cast<uint32>(cmd.transformValues_shm_id);
-    uint32 transforms_shm_offset =
-        static_cast<uint32>(cmd.transformValues_shm_offset);
-    uint32 transforms_component_count =
+    uint32_t transforms_shm_id =
+        static_cast<uint32_t>(cmd.transformValues_shm_id);
+    uint32_t transforms_shm_offset =
+        static_cast<uint32_t>(cmd.transformValues_shm_offset);
+    uint32_t transforms_component_count =
         GLES2Util::GetComponentCountForGLTransformType(transform_type);
     // Below multiplication will not overflow.
     DCHECK(transforms_component_count <= 12);
-    uint32 one_transform_size = sizeof(GLfloat) * transforms_component_count;
-    uint32 transforms_size = 0;
+    uint32_t one_transform_size = sizeof(GLfloat) * transforms_component_count;
+    uint32_t transforms_size = 0;
     if (!SafeMultiplyUint32(one_transform_size, num_paths, &transforms_size)) {
       error_ = error::kOutOfBounds;
       return false;
     }
     const GLfloat* transforms = nullptr;
     if (transforms_shm_id != 0 || transforms_shm_offset != 0)
       transforms = decoder_->GetSharedMemoryAs<const GLfloat*>(
           transforms_shm_id, transforms_shm_offset, transforms_size);
     if (!transforms) {
       error_ = error::kOutOfBounds;
@@ skipping 11 matching lines @@
       return false;
     }
     *out_cover_mode = cover_mode;
     return true;
   }
 
  private:
   template <typename T>
   bool GetPathNameDataImpl(GLuint num_paths,
                            GLuint path_base,
-                           uint32 shm_id,
-                           uint32 shm_offset,
+                           uint32_t shm_id,
+                           uint32_t shm_offset,
                            PathNameBuffer* out_buffer) {
-    uint32 paths_size = 0;
+    uint32_t paths_size = 0;
     if (!SafeMultiplyUint32(num_paths, sizeof(T), &paths_size)) {
       error_ = error::kOutOfBounds;
       return false;
     }
     T* paths = decoder_->GetSharedMemoryAs<T*>(shm_id, shm_offset, paths_size);
     if (!paths) {
       error_ = error::kOutOfBounds;
       return false;
     }
     GLuint* result_paths = out_buffer->AllocateOrAdopt(num_paths, paths);
     bool has_paths = false;
     for (GLuint i = 0; i < num_paths; ++i) {
       GLuint service_id = 0;
       // The below addition is ok even with over- and underflows.
       // There is no difference if client passes:
       //  * base==4, T=GLbyte, paths[0]==0xfa (-6)
       //  * base==0xffffffff, T=GLuint, paths[0]==0xffffffff
       //  * base==0, T=GLuint, paths[0]==0xfffffffe
       // For the all the cases, the interpretation is that
       // client intends to use the path 0xfffffffe.
       // The client_id verification is only done after the addition.
-      uint32 client_id = path_base + paths[i];
+      uint32_t client_id = path_base + paths[i];
       if (decoder_->path_manager()->GetPath(client_id, &service_id))
         has_paths = true;
       // Will use path 0 if the path is not found. This is in line
       // of the spec: missing paths will produce nothing, let
       // the instanced draw continue.
       result_paths[i] = service_id;
     }
     return has_paths;
   }
   GLES2DecoderImpl* decoder_;
   ErrorState* error_state_;
   const Validators* validators_;
   const char* function_name_;
   error::Error error_;
 };
 
 error::Error GLES2DecoderImpl::HandleGenPathsCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GenPathsCHROMIUM& c =
       *static_cast<const gles2::cmds::GenPathsCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glGenPathsCHROMIUM");
   GLsizei range = 0;
   if (!v.GetPathRange(c, &range))
     return v.error();
@@ skipping 29 matching lines @@
   GLuint first_client_id = c.first_client_id;
   // first_client_id can be 0, because non-existing path ids are skipped.
 
   if (!DeletePathsCHROMIUMHelper(first_client_id, range))
     return error::kInvalidArguments;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   static const char kFunctionName[] = "glPathCommandsCHROMIUM";
   const gles2::cmds::PathCommandsCHROMIUM& c =
       *static_cast<const gles2::cmds::PathCommandsCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "invalid path name");
     return error::kNoError;
   }
 
   GLsizei num_commands = static_cast<GLsizei>(c.numCommands);
   if (num_commands < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "numCommands < 0");
     return error::kNoError;
   }
 
-  GLsizei num_coords = static_cast<uint32>(c.numCoords);
+  GLsizei num_coords = static_cast<uint32_t>(c.numCoords);
   if (num_coords < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "numCoords < 0");
     return error::kNoError;
   }
 
-  GLenum coord_type = static_cast<uint32>(c.coordType);
+  GLenum coord_type = static_cast<uint32_t>(c.coordType);
   if (!validators_->path_coord_type.IsValid(static_cast<GLint>(coord_type))) {
     LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, kFunctionName, "invalid coordType");
     return error::kNoError;
   }
 
   const GLubyte* commands = NULL;
   base::CheckedNumeric<GLsizei> num_coords_expected = 0;
 
   if (num_commands > 0) {
-    uint32 commands_shm_id = static_cast<uint32>(c.commands_shm_id);
-    uint32 commands_shm_offset = static_cast<uint32>(c.commands_shm_offset);
+    uint32_t commands_shm_id = static_cast<uint32_t>(c.commands_shm_id);
+    uint32_t commands_shm_offset = static_cast<uint32_t>(c.commands_shm_offset);
     if (commands_shm_id != 0 || commands_shm_offset != 0)
       commands = GetSharedMemoryAs<const GLubyte*>(
           commands_shm_id, commands_shm_offset, num_commands);
 
     if (!commands)
       return error::kOutOfBounds;
 
     for (GLsizei i = 0; i < num_commands; ++i) {
       switch (commands[i]) {
         case GL_CLOSE_PATH_CHROMIUM:
@@ skipping 23 matching lines @@
   if (!num_coords_expected.IsValid() ||
       num_coords != num_coords_expected.ValueOrDie()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "numCoords does not match commands");
     return error::kNoError;
   }
 
   const void* coords = NULL;
 
   if (num_coords > 0) {
-    uint32 coords_size = 0;
-    uint32 coord_type_size =
+    uint32_t coords_size = 0;
+    uint32_t coord_type_size =
         GLES2Util::GetGLTypeSizeForPathCoordType(coord_type);
     if (!SafeMultiplyUint32(num_coords, coord_type_size, &coords_size))
       return error::kOutOfBounds;
 
-    uint32 coords_shm_id = static_cast<uint32>(c.coords_shm_id);
-    uint32 coords_shm_offset = static_cast<uint32>(c.coords_shm_offset);
+    uint32_t coords_shm_id = static_cast<uint32_t>(c.coords_shm_id);
+    uint32_t coords_shm_offset = static_cast<uint32_t>(c.coords_shm_offset);
     if (coords_shm_id != 0 || coords_shm_offset != 0)
       coords = GetSharedMemoryAs<const void*>(coords_shm_id, coords_shm_offset,
                                               coords_size);
 
     if (!coords)
       return error::kOutOfBounds;
   }
 
   glPathCommandsNV(service_id, num_commands, commands, num_coords, coord_type,
                    coords);
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathParameterfCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   static const char kFunctionName[] = "glPathParameterfCHROMIUM";
   const gles2::cmds::PathParameterfCHROMIUM& c =
       *static_cast<const gles2::cmds::PathParameterfCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
@@ skipping 31 matching lines @@
   if (hasValueError) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "value not correct");
     return error::kNoError;
   }
 
   glPathParameterfNV(service_id, pname, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathParameteriCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   static const char kFunctionName[] = "glPathParameteriCHROMIUM";
   const gles2::cmds::PathParameteriCHROMIUM& c =
       *static_cast<const gles2::cmds::PathParameteriCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
@@ skipping 29 matching lines @@
   if (hasValueError) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "value not correct");
     return error::kNoError;
   }
 
   glPathParameteriNV(service_id, pname, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFillPathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilFillPathCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilFillPathCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this, "glStencilFillPathCHROMIUM");
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask))
     return v.error();
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     // "If /path/ does not name an existing path object, the command does
     // nothing (and no error is generated)."
     // This holds for other rendering functions, too.
     return error::kNoError;
   }
   ApplyDirtyState();
   glStencilFillPathNV(service_id, fill_mode, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilStrokePathCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilStrokePathCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     return error::kNoError;
   }
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   ApplyDirtyState();
   glStencilStrokePathNV(service_id, reference, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CoverFillPathCHROMIUM& c =
       *static_cast<const gles2::cmds::CoverFillPathCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glCoverFillPathCHROMIUM");
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   ApplyDirtyState();
   glCoverFillPathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CoverStrokePathCHROMIUM& c =
       *static_cast<const gles2::cmds::CoverStrokePathCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glCoverStrokePathCHROMIUM");
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   ApplyDirtyState();
   glCoverStrokePathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverFillPathCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilThenCoverFillPathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glStencilThenCoverFillPathCHROMIUM");
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask) ||
       !v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   ApplyDirtyState();
   glStencilThenCoverFillPathNV(service_id, fill_mode, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverStrokePathCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverStrokePathCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilThenCoverStrokePathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glStencilThenCoverStrokePathCHROMIUM");
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   ApplyDirtyState();
   glStencilThenCoverStrokePathNV(service_id, reference, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFillPathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilFillPathInstancedCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilFillPathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glStencilFillPathInstancedCHROMIUM");
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
@@ skipping 16 matching lines @@
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glStencilFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.path_names(),
                                0, fill_mode, mask, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilStrokePathInstancedCHROMIUM& c =
       *static_cast<const gles2::cmds::StencilStrokePathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glStencilStrokePathInstancedCHROMIUM");
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
@@ skipping 16 matching lines @@
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   ApplyDirtyState();
   glStencilStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.path_names(),
                                  0, reference, mask, transform_type,
                                  transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CoverFillPathInstancedCHROMIUM& c =
       *static_cast<const gles2::cmds::CoverFillPathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glCoverFillPathInstancedCHROMIUM");
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
@@ skipping 15 matching lines @@
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.path_names(), 0,
                              cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CoverStrokePathInstancedCHROMIUM& c =
       *static_cast<const gles2::cmds::CoverStrokePathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glCoverStrokePathInstancedCHROMIUM");
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
@@ skipping 15 matching lines @@
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glCoverStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.path_names(),
                                0, cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM& c =
       *static_cast<
           const gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this,
                                 "glStencilThenCoverFillPathInstancedCHROMIUM");
   GLuint num_paths = 0;
@@ skipping 21 matching lines @@
 
   ApplyDirtyState();
   glStencilThenCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT,
                                         paths.path_names(), 0, fill_mode, mask,
                                         cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderImpl::HandleStencilThenCoverStrokePathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM& c =
       *static_cast<
           const gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this,
                                 "glStencilThenCoverStrokeInstancedCHROMIUM");
   GLuint num_paths = 0;
@@ skipping 37 matching lines @@
   if (ProgramManager::HasBuiltInPrefix(name)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName, "reserved prefix");
     return;
   }
   Program* program = GetProgram(program_id);
   if (!program || program->IsDeleted()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName, "invalid program");
     return;
   }
   if (location < 0 ||
-      static_cast<uint32>(location) >= group_->max_varying_vectors() * 4) {
+      static_cast<uint32_t>(location) >= group_->max_varying_vectors() * 4) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                        "location out of range");
     return;
   }
 
   program->SetFragmentInputLocationBinding(name, location);
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
       *static_cast<const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindFragmentInputLocationCHROMIUM(program, location, name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleProgramPathFragmentInputGenCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   static const char kFunctionName[] = "glProgramPathFragmentInputGenCHROMIUM";
   const gles2::cmds::ProgramPathFragmentInputGenCHROMIUM& c =
       *static_cast<const gles2::cmds::ProgramPathFragmentInputGenCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
   GLint program_id = static_cast<GLint>(c.program);
@@ skipping 59 matching lines @@
                            "fragment input type is not single-precision "
                            "floating-point scalar or vector");
         return error::kNoError;
     }
 
     if (components_needed != components) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                          "components does not match fragment input type");
       return error::kNoError;
     }
-    uint32 coeffs_per_component =
+    uint32_t coeffs_per_component =
         GLES2Util::GetCoefficientCountForGLPathFragmentInputGenMode(gen_mode);
     // The multiplication below will not overflow.
     DCHECK(coeffs_per_component > 0 && coeffs_per_component <= 4);
     DCHECK(components > 0 && components <= 4);
-    uint32 coeffs_size = sizeof(GLfloat) * coeffs_per_component * components;
+    uint32_t coeffs_size = sizeof(GLfloat) * coeffs_per_component * components;
 
-    uint32 coeffs_shm_id = static_cast<uint32>(c.coeffs_shm_id);
-    uint32 coeffs_shm_offset = static_cast<uint32>(c.coeffs_shm_offset);
+    uint32_t coeffs_shm_id = static_cast<uint32_t>(c.coeffs_shm_id);
+    uint32_t coeffs_shm_offset = static_cast<uint32_t>(c.coeffs_shm_offset);
 
     if (coeffs_shm_id != 0 || coeffs_shm_offset != 0) {
       coeffs = GetSharedMemoryAs<const GLfloat*>(
           coeffs_shm_id, coeffs_shm_offset, coeffs_size);
     }
 
     if (!coeffs) {
       return error::kOutOfBounds;
     }
   }
   glProgramPathFragmentInputGenNV(program->service_id(), real_location,
                                   gen_mode, components, coeffs);
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
+#include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu