Switch to standard integer types in gpu/.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <sstream>
 #include <string>
 #include "base/compiler_specific.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
@@ skipping 258 matching lines @@
   if (namespace_id == id_namespaces::kQueries)
     return query_id_allocator_.get();
   NOTREACHED();
   return NULL;
 }
 
 void* GLES2Implementation::GetResultBuffer() {
   return transfer_buffer_->GetResultBuffer();
 }
 
-int32 GLES2Implementation::GetResultShmId() {
+int32_t GLES2Implementation::GetResultShmId() {
   return transfer_buffer_->GetShmId();
 }
 
-uint32 GLES2Implementation::GetResultShmOffset() {
+uint32_t GLES2Implementation::GetResultShmOffset() {
   return transfer_buffer_->GetResultOffset();
 }
 
 void GLES2Implementation::FreeUnusedSharedMemory() {
   mapped_memory_->FreeUnused();
 }
 
 void GLES2Implementation::FreeEverything() {
   WaitForCmd();
   query_tracker_->Shrink();
   FreeUnusedSharedMemory();
   transfer_buffer_->Free();
   helper_->FreeRingBuffer();
 }
 
 void GLES2Implementation::RunIfContextNotLost(const base::Closure& callback) {
   if (!helper_->IsContextLost())
     callback.Run();
 }
 
-void GLES2Implementation::SignalSyncPoint(uint32 sync_point,
+void GLES2Implementation::SignalSyncPoint(uint32_t sync_point,
                                           const base::Closure& callback) {
   gpu_control_->SignalSyncPoint(
       sync_point,
       base::Bind(&GLES2Implementation::RunIfContextNotLost,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void GLES2Implementation::SignalSyncToken(const gpu::SyncToken& sync_token,
                                           const base::Closure& callback) {
@@ skipping 11 matching lines @@
         intermediate_sync_token,
         base::Bind(&GLES2Implementation::RunIfContextNotLost,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   } else {
     // Invalid sync token, just call the callback immediately.
     callback.Run();
   }
 }
 
-void GLES2Implementation::SignalQuery(uint32 query,
+void GLES2Implementation::SignalQuery(uint32_t query,
                                       const base::Closure& callback) {
   // Flush previously entered commands to ensure ordering with any
   // glBeginQueryEXT() calls that may have been put into the context.
   ShallowFlushCHROMIUM();
   gpu_control_->SignalQuery(
       query,
       base::Bind(&GLES2Implementation::RunIfContextNotLost,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
@@ skipping 15 matching lines @@
     ShallowFlushCHROMIUM();
   }
 }
 
 bool GLES2Implementation::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   if (!transfer_buffer_->HaveBuffer())
     return true;
 
-  const uint64 tracing_process_id =
+  const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
 
   base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
       base::StringPrintf("gpu/transfer_buffer_memory/buffer_%d",
                          transfer_buffer_->GetShmId()));
   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                   transfer_buffer_->GetSize());
   dump->AddScalar("free_size",
@@ skipping 72 matching lines @@
   GPU_CLIENT_LOG("returned " << GLES2Util::GetStringError(err));
   return err;
 }
 
 GLenum GLES2Implementation::GetClientSideGLError() {
   if (error_bits_ == 0) {
     return GL_NO_ERROR;
   }
 
   GLenum error = GL_NO_ERROR;
-  for (uint32 mask = 1; mask != 0; mask = mask << 1) {
+  for (uint32_t mask = 1; mask != 0; mask = mask << 1) {
     if ((error_bits_ & mask) != 0) {
       error = GLES2Util::GLErrorBitToGLError(mask);
       break;
     }
   }
   error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   return error;
 }
 
 GLenum GLES2Implementation::GetGLError() {
@@ skipping 52 matching lines @@
   }
 }
 
 void GLES2Implementation::SetGLErrorInvalidEnum(
     const char* function_name, GLenum value, const char* label) {
   SetGLError(GL_INVALID_ENUM, function_name,
              (std::string(label) + " was " +
               GLES2Util::GetStringEnum(value)).c_str());
 }
 
-bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
-                                            std::vector<int8>* data) {
+bool GLES2Implementation::GetBucketContents(uint32_t bucket_id,
+                                            std::vector<int8_t>* data) {
   TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
   DCHECK(data);
-  const uint32 kStartSize = 32 * 1024;
+  const uint32_t kStartSize = 32 * 1024;
   ScopedTransferBufferPtr buffer(kStartSize, helper_, transfer_buffer_);
   if (!buffer.valid()) {
     return false;
   }
   typedef cmd::GetBucketStart::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return false;
   }
   *result = 0;
   helper_->GetBucketStart(
       bucket_id, GetResultShmId(), GetResultShmOffset(),
       buffer.size(), buffer.shm_id(), buffer.offset());
   WaitForCmd();
-  uint32 size = *result;
+  uint32_t size = *result;
   data->resize(size);
   if (size > 0u) {
-    uint32 offset = 0;
+    uint32_t offset = 0;
     while (size) {
       if (!buffer.valid()) {
         buffer.Reset(size);
         if (!buffer.valid()) {
           return false;
         }
         helper_->GetBucketData(
             bucket_id, offset, buffer.size(), buffer.shm_id(), buffer.offset());
         WaitForCmd();
       }
-      uint32 size_to_copy = std::min(size, buffer.size());
+      uint32_t size_to_copy = std::min(size, buffer.size());
       memcpy(&(*data)[offset], buffer.address(), size_to_copy);
       offset += size_to_copy;
       size -= size_to_copy;
       buffer.Release();
     }
     // Free the bucket. This is not required but it does free up the memory.
     // and we don't have to wait for the result so from the client's perspective
     // it's cheap.
     helper_->SetBucketSize(bucket_id, 0);
   }
   return true;
 }
 
-void GLES2Implementation::SetBucketContents(
-    uint32 bucket_id, const void* data, size_t size) {
+void GLES2Implementation::SetBucketContents(uint32_t bucket_id,
+                                            const void* data,
+                                            size_t size) {
   DCHECK(data);
   helper_->SetBucketSize(bucket_id, size);
   if (size > 0u) {
-    uint32 offset = 0;
+    uint32_t offset = 0;
     while (size) {
       ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
       if (!buffer.valid()) {
         return;
       }
-      memcpy(buffer.address(), static_cast<const int8*>(data) + offset,
+      memcpy(buffer.address(), static_cast<const int8_t*>(data) + offset,
              buffer.size());
       helper_->SetBucketData(
           bucket_id, offset, buffer.size(), buffer.shm_id(), buffer.offset());
       offset += buffer.size();
       size -= buffer.size();
     }
   }
 }
 
-void GLES2Implementation::SetBucketAsCString(
-    uint32 bucket_id, const char* str) {
+void GLES2Implementation::SetBucketAsCString(uint32_t bucket_id,
+                                             const char* str) {
   // NOTE: strings are passed NULL terminated. That means the empty
   // string will have a size of 1 and no-string will have a size of 0
   if (str) {
     SetBucketContents(bucket_id, str, strlen(str) + 1);
   } else {
     helper_->SetBucketSize(bucket_id, 0);
   }
 }
 
-bool GLES2Implementation::GetBucketAsString(
-    uint32 bucket_id, std::string* str) {
+bool GLES2Implementation::GetBucketAsString(uint32_t bucket_id,
+                                            std::string* str) {
   DCHECK(str);
-  std::vector<int8> data;
+  std::vector<int8_t> data;
   // NOTE: strings are passed NULL terminated. That means the empty
   // string will have a size of 1 and no-string will have a size of 0
   if (!GetBucketContents(bucket_id, &data)) {
     return false;
   }
   if (data.empty()) {
     return false;
   }
   str->assign(&data[0], &data[0] + data.size() - 1);
   return true;
 }
 
-void GLES2Implementation::SetBucketAsString(
-    uint32 bucket_id, const std::string& str) {
+void GLES2Implementation::SetBucketAsString(uint32_t bucket_id,
+                                            const std::string& str) {
   // NOTE: strings are passed NULL terminated. That means the empty
   // string will have a size of 1 and no-string will have a size of 0
   SetBucketContents(bucket_id, str.c_str(), str.size() + 1);
 }
 
 void GLES2Implementation::Disable(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDisable("
                  << GLES2Util::GetStringCapability(cap) << ")");
   bool changed = false;
@@ skipping 777 matching lines @@
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribPointerv(
     GLuint index, GLenum pname, void** ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribPointer("
       << index << ", " << GLES2Util::GetStringVertexPointer(pname) << ", "
       << static_cast<void*>(ptr) << ")");
-  GPU_CLIENT_LOG_CODE_BLOCK(int32 num_results = 1);
+  GPU_CLIENT_LOG_CODE_BLOCK(int32_t num_results = 1);
   if (!vertex_array_object_manager_->GetAttribPointer(index, pname, ptr)) {
     TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
     typedef cmds::GetVertexAttribPointerv::Result Result;
     Result* result = GetResultAs<Result*>();
     if (!result) {
       return;
     }
     result->SetNumResults(0);
     helper_->GetVertexAttribPointerv(
       index, pname, GetResultShmId(), GetResultShmOffset());
     WaitForCmd();
     result->CopyResult(ptr);
     GPU_CLIENT_LOG_CODE_BLOCK(num_results = result->GetNumResults());
   }
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < num_results; ++i) {
+    for (int32_t i = 0; i < num_results; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << ptr[i]);
     }
   });
   CheckGLError();
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
   if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
       this, 1, &program, &GLES2Implementation::DeleteProgramStub)) {
     SetGLError(
@@ skipping 515 matching lines @@
   if (GetBoundPixelTransferBuffer(target, "glBufferSubData", &buffer_id)) {
     if (!buffer_id) {
       return;
     }
     BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
     if (!buffer) {
       SetGLError(GL_INVALID_VALUE, "glBufferSubData", "unknown buffer");
       return;
     }
 
-    int32 end = 0;
-    int32 buffer_size = buffer->size();
+    int32_t end = 0;
+    int32_t buffer_size = buffer->size();
     if (!SafeAddInt32(offset, size, &end) || end > buffer_size) {
       SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
       return;
     }
 
     if (buffer->address() && data)
-      memcpy(static_cast<uint8*>(buffer->address()) + offset, data, size);
+      memcpy(static_cast<uint8_t*>(buffer->address()) + offset, data, size);
     return;
   }
 
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   BufferSubDataHelperImpl(target, offset, size, data, &buffer);
 }
 
 void GLES2Implementation::BufferSubDataHelperImpl(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data,
     ScopedTransferBufferPtr* buffer) {
   DCHECK(buffer);
   DCHECK_GT(size, 0);
 
-  const int8* source = static_cast<const int8*>(data);
+  const int8_t* source = static_cast<const int8_t*>(data);
   while (size) {
     if (!buffer->valid() || buffer->size() == 0) {
       buffer->Reset(size);
       if (!buffer->valid()) {
         return;
       }
     }
     memcpy(buffer->address(), source, buffer->size());
     helper_->BufferSubData(
         target, offset, buffer->size(), buffer->shm_id(), buffer->offset());
     offset += buffer->size();
     source += buffer->size();
     size -= buffer->size();
     buffer->Release();
   }
 }
 
 void GLES2Implementation::BufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
   CheckGLError();
 }
 
 void GLES2Implementation::RemoveTransferBuffer(BufferTracker::Buffer* buffer) {
-  int32 token = buffer->last_usage_token();
+  int32_t token = buffer->last_usage_token();
 
   if (token) {
     if (helper_->HasTokenPassed(token))
       buffer_tracker_->Free(buffer);
     else
       buffer_tracker_->FreePendingToken(buffer, token);
   } else {
       buffer_tracker_->Free(buffer);
   }
 
@@ skipping 220 matching lines @@
       kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
 namespace {
 
-void CopyRectToBuffer(
-    const void* pixels,
-    uint32 height,
-    uint32 unpadded_row_size,
-    uint32 pixels_padded_row_size,
-    void* buffer,
-    uint32 buffer_padded_row_size) {
-  const int8* source = static_cast<const int8*>(pixels);
-  int8* dest = static_cast<int8*>(buffer);
+void CopyRectToBuffer(const void* pixels,
+                      uint32_t height,
+                      uint32_t unpadded_row_size,
+                      uint32_t pixels_padded_row_size,
+                      void* buffer,
+                      uint32_t buffer_padded_row_size) {
+  const int8_t* source = static_cast<const int8_t*>(pixels);
+  int8_t* dest = static_cast<int8_t*>(buffer);
   if (pixels_padded_row_size != buffer_padded_row_size) {
     // the last row is copied unpadded at the end
     for (; height > 1; --height) {
       memcpy(dest, source, buffer_padded_row_size);
       dest += buffer_padded_row_size;
       source += pixels_padded_row_size;
     }
     memcpy(dest, source, unpadded_row_size);
   } else {
-    uint32 size = (height - 1) * pixels_padded_row_size + unpadded_row_size;
+    uint32_t size = (height - 1) * pixels_padded_row_size + unpadded_row_size;
     memcpy(dest, source, size);
   }
 }
 
 }  // anonymous namespace
 
 void GLES2Implementation::TexImage2D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
   if (border != 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
     return;
   }
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
+  uint32_t size;
+  uint32_t unpadded_row_size;
+  uint32_t padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, 1, format, type, unpack_alignment_, &size,
           &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(pixels);
@@ skipping 13 matching lines @@
   // If there's no data just issue TexImage2D
   if (!pixels) {
     helper_->TexImage2D(
        target, level, internalformat, width, height, format, type,
        0, 0);
     CheckGLError();
     return;
   }
 
   // compute the advance bytes per row for the src pixels
-  uint32 src_padded_row_size;
+  uint32_t src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
       SetGLError(
           GL_INVALID_VALUE, "glTexImage2D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
-  pixels = reinterpret_cast<const int8*>(pixels) +
-      unpack_skip_rows_ * src_padded_row_size;
+  pixels = reinterpret_cast<const int8_t*>(pixels) +
+           unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
-    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
-    pixels = reinterpret_cast<const int8*>(pixels) +
-        unpack_skip_pixels_ * group_size;
+    uint32_t group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8_t*>(pixels) +
+             unpack_skip_pixels_ * group_size;
   }
 
   // Check if we can send it all at once.
   int32_t shm_id = 0;
   uint32_t shm_offset = 0;
   void* buffer_pointer = nullptr;
 
   ScopedTransferBufferPtr transfer_alloc(size, helper_, transfer_buffer_);
   ScopedMappedMemoryPtr mapped_alloc(0, helper_, mapped_memory_.get());
 
@@ skipping 48 matching lines @@
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0 || depth < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage3D", "dimension < 0");
     return;
   }
   if (border != 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage3D", "border != 0");
     return;
   }
-  uint32 size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
+  uint32_t size;
+  uint32_t unpadded_row_size;
+  uint32_t padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, depth, format, type, unpack_alignment_, &size,
           &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexImage3D", "image size too large");
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexImage3D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(pixels);
@@ skipping 13 matching lines @@
   // If there's no data just issue TexImage3D
   if (!pixels) {
     helper_->TexImage3D(
        target, level, internalformat, width, height, depth, format, type,
        0, 0);
     CheckGLError();
     return;
   }
 
   // compute the advance bytes per row for the src pixels
-  uint32 src_padded_row_size;
+  uint32_t src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
       SetGLError(
           GL_INVALID_VALUE, "glTexImage3D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
-  uint32 src_height = unpack_image_height_ > 0 ? unpack_image_height_ : height;
+  uint32_t src_height =
+      unpack_image_height_ > 0 ? unpack_image_height_ : height;
 
   // advance pixels pointer past the skip images/rows/pixels
-  pixels = reinterpret_cast<const int8*>(pixels) +
-      unpack_skip_images_ * src_padded_row_size * src_height +
-      unpack_skip_rows_ * src_padded_row_size;
+  pixels = reinterpret_cast<const int8_t*>(pixels) +
+           unpack_skip_images_ * src_padded_row_size * src_height +
+           unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
-    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
-    pixels = reinterpret_cast<const int8*>(pixels) +
-        unpack_skip_pixels_ * group_size;
+    uint32_t group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8_t*>(pixels) +
+             unpack_skip_pixels_ * group_size;
   }
 
   // Check if we can send it all at once.
   int32_t shm_id = 0;
   uint32_t shm_offset = 0;
   void* buffer_pointer = nullptr;
 
   ScopedTransferBufferPtr transfer_alloc(size, helper_, transfer_buffer_);
   ScopedMappedMemoryPtr mapped_alloc(0, helper_, mapped_memory_.get());
 
   if (transfer_alloc.valid() && transfer_alloc.size() >= size) {
     shm_id = transfer_alloc.shm_id();
     shm_offset = transfer_alloc.offset();
     buffer_pointer = transfer_alloc.address();
   } else if (size < max_extra_transfer_buffer_size_) {
     mapped_alloc.Reset(size);
     if (mapped_alloc.valid()) {
       transfer_alloc.Discard();
 
       mapped_alloc.SetFlushAfterRelease(true);
       shm_id = mapped_alloc.shm_id();
       shm_offset = mapped_alloc.offset();
       buffer_pointer = mapped_alloc.address();
     }
   }
 
   if (buffer_pointer) {
     for (GLsizei z = 0; z < depth; ++z) {
       // Only the last row of the last image is unpadded.
-      uint32 src_unpadded_row_size =
+      uint32_t src_unpadded_row_size =
           (z == depth - 1) ? unpadded_row_size : src_padded_row_size;
       CopyRectToBuffer(
           pixels, height, src_unpadded_row_size, src_padded_row_size,
           buffer_pointer, padded_row_size);
-      pixels = reinterpret_cast<const int8*>(pixels) +
-          src_padded_row_size * src_height;
-      buffer_pointer = reinterpret_cast<int8*>(buffer_pointer) +
-          padded_row_size * height;
+      pixels = reinterpret_cast<const int8_t*>(pixels) +
+               src_padded_row_size * src_height;
+      buffer_pointer =
+          reinterpret_cast<int8_t*>(buffer_pointer) + padded_row_size * height;
     }
     helper_->TexImage3D(
         target, level, internalformat, width, height, depth, format, type,
         shm_id, shm_offset);
     CheckGLError();
     return;
   }
 
   // No, so send it using TexSubImage3D.
   helper_->TexImage3D(
@@ skipping 20 matching lines @@
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
 
-  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, height, 1, format, type, unpack_alignment_, &temp_size,
         &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "size to large");
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexSubImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_unpack_transfer_buffer_id_,
         "glTexSubImage2D", offset, temp_size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexSubImage2D(
           target, level, xoffset, yoffset, width, height, format, type,
           buffer->shm_id(), buffer->shm_offset() + offset, false);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
   // compute the advance bytes per row for the src pixels
-  uint32 src_padded_row_size;
+  uint32_t src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
       SetGLError(
           GL_INVALID_VALUE, "glTexImage2D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
-  pixels = reinterpret_cast<const int8*>(pixels) +
-      unpack_skip_rows_ * src_padded_row_size;
+  pixels = reinterpret_cast<const int8_t*>(pixels) +
+           unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
-    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
-    pixels = reinterpret_cast<const int8*>(pixels) +
-        unpack_skip_pixels_ * group_size;
+    uint32_t group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8_t*>(pixels) +
+             unpack_skip_pixels_ * group_size;
   }
 
   ScopedTransferBufferPtr buffer(temp_size, helper_, transfer_buffer_);
   TexSubImage2DImpl(
       target, level, xoffset, yoffset, width, height, format, type,
       unpadded_row_size, pixels, src_padded_row_size, GL_FALSE, &buffer,
       padded_row_size);
   CheckGLError();
 }
 
@@ skipping 12 matching lines @@
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0 || depth < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0 || depth == 0) {
     return;
   }
 
-  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, height, depth, format, type, unpack_alignment_, &temp_size,
           &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage3D", "size to large");
     return;
   }
 
   // If there's a pixel unpack buffer bound use it when issuing TexSubImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_unpack_transfer_buffer_id_,
         "glTexSubImage3D", offset, temp_size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexSubImage3D(
           target, level, xoffset, yoffset, zoffset, width, height, depth,
           format, type, buffer->shm_id(), buffer->shm_offset() + offset, false);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
     }
     return;
   }
 
   // compute the advance bytes per row for the src pixels
-  uint32 src_padded_row_size;
+  uint32_t src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
       SetGLError(
           GL_INVALID_VALUE, "glTexImage3D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
-  uint32 src_height = unpack_image_height_ > 0 ? unpack_image_height_ : height;
+  uint32_t src_height =
+      unpack_image_height_ > 0 ? unpack_image_height_ : height;
 
   // advance pixels pointer past the skip images/rows/pixels
-  pixels = reinterpret_cast<const int8*>(pixels) +
-      unpack_skip_images_ * src_padded_row_size * src_height +
-      unpack_skip_rows_ * src_padded_row_size;
+  pixels = reinterpret_cast<const int8_t*>(pixels) +
+           unpack_skip_images_ * src_padded_row_size * src_height +
+           unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
-    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
-    pixels = reinterpret_cast<const int8*>(pixels) +
-        unpack_skip_pixels_ * group_size;
+    uint32_t group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8_t*>(pixels) +
+             unpack_skip_pixels_ * group_size;
   }
 
   ScopedTransferBufferPtr buffer(temp_size, helper_, transfer_buffer_);
   TexSubImage3DImpl(
       target, level, xoffset, yoffset, zoffset, width, height, depth,
       format, type, unpadded_row_size, pixels, src_padded_row_size, GL_FALSE,
       &buffer, padded_row_size);
   CheckGLError();
 }
 
-static GLint ComputeNumRowsThatFitInBuffer(
-    uint32 padded_row_size, uint32 unpadded_row_size,
-    unsigned int size, GLsizei remaining_rows) {
+static GLint ComputeNumRowsThatFitInBuffer(uint32_t padded_row_size,
+                                           uint32_t unpadded_row_size,
+                                           unsigned int size,
+                                           GLsizei remaining_rows) {
   DCHECK_GE(unpadded_row_size, 0u);
   if (padded_row_size == 0) {
     return 1;
   }
   GLint num_rows = size / padded_row_size;
   if (num_rows + 1 == remaining_rows &&
       size - num_rows * padded_row_size >= unpadded_row_size) {
     num_rows++;
   }
   return num_rows;
 }
 
-void GLES2Implementation::TexSubImage2DImpl(
-    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-    GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size,
-    const void* pixels, uint32 pixels_padded_row_size, GLboolean internal,
-    ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size) {
+void GLES2Implementation::TexSubImage2DImpl(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            uint32_t unpadded_row_size,
+                                            const void* pixels,
+                                            uint32_t pixels_padded_row_size,
+                                            GLboolean internal,
+                                            ScopedTransferBufferPtr* buffer,
+                                            uint32_t buffer_padded_row_size) {
   DCHECK(buffer);
   DCHECK_GE(level, 0);
   DCHECK_GT(height, 0);
   DCHECK_GT(width, 0);
 
-  const int8* source = reinterpret_cast<const int8*>(pixels);
+  const int8_t* source = reinterpret_cast<const int8_t*>(pixels);
   // Transfer by rows.
   while (height) {
     unsigned int desired_size =
         buffer_padded_row_size * (height - 1) + unpadded_row_size;
     if (!buffer->valid() || buffer->size() == 0) {
       buffer->Reset(desired_size);
       if (!buffer->valid()) {
         return;
       }
     }
 
     GLint num_rows = ComputeNumRowsThatFitInBuffer(
         buffer_padded_row_size, unpadded_row_size, buffer->size(), height);
     num_rows = std::min(num_rows, height);
     CopyRectToBuffer(
         source, num_rows, unpadded_row_size, pixels_padded_row_size,
         buffer->address(), buffer_padded_row_size);
     helper_->TexSubImage2D(
         target, level, xoffset, yoffset, width, num_rows, format, type,
         buffer->shm_id(), buffer->offset(), internal);
     buffer->Release();
     yoffset += num_rows;
     source += num_rows * pixels_padded_row_size;
     height -= num_rows;
   }
 }
 
-void GLES2Implementation::TexSubImage3DImpl(
-    GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei zoffset,
-    GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
-    uint32 unpadded_row_size, const void* pixels, uint32 pixels_padded_row_size,
-    GLboolean internal, ScopedTransferBufferPtr* buffer,
-    uint32 buffer_padded_row_size) {
+void GLES2Implementation::TexSubImage3DImpl(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            uint32_t unpadded_row_size,
+                                            const void* pixels,
+                                            uint32_t pixels_padded_row_size,
+                                            GLboolean internal,
+                                            ScopedTransferBufferPtr* buffer,
+                                            uint32_t buffer_padded_row_size) {
   DCHECK(buffer);
   DCHECK_GE(level, 0);
   DCHECK_GT(height, 0);
   DCHECK_GT(width, 0);
   DCHECK_GT(depth, 0);
-  const int8* source = reinterpret_cast<const int8*>(pixels);
+  const int8_t* source = reinterpret_cast<const int8_t*>(pixels);
   GLsizei total_rows = height * depth;
   GLint row_index = 0, depth_index = 0;
   while (total_rows) {
     // Each time, we either copy one or more images, or copy one or more rows
     // within a single image, depending on the buffer size limit.
     GLsizei max_rows;
     unsigned int desired_size;
     if (row_index > 0) {
       // We are in the middle of an image. Send the remaining of the image.
       max_rows = height - row_index;
@@ skipping 24 matching lines @@
     if (num_images > 0) {
       num_rows = num_images * height;
       my_height = height;
       my_depth = num_images;
     } else {
       my_height = num_rows;
       my_depth = 1;
     }
 
     if (num_images > 0) {
-      int8* buffer_pointer = reinterpret_cast<int8*>(buffer->address());
-      uint32 src_height =
+      int8_t* buffer_pointer = reinterpret_cast<int8_t*>(buffer->address());
+      uint32_t src_height =
           unpack_image_height_ > 0 ? unpack_image_height_ : height;
-      uint32 image_size_dst = buffer_padded_row_size * height;
-      uint32 image_size_src = pixels_padded_row_size * src_height;
+      uint32_t image_size_dst = buffer_padded_row_size * height;
+      uint32_t image_size_src = pixels_padded_row_size * src_height;
       for (GLint ii = 0; ii < num_images; ++ii) {
-        uint32 my_unpadded_row_size;
+        uint32_t my_unpadded_row_size;
         if (total_rows == num_rows && ii + 1 == num_images)
           my_unpadded_row_size = unpadded_row_size;
         else
           my_unpadded_row_size = pixels_padded_row_size;
         CopyRectToBuffer(
             source + ii * image_size_src, my_height, my_unpadded_row_size,
             pixels_padded_row_size, buffer_pointer + ii * image_size_dst,
             buffer_padded_row_size);
       }
     } else {
-      uint32 my_unpadded_row_size;
+      uint32_t my_unpadded_row_size;
       if (total_rows == num_rows)
         my_unpadded_row_size = unpadded_row_size;
       else
         my_unpadded_row_size = pixels_padded_row_size;
       CopyRectToBuffer(
           source, my_height, my_unpadded_row_size, pixels_padded_row_size,
           buffer->address(), buffer_padded_row_size);
     }
     helper_->TexSubImage3D(
         target, level, xoffset, yoffset + row_index, zoffset + depth_index,
@@ skipping 41 matching lines @@
                            GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (size) {
       *size = result->size;
     }
     if (type) {
       *type = result->type;
     }
     if (length || name) {
-      std::vector<int8> str;
+      std::vector<int8_t> str;
       GetBucketContents(kResultBucketId, &str);
       GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
                                   std::max(static_cast<size_t>(0),
                                            str.size() - 1));
       if (length) {
         *length = max_size;
       }
       if (name && bufsize > 0) {
         memcpy(name, &str[0], max_size);
         name[max_size] = '\0';
@@ skipping 50 matching lines @@
                             GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (size) {
       *size = result->size;
     }
     if (type) {
       *type = result->type;
     }
     if (length || name) {
-      std::vector<int8> str;
+      std::vector<int8_t> str;
       GetBucketContents(kResultBucketId, &str);
       GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
                                   std::max(static_cast<size_t>(0),
                                            str.size() - 1));
       if (length) {
         *length = max_size;
       }
       if (name && bufsize > 0) {
         memcpy(name, &str[0], max_size);
         name[max_size] = '\0';
@@ skipping 49 matching lines @@
   *result = 0;
   helper_->GetActiveUniformBlockName(program, index, kResultBucketId,
                                      GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (*result) {
     if (bufsize == 0) {
       if (length) {
         *length = 0;
       }
     } else if (length || name) {
-      std::vector<int8> str;
+      std::vector<int8_t> str;
       GetBucketContents(kResultBucketId, &str);
       DCHECK_GT(str.size(), 0u);
       GLsizei max_size =
           std::min(bufsize, static_cast<GLsizei>(str.size())) - 1;
       if (length) {
         *length = max_size;
       }
       if (name) {
         memcpy(name, &str[0], max_size);
         name[max_size] = '\0';
@@ skipping 141 matching lines @@
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetAttachedShaders("
       << program << ", " << maxcount << ", "
       << static_cast<const void*>(count) << ", "
       << static_cast<const void*>(shaders) << ", ");
   if (maxcount < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders", "maxcount < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
   typedef cmds::GetAttachedShaders::Result Result;
-  uint32 size = Result::ComputeSize(maxcount);
+  uint32_t size = Result::ComputeSize(maxcount);
   Result* result = static_cast<Result*>(transfer_buffer_->Alloc(size));
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetAttachedShaders(
     program,
     transfer_buffer_->GetShmId(),
     transfer_buffer_->GetOffset(result),
     size);
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
   WaitForCmd();
   if (count) {
     *count = result->GetNumResults();
   }
   result->CopyResult(shaders);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   transfer_buffer_->FreePendingToken(result, token);
   CheckGLError();
 }
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
@@ skipping 112 matching lines @@
       program, index, kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (size) {
       *size = result->size;
     }
     if (type) {
       *type = result->type;
     }
     if (length || name) {
-      std::vector<int8> str;
+      std::vector<int8_t> str;
       GetBucketContents(kResultBucketId, &str);
       GLsizei max_size = std::min(bufsize, static_cast<GLsizei>(str.size()));
       if (max_size > 0) {
         --max_size;
       }
       if (length) {
         *length = max_size;
       }
       if (name) {
         if (max_size > 0) {
@@ skipping 52 matching lines @@
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformfv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetUniformiv(
     GLuint program, GLint location, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformiv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
   typedef cmds::GetUniformiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformiv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   GetResultAs<cmds::GetUniformiv::Result*>()->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetUniformuiv(
     GLuint program, GLint location, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformuiv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformuiv");
   typedef cmds::GetUniformuiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformuiv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   GetResultAs<cmds::GetUniformuiv::Result*>()->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::ReadPixels(
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLenum type, void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
@@ skipping 13 matching lines @@
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef cmds::ReadPixels::Result Result;
 
-  int8* dest = reinterpret_cast<int8*>(pixels);
-  uint32 temp_size;
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
+  int8_t* dest = reinterpret_cast<int8_t*>(pixels);
+  uint32_t temp_size;
+  uint32_t unpadded_row_size;
+  uint32_t padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, 2, 1, format, type, pack_alignment_, &temp_size,
       &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
   }
 
   if (bound_pixel_pack_buffer_) {
     GLuint offset = ToGLuint(pixels);
     helper_->ReadPixels(
@@ skipping 15 matching lines @@
     }
     return;
   }
 
   if (!pixels) {
     SetGLError(GL_INVALID_OPERATION, "glReadPixels", "pixels = NULL");
     return;
   }
 
   // compute the advance bytes per row for the dst pixels
-  uint32 dst_padded_row_size;
+  uint32_t dst_padded_row_size;
   if (pack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         pack_row_length_, format, type, pack_alignment_,
         &dst_padded_row_size)) {
       SetGLError(
           GL_INVALID_VALUE, "glReadPixels", "pack row length too large");
       return;
     }
   } else {
     dst_padded_row_size = padded_row_size;
   }
 
   // Advance pixels pointer past the skip rows and skip pixels
   dest += pack_skip_rows_ * dst_padded_row_size;
   if (pack_skip_pixels_) {
-    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    uint32_t group_size = GLES2Util::ComputeImageGroupSize(format, type);
     dest += pack_skip_pixels_ * group_size;
   }
 
   // Transfer by rows.
   // The max rows we can transfer.
   while (height) {
     GLsizei desired_size = padded_row_size * (height - 1) + unpadded_row_size;
     ScopedTransferBufferPtr buffer(desired_size, helper_, transfer_buffer_);
     if (!buffer.valid()) {
       return;
@@ skipping 11 matching lines @@
     helper_->ReadPixels(
         xoffset, yoffset, width, num_rows, format, type,
         buffer.shm_id(), buffer.offset(),
         GetResultShmId(), GetResultShmOffset(),
         false);
     WaitForCmd();
     if (*result != 0) {
       // when doing a y-flip we have to iterate through top-to-bottom chunks
       // of the dst. The service side handles reversing the rows within a
       // chunk.
-      int8* rows_dst;
+      int8_t* rows_dst;
       if (pack_reverse_row_order_) {
           rows_dst = dest + (height - num_rows) * dst_padded_row_size;
       } else {
           rows_dst = dest;
       }
       // We have to copy 1 row at a time to avoid writing pad bytes.
-      const int8* src = static_cast<const int8*>(buffer.address());
+      const int8_t* src = static_cast<const int8_t*>(buffer.address());
       for (GLint yy = 0; yy < num_rows; ++yy) {
         memcpy(rows_dst, src, unpadded_row_size);
         rows_dst += dst_padded_row_size;
         src += padded_row_size;
       }
       if (!pack_reverse_row_order_) {
         dest = rows_dst;
       }
     }
     // If it was not marked as successful exit.
@@ skipping 605 matching lines @@
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribfv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
-  uint32 value = 0;
+  uint32_t value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = static_cast<GLfloat>(value);
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribfv");
   typedef cmds::GetVertexAttribfv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribfv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
-  uint32 value = 0;
+  uint32_t value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = static_cast<GLint>(value);
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribiv");
   typedef cmds::GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribiv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribIiv(
     GLuint index, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribIiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
-  uint32 value = 0;
+  uint32_t value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = static_cast<GLint>(value);
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribIiv");
   typedef cmds::GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribIiv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribIuiv(
     GLuint index, GLenum pname, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribIuiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
-  uint32 value = 0;
+  uint32_t value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = static_cast<GLuint>(value);
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribIuiv");
   typedef cmds::GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribIuiv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
+    for (int32_t i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 GLenum GLES2Implementation::GetGraphicsResetStatusKHR() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetGraphicsResetStatusKHR()");
   // If we can't make command buffers then the context is lost.
@@ skipping 136 matching lines @@
   if (access != GL_WRITE_ONLY) {
     SetGLErrorInvalidEnum(
         "glMapBufferSubDataCHROMIUM", access, "access");
     return NULL;
   }
   if (!ValidateSize("glMapBufferSubDataCHROMIUM", size) ||
       !ValidateOffset("glMapBufferSubDataCHROMIUM", offset)) {
     return NULL;
   }
 
-  int32 shm_id;
+  int32_t shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
     SetGLError(GL_OUT_OF_MEMORY, "glMapBufferSubDataCHROMIUM", "out of memory");
     return NULL;
   }
 
   std::pair<MappedBufferMap::iterator, bool> result =
      mapped_buffers_.insert(std::make_pair(
          mem,
@@ skipping 60 matching lines @@
     GLenum target, GLintptr offset, GLsizeiptr size, GLbitfield access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferRange("
       << GLES2Util::GetStringEnum(target) << ", " << offset << ", "
       << size << ", " << access << ")");
   if (!ValidateSize("glMapBufferRange", size) ||
       !ValidateOffset("glMapBufferRange", offset)) {
     return nullptr;
   }
 
-  int32 shm_id;
+  int32_t shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
     SetGLError(GL_OUT_OF_MEMORY, "glMapBufferRange", "out of memory");
     return nullptr;
   }
 
   typedef cmds::MapBufferRange::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = 0;
@@ skipping 91 matching lines @@
         "glMapTexSubImage2DCHROMIUM", access, "access");
     return NULL;
   }
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "bad dimensions");
     return NULL;
   }
-  uint32 size;
+  uint32_t size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, unpack_alignment_, &size, NULL, NULL)) {
     SetGLError(
         GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "image size too large");
     return NULL;
   }
-  int32 shm_id;
+  int32_t shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
     SetGLError(GL_OUT_OF_MEMORY, "glMapTexSubImage2DCHROMIUM", "out of memory");
     return NULL;
   }
 
   std::pair<MappedTextureMap::iterator, bool> result =
      mapped_textures_.insert(std::make_pair(
          mem,
@@ skipping 94 matching lines @@
   for (size_t ii = 0; ii < kNumChecks; ++ii) {
     const ExtensionCheck& check = checks[ii];
     if (*check.status == kUnavailableExtensionStatus &&
         !strcmp(extension, check.extension)) {
       *check.status = kUnknownExtensionStatus;
     }
   }
 }
 
 void GLES2Implementation::GetProgramInfoCHROMIUMHelper(
-    GLuint program, std::vector<int8>* result) {
+    GLuint program,
+    std::vector<int8_t>* result) {
   DCHECK(result);
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetProgramInfoCHROMIUM(program, kResultBucketId);
   GetBucketContents(kResultBucketId, result);
 }
 
 void GLES2Implementation::GetProgramInfoCHROMIUM(
     GLuint program, GLsizei bufsize, GLsizei* size, void* info) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   if (bufsize < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glProgramInfoCHROMIUM", "bufsize less than 0.");
     return;
   }
   if (size == NULL) {
     SetGLError(GL_INVALID_VALUE, "glProgramInfoCHROMIUM", "size is null.");
     return;
   }
   // Make sure they've set size to 0 else the value will be undefined on
   // lost context.
   DCHECK_EQ(0, *size);
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   GetProgramInfoCHROMIUMHelper(program, &result);
   if (result.empty()) {
     return;
   }
   *size = result.size();
   if (!info) {
     return;
   }
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION,
                "glProgramInfoCHROMIUM", "bufsize is too small for result.");
     return;
   }
   memcpy(info, &result[0], result.size());
 }
 
 void GLES2Implementation::GetUniformBlocksCHROMIUMHelper(
-    GLuint program, std::vector<int8>* result) {
+    GLuint program,
+    std::vector<int8_t>* result) {
   DCHECK(result);
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetUniformBlocksCHROMIUM(program, kResultBucketId);
   GetBucketContents(kResultBucketId, result);
 }
 
 void GLES2Implementation::GetUniformBlocksCHROMIUM(
     GLuint program, GLsizei bufsize, GLsizei* size, void* info) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   if (bufsize < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glGetUniformBlocksCHROMIUM", "bufsize less than 0.");
     return;
   }
   if (size == NULL) {
     SetGLError(GL_INVALID_VALUE, "glGetUniformBlocksCHROMIUM", "size is null.");
     return;
   }
   // Make sure they've set size to 0 else the value will be undefined on
   // lost context.
   DCHECK_EQ(0, *size);
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   GetUniformBlocksCHROMIUMHelper(program, &result);
   if (result.empty()) {
     return;
   }
   *size = result.size();
   if (!info) {
     return;
   }
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION, "glGetUniformBlocksCHROMIUM",
                "bufsize is too small for result.");
     return;
   }
   memcpy(info, &result[0], result.size());
 }
 
 void GLES2Implementation::GetUniformsES3CHROMIUMHelper(
-    GLuint program, std::vector<int8>* result) {
+    GLuint program,
+    std::vector<int8_t>* result) {
   DCHECK(result);
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetUniformsES3CHROMIUM(program, kResultBucketId);
   GetBucketContents(kResultBucketId, result);
 }
 
 void GLES2Implementation::GetUniformsES3CHROMIUM(
     GLuint program, GLsizei bufsize, GLsizei* size, void* info) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   if (bufsize < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glGetUniformsES3CHROMIUM", "bufsize less than 0.");
     return;
   }
   if (size == NULL) {
     SetGLError(GL_INVALID_VALUE, "glGetUniformsES3CHROMIUM", "size is null.");
     return;
   }
   // Make sure they've set size to 0 else the value will be undefined on
   // lost context.
   DCHECK_EQ(0, *size);
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   GetUniformsES3CHROMIUMHelper(program, &result);
   if (result.empty()) {
     return;
   }
   *size = result.size();
   if (!info) {
     return;
   }
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION,
                "glGetUniformsES3CHROMIUM", "bufsize is too small for result.");
     return;
   }
   memcpy(info, &result[0], result.size());
 }
 
 void GLES2Implementation::GetTransformFeedbackVaryingsCHROMIUMHelper(
-    GLuint program, std::vector<int8>* result) {
+    GLuint program,
+    std::vector<int8_t>* result) {
   DCHECK(result);
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetTransformFeedbackVaryingsCHROMIUM(program, kResultBucketId);
   GetBucketContents(kResultBucketId, result);
 }
 
 void GLES2Implementation::GetTransformFeedbackVaryingsCHROMIUM(
     GLuint program, GLsizei bufsize, GLsizei* size, void* info) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetTransformFeedbackVaryingsCHROMIUM",
                "bufsize less than 0.");
     return;
   }
   if (size == NULL) {
     SetGLError(GL_INVALID_VALUE, "glGetTransformFeedbackVaryingsCHROMIUM",
                "size is null.");
     return;
   }
   // Make sure they've set size to 0 else the value will be undefined on
   // lost context.
   DCHECK_EQ(0, *size);
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   GetTransformFeedbackVaryingsCHROMIUMHelper(program, &result);
   if (result.empty()) {
     return;
   }
   *size = result.size();
   if (!info) {
     return;
   }
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION, "glGetTransformFeedbackVaryingsCHROMIUM",
@@ skipping 1108 matching lines @@
     return;
   }
   if (num_coords < 0) {
     SetGLError(GL_INVALID_VALUE, kFunctionName, "numCoords < 0");
     return;
   }
   if (num_coords != 0 && !coords) {
     SetGLError(GL_INVALID_VALUE, kFunctionName, "missing coords");
     return;
   }
-  uint32 coord_type_size = GLES2Util::GetGLTypeSizeForPathCoordType(coord_type);
+  uint32_t coord_type_size =
+      GLES2Util::GetGLTypeSizeForPathCoordType(coord_type);
   if (coord_type_size == 0) {
     SetGLError(GL_INVALID_ENUM, kFunctionName, "invalid coordType");
     return;
   }
   if (num_commands == 0) {
     // No commands must mean no coords, thus nothing to memcpy. Let
     // the service validate the call. Validate coord_type above, so
     // that the parameters will be checked the in the same order
     // regardless of num_commands.
     helper_->PathCommandsCHROMIUM(path, num_commands, 0, 0, num_coords,
                                   coord_type, 0, 0);
     CheckGLError();
     return;
   }
 
-  uint32 coords_size;
+  uint32_t coords_size;
   if (!SafeMultiplyUint32(num_coords, coord_type_size, &coords_size)) {
     SetGLError(GL_INVALID_OPERATION, kFunctionName, "overflow");
     return;
   }
 
-  uint32 required_buffer_size;
+  uint32_t required_buffer_size;
   if (!SafeAddUint32(coords_size, num_commands, &required_buffer_size)) {
     SetGLError(GL_INVALID_OPERATION, kFunctionName, "overflow");
     return;
   }
 
   ScopedTransferBufferPtr buffer(required_buffer_size, helper_,
                                  transfer_buffer_);
   if (!buffer.valid() || buffer.size() < required_buffer_size) {
     SetGLError(GL_OUT_OF_MEMORY, kFunctionName, "too large");
     return;
   }
 
-  uint32 coords_shm_id = 0;
-  uint32 coords_shm_offset = 0;
+  uint32_t coords_shm_id = 0;
+  uint32_t coords_shm_offset = 0;
   // Copy coords first because they need more strict alignment.
   if (coords_size > 0) {
     unsigned char* coords_addr = static_cast<unsigned char*>(buffer.address());
     memcpy(coords_addr, coords, coords_size);
     coords_shm_id = buffer.shm_id();
     coords_shm_offset = buffer.offset();
   }
 
   DCHECK(num_commands > 0);
   unsigned char* commands_addr =
       static_cast<unsigned char*>(buffer.address()) + coords_size;
   memcpy(commands_addr, commands, num_commands);
 
   helper_->PathCommandsCHROMIUM(path, num_commands, buffer.shm_id(),
                                 buffer.offset() + coords_size, num_coords,
                                 coord_type, coords_shm_id, coords_shm_offset);
   CheckGLError();
 }
 
 bool GLES2Implementation::PrepareInstancedPathCommand(
     const char* function_name,
     GLsizei num_paths,
     GLenum path_name_type,
     const void* paths,
     GLenum transform_type,
     const GLfloat* transform_values,
     ScopedTransferBufferPtr* buffer,
-    uint32* out_paths_shm_id,
+    uint32_t* out_paths_shm_id,
     size_t* out_paths_offset,
-    uint32* out_transforms_shm_id,
+    uint32_t* out_transforms_shm_id,
     size_t* out_transforms_offset) {
   if (num_paths < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "numPaths < 0");
     return false;
   }
-  uint32 path_name_size =
+  uint32_t path_name_size =
       GLES2Util::GetGLTypeSizeForGLPathNameType(path_name_type);
 
   if (path_name_size == 0) {
     SetGLError(GL_INVALID_ENUM, function_name, "invalid pathNameType");
     return false;
   }
 
-  uint32 transforms_component_count =
+  uint32_t transforms_component_count =
       GLES2Util::GetComponentCountForGLTransformType(transform_type);
 
   if (transform_type != GL_NONE && transforms_component_count == 0) {
     SetGLError(GL_INVALID_ENUM, function_name, "invalid transformType");
     return false;
   }
 
   if (num_paths == 0) {
     // This might still be a valid or an invalid GL call. Make an empty call to
     // the service side to check the rest of the parameters. We check the above
@@ skipping 11 matching lines @@
   if (!paths) {
     SetGLError(GL_INVALID_VALUE, function_name, "missing paths");
     return false;
   }
 
   if (transform_type != GL_NONE && !transform_values) {
     SetGLError(GL_INVALID_VALUE, function_name, "missing transforms");
     return false;
   }
 
-  uint32 paths_size;
+  uint32_t paths_size;
   if (!SafeMultiplyUint32(path_name_size, num_paths, &paths_size)) {
     SetGLError(GL_INVALID_OPERATION, function_name, "overflow");
     return false;
   }
 
   // The multiplication below will not overflow.
   DCHECK(transforms_component_count <= 12);
-  uint32 one_transform_size = sizeof(GLfloat) * transforms_component_count;
+  uint32_t one_transform_size = sizeof(GLfloat) * transforms_component_count;
 
-  uint32 transforms_size;
+  uint32_t transforms_size;
   if (!SafeMultiplyUint32(one_transform_size, num_paths, &transforms_size)) {
     SetGLError(GL_INVALID_OPERATION, function_name, "overflow");
     return false;
   }
 
-  uint32 required_buffer_size;
+  uint32_t required_buffer_size;
   if (!SafeAddUint32(transforms_size, paths_size, &required_buffer_size)) {
     SetGLError(GL_INVALID_OPERATION, function_name, "overflow");
     return false;
   }
 
   buffer->Reset(required_buffer_size);
 
   if (!buffer->valid() || buffer->size() < required_buffer_size) {
     SetGLError(GL_OUT_OF_MEMORY, function_name, "too large");
     return false;
@@ skipping 31 matching lines @@
     GLenum transform_type,
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix()
                      << "] glStencilFillPathInstancedCHROMIUM(" << num_paths
                      << ", " << path_name_type << ", " << paths << ", "
                      << path_base << ", " << fill_mode << ", " << mask << ", "
                      << transform_type << ", " << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glStencilFillPathInstancedCHROMIUM", num_paths, path_name_type,
           paths, transform_type, transform_values, &buffer, &paths_shm_id,
           &paths_offset, &transforms_shm_id, &transforms_offset)) {
     return;
   }
 
   helper_->StencilFillPathInstancedCHROMIUM(
       num_paths, path_name_type, paths_shm_id, paths_offset, path_base,
@@ skipping 12 matching lines @@
     GLenum transform_type,
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix()
                      << "] glStencilStrokePathInstancedCHROMIUM(" << num_paths
                      << ", " << path_name_type << ", " << paths << ", "
                      << path_base << ", " << ref << ", " << mask << ", "
                      << transform_type << ", " << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glStencilStrokePathInstancedCHROMIUM", num_paths, path_name_type,
           paths, transform_type, transform_values, &buffer, &paths_shm_id,
           &paths_offset, &transforms_shm_id, &transforms_offset)) {
     return;
   }
 
   helper_->StencilStrokePathInstancedCHROMIUM(
       num_paths, path_name_type, paths_shm_id, paths_offset, path_base, ref,
@@ skipping 10 matching lines @@
     GLenum cover_mode,
     GLenum transform_type,
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCoverFillPathInstancedCHROMIUM("
                      << num_paths << ", " << path_name_type << ", " << paths
                      << ", " << path_base << ", " << cover_mode << ", "
                      << transform_type << ", " << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glCoverFillPathInstancedCHROMIUM", num_paths, path_name_type, paths,
           transform_type, transform_values, &buffer, &paths_shm_id,
           &paths_offset, &transforms_shm_id, &transforms_offset)) {
     return;
   }
 
   helper_->CoverFillPathInstancedCHROMIUM(
       num_paths, path_name_type, paths_shm_id, paths_offset, path_base,
@@ skipping 11 matching lines @@
     GLenum transform_type,
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix()
                      << "] glCoverStrokePathInstancedCHROMIUM(" << num_paths
                      << ", " << path_name_type << ", " << paths << ", "
                      << path_base << ", " << cover_mode << ", "
                      << transform_type << ", " << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glCoverStrokePathInstancedCHROMIUM", num_paths, path_name_type,
           paths, transform_type, transform_values, &buffer, &paths_shm_id,
           &paths_offset, &transforms_shm_id, &transforms_offset)) {
     return;
   }
 
   helper_->CoverStrokePathInstancedCHROMIUM(
       num_paths, path_name_type, paths_shm_id, paths_offset, path_base,
@@ skipping 13 matching lines @@
     GLenum transform_type,
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << GetLogPrefix() << "] glStencilThenCoverFillPathInstancedCHROMIUM("
           << num_paths << ", " << path_name_type << ", " << paths << ", "
           << path_base << ", " << cover_mode << ", " << fill_mode << ", "
           << mask << ", " << transform_type << ", " << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glStencilThenCoverFillPathInstancedCHROMIUM", num_paths,
           path_name_type, paths, transform_type, transform_values, &buffer,
           &paths_shm_id, &paths_offset, &transforms_shm_id,
           &transforms_offset)) {
     return;
   }
 
   helper_->StencilThenCoverFillPathInstancedCHROMIUM(
@@ skipping 16 matching lines @@
     const GLfloat* transform_values) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix()
                      << "] glStencilThenCoverStrokePathInstancedCHROMIUM("
                      << num_paths << ", " << path_name_type << ", " << paths
                      << ", " << path_base << ", " << cover_mode << ", " << ref
                      << ", " << mask << ", " << transform_type << ", "
                      << transform_values << ")");
 
   ScopedTransferBufferPtr buffer(helper_, transfer_buffer_);
-  uint32 paths_shm_id = 0;
+  uint32_t paths_shm_id = 0;
   size_t paths_offset = 0;
-  uint32 transforms_shm_id = 0;
+  uint32_t transforms_shm_id = 0;
   size_t transforms_offset = 0;
   if (!PrepareInstancedPathCommand(
           "glStencilThenCoverStrokePathInstancedCHROMIUM", num_paths,
           path_name_type, paths, transform_type, transform_values, &buffer,
           &paths_shm_id, &paths_offset, &transforms_shm_id,
           &transforms_offset)) {
     return;
   }
 
   helper_->StencilThenCoverStrokePathInstancedCHROMIUM(
@@ skipping 22 matching lines @@
     GLint location,
     GLenum gen_mode,
     GLint components,
     const GLfloat* coeffs) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix()
                      << "] glProgramPathFragmentInputGenCHROMIUM(" << program
                      << ", " << gen_mode << ", " << components << ", " << coeffs
                      << ")");
 
-  uint32 coeffs_per_component =
+  uint32_t coeffs_per_component =
       GLES2Util::GetCoefficientCountForGLPathFragmentInputGenMode(gen_mode);
 
   if (components <= 0 || components > 4 || gen_mode == GL_NONE ||
       coeffs_per_component == 0 || location == -1) {
     helper_->ProgramPathFragmentInputGenCHROMIUM(program, location, gen_mode,
                                                  components, 0, 0);
   } else {
     // 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;
 
     ScopedTransferBufferPtr buffer(coeffs_size, helper_, transfer_buffer_);
     if (!buffer.valid() || buffer.size() < coeffs_size) {
       SetGLError(GL_OUT_OF_MEMORY, "glProgramPathFragmentInputGenCHROMIUM",
                  "no room in transfer buffer");
       return;
     }
 
     DCHECK(coeffs_size > 0);
     unsigned char* addr = static_cast<unsigned char*>(buffer.address());
     memcpy(addr, coeffs, coeffs_size);
 
     helper_->ProgramPathFragmentInputGenCHROMIUM(program, location, gen_mode,
                                                  components, buffer.shm_id(),
                                                  buffer.offset());
   }
   CheckGLError();
 }
 
 // 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 "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu