Switch to standard integer types in gpu/.

BUG=138542
TBR=piman@chromium.org

Review URL: https://codereview.chromium.org/1542513002

Cr-Commit-Position: refs/heads/master@{#366400}

253 files changed, 3536 insertions, 2896 deletions

diff --git a/gpu/blink/webgraphicscontext3d_impl.cc b/gpu/blink/webgraphicscontext3d_impl.cc
index 29141e4..eec0300 100644
--- a/gpu/blink/webgraphicscontext3d_impl.cc
+++ b/gpu/blink/webgraphicscontext3d_impl.cc
@@ -4,9 +4,12 @@
 
 #include "gpu/blink/webgraphicscontext3d_impl.h"
 
+#include <stdint.h>
+
 #include "base/atomicops.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
diff --git a/gpu/blink/webgraphicscontext3d_impl.h b/gpu/blink/webgraphicscontext3d_impl.h
index 7e7625b..b3c1dea 100644
--- a/gpu/blink/webgraphicscontext3d_impl.h
+++ b/gpu/blink/webgraphicscontext3d_impl.h
@@ -5,6 +5,8 @@
 #ifndef GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_
 #define GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
diff --git a/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.cc b/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.cc
index 04af7ca..d1d7e35 100644
--- a/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.cc
+++ b/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.cc
@@ -10,6 +10,7 @@
 #endif
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
 
 #include <string>
 
diff --git a/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h b/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h
index 8500a7f..87352f4 100644
--- a/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h
+++ b/gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h
@@ -5,6 +5,8 @@
 #ifndef GPU_BLINK_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
 #define GPU_BLINK_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
 
+#include <stddef.h>
+
 #include <vector>
 
 #include "base/compiler_specific.h"
diff --git a/gpu/command_buffer/client/buffer_tracker.cc b/gpu/command_buffer/client/buffer_tracker.cc
index 63adba7..548dbe8 100644
--- a/gpu/command_buffer/client/buffer_tracker.cc
+++ b/gpu/command_buffer/client/buffer_tracker.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/client/buffer_tracker.h"
 
+#include <stdint.h>
+
 #include <utility>
 #include "gpu/command_buffer/client/mapped_memory.h"
 
@@ -24,8 +26,8 @@ BufferTracker::Buffer* BufferTracker::CreateBuffer(
     GLuint id, GLsizeiptr size) {
   DCHECK_NE(0u, id);
   DCHECK_LE(0, size);
-  int32 shm_id = -1;
-  uint32 shm_offset = 0;
+  int32_t shm_id = -1;
+  uint32_t shm_offset = 0;
   void* address = NULL;
   if (size)
     address = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
@@ -53,7 +55,7 @@ void BufferTracker::RemoveBuffer(GLuint client_id) {
   }
 }
 
-void BufferTracker::FreePendingToken(Buffer* buffer, int32 token) {
+void BufferTracker::FreePendingToken(Buffer* buffer, int32_t token) {
   if (buffer->address_)
     mapped_memory_->FreePendingToken(buffer->address_, token);
   buffer->size_ = 0;
diff --git a/gpu/command_buffer/client/buffer_tracker.h b/gpu/command_buffer/client/buffer_tracker.h
index b092b8a..62508b3 100644
--- a/gpu/command_buffer/client/buffer_tracker.h
+++ b/gpu/command_buffer/client/buffer_tracker.h
@@ -5,7 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_BUFFER_TRACKER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_BUFFER_TRACKER_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "gles2_impl_export.h"
@@ -24,8 +25,8 @@ class GLES2_IMPL_EXPORT BufferTracker {
    public:
     Buffer(GLuint id,
            unsigned int size,
-           int32 shm_id,
-           uint32 shm_offset,
+           int32_t shm_id,
+           uint32_t shm_offset,
            void* address)
         : id_(id),
           size_(size),
@@ -34,8 +35,7 @@ class GLES2_IMPL_EXPORT BufferTracker {
           address_(address),
           mapped_(false),
           last_usage_token_(0),
-          last_async_upload_token_(0) {
-    }
+          last_async_upload_token_(0) {}
 
     GLenum id() const {
       return id_;
@@ -45,13 +45,9 @@ class GLES2_IMPL_EXPORT BufferTracker {
       return size_;
     }
 
-    int32 shm_id() const {
-      return shm_id_;
-    }
+    int32_t shm_id() const { return shm_id_; }
 
-    uint32 shm_offset() const {
-      return shm_offset_;
-    }
+    uint32_t shm_offset() const { return shm_offset_; }
 
     void* address() const {
       return address_;
@@ -73,7 +69,7 @@ class GLES2_IMPL_EXPORT BufferTracker {
       return last_usage_token_;
     }
 
-    void set_last_async_upload_token(uint32 async_token) {
+    void set_last_async_upload_token(uint32_t async_token) {
       last_async_upload_token_ = async_token;
     }
 
@@ -87,11 +83,11 @@ class GLES2_IMPL_EXPORT BufferTracker {
 
     GLuint id_;
     unsigned int size_;
-    int32 shm_id_;
-    uint32 shm_offset_;
+    int32_t shm_id_;
+    uint32_t shm_offset_;
     void* address_;
     bool mapped_;
-    int32 last_usage_token_;
+    int32_t last_usage_token_;
     GLuint last_async_upload_token_;
   };
 
@@ -104,7 +100,7 @@ class GLES2_IMPL_EXPORT BufferTracker {
 
   // Frees the block of memory associated with buffer, pending the passage
   // of a token.
-  void FreePendingToken(Buffer* buffer, int32 token);
+  void FreePendingToken(Buffer* buffer, int32_t token);
   void Unmanage(Buffer* buffer);
   void Free(Buffer* buffer);
 
diff --git a/gpu/command_buffer/client/buffer_tracker_unittest.cc b/gpu/command_buffer/client/buffer_tracker_unittest.cc
index c1ed0b6..c44d384 100644
--- a/gpu/command_buffer/client/buffer_tracker_unittest.cc
+++ b/gpu/command_buffer/client/buffer_tracker_unittest.cc
@@ -8,6 +8,8 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stddef.h>
+#include <stdint.h>
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
@@ -27,7 +29,7 @@ class MockClientCommandBufferImpl : public MockClientCommandBuffer {
   ~MockClientCommandBufferImpl() override {}
 
   scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
-                                                  int32* id) override {
+                                                  int32_t* id) override {
     if (context_lost_) {
       *id = -1;
       return NULL;
@@ -45,8 +47,8 @@ class MockClientCommandBufferImpl : public MockClientCommandBuffer {
 
 class BufferTrackerTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
 
   void SetUp() override {
diff --git a/gpu/command_buffer/client/client_test_helper.cc b/gpu/command_buffer/client/client_test_helper.cc
index f317902..3e8c43c 100644
--- a/gpu/command_buffer/client/client_test_helper.cc
+++ b/gpu/command_buffer/client/client_test_helper.cc
@@ -6,8 +6,11 @@
 
 #include "gpu/command_buffer/client/client_test_helper.h"
 
-#include "gpu/command_buffer/common/command_buffer.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
+#include "gpu/command_buffer/common/command_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
@@ -29,17 +32,18 @@ CommandBuffer::State MockCommandBufferBase::GetLastState() {
   return state_;
 }
 
-int32 MockCommandBufferBase::GetLastToken() {
+int32_t MockCommandBufferBase::GetLastToken() {
   return state_.token;
 }
 
-void MockCommandBufferBase::SetGetOffset(int32 get_offset) {
+void MockCommandBufferBase::SetGetOffset(int32_t get_offset) {
   state_.get_offset = get_offset;
 }
 
-void MockCommandBufferBase::WaitForTokenInRange(int32 start, int32 end) {}
+void MockCommandBufferBase::WaitForTokenInRange(int32_t start, int32_t end) {}
 
-void MockCommandBufferBase::WaitForGetOffsetInRange(int32 start, int32 end) {
+void MockCommandBufferBase::WaitForGetOffsetInRange(int32_t start,
+                                                    int32_t end) {
   state_.get_offset = put_offset_;
   OnFlush();
 }
@@ -53,7 +57,7 @@ void MockCommandBufferBase::SetGetBuffer(int transfer_buffer_id) {
 
 // Get's the Id of the next transfer buffer that will be returned
 // by CreateTransferBuffer. This is useful for testing expected ids.
-int32 MockCommandBufferBase::GetNextFreeTransferBufferId() {
+int32_t MockCommandBufferBase::GetNextFreeTransferBufferId() {
   for (size_t ii = 0; ii < arraysize(transfer_buffer_buffers_); ++ii) {
     if (!transfer_buffer_buffers_[ii].get()) {
       return kTransferBufferBaseId + ii;
@@ -64,10 +68,10 @@ int32 MockCommandBufferBase::GetNextFreeTransferBufferId() {
 
 scoped_refptr<gpu::Buffer> MockCommandBufferBase::CreateTransferBuffer(
     size_t size,
-    int32* id) {
+    int32_t* id) {
   *id = GetNextFreeTransferBufferId();
   if (*id >= 0) {
-    int32 ndx = *id - kTransferBufferBaseId;
+    int32_t ndx = *id - kTransferBufferBaseId;
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(size);
     transfer_buffer_buffers_[ndx] =
@@ -76,24 +80,24 @@ scoped_refptr<gpu::Buffer> MockCommandBufferBase::CreateTransferBuffer(
   return GetTransferBuffer(*id);
 }
 
-void MockCommandBufferBase::DestroyTransferBufferHelper(int32 id) {
+void MockCommandBufferBase::DestroyTransferBufferHelper(int32_t id) {
   DCHECK_GE(id, kTransferBufferBaseId);
   DCHECK_LT(id, kTransferBufferBaseId + kMaxTransferBuffers);
   id -= kTransferBufferBaseId;
   transfer_buffer_buffers_[id] = NULL;
 }
 
-scoped_refptr<Buffer> MockCommandBufferBase::GetTransferBuffer(int32 id) {
+scoped_refptr<Buffer> MockCommandBufferBase::GetTransferBuffer(int32_t id) {
   DCHECK_GE(id, kTransferBufferBaseId);
   DCHECK_LT(id, kTransferBufferBaseId + kMaxTransferBuffers);
   return transfer_buffer_buffers_[id - kTransferBufferBaseId];
 }
 
-void MockCommandBufferBase::FlushHelper(int32 put_offset) {
+void MockCommandBufferBase::FlushHelper(int32_t put_offset) {
   put_offset_ = put_offset;
 }
 
-void MockCommandBufferBase::SetToken(int32 token) {
+void MockCommandBufferBase::SetToken(int32_t token) {
   NOTREACHED();
   state_.token = token;
 }
@@ -109,14 +113,14 @@ void MockCommandBufferBase::SetContextLostReason(
   state_.context_lost_reason = reason;
 }
 
-int32 MockCommandBufferBase::GetPutOffset() {
+int32_t MockCommandBufferBase::GetPutOffset() {
   return put_offset_;
 }
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
-const int32 MockCommandBufferBase::kTransferBufferBaseId;
-const int32 MockCommandBufferBase::kMaxTransferBuffers;
+const int32_t MockCommandBufferBase::kTransferBufferBaseId;
+const int32_t MockCommandBufferBase::kMaxTransferBuffers;
 #endif
 
 MockClientCommandBuffer::MockClientCommandBuffer() {
@@ -126,11 +130,11 @@ MockClientCommandBuffer::MockClientCommandBuffer() {
 MockClientCommandBuffer::~MockClientCommandBuffer() {
 }
 
-void MockClientCommandBuffer::Flush(int32 put_offset) {
+void MockClientCommandBuffer::Flush(int32_t put_offset) {
   FlushHelper(put_offset);
 }
 
-void MockClientCommandBuffer::OrderingBarrier(int32 put_offset) {
+void MockClientCommandBuffer::OrderingBarrier(int32_t put_offset) {
   FlushHelper(put_offset);
 }
 
diff --git a/gpu/command_buffer/client/client_test_helper.h b/gpu/command_buffer/client/client_test_helper.h
index 91ad50a..994dff5 100644
--- a/gpu/command_buffer/client/client_test_helper.h
+++ b/gpu/command_buffer/client/client_test_helper.h
@@ -7,7 +7,11 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_CLIENT_TEST_HELPER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_CLIENT_TEST_HELPER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/client/gpu_control.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
@@ -23,33 +27,33 @@ class CommandBufferHelper;
 
 class MockCommandBufferBase : public CommandBufferServiceBase {
  public:
-  static const int32 kTransferBufferBaseId = 0x123;
-  static const int32 kMaxTransferBuffers = 32;
+  static const int32_t kTransferBufferBaseId = 0x123;
+  static const int32_t kMaxTransferBuffers = 32;
 
   MockCommandBufferBase();
   ~MockCommandBufferBase() override;
 
   bool Initialize() override;
   State GetLastState() override;
-  int32 GetLastToken() override;
-  void WaitForTokenInRange(int32 start, int32 end) override;
-  void WaitForGetOffsetInRange(int32 start, int32 end) override;
+  int32_t GetLastToken() override;
+  void WaitForTokenInRange(int32_t start, int32_t end) override;
+  void WaitForGetOffsetInRange(int32_t start, int32_t end) override;
   void SetGetBuffer(int transfer_buffer_id) override;
-  void SetGetOffset(int32 get_offset) override;
+  void SetGetOffset(int32_t get_offset) override;
   scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
-                                                  int32* id) override;
-  scoped_refptr<gpu::Buffer> GetTransferBuffer(int32 id) override;
-  void SetToken(int32 token) override;
+                                                  int32_t* id) override;
+  scoped_refptr<gpu::Buffer> GetTransferBuffer(int32_t id) override;
+  void SetToken(int32_t token) override;
   void SetParseError(error::Error error) override;
   void SetContextLostReason(error::ContextLostReason reason) override;
-  int32 GetPutOffset() override;
+  int32_t GetPutOffset() override;
 
   // Get's the Id of the next transfer buffer that will be returned
   // by CreateTransferBuffer. This is useful for testing expected ids.
-  int32 GetNextFreeTransferBufferId();
+  int32_t GetNextFreeTransferBufferId();
 
-  void FlushHelper(int32 put_offset);
-  void DestroyTransferBufferHelper(int32 id);
+  void FlushHelper(int32_t put_offset);
+  void DestroyTransferBufferHelper(int32_t id);
 
   virtual void OnFlush() = 0;
 
@@ -58,7 +62,7 @@ class MockCommandBufferBase : public CommandBufferServiceBase {
   CommandBufferEntry* ring_buffer_;
   scoped_refptr<Buffer> ring_buffer_buffer_;
   State state_;
-  int32 put_offset_;
+  int32_t put_offset_;
 };
 
 class MockClientCommandBuffer : public MockCommandBufferBase {
@@ -68,10 +72,10 @@ class MockClientCommandBuffer : public MockCommandBufferBase {
 
   // This is so we can use all the gmock functions when Flush is called.
   MOCK_METHOD0(OnFlush, void());
-  MOCK_METHOD1(DestroyTransferBuffer, void(int32 id));
+  MOCK_METHOD1(DestroyTransferBuffer, void(int32_t id));
 
-  void Flush(int32 put_offset) override;
-  void OrderingBarrier(int32 put_offset) override;
+  void Flush(int32_t put_offset) override;
+  void OrderingBarrier(int32_t put_offset) override;
 
   void DelegateToFake();
 };
@@ -81,8 +85,8 @@ class MockClientCommandBufferMockFlush : public MockClientCommandBuffer {
   MockClientCommandBufferMockFlush();
   virtual ~MockClientCommandBufferMockFlush();
 
-  MOCK_METHOD1(Flush, void(int32 put_offset));
-  MOCK_METHOD1(OrderingBarrier, void(int32 put_offset));
+  MOCK_METHOD1(Flush, void(int32_t put_offset));
+  MOCK_METHOD1(OrderingBarrier, void(int32_t put_offset));
 
   void DelegateToFake();
 };
@@ -94,22 +98,24 @@ class MockClientGpuControl : public GpuControl {
 
   MOCK_METHOD0(GetCapabilities, Capabilities());
   MOCK_METHOD4(CreateImage,
-               int32(ClientBuffer buffer,
-                     size_t width,
-                     size_t height,
-                     unsigned internalformat));
-  MOCK_METHOD1(DestroyImage, void(int32 id));
+               int32_t(ClientBuffer buffer,
+                       size_t width,
+                       size_t height,
+                       unsigned internalformat));
+  MOCK_METHOD1(DestroyImage, void(int32_t id));
   MOCK_METHOD4(CreateGpuMemoryBufferImage,
-               int32(size_t width,
-                     size_t height,
-                     unsigned internalformat,
-                     unsigned usage));
-  MOCK_METHOD0(InsertSyncPoint, uint32());
-  MOCK_METHOD0(InsertFutureSyncPoint, uint32());
-  MOCK_METHOD1(RetireSyncPoint, void(uint32 id));
-  MOCK_METHOD2(SignalSyncPoint, void(uint32 id, const base::Closure& callback));
-  MOCK_METHOD2(SignalQuery, void(uint32 query, const base::Closure& callback));
-  MOCK_METHOD1(CreateStreamTexture, uint32(uint32));
+               int32_t(size_t width,
+                       size_t height,
+                       unsigned internalformat,
+                       unsigned usage));
+  MOCK_METHOD0(InsertSyncPoint, uint32_t());
+  MOCK_METHOD0(InsertFutureSyncPoint, uint32_t());
+  MOCK_METHOD1(RetireSyncPoint, void(uint32_t id));
+  MOCK_METHOD2(SignalSyncPoint,
+               void(uint32_t id, const base::Closure& callback));
+  MOCK_METHOD2(SignalQuery,
+               void(uint32_t query, const base::Closure& callback));
+  MOCK_METHOD1(CreateStreamTexture, uint32_t(uint32_t));
   MOCK_METHOD1(SetLock, void(base::Lock*));
   MOCK_METHOD0(IsGpuChannelLost, bool());
   MOCK_CONST_METHOD0(GetNamespaceID, CommandBufferNamespace());
diff --git a/gpu/command_buffer/client/cmd_buffer_helper.cc b/gpu/command_buffer/client/cmd_buffer_helper.cc
index 21a5b2c..6f5bc2e 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper.cc
+++ b/gpu/command_buffer/client/cmd_buffer_helper.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ -69,7 +71,7 @@ void CommandBufferHelper::CalcImmediateEntries(int waiting_count) {
   }
 
   // Get maximum safe contiguous entries.
-  const int32 curr_get = get_offset();
+  const int32_t curr_get = get_offset();
   if (curr_get > put_) {
     immediate_entry_count_ = curr_get - put_ - 1;
   } else {
@@ -79,11 +81,11 @@ void CommandBufferHelper::CalcImmediateEntries(int waiting_count) {
 
   // Limit entry count to force early flushing.
   if (flush_automatically_) {
-    int32 limit =
+    int32_t limit =
         total_entry_count_ /
         ((curr_get == last_put_sent_) ? kAutoFlushSmall : kAutoFlushBig);
 
-    int32 pending =
+    int32_t pending =
         (put_ + total_entry_count_ - last_put_sent_) % total_entry_count_;
 
     if (pending > 0 && pending >= limit) {
@@ -109,7 +111,7 @@ bool CommandBufferHelper::AllocateRingBuffer() {
     return true;
   }
 
-  int32 id = -1;
+  int32_t id = -1;
   scoped_refptr<Buffer> buffer =
       command_buffer_->CreateTransferBuffer(ring_buffer_size_, &id);
   if (id < 0) {
@@ -146,7 +148,7 @@ void CommandBufferHelper::FreeRingBuffer() {
   FreeResources();
 }
 
-bool CommandBufferHelper::Initialize(int32 ring_buffer_size) {
+bool CommandBufferHelper::Initialize(int32_t ring_buffer_size) {
   ring_buffer_size_ = ring_buffer_size;
   return AllocateRingBuffer();
 }
@@ -157,7 +159,7 @@ CommandBufferHelper::~CommandBufferHelper() {
   FreeResources();
 }
 
-bool CommandBufferHelper::WaitForGetOffsetInRange(int32 start, int32 end) {
+bool CommandBufferHelper::WaitForGetOffsetInRange(int32_t start, int32_t end) {
   DCHECK(start >= 0 && start <= total_entry_count_);
   DCHECK(end >= 0 && end <= total_entry_count_);
   if (!usable()) {
@@ -230,7 +232,7 @@ bool CommandBufferHelper::Finish() {
 // scheme so that we don't lose tokens (a token has passed if the current token
 // value is higher than that token). Calls Finish() if the token value wraps,
 // which will be rare.
-int32 CommandBufferHelper::InsertToken() {
+int32_t CommandBufferHelper::InsertToken() {
   AllocateRingBuffer();
   if (!usable()) {
     return token_;
@@ -254,7 +256,7 @@ int32 CommandBufferHelper::InsertToken() {
 
 // Waits until the current token value is greater or equal to the value passed
 // in argument.
-void CommandBufferHelper::WaitForToken(int32 token) {
+void CommandBufferHelper::WaitForToken(int32_t token) {
   if (!usable() || !HaveRingBuffer()) {
     return;
   }
@@ -273,7 +275,7 @@ void CommandBufferHelper::WaitForToken(int32 token) {
 // around, adding a noops. Thus this function may change the value of put_. The
 // function will return early if an error occurs, in which case the available
 // space may not be available.
-void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
+void CommandBufferHelper::WaitForAvailableEntries(int32_t count) {
   AllocateRingBuffer();
   if (!usable()) {
     return;
@@ -286,7 +288,7 @@ void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
     // but we need to make sure get wraps first, actually that get is 1 or
     // more (since put will wrap to 0 after we add the noops).
     DCHECK_LE(1, put_);
-    int32 curr_get = get_offset();
+    int32_t curr_get = get_offset();
     if (curr_get > put_ || curr_get == 0) {
       TRACE_EVENT0("gpu", "CommandBufferHelper::WaitForAvailableEntries");
       Flush();
@@ -297,9 +299,9 @@ void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
       DCHECK_NE(0, curr_get);
     }
     // Insert Noops to fill out the buffer.
-    int32 num_entries = total_entry_count_ - put_;
+    int32_t num_entries = total_entry_count_ - put_;
     while (num_entries > 0) {
-      int32 num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
+      int32_t num_to_skip = std::min(CommandHeader::kMaxSize, num_entries);
       cmd::Noop::Set(&entries_[put_], num_to_skip);
       put_ += num_to_skip;
       num_entries -= num_to_skip;
@@ -325,8 +327,8 @@ void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
   }
 }
 
-int32 CommandBufferHelper::GetTotalFreeEntriesNoWaiting() const {
-  int32 current_get_offset = get_offset();
+int32_t CommandBufferHelper::GetTotalFreeEntriesNoWaiting() const {
+  int32_t current_get_offset = get_offset();
   if (current_get_offset > put_) {
     return current_get_offset - put_ - 1;
   } else {
@@ -341,7 +343,7 @@ bool CommandBufferHelper::OnMemoryDump(
   if (!HaveRingBuffer())
     return true;
 
-  const uint64 tracing_process_id =
+  const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
 
diff --git a/gpu/command_buffer/client/cmd_buffer_helper.h b/gpu/command_buffer/client/cmd_buffer_helper.h
index 8739316..df18922 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper.h
+++ b/gpu/command_buffer/client/cmd_buffer_helper.h
@@ -7,9 +7,10 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_CMD_BUFFER_HELPER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -42,7 +43,7 @@ const int kAutoFlushBig = 2;     // 1/2 of the buffer
 //
 // helper.AddCommand(...);
 // helper.AddCommand(...);
-// int32 token = helper.InsertToken();
+// int32_t token = helper.InsertToken();
 // helper.AddCommand(...);
 // helper.AddCommand(...);
 // [...]
@@ -59,7 +60,7 @@ class GPU_EXPORT CommandBufferHelper
   // Parameters:
   //   ring_buffer_size: The size of the ring buffer portion of the command
   //       buffer.
-  bool Initialize(int32 ring_buffer_size);
+  bool Initialize(int32_t ring_buffer_size);
 
   // Sets whether the command buffer should automatically flush periodically
   // to try to increase performance. Defaults to true.
@@ -87,7 +88,7 @@ class GPU_EXPORT CommandBufferHelper
   // Parameters:
   //   count: number of entries needed. This value must be at most
   //     the size of the buffer minus one.
-  void WaitForAvailableEntries(int32 count);
+  void WaitForAvailableEntries(int32_t count);
 
   // Inserts a new token into the command buffer. This token either has a value
   // different from previously inserted tokens, or ensures that previously
@@ -96,12 +97,12 @@ class GPU_EXPORT CommandBufferHelper
   // Returns:
   //   the value of the new token or -1 if the command buffer reader has
   //   shutdown.
-  int32 InsertToken();
+  int32_t InsertToken();
 
   // Returns true if the token has passed.
   // Parameters:
   //   the value of the token to check whether it has passed
-  bool HasTokenPassed(int32 token) const {
+  bool HasTokenPassed(int32_t token) const {
     if (token > token_)
       return true;  // we wrapped
     return last_token_read() >= token;
@@ -112,11 +113,11 @@ class GPU_EXPORT CommandBufferHelper
   // NOTE: This will call Flush if it needs to block.
   // Parameters:
   //   the value of the token to wait for.
-  void WaitForToken(int32 token);
+  void WaitForToken(int32_t token);
 
   // Called prior to each command being issued. Waits for a certain amount of
   // space to be available. Returns address of space.
-  void* GetSpace(int32 entries) {
+  void* GetSpace(int32_t entries) {
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
     // Allow this command buffer to be pre-empted by another if a "reasonable"
     // amount of work has been done. On highend machines, this reduces the
@@ -166,7 +167,7 @@ class GPU_EXPORT CommandBufferHelper
   T* GetCmdSpace() {
     static_assert(T::kArgFlags == cmd::kFixed,
                   "T::kArgFlags should equal cmd::kFixed");
-    int32 space_needed = ComputeNumEntries(sizeof(T));
+    int32_t space_needed = ComputeNumEntries(sizeof(T));
     T* data = static_cast<T*>(GetSpace(space_needed));
     ForceNullCheck(data);
     return data;
@@ -177,7 +178,7 @@ class GPU_EXPORT CommandBufferHelper
   T* GetImmediateCmdSpace(size_t data_space) {
     static_assert(T::kArgFlags == cmd::kAtLeastN,
                   "T::kArgFlags should equal cmd::kAtLeastN");
-    int32 space_needed = ComputeNumEntries(sizeof(T) + data_space);
+    int32_t space_needed = ComputeNumEntries(sizeof(T) + data_space);
     T* data = static_cast<T*>(GetSpace(space_needed));
     ForceNullCheck(data);
     return data;
@@ -188,22 +189,20 @@ class GPU_EXPORT CommandBufferHelper
   T* GetImmediateCmdSpaceTotalSize(size_t total_space) {
     static_assert(T::kArgFlags == cmd::kAtLeastN,
                   "T::kArgFlags should equal cmd::kAtLeastN");
-    int32 space_needed = ComputeNumEntries(total_space);
+    int32_t space_needed = ComputeNumEntries(total_space);
     T* data = static_cast<T*>(GetSpace(space_needed));
     ForceNullCheck(data);
     return data;
   }
 
-  int32 last_token_read() const {
-    return command_buffer_->GetLastToken();
-  }
+  int32_t last_token_read() const { return command_buffer_->GetLastToken(); }
 
-  int32 get_offset() const {
+  int32_t get_offset() const {
     return command_buffer_->GetLastState().get_offset;
   }
 
   // Common Commands
-  void Noop(uint32 skip_count) {
+  void Noop(uint32_t skip_count) {
     cmd::Noop* cmd = GetImmediateCmdSpace<cmd::Noop>(
         (skip_count - 1) * sizeof(CommandBufferEntry));
     if (cmd) {
@@ -211,25 +210,25 @@ class GPU_EXPORT CommandBufferHelper
     }
   }
 
-  void SetToken(uint32 token) {
+  void SetToken(uint32_t token) {
     cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
     if (cmd) {
       cmd->Init(token);
     }
   }
 
-  void SetBucketSize(uint32 bucket_id, uint32 size) {
+  void SetBucketSize(uint32_t bucket_id, uint32_t size) {
     cmd::SetBucketSize* cmd = GetCmdSpace<cmd::SetBucketSize>();
     if (cmd) {
       cmd->Init(bucket_id, size);
     }
   }
 
-  void SetBucketData(uint32 bucket_id,
-                     uint32 offset,
-                     uint32 size,
-                     uint32 shared_memory_id,
-                     uint32 shared_memory_offset) {
+  void SetBucketData(uint32_t bucket_id,
+                     uint32_t offset,
+                     uint32_t size,
+                     uint32_t shared_memory_id,
+                     uint32_t shared_memory_offset) {
     cmd::SetBucketData* cmd = GetCmdSpace<cmd::SetBucketData>();
     if (cmd) {
       cmd->Init(bucket_id,
@@ -240,8 +239,10 @@ class GPU_EXPORT CommandBufferHelper
     }
   }
 
-  void SetBucketDataImmediate(
-      uint32 bucket_id, uint32 offset, const void* data, uint32 size) {
+  void SetBucketDataImmediate(uint32_t bucket_id,
+                              uint32_t offset,
+                              const void* data,
+                              uint32_t size) {
     cmd::SetBucketDataImmediate* cmd =
         GetImmediateCmdSpace<cmd::SetBucketDataImmediate>(size);
     if (cmd) {
@@ -250,12 +251,12 @@ class GPU_EXPORT CommandBufferHelper
     }
   }
 
-  void GetBucketStart(uint32 bucket_id,
-                      uint32 result_memory_id,
-                      uint32 result_memory_offset,
-                      uint32 data_memory_size,
-                      uint32 data_memory_id,
-                      uint32 data_memory_offset) {
+  void GetBucketStart(uint32_t bucket_id,
+                      uint32_t result_memory_id,
+                      uint32_t result_memory_offset,
+                      uint32_t data_memory_size,
+                      uint32_t data_memory_id,
+                      uint32_t data_memory_offset) {
     cmd::GetBucketStart* cmd = GetCmdSpace<cmd::GetBucketStart>();
     if (cmd) {
       cmd->Init(bucket_id,
@@ -267,11 +268,11 @@ class GPU_EXPORT CommandBufferHelper
     }
   }
 
-  void GetBucketData(uint32 bucket_id,
-                     uint32 offset,
-                     uint32 size,
-                     uint32 shared_memory_id,
-                     uint32 shared_memory_offset) {
+  void GetBucketData(uint32_t bucket_id,
+                     uint32_t offset,
+                     uint32_t size,
+                     uint32_t shared_memory_id,
+                     uint32_t shared_memory_offset) {
     cmd::GetBucketData* cmd = GetCmdSpace<cmd::GetBucketData>();
     if (cmd) {
       cmd->Init(bucket_id,
@@ -288,7 +289,7 @@ class GPU_EXPORT CommandBufferHelper
 
   scoped_refptr<Buffer> get_ring_buffer() const { return ring_buffer_; }
 
-  uint32 flush_generation() const { return flush_generation_; }
+  uint32_t flush_generation() const { return flush_generation_; }
 
   void FreeRingBuffer();
 
@@ -312,7 +313,7 @@ class GPU_EXPORT CommandBufferHelper
 
  private:
   // Returns the number of available entries (they may not be contiguous).
-  int32 AvailableEntries() {
+  int32_t AvailableEntries() {
     return (get_offset() - put_ - 1 + total_entry_count_) % total_entry_count_;
   }
 
@@ -322,26 +323,26 @@ class GPU_EXPORT CommandBufferHelper
 
   // Waits for the get offset to be in a specific range, inclusive. Returns
   // false if there was an error.
-  bool WaitForGetOffsetInRange(int32 start, int32 end);
+  bool WaitForGetOffsetInRange(int32_t start, int32_t end);
 
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
   // Calls Flush if automatic flush conditions are met.
   void PeriodicFlushCheck();
 #endif
 
-  int32 GetTotalFreeEntriesNoWaiting() const;
+  int32_t GetTotalFreeEntriesNoWaiting() const;
 
   CommandBuffer* command_buffer_;
-  int32 ring_buffer_id_;
-  int32 ring_buffer_size_;
+  int32_t ring_buffer_id_;
+  int32_t ring_buffer_size_;
   scoped_refptr<gpu::Buffer> ring_buffer_;
   CommandBufferEntry* entries_;
-  int32 total_entry_count_;  // the total number of entries
-  int32 immediate_entry_count_;
-  int32 token_;
-  int32 put_;
-  int32 last_put_sent_;
-  int32 last_barrier_put_sent_;
+  int32_t total_entry_count_;  // the total number of entries
+  int32_t immediate_entry_count_;
+  int32_t token_;
+  int32_t put_;
+  int32_t last_put_sent_;
+  int32_t last_barrier_put_sent_;
 
 #if defined(CMD_HELPER_PERIODIC_FLUSH_CHECK)
   int commands_issued_;
@@ -355,7 +356,7 @@ class GPU_EXPORT CommandBufferHelper
 
   // Incremented every time the helper flushes the command buffer.
   // Can be used to track when prior commands have been flushed.
-  uint32 flush_generation_;
+  uint32_t flush_generation_;
 
   friend class CommandBufferHelperTest;
   DISALLOW_COPY_AND_ASSIGN(CommandBufferHelper);
diff --git a/gpu/command_buffer/client/cmd_buffer_helper_test.cc b/gpu/command_buffer/client/cmd_buffer_helper_test.cc
index 2e5affb..06bbf4d 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper_test.cc
+++ b/gpu/command_buffer/client/cmd_buffer_helper_test.cc
@@ -4,10 +4,14 @@
 
 // Tests for the Command Buffer Helper.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
@@ -26,10 +30,10 @@ using testing::DoAll;
 using testing::Invoke;
 using testing::_;
 
-const int32 kTotalNumCommandEntries = 32;
-const int32 kCommandBufferSizeBytes =
+const int32_t kTotalNumCommandEntries = 32;
+const int32_t kCommandBufferSizeBytes =
     kTotalNumCommandEntries * sizeof(CommandBufferEntry);
-const int32 kUnusedCommandId = 5;  // we use 0 and 2 currently.
+const int32_t kUnusedCommandId = 5;  // we use 0 and 2 currently.
 
 // Override CommandBufferService::Flush() to lock flushing and simulate
 // the buffer becoming full in asynchronous mode.
@@ -45,7 +49,7 @@ class CommandBufferServiceLocked : public CommandBufferService {
   ~CommandBufferServiceLocked() override {}
 
   // Overridden from CommandBufferService
-  void Flush(int32 put_offset) override {
+  void Flush(int32_t put_offset) override {
     flush_count_++;
     if (!flush_locked_) {
       last_flush_ = -1;
@@ -62,7 +66,7 @@ class CommandBufferServiceLocked : public CommandBufferService {
 
   int FlushCount() { return flush_count_; }
 
-  void WaitForGetOffsetInRange(int32 start, int32 end) override {
+  void WaitForGetOffsetInRange(int32_t start, int32_t end) override {
     // Flush only if it's required to unblock this Wait.
     if (last_flush_ != -1 &&
         !CommandBuffer::InRange(start, end, previous_put_offset_)) {
@@ -128,7 +132,9 @@ class CommandBufferHelperTest : public testing::Test {
     return gpu_scheduler_->parser();
   }
 
-  int32 ImmediateEntryCount() const { return helper_->immediate_entry_count_; }
+  int32_t ImmediateEntryCount() const {
+    return helper_->immediate_entry_count_;
+  }
 
   // Adds a command to the buffer through the helper, while adding it as an
   // expected call on the API mock.
@@ -162,7 +168,7 @@ class CommandBufferHelperTest : public testing::Test {
     linked_ptr<std::vector<CommandBufferEntry> > args_ptr(
         new std::vector<CommandBufferEntry>(arg_count ? arg_count : 1));
 
-    for (int32 ii = 0; ii < arg_count; ++ii) {
+    for (int32_t ii = 0; ii < arg_count; ++ii) {
       (*args_ptr)[ii].value_uint32 = 0xF00DF00D + ii;
     }
 
@@ -172,17 +178,17 @@ class CommandBufferHelperTest : public testing::Test {
     test_command_args_.insert(test_command_args_.end(), args_ptr);
   }
 
-  void TestCommandWrappingFull(int32 cmd_size, int32 start_commands) {
-    const int32 num_args = cmd_size - 1;
+  void TestCommandWrappingFull(int32_t cmd_size, int32_t start_commands) {
+    const int32_t num_args = cmd_size - 1;
     EXPECT_EQ(kTotalNumCommandEntries % cmd_size, 0);
 
     std::vector<CommandBufferEntry> args(num_args);
-    for (int32 ii = 0; ii < num_args; ++ii) {
+    for (int32_t ii = 0; ii < num_args; ++ii) {
       args[ii].value_uint32 = ii + 1;
     }
 
     // Initially insert commands up to start_commands and Finish().
-    for (int32 ii = 0; ii < start_commands; ++ii) {
+    for (int32_t ii = 0; ii < start_commands; ++ii) {
       AddCommandWithExpect(
           error::kNoError, ii + kUnusedCommandId, num_args, &args[0]);
     }
@@ -197,7 +203,7 @@ class CommandBufferHelperTest : public testing::Test {
     command_buffer_->LockFlush();
 
     // Add enough commands to over fill the buffer.
-    for (int32 ii = 0; ii < kTotalNumCommandEntries / cmd_size + 2; ++ii) {
+    for (int32_t ii = 0; ii < kTotalNumCommandEntries / cmd_size + 2; ++ii) {
       AddCommandWithExpect(error::kNoError,
                            start_commands + ii + kUnusedCommandId,
                            num_args,
@@ -238,19 +244,15 @@ class CommandBufferHelperTest : public testing::Test {
     }
   }
 
-  int32 GetGetOffset() {
-    return command_buffer_->GetLastState().get_offset;
-  }
+  int32_t GetGetOffset() { return command_buffer_->GetLastState().get_offset; }
 
-  int32 GetPutOffset() {
-    return command_buffer_->GetPutOffset();
-  }
+  int32_t GetPutOffset() { return command_buffer_->GetPutOffset(); }
 
-  int32 GetHelperGetOffset() { return helper_->get_offset(); }
+  int32_t GetHelperGetOffset() { return helper_->get_offset(); }
 
-  int32 GetHelperPutOffset() { return helper_->put_; }
+  int32_t GetHelperPutOffset() { return helper_->put_; }
 
-  uint32 GetHelperFlushGeneration() { return helper_->flush_generation(); }
+  uint32_t GetHelperFlushGeneration() { return helper_->flush_generation(); }
 
   error::Error GetError() {
     return command_buffer_->GetLastState().error;
@@ -492,7 +494,7 @@ TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
 // Checks the case where the command inserted exactly matches the space left in
 // the command buffer.
 TEST_F(CommandBufferHelperTest, TestCommandWrappingExactMultiple) {
-  const int32 kCommandSize = kTotalNumCommandEntries / 2;
+  const int32_t kCommandSize = kTotalNumCommandEntries / 2;
   const size_t kNumArgs = kCommandSize - 1;
   static_assert(kTotalNumCommandEntries % kCommandSize == 0,
                 "kTotalNumCommandEntries should be a multiple of kCommandSize");
@@ -572,7 +574,7 @@ TEST_F(CommandBufferHelperTest, TestToken) {
   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
   // keep track of the buffer position.
   CommandBufferOffset command1_put = get_helper_put();
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
 
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
@@ -599,7 +601,7 @@ TEST_F(CommandBufferHelperTest, TestWaitForTokenFlush) {
 
   // Add a first command.
   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
 
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
@@ -639,7 +641,7 @@ TEST_F(CommandBufferHelperTest, FreeRingBuffer) {
   EXPECT_FALSE(helper_->HaveRingBuffer());
 
   // Test that InsertToken allocates a new one
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
   EXPECT_TRUE(helper_->HaveRingBuffer());
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
@@ -680,7 +682,7 @@ TEST_F(CommandBufferHelperTest, TestFlushGeneration) {
   helper_->SetAutomaticFlushes(false);
 
   // Generation should change after Flush() but not before.
-  uint32 gen1, gen2, gen3;
+  uint32_t gen1, gen2, gen3;
 
   gen1 = GetHelperFlushGeneration();
   AddUniqueCommandWithExpect(error::kNoError, 2);
@@ -713,7 +715,7 @@ TEST_F(CommandBufferHelperTest, TestOrderingBarrierFlushGeneration) {
   helper_->SetAutomaticFlushes(false);
 
   // Generation should change after OrderingBarrier() but not before.
-  uint32 gen1, gen2, gen3;
+  uint32_t gen1, gen2, gen3;
 
   gen1 = GetHelperFlushGeneration();
   AddUniqueCommandWithExpect(error::kNoError, 2);
diff --git a/gpu/command_buffer/client/context_support.h b/gpu/command_buffer/client/context_support.h
index 19218aa..1e71190 100644
--- a/gpu/command_buffer/client/context_support.h
+++ b/gpu/command_buffer/client/context_support.h
@@ -5,6 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_CONTEXT_SUPPORT_H_
 #define GPU_COMMAND_BUFFER_CLIENT_CONTEXT_SUPPORT_H_
 
+#include <stdint.h>
+
 #include "base/callback.h"
 #include "ui/gfx/overlay_transform.h"
 
@@ -20,7 +22,7 @@ struct SyncToken;
 class ContextSupport {
  public:
   // Runs |callback| when a sync point is reached.
-  virtual void SignalSyncPoint(uint32 sync_point,
+  virtual void SignalSyncPoint(uint32_t sync_point,
                                const base::Closure& callback) = 0;
 
   // Runs |callback| when a sync token is signalled.
@@ -29,7 +31,7 @@ class ContextSupport {
 
   // Runs |callback| when a query created via glCreateQueryEXT() has cleared
   // passed the glEndQueryEXT() point.
-  virtual void SignalQuery(uint32 query, const base::Closure& callback) = 0;
+  virtual void SignalQuery(uint32_t query, const base::Closure& callback) = 0;
 
   // Indicates whether the context should aggressively free allocated resources.
   // If set to true, the context will purge all temporary resources when
@@ -50,8 +52,8 @@ class ContextSupport {
                                     const gfx::Rect& display_bounds,
                                     const gfx::RectF& uv_rect) = 0;
 
-  virtual uint32 InsertFutureSyncPointCHROMIUM() = 0;
-  virtual void RetireSyncPointCHROMIUM(uint32 sync_point) = 0;
+  virtual uint32_t InsertFutureSyncPointCHROMIUM() = 0;
+  virtual void RetireSyncPointCHROMIUM(uint32_t sync_point) = 0;
 
   // Returns an ID that can be used to globally identify the share group that
   // this context's resources belong to.
diff --git a/gpu/command_buffer/client/fenced_allocator.cc b/gpu/command_buffer/client/fenced_allocator.cc
index 7f34e58..47450d3 100644
--- a/gpu/command_buffer/client/fenced_allocator.cc
+++ b/gpu/command_buffer/client/fenced_allocator.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/client/fenced_allocator.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
@@ -95,8 +97,8 @@ void FencedAllocator::Free(FencedAllocator::Offset offset) {
 }
 
 // Looks for the corresponding block, mark it FREE_PENDING_TOKEN.
-void FencedAllocator::FreePendingToken(
-    FencedAllocator::Offset offset, int32 token) {
+void FencedAllocator::FreePendingToken(FencedAllocator::Offset offset,
+                                       int32_t token) {
   BlockIndex index = GetBlockByOffset(offset);
   Block &block = blocks_[index];
   if (block.state == IN_USE)
diff --git a/gpu/command_buffer/client/fenced_allocator.h b/gpu/command_buffer/client/fenced_allocator.h
index 45b4dfd..0e8c64c 100644
--- a/gpu/command_buffer/client/fenced_allocator.h
+++ b/gpu/command_buffer/client/fenced_allocator.h
@@ -7,6 +7,7 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_FENCED_ALLOCATOR_H_
 #define GPU_COMMAND_BUFFER_CLIENT_FENCED_ALLOCATOR_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ -68,7 +69,7 @@ class GPU_EXPORT FencedAllocator {
   // Parameters:
   //   offset: the offset of the memory block to free.
   //   token: the token value to wait for before re-using the memory.
-  void FreePendingToken(Offset offset, int32 token);
+  void FreePendingToken(Offset offset, int32_t token);
 
   // Frees any blocks pending a token for which the token has been read.
   void FreeUnused();
@@ -204,7 +205,7 @@ class FencedAllocatorWrapper {
   // Parameters:
   //   pointer: the pointer to the memory block to free.
   //   token: the token value to wait for before re-using the memory.
-  void FreePendingToken(void *pointer, int32 token) {
+  void FreePendingToken(void* pointer, int32_t token) {
     DCHECK(pointer);
     allocator_.FreePendingToken(GetOffset(pointer), token);
   }
diff --git a/gpu/command_buffer/client/fenced_allocator_test.cc b/gpu/command_buffer/client/fenced_allocator_test.cc
index 8635d0b..4ee2ea2 100644
--- a/gpu/command_buffer/client/fenced_allocator_test.cc
+++ b/gpu/command_buffer/client/fenced_allocator_test.cc
@@ -4,6 +4,8 @@
 
 // This file contains the tests for the FencedAllocator class.
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/aligned_memory.h"
@@ -65,9 +67,7 @@ class BaseFencedAllocatorTest : public testing::Test {
     helper_->Initialize(kBufferSize);
   }
 
-  int32 GetToken() {
-    return command_buffer_->GetLastState().token;
-  }
+  int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
@@ -194,7 +194,7 @@ TEST_F(FencedAllocatorTest, TestFreePendingToken) {
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // Free one successful allocation, pending fence.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(offsets[0], token);
   EXPECT_TRUE(allocator_->CheckConsistency());
 
@@ -241,7 +241,7 @@ TEST_F(FencedAllocatorTest, FreeUnused) {
   EXPECT_EQ(0u, allocator_->GetLargestFreeSize());
 
   // Free one successful allocation, pending fence.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(offsets[0], token);
   EXPECT_TRUE(allocator_->CheckConsistency());
 
@@ -357,7 +357,7 @@ TEST_F(FencedAllocatorTest, TestGetLargestFreeOrPendingSize) {
             allocator_->GetLargestFreeOrPendingSize());
 
   // Free the last one, pending a token.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(offset2, token);
 
   // Now all the buffers have been freed...
@@ -545,7 +545,7 @@ TEST_F(FencedAllocatorWrapperTest, TestFreePendingToken) {
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // Free one successful allocation, pending fence.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(pointers[0], token);
   EXPECT_TRUE(allocator_->CheckConsistency());
 
diff --git a/gpu/command_buffer/client/gl_in_process_context.cc b/gpu/command_buffer/client/gl_in_process_context.cc
index 774f7d2..99e4b78 100644
--- a/gpu/command_buffer/client/gl_in_process_context.cc
+++ b/gpu/command_buffer/client/gl_in_process_context.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 #include <utility>
 #include <vector>
@@ -19,6 +22,7 @@
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ -38,7 +42,7 @@ namespace gpu {
 
 namespace {
 
-const int32 kDefaultCommandBufferSize = 1024 * 1024;
+const int32_t kDefaultCommandBufferSize = 1024 * 1024;
 const unsigned int kDefaultStartTransferBufferSize = 4 * 1024 * 1024;
 const unsigned int kDefaultMinTransferBufferSize = 1 * 256 * 1024;
 const unsigned int kDefaultMaxTransferBufferSize = 16 * 1024 * 1024;
@@ -71,8 +75,8 @@ class GLInProcessContextImpl
 
 #if defined(OS_ANDROID)
   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
-      uint32 stream_id) override;
-  uint32 CreateStreamTexture(uint32 texture_id) override;
+      uint32_t stream_id) override;
+  uint32_t CreateStreamTexture(uint32_t texture_id) override;
 #endif
 
  private:
@@ -154,7 +158,7 @@ bool GLInProcessContextImpl::Initialize(
   DCHECK(!use_global_share_group || !share_context);
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
-  std::vector<int32> attrib_vector;
+  std::vector<int32_t> attrib_vector;
   attribs.Serialize(&attrib_vector);
 
   base::Closure wrapped_callback =
@@ -263,12 +267,12 @@ void GLInProcessContextImpl::Destroy() {
 }
 
 #if defined(OS_ANDROID)
-scoped_refptr<gfx::SurfaceTexture>
-GLInProcessContextImpl::GetSurfaceTexture(uint32 stream_id) {
+scoped_refptr<gfx::SurfaceTexture> GLInProcessContextImpl::GetSurfaceTexture(
+    uint32_t stream_id) {
   return command_buffer_->GetSurfaceTexture(stream_id);
 }
 
-uint32 GLInProcessContextImpl::CreateStreamTexture(uint32 texture_id) {
+uint32_t GLInProcessContextImpl::CreateStreamTexture(uint32_t texture_id) {
   return command_buffer_->CreateStreamTexture(texture_id);
 }
 #endif
diff --git a/gpu/command_buffer/client/gl_in_process_context.h b/gpu/command_buffer/client/gl_in_process_context.h
index 656c8b2..36484ce 100644
--- a/gpu/command_buffer/client/gl_in_process_context.h
+++ b/gpu/command_buffer/client/gl_in_process_context.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GL_IN_PROCESS_CONTEXT_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GL_IN_PROCESS_CONTEXT_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "gl_in_process_context_export.h"
@@ -33,7 +36,7 @@ class GLES2Implementation;
 struct GL_IN_PROCESS_CONTEXT_EXPORT GLInProcessContextSharedMemoryLimits {
   GLInProcessContextSharedMemoryLimits();
 
-  int32 command_buffer_size;
+  int32_t command_buffer_size;
   unsigned int start_transfer_buffer_size;
   unsigned int min_transfer_buffer_size;
   unsigned int max_transfer_buffer_size;
@@ -80,8 +83,8 @@ class GL_IN_PROCESS_CONTEXT_EXPORT GLInProcessContext {
 
 #if defined(OS_ANDROID)
   virtual scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
-      uint32 stream_id) = 0;
-  virtual uint32 CreateStreamTexture(uint32 texture_id) = 0;
+      uint32_t stream_id) = 0;
+  virtual uint32_t CreateStreamTexture(uint32_t texture_id) = 0;
 #endif
 };
 
diff --git a/gpu/command_buffer/client/gles2_cmd_helper.h b/gpu/command_buffer/client/gles2_cmd_helper.h
index 8a5cde1..8d38ad4 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_H_
 
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/gpu_export.h"
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 8fe6f98..95b90de 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -10,6 +10,8 @@
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <algorithm>
 #include <map>
 #include <set>
@@ -288,11 +290,11 @@ 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();
 }
 
@@ -313,7 +315,7 @@ void GLES2Implementation::RunIfContextNotLost(const base::Closure& callback) {
     callback.Run();
 }
 
-void GLES2Implementation::SignalSyncPoint(uint32 sync_point,
+void GLES2Implementation::SignalSyncPoint(uint32_t sync_point,
                                           const base::Closure& callback) {
   gpu_control_->SignalSyncPoint(
       sync_point,
@@ -345,7 +347,7 @@ void GLES2Implementation::SignalSyncToken(const gpu::SyncToken& sync_token,
   }
 }
 
-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.
@@ -381,7 +383,7 @@ bool GLES2Implementation::OnMemoryDump(
   if (!transfer_buffer_->HaveBuffer())
     return true;
 
-  const uint64 tracing_process_id =
+  const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
 
@@ -474,7 +476,7 @@ GLenum GLES2Implementation::GetClientSideGLError() {
   }
 
   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;
@@ -547,11 +549,11 @@ void GLES2Implementation::SetGLErrorInvalidEnum(
               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;
@@ -566,10 +568,10 @@ bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
       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);
@@ -580,7 +582,7 @@ bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
             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;
@@ -594,18 +596,19 @@ bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
   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());
@@ -615,8 +618,8 @@ void GLES2Implementation::SetBucketContents(
   }
 }
 
-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) {
@@ -626,10 +629,10 @@ void GLES2Implementation::SetBucketAsCString(
   }
 }
 
-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)) {
@@ -642,8 +645,8 @@ bool GLES2Implementation::GetBucketAsString(
   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);
@@ -1441,7 +1444,7 @@ void GLES2Implementation::GetVertexAttribPointerv(
   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;
@@ -1457,7 +1460,7 @@ void GLES2Implementation::GetVertexAttribPointerv(
     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]);
     }
   });
@@ -1993,15 +1996,15 @@ void GLES2Implementation::BufferSubDataHelper(
       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;
   }
 
@@ -2015,7 +2018,7 @@ void GLES2Implementation::BufferSubDataHelperImpl(
   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);
@@ -2045,7 +2048,7 @@ void GLES2Implementation::BufferSubData(
 }
 
 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))
@@ -2286,15 +2289,14 @@ void GLES2Implementation::CompressedTexSubImage3D(
 
 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) {
@@ -2304,7 +2306,7 @@ void CopyRectToBuffer(
     }
     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);
   }
 }
@@ -2332,9 +2334,9 @@ void GLES2Implementation::TexImage2D(
     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)) {
@@ -2368,7 +2370,7 @@ void GLES2Implementation::TexImage2D(
   }
 
   // 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_,
@@ -2382,12 +2384,12 @@ void GLES2Implementation::TexImage2D(
   }
 
   // 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.
@@ -2456,9 +2458,9 @@ void GLES2Implementation::TexImage3D(
     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)) {
@@ -2492,7 +2494,7 @@ void GLES2Implementation::TexImage3D(
   }
 
   // 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_,
@@ -2504,16 +2506,17 @@ void GLES2Implementation::TexImage3D(
   } 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.
@@ -2543,15 +2546,15 @@ void GLES2Implementation::TexImage3D(
   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,
@@ -2592,9 +2595,9 @@ void GLES2Implementation::TexSubImage2D(
     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)) {
@@ -2619,7 +2622,7 @@ void GLES2Implementation::TexSubImage2D(
   }
 
   // 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_,
@@ -2633,12 +2636,12 @@ void GLES2Implementation::TexSubImage2D(
   }
 
   // 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_);
@@ -2671,9 +2674,9 @@ void GLES2Implementation::TexSubImage3D(
     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)) {
@@ -2698,7 +2701,7 @@ void GLES2Implementation::TexSubImage3D(
   }
 
   // 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_,
@@ -2710,16 +2713,17 @@ void GLES2Implementation::TexSubImage3D(
   } 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_);
@@ -2730,9 +2734,10 @@ void GLES2Implementation::TexSubImage3D(
   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;
@@ -2745,17 +2750,26 @@ static GLint ComputeNumRowsThatFitInBuffer(
   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 =
@@ -2783,18 +2797,28 @@ void GLES2Implementation::TexSubImage2DImpl(
   }
 }
 
-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) {
@@ -2839,13 +2863,13 @@ void GLES2Implementation::TexSubImage3DImpl(
     }
 
     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
@@ -2856,7 +2880,7 @@ void GLES2Implementation::TexSubImage3DImpl(
             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
@@ -2918,7 +2942,7 @@ bool GLES2Implementation::GetActiveAttribHelper(
       *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),
@@ -2989,7 +3013,7 @@ bool GLES2Implementation::GetActiveUniformHelper(
       *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),
@@ -3059,7 +3083,7 @@ bool GLES2Implementation::GetActiveUniformBlockNameHelper(
         *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 =
@@ -3221,7 +3245,7 @@ void GLES2Implementation::GetAttachedShaders(
   }
   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;
@@ -3232,14 +3256,14 @@ void GLES2Implementation::GetAttachedShaders(
     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]);
     }
   });
@@ -3372,7 +3396,7 @@ bool GLES2Implementation::GetTransformFeedbackVaryingHelper(
       *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) {
@@ -3445,7 +3469,7 @@ void GLES2Implementation::GetUniformfv(
   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]);
     }
   });
@@ -3470,7 +3494,7 @@ void GLES2Implementation::GetUniformiv(
   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]);
     }
   });
@@ -3495,7 +3519,7 @@ void GLES2Implementation::GetUniformuiv(
   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]);
     }
   });
@@ -3529,10 +3553,10 @@ void GLES2Implementation::ReadPixels(
   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)) {
@@ -3568,7 +3592,7 @@ void GLES2Implementation::ReadPixels(
   }
 
   // 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_,
@@ -3584,7 +3608,7 @@ void GLES2Implementation::ReadPixels(
   // 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;
   }
 
@@ -3616,14 +3640,14 @@ void GLES2Implementation::ReadPixels(
       // 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;
@@ -4249,7 +4273,7 @@ void GLES2Implementation::GetVertexAttribfv(
       << 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;
@@ -4266,7 +4290,7 @@ void GLES2Implementation::GetVertexAttribfv(
   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]);
     }
   });
@@ -4280,7 +4304,7 @@ void GLES2Implementation::GetVertexAttribiv(
       << 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;
@@ -4297,7 +4321,7 @@ void GLES2Implementation::GetVertexAttribiv(
   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]);
     }
   });
@@ -4311,7 +4335,7 @@ void GLES2Implementation::GetVertexAttribIiv(
       << 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;
@@ -4328,7 +4352,7 @@ void GLES2Implementation::GetVertexAttribIiv(
   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]);
     }
   });
@@ -4342,7 +4366,7 @@ void GLES2Implementation::GetVertexAttribIuiv(
       << 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;
@@ -4359,7 +4383,7 @@ void GLES2Implementation::GetVertexAttribIuiv(
   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]);
     }
   });
@@ -4516,7 +4540,7 @@ void* GLES2Implementation::MapBufferSubDataCHROMIUM(
     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) {
@@ -4597,7 +4621,7 @@ void* GLES2Implementation::MapBufferRange(
     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) {
@@ -4709,14 +4733,14 @@ void* GLES2Implementation::MapTexSubImage2DCHROMIUM(
         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) {
@@ -4831,7 +4855,8 @@ void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
 }
 
 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);
@@ -4854,7 +4879,7 @@ void GLES2Implementation::GetProgramInfoCHROMIUM(
   // 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;
@@ -4872,7 +4897,8 @@ void GLES2Implementation::GetProgramInfoCHROMIUM(
 }
 
 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);
@@ -4895,7 +4921,7 @@ void GLES2Implementation::GetUniformBlocksCHROMIUM(
   // 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;
@@ -4913,7 +4939,8 @@ void GLES2Implementation::GetUniformBlocksCHROMIUM(
 }
 
 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);
@@ -4936,7 +4963,7 @@ void GLES2Implementation::GetUniformsES3CHROMIUM(
   // 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;
@@ -4954,7 +4981,8 @@ void GLES2Implementation::GetUniformsES3CHROMIUM(
 }
 
 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);
@@ -4978,7 +5006,7 @@ void GLES2Implementation::GetTransformFeedbackVaryingsCHROMIUM(
   // 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;
@@ -6107,7 +6135,8 @@ void GLES2Implementation::PathCommandsCHROMIUM(GLuint path,
     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;
@@ -6123,13 +6152,13 @@ void GLES2Implementation::PathCommandsCHROMIUM(GLuint path,
     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;
@@ -6142,8 +6171,8 @@ void GLES2Implementation::PathCommandsCHROMIUM(GLuint path,
     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());
@@ -6171,15 +6200,15 @@ bool GLES2Implementation::PrepareInstancedPathCommand(
     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) {
@@ -6187,7 +6216,7 @@ bool GLES2Implementation::PrepareInstancedPathCommand(
     return false;
   }
 
-  uint32 transforms_component_count =
+  uint32_t transforms_component_count =
       GLES2Util::GetComponentCountForGLTransformType(transform_type);
 
   if (transform_type != GL_NONE && transforms_component_count == 0) {
@@ -6219,7 +6248,7 @@ bool GLES2Implementation::PrepareInstancedPathCommand(
     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;
@@ -6227,15 +6256,15 @@ bool GLES2Implementation::PrepareInstancedPathCommand(
 
   // 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;
@@ -6287,9 +6316,9 @@ void GLES2Implementation::StencilFillPathInstancedCHROMIUM(
                      << 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,
@@ -6322,9 +6351,9 @@ void GLES2Implementation::StencilStrokePathInstancedCHROMIUM(
                      << 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,
@@ -6355,9 +6384,9 @@ void GLES2Implementation::CoverFillPathInstancedCHROMIUM(
                      << 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,
@@ -6389,9 +6418,9 @@ void GLES2Implementation::CoverStrokePathInstancedCHROMIUM(
                      << 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,
@@ -6425,9 +6454,9 @@ void GLES2Implementation::StencilThenCoverFillPathInstancedCHROMIUM(
           << 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,
@@ -6464,9 +6493,9 @@ void GLES2Implementation::StencilThenCoverStrokePathInstancedCHROMIUM(
                      << 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,
@@ -6509,7 +6538,7 @@ void GLES2Implementation::ProgramPathFragmentInputGenCHROMIUM(
                      << ", " << 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 ||
@@ -6520,7 +6549,7 @@ void GLES2Implementation::ProgramPathFragmentInputGenCHROMIUM(
     // 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) {
diff --git a/gpu/command_buffer/client/gles2_implementation.h b/gpu/command_buffer/client/gles2_implementation.h
index 1c55b83..eb55550 100644
--- a/gpu/command_buffer/client/gles2_implementation.h
+++ b/gpu/command_buffer/client/gles2_implementation.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 #include <map>
 #include <queue>
@@ -13,7 +16,6 @@
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ -143,7 +145,8 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   };
 
   // The maxiumum result size from simple GL get commands.
-  static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32);  // NOLINT.
+  static const size_t kMaxSizeOfSimpleResult =
+      16 * sizeof(uint32_t);  // NOLINT.
 
   // used for testing only. If more things are reseved add them here.
   static const unsigned int kStartingOffset = kMaxSizeOfSimpleResult;
@@ -152,7 +155,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   static const unsigned int kSizeToFlush = 256 * 1024;
 
   // The bucket used for results. Public for testing only.
-  static const uint32 kResultBucketId = 1;
+  static const uint32_t kResultBucketId = 1;
 
   // Alignment of allocations.
   static const unsigned int kAlignment = 4;
@@ -212,7 +215,8 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   void RetireSyncPointCHROMIUM(GLuint sync_point) override;
   uint64_t ShareGroupTracingGUID() const override;
 
-  void GetProgramInfoCHROMIUMHelper(GLuint program, std::vector<int8>* result);
+  void GetProgramInfoCHROMIUMHelper(GLuint program,
+                                    std::vector<int8_t>* result);
   GLint GetAttribLocationHelper(GLuint program, const char* name);
   GLint GetUniformLocationHelper(GLuint program, const char* name);
   GLint GetFragDataIndexEXTHelper(GLuint program, const char* name);
@@ -223,18 +227,18 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   bool GetActiveUniformHelper(
       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
       GLint* size, GLenum* type, char* name);
-  void GetUniformBlocksCHROMIUMHelper(
-      GLuint program, std::vector<int8>* result);
-  void GetUniformsES3CHROMIUMHelper(
-      GLuint program, std::vector<int8>* result);
+  void GetUniformBlocksCHROMIUMHelper(GLuint program,
+                                      std::vector<int8_t>* result);
+  void GetUniformsES3CHROMIUMHelper(GLuint program,
+                                    std::vector<int8_t>* result);
   GLuint GetUniformBlockIndexHelper(GLuint program, const char* name);
   bool GetActiveUniformBlockNameHelper(
       GLuint program, GLuint index, GLsizei bufsize,
       GLsizei* length, char* name);
   bool GetActiveUniformBlockivHelper(
       GLuint program, GLuint index, GLenum pname, GLint* params);
-  void GetTransformFeedbackVaryingsCHROMIUMHelper(
-      GLuint program, std::vector<int8>* result);
+  void GetTransformFeedbackVaryingsCHROMIUMHelper(GLuint program,
+                                                  std::vector<int8_t>* result);
   bool GetTransformFeedbackVaryingHelper(
       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
       GLint* size, GLenum* type, char* name);
@@ -253,11 +257,11 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   void FreeEverything();
 
   // ContextSupport implementation.
-  void SignalSyncPoint(uint32 sync_point,
+  void SignalSyncPoint(uint32_t sync_point,
                        const base::Closure& callback) override;
   void SignalSyncToken(const gpu::SyncToken& sync_token,
                        const base::Closure& callback) override;
-  void SignalQuery(uint32 query, const base::Closure& callback) override;
+  void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetAggressivelyFreeResources(bool aggressively_free_resources) override;
 
   // base::trace_event::MemoryDumpProvider implementation.
@@ -413,8 +417,8 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   }
 
   void* GetResultBuffer();
-  int32 GetResultShmId();
-  uint32 GetResultShmOffset();
+  int32_t GetResultShmId();
+  uint32_t GetResultShmOffset();
 
   // Lazily determines if GL_ANGLE_pack_reverse_row_order is available
   bool IsAnglePackReverseRowOrderAvailable();
@@ -444,20 +448,20 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   // a transfer buffer to function which is currently managed by this class.
 
   // Gets the contents of a bucket.
-  bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data);
+  bool GetBucketContents(uint32_t bucket_id, std::vector<int8_t>* data);
 
   // Sets the contents of a bucket.
-  void SetBucketContents(uint32 bucket_id, const void* data, size_t size);
+  void SetBucketContents(uint32_t bucket_id, const void* data, size_t size);
 
   // Sets the contents of a bucket as a string.
-  void SetBucketAsCString(uint32 bucket_id, const char* str);
+  void SetBucketAsCString(uint32_t bucket_id, const char* str);
 
   // Gets the contents of a bucket as a string. Returns false if there is no
   // string available which is a separate case from the empty string.
-  bool GetBucketAsString(uint32 bucket_id, std::string* str);
+  bool GetBucketAsString(uint32_t bucket_id, std::string* str);
 
   // Sets the contents of a bucket as a string.
-  void SetBucketAsString(uint32 bucket_id, const std::string& str);
+  void SetBucketAsString(uint32_t bucket_id, const std::string& str);
 
   // Returns true if id is reserved.
   bool IsBufferReservedId(GLuint id);
@@ -549,7 +553,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
                                                   GLenum usage);
 
   // Helper for GetVertexAttrib
-  bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32* param);
+  bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32_t* param);
 
   GLuint GetMaxValueInBufferCHROMIUMHelper(
       GLuint buffer_id, GLsizei count, GLenum type, GLuint offset);
@@ -561,17 +565,36 @@ class GLES2_IMPL_EXPORT GLES2Implementation
 
   // The pixels pointer should already account for unpack skip
   // images/rows/pixels.
-  void 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 TexSubImage3DImpl(
-      GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint 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 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);
+  void TexSubImage3DImpl(GLenum target,
+                         GLint level,
+                         GLint xoffset,
+                         GLint yoffset,
+                         GLint 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);
 
   // Helpers for query functions.
   bool GetHelper(GLenum pname, GLint* params);
@@ -655,9 +678,9 @@ class GLES2_IMPL_EXPORT GLES2Implementation
                                    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 defined(GL_CLIENT_FAIL_GL_ERRORS)
   void CheckGLError();
@@ -681,8 +704,8 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   DebugMarkerManager debug_marker_manager_;
   std::string this_in_hex_;
 
-  std::queue<int32> swap_buffers_tokens_;
-  std::queue<int32> rate_limit_tokens_;
+  std::queue<int32_t> swap_buffers_tokens_;
+  std::queue<int32_t> rate_limit_tokens_;
 
   ExtensionStatus angle_pack_reverse_row_order_status_;
   ExtensionStatus chromium_framebuffer_multisample_;
@@ -755,7 +778,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
   GLuint reserved_ids_[2];
 
   // Current GL error bits.
-  uint32 error_bits_;
+  uint32_t error_bits_;
 
   // Whether or not to print debugging info.
   bool debug_;
@@ -777,7 +800,7 @@ class GLES2_IMPL_EXPORT GLES2Implementation
 
   // Map of GLenum to Strings for glGetString.  We need to cache these because
   // the pointer passed back to the client has to remain valid for eternity.
-  typedef std::map<uint32, std::set<std::string> > GLStringMap;
+  typedef std::map<uint32_t, std::set<std::string>> GLStringMap;
   GLStringMap gl_strings_;
 
   // Similar cache for glGetRequestableExtensionsCHROMIUM. We don't
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest.cc b/gpu/command_buffer/client/gles2_implementation_unittest.cc
index b3c29d0..e41c0b1 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest.cc
+++ b/gpu/command_buffer/client/gles2_implementation_unittest.cc
@@ -10,6 +10,8 @@
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include "base/compiler_specific.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
@@ -19,8 +21,8 @@
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 #if !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
@@ -59,7 +61,7 @@ class SizedResultHelper {
   }
 
  private:
-  uint32 size_;
+  uint32_t size_;
   char result_[sizeof(T)];
 };
 
@@ -88,9 +90,9 @@ struct Str7 {
 class MockTransferBuffer : public TransferBufferInterface {
  public:
   struct ExpectedMemoryInfo {
-    uint32 offset;
-    int32 id;
-    uint8* ptr;
+    uint32_t offset;
+    int32_t id;
+    uint8_t* ptr;
   };
 
   MockTransferBuffer(
@@ -158,8 +160,8 @@ class MockTransferBuffer : public TransferBufferInterface {
     ExpectedMemoryInfo mem;
     mem.offset = AllocateExpectedTransferBuffer(size);
     mem.id = GetExpectedTransferBufferId();
-    mem.ptr = static_cast<uint8*>(
-       GetExpectedTransferAddressFromOffset(mem.offset, size));
+    mem.ptr = static_cast<uint8_t*>(
+        GetExpectedTransferAddressFromOffset(mem.offset, size));
     return mem;
   }
 
@@ -167,7 +169,7 @@ class MockTransferBuffer : public TransferBufferInterface {
     ExpectedMemoryInfo mem;
     mem.offset = GetExpectedResultBufferOffset();
     mem.id = GetExpectedResultBufferId();
-    mem.ptr = static_cast<uint8*>(
+    mem.ptr = static_cast<uint8_t*>(
         GetExpectedTransferAddressFromOffset(mem.offset, size));
     return mem;
   }
@@ -175,15 +177,15 @@ class MockTransferBuffer : public TransferBufferInterface {
  private:
   static const int kNumBuffers = 2;
 
-  uint8* actual_buffer() const {
-    return static_cast<uint8*>(buffers_[actual_buffer_index_]->memory());
+  uint8_t* actual_buffer() const {
+    return static_cast<uint8_t*>(buffers_[actual_buffer_index_]->memory());
   }
 
-  uint8* expected_buffer() const {
-    return static_cast<uint8*>(buffers_[expected_buffer_index_]->memory());
+  uint8_t* expected_buffer() const {
+    return static_cast<uint8_t*>(buffers_[expected_buffer_index_]->memory());
   }
 
-  uint32 AllocateExpectedTransferBuffer(size_t size) {
+  uint32_t AllocateExpectedTransferBuffer(size_t size) {
     EXPECT_LE(size, MaxTransferBufferSize());
 
     // Toggle which buffer we get each time to simulate the buffer being
@@ -193,14 +195,14 @@ class MockTransferBuffer : public TransferBufferInterface {
     if (expected_offset_ + size > size_) {
       expected_offset_ = result_size_;
     }
-    uint32 offset = expected_offset_;
+    uint32_t offset = expected_offset_;
     expected_offset_ += RoundToAlignment(size);
 
     // Make sure each buffer has a different offset.
     return offset + expected_buffer_index_ * alignment_;
   }
 
-  void* GetExpectedTransferAddressFromOffset(uint32 offset, size_t size) {
+  void* GetExpectedTransferAddressFromOffset(uint32_t offset, size_t size) {
     EXPECT_GE(offset, expected_buffer_index_ * alignment_);
     EXPECT_LE(offset + size, size_ + expected_buffer_index_ * alignment_);
     return expected_buffer() + offset;
@@ -210,7 +212,7 @@ class MockTransferBuffer : public TransferBufferInterface {
     return buffer_ids_[expected_buffer_index_];
   }
 
-  uint32 GetExpectedResultBufferOffset() {
+  uint32_t GetExpectedResultBufferOffset() {
     return expected_buffer_index_ * alignment_;
   }
 
@@ -221,14 +223,14 @@ class MockTransferBuffer : public TransferBufferInterface {
   CommandBuffer* command_buffer_;
   size_t size_;
   size_t result_size_;
-  uint32 alignment_;
+  uint32_t alignment_;
   int buffer_ids_[kNumBuffers];
   scoped_refptr<Buffer> buffers_[kNumBuffers];
   int actual_buffer_index_;
   int expected_buffer_index_;
   void* last_alloc_;
-  uint32 expected_offset_;
-  uint32 actual_offset_;
+  uint32_t expected_offset_;
+  uint32_t actual_offset_;
   bool initialize_fail_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTransferBuffer);
@@ -280,7 +282,7 @@ void* MockTransferBuffer::AllocUpTo(
   if (actual_offset_ + size > size_) {
     actual_offset_ = result_size_;
   }
-  uint32 offset = actual_offset_;
+  uint32_t offset = actual_offset_;
   actual_offset_ += RoundToAlignment(size);
   *size_allocated = size;
 
@@ -299,7 +301,7 @@ void* MockTransferBuffer::Alloc(unsigned int size) {
 
 RingBuffer::Offset MockTransferBuffer::GetOffset(void* pointer) const {
   // Make sure each buffer has a different offset.
-  return static_cast<uint8*>(pointer) - actual_buffer();
+  return static_cast<uint8_t*>(pointer) - actual_buffer();
 }
 
 void MockTransferBuffer::DiscardBlock(void* p) {
@@ -379,9 +381,9 @@ class GenTexturesAPI {
 class GLES2ImplementationTest : public testing::Test {
  protected:
   static const int kNumTestContexts = 2;
-  static const uint8 kInitialValue = 0xBD;
-  static const int32 kNumCommandEntries = 500;
-  static const int32 kCommandBufferSizeBytes =
+  static const uint8_t kInitialValue = 0xBD;
+  static const int32_t kNumCommandEntries = 500;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const size_t kTransferBufferSize = 512;
 
@@ -541,8 +543,9 @@ class GLES2ImplementationTest : public testing::Test {
 
   bool NoCommandsWritten() {
     scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
-    const uint8* cmds = reinterpret_cast<const uint8*>(ring_buffer->memory());
-    const uint8* end = cmds + ring_buffer->size();
+    const uint8_t* cmds =
+        reinterpret_cast<const uint8_t*>(ring_buffer->memory());
+    const uint8_t* end = cmds + ring_buffer->size();
     for (; cmds < end; ++cmds) {
       if (*cmds != kInitialValue) {
         return false;
@@ -640,9 +643,8 @@ class GLES2ImplementationTest : public testing::Test {
     ExpectedMemoryInfo mem;
 
     // Temporarily allocate memory and expect that memory block to be reused.
-    mem.ptr = static_cast<uint8*>(gl_->mapped_memory_->Alloc(size,
-                                                             &mem.id,
-                                                             &mem.offset));
+    mem.ptr = static_cast<uint8_t*>(
+        gl_->mapped_memory_->Alloc(size, &mem.id, &mem.offset));
     gl_->mapped_memory_->Free(mem.ptr);
 
     return mem;
@@ -667,7 +669,7 @@ class GLES2ImplementationTest : public testing::Test {
     return gl_->GetLastError();
   }
 
-  bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data) {
+  bool GetBucketContents(uint32_t bucket_id, std::vector<int8_t>* data) {
     return gl_->GetBucketContents(bucket_id, data);
   }
 
@@ -798,9 +800,9 @@ void GLES2ImplementationStrictSharedTest::SetUp() {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
-const uint8 GLES2ImplementationTest::kInitialValue;
-const int32 GLES2ImplementationTest::kNumCommandEntries;
-const int32 GLES2ImplementationTest::kCommandBufferSizeBytes;
+const uint8_t GLES2ImplementationTest::kInitialValue;
+const int32_t GLES2ImplementationTest::kNumCommandEntries;
+const int32_t GLES2ImplementationTest::kCommandBufferSizeBytes;
 const size_t GLES2ImplementationTest::kTransferBufferSize;
 const GLint GLES2ImplementationTest::kMaxCombinedTextureImageUnits;
 const GLint GLES2ImplementationTest::kMaxCubeMapTextureSize;
@@ -832,12 +834,12 @@ TEST_F(GLES2ImplementationTest, Basic) {
 }
 
 TEST_F(GLES2ImplementationTest, GetBucketContents) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
-  const uint32 kTestSize = MaxTransferBufferSize() + 32;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kTestSize = MaxTransferBufferSize() + 32;
 
-  scoped_ptr<uint8[]> buf(new uint8 [kTestSize]);
-  uint8* expected_data = buf.get();
-  for (uint32 ii = 0; ii < kTestSize; ++ii) {
+  scoped_ptr<uint8_t[]> buf(new uint8_t[kTestSize]);
+  uint8_t* expected_data = buf.get();
+  for (uint32_t ii = 0; ii < kTestSize; ++ii) {
     expected_data[ii] = ii * 3;
   }
 
@@ -850,7 +852,7 @@ TEST_F(GLES2ImplementationTest, GetBucketContents) {
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
-  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32));
+  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32_t));
   ExpectedMemoryInfo mem2 = GetExpectedMemory(
       kTestSize - MaxTransferBufferSize());
 
@@ -875,7 +877,7 @@ TEST_F(GLES2ImplementationTest, GetBucketContents) {
           kTestSize - MaxTransferBufferSize()))
       .RetiresOnSaturation();
 
-  std::vector<int8> data;
+  std::vector<int8_t> data;
   GetBucketContents(kBucketId, &data);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   ASSERT_EQ(kTestSize, data.size());
@@ -960,7 +962,7 @@ TEST_F(GLES2ImplementationTest, GetShaderPrecisionFormat) {
 }
 
 TEST_F(GLES2ImplementationTest, GetShaderSource) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kShaderId = 456;
   const Str7 kString = {"foobar"};
   const char kBad = 0x12;
@@ -973,7 +975,7 @@ TEST_F(GLES2ImplementationTest, GetShaderSource) {
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
-  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32));
+  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32_t));
 
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
@@ -987,7 +989,7 @@ TEST_F(GLES2ImplementationTest, GetShaderSource) {
   memset(buf, kBad, sizeof(buf));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .RetiresOnSaturation();
 
@@ -1143,8 +1145,8 @@ TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffers) {
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
-  static const uint16 indices[] = {
-    1, 2,
+  static const uint16_t indices[] = {
+      1, 2,
   };
   struct Cmds {
     cmds::EnableVertexAttribArray enable1;
@@ -1227,8 +1229,8 @@ TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffersIndexUint) {
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
-  static const uint32 indices[] = {
-    1, 2,
+  static const uint32_t indices[] = {
+      1, 2,
   };
   struct Cmds {
     cmds::EnableVertexAttribArray enable1;
@@ -1311,9 +1313,7 @@ TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffersInvalidIndexUint) {
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
-  static const uint32 indices[] = {
-    1, 0x90000000
-  };
+  static const uint32_t indices[] = {1, 0x90000000};
 
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
@@ -1378,7 +1378,7 @@ TEST_F(GLES2ImplementationTest,
   const GLsizei kEmuOffset2 = kSize1;
   const GLsizei kTotalSize = kSize1 + kSize2;
 
-  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(sizeof(uint32));
+  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(sizeof(uint32_t));
   ExpectedMemoryInfo mem2 = GetExpectedMemory(kSize1);
   ExpectedMemoryInfo mem3 = GetExpectedMemory(kSize2);
 
@@ -1426,8 +1426,8 @@ TEST_F(GLES2ImplementationTest, DrawElementsInstancedANGLEClientSideBuffers) {
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
-  static const uint16 indices[] = {
-    1, 2,
+  static const uint16_t indices[] = {
+      1, 2,
   };
   struct Cmds {
     cmds::EnableVertexAttribArray enable1;
@@ -1704,11 +1704,11 @@ TEST_F(GLES2ImplementationTest, ReadPixels2Reads) {
       0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
       mem2.id, mem2.offset, result2.id, result2.offset, false);
   expected.set_token2.Init(GetNextToken());
-  scoped_ptr<int8[]> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
+  scoped_ptr<int8_t[]> buffer(new int8_t[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(SetMemory(result1.ptr, static_cast<uint32>(1)))
-      .WillOnce(SetMemory(result2.ptr, static_cast<uint32>(1)))
+      .WillOnce(SetMemory(result1.ptr, static_cast<uint32_t>(1)))
+      .WillOnce(SetMemory(result2.ptr, static_cast<uint32_t>(1)))
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
@@ -1736,7 +1736,7 @@ TEST_F(GLES2ImplementationTest, ReadPixelsBadFormatType) {
       0, 0, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset, false);
   expected.set_token.Init(GetNextToken());
-  scoped_ptr<int8[]> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
+  scoped_ptr<int8_t[]> buffer(new int8_t[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .Times(1)
@@ -1780,7 +1780,7 @@ TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUM) {
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
-  uint32 offset = 0;
+  uint32_t offset = 0;
   Cmds expected;
   expected.buf.Init(
       kTarget, kOffset, kSize,
@@ -1844,7 +1844,7 @@ TEST_F(GLES2ImplementationTest, MapUnmapTexSubImage2DCHROMIUM) {
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
-  uint32 offset = 0;
+  uint32_t offset = 0;
   Cmds expected;
   expected.tex.Init(
       GL_TEXTURE_2D, kLevel, kXOffset, kYOffset, kWidth, kHeight, kFormat,
@@ -1981,7 +1981,7 @@ TEST_F(GLES2ImplementationTest, MapUnmapTexSubImage2DCHROMIUMBadArgs) {
 }
 
 TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMGoodArgs) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kProgramId = 123;
   const char kBad = 0x12;
   GLsizei size = 0;
@@ -1997,7 +1997,7 @@ TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMGoodArgs) {
 
   memset(buf, kBad, sizeof(buf));
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
@@ -2026,7 +2026,7 @@ TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMGoodArgs) {
 }
 
 TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMBadArgs) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kProgramId = 123;
   GLsizei size = 0;
   const Str7 kString = {"foobar"};
@@ -2043,8 +2043,8 @@ TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMBadArgs) {
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
-                      SetMemory(mem1.ptr,  kString)))
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
+                      SetMemory(mem1.ptr, kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
@@ -2083,7 +2083,7 @@ TEST_F(GLES2ImplementationTest, GetProgramInfoCHROMIUMBadArgs) {
 }
 
 TEST_F(GLES2ImplementationTest, GetUniformBlocksCHROMIUMGoodArgs) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kProgramId = 123;
   const char kBad = 0x12;
   GLsizei size = 0;
@@ -2099,7 +2099,7 @@ TEST_F(GLES2ImplementationTest, GetUniformBlocksCHROMIUMGoodArgs) {
 
   memset(buf, kBad, sizeof(buf));
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
@@ -2128,7 +2128,7 @@ TEST_F(GLES2ImplementationTest, GetUniformBlocksCHROMIUMGoodArgs) {
 }
 
 TEST_F(GLES2ImplementationTest, GetUniformBlocksCHROMIUMBadArgs) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kProgramId = 123;
   GLsizei size = 0;
   const Str7 kString = {"foobar"};
@@ -2145,8 +2145,8 @@ TEST_F(GLES2ImplementationTest, GetUniformBlocksCHROMIUMBadArgs) {
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
-                      SetMemory(mem1.ptr,  kString)))
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
+                      SetMemory(mem1.ptr, kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
@@ -2304,12 +2304,16 @@ TEST_F(GLES2ImplementationTest, GetIntegerCacheWrite) {
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
-static bool CheckRect(
-    int width, int height, GLenum format, GLenum type, int alignment,
-    const uint8* r1, const uint8* r2) {
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+static bool CheckRect(int width,
+                      int height,
+                      GLenum format,
+                      GLenum type,
+                      int alignment,
+                      const uint8_t* r1,
+                      const uint8_t* r2) {
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, alignment, &size, &unpadded_row_size,
       &padded_row_size)) {
@@ -2350,11 +2354,10 @@ TEST_F(GLES2ImplementationTest, TexImage2D) {
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
-  static uint8 pixels[] = {
-    11, 12, 13, 13, 14, 15, 15, 16, 17, 101, 102, 103,
-    21, 22, 23, 23, 24, 25, 25, 26, 27, 201, 202, 203,
-    31, 32, 33, 33, 34, 35, 35, 36, 37, 123, 124, 125,
-    41, 42, 43, 43, 44, 45, 45, 46, 47,
+  static uint8_t pixels[] = {
+      11, 12, 13, 13,  14,  15,  15,  16,  17,  101, 102, 103, 21, 22, 23,
+      23, 24, 25, 25,  26,  27,  201, 202, 203, 31,  32,  33,  33, 34, 35,
+      35, 36, 37, 123, 124, 125, 41,  42,  43,  43,  44,  45,  45, 46, 47,
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sizeof(pixels));
@@ -2391,9 +2394,9 @@ TEST_F(GLES2ImplementationTest, TexImage2DViaMappedMem) {
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2403,9 +2406,9 @@ TEST_F(GLES2ImplementationTest, TexImage2DViaMappedMem) {
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
 
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMappedMemory(size);
@@ -2444,9 +2447,9 @@ TEST_F(GLES2ImplementationTest, TexImage2DViaTexSubImage2D) {
   const GLint kPixelStoreUnpackAlignment = 4;
   const GLsizei kWidth = 3;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2454,14 +2457,14 @@ TEST_F(GLES2ImplementationTest, TexImage2DViaTexSubImage2D) {
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
-  uint32 half_size = 0;
+  uint32_t half_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &half_size, NULL, NULL));
 
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(half_size);
@@ -2485,7 +2488,8 @@ TEST_F(GLES2ImplementationTest, TexImage2DViaTexSubImage2D) {
   //     .WillOnce(CheckRectAction(
   //         kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
   //         false, pixels.get(),
-  //         GetExpectedTransferAddressFromOffsetAs<uint8>(offset1, half_size)))
+  //         GetExpectedTransferAddressFromOffsetAs<uint8_t>(offset1,
+  //         half_size)))
   //     .RetiresOnSaturation();
 
   gl_->TexImage2D(
@@ -2532,21 +2536,21 @@ TEST_F(GLES2ImplementationTest, SubImageUnpack) {
     cmds::TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
-  uint32 src_size;
+  uint32_t src_size;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSrcWidth, kSrcSubImageY1, 1, kFormat, kType, 8, &src_size, NULL, NULL));
-  scoped_ptr<uint8[]> src_pixels;
-  src_pixels.reset(new uint8[src_size]);
+  scoped_ptr<uint8_t[]> src_pixels;
+  src_pixels.reset(new uint8_t[src_size]);
   for (size_t i = 0; i < src_size; ++i) {
-    src_pixels[i] = static_cast<int8>(i);
+    src_pixels[i] = static_cast<int8_t>(i);
   }
 
   for (int sub = 0; sub < 2; ++sub) {
     for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
       GLint alignment = unpack_alignments[a];
-      uint32 size;
-      uint32 unpadded_row_size;
-      uint32 padded_row_size;
+      uint32_t size;
+      uint32_t unpadded_row_size;
+      uint32_t padded_row_size;
       ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
           kSrcSubImageWidth, kSrcSubImageHeight, 1, kFormat, kType, alignment,
           &size, &unpadded_row_size, &padded_row_size));
@@ -2589,16 +2593,16 @@ TEST_F(GLES2ImplementationTest, SubImageUnpack) {
         EXPECT_EQ(0, memcmp(
             &texImageExpected, commands, sizeof(texImageExpected)));
       }
-      uint32 src_padded_row_size;
+      uint32_t src_padded_row_size;
       ASSERT_TRUE(GLES2Util::ComputeImagePaddedRowSize(
           kSrcWidth, kFormat, kType, alignment, &src_padded_row_size));
-      uint32 bytes_per_group = GLES2Util::ComputeImageGroupSize(
-          kFormat, kType);
+      uint32_t bytes_per_group =
+          GLES2Util::ComputeImageGroupSize(kFormat, kType);
       for (int y = 0; y < kSrcSubImageHeight; ++y) {
-        const uint8* src_row = src_pixels.get() +
-            (kSrcSubImageY0 + y) * src_padded_row_size +
-            bytes_per_group * kSrcSubImageX0;
-        const uint8* dst_row = mem.ptr + y * padded_row_size;
+        const uint8_t* src_row = src_pixels.get() +
+                                 (kSrcSubImageY0 + y) * src_padded_row_size +
+                                 bytes_per_group * kSrcSubImageX0;
+        const uint8_t* dst_row = mem.ptr + y * padded_row_size;
         EXPECT_EQ(0, memcmp(src_row, dst_row, unpadded_row_size));
       }
       ClearCommands();
@@ -2621,11 +2625,10 @@ TEST_F(GLES2ImplementationTest, TextureInvalidArguments) {
   const GLint kInvalidBorder = 1;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
-  static uint8 pixels[] = {
-    11, 12, 13, 13, 14, 15, 15, 16, 17, 101, 102, 103,
-    21, 22, 23, 23, 24, 25, 25, 26, 27, 201, 202, 203,
-    31, 32, 33, 33, 34, 35, 35, 36, 37, 123, 124, 125,
-    41, 42, 43, 43, 44, 45, 45, 46, 47,
+  static uint8_t pixels[] = {
+      11, 12, 13, 13,  14,  15,  15,  16,  17,  101, 102, 103, 21, 22, 23,
+      23, 24, 25, 25,  26,  27,  201, 202, 203, 31,  32,  33,  33, 34, 35,
+      35, 36, 37, 123, 124, 125, 41,  42,  43,  43,  44,  45,  45, 46, 47,
   };
 
   // Verify that something works.
@@ -2696,9 +2699,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DSingleCommand) {
   const GLsizei kWidth = 3;
   const GLsizei kDepth = 2;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2708,9 +2711,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DSingleCommand) {
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
 
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem = GetExpectedMemory(size);
@@ -2725,9 +2728,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DSingleCommand) {
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
-  EXPECT_TRUE(CheckRect(
-      kWidth, kHeight * kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
-      reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
+  EXPECT_TRUE(CheckRect(kWidth, kHeight * kDepth, kFormat, kType,
+                        kPixelStoreUnpackAlignment,
+                        reinterpret_cast<uint8_t*>(pixels.get()), mem.ptr));
 }
 
 TEST_F(GLES2ImplementationTest, TexImage3DViaMappedMem) {
@@ -2748,9 +2751,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DViaMappedMem) {
   const GLsizei kWidth = 3;
   const GLsizei kDepth = 2;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2761,9 +2764,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DViaMappedMem) {
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
 
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem = GetExpectedMappedMemory(size);
@@ -2778,9 +2781,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DViaMappedMem) {
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
-  EXPECT_TRUE(CheckRect(
-      kWidth, kHeight * kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
-      reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
+  EXPECT_TRUE(CheckRect(kWidth, kHeight * kDepth, kFormat, kType,
+                        kPixelStoreUnpackAlignment,
+                        reinterpret_cast<uint8_t*>(pixels.get()), mem.ptr));
 }
 
 TEST_F(GLES2ImplementationTest, TexImage3DViaTexSubImage3D) {
@@ -2801,9 +2804,9 @@ TEST_F(GLES2ImplementationTest, TexImage3DViaTexSubImage3D) {
   const GLint kPixelStoreUnpackAlignment = 4;
   const GLsizei kWidth = 3;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2812,15 +2815,15 @@ TEST_F(GLES2ImplementationTest, TexImage3DViaTexSubImage3D) {
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
-  uint32 first_size = padded_row_size * (kHeight - 3);
-  uint32 second_size =
+  uint32_t first_size = padded_row_size * (kHeight - 3);
+  uint32_t second_size =
       padded_row_size * 3 - (padded_row_size - unpadded_row_size);
   EXPECT_EQ(size, first_size + second_size);
   ExpectedMemoryInfo mem1 = GetExpectedMemory(first_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(second_size);
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   Cmds expected;
@@ -2862,9 +2865,9 @@ TEST_F(GLES2ImplementationTest, TexSubImage3D4Writes) {
   const GLsizei kWidth = 3;
   const GLsizei kDepth = 2;
 
-  uint32 size = 0;
-  uint32 unpadded_row_size = 0;
-  uint32 padded_row_size = 0;
+  uint32_t size = 0;
+  uint32_t unpadded_row_size = 0;
+  uint32_t padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
@@ -2872,15 +2875,15 @@ TEST_F(GLES2ImplementationTest, TexSubImage3D4Writes) {
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
-  uint32 first_size = (kHeight - 2) * padded_row_size;
-  uint32 second_size = 2 * padded_row_size;
-  uint32 third_size = first_size;
-  uint32 fourth_size = second_size - (padded_row_size - unpadded_row_size);
+  uint32_t first_size = (kHeight - 2) * padded_row_size;
+  uint32_t second_size = 2 * padded_row_size;
+  uint32_t third_size = first_size;
+  uint32_t fourth_size = second_size - (padded_row_size - unpadded_row_size);
   EXPECT_EQ(size, first_size + second_size + third_size + fourth_size);
 
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
-  for (uint32 ii = 0; ii < size; ++ii) {
-    pixels[ii] = static_cast<uint8>(ii);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
+  for (uint32_t ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8_t>(ii);
   }
 
   ExpectedMemoryInfo mem1_1 = GetExpectedMemory(first_size);
@@ -2912,10 +2915,10 @@ TEST_F(GLES2ImplementationTest, TexSubImage3D4Writes) {
       kFormat, kType, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
-  uint32 offset_to_last = first_size + second_size + third_size;
+  uint32_t offset_to_last = first_size + second_size + third_size;
   EXPECT_TRUE(CheckRect(
       kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
-      reinterpret_cast<uint8*>(pixels.get()) + offset_to_last, mem2_2.ptr));
+      reinterpret_cast<uint8_t*>(pixels.get()) + offset_to_last, mem2_2.ptr));
 }
 
 // glGen* Ids must not be reused until glDelete* commands have been
@@ -2971,7 +2974,7 @@ TEST_F(GLES2ImplementationStrictSharedTest,
 }
 
 TEST_F(GLES2ImplementationTest, GetString) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
   // GL_CHROMIUM_map_sub is hard coded into GLES2Implementation.
   const char* expected_str =
@@ -3001,7 +3004,7 @@ TEST_F(GLES2ImplementationTest, GetString) {
   memset(buf, kBad, sizeof(buf));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .RetiresOnSaturation();
 
@@ -3011,7 +3014,7 @@ TEST_F(GLES2ImplementationTest, GetString) {
 }
 
 TEST_F(GLES2ImplementationTest, PixelStoreiGLPackReverseRowOrderANGLE) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
@@ -3037,7 +3040,7 @@ TEST_F(GLES2ImplementationTest, PixelStoreiGLPackReverseRowOrderANGLE) {
   expected.pixel_store.Init(GL_PACK_REVERSE_ROW_ORDER_ANGLE, 1);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
+      .WillOnce(DoAll(SetMemory(result1.ptr, uint32_t(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .RetiresOnSaturation();
 
@@ -3067,7 +3070,9 @@ TEST_F(GLES2ImplementationTest, BufferDataLargerThanTransferBuffer) {
   };
   const unsigned kUsableSize =
       kTransferBufferSize - GLES2Implementation::kStartingOffset;
-  uint8 buf[kUsableSize * 2] = { 0, };
+  uint8_t buf[kUsableSize * 2] = {
+      0,
+  };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kUsableSize);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(kUsableSize);
@@ -3589,7 +3594,7 @@ TEST_F(GLES2ImplementationTest, LimitSizeAndOffsetTo32Bit) {
     return;
   // The below two casts should be no-op, as we return early if
   // it's 32-bit system.
-  int64 value64 = 0x100000000;
+  int64_t value64 = 0x100000000;
   size = static_cast<GLsizeiptr>(value64);
   offset = static_cast<GLintptr>(value64);
 
@@ -3687,8 +3692,8 @@ TEST_F(GLES2ImplementationTest, LimitSizeAndOffsetTo32Bit) {
 }
 
 TEST_F(GLES2ImplementationTest, TraceBeginCHROMIUM) {
-  const uint32 kCategoryBucketId = GLES2Implementation::kResultBucketId;
-  const uint32 kNameBucketId = GLES2Implementation::kResultBucketId + 1;
+  const uint32_t kCategoryBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kNameBucketId = GLES2Implementation::kResultBucketId + 1;
   const std::string category_name = "test category";
   const std::string trace_name = "test trace";
   const size_t kPaddedString1Size =
@@ -4256,6 +4261,7 @@ TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
   EXPECT_FALSE(Initialize(init_options));
 }
 
+#include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
index e8efce0..9deba0a 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
@@ -1521,7 +1521,7 @@ TEST_F(GLES2ImplementationTest, Scissor) {
 }
 
 TEST_F(GLES2ImplementationTest, ShaderSource) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const char* kString1 = "happy";
   const char* kString2 = "ending";
   const size_t kString1Size = ::strlen(kString1) + 1;
@@ -1569,7 +1569,7 @@ TEST_F(GLES2ImplementationTest, ShaderSource) {
 }
 
 TEST_F(GLES2ImplementationTest, ShaderSourceWithLength) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const char* kString = "foobar******";
   const size_t kStringSize = 6;  // We only need "foobar".
   const size_t kHeaderSize = sizeof(GLint) * 2;
@@ -1739,7 +1739,7 @@ TEST_F(GLES2ImplementationTest, TexStorage3D) {
 }
 
 TEST_F(GLES2ImplementationTest, TransformFeedbackVaryings) {
-  const uint32 kBucketId = GLES2Implementation::kResultBucketId;
+  const uint32_t kBucketId = GLES2Implementation::kResultBucketId;
   const char* kString1 = "happy";
   const char* kString2 = "ending";
   const size_t kString1Size = ::strlen(kString1) + 1;
diff --git a/gpu/command_buffer/client/gpu_control.h b/gpu/command_buffer/client/gpu_control.h
index 9e04d29..d637a1d 100644
--- a/gpu/command_buffer/client/gpu_control.h
+++ b/gpu/command_buffer/client/gpu_control.h
@@ -5,6 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GPU_CONTROL_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GPU_CONTROL_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
diff --git a/gpu/command_buffer/client/gpu_switches.cc b/gpu/command_buffer/client/gpu_switches.cc
index f933c19..7f7abef8 100644
--- a/gpu/command_buffer/client/gpu_switches.cc
+++ b/gpu/command_buffer/client/gpu_switches.cc
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/client/gpu_switches.h"
-#include "base/basictypes.h"
 
 namespace switches {
 
diff --git a/gpu/command_buffer/client/mapped_memory.cc b/gpu/command_buffer/client/mapped_memory.cc
index dcfead22..c40278e 100644
--- a/gpu/command_buffer/client/mapped_memory.cc
+++ b/gpu/command_buffer/client/mapped_memory.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <functional>
 
@@ -25,7 +28,7 @@ base::StaticAtomicSequenceNumber g_next_mapped_memory_manager_tracing_id;
 
 }  // namespace
 
-MemoryChunk::MemoryChunk(int32 shm_id,
+MemoryChunk::MemoryChunk(int32_t shm_id,
                          scoped_refptr<gpu::Buffer> shm,
                          CommandBufferHelper* helper)
     : shm_id_(shm_id),
@@ -61,8 +64,9 @@ MappedMemoryManager::~MappedMemoryManager() {
   }
 }
 
-void* MappedMemoryManager::Alloc(
-    unsigned int size, int32* shm_id, unsigned int* shm_offset) {
+void* MappedMemoryManager::Alloc(unsigned int size,
+                                 int32_t* shm_id,
+                                 unsigned int* shm_offset) {
   DCHECK(shm_id);
   DCHECK(shm_offset);
   if (size <= allocated_memory_) {
@@ -108,7 +112,7 @@ void* MappedMemoryManager::Alloc(
   unsigned int chunk_size =
       ((size + chunk_size_multiple_ - 1) / chunk_size_multiple_) *
       chunk_size_multiple_;
-  int32 id = -1;
+  int32_t id = -1;
   scoped_refptr<gpu::Buffer> shm =
       cmd_buf->CreateTransferBuffer(chunk_size, &id);
   if (id  < 0)
@@ -134,7 +138,7 @@ void MappedMemoryManager::Free(void* pointer) {
   NOTREACHED();
 }
 
-void MappedMemoryManager::FreePendingToken(void* pointer, int32 token) {
+void MappedMemoryManager::FreePendingToken(void* pointer, int32_t token) {
   for (auto& chunk : chunks_) {
     if (chunk->IsInChunk(pointer)) {
       chunk->FreePendingToken(pointer, token);
@@ -163,7 +167,7 @@ void MappedMemoryManager::FreeUnused() {
 bool MappedMemoryManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
-  const uint64 tracing_process_id =
+  const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
 
diff --git a/gpu/command_buffer/client/mapped_memory.h b/gpu/command_buffer/client/mapped_memory.h
index 78f5255..7083159 100644
--- a/gpu/command_buffer/client/mapped_memory.h
+++ b/gpu/command_buffer/client/mapped_memory.h
@@ -5,6 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
 #define GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
diff --git a/gpu/command_buffer/client/mapped_memory_unittest.cc b/gpu/command_buffer/client/mapped_memory_unittest.cc
index 15f5fbf..ac30abb 100644
--- a/gpu/command_buffer/client/mapped_memory_unittest.cc
+++ b/gpu/command_buffer/client/mapped_memory_unittest.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ -63,9 +66,7 @@ class MappedMemoryTestBase : public testing::Test {
     helper_->Initialize(kBufferSize);
   }
 
-  int32 GetToken() {
-    return command_buffer_->GetLastState().token;
-  }
+  int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
@@ -85,7 +86,7 @@ const unsigned int MappedMemoryTestBase::kBufferSize;
 // and SetToken are properly forwarded to the engine.
 class MemoryChunkTest : public MappedMemoryTestBase {
  protected:
-  static const int32 kShmId = 123;
+  static const int32_t kShmId = 123;
   void SetUp() override {
     MappedMemoryTestBase::SetUp();
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
@@ -101,14 +102,14 @@ class MemoryChunkTest : public MappedMemoryTestBase {
     MappedMemoryTestBase::TearDown();
   }
 
-  uint8* buffer_memory() { return static_cast<uint8*>(buffer_->memory()); }
+  uint8_t* buffer_memory() { return static_cast<uint8_t*>(buffer_->memory()); }
 
   scoped_ptr<MemoryChunk> chunk_;
   scoped_refptr<gpu::Buffer> buffer_;
 };
 
 #ifndef _MSC_VER
-const int32 MemoryChunkTest::kShmId;
+const int32_t MemoryChunkTest::kShmId;
 #endif
 
 TEST_F(MemoryChunkTest, Basic) {
@@ -119,9 +120,9 @@ TEST_F(MemoryChunkTest, Basic) {
   EXPECT_EQ(kBufferSize, chunk_->GetSize());
   void *pointer = chunk_->Alloc(kSize);
   ASSERT_TRUE(pointer);
-  EXPECT_LE(buffer_->memory(), static_cast<uint8*>(pointer));
+  EXPECT_LE(buffer_->memory(), static_cast<uint8_t*>(pointer));
   EXPECT_GE(kBufferSize,
-            static_cast<uint8*>(pointer) - buffer_memory() + kSize);
+            static_cast<uint8_t*>(pointer) - buffer_memory() + kSize);
   EXPECT_EQ(kBufferSize - kSize, chunk_->GetLargestFreeSizeWithoutWaiting());
   EXPECT_EQ(kBufferSize - kSize, chunk_->GetLargestFreeSizeWithWaiting());
   EXPECT_EQ(kBufferSize, chunk_->GetSize());
@@ -130,7 +131,7 @@ TEST_F(MemoryChunkTest, Basic) {
   EXPECT_EQ(kBufferSize, chunk_->GetLargestFreeSizeWithoutWaiting());
   EXPECT_EQ(kBufferSize, chunk_->GetLargestFreeSizeWithWaiting());
 
-  uint8 *pointer_char = static_cast<uint8*>(chunk_->Alloc(kSize));
+  uint8_t* pointer_char = static_cast<uint8_t*>(chunk_->Alloc(kSize));
   ASSERT_TRUE(pointer_char);
   EXPECT_LE(buffer_memory(), pointer_char);
   EXPECT_GE(buffer_memory() + kBufferSize, pointer_char + kSize);
@@ -167,14 +168,14 @@ class MappedMemoryManagerTest : public MappedMemoryTestBase {
 TEST_F(MappedMemoryManagerTest, Basic) {
   const unsigned int kSize = 1024;
   // Check we can alloc.
-  int32 id1 = -1;
+  int32_t id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
   ASSERT_TRUE(mem1);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(0u, offset1);
   // Check if we free and realloc the same size we get the same memory
-  int32 id2 = -1;
+  int32_t id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   manager_->Free(mem1);
   void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
@@ -182,7 +183,7 @@ TEST_F(MappedMemoryManagerTest, Basic) {
   EXPECT_EQ(id1, id2);
   EXPECT_EQ(offset1, offset2);
   // Check if we allocate again we get different shared memory
-  int32 id3 = -1;
+  int32_t id3 = -1;
   unsigned int offset3 = 0xFFFFFFFFU;
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   ASSERT_TRUE(mem3 != NULL);
@@ -191,8 +192,8 @@ TEST_F(MappedMemoryManagerTest, Basic) {
   EXPECT_EQ(0u, offset3);
   // Free 3 and allocate 2 half size blocks.
   manager_->Free(mem3);
-  int32 id4 = -1;
-  int32 id5 = -1;
+  int32_t id4 = -1;
+  int32_t id5 = -1;
   unsigned int offset4 = 0xFFFFFFFFU;
   unsigned int offset5 = 0xFFFFFFFFU;
   void* mem4 = manager_->Alloc(kSize / 2, &id4, &offset4);
@@ -216,7 +217,7 @@ TEST_F(MappedMemoryManagerTest, FreePendingToken) {
   // Allocate several buffers across multiple chunks.
   void *pointers[kAllocCount];
   for (unsigned int i = 0; i < kAllocCount; ++i) {
-    int32 id = -1;
+    int32_t id = -1;
     unsigned int offset = 0xFFFFFFFFu;
     pointers[i] = manager_->Alloc(kSize, &id, &offset);
     EXPECT_TRUE(pointers[i]);
@@ -225,7 +226,7 @@ TEST_F(MappedMemoryManagerTest, FreePendingToken) {
   }
 
   // Free one successful allocation, pending fence.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   manager_->FreePendingToken(pointers[0], token);
 
   // The way we hooked up the helper and engine, it won't process commands
@@ -238,7 +239,7 @@ TEST_F(MappedMemoryManagerTest, FreePendingToken) {
   EXPECT_LE(token, GetToken());
 
   // This allocation should use the spot just freed above.
-  int32 new_id = -1;
+  int32_t new_id = -1;
   unsigned int new_offset = 0xFFFFFFFFu;
   void* new_ptr = manager_->Alloc(kSize, &new_id, &new_offset);
   EXPECT_TRUE(new_ptr);
@@ -254,7 +255,7 @@ TEST_F(MappedMemoryManagerTest, FreePendingToken) {
 }
 
 TEST_F(MappedMemoryManagerTest, FreeUnused) {
-  int32 id = -1;
+  int32_t id = -1;
   unsigned int offset = 0xFFFFFFFFU;
   void* m1 = manager_->Alloc(kBufferSize, &id, &offset);
   void* m2 = manager_->Alloc(kBufferSize, &id, &offset);
@@ -278,13 +279,13 @@ TEST_F(MappedMemoryManagerTest, ChunkSizeMultiple) {
   manager_->set_chunk_size_multiple(kSize *  2);
   // Check if we allocate less than the chunk size multiple we get
   // chunks arounded up.
-  int32 id1 = -1;
+  int32_t id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
-  int32 id2 = -1;
+  int32_t id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
-  int32 id3 = -1;
+  int32_t id3 = -1;
   unsigned int offset3 = 0xFFFFFFFFU;
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   ASSERT_TRUE(mem1);
@@ -309,7 +310,7 @@ TEST_F(MappedMemoryManagerTest, UnusedMemoryLimit) {
   manager_->set_chunk_size_multiple(kChunkSize);
 
   // Allocate one chunk worth of memory.
-  int32 id1 = -1;
+  int32_t id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kChunkSize, &id1, &offset1);
   ASSERT_TRUE(mem1);
@@ -318,7 +319,7 @@ TEST_F(MappedMemoryManagerTest, UnusedMemoryLimit) {
 
   // Allocate half a chunk worth of memory again.
   // The same chunk will be used.
-  int32 id2 = -1;
+  int32_t id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   void* mem2 = manager_->Alloc(kChunkSize, &id2, &offset2);
   ASSERT_TRUE(mem2);
@@ -341,7 +342,7 @@ TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
   manager_->set_chunk_size_multiple(kChunkSize);
 
   // Allocate half a chunk worth of memory.
-  int32 id1 = -1;
+  int32_t id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
   ASSERT_TRUE(mem1);
@@ -350,7 +351,7 @@ TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
 
   // Allocate half a chunk worth of memory again.
   // The same chunk will be used.
-  int32 id2 = -1;
+  int32_t id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
   ASSERT_TRUE(mem2);
@@ -358,7 +359,7 @@ TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
   EXPECT_EQ(kSize, offset2);
 
   // Free one successful allocation, pending fence.
-  int32 token = helper_.get()->InsertToken();
+  int32_t token = helper_.get()->InsertToken();
   manager_->FreePendingToken(mem2, token);
 
   // The way we hooked up the helper and engine, it won't process commands
@@ -370,7 +371,7 @@ TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
   // We won't be able to claim the free memory without waiting and
   // as we've already met the memory limit we'll have to wait
   // on the token.
-  int32 id3 = -1;
+  int32_t id3 = -1;
   unsigned int offset3 = 0xFFFFFFFFU;
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   ASSERT_TRUE(mem3);
@@ -394,14 +395,14 @@ TEST_F(MappedMemoryManagerTest, MaxAllocationTest) {
   manager_->set_chunk_size_multiple(kLimit);
 
   // Allocate twice the limit worth of memory (currently unbounded).
-  int32 id1 = -1;
+  int32_t id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kLimit, &id1, &offset1);
   ASSERT_TRUE(mem1);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(0u, offset1);
 
-  int32 id2 = -1;
+  int32_t id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   void* mem2 = manager_->Alloc(kLimit, &id2, &offset2);
   ASSERT_TRUE(mem2);
@@ -411,7 +412,7 @@ TEST_F(MappedMemoryManagerTest, MaxAllocationTest) {
   manager_->set_max_allocated_bytes(kLimit);
 
   // A new allocation should now fail.
-  int32 id3 = -1;
+  int32_t id3 = -1;
   unsigned int offset3 = 0xFFFFFFFFU;
   void* mem3 = manager_->Alloc(kLimit, &id3, &offset3);
   ASSERT_FALSE(mem3);
@@ -421,7 +422,7 @@ TEST_F(MappedMemoryManagerTest, MaxAllocationTest) {
   manager_->Free(mem2);
 
   // New allocation is over the limit but should reuse allocated space
-  int32 id4 = -1;
+  int32_t id4 = -1;
   unsigned int offset4 = 0xFFFFFFFFU;
   void* mem4 = manager_->Alloc(kLimit, &id4, &offset4);
   ASSERT_TRUE(mem4);
diff --git a/gpu/command_buffer/client/program_info_manager.cc b/gpu/command_buffer/client/program_info_manager.cc
index 573e236..adfb620 100644
--- a/gpu/command_buffer/client/program_info_manager.cc
+++ b/gpu/command_buffer/client/program_info_manager.cc
@@ -2,13 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/client/program_info_manager.h"
 
 namespace {
 
-template<typename T> static T LocalGetAs(
-    const std::vector<int8>& data, uint32 offset, size_t size) {
-  const int8* p = &data[0] + offset;
+template <typename T>
+static T LocalGetAs(const std::vector<int8_t>& data,
+                    uint32_t offset,
+                    size_t size) {
+  const int8_t* p = &data[0] + offset;
   if (offset + size > data.size()) {
     NOTREACHED();
     return NULL;
@@ -329,7 +334,7 @@ bool ProgramInfoManager::Program::GetUniformsiv(
   return false;
 }
 
-void ProgramInfoManager::Program::UpdateES2(const std::vector<int8>& result) {
+void ProgramInfoManager::Program::UpdateES2(const std::vector<int8_t>& result) {
   if (cached_es2_) {
     return;
   }
@@ -352,9 +357,9 @@ void ProgramInfoManager::Program::UpdateES2(const std::vector<int8>& result) {
       result, sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   const ProgramInput* input = inputs;
-  for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
-    const int32* location = LocalGetAs<const int32*>(
-        result, input->location_offset, sizeof(int32));
+  for (uint32_t ii = 0; ii < header->num_attribs; ++ii) {
+    const int32_t* location = LocalGetAs<const int32_t*>(
+        result, input->location_offset, sizeof(int32_t));
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
@@ -364,28 +369,28 @@ void ProgramInfoManager::Program::UpdateES2(const std::vector<int8>& result) {
         static_cast<GLsizei>(name.size() + 1), max_attrib_name_length_);
     ++input;
   }
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
-    const int32* locations = LocalGetAs<const int32*>(
-        result, input->location_offset, sizeof(int32) * input->size);
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
+    const int32_t* locations = LocalGetAs<const int32_t*>(
+        result, input->location_offset, sizeof(int32_t) * input->size);
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
     UniformInfo info(input->size, input->type, name);
     max_uniform_name_length_ = std::max(
         static_cast<GLsizei>(name.size() + 1), max_uniform_name_length_);
-    for (int32 jj = 0; jj < input->size; ++jj) {
+    for (int32_t jj = 0; jj < input->size; ++jj) {
       info.element_locations.push_back(locations[jj]);
     }
     uniform_infos_.push_back(info);
     ++input;
   }
   DCHECK_EQ(header->num_attribs + header->num_uniforms,
-            static_cast<uint32>(input - inputs));
+            static_cast<uint32_t>(input - inputs));
   cached_es2_ = true;
 }
 
 void ProgramInfoManager::Program::UpdateES3UniformBlocks(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_uniform_blocks_) {
     return;
   }
@@ -456,7 +461,7 @@ void ProgramInfoManager::Program::UpdateES3UniformBlocks(
 }
 
 void ProgramInfoManager::Program::UpdateES3Uniformsiv(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_uniformsiv_) {
     return;
   }
@@ -498,7 +503,7 @@ void ProgramInfoManager::Program::UpdateES3Uniformsiv(
 }
 
 void ProgramInfoManager::Program::UpdateES3TransformFeedbackVaryings(
-    const std::vector<int8>& result) {
+    const std::vector<int8_t>& result) {
   if (cached_es3_transform_feedback_varyings_) {
     return;
   }
@@ -596,7 +601,7 @@ ProgramInfoManager::Program* ProgramInfoManager::GetProgramInfo(
   if (info->IsCached(type))
     return info;
 
-  std::vector<int8> result;
+  std::vector<int8_t> result;
   switch (type) {
     case kES2:
       {
diff --git a/gpu/command_buffer/client/program_info_manager.h b/gpu/command_buffer/client/program_info_manager.h
index fbae19a..b3091e2 100644
--- a/gpu/command_buffer/client/program_info_manager.h
+++ b/gpu/command_buffer/client/program_info_manager.h
@@ -6,6 +6,7 @@
 #define GPU_COMMAND_BUFFER_CLIENT_PROGRAM_INFO_MANAGER_H_
 
 #include <GLES3/gl3.h>
+#include <stdint.h>
 
 #include <string>
 #include <vector>
@@ -188,16 +189,16 @@ class GLES2_IMPL_EXPORT ProgramInfoManager {
         GLuint index) const;
 
     // Updates the ES2 only program info after a successful link.
-    void UpdateES2(const std::vector<int8>& result);
+    void UpdateES2(const std::vector<int8_t>& result);
 
     // Updates the ES3 UniformBlock info after a successful link.
-    void UpdateES3UniformBlocks(const std::vector<int8>& result);
+    void UpdateES3UniformBlocks(const std::vector<int8_t>& result);
 
     // Updates the ES3 Uniformsiv info after a successful link.
-    void UpdateES3Uniformsiv(const std::vector<int8>& result);
+    void UpdateES3Uniformsiv(const std::vector<int8_t>& result);
 
     // Updates the ES3 TransformFeedbackVaryings info after a successful link.
-    void UpdateES3TransformFeedbackVaryings(const std::vector<int8>& result);
+    void UpdateES3TransformFeedbackVaryings(const std::vector<int8_t>& result);
 
     bool IsCached(ProgramInfoType type) const;
 
diff --git a/gpu/command_buffer/client/program_info_manager_unittest.cc b/gpu/command_buffer/client/program_info_manager_unittest.cc
index c78fa08..1911b1c 100644
--- a/gpu/command_buffer/client/program_info_manager_unittest.cc
+++ b/gpu/command_buffer/client/program_info_manager_unittest.cc
@@ -2,14 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+uint32_t ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8_t*>(position) -
+         static_cast<const uint8_t*>(start);
 }
 
 const GLuint kClientProgramId = 321;
@@ -171,7 +174,7 @@ TEST_F(ProgramInfoManagerTest, UpdateES2) {
   SetupProgramES2Data(&data);
   const std::string kNames[] = { data.uniform_name0, data.uniform_name1 };
   const int32_t* kLocs[] = { data.uniform_loc0, data.uniform_loc1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES2));
   program_->UpdateES2(result);
@@ -217,7 +220,7 @@ TEST_F(ProgramInfoManagerTest, UpdateES3UniformBlocks) {
   SetupUniformBlocksData(&data);
   const std::string kName[] = { data.name0, data.name1 };
   const uint32_t* kIndices[] = { data.indices0, data.indices1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES3UniformBlocks));
   program_->UpdateES3UniformBlocks(result);
@@ -258,7 +261,7 @@ TEST_F(ProgramInfoManagerTest, UpdateES3TransformFeedbackVaryings) {
   TransformFeedbackVaryingsData data;
   SetupTransformFeedbackVaryingsData(&data);
   const std::string kName[] = { data.name0, data.name1 };
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   EXPECT_FALSE(program_->IsCached(
       ProgramInfoManager::kES3TransformFeedbackVaryings));
@@ -296,7 +299,7 @@ TEST_F(ProgramInfoManagerTest, UpdateES3TransformFeedbackVaryings) {
 TEST_F(ProgramInfoManagerTest, GetUniformBlockIndexCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
 
@@ -311,7 +314,7 @@ TEST_F(ProgramInfoManagerTest, GetUniformBlockIndexCached) {
 TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockNameCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
 
@@ -349,7 +352,7 @@ TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockNameCached) {
 TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockivCached) {
   UniformBlocksData data;
   SetupUniformBlocksData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3UniformBlocks(result);
   const char* kName[] = { data.name0, data.name1 };
@@ -398,7 +401,7 @@ TEST_F(ProgramInfoManagerTest, GetActiveUniformBlockivCached) {
 TEST_F(ProgramInfoManagerTest, GetTransformFeedbackVaryingCached) {
   TransformFeedbackVaryingsData data;
   SetupTransformFeedbackVaryingsData(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES3TransformFeedbackVaryings(result);
   const char* kName[] = { data.name0, data.name1 };
@@ -422,7 +425,7 @@ TEST_F(ProgramInfoManagerTest, GetTransformFeedbackVaryingCached) {
 TEST_F(ProgramInfoManagerTest, GetUniformIndices) {
   ProgramES2Data data;
   SetupProgramES2Data(&data);
-  std::vector<int8> result(sizeof(data));
+  std::vector<int8_t> result(sizeof(data));
   memcpy(&result[0], &data, sizeof(data));
   program_->UpdateES2(result);
 
@@ -480,7 +483,7 @@ TEST_F(ProgramInfoManagerTest, GetActiveUniformsivCached) {
   // ES3 only parameters.
   UniformsES3Data data_es3;
   SetupUniformsES3Data(&data_es3);
-  std::vector<int8> result(sizeof(data_es3));
+  std::vector<int8_t> result(sizeof(data_es3));
   memcpy(&result[0], &data_es3, sizeof(data_es3));
   EXPECT_FALSE(program_->IsCached(ProgramInfoManager::kES3Uniformsiv));
   program_->UpdateES3Uniformsiv(result);
diff --git a/gpu/command_buffer/client/query_tracker.cc b/gpu/command_buffer/client/query_tracker.cc
index f5363f0..bf71645 100644
--- a/gpu/command_buffer/client/query_tracker.cc
+++ b/gpu/command_buffer/client/query_tracker.cc
@@ -9,6 +9,8 @@
 #include <GLES2/gl2extchromium.h>
 
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/atomicops.h"
 #include "base/numerics/safe_conversions.h"
@@ -21,12 +23,9 @@ namespace gpu {
 namespace gles2 {
 
 QuerySyncManager::Bucket::Bucket(QuerySync* sync_mem,
-                                 int32 shm_id,
+                                 int32_t shm_id,
                                  unsigned int shm_offset)
-    : syncs(sync_mem),
-      shm_id(shm_id),
-      base_shm_offset(shm_offset) {
-}
+    : syncs(sync_mem), shm_id(shm_id), base_shm_offset(shm_offset) {}
 
 QuerySyncManager::Bucket::~Bucket() = default;
 
@@ -55,7 +54,7 @@ bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) {
     }
   }
   if (!bucket) {
-    int32 shm_id;
+    int32_t shm_id;
     unsigned int shm_offset;
     void* mem = mapped_memory_->Alloc(
         kSyncsPerBucket * sizeof(QuerySync), &shm_id, &shm_offset);
@@ -75,7 +74,7 @@ bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) {
     }
   }
 
-  uint32 shm_offset =
+  uint32_t shm_offset =
       bucket->base_shm_offset + index_in_bucket * sizeof(QuerySync);
   QuerySync* sync = bucket->syncs + index_in_bucket;
   *info = QueryInfo(bucket, bucket->shm_id, shm_offset, sync);
@@ -206,7 +205,7 @@ bool QueryTracker::Query::CheckResultsAvailable(
   return state_ == kComplete;
 }
 
-uint64 QueryTracker::Query::GetResult() const {
+uint64_t QueryTracker::Query::GetResult() const {
   DCHECK(state_ == kComplete || state_ == kUninitialized);
   return result_;
 }
diff --git a/gpu/command_buffer/client/query_tracker.h b/gpu/command_buffer/client/query_tracker.h
index 986b9f2..35d4a47 100644
--- a/gpu/command_buffer/client/query_tracker.h
+++ b/gpu/command_buffer/client/query_tracker.h
@@ -6,6 +6,8 @@
 #define GPU_COMMAND_BUFFER_CLIENT_QUERY_TRACKER_H_
 
 #include <GLES2/gl2.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <bitset>
 #include <deque>
@@ -13,6 +15,7 @@
 
 #include "base/atomicops.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "gles2_impl_export.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 
@@ -31,20 +34,16 @@ class GLES2_IMPL_EXPORT QuerySyncManager {
   static const size_t kSyncsPerBucket = 256;
 
   struct Bucket {
-    Bucket(QuerySync* sync_mem, int32 shm_id, uint32 shm_offset);
+    Bucket(QuerySync* sync_mem, int32_t shm_id, uint32_t shm_offset);
     ~Bucket();
     QuerySync* syncs;
-    int32 shm_id;
-    uint32 base_shm_offset;
+    int32_t shm_id;
+    uint32_t base_shm_offset;
     std::bitset<kSyncsPerBucket> in_use_queries;
   };
   struct QueryInfo {
-    QueryInfo(Bucket* bucket, int32 id, uint32 offset, QuerySync* sync_mem)
-        : bucket(bucket),
-          shm_id(id),
-          shm_offset(offset),
-          sync(sync_mem) {
-    }
+    QueryInfo(Bucket* bucket, int32_t id, uint32_t offset, QuerySync* sync_mem)
+        : bucket(bucket), shm_id(id), shm_offset(offset), sync(sync_mem) {}
 
     QueryInfo()
         : bucket(NULL),
@@ -54,8 +53,8 @@ class GLES2_IMPL_EXPORT QuerySyncManager {
     }
 
     Bucket* bucket;
-    int32 shm_id;
-    uint32 shm_offset;
+    int32_t shm_id;
+    uint32_t shm_offset;
     QuerySync* sync;
   };
 
@@ -95,13 +94,9 @@ class GLES2_IMPL_EXPORT QueryTracker {
       return id_;
     }
 
-    int32 shm_id() const {
-      return info_.shm_id;
-    }
+    int32_t shm_id() const { return info_.shm_id; }
 
-    uint32 shm_offset() const {
-      return info_.shm_offset;
-    }
+    uint32_t shm_offset() const { return info_.shm_offset; }
 
     void MarkAsActive() {
       state_ = kActive;
@@ -110,16 +105,14 @@ class GLES2_IMPL_EXPORT QueryTracker {
         submit_count_ = 1;
     }
 
-    void MarkAsPending(int32 token) {
+    void MarkAsPending(int32_t token) {
       token_ = token;
       state_ = kPending;
     }
 
     base::subtle::Atomic32 submit_count() const { return submit_count_; }
 
-    int32 token() const {
-      return token_;
-    }
+    int32_t token() const { return token_; }
 
     bool NeverUsed() const {
       return state_ == kUninitialized;
@@ -135,7 +128,7 @@ class GLES2_IMPL_EXPORT QueryTracker {
 
     bool CheckResultsAvailable(CommandBufferHelper* helper);
 
-    uint64 GetResult() const;
+    uint64_t GetResult() const;
 
    private:
     friend class QueryTracker;
@@ -150,10 +143,10 @@ class GLES2_IMPL_EXPORT QueryTracker {
     QuerySyncManager::QueryInfo info_;
     State state_;
     base::subtle::Atomic32 submit_count_;
-    int32 token_;
-    uint32 flush_count_;
-    uint64 client_begin_time_us_; // Only used for latency query target.
-    uint64 result_;
+    int32_t token_;
+    uint32_t flush_count_;
+    uint64_t client_begin_time_us_;  // Only used for latency query target.
+    uint64_t result_;
   };
 
   QueryTracker(MappedMemoryManager* manager);
diff --git a/gpu/command_buffer/client/query_tracker_unittest.cc b/gpu/command_buffer/client/query_tracker_unittest.cc
index 93c2cbe..a110087 100644
--- a/gpu/command_buffer/client/query_tracker_unittest.cc
+++ b/gpu/command_buffer/client/query_tracker_unittest.cc
@@ -7,6 +7,8 @@
 #include "gpu/command_buffer/client/query_tracker.h"
 
 #include <GLES2/gl2ext.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <vector>
 
@@ -15,16 +17,16 @@
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/mapped_memory.h"
 #include "gpu/command_buffer/common/command_buffer.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 namespace gles2 {
 
 class QuerySyncManagerTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
 
   void SetUp() override {
@@ -77,8 +79,8 @@ TEST_F(QuerySyncManagerTest, DontFree) {
 
 class QueryTrackerTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
 
   void SetUp() override {
@@ -105,11 +107,11 @@ class QueryTrackerTest : public testing::Test {
     return query->info_.bucket;
   }
 
-  uint32 GetBucketUsedCount(QuerySyncManager::Bucket* bucket) {
+  uint32_t GetBucketUsedCount(QuerySyncManager::Bucket* bucket) {
     return bucket->in_use_queries.count();
   }
 
-  uint32 GetFlushGeneration() { return helper_->flush_generation(); }
+  uint32_t GetFlushGeneration() { return helper_->flush_generation(); }
 
   scoped_ptr<CommandBuffer> command_buffer_;
   scoped_ptr<GLES2CmdHelper> helper_;
@@ -137,8 +139,8 @@ TEST_F(QueryTrackerTest, Basic) {
 
 TEST_F(QueryTrackerTest, Query) {
   const GLuint kId1 = 123;
-  const int32 kToken = 46;
-  const uint32 kResult = 456;
+  const int32_t kToken = 46;
+  const uint32_t kResult = 456;
 
   // Create a Query.
   QueryTracker::Query* query = query_tracker_->CreateQuery(
@@ -170,14 +172,14 @@ TEST_F(QueryTrackerTest, Query) {
   helper_->Noop(1);
 
   // Store FlushGeneration count after EndQuery is called
-  uint32 gen1 = GetFlushGeneration();
+  uint32_t gen1 = GetFlushGeneration();
 
   // Check CheckResultsAvailable.
   EXPECT_FALSE(query->CheckResultsAvailable(helper_.get()));
   EXPECT_FALSE(query->NeverUsed());
   EXPECT_TRUE(query->Pending());
 
-  uint32 gen2 = GetFlushGeneration();
+  uint32_t gen2 = GetFlushGeneration();
   EXPECT_NE(gen1, gen2);
 
   // Repeated calls to CheckResultsAvailable should not flush unnecessarily
@@ -202,8 +204,8 @@ TEST_F(QueryTrackerTest, Query) {
 
 TEST_F(QueryTrackerTest, Remove) {
   const GLuint kId1 = 123;
-  const int32 kToken = 46;
-  const uint32 kResult = 456;
+  const int32_t kToken = 46;
+  const uint32_t kResult = 456;
 
   // Create a Query.
   QueryTracker::Query* query = query_tracker_->CreateQuery(
@@ -235,8 +237,8 @@ TEST_F(QueryTrackerTest, Remove) {
 
 TEST_F(QueryTrackerTest, ManyQueries) {
   const GLuint kId1 = 123;
-  const int32 kToken = 46;
-  const uint32 kResult = 456;
+  const int32_t kToken = 46;
+  const uint32_t kResult = 456;
 
   const size_t kTestSize = 4000;
   static_assert(kTestSize > QuerySyncManager::kSyncsPerBucket,
@@ -253,7 +255,7 @@ TEST_F(QueryTrackerTest, ManyQueries) {
   }
 
   QuerySyncManager::Bucket* query_0_bucket = GetBucket(queries[0]);
-  uint32 expected_use_count = QuerySyncManager::kSyncsPerBucket;
+  uint32_t expected_use_count = QuerySyncManager::kSyncsPerBucket;
   EXPECT_EQ(expected_use_count, GetBucketUsedCount(query_0_bucket));
 
   while (!queries.empty()) {
@@ -265,7 +267,7 @@ TEST_F(QueryTrackerTest, ManyQueries) {
     query->MarkAsPending(kToken);
 
     QuerySyncManager::Bucket* bucket = GetBucket(query);
-    uint32 use_count_before_remove = GetBucketUsedCount(bucket);
+    uint32_t use_count_before_remove = GetBucketUsedCount(bucket);
     query_tracker_->FreeCompletedQueries();
     EXPECT_EQ(use_count_before_remove, GetBucketUsedCount(bucket));
     query_tracker_->RemoveQuery(query_id);
diff --git a/gpu/command_buffer/client/ring_buffer.cc b/gpu/command_buffer/client/ring_buffer.cc
index 002d529..ebbb118 100644
--- a/gpu/command_buffer/client/ring_buffer.cc
+++ b/gpu/command_buffer/client/ring_buffer.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/client/ring_buffer.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/logging.h"
@@ -13,8 +15,10 @@
 
 namespace gpu {
 
-RingBuffer::RingBuffer(unsigned int alignment, Offset base_offset,
-                       unsigned int size, CommandBufferHelper* helper,
+RingBuffer::RingBuffer(unsigned int alignment,
+                       Offset base_offset,
+                       unsigned int size,
+                       CommandBufferHelper* helper,
                        void* base)
     : helper_(helper),
       base_offset_(base_offset),
@@ -22,8 +26,7 @@ RingBuffer::RingBuffer(unsigned int alignment, Offset base_offset,
       free_offset_(0),
       in_use_offset_(0),
       alignment_(alignment),
-      base_(static_cast<int8*>(base) - base_offset) {
-}
+      base_(static_cast<int8_t*>(base) - base_offset) {}
 
 RingBuffer::~RingBuffer() {
   // Free blocks pending tokens.
diff --git a/gpu/command_buffer/client/ring_buffer.h b/gpu/command_buffer/client/ring_buffer.h
index ff20a4c..083cb01 100644
--- a/gpu/command_buffer/client/ring_buffer.h
+++ b/gpu/command_buffer/client/ring_buffer.h
@@ -7,6 +7,8 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
 
+#include <stdint.h>
+
 #include <deque>
 
 #include "base/logging.h"
@@ -75,12 +77,12 @@ class GPU_EXPORT RingBuffer {
 
   // Gets a pointer to a memory block given the base memory and the offset.
   void* GetPointer(RingBuffer::Offset offset) const {
-    return static_cast<int8*>(base_) + offset;
+    return static_cast<int8_t*>(base_) + offset;
   }
 
   // Gets the offset to a memory block given the base memory and the address.
   RingBuffer::Offset GetOffset(void* pointer) const {
-    return static_cast<int8*>(pointer) - static_cast<int8*>(base_);
+    return static_cast<int8_t*>(pointer) - static_cast<int8_t*>(base_);
   }
 
   // Rounds the given size to the alignment in use.
diff --git a/gpu/command_buffer/client/ring_buffer_test.cc b/gpu/command_buffer/client/ring_buffer_test.cc
index ac3c8d7..e6d11f7 100644
--- a/gpu/command_buffer/client/ring_buffer_test.cc
+++ b/gpu/command_buffer/client/ring_buffer_test.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/client/ring_buffer.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
@@ -87,9 +89,7 @@ class BaseRingBufferTest : public testing::Test {
     helper_->Initialize(kBufferSize);
   }
 
-  int32 GetToken() {
-    return command_buffer_->GetLastState().token;
-  }
+  int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
@@ -99,8 +99,8 @@ class BaseRingBufferTest : public testing::Test {
   std::vector<const void*> set_token_arguments_;
   bool delay_set_token_;
 
-  scoped_ptr<int8[]> buffer_;
-  int8* buffer_start_;
+  scoped_ptr<int8_t[]> buffer_;
+  int8_t* buffer_start_;
   base::MessageLoop message_loop_;
 };
 
@@ -118,7 +118,7 @@ class RingBufferTest : public BaseRingBufferTest {
   void SetUp() override {
     BaseRingBufferTest::SetUp();
 
-    buffer_.reset(new int8[kBufferSize + kBaseOffset]);
+    buffer_.reset(new int8_t[kBufferSize + kBaseOffset]);
     buffer_start_ = buffer_.get() + kBaseOffset;
     allocator_.reset(new RingBuffer(kAlignment, kBaseOffset, kBufferSize,
                                     helper_.get(), buffer_start_));
@@ -143,7 +143,7 @@ TEST_F(RingBufferTest, TestBasic) {
   EXPECT_GE(kBufferSize, allocator_->GetOffset(pointer) - kBaseOffset + kSize);
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
   EXPECT_EQ(kBufferSize - kSize, allocator_->GetLargestFreeSizeNoWaiting());
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
   allocator_->FreePendingToken(pointer, token);
 }
 
@@ -155,7 +155,7 @@ TEST_F(RingBufferTest, TestFreePendingToken) {
 
   delay_set_token_ = true;
   // Allocate several buffers to fill in the memory.
-  int32 tokens[kAllocCount];
+  int32_t tokens[kAllocCount];
   for (unsigned int ii = 0; ii < kAllocCount; ++ii) {
     void* pointer = allocator_->Alloc(kSize);
     EXPECT_GE(kBufferSize,
diff --git a/gpu/command_buffer/client/share_group.cc b/gpu/command_buffer/client/share_group.cc
index fb5b886..2ba790a 100644
--- a/gpu/command_buffer/client/share_group.cc
+++ b/gpu/command_buffer/client/share_group.cc
@@ -4,9 +4,10 @@
 
 #include "gpu/command_buffer/client/share_group.h"
 
+#include <stdint.h>
+
 #include <stack>
 #include <vector>
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
@@ -234,13 +235,13 @@ class StrictIdHandler : public IdHandlerInterface {
   enum IdState { kIdFree, kIdPendingFree, kIdInUse };
 
   void CollectPendingFreeIds(GLES2Implementation* gl_impl) {
-    uint32 flush_generation = gl_impl->helper()->flush_generation();
+    uint32_t flush_generation = gl_impl->helper()->flush_generation();
     ShareGroupContextData::IdHandlerData* ctxt_data =
         gl_impl->share_group_context_data()->id_handler_data(id_namespace_);
 
     if (ctxt_data->flush_generation_ != flush_generation) {
       ctxt_data->flush_generation_ = flush_generation;
-      for (uint32 ii = 0; ii < ctxt_data->freed_ids_.size(); ++ii) {
+      for (uint32_t ii = 0; ii < ctxt_data->freed_ids_.size(); ++ii) {
         const GLuint id = ctxt_data->freed_ids_[ii];
         DCHECK(id_states_[id - 1] == kIdPendingFree);
         id_states_[id - 1] = kIdFree;
@@ -253,8 +254,8 @@ class StrictIdHandler : public IdHandlerInterface {
   int id_namespace_;
 
   base::Lock lock_;
-  std::vector<uint8> id_states_;
-  std::stack<uint32> free_ids_;
+  std::vector<uint8_t> id_states_;
+  std::stack<uint32_t> free_ids_;
 };
 
 // An id handler for ids that are never reused.
diff --git a/gpu/command_buffer/client/share_group.h b/gpu/command_buffer/client/share_group.h
index 9fe0fb9..25427e3 100644
--- a/gpu/command_buffer/client/share_group.h
+++ b/gpu/command_buffer/client/share_group.h
@@ -6,6 +6,8 @@
 #define GPU_COMMAND_BUFFER_CLIENT_SHARE_GROUP_H_
 
 #include <GLES2/gl2.h>
+#include <stdint.h>
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gles2_impl_export.h"
 #include "gpu/command_buffer/client/ref_counted.h"
@@ -34,7 +36,7 @@ class ShareGroupContextData {
     ~IdHandlerData();
 
     std::vector<GLuint> freed_ids_;
-    uint32 flush_generation_;
+    uint32_t flush_generation_;
   };
 
   IdHandlerData* id_handler_data(int namespace_id) {
diff --git a/gpu/command_buffer/client/transfer_buffer.cc b/gpu/command_buffer/client/transfer_buffer.cc
index dde8020..161c836 100644
--- a/gpu/command_buffer/client/transfer_buffer.cc
+++ b/gpu/command_buffer/client/transfer_buffer.cc
@@ -6,6 +6,9 @@
 
 #include "gpu/command_buffer/client/transfer_buffer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
@@ -95,7 +98,7 @@ unsigned int TransferBuffer::GetFreeSize() const {
 
 void TransferBuffer::AllocateRingBuffer(unsigned int size) {
   for (;size >= min_buffer_size_; size /= 2) {
-    int32 id = -1;
+    int32_t id = -1;
     scoped_refptr<gpu::Buffer> buffer =
         helper_->command_buffer()->CreateTransferBuffer(size, &id);
     if (id != -1) {
diff --git a/gpu/command_buffer/client/transfer_buffer.h b/gpu/command_buffer/client/transfer_buffer.h
index 307f26b..43fea94 100644
--- a/gpu/command_buffer/client/transfer_buffer.h
+++ b/gpu/command_buffer/client/transfer_buffer.h
@@ -5,7 +5,11 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_TRANSFER_BUFFER_H_
 #define GPU_COMMAND_BUFFER_CLIENT_TRANSFER_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/client/ring_buffer.h"
 #include "gpu/command_buffer/common/buffer.h"
@@ -120,13 +124,13 @@ class GPU_EXPORT TransferBuffer : public TransferBufferInterface {
   scoped_refptr<gpu::Buffer> buffer_;
 
   // id of buffer. -1 = no buffer
-  int32 buffer_id_;
+  int32_t buffer_id_;
 
   // address of result area
   void* result_buffer_;
 
   // offset to result area
-  uint32 result_shm_offset_;
+  uint32_t result_shm_offset_;
 
   // false if we failed to allocate min_buffer_size
   bool usable_;
diff --git a/gpu/command_buffer/client/transfer_buffer_unittest.cc b/gpu/command_buffer/client/transfer_buffer_unittest.cc
index 1a2a4b0..7a98b80 100644
--- a/gpu/command_buffer/client/transfer_buffer_unittest.cc
+++ b/gpu/command_buffer/client/transfer_buffer_unittest.cc
@@ -6,12 +6,15 @@
 
 #include "gpu/command_buffer/client/transfer_buffer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/compiler_specific.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/common/command_buffer.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtMost;
@@ -25,8 +28,8 @@ namespace gpu {
 
 class TransferBufferTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const unsigned int kStartingOffset = 64;
   static const unsigned int kAlignment = 4;
@@ -56,7 +59,7 @@ class TransferBufferTest : public testing::Test {
   scoped_ptr<MockClientCommandBufferMockFlush> command_buffer_;
   scoped_ptr<CommandBufferHelper> helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
-  int32 transfer_buffer_id_;
+  int32_t transfer_buffer_id_;
 };
 
 void TransferBufferTest::SetUp() {
@@ -88,8 +91,8 @@ void TransferBufferTest::TearDown() {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
-const int32 TransferBufferTest::kNumCommandEntries;
-const int32 TransferBufferTest::kCommandBufferSizeBytes;
+const int32_t TransferBufferTest::kNumCommandEntries;
+const int32_t TransferBufferTest::kCommandBufferSizeBytes;
 const unsigned int TransferBufferTest::kStartingOffset;
 const unsigned int TransferBufferTest::kAlignment;
 const size_t TransferBufferTest::kTransferBufferSize;
@@ -227,17 +230,18 @@ class MockClientCommandBufferCanFail : public MockClientCommandBufferMockFlush {
   }
 
   MOCK_METHOD2(CreateTransferBuffer,
-               scoped_refptr<Buffer>(size_t size, int32* id));
+               scoped_refptr<Buffer>(size_t size, int32_t* id));
 
-  scoped_refptr<gpu::Buffer> RealCreateTransferBuffer(size_t size, int32* id) {
+  scoped_refptr<gpu::Buffer> RealCreateTransferBuffer(size_t size,
+                                                      int32_t* id) {
     return MockCommandBufferBase::CreateTransferBuffer(size, id);
   }
 };
 
 class TransferBufferExpandContractTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const unsigned int kStartingOffset = 64;
   static const unsigned int kAlignment = 4;
@@ -259,7 +263,7 @@ class TransferBufferExpandContractTest : public testing::Test {
   scoped_ptr<MockClientCommandBufferCanFail> command_buffer_;
   scoped_ptr<CommandBufferHelper> helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
-  int32 transfer_buffer_id_;
+  int32_t transfer_buffer_id_;
 };
 
 void TransferBufferExpandContractTest::SetUp() {
@@ -310,8 +314,8 @@ void TransferBufferExpandContractTest::TearDown() {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
-const int32 TransferBufferExpandContractTest::kNumCommandEntries;
-const int32 TransferBufferExpandContractTest::kCommandBufferSizeBytes;
+const int32_t TransferBufferExpandContractTest::kNumCommandEntries;
+const int32_t TransferBufferExpandContractTest::kCommandBufferSizeBytes;
 const unsigned int TransferBufferExpandContractTest::kStartingOffset;
 const unsigned int TransferBufferExpandContractTest::kAlignment;
 const size_t TransferBufferExpandContractTest::kStartTransferBufferSize;
diff --git a/gpu/command_buffer/client/vertex_array_object_manager.cc b/gpu/command_buffer/client/vertex_array_object_manager.cc
index 415abe6..b5b0839 100644
--- a/gpu/command_buffer/client/vertex_array_object_manager.cc
+++ b/gpu/command_buffer/client/vertex_array_object_manager.cc
@@ -4,7 +4,11 @@
 
 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
@@ -166,8 +170,7 @@ class GLES2_IMPL_EXPORT VertexArrayObject {
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
     const void* ptr, GLboolean integer);
 
-  bool GetVertexAttrib(
-      GLuint index, GLenum pname, uint32* param) const;
+  bool GetVertexAttrib(GLuint index, GLenum pname, uint32_t* param) const;
 
   void SetAttribDivisor(GLuint index, GLuint divisor);
 
@@ -266,8 +269,9 @@ void VertexArrayObject::SetAttribPointer(
   }
 }
 
-bool VertexArrayObject::GetVertexAttrib(
-    GLuint index, GLenum pname, uint32* param) const {
+bool VertexArrayObject::GetVertexAttrib(GLuint index,
+                                        GLenum pname,
+                                        uint32_t* param) const {
   const VertexAttrib* attrib = GetAttrib(index);
   if (!attrib) {
     return false;
@@ -424,8 +428,9 @@ void VertexArrayObjectManager::SetAttribEnable(GLuint index, bool enabled) {
   bound_vertex_array_object_->SetAttribEnable(index, enabled);
 }
 
-bool VertexArrayObjectManager::GetVertexAttrib(
-    GLuint index, GLenum pname, uint32* param) {
+bool VertexArrayObjectManager::GetVertexAttrib(GLuint index,
+                                               GLenum pname,
+                                               uint32_t* param) {
   return bound_vertex_array_object_->GetVertexAttrib(index, pname, param);
 }
 
@@ -465,12 +470,12 @@ GLsizei VertexArrayObjectManager::CollectData(
     GLsizei num_elements) {
   GLsizei bytes_needed = bytes_per_element * num_elements;
   if (collection_buffer_size_ < bytes_needed) {
-    collection_buffer_.reset(new int8[bytes_needed]);
+    collection_buffer_.reset(new int8_t[bytes_needed]);
     collection_buffer_size_ = bytes_needed;
   }
-  const int8* src = static_cast<const int8*>(data);
-  int8* dst = collection_buffer_.get();
-  int8* end = dst + bytes_per_element * num_elements;
+  const int8_t* src = static_cast<const int8_t*>(data);
+  int8_t* dst = collection_buffer_.get();
+  int8_t* end = dst + bytes_per_element * num_elements;
   for (; dst < end; src += real_stride, dst += bytes_per_element) {
     memcpy(dst, src, bytes_per_element);
   }
@@ -570,7 +575,7 @@ bool VertexArrayObjectManager::SetupSimulatedIndexAndClientSideBuffers(
     GLsizei max_index = -1;
     switch (type) {
       case GL_UNSIGNED_BYTE: {
-        const uint8* src = static_cast<const uint8*>(indices);
+        const uint8_t* src = static_cast<const uint8_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           if (src[ii] > max_index) {
             max_index = src[ii];
@@ -579,7 +584,7 @@ bool VertexArrayObjectManager::SetupSimulatedIndexAndClientSideBuffers(
         break;
       }
       case GL_UNSIGNED_SHORT: {
-        const uint16* src = static_cast<const uint16*>(indices);
+        const uint16_t* src = static_cast<const uint16_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           if (src[ii] > max_index) {
             max_index = src[ii];
@@ -588,9 +593,9 @@ bool VertexArrayObjectManager::SetupSimulatedIndexAndClientSideBuffers(
         break;
       }
       case GL_UNSIGNED_INT: {
-        uint32 max_glsizei = static_cast<uint32>(
-            std::numeric_limits<GLsizei>::max());
-        const uint32* src = static_cast<const uint32*>(indices);
+        uint32_t max_glsizei =
+            static_cast<uint32_t>(std::numeric_limits<GLsizei>::max());
+        const uint32_t* src = static_cast<const uint32_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           // Other parts of the API use GLsizei (signed) to store limits.
           // As such, if we encounter a index that cannot be represented with
diff --git a/gpu/command_buffer/client/vertex_array_object_manager.h b/gpu/command_buffer/client/vertex_array_object_manager.h
index 8714521..6897c92 100644
--- a/gpu/command_buffer/client/vertex_array_object_manager.h
+++ b/gpu/command_buffer/client/vertex_array_object_manager.h
@@ -6,6 +6,7 @@
 #define GPU_COMMAND_BUFFER_CLIENT_VERTEX_ARRAY_OBJECT_MANAGER_H_
 
 #include <GLES2/gl2.h>
+#include <stdint.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
@@ -76,7 +77,7 @@ class GLES2_IMPL_EXPORT VertexArrayObjectManager {
 
   void SetAttribEnable(GLuint index, bool enabled);
 
-  bool GetVertexAttrib(GLuint index, GLenum pname, uint32* param);
+  bool GetVertexAttrib(GLuint index, GLenum pname, uint32_t* param);
 
   bool GetAttribPointer(GLuint index, GLenum pname, void** ptr) const;
 
@@ -112,7 +113,7 @@ class GLES2_IMPL_EXPORT VertexArrayObjectManager {
   GLuint element_array_buffer_id_;
   GLsizei element_array_buffer_size_;
   GLsizei collection_buffer_size_;
-  scoped_ptr<int8[]> collection_buffer_;
+  scoped_ptr<int8_t[]> collection_buffer_;
 
   VertexArrayObject* default_vertex_array_object_;
   VertexArrayObject* bound_vertex_array_object_;
diff --git a/gpu/command_buffer/client/vertex_array_object_manager_unittest.cc b/gpu/command_buffer/client/vertex_array_object_manager_unittest.cc
index 927eafc..b39aab8 100644
--- a/gpu/command_buffer/client/vertex_array_object_manager_unittest.cc
+++ b/gpu/command_buffer/client/vertex_array_object_manager_unittest.cc
@@ -6,6 +6,8 @@
 
 #include <GLES2/gl2ext.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
@@ -40,7 +42,7 @@ const GLuint VertexArrayObjectManagerTest::kClientSideElementArrayBuffer;
 TEST_F(VertexArrayObjectManagerTest, Basic) {
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
   // Check out of bounds access.
-  uint32 param;
+  uint32_t param;
   void* ptr;
   EXPECT_FALSE(manager_->GetVertexAttrib(
       kMaxAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &param));
@@ -59,7 +61,7 @@ TEST_F(VertexArrayObjectManagerTest, Basic) {
     EXPECT_EQ(4u, param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_TYPE, &param));
-    EXPECT_EQ(static_cast<uint32>(GL_FLOAT), param);
+    EXPECT_EQ(static_cast<uint32_t>(GL_FLOAT), param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &param));
     EXPECT_EQ(0u, param);
@@ -100,9 +102,13 @@ TEST_F(VertexArrayObjectManagerTest, UnbindBuffer) {
   // The attribs are still enabled but their buffer is 0.
   EXPECT_TRUE(manager_->HaveEnabledClientSideBuffers());
   // Check the status of the bindings.
-  static const uint32 expected[][4] = {
-    { 0, kBufferToRemain, 0, kBufferToRemain, },
-    { kBufferToUnbind, kBufferToRemain, kBufferToUnbind, kBufferToRemain, },
+  static const uint32_t expected[][4] = {
+      {
+          0, kBufferToRemain, 0, kBufferToRemain,
+      },
+      {
+          kBufferToUnbind, kBufferToRemain, kBufferToUnbind, kBufferToRemain,
+      },
   };
   static const GLuint expected_element_array[] = {
     0, kElementArray,
@@ -110,7 +116,7 @@ TEST_F(VertexArrayObjectManagerTest, UnbindBuffer) {
   for (size_t ii = 0; ii < arraysize(ids); ++ii) {
     EXPECT_TRUE(manager_->BindVertexArray(ids[ii], &changed));
     for (size_t jj = 0; jj < 4; ++jj) {
-      uint32 param = 1;
+      uint32_t param = 1;
       EXPECT_TRUE(manager_->GetVertexAttrib(
           jj, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &param));
       EXPECT_EQ(expected[ii][jj], param)
@@ -137,7 +143,7 @@ TEST_F(VertexArrayObjectManagerTest, GetSet) {
   const void* p = reinterpret_cast<const void*>(dummy);
   manager_->SetAttribEnable(1, true);
   manager_->SetAttribPointer(123, 1, 3, GL_BYTE, true, 3, p, GL_TRUE);
-  uint32 param;
+  uint32_t param;
   void* ptr;
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &param));
@@ -150,7 +156,7 @@ TEST_F(VertexArrayObjectManagerTest, GetSet) {
   EXPECT_EQ(3u, param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_TYPE, &param));
-  EXPECT_EQ(static_cast<uint32>(GL_BYTE), param);
+  EXPECT_EQ(static_cast<uint32_t>(GL_BYTE), param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &param));
   EXPECT_NE(0u, param);
diff --git a/gpu/command_buffer/common/buffer.cc b/gpu/command_buffer/common/buffer.cc
index 8ddcf19..02c7777 100644
--- a/gpu/command_buffer/common/buffer.cc
+++ b/gpu/command_buffer/common/buffer.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/common/buffer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
@@ -32,12 +35,12 @@ Buffer::Buffer(scoped_ptr<BufferBacking> backing)
 
 Buffer::~Buffer() {}
 
-void* Buffer::GetDataAddress(uint32 data_offset, uint32 data_size) const {
-  base::CheckedNumeric<uint32> end = data_offset;
+void* Buffer::GetDataAddress(uint32_t data_offset, uint32_t data_size) const {
+  base::CheckedNumeric<uint32_t> end = data_offset;
   end += data_size;
-  if (!end.IsValid() || end.ValueOrDie() > static_cast<uint32>(size_))
+  if (!end.IsValid() || end.ValueOrDie() > static_cast<uint32_t>(size_))
     return NULL;
-  return static_cast<uint8*>(memory_) + data_offset;
+  return static_cast<uint8_t*>(memory_) + data_offset;
 }
 
 base::trace_event::MemoryAllocatorDumpGuid GetBufferGUIDForTracing(
diff --git a/gpu/command_buffer/common/buffer.h b/gpu/command_buffer/common/buffer.h
index 52839c5..1e427f2 100644
--- a/gpu/command_buffer/common/buffer.h
+++ b/gpu/command_buffer/common/buffer.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_COMMON_BUFFER_H_
 #define GPU_COMMAND_BUFFER_COMMON_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -50,7 +53,7 @@ class GPU_EXPORT Buffer : public base::RefCountedThreadSafe<Buffer> {
   size_t size() const { return size_; }
 
   // Returns NULL if the address overflows the memory.
-  void* GetDataAddress(uint32 data_offset, uint32 data_size) const;
+  void* GetDataAddress(uint32_t data_offset, uint32_t data_size) const;
 
  private:
   friend class base::RefCountedThreadSafe<Buffer>;
diff --git a/gpu/command_buffer/common/cmd_buffer_common.cc b/gpu/command_buffer/common/cmd_buffer_common.cc
index f337e86..c9f4b16 100644
--- a/gpu/command_buffer/common/cmd_buffer_common.cc
+++ b/gpu/command_buffer/common/cmd_buffer_common.cc
@@ -7,12 +7,14 @@
 
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/command_buffer.h"
 
 namespace gpu {
 #if !defined(_WIN32)
 // gcc needs this to link, but MSVC requires it not be present
-const int32 CommandHeader::kMaxSize;
+const int32_t CommandHeader::kMaxSize;
 #endif
 namespace cmd {
 
diff --git a/gpu/command_buffer/common/command_buffer.h b/gpu/command_buffer/common/command_buffer.h
index b699363..23cb406 100644
--- a/gpu/command_buffer/common/command_buffer.h
+++ b/gpu/command_buffer/common/command_buffer.h
@@ -5,6 +5,10 @@
 #ifndef GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "gpu/command_buffer/common/buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/gpu_export.h"
@@ -28,14 +32,14 @@ class GPU_EXPORT CommandBuffer {
     }
 
     // The offset (in entries) from which the reader is reading.
-    int32 get_offset;
+    int32_t get_offset;
 
     // The current token value. This is used by the writer to defer
     // changes to shared memory objects until the reader has reached a certain
     // point in the command buffer. The reader is responsible for updating the
     // token value, for example in response to an asynchronous set token command
     // embedded in the command buffer. The default token value is zero.
-    int32 token;
+    int32_t token;
 
     // Error status.
     error::Error error;
@@ -46,12 +50,12 @@ class GPU_EXPORT CommandBuffer {
     // Generation index of this state. The generation index is incremented every
     // time a new state is retrieved from the command processor, so that
     // consistency can be kept even if IPC messages are processed out-of-order.
-    uint32 generation;
+    uint32_t generation;
   };
 
   struct ConsoleMessage {
     // An user supplied id.
-    int32 id;
+    int32_t id;
     // The message.
     std::string message;
   };
@@ -64,7 +68,7 @@ class GPU_EXPORT CommandBuffer {
 
   // Check if a value is between a start and end value, inclusive, allowing
   // for wrapping if start > end.
-  static bool InRange(int32 start, int32 end, int32 value) {
+  static bool InRange(int32_t start, int32_t end, int32_t value) {
     if (start <= end)
       return start <= value && value <= end;
     else
@@ -82,38 +86,38 @@ class GPU_EXPORT CommandBuffer {
   // fast as it is called for every command where GetLastToken is only called
   // by code that needs to know the last token so it can be slower but more up
   // to date than GetLastState.
-  virtual int32 GetLastToken() = 0;
+  virtual int32_t GetLastToken() = 0;
 
   // The writer calls this to update its put offset. This ensures the reader
   // sees the latest added commands, and will eventually process them. On the
   // service side, commands are processed up to the given put_offset before
   // subsequent Flushes on the same GpuChannel.
-  virtual void Flush(int32 put_offset) = 0;
+  virtual void Flush(int32_t put_offset) = 0;
 
   // As Flush, ensures that on the service side, commands up to put_offset
   // are processed but before subsequent commands on the same GpuChannel but
   // flushing to the service may be deferred.
-  virtual void OrderingBarrier(int32 put_offset) = 0;
+  virtual void OrderingBarrier(int32_t put_offset) = 0;
 
   // The writer calls this to wait until the current token is within a
   // specific range, inclusive. Can return early if an error is generated.
-  virtual void WaitForTokenInRange(int32 start, int32 end) = 0;
+  virtual void WaitForTokenInRange(int32_t start, int32_t end) = 0;
 
   // The writer calls this to wait until the current get offset is within a
   // specific range, inclusive. Can return early if an error is generated.
-  virtual void WaitForGetOffsetInRange(int32 start, int32 end) = 0;
+  virtual void WaitForGetOffsetInRange(int32_t start, int32_t end) = 0;
 
   // Sets the buffer commands are read from.
   // Also resets the get and put offsets to 0.
-  virtual void SetGetBuffer(int32 transfer_buffer_id) = 0;
+  virtual void SetGetBuffer(int32_t transfer_buffer_id) = 0;
 
   // Create a transfer buffer of the given size. Returns its ID or -1 on
   // error.
   virtual scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
-                                                          int32* id) = 0;
+                                                          int32_t* id) = 0;
 
   // Destroy a transfer buffer. The ID must be positive.
-  virtual void DestroyTransferBuffer(int32 id) = 0;
+  virtual void DestroyTransferBuffer(int32_t id) = 0;
 
 // The NaCl Win64 build only really needs the struct definitions above; having
 // GetLastError declared would mean we'd have to also define it, and pull more
diff --git a/gpu/command_buffer/common/command_buffer_mock.h b/gpu/command_buffer/common/command_buffer_mock.h
index 9e1f713..600ae7e 100644
--- a/gpu/command_buffer/common/command_buffer_mock.h
+++ b/gpu/command_buffer/common/command_buffer_mock.h
@@ -5,6 +5,10 @@
 #ifndef GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_MOCK_H_
 #define GPU_COMMAND_BUFFER_COMMON_COMMAND_BUFFER_MOCK_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -23,23 +27,23 @@ class MockCommandBuffer : public CommandBufferServiceBase {
 
   MOCK_METHOD0(Initialize, bool());
   MOCK_METHOD0(GetLastState, State());
-  MOCK_METHOD0(GetLastToken, int32());
-  MOCK_METHOD1(Flush, void(int32 put_offset));
-  MOCK_METHOD1(OrderingBarrier, void(int32 put_offset));
-  MOCK_METHOD2(WaitForTokenInRange, void(int32 start, int32 end));
-  MOCK_METHOD2(WaitForGetOffsetInRange, void(int32 start, int32 end));
-  MOCK_METHOD1(SetGetBuffer, void(int32 transfer_buffer_id));
-  MOCK_METHOD1(SetGetOffset, void(int32 get_offset));
+  MOCK_METHOD0(GetLastToken, int32_t());
+  MOCK_METHOD1(Flush, void(int32_t put_offset));
+  MOCK_METHOD1(OrderingBarrier, void(int32_t put_offset));
+  MOCK_METHOD2(WaitForTokenInRange, void(int32_t start, int32_t end));
+  MOCK_METHOD2(WaitForGetOffsetInRange, void(int32_t start, int32_t end));
+  MOCK_METHOD1(SetGetBuffer, void(int32_t transfer_buffer_id));
+  MOCK_METHOD1(SetGetOffset, void(int32_t get_offset));
   MOCK_METHOD2(CreateTransferBuffer,
-               scoped_refptr<gpu::Buffer>(size_t size, int32* id));
-  MOCK_METHOD1(DestroyTransferBuffer, void(int32 id));
-  MOCK_METHOD1(GetTransferBuffer, scoped_refptr<gpu::Buffer>(int32 id));
-  MOCK_METHOD1(SetToken, void(int32 token));
+               scoped_refptr<gpu::Buffer>(size_t size, int32_t* id));
+  MOCK_METHOD1(DestroyTransferBuffer, void(int32_t id));
+  MOCK_METHOD1(GetTransferBuffer, scoped_refptr<gpu::Buffer>(int32_t id));
+  MOCK_METHOD1(SetToken, void(int32_t token));
   MOCK_METHOD1(SetParseError, void(error::Error error));
   MOCK_METHOD1(SetContextLostReason,
                void(error::ContextLostReason context_lost_reason));
-  MOCK_METHOD0(InsertSyncPoint, uint32());
-  MOCK_METHOD0(GetPutOffset, int32());
+  MOCK_METHOD0(InsertSyncPoint, uint32_t());
+  MOCK_METHOD0(GetPutOffset, int32_t());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockCommandBuffer);
diff --git a/gpu/command_buffer/common/command_buffer_shared_test.cc b/gpu/command_buffer/common/command_buffer_shared_test.cc
index 83aed36..dc4bbed 100644
--- a/gpu/command_buffer/common/command_buffer_shared_test.cc
+++ b/gpu/command_buffer/common/command_buffer_shared_test.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
@@ -39,8 +41,7 @@ TEST_F(CommandBufferSharedTest, TestBasic) {
 
 static const int kSize = 100000;
 
-void WriteToState(int32 *buffer,
-                  CommandBufferSharedState* shared_state) {
+void WriteToState(int32_t* buffer, CommandBufferSharedState* shared_state) {
   CommandBuffer::State state;
   for (int i = 0; i < kSize; i++) {
     state.token = i - 1;
@@ -56,11 +57,11 @@ void WriteToState(int32 *buffer,
 }
 
 TEST_F(CommandBufferSharedTest, TestConsistency) {
-  scoped_ptr<int32[]> buffer;
-  buffer.reset(new int32[kSize]);
+  scoped_ptr<int32_t[]> buffer;
+  buffer.reset(new int32_t[kSize]);
   base::Thread consumer("Reader Thread");
 
-  memset(buffer.get(), 0, kSize * sizeof(int32));
+  memset(buffer.get(), 0, kSize * sizeof(int32_t));
 
   consumer.Start();
   consumer.task_runner()->PostTask(
diff --git a/gpu/command_buffer/common/gles2_cmd_format.cc b/gpu/command_buffer/common/gles2_cmd_format.cc
index 5b437a5..cbc486a 100644
--- a/gpu/command_buffer/common/gles2_cmd_format.cc
+++ b/gpu/command_buffer/common/gles2_cmd_format.cc
@@ -12,6 +12,8 @@
 namespace gpu {
 namespace gles2 {
 
+#include <stddef.h>
+
 #include "gpu/command_buffer/common/gles2_cmd_ids_autogen.h"
 
 const char* GetCommandName(CommandId id) {
diff --git a/gpu/command_buffer/common/gles2_cmd_format.h b/gpu/command_buffer/common/gles2_cmd_format.h
index dd42a95..8b12baf 100644
--- a/gpu/command_buffer/common/gles2_cmd_format.h
+++ b/gpu/command_buffer/common/gles2_cmd_format.h
@@ -10,6 +10,7 @@
 
 #include <KHR/khrplatform.h>
 
+#include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ -317,7 +318,7 @@ struct GenMailboxCHROMIUM {
   typedef GenMailboxCHROMIUM ValueType;
   static const CommandId kCmdId = kGenMailboxCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
   CommandHeader header;
 };
 
@@ -325,7 +326,7 @@ struct InsertSyncPointCHROMIUM {
   typedef InsertSyncPointCHROMIUM ValueType;
   static const CommandId kCmdId = kInsertSyncPointCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
   CommandHeader header;
 };
 
@@ -333,7 +334,7 @@ struct CreateAndConsumeTextureCHROMIUMImmediate {
   typedef CreateAndConsumeTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kCreateAndConsumeTextureCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);  // NOLINT
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 9b1a225..2eea1ca 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -18,7 +18,7 @@ struct ActiveTexture {
   typedef ActiveTexture ValueType;
   static const CommandId kCmdId = kActiveTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -50,7 +50,7 @@ struct AttachShader {
   typedef AttachShader ValueType;
   static const CommandId kCmdId = kAttachShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -86,7 +86,7 @@ struct BindAttribLocationBucket {
   typedef BindAttribLocationBucket ValueType;
   static const CommandId kCmdId = kBindAttribLocationBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -130,7 +130,7 @@ struct BindBuffer {
   typedef BindBuffer ValueType;
   static const CommandId kCmdId = kBindBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -166,7 +166,7 @@ struct BindBufferBase {
   typedef BindBufferBase ValueType;
   static const CommandId kCmdId = kBindBufferBase;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -207,7 +207,7 @@ struct BindBufferRange {
   typedef BindBufferRange ValueType;
   static const CommandId kCmdId = kBindBufferRange;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -266,7 +266,7 @@ struct BindFramebuffer {
   typedef BindFramebuffer ValueType;
   static const CommandId kCmdId = kBindFramebuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -303,7 +303,7 @@ struct BindRenderbuffer {
   typedef BindRenderbuffer ValueType;
   static const CommandId kCmdId = kBindRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -340,7 +340,7 @@ struct BindSampler {
   typedef BindSampler ValueType;
   static const CommandId kCmdId = kBindSampler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -376,7 +376,7 @@ struct BindTexture {
   typedef BindTexture ValueType;
   static const CommandId kCmdId = kBindTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -412,7 +412,7 @@ struct BindTransformFeedback {
   typedef BindTransformFeedback ValueType;
   static const CommandId kCmdId = kBindTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -449,7 +449,7 @@ struct BlendColor {
   typedef BlendColor ValueType;
   static const CommandId kCmdId = kBlendColor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -497,7 +497,7 @@ struct BlendEquation {
   typedef BlendEquation ValueType;
   static const CommandId kCmdId = kBlendEquation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -529,7 +529,7 @@ struct BlendEquationSeparate {
   typedef BlendEquationSeparate ValueType;
   static const CommandId kCmdId = kBlendEquationSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -566,7 +566,7 @@ struct BlendFunc {
   typedef BlendFunc ValueType;
   static const CommandId kCmdId = kBlendFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -602,7 +602,7 @@ struct BlendFuncSeparate {
   typedef BlendFuncSeparate ValueType;
   static const CommandId kCmdId = kBlendFuncSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -654,7 +654,7 @@ struct BufferData {
   typedef BufferData ValueType;
   static const CommandId kCmdId = kBufferData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -712,7 +712,7 @@ struct BufferSubData {
   typedef BufferSubData ValueType;
   static const CommandId kCmdId = kBufferSubData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -771,7 +771,7 @@ struct CheckFramebufferStatus {
   typedef CheckFramebufferStatus ValueType;
   static const CommandId kCmdId = kCheckFramebufferStatus;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLenum Result;
 
@@ -821,7 +821,7 @@ struct Clear {
   typedef Clear ValueType;
   static const CommandId kCmdId = kClear;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -852,7 +852,7 @@ struct ClearBufferfi {
   typedef ClearBufferfi ValueType;
   static const CommandId kCmdId = kClearBufferfi;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -904,7 +904,7 @@ struct ClearBufferfvImmediate {
   typedef ClearBufferfvImmediate ValueType;
   static const CommandId kCmdId = kClearBufferfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4);
@@ -960,7 +960,7 @@ struct ClearBufferivImmediate {
   typedef ClearBufferivImmediate ValueType;
   static const CommandId kCmdId = kClearBufferivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 4);
@@ -1016,7 +1016,7 @@ struct ClearBufferuivImmediate {
   typedef ClearBufferuivImmediate ValueType;
   static const CommandId kCmdId = kClearBufferuivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLuint) * 4);
@@ -1062,7 +1062,7 @@ struct ClearColor {
   typedef ClearColor ValueType;
   static const CommandId kCmdId = kClearColor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1110,7 +1110,7 @@ struct ClearDepthf {
   typedef ClearDepthf ValueType;
   static const CommandId kCmdId = kClearDepthf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1142,7 +1142,7 @@ struct ClearStencil {
   typedef ClearStencil ValueType;
   static const CommandId kCmdId = kClearStencil;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1174,7 +1174,7 @@ struct ClientWaitSync {
   typedef ClientWaitSync ValueType;
   static const CommandId kCmdId = kClientWaitSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   typedef GLenum Result;
 
@@ -1244,7 +1244,7 @@ struct ColorMask {
   typedef ColorMask ValueType;
   static const CommandId kCmdId = kColorMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1295,7 +1295,7 @@ struct CompileShader {
   typedef CompileShader ValueType;
   static const CommandId kCmdId = kCompileShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1327,7 +1327,7 @@ struct CompressedTexImage2DBucket {
   typedef CompressedTexImage2DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexImage2DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1394,7 +1394,7 @@ struct CompressedTexImage2D {
   typedef CompressedTexImage2D ValueType;
   static const CommandId kCmdId = kCompressedTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1473,7 +1473,7 @@ struct CompressedTexSubImage2DBucket {
   typedef CompressedTexSubImage2DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage2DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1550,7 +1550,7 @@ struct CompressedTexSubImage2D {
   typedef CompressedTexSubImage2D ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1640,7 +1640,7 @@ struct CompressedTexImage3DBucket {
   typedef CompressedTexImage3DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexImage3DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1713,7 +1713,7 @@ struct CompressedTexImage3D {
   typedef CompressedTexImage3D ValueType;
   static const CommandId kCmdId = kCompressedTexImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1798,7 +1798,7 @@ struct CompressedTexSubImage3DBucket {
   typedef CompressedTexSubImage3DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage3DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1888,7 +1888,7 @@ struct CompressedTexSubImage3D {
   typedef CompressedTexSubImage3D ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -1990,7 +1990,7 @@ struct CopyBufferSubData {
   typedef CopyBufferSubData ValueType;
   static const CommandId kCmdId = kCopyBufferSubData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2049,7 +2049,7 @@ struct CopyTexImage2D {
   typedef CopyTexImage2D ValueType;
   static const CommandId kCmdId = kCopyTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2121,7 +2121,7 @@ struct CopyTexSubImage2D {
   typedef CopyTexSubImage2D ValueType;
   static const CommandId kCmdId = kCopyTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2198,7 +2198,7 @@ struct CopyTexSubImage3D {
   typedef CopyTexSubImage3D ValueType;
   static const CommandId kCmdId = kCopyTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2281,7 +2281,7 @@ struct CreateProgram {
   typedef CreateProgram ValueType;
   static const CommandId kCmdId = kCreateProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2313,7 +2313,7 @@ struct CreateShader {
   typedef CreateShader ValueType;
   static const CommandId kCmdId = kCreateShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2349,7 +2349,7 @@ struct CullFace {
   typedef CullFace ValueType;
   static const CommandId kCmdId = kCullFace;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2381,7 +2381,7 @@ struct DeleteBuffersImmediate {
   typedef DeleteBuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteBuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2423,7 +2423,7 @@ struct DeleteFramebuffersImmediate {
   typedef DeleteFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteFramebuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2465,7 +2465,7 @@ struct DeleteProgram {
   typedef DeleteProgram ValueType;
   static const CommandId kCmdId = kDeleteProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2497,7 +2497,7 @@ struct DeleteRenderbuffersImmediate {
   typedef DeleteRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteRenderbuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2539,7 +2539,7 @@ struct DeleteSamplersImmediate {
   typedef DeleteSamplersImmediate ValueType;
   static const CommandId kCmdId = kDeleteSamplersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2581,7 +2581,7 @@ struct DeleteSync {
   typedef DeleteSync ValueType;
   static const CommandId kCmdId = kDeleteSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2613,7 +2613,7 @@ struct DeleteShader {
   typedef DeleteShader ValueType;
   static const CommandId kCmdId = kDeleteShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2645,7 +2645,7 @@ struct DeleteTexturesImmediate {
   typedef DeleteTexturesImmediate ValueType;
   static const CommandId kCmdId = kDeleteTexturesImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2687,7 +2687,7 @@ struct DeleteTransformFeedbacksImmediate {
   typedef DeleteTransformFeedbacksImmediate ValueType;
   static const CommandId kCmdId = kDeleteTransformFeedbacksImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -2729,7 +2729,7 @@ struct DepthFunc {
   typedef DepthFunc ValueType;
   static const CommandId kCmdId = kDepthFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2761,7 +2761,7 @@ struct DepthMask {
   typedef DepthMask ValueType;
   static const CommandId kCmdId = kDepthMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2793,7 +2793,7 @@ struct DepthRangef {
   typedef DepthRangef ValueType;
   static const CommandId kCmdId = kDepthRangef;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2829,7 +2829,7 @@ struct DetachShader {
   typedef DetachShader ValueType;
   static const CommandId kCmdId = kDetachShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2865,7 +2865,7 @@ struct Disable {
   typedef Disable ValueType;
   static const CommandId kCmdId = kDisable;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2896,7 +2896,7 @@ struct DisableVertexAttribArray {
   typedef DisableVertexAttribArray ValueType;
   static const CommandId kCmdId = kDisableVertexAttribArray;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2929,7 +2929,7 @@ struct DrawArrays {
   typedef DrawArrays ValueType;
   static const CommandId kCmdId = kDrawArrays;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -2969,7 +2969,7 @@ struct DrawElements {
   typedef DrawElements ValueType;
   static const CommandId kCmdId = kDrawElements;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3017,7 +3017,7 @@ struct Enable {
   typedef Enable ValueType;
   static const CommandId kCmdId = kEnable;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3048,7 +3048,7 @@ struct EnableVertexAttribArray {
   typedef EnableVertexAttribArray ValueType;
   static const CommandId kCmdId = kEnableVertexAttribArray;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3081,7 +3081,7 @@ struct FenceSync {
   typedef FenceSync ValueType;
   static const CommandId kCmdId = kFenceSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3115,7 +3115,7 @@ struct Finish {
   typedef Finish ValueType;
   static const CommandId kCmdId = kFinish;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3141,7 +3141,7 @@ struct Flush {
   typedef Flush ValueType;
   static const CommandId kCmdId = kFlush;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3167,7 +3167,7 @@ struct FramebufferRenderbuffer {
   typedef FramebufferRenderbuffer ValueType;
   static const CommandId kCmdId = kFramebufferRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3221,7 +3221,7 @@ struct FramebufferTexture2D {
   typedef FramebufferTexture2D ValueType;
   static const CommandId kCmdId = kFramebufferTexture2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3280,7 +3280,7 @@ struct FramebufferTextureLayer {
   typedef FramebufferTextureLayer ValueType;
   static const CommandId kCmdId = kFramebufferTextureLayer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3339,7 +3339,7 @@ struct FrontFace {
   typedef FrontFace ValueType;
   static const CommandId kCmdId = kFrontFace;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3371,7 +3371,7 @@ struct GenBuffersImmediate {
   typedef GenBuffersImmediate ValueType;
   static const CommandId kCmdId = kGenBuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3413,7 +3413,7 @@ struct GenerateMipmap {
   typedef GenerateMipmap ValueType;
   static const CommandId kCmdId = kGenerateMipmap;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -3446,7 +3446,7 @@ struct GenFramebuffersImmediate {
   typedef GenFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kGenFramebuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3488,7 +3488,7 @@ struct GenRenderbuffersImmediate {
   typedef GenRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kGenRenderbuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3530,7 +3530,7 @@ struct GenSamplersImmediate {
   typedef GenSamplersImmediate ValueType;
   static const CommandId kCmdId = kGenSamplersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3572,7 +3572,7 @@ struct GenTexturesImmediate {
   typedef GenTexturesImmediate ValueType;
   static const CommandId kCmdId = kGenTexturesImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3614,7 +3614,7 @@ struct GenTransformFeedbacksImmediate {
   typedef GenTransformFeedbacksImmediate ValueType;
   static const CommandId kCmdId = kGenTransformFeedbacksImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -3656,7 +3656,7 @@ struct GetActiveAttrib {
   typedef GetActiveAttrib ValueType;
   static const CommandId kCmdId = kGetActiveAttrib;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
@@ -3730,7 +3730,7 @@ struct GetActiveUniform {
   typedef GetActiveUniform ValueType;
   static const CommandId kCmdId = kGetActiveUniform;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
@@ -3804,7 +3804,7 @@ struct GetActiveUniformBlockiv {
   typedef GetActiveUniformBlockiv ValueType;
   static const CommandId kCmdId = kGetActiveUniformBlockiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -3866,7 +3866,7 @@ struct GetActiveUniformBlockName {
   typedef GetActiveUniformBlockName ValueType;
   static const CommandId kCmdId = kGetActiveUniformBlockName;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef int32_t Result;
 
@@ -3929,7 +3929,7 @@ struct GetActiveUniformsiv {
   typedef GetActiveUniformsiv ValueType;
   static const CommandId kCmdId = kGetActiveUniformsiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -3990,7 +3990,7 @@ struct GetAttachedShaders {
   typedef GetAttachedShaders ValueType;
   static const CommandId kCmdId = kGetAttachedShaders;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
@@ -4045,7 +4045,7 @@ struct GetAttribLocation {
   typedef GetAttribLocation ValueType;
   static const CommandId kCmdId = kGetAttribLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
@@ -4100,7 +4100,7 @@ struct GetBooleanv {
   typedef GetBooleanv ValueType;
   static const CommandId kCmdId = kGetBooleanv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLboolean> Result;
 
@@ -4148,7 +4148,7 @@ struct GetBufferParameteri64v {
   typedef GetBufferParameteri64v ValueType;
   static const CommandId kCmdId = kGetBufferParameteri64v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
@@ -4204,7 +4204,7 @@ struct GetBufferParameteriv {
   typedef GetBufferParameteriv ValueType;
   static const CommandId kCmdId = kGetBufferParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4259,7 +4259,7 @@ struct GetError {
   typedef GetError ValueType;
   static const CommandId kCmdId = kGetError;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLenum Result;
 
@@ -4297,7 +4297,7 @@ struct GetFloatv {
   typedef GetFloatv ValueType;
   static const CommandId kCmdId = kGetFloatv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
@@ -4345,7 +4345,7 @@ struct GetFragDataLocation {
   typedef GetFragDataLocation ValueType;
   static const CommandId kCmdId = kGetFragDataLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
@@ -4400,7 +4400,7 @@ struct GetFramebufferAttachmentParameteriv {
   typedef GetFramebufferAttachmentParameteriv ValueType;
   static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4468,7 +4468,7 @@ struct GetInteger64v {
   typedef GetInteger64v ValueType;
   static const CommandId kCmdId = kGetInteger64v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
@@ -4517,7 +4517,7 @@ struct GetIntegeri_v {
   typedef GetIntegeri_v ValueType;
   static const CommandId kCmdId = kGetIntegeri_v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4572,7 +4572,7 @@ struct GetInteger64i_v {
   typedef GetInteger64i_v ValueType;
   static const CommandId kCmdId = kGetInteger64i_v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
@@ -4627,7 +4627,7 @@ struct GetIntegerv {
   typedef GetIntegerv ValueType;
   static const CommandId kCmdId = kGetIntegerv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4675,7 +4675,7 @@ struct GetInternalformativ {
   typedef GetInternalformativ ValueType;
   static const CommandId kCmdId = kGetInternalformativ;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4736,7 +4736,7 @@ struct GetProgramiv {
   typedef GetProgramiv ValueType;
   static const CommandId kCmdId = kGetProgramiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4790,7 +4790,7 @@ struct GetProgramInfoLog {
   typedef GetProgramInfoLog ValueType;
   static const CommandId kCmdId = kGetProgramInfoLog;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -4827,7 +4827,7 @@ struct GetRenderbufferParameteriv {
   typedef GetRenderbufferParameteriv ValueType;
   static const CommandId kCmdId = kGetRenderbufferParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4884,7 +4884,7 @@ struct GetSamplerParameterfv {
   typedef GetSamplerParameterfv ValueType;
   static const CommandId kCmdId = kGetSamplerParameterfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
@@ -4939,7 +4939,7 @@ struct GetSamplerParameteriv {
   typedef GetSamplerParameteriv ValueType;
   static const CommandId kCmdId = kGetSamplerParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -4994,7 +4994,7 @@ struct GetShaderiv {
   typedef GetShaderiv ValueType;
   static const CommandId kCmdId = kGetShaderiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5048,7 +5048,7 @@ struct GetShaderInfoLog {
   typedef GetShaderInfoLog ValueType;
   static const CommandId kCmdId = kGetShaderInfoLog;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -5085,7 +5085,7 @@ struct GetShaderPrecisionFormat {
   typedef GetShaderPrecisionFormat ValueType;
   static const CommandId kCmdId = kGetShaderPrecisionFormat;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
@@ -5158,7 +5158,7 @@ struct GetShaderSource {
   typedef GetShaderSource ValueType;
   static const CommandId kCmdId = kGetShaderSource;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -5195,7 +5195,7 @@ struct GetString {
   typedef GetString ValueType;
   static const CommandId kCmdId = kGetString;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -5231,7 +5231,7 @@ struct GetSynciv {
   typedef GetSynciv ValueType;
   static const CommandId kCmdId = kGetSynciv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5285,7 +5285,7 @@ struct GetTexParameterfv {
   typedef GetTexParameterfv ValueType;
   static const CommandId kCmdId = kGetTexParameterfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
@@ -5340,7 +5340,7 @@ struct GetTexParameteriv {
   typedef GetTexParameteriv ValueType;
   static const CommandId kCmdId = kGetTexParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5395,7 +5395,7 @@ struct GetTransformFeedbackVarying {
   typedef GetTransformFeedbackVarying ValueType;
   static const CommandId kCmdId = kGetTransformFeedbackVarying;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
@@ -5472,7 +5472,7 @@ struct GetUniformBlockIndex {
   typedef GetUniformBlockIndex ValueType;
   static const CommandId kCmdId = kGetUniformBlockIndex;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLuint Result;
 
@@ -5527,7 +5527,7 @@ struct GetUniformfv {
   typedef GetUniformfv ValueType;
   static const CommandId kCmdId = kGetUniformfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
@@ -5581,7 +5581,7 @@ struct GetUniformiv {
   typedef GetUniformiv ValueType;
   static const CommandId kCmdId = kGetUniformiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5635,7 +5635,7 @@ struct GetUniformuiv {
   typedef GetUniformuiv ValueType;
   static const CommandId kCmdId = kGetUniformuiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
@@ -5690,7 +5690,7 @@ struct GetUniformIndices {
   typedef GetUniformIndices ValueType;
   static const CommandId kCmdId = kGetUniformIndices;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
@@ -5745,7 +5745,7 @@ struct GetUniformLocation {
   typedef GetUniformLocation ValueType;
   static const CommandId kCmdId = kGetUniformLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
@@ -5800,7 +5800,7 @@ struct GetVertexAttribfv {
   typedef GetVertexAttribfv ValueType;
   static const CommandId kCmdId = kGetVertexAttribfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
@@ -5855,7 +5855,7 @@ struct GetVertexAttribiv {
   typedef GetVertexAttribiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5910,7 +5910,7 @@ struct GetVertexAttribIiv {
   typedef GetVertexAttribIiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribIiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
@@ -5965,7 +5965,7 @@ struct GetVertexAttribIuiv {
   typedef GetVertexAttribIuiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribIuiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
@@ -6020,7 +6020,7 @@ struct GetVertexAttribPointerv {
   typedef GetVertexAttribPointerv ValueType;
   static const CommandId kCmdId = kGetVertexAttribPointerv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
@@ -6076,7 +6076,7 @@ struct Hint {
   typedef Hint ValueType;
   static const CommandId kCmdId = kHint;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6109,7 +6109,7 @@ struct InvalidateFramebufferImmediate {
   typedef InvalidateFramebufferImmediate ValueType;
   static const CommandId kCmdId = kInvalidateFramebufferImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
@@ -6158,7 +6158,7 @@ struct InvalidateSubFramebufferImmediate {
   typedef InvalidateSubFramebufferImmediate ValueType;
   static const CommandId kCmdId = kInvalidateSubFramebufferImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
@@ -6235,7 +6235,7 @@ struct IsBuffer {
   typedef IsBuffer ValueType;
   static const CommandId kCmdId = kIsBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6283,7 +6283,7 @@ struct IsEnabled {
   typedef IsEnabled ValueType;
   static const CommandId kCmdId = kIsEnabled;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6329,7 +6329,7 @@ struct IsFramebuffer {
   typedef IsFramebuffer ValueType;
   static const CommandId kCmdId = kIsFramebuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6378,7 +6378,7 @@ struct IsProgram {
   typedef IsProgram ValueType;
   static const CommandId kCmdId = kIsProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6426,7 +6426,7 @@ struct IsRenderbuffer {
   typedef IsRenderbuffer ValueType;
   static const CommandId kCmdId = kIsRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6475,7 +6475,7 @@ struct IsSampler {
   typedef IsSampler ValueType;
   static const CommandId kCmdId = kIsSampler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6523,7 +6523,7 @@ struct IsShader {
   typedef IsShader ValueType;
   static const CommandId kCmdId = kIsShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6571,7 +6571,7 @@ struct IsSync {
   typedef IsSync ValueType;
   static const CommandId kCmdId = kIsSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6618,7 +6618,7 @@ struct IsTexture {
   typedef IsTexture ValueType;
   static const CommandId kCmdId = kIsTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6666,7 +6666,7 @@ struct IsTransformFeedback {
   typedef IsTransformFeedback ValueType;
   static const CommandId kCmdId = kIsTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -6715,7 +6715,7 @@ struct LineWidth {
   typedef LineWidth ValueType;
   static const CommandId kCmdId = kLineWidth;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6747,7 +6747,7 @@ struct LinkProgram {
   typedef LinkProgram ValueType;
   static const CommandId kCmdId = kLinkProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6779,7 +6779,7 @@ struct PauseTransformFeedback {
   typedef PauseTransformFeedback ValueType;
   static const CommandId kCmdId = kPauseTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6806,7 +6806,7 @@ struct PixelStorei {
   typedef PixelStorei ValueType;
   static const CommandId kCmdId = kPixelStorei;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6842,7 +6842,7 @@ struct PolygonOffset {
   typedef PolygonOffset ValueType;
   static const CommandId kCmdId = kPolygonOffset;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6879,7 +6879,7 @@ struct ReadBuffer {
   typedef ReadBuffer ValueType;
   static const CommandId kCmdId = kReadBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -6914,7 +6914,7 @@ struct ReadPixels {
   typedef ReadPixels ValueType;
   static const CommandId kCmdId = kReadPixels;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   typedef uint32_t Result;
 
@@ -7011,7 +7011,7 @@ struct ReleaseShaderCompiler {
   typedef ReleaseShaderCompiler ValueType;
   static const CommandId kCmdId = kReleaseShaderCompiler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7038,7 +7038,7 @@ struct RenderbufferStorage {
   typedef RenderbufferStorage ValueType;
   static const CommandId kCmdId = kRenderbufferStorage;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7091,7 +7091,7 @@ struct ResumeTransformFeedback {
   typedef ResumeTransformFeedback ValueType;
   static const CommandId kCmdId = kResumeTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7118,7 +7118,7 @@ struct SampleCoverage {
   typedef SampleCoverage ValueType;
   static const CommandId kCmdId = kSampleCoverage;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7155,7 +7155,7 @@ struct SamplerParameterf {
   typedef SamplerParameterf ValueType;
   static const CommandId kCmdId = kSamplerParameterf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7196,7 +7196,7 @@ struct SamplerParameterfvImmediate {
   typedef SamplerParameterfvImmediate ValueType;
   static const CommandId kCmdId = kSamplerParameterfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
@@ -7239,7 +7239,7 @@ struct SamplerParameteri {
   typedef SamplerParameteri ValueType;
   static const CommandId kCmdId = kSamplerParameteri;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7280,7 +7280,7 @@ struct SamplerParameterivImmediate {
   typedef SamplerParameterivImmediate ValueType;
   static const CommandId kCmdId = kSamplerParameterivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 1);
@@ -7323,7 +7323,7 @@ struct Scissor {
   typedef Scissor ValueType;
   static const CommandId kCmdId = kScissor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7365,7 +7365,7 @@ struct ShaderBinary {
   typedef ShaderBinary ValueType;
   static const CommandId kCmdId = kShaderBinary;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7436,7 +7436,7 @@ struct ShaderSourceBucket {
   typedef ShaderSourceBucket ValueType;
   static const CommandId kCmdId = kShaderSourceBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7473,7 +7473,7 @@ struct StencilFunc {
   typedef StencilFunc ValueType;
   static const CommandId kCmdId = kStencilFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7513,7 +7513,7 @@ struct StencilFuncSeparate {
   typedef StencilFuncSeparate ValueType;
   static const CommandId kCmdId = kStencilFuncSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7558,7 +7558,7 @@ struct StencilMask {
   typedef StencilMask ValueType;
   static const CommandId kCmdId = kStencilMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7590,7 +7590,7 @@ struct StencilMaskSeparate {
   typedef StencilMaskSeparate ValueType;
   static const CommandId kCmdId = kStencilMaskSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7627,7 +7627,7 @@ struct StencilOp {
   typedef StencilOp ValueType;
   static const CommandId kCmdId = kStencilOp;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7667,7 +7667,7 @@ struct StencilOpSeparate {
   typedef StencilOpSeparate ValueType;
   static const CommandId kCmdId = kStencilOpSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7716,7 +7716,7 @@ struct TexImage2D {
   typedef TexImage2D ValueType;
   static const CommandId kCmdId = kTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7800,7 +7800,7 @@ struct TexImage3D {
   typedef TexImage3D ValueType;
   static const CommandId kCmdId = kTexImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7890,7 +7890,7 @@ struct TexParameterf {
   typedef TexParameterf ValueType;
   static const CommandId kCmdId = kTexParameterf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -7931,7 +7931,7 @@ struct TexParameterfvImmediate {
   typedef TexParameterfvImmediate ValueType;
   static const CommandId kCmdId = kTexParameterfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
@@ -7974,7 +7974,7 @@ struct TexParameteri {
   typedef TexParameteri ValueType;
   static const CommandId kCmdId = kTexParameteri;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8015,7 +8015,7 @@ struct TexParameterivImmediate {
   typedef TexParameterivImmediate ValueType;
   static const CommandId kCmdId = kTexParameterivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 1);
@@ -8058,7 +8058,7 @@ struct TexStorage3D {
   typedef TexStorage3D ValueType;
   static const CommandId kCmdId = kTexStorage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8122,7 +8122,7 @@ struct TexSubImage2D {
   typedef TexSubImage2D ValueType;
   static const CommandId kCmdId = kTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8218,7 +8218,7 @@ struct TexSubImage3D {
   typedef TexSubImage3D ValueType;
   static const CommandId kCmdId = kTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8326,7 +8326,7 @@ struct TransformFeedbackVaryingsBucket {
   typedef TransformFeedbackVaryingsBucket ValueType;
   static const CommandId kCmdId = kTransformFeedbackVaryingsBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8373,7 +8373,7 @@ struct Uniform1f {
   typedef Uniform1f ValueType;
   static const CommandId kCmdId = kUniform1f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8408,7 +8408,7 @@ struct Uniform1fvImmediate {
   typedef Uniform1fvImmediate ValueType;
   static const CommandId kCmdId = kUniform1fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1 * count);  // NOLINT
@@ -8454,7 +8454,7 @@ struct Uniform1i {
   typedef Uniform1i ValueType;
   static const CommandId kCmdId = kUniform1i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8489,7 +8489,7 @@ struct Uniform1ivImmediate {
   typedef Uniform1ivImmediate ValueType;
   static const CommandId kCmdId = kUniform1ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 1 * count);  // NOLINT
@@ -8535,7 +8535,7 @@ struct Uniform1ui {
   typedef Uniform1ui ValueType;
   static const CommandId kCmdId = kUniform1ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8571,7 +8571,7 @@ struct Uniform1uivImmediate {
   typedef Uniform1uivImmediate ValueType;
   static const CommandId kCmdId = kUniform1uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 1 * count);  // NOLINT
@@ -8617,7 +8617,7 @@ struct Uniform2f {
   typedef Uniform2f ValueType;
   static const CommandId kCmdId = kUniform2f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8656,7 +8656,7 @@ struct Uniform2fvImmediate {
   typedef Uniform2fvImmediate ValueType;
   static const CommandId kCmdId = kUniform2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 2 * count);  // NOLINT
@@ -8702,7 +8702,7 @@ struct Uniform2i {
   typedef Uniform2i ValueType;
   static const CommandId kCmdId = kUniform2i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8741,7 +8741,7 @@ struct Uniform2ivImmediate {
   typedef Uniform2ivImmediate ValueType;
   static const CommandId kCmdId = kUniform2ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 2 * count);  // NOLINT
@@ -8787,7 +8787,7 @@ struct Uniform2ui {
   typedef Uniform2ui ValueType;
   static const CommandId kCmdId = kUniform2ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8827,7 +8827,7 @@ struct Uniform2uivImmediate {
   typedef Uniform2uivImmediate ValueType;
   static const CommandId kCmdId = kUniform2uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 2 * count);  // NOLINT
@@ -8873,7 +8873,7 @@ struct Uniform3f {
   typedef Uniform3f ValueType;
   static const CommandId kCmdId = kUniform3f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -8916,7 +8916,7 @@ struct Uniform3fvImmediate {
   typedef Uniform3fvImmediate ValueType;
   static const CommandId kCmdId = kUniform3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 3 * count);  // NOLINT
@@ -8962,7 +8962,7 @@ struct Uniform3i {
   typedef Uniform3i ValueType;
   static const CommandId kCmdId = kUniform3i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9005,7 +9005,7 @@ struct Uniform3ivImmediate {
   typedef Uniform3ivImmediate ValueType;
   static const CommandId kCmdId = kUniform3ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 3 * count);  // NOLINT
@@ -9051,7 +9051,7 @@ struct Uniform3ui {
   typedef Uniform3ui ValueType;
   static const CommandId kCmdId = kUniform3ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9095,7 +9095,7 @@ struct Uniform3uivImmediate {
   typedef Uniform3uivImmediate ValueType;
   static const CommandId kCmdId = kUniform3uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 3 * count);  // NOLINT
@@ -9141,7 +9141,7 @@ struct Uniform4f {
   typedef Uniform4f ValueType;
   static const CommandId kCmdId = kUniform4f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9193,7 +9193,7 @@ struct Uniform4fvImmediate {
   typedef Uniform4fvImmediate ValueType;
   static const CommandId kCmdId = kUniform4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
@@ -9239,7 +9239,7 @@ struct Uniform4i {
   typedef Uniform4i ValueType;
   static const CommandId kCmdId = kUniform4i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9291,7 +9291,7 @@ struct Uniform4ivImmediate {
   typedef Uniform4ivImmediate ValueType;
   static const CommandId kCmdId = kUniform4ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 4 * count);  // NOLINT
@@ -9337,7 +9337,7 @@ struct Uniform4ui {
   typedef Uniform4ui ValueType;
   static const CommandId kCmdId = kUniform4ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9390,7 +9390,7 @@ struct Uniform4uivImmediate {
   typedef Uniform4uivImmediate ValueType;
   static const CommandId kCmdId = kUniform4uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 4 * count);  // NOLINT
@@ -9436,7 +9436,7 @@ struct UniformBlockBinding {
   typedef UniformBlockBinding ValueType;
   static const CommandId kCmdId = kUniformBlockBinding;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9477,7 +9477,7 @@ struct UniformMatrix2fvImmediate {
   typedef UniformMatrix2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
@@ -9524,7 +9524,7 @@ struct UniformMatrix2x3fvImmediate {
   typedef UniformMatrix2x3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2x3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
@@ -9571,7 +9571,7 @@ struct UniformMatrix2x4fvImmediate {
   typedef UniformMatrix2x4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2x4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
@@ -9618,7 +9618,7 @@ struct UniformMatrix3fvImmediate {
   typedef UniformMatrix3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 9 * count);  // NOLINT
@@ -9665,7 +9665,7 @@ struct UniformMatrix3x2fvImmediate {
   typedef UniformMatrix3x2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3x2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
@@ -9712,7 +9712,7 @@ struct UniformMatrix3x4fvImmediate {
   typedef UniformMatrix3x4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3x4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
@@ -9759,7 +9759,7 @@ struct UniformMatrix4fvImmediate {
   typedef UniformMatrix4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 16 * count);  // NOLINT
@@ -9806,7 +9806,7 @@ struct UniformMatrix4x2fvImmediate {
   typedef UniformMatrix4x2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4x2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
@@ -9853,7 +9853,7 @@ struct UniformMatrix4x3fvImmediate {
   typedef UniformMatrix4x3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4x3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
@@ -9900,7 +9900,7 @@ struct UseProgram {
   typedef UseProgram ValueType;
   static const CommandId kCmdId = kUseProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9932,7 +9932,7 @@ struct ValidateProgram {
   typedef ValidateProgram ValueType;
   static const CommandId kCmdId = kValidateProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -9965,7 +9965,7 @@ struct VertexAttrib1f {
   typedef VertexAttrib1f ValueType;
   static const CommandId kCmdId = kVertexAttrib1f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10002,7 +10002,7 @@ struct VertexAttrib1fvImmediate {
   typedef VertexAttrib1fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib1fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
@@ -10041,7 +10041,7 @@ struct VertexAttrib2f {
   typedef VertexAttrib2f ValueType;
   static const CommandId kCmdId = kVertexAttrib2f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10082,7 +10082,7 @@ struct VertexAttrib2fvImmediate {
   typedef VertexAttrib2fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 2);
@@ -10121,7 +10121,7 @@ struct VertexAttrib3f {
   typedef VertexAttrib3f ValueType;
   static const CommandId kCmdId = kVertexAttrib3f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10166,7 +10166,7 @@ struct VertexAttrib3fvImmediate {
   typedef VertexAttrib3fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 3);
@@ -10205,7 +10205,7 @@ struct VertexAttrib4f {
   typedef VertexAttrib4f ValueType;
   static const CommandId kCmdId = kVertexAttrib4f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10259,7 +10259,7 @@ struct VertexAttrib4fvImmediate {
   typedef VertexAttrib4fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4);
@@ -10298,7 +10298,7 @@ struct VertexAttribI4i {
   typedef VertexAttribI4i ValueType;
   static const CommandId kCmdId = kVertexAttribI4i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10347,7 +10347,7 @@ struct VertexAttribI4ivImmediate {
   typedef VertexAttribI4ivImmediate ValueType;
   static const CommandId kCmdId = kVertexAttribI4ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 4);
@@ -10386,7 +10386,7 @@ struct VertexAttribI4ui {
   typedef VertexAttribI4ui ValueType;
   static const CommandId kCmdId = kVertexAttribI4ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10440,7 +10440,7 @@ struct VertexAttribI4uivImmediate {
   typedef VertexAttribI4uivImmediate ValueType;
   static const CommandId kCmdId = kVertexAttribI4uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLuint) * 4);
@@ -10479,7 +10479,7 @@ struct VertexAttribIPointer {
   typedef VertexAttribIPointer ValueType;
   static const CommandId kCmdId = kVertexAttribIPointer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10537,7 +10537,7 @@ struct VertexAttribPointer {
   typedef VertexAttribPointer ValueType;
   static const CommandId kCmdId = kVertexAttribPointer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10602,7 +10602,7 @@ struct Viewport {
   typedef Viewport ValueType;
   static const CommandId kCmdId = kViewport;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10644,7 +10644,7 @@ struct WaitSync {
   typedef WaitSync ValueType;
   static const CommandId kCmdId = kWaitSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10693,7 +10693,7 @@ struct BlitFramebufferCHROMIUM {
   typedef BlitFramebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kBlitFramebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10783,7 +10783,7 @@ struct RenderbufferStorageMultisampleCHROMIUM {
   typedef RenderbufferStorageMultisampleCHROMIUM ValueType;
   static const CommandId kCmdId = kRenderbufferStorageMultisampleCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10850,7 +10850,7 @@ struct RenderbufferStorageMultisampleEXT {
   typedef RenderbufferStorageMultisampleEXT ValueType;
   static const CommandId kCmdId = kRenderbufferStorageMultisampleEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10912,7 +10912,7 @@ struct FramebufferTexture2DMultisampleEXT {
   typedef FramebufferTexture2DMultisampleEXT ValueType;
   static const CommandId kCmdId = kFramebufferTexture2DMultisampleEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -10984,7 +10984,7 @@ struct TexStorage2DEXT {
   typedef TexStorage2DEXT ValueType;
   static const CommandId kCmdId = kTexStorage2DEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11043,7 +11043,7 @@ struct GenQueriesEXTImmediate {
   typedef GenQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kGenQueriesEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -11085,7 +11085,7 @@ struct DeleteQueriesEXTImmediate {
   typedef DeleteQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kDeleteQueriesEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -11127,7 +11127,7 @@ struct QueryCounterEXT {
   typedef QueryCounterEXT ValueType;
   static const CommandId kCmdId = kQueryCounterEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11186,7 +11186,7 @@ struct BeginQueryEXT {
   typedef BeginQueryEXT ValueType;
   static const CommandId kCmdId = kBeginQueryEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11239,7 +11239,7 @@ struct BeginTransformFeedback {
   typedef BeginTransformFeedback ValueType;
   static const CommandId kCmdId = kBeginTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11272,7 +11272,7 @@ struct EndQueryEXT {
   typedef EndQueryEXT ValueType;
   static const CommandId kCmdId = kEndQueryEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11308,7 +11308,7 @@ struct EndTransformFeedback {
   typedef EndTransformFeedback ValueType;
   static const CommandId kCmdId = kEndTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11335,7 +11335,7 @@ struct SetDisjointValueSyncCHROMIUM {
   typedef SetDisjointValueSyncCHROMIUM ValueType;
   static const CommandId kCmdId = kSetDisjointValueSyncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11377,7 +11377,7 @@ struct InsertEventMarkerEXT {
   typedef InsertEventMarkerEXT ValueType;
   static const CommandId kCmdId = kInsertEventMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11410,7 +11410,7 @@ struct PushGroupMarkerEXT {
   typedef PushGroupMarkerEXT ValueType;
   static const CommandId kCmdId = kPushGroupMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11443,7 +11443,7 @@ struct PopGroupMarkerEXT {
   typedef PopGroupMarkerEXT ValueType;
   static const CommandId kCmdId = kPopGroupMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11470,7 +11470,7 @@ struct GenVertexArraysOESImmediate {
   typedef GenVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kGenVertexArraysOESImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -11512,7 +11512,7 @@ struct DeleteVertexArraysOESImmediate {
   typedef DeleteVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kDeleteVertexArraysOESImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -11554,7 +11554,7 @@ struct IsVertexArrayOES {
   typedef IsVertexArrayOES ValueType;
   static const CommandId kCmdId = kIsVertexArrayOES;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -11603,7 +11603,7 @@ struct BindVertexArrayOES {
   typedef BindVertexArrayOES ValueType;
   static const CommandId kCmdId = kBindVertexArrayOES;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11636,7 +11636,7 @@ struct SwapBuffers {
   typedef SwapBuffers ValueType;
   static const CommandId kCmdId = kSwapBuffers;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11662,7 +11662,7 @@ struct GetMaxValueInBufferCHROMIUM {
   typedef GetMaxValueInBufferCHROMIUM ValueType;
   static const CommandId kCmdId = kGetMaxValueInBufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLuint Result;
 
@@ -11731,7 +11731,7 @@ struct EnableFeatureCHROMIUM {
   typedef EnableFeatureCHROMIUM ValueType;
   static const CommandId kCmdId = kEnableFeatureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
@@ -11780,7 +11780,7 @@ struct MapBufferRange {
   typedef MapBufferRange ValueType;
   static const CommandId kCmdId = kMapBufferRange;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   typedef uint32_t Result;
 
@@ -11860,7 +11860,7 @@ struct UnmapBuffer {
   typedef UnmapBuffer ValueType;
   static const CommandId kCmdId = kUnmapBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11892,7 +11892,7 @@ struct ResizeCHROMIUM {
   typedef ResizeCHROMIUM ValueType;
   static const CommandId kCmdId = kResizeCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11944,7 +11944,7 @@ struct GetRequestableExtensionsCHROMIUM {
   typedef GetRequestableExtensionsCHROMIUM ValueType;
   static const CommandId kCmdId = kGetRequestableExtensionsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -11978,7 +11978,7 @@ struct RequestExtensionCHROMIUM {
   typedef RequestExtensionCHROMIUM ValueType;
   static const CommandId kCmdId = kRequestExtensionCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12011,7 +12011,7 @@ struct GetProgramInfoCHROMIUM {
   typedef GetProgramInfoCHROMIUM ValueType;
   static const CommandId kCmdId = kGetProgramInfoCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     uint32_t link_status;
@@ -12063,7 +12063,7 @@ struct GetUniformBlocksCHROMIUM {
   typedef GetUniformBlocksCHROMIUM ValueType;
   static const CommandId kCmdId = kGetUniformBlocksCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -12102,7 +12102,7 @@ struct GetTransformFeedbackVaryingsCHROMIUM {
   typedef GetTransformFeedbackVaryingsCHROMIUM ValueType;
   static const CommandId kCmdId = kGetTransformFeedbackVaryingsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -12144,7 +12144,7 @@ struct GetUniformsES3CHROMIUM {
   typedef GetUniformsES3CHROMIUM ValueType;
   static const CommandId kCmdId = kGetUniformsES3CHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -12183,7 +12183,7 @@ struct GetTranslatedShaderSourceANGLE {
   typedef GetTranslatedShaderSourceANGLE ValueType;
   static const CommandId kCmdId = kGetTranslatedShaderSourceANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12220,7 +12220,7 @@ struct PostSubBufferCHROMIUM {
   typedef PostSubBufferCHROMIUM ValueType;
   static const CommandId kCmdId = kPostSubBufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12265,7 +12265,7 @@ struct TexImageIOSurface2DCHROMIUM {
   typedef TexImageIOSurface2DCHROMIUM ValueType;
   static const CommandId kCmdId = kTexImageIOSurface2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12324,7 +12324,7 @@ struct CopyTextureCHROMIUM {
   typedef CopyTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCopyTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12404,7 +12404,7 @@ struct CopySubTextureCHROMIUM {
   typedef CopySubTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCopySubTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12509,7 +12509,7 @@ struct CompressedCopyTextureCHROMIUM {
   typedef CompressedCopyTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCompressedCopyTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12550,7 +12550,7 @@ struct CompressedCopySubTextureCHROMIUM {
   typedef CompressedCopySubTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCompressedCopySubTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12637,7 +12637,7 @@ struct DrawArraysInstancedANGLE {
   typedef DrawArraysInstancedANGLE ValueType;
   static const CommandId kCmdId = kDrawArraysInstancedANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12686,7 +12686,7 @@ struct DrawElementsInstancedANGLE {
   typedef DrawElementsInstancedANGLE ValueType;
   static const CommandId kCmdId = kDrawElementsInstancedANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12745,7 +12745,7 @@ struct VertexAttribDivisorANGLE {
   typedef VertexAttribDivisorANGLE ValueType;
   static const CommandId kCmdId = kVertexAttribDivisorANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12782,7 +12782,7 @@ struct ProduceTextureCHROMIUMImmediate {
   typedef ProduceTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
@@ -12821,7 +12821,7 @@ struct ProduceTextureDirectCHROMIUMImmediate {
   typedef ProduceTextureDirectCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kProduceTextureDirectCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
@@ -12870,7 +12870,7 @@ struct ConsumeTextureCHROMIUMImmediate {
   typedef ConsumeTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
@@ -12909,7 +12909,7 @@ struct BindUniformLocationCHROMIUMBucket {
   typedef BindUniformLocationCHROMIUMBucket ValueType;
   static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -12956,7 +12956,7 @@ struct GenValuebuffersCHROMIUMImmediate {
   typedef GenValuebuffersCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenValuebuffersCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -12998,7 +12998,7 @@ struct DeleteValuebuffersCHROMIUMImmediate {
   typedef DeleteValuebuffersCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kDeleteValuebuffersCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
@@ -13041,7 +13041,7 @@ struct IsValuebufferCHROMIUM {
   typedef IsValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kIsValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -13090,7 +13090,7 @@ struct BindValuebufferCHROMIUM {
   typedef BindValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kBindValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13127,7 +13127,7 @@ struct SubscribeValueCHROMIUM {
   typedef SubscribeValueCHROMIUM ValueType;
   static const CommandId kCmdId = kSubscribeValueCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13164,7 +13164,7 @@ struct PopulateSubscribedValuesCHROMIUM {
   typedef PopulateSubscribedValuesCHROMIUM ValueType;
   static const CommandId kCmdId = kPopulateSubscribedValuesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13197,7 +13197,7 @@ struct UniformValuebufferCHROMIUM {
   typedef UniformValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kUniformValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13238,7 +13238,7 @@ struct BindTexImage2DCHROMIUM {
   typedef BindTexImage2DCHROMIUM ValueType;
   static const CommandId kCmdId = kBindTexImage2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13275,7 +13275,7 @@ struct ReleaseTexImage2DCHROMIUM {
   typedef ReleaseTexImage2DCHROMIUM ValueType;
   static const CommandId kCmdId = kReleaseTexImage2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13312,7 +13312,7 @@ struct TraceBeginCHROMIUM {
   typedef TraceBeginCHROMIUM ValueType;
   static const CommandId kCmdId = kTraceBeginCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13349,7 +13349,7 @@ struct TraceEndCHROMIUM {
   typedef TraceEndCHROMIUM ValueType;
   static const CommandId kCmdId = kTraceEndCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13376,7 +13376,7 @@ struct DiscardFramebufferEXTImmediate {
   typedef DiscardFramebufferEXTImmediate ValueType;
   static const CommandId kCmdId = kDiscardFramebufferEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
@@ -13425,7 +13425,7 @@ struct LoseContextCHROMIUM {
   typedef LoseContextCHROMIUM ValueType;
   static const CommandId kCmdId = kLoseContextCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13462,7 +13462,7 @@ struct WaitSyncPointCHROMIUM {
   typedef WaitSyncPointCHROMIUM ValueType;
   static const CommandId kCmdId = kWaitSyncPointCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13495,7 +13495,7 @@ struct InsertFenceSyncCHROMIUM {
   typedef InsertFenceSyncCHROMIUM ValueType;
   static const CommandId kCmdId = kInsertFenceSyncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13537,7 +13537,7 @@ struct GenSyncTokenCHROMIUMImmediate {
   typedef GenSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
@@ -13586,7 +13586,7 @@ struct GenUnverifiedSyncTokenCHROMIUMImmediate {
   typedef GenUnverifiedSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenUnverifiedSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
@@ -13638,7 +13638,7 @@ struct VerifySyncTokensCHROMIUMImmediate {
   typedef VerifySyncTokensCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kVerifySyncTokensCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
@@ -13676,7 +13676,7 @@ struct WaitSyncTokenCHROMIUM {
   typedef WaitSyncTokenCHROMIUM ValueType;
   static const CommandId kCmdId = kWaitSyncTokenCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13743,7 +13743,7 @@ struct DrawBuffersEXTImmediate {
   typedef DrawBuffersEXTImmediate ValueType;
   static const CommandId kCmdId = kDrawBuffersEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
@@ -13785,7 +13785,7 @@ struct DiscardBackbufferCHROMIUM {
   typedef DiscardBackbufferCHROMIUM ValueType;
   static const CommandId kCmdId = kDiscardBackbufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13812,7 +13812,7 @@ struct ScheduleOverlayPlaneCHROMIUM {
   typedef ScheduleOverlayPlaneCHROMIUM ValueType;
   static const CommandId kCmdId = kScheduleOverlayPlaneCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13914,7 +13914,7 @@ struct ScheduleCALayerCHROMIUM {
   typedef ScheduleCALayerCHROMIUM ValueType;
   static const CommandId kCmdId = kScheduleCALayerCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -13995,7 +13995,7 @@ struct CommitOverlayPlanesCHROMIUM {
   typedef CommitOverlayPlanesCHROMIUM ValueType;
   static const CommandId kCmdId = kCommitOverlayPlanesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14022,7 +14022,7 @@ struct SwapInterval {
   typedef SwapInterval ValueType;
   static const CommandId kCmdId = kSwapInterval;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14054,7 +14054,7 @@ struct FlushDriverCachesCHROMIUM {
   typedef FlushDriverCachesCHROMIUM ValueType;
   static const CommandId kCmdId = kFlushDriverCachesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14081,7 +14081,7 @@ struct MatrixLoadfCHROMIUMImmediate {
   typedef MatrixLoadfCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kMatrixLoadfCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 16);
@@ -14120,7 +14120,7 @@ struct MatrixLoadIdentityCHROMIUM {
   typedef MatrixLoadIdentityCHROMIUM ValueType;
   static const CommandId kCmdId = kMatrixLoadIdentityCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14153,7 +14153,7 @@ struct GenPathsCHROMIUM {
   typedef GenPathsCHROMIUM ValueType;
   static const CommandId kCmdId = kGenPathsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14190,7 +14190,7 @@ struct DeletePathsCHROMIUM {
   typedef DeletePathsCHROMIUM ValueType;
   static const CommandId kCmdId = kDeletePathsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14227,7 +14227,7 @@ struct IsPathCHROMIUM {
   typedef IsPathCHROMIUM ValueType;
   static const CommandId kCmdId = kIsPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
@@ -14276,7 +14276,7 @@ struct PathCommandsCHROMIUM {
   typedef PathCommandsCHROMIUM ValueType;
   static const CommandId kCmdId = kPathCommandsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14355,7 +14355,7 @@ struct PathParameterfCHROMIUM {
   typedef PathParameterfCHROMIUM ValueType;
   static const CommandId kCmdId = kPathParameterfCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14396,7 +14396,7 @@ struct PathParameteriCHROMIUM {
   typedef PathParameteriCHROMIUM ValueType;
   static const CommandId kCmdId = kPathParameteriCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14437,7 +14437,7 @@ struct PathStencilFuncCHROMIUM {
   typedef PathStencilFuncCHROMIUM ValueType;
   static const CommandId kCmdId = kPathStencilFuncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14478,7 +14478,7 @@ struct StencilFillPathCHROMIUM {
   typedef StencilFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14519,7 +14519,7 @@ struct StencilStrokePathCHROMIUM {
   typedef StencilStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14560,7 +14560,7 @@ struct CoverFillPathCHROMIUM {
   typedef CoverFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14597,7 +14597,7 @@ struct CoverStrokePathCHROMIUM {
   typedef CoverStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14634,7 +14634,7 @@ struct StencilThenCoverFillPathCHROMIUM {
   typedef StencilThenCoverFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14685,7 +14685,7 @@ struct StencilThenCoverStrokePathCHROMIUM {
   typedef StencilThenCoverStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14737,7 +14737,7 @@ struct StencilFillPathInstancedCHROMIUM {
   typedef StencilFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14839,7 +14839,7 @@ struct StencilStrokePathInstancedCHROMIUM {
   typedef StencilStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -14943,7 +14943,7 @@ struct CoverFillPathInstancedCHROMIUM {
   typedef CoverFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15037,7 +15037,7 @@ struct CoverStrokePathInstancedCHROMIUM {
   typedef CoverStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15133,7 +15133,7 @@ struct StencilThenCoverFillPathInstancedCHROMIUM {
   typedef StencilThenCoverFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15251,7 +15251,7 @@ struct StencilThenCoverStrokePathInstancedCHROMIUM {
   typedef StencilThenCoverStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15371,7 +15371,7 @@ struct BindFragmentInputLocationCHROMIUMBucket {
   typedef BindFragmentInputLocationCHROMIUMBucket ValueType;
   static const CommandId kCmdId = kBindFragmentInputLocationCHROMIUMBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15420,7 +15420,7 @@ struct ProgramPathFragmentInputGenCHROMIUM {
   typedef ProgramPathFragmentInputGenCHROMIUM ValueType;
   static const CommandId kCmdId = kProgramPathFragmentInputGenCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15494,7 +15494,7 @@ struct BlendBarrierKHR {
   typedef BlendBarrierKHR ValueType;
   static const CommandId kCmdId = kBlendBarrierKHR;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15521,7 +15521,7 @@ struct ApplyScreenSpaceAntialiasingCHROMIUM {
   typedef ApplyScreenSpaceAntialiasingCHROMIUM ValueType;
   static const CommandId kCmdId = kApplyScreenSpaceAntialiasingCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15549,7 +15549,7 @@ struct BindFragDataLocationIndexedEXTBucket {
   typedef BindFragDataLocationIndexedEXTBucket ValueType;
   static const CommandId kCmdId = kBindFragDataLocationIndexedEXTBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15608,7 +15608,7 @@ struct BindFragDataLocationEXTBucket {
   typedef BindFragDataLocationEXTBucket ValueType;
   static const CommandId kCmdId = kBindFragDataLocationEXTBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ -15654,7 +15654,7 @@ struct GetFragDataIndexEXT {
   typedef GetFragDataIndexEXT ValueType;
   static const CommandId kCmdId = kGetFragDataIndexEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test.cc b/gpu/command_buffer/common/gles2_cmd_format_test.cc
index d11b2c5..4403886 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test.cc
+++ b/gpu/command_buffer/common/gles2_cmd_format_test.cc
@@ -4,6 +4,9 @@
 
 // This file contains unit tests for gles2 commmands
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 
 #include "base/bind.h"
@@ -50,8 +53,8 @@ class GLES2FormatTest : public testing::Test {
   unsigned char buffer_[1024];
 };
 
-void SignalCompletion(uint32* assigned_async_token_ptr,
-                      uint32 async_token,
+void SignalCompletion(uint32_t* assigned_async_token_ptr,
+                      uint32_t async_token,
                       AsyncUploadSync* sync) {
   EXPECT_EQ(async_token, *assigned_async_token_ptr);
   sync->SetAsyncUploadToken(async_token);
@@ -69,11 +72,11 @@ TEST(GLES2FormatAsyncUploadSyncTest, AsyncUploadSync) {
     AsyncUploadSync sync;
     sync.Reset();
 
-    uint32 buffer_tokens[kSize];
+    uint32_t buffer_tokens[kSize];
     memset(buffer_tokens, 0, sizeof(buffer_tokens));
 
     // Start with a token large enough so that we'll wrap.
-    uint32 async_token = std::numeric_limits<uint32>::max() - kCount / 2;
+    uint32_t async_token = std::numeric_limits<uint32_t>::max() - kCount / 2;
 
     // Set initial async token.
     sync.SetAsyncUploadToken(async_token);
diff --git a/gpu/command_buffer/common/gles2_cmd_utils.cc b/gpu/command_buffer/common/gles2_cmd_utils.cc
index c0a5cd5..0d07f4e 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils.cc
+++ b/gpu/command_buffer/common/gles2_cmd_utils.cc
@@ -501,7 +501,7 @@ int BytesPerElement(int type) {
 
 }  // anonymous namespace
 
-uint32 GLES2Util::ComputeImageGroupSize(int format, int type) {
+uint32_t GLES2Util::ComputeImageGroupSize(int format, int type) {
   int bytes_per_element = BytesPerElement(type);
   DCHECK_GE(8, bytes_per_element);
   int elements_per_group = ElementsPerGroup(format, type);
@@ -509,20 +509,22 @@ uint32 GLES2Util::ComputeImageGroupSize(int format, int type) {
   return  bytes_per_element * elements_per_group;
 }
 
-bool GLES2Util::ComputeImageRowSizeHelper(
-    int width, uint32 bytes_per_group, int alignment,
-    uint32* rt_unpadded_row_size, uint32* rt_padded_row_size) {
+bool GLES2Util::ComputeImageRowSizeHelper(int width,
+                                          uint32_t bytes_per_group,
+                                          int alignment,
+                                          uint32_t* rt_unpadded_row_size,
+                                          uint32_t* rt_padded_row_size) {
   DCHECK(alignment == 1 || alignment == 2 ||
          alignment == 4 || alignment == 8);
-  uint32 unpadded_row_size;
+  uint32_t unpadded_row_size;
   if (!SafeMultiplyUint32(width, bytes_per_group, &unpadded_row_size)) {
     return false;
   }
-  uint32 temp;
+  uint32_t temp;
   if (!SafeAddUint32(unpadded_row_size, alignment - 1, &temp)) {
     return false;
   }
-  uint32 padded_row_size = (temp / alignment) * alignment;
+  uint32_t padded_row_size = (temp / alignment) * alignment;
   if (rt_unpadded_row_size)
     *rt_unpadded_row_size = unpadded_row_size;
   if (rt_padded_row_size)
@@ -530,18 +532,26 @@ bool GLES2Util::ComputeImageRowSizeHelper(
   return true;
 }
 
-bool GLES2Util::ComputeImagePaddedRowSize(
-    int width, int format, int type, int alignment, uint32* padded_row_size) {
-  uint32 bytes_per_group = ComputeImageGroupSize(format, type);
+bool GLES2Util::ComputeImagePaddedRowSize(int width,
+                                          int format,
+                                          int type,
+                                          int alignment,
+                                          uint32_t* padded_row_size) {
+  uint32_t bytes_per_group = ComputeImageGroupSize(format, type);
   return ComputeImageRowSizeHelper(
       width, bytes_per_group, alignment, nullptr, padded_row_size);
 }
 
 // Returns the amount of data glTexImage*D or glTexSubImage*D will access.
-bool GLES2Util::ComputeImageDataSizes(
-    int width, int height, int depth, int format, int type,
-    int alignment, uint32* size, uint32* opt_unpadded_row_size,
-    uint32* opt_padded_row_size) {
+bool GLES2Util::ComputeImageDataSizes(int width,
+                                      int height,
+                                      int depth,
+                                      int format,
+                                      int type,
+                                      int alignment,
+                                      uint32_t* size,
+                                      uint32_t* opt_unpadded_row_size,
+                                      uint32_t* opt_padded_row_size) {
   PixelStoreParams params;
   params.alignment = alignment;
   return ComputeImageDataSizesES3(
@@ -556,10 +566,10 @@ bool GLES2Util::ComputeImageDataSizesES3(
     uint32_t* opt_padded_row_size, uint32_t* opt_skip_size) {
   DCHECK(width >= 0 && height >= 0 && depth >= 0);
 
-  uint32 bytes_per_group = ComputeImageGroupSize(format, type);
+  uint32_t bytes_per_group = ComputeImageGroupSize(format, type);
 
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
+  uint32_t unpadded_row_size;
+  uint32_t padded_row_size;
   if (!ComputeImageRowSizeHelper(width, bytes_per_group, params.alignment,
                                  &unpadded_row_size, &padded_row_size)) {
     return false;
@@ -573,7 +583,7 @@ bool GLES2Util::ComputeImageDataSizesES3(
   }
 
   int image_height = params.image_height > 0 ? params.image_height : height;
-  uint32 num_of_rows;
+  uint32_t num_of_rows;
   if (depth > 0) {
     if (!SafeMultiplyUint32(image_height, depth - 1, &num_of_rows) ||
         !SafeAddUint32(num_of_rows, height, &num_of_rows)) {
@@ -584,7 +594,7 @@ bool GLES2Util::ComputeImageDataSizesES3(
   }
 
   if (num_of_rows > 0) {
-    uint32 size_of_all_but_last_row;
+    uint32_t size_of_all_but_last_row;
     if (!SafeMultiplyUint32((num_of_rows - 1), padded_row_size,
                             &size_of_all_but_last_row)) {
       return false;
@@ -596,29 +606,29 @@ bool GLES2Util::ComputeImageDataSizesES3(
     *size = 0;
   }
 
-  uint32 skip_size = 0;
+  uint32_t skip_size = 0;
   if (params.skip_images > 0) {
-    uint32 image_size;
+    uint32_t image_size;
     if (!SafeMultiplyUint32(image_height, padded_row_size, &image_size))
       return false;
     if (!SafeMultiplyUint32(image_size, params.skip_images, &skip_size))
       return false;
   }
   if (params.skip_rows > 0) {
-    uint32 temp;
+    uint32_t temp;
     if (!SafeMultiplyUint32(padded_row_size, params.skip_rows, &temp))
       return false;
     if (!SafeAddUint32(skip_size, temp, &skip_size))
       return false;
   }
   if (params.skip_pixels > 0) {
-    uint32 temp;
+    uint32_t temp;
     if (!SafeMultiplyUint32(bytes_per_group, params.skip_pixels, &temp))
       return false;
     if (!SafeAddUint32(skip_size, temp, &skip_size))
       return false;
   }
-  uint32 total_size;
+  uint32_t total_size;
   if (!SafeAddUint32(*size, skip_size, &total_size))
     return false;
 
@@ -654,7 +664,7 @@ size_t GLES2Util::RenderbufferBytesPerPixel(int format) {
   }
 }
 
-uint32 GLES2Util::GetElementSizeForUniformType(int type) {
+uint32_t GLES2Util::GetElementSizeForUniformType(int type) {
   switch (type) {
     case GL_FLOAT:
     case GL_FLOAT_VEC2:
@@ -711,7 +721,7 @@ uint32 GLES2Util::GetElementSizeForUniformType(int type) {
   }
 }
 
-uint32 GLES2Util::GetElementCountForUniformType(int type) {
+uint32_t GLES2Util::GetElementCountForUniformType(int type) {
   switch (type) {
     case GL_FLOAT:
     case GL_INT:
@@ -776,7 +786,7 @@ uint32 GLES2Util::GetElementCountForUniformType(int type) {
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
@@ -799,7 +809,7 @@ size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32 type) {
   }
 }
 
-size_t GLES2Util::GetComponentCountForGLTransformType(uint32 type) {
+size_t GLES2Util::GetComponentCountForGLTransformType(uint32_t type) {
   switch (type) {
     case GL_TRANSLATE_X_CHROMIUM:
     case GL_TRANSLATE_Y_CHROMIUM:
@@ -833,7 +843,7 @@ size_t GLES2Util::GetCoefficientCountForGLPathFragmentInputGenMode(
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForPathCoordType(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForPathCoordType(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
@@ -850,7 +860,7 @@ size_t GLES2Util::GetGLTypeSizeForPathCoordType(uint32 type) {
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForGLPathNameType(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForGLPathNameType(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
@@ -869,7 +879,7 @@ size_t GLES2Util::GetGLTypeSizeForGLPathNameType(uint32 type) {
   }
 }
 
-uint32 GLES2Util::GLErrorToErrorBit(uint32 error) {
+uint32_t GLES2Util::GLErrorToErrorBit(uint32_t error) {
   switch (error) {
     case GL_INVALID_ENUM:
       return gl_error_bit::kInvalidEnum;
@@ -889,7 +899,7 @@ uint32 GLES2Util::GLErrorToErrorBit(uint32 error) {
   }
 }
 
-uint32 GLES2Util::GLErrorBitToGLError(uint32 error_bit) {
+uint32_t GLES2Util::GLErrorBitToGLError(uint32_t error_bit) {
   switch (error_bit) {
     case gl_error_bit::kInvalidEnum:
       return GL_INVALID_ENUM;
@@ -909,19 +919,16 @@ uint32 GLES2Util::GLErrorBitToGLError(uint32 error_bit) {
   }
 }
 
-uint32 GLES2Util::IndexToGLFaceTarget(int index) {
-  static uint32 faces[] = {
-    GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
-    GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
-    GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+uint32_t GLES2Util::IndexToGLFaceTarget(int index) {
+  static uint32_t faces[] = {
+      GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
   };
   return faces[index];
 }
 
-size_t GLES2Util::GLTargetToFaceIndex(uint32 target) {
+size_t GLES2Util::GLTargetToFaceIndex(uint32_t target) {
   switch (target) {
     case GL_TEXTURE_2D:
     case GL_TEXTURE_EXTERNAL_OES:
@@ -947,8 +954,8 @@ size_t GLES2Util::GLTargetToFaceIndex(uint32 target) {
   }
 }
 
-uint32 GLES2Util::GetGLReadPixelsImplementationFormat(
-    uint32 internal_format) {
+uint32_t GLES2Util::GetGLReadPixelsImplementationFormat(
+    uint32_t internal_format) {
   switch (internal_format) {
     case GL_R8:
     case GL_R16F:
@@ -992,8 +999,8 @@ uint32 GLES2Util::GetGLReadPixelsImplementationFormat(
   }
 }
 
-uint32 GLES2Util::GetGLReadPixelsImplementationType(
-    uint32 internal_format, uint32 texture_type) {
+uint32_t GLES2Util::GetGLReadPixelsImplementationType(uint32_t internal_format,
+                                                      uint32_t texture_type) {
   switch (internal_format) {
     case GL_R16UI:
     case GL_RG16UI:
@@ -1048,7 +1055,7 @@ uint32 GLES2Util::GetGLReadPixelsImplementationType(
   }
 }
 
-uint32 GLES2Util::GetChannelsForFormat(int format) {
+uint32_t GLES2Util::GetChannelsForFormat(int format) {
   switch (format) {
     case GL_ALPHA:
     case GL_ALPHA16F_EXT:
@@ -1136,8 +1143,9 @@ uint32 GLES2Util::GetChannelsForFormat(int format) {
   }
 }
 
-uint32 GLES2Util::GetChannelsNeededForAttachmentType(
-    int type, uint32 max_color_attachments) {
+uint32_t GLES2Util::GetChannelsNeededForAttachmentType(
+    int type,
+    uint32_t max_color_attachments) {
   switch (type) {
     case GL_DEPTH_ATTACHMENT:
       return kDepth;
@@ -1153,7 +1161,7 @@ uint32 GLES2Util::GetChannelsNeededForAttachmentType(
   }
 }
 
-std::string GLES2Util::GetStringEnum(uint32 value) {
+std::string GLES2Util::GetStringEnum(uint32_t value) {
   const EnumToString* entry = enum_to_string_table_;
   const EnumToString* end = entry + enum_to_string_table_len_;
   for (;entry < end; ++entry) {
@@ -1168,7 +1176,7 @@ std::string GLES2Util::GetStringEnum(uint32 value) {
   return "0x" + ss.str();
 }
 
-std::string GLES2Util::GetStringError(uint32 value) {
+std::string GLES2Util::GetStringError(uint32_t value) {
   static EnumToString string_table[] = {
     { GL_NONE, "GL_NONE" },
   };
@@ -1176,12 +1184,13 @@ std::string GLES2Util::GetStringError(uint32 value) {
       string_table, arraysize(string_table), value);
 }
 
-std::string GLES2Util::GetStringBool(uint32 value) {
+std::string GLES2Util::GetStringBool(uint32_t value) {
   return value ? "GL_TRUE" : "GL_FALSE";
 }
 
-std::string GLES2Util::GetQualifiedEnumString(
-    const EnumToString* table, size_t count, uint32 value) {
+std::string GLES2Util::GetQualifiedEnumString(const EnumToString* table,
+                                              size_t count,
+                                              uint32_t value) {
   for (const EnumToString* end = table + count; table < end; ++table) {
     if (table->value == value) {
       return table->name;
@@ -1203,7 +1212,7 @@ GLSLArrayName::GLSLArrayName(const std::string& name) : element_index_(-1) {
   base::CheckedNumeric<int> index = 0;
   size_t last = name.size() - 1;
   for (size_t pos = open_pos + 1; pos < last; ++pos) {
-    int8 digit = name[pos] - '0';
+    int8_t digit = name[pos] - '0';
     if (digit < 0 || digit > 9)
       return;
     index = index * 10 + digit;
@@ -1342,24 +1351,26 @@ namespace {
 // are unique to Chromium. Attributes are matched using a closest fit algorithm.
 
 // From <EGL/egl.h>.
-const int32 kAlphaSize       = 0x3021;  // EGL_ALPHA_SIZE
-const int32 kBlueSize        = 0x3022;  // EGL_BLUE_SIZE
-const int32 kGreenSize       = 0x3023;  // EGL_GREEN_SIZE
-const int32 kRedSize         = 0x3024;  // EGL_RED_SIZE
-const int32 kDepthSize       = 0x3025;  // EGL_DEPTH_SIZE
-const int32 kStencilSize     = 0x3026;  // EGL_STENCIL_SIZE
-const int32 kSamples         = 0x3031;  // EGL_SAMPLES
-const int32 kSampleBuffers   = 0x3032;  // EGL_SAMPLE_BUFFERS
-const int32 kNone            = 0x3038;  // EGL_NONE
-const int32 kSwapBehavior    = 0x3093;  // EGL_SWAP_BEHAVIOR
-const int32 kBufferPreserved = 0x3094;  // EGL_BUFFER_PRESERVED
-const int32 kBufferDestroyed = 0x3095;  // EGL_BUFFER_DESTROYED
+#include <stddef.h>
+#include <stdint.h>
+const int32_t kAlphaSize = 0x3021;        // EGL_ALPHA_SIZE
+const int32_t kBlueSize = 0x3022;         // EGL_BLUE_SIZE
+const int32_t kGreenSize = 0x3023;        // EGL_GREEN_SIZE
+const int32_t kRedSize = 0x3024;          // EGL_RED_SIZE
+const int32_t kDepthSize = 0x3025;        // EGL_DEPTH_SIZE
+const int32_t kStencilSize = 0x3026;      // EGL_STENCIL_SIZE
+const int32_t kSamples = 0x3031;          // EGL_SAMPLES
+const int32_t kSampleBuffers = 0x3032;    // EGL_SAMPLE_BUFFERS
+const int32_t kNone = 0x3038;             // EGL_NONE
+const int32_t kSwapBehavior = 0x3093;     // EGL_SWAP_BEHAVIOR
+const int32_t kBufferPreserved = 0x3094;  // EGL_BUFFER_PRESERVED
+const int32_t kBufferDestroyed = 0x3095;  // EGL_BUFFER_DESTROYED
 
 // Chromium only.
-const int32 kBindGeneratesResource = 0x10000;
-const int32 kFailIfMajorPerfCaveat = 0x10001;
-const int32 kLoseContextWhenOutOfMemory = 0x10002;
-const int32 kContextType = 0x10003;
+const int32_t kBindGeneratesResource = 0x10000;
+const int32_t kFailIfMajorPerfCaveat = 0x10001;
+const int32_t kLoseContextWhenOutOfMemory = 0x10002;
+const int32_t kContextType = 0x10003;
 
 }  // namespace
 
@@ -1378,7 +1389,8 @@ ContextCreationAttribHelper::ContextCreationAttribHelper()
       lose_context_when_out_of_memory(false),
       context_type(CONTEXT_TYPE_OPENGLES2) {}
 
-void ContextCreationAttribHelper::Serialize(std::vector<int32>* attribs) const {
+void ContextCreationAttribHelper::Serialize(
+    std::vector<int32_t>* attribs) const {
   if (alpha_size != -1) {
     attribs->push_back(kAlphaSize);
     attribs->push_back(alpha_size);
@@ -1424,9 +1436,9 @@ void ContextCreationAttribHelper::Serialize(std::vector<int32>* attribs) const {
   attribs->push_back(kNone);
 }
 
-bool ContextCreationAttribHelper::Parse(const std::vector<int32>& attribs) {
+bool ContextCreationAttribHelper::Parse(const std::vector<int32_t>& attribs) {
   for (size_t i = 0; i < attribs.size(); i += 2) {
-    const int32 attrib = attribs[i];
+    const int32_t attrib = attribs[i];
     if (i + 1 >= attribs.size()) {
       if (attrib == kNone) {
         return true;
@@ -1437,7 +1449,7 @@ bool ContextCreationAttribHelper::Parse(const std::vector<int32>& attribs) {
       return false;
     }
 
-    const int32 value = attribs[i+1];
+    const int32_t value = attribs[i + 1];
     switch (attrib) {
       case kAlphaSize:
         alpha_size = value;
diff --git a/gpu/command_buffer/common/gles2_cmd_utils.h b/gpu/command_buffer/common/gles2_cmd_utils.h
index e3b82b8..ea79b2b 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils.h
@@ -8,6 +8,7 @@
 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_UTILS_H_
 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_UTILS_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ -219,9 +220,11 @@ class GLES2_UTILS_EXPORT GLES2Util {
   static std::string GetQualifiedEnumString(
       const EnumToString* table, size_t count, uint32_t value);
 
-  static bool ComputeImageRowSizeHelper(
-      int width, uint32 bytes_per_group, int alignment,
-      uint32* rt_unpadded_row_size, uint32* rt_padded_row_size);
+  static bool ComputeImageRowSizeHelper(int width,
+                                        uint32_t bytes_per_group,
+                                        int alignment,
+                                        uint32_t* rt_unpadded_row_size,
+                                        uint32_t* rt_padded_row_size);
 
   static const EnumToString* const enum_to_string_table_;
   static const size_t enum_to_string_table_len_;
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_unittest.cc b/gpu/command_buffer/common/gles2_cmd_utils_unittest.cc
index a435f28..e2b0950 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_unittest.cc
+++ b/gpu/command_buffer/common/gles2_cmd_utils_unittest.cc
@@ -9,6 +9,7 @@
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stdint.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/gpu/command_buffer/common/gpu_memory_allocation.h b/gpu/command_buffer/common/gpu_memory_allocation.h
index facbd7f..675b955 100644
--- a/gpu/command_buffer/common/gpu_memory_allocation.h
+++ b/gpu/command_buffer/common/gpu_memory_allocation.h
@@ -5,7 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_COMMON_GPU_MEMORY_ALLOCATION_H_
 #define GPU_COMMAND_BUFFER_COMMON_GPU_MEMORY_ALLOCATION_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
 
 namespace gpu {
 
@@ -29,7 +29,7 @@ struct MemoryAllocation {
   };
 
   // Limits when this renderer is visible.
-  uint64 bytes_limit_when_visible;
+  uint64_t bytes_limit_when_visible;
   PriorityCutoff priority_cutoff_when_visible;
 
   MemoryAllocation()
@@ -37,10 +37,9 @@ struct MemoryAllocation {
         priority_cutoff_when_visible(CUTOFF_ALLOW_NOTHING) {
   }
 
-  MemoryAllocation(uint64 bytes_limit_when_visible)
+  MemoryAllocation(uint64_t bytes_limit_when_visible)
       : bytes_limit_when_visible(bytes_limit_when_visible),
-        priority_cutoff_when_visible(CUTOFF_ALLOW_EVERYTHING) {
-  }
+        priority_cutoff_when_visible(CUTOFF_ALLOW_EVERYTHING) {}
 
   bool Equals(const MemoryAllocation& other) const {
     return bytes_limit_when_visible ==
diff --git a/gpu/command_buffer/common/id_allocator.cc b/gpu/command_buffer/common/id_allocator.cc
index 80e109a..13a4aba 100644
--- a/gpu/command_buffer/common/id_allocator.cc
+++ b/gpu/command_buffer/common/id_allocator.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/common/id_allocator.h"
 
+#include <stdint.h>
+
 #include <limits>
 #include "base/logging.h"
 
@@ -142,7 +144,7 @@ void IdAllocator::FreeID(ResourceId id) {
   FreeIDRange(id, 1u);
 }
 
-void IdAllocator::FreeIDRange(ResourceId first_id, uint32 range) {
+void IdAllocator::FreeIDRange(ResourceId first_id, uint32_t range) {
   static_assert(kInvalidResource == 0u, "kInvalidResource must be 0");
 
   if (range == 0u || (first_id == 0u && range == 1u)) {
diff --git a/gpu/command_buffer/common/id_allocator_test.cc b/gpu/command_buffer/common/id_allocator_test.cc
index 7d93906..9e0c184 100644
--- a/gpu/command_buffer/common/id_allocator_test.cc
+++ b/gpu/command_buffer/common/id_allocator_test.cc
@@ -4,6 +4,8 @@
 
 // This file has the unit tests for the IdAllocator class.
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/gpu/command_buffer/common/mailbox.cc b/gpu/command_buffer/common/mailbox.cc
index 21602ab..8ca3d53 100644
--- a/gpu/command_buffer/common/mailbox.cc
+++ b/gpu/command_buffer/common/mailbox.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/common/mailbox.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "base/logging.h"
@@ -27,7 +29,7 @@ void Mailbox::SetZero() {
   memset(name, 0, sizeof(name));
 }
 
-void Mailbox::SetName(const int8* n) {
+void Mailbox::SetName(const int8_t* n) {
   DCHECK(IsZero() || !memcmp(name, n, sizeof(name)));
   memcpy(name, n, sizeof(name));
 }
@@ -37,7 +39,7 @@ Mailbox Mailbox::Generate() {
   // Generates cryptographically-secure bytes.
   base::RandBytes(result.name, sizeof(result.name));
 #if !defined(NDEBUG)
-  int8 value = 1;
+  int8_t value = 1;
   for (size_t i = 1; i < sizeof(result.name); ++i)
     value ^= result.name[i];
   result.name[0] = value;
@@ -47,7 +49,7 @@ Mailbox Mailbox::Generate() {
 
 bool Mailbox::Verify() const {
 #if !defined(NDEBUG)
-  int8 value = 1;
+  int8_t value = 1;
   for (size_t i = 0; i < sizeof(name); ++i)
     value ^= name[i];
   return value == 0;
diff --git a/gpu/command_buffer/common/mailbox_holder.cc b/gpu/command_buffer/common/mailbox_holder.cc
index f496e66..7f3bbe5 100644
--- a/gpu/command_buffer/common/mailbox_holder.cc
+++ b/gpu/command_buffer/common/mailbox_holder.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/mailbox_holder.h"
 
 namespace gpu {
diff --git a/gpu/command_buffer/common/time.h b/gpu/command_buffer/common/time.h
index e58145b..8886966 100644
--- a/gpu/command_buffer/common/time.h
+++ b/gpu/command_buffer/common/time.h
@@ -7,11 +7,13 @@
 
 #if !defined(__native_client__)
 
+#include <stdint.h>
+
 #include "base/time/time.h"
 
 namespace gpu {
 
-inline uint64 MicrosecondsSinceOriginOfTime() {
+inline uint64_t MicrosecondsSinceOriginOfTime() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds();
 }
 
@@ -21,7 +23,7 @@ inline uint64 MicrosecondsSinceOriginOfTime() {
 
 namespace gpu {
 
-inline uint64 MicrosecondsSinceOriginOfTime() {
+inline uint64_t MicrosecondsSinceOriginOfTime() {
   return 0;
 }
 
diff --git a/gpu/command_buffer/common/value_state.h b/gpu/command_buffer/common/value_state.h
index 4789245..ca7675f 100644
--- a/gpu/command_buffer/common/value_state.h
+++ b/gpu/command_buffer/common/value_state.h
@@ -6,6 +6,7 @@
 #define GPU_COMMAND_BUFFER_COMMON_VALUE_STATE_H_
 
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/buffer_manager.cc b/gpu/command_buffer/service/buffer_manager.cc
index 50b03b5..498185f 100644
--- a/gpu/command_buffer/service/buffer_manager.cc
+++ b/gpu/command_buffer/service/buffer_manager.cc
@@ -3,7 +3,11 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/buffer_manager.h"
+
+#include <stdint.h>
+
 #include <limits>
+
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ -143,7 +147,7 @@ void Buffer::SetInfo(
     shadowed_ = shadow;
     size_ = size;
     if (shadowed_) {
-      shadow_.reset(new int8[size]);
+      shadow_.reset(new int8_t[size]);
     } else {
       shadow_.reset();
     }
@@ -160,10 +164,10 @@ void Buffer::SetInfo(
 
 bool Buffer::CheckRange(
     GLintptr offset, GLsizeiptr size) const {
-  int32 end = 0;
+  int32_t end = 0;
   return offset >= 0 && size >= 0 &&
-         offset <= std::numeric_limits<int32>::max() &&
-         size <= std::numeric_limits<int32>::max() &&
+         offset <= std::numeric_limits<int32_t>::max() &&
+         size <= std::numeric_limits<int32_t>::max() &&
          SafeAddInt32(offset, size, &end) && end <= size_;
 }
 
@@ -197,8 +201,8 @@ void Buffer::ClearCache() {
 template <typename T>
 GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count) {
   GLuint max_value = 0;
-  const T* element = reinterpret_cast<const T*>(
-      static_cast<const int8*>(data) + offset);
+  const T* element =
+      reinterpret_cast<const T*>(static_cast<const int8_t*>(data) + offset);
   const T* end = element + count;
   for (; element < end; ++element) {
     if (*element > max_value) {
@@ -217,7 +221,7 @@ bool Buffer::GetMaxValueForRange(
     return true;
   }
 
-  uint32 size;
+  uint32_t size;
   if (!SafeMultiplyUint32(
       count, GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type), &size)) {
     return false;
@@ -227,7 +231,7 @@ bool Buffer::GetMaxValueForRange(
     return false;
   }
 
-  if (size > static_cast<uint32>(size_)) {
+  if (size > static_cast<uint32_t>(size_)) {
     return false;
   }
 
@@ -239,21 +243,21 @@ bool Buffer::GetMaxValueForRange(
   GLuint max_v = 0;
   switch (type) {
     case GL_UNSIGNED_BYTE:
-      max_v = GetMaxValue<uint8>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint8_t>(shadow_.get(), offset, count);
       break;
     case GL_UNSIGNED_SHORT:
       // Check we are not accessing an odd byte for a 2 byte value.
       if ((offset & 1) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint16>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint16_t>(shadow_.get(), offset, count);
       break;
     case GL_UNSIGNED_INT:
       // Check we are not accessing a non aligned address for a 4 byte value.
       if ((offset & 3) != 0) {
         return false;
       }
-      max_v = GetMaxValue<uint32>(shadow_.get(), offset, count);
+      max_v = GetMaxValue<uint32_t>(shadow_.get(), offset, count);
       break;
     default:
       NOTREACHED();  // should never get here by validation.
@@ -347,9 +351,9 @@ void BufferManager::DoBufferData(
     GLenum usage,
     const GLvoid* data) {
   // Clear the buffer to 0 if no initial data was passed in.
-  scoped_ptr<int8[]> zero;
+  scoped_ptr<int8_t[]> zero;
   if (!data) {
-    zero.reset(new int8[size]);
+    zero.reset(new int8_t[size]);
     memset(zero.get(), 0, size);
     data = zero.get();
   }
diff --git a/gpu/command_buffer/service/buffer_manager.h b/gpu/command_buffer/service/buffer_manager.h
index 2f64e0d..33df818 100644
--- a/gpu/command_buffer/service/buffer_manager.h
+++ b/gpu/command_buffer/service/buffer_manager.h
@@ -5,10 +5,13 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_BUFFER_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/common/buffer.h"
@@ -164,7 +167,7 @@ class GPU_EXPORT Buffer : public base::RefCounted<Buffer> {
 
   // A copy of the data in the buffer. This data is only kept if the target
   // is backed_ = true.
-  scoped_ptr<int8[]> shadow_;
+  scoped_ptr<int8_t[]> shadow_;
 
   // Size of buffer.
   GLsizeiptr size_;
diff --git a/gpu/command_buffer/service/buffer_manager_unittest.cc b/gpu/command_buffer/service/buffer_manager_unittest.cc
index faf7828..4c6707a 100644
--- a/gpu/command_buffer/service/buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/buffer_manager_unittest.cc
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ -193,7 +196,7 @@ TEST_F(BufferManagerTest, DoBufferSubData) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint8_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
@@ -208,7 +211,7 @@ TEST_F(BufferManagerTest, DoBufferSubData) {
   EXPECT_FALSE(DoBufferSubData(buffer, kTarget, 0, -1, data));
   DoBufferData(buffer, kTarget, 1, GL_STATIC_DRAW, NULL, GL_NO_ERROR);
   const int size = 0x20000;
-  scoped_ptr<uint8[]> temp(new uint8[size]);
+  scoped_ptr<uint8_t[]> temp(new uint8_t[size]);
   EXPECT_FALSE(DoBufferSubData(buffer, kTarget, 0 - size, size, temp.get()));
   EXPECT_FALSE(DoBufferSubData(buffer, kTarget, 1, size / 2, temp.get()));
 }
@@ -243,8 +246,8 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  const uint8 new_data[] = {100, 120, 110};
+  const uint8_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint8_t new_data[] = {100, 120, 110};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
@@ -281,8 +284,8 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  const uint16 new_data[] = {100, 120, 110};
+  const uint16_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint16_t new_data[] = {100, 120, 110};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
@@ -322,8 +325,8 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  const uint32 new_data[] = {100, 120, 110};
+  const uint32_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint32_t new_data[] = {100, 120, 110};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
@@ -386,7 +389,7 @@ TEST_F(BufferManagerClientSideArraysTest, StreamBuffersAreShadowed) {
   const GLenum kTarget = GL_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  static const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  static const uint32_t data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
@@ -404,9 +407,9 @@ TEST_F(BufferManagerTest, MaxValueCacheClearedCorrectly) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
-  const uint32 data1[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  const uint32 data2[] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
-  const uint32 data3[] = {30, 29, 28};
+  const uint32_t data1[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  const uint32_t data2[] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+  const uint32_t data3[] = {30, 29, 28};
   manager_->CreateBuffer(kClientBufferId, kServiceBufferId);
   Buffer* buffer = manager_->GetBuffer(kClientBufferId);
   ASSERT_TRUE(buffer != NULL);
diff --git a/gpu/command_buffer/service/cmd_buffer_engine.h b/gpu/command_buffer/service/cmd_buffer_engine.h
index 75e6069..eaf8309 100644
--- a/gpu/command_buffer/service/cmd_buffer_engine.h
+++ b/gpu/command_buffer/service/cmd_buffer_engine.h
@@ -8,7 +8,9 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_CMD_BUFFER_ENGINE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_CMD_BUFFER_ENGINE_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "gpu/command_buffer/common/buffer.h"
 
 namespace gpu {
@@ -24,19 +26,19 @@ class CommandBufferEngine {
   // Gets the base address and size of a registered shared memory buffer.
   // Parameters:
   //   shm_id: the identifier for the shared memory buffer.
-  virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) = 0;
+  virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32_t shm_id) = 0;
 
   // Sets the token value.
-  virtual void set_token(int32 token) = 0;
+  virtual void set_token(int32_t token) = 0;
 
   // Sets the shared memory buffer used for commands.
-  virtual bool SetGetBuffer(int32 transfer_buffer_id) = 0;
+  virtual bool SetGetBuffer(int32_t transfer_buffer_id) = 0;
 
   // Sets the "get" pointer. Return false if offset is out of range.
-  virtual bool SetGetOffset(int32 offset) = 0;
+  virtual bool SetGetOffset(int32_t offset) = 0;
 
   // Gets the "get" pointer.
-  virtual int32 GetGetOffset() = 0;
+  virtual int32_t GetGetOffset() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CommandBufferEngine);
diff --git a/gpu/command_buffer/service/cmd_parser.cc b/gpu/command_buffer/service/cmd_parser.cc
index d7dfc59..3c4c39e 100644
--- a/gpu/command_buffer/service/cmd_parser.cc
+++ b/gpu/command_buffer/service/cmd_parser.cc
@@ -6,6 +6,8 @@
 
 #include "gpu/command_buffer/service/cmd_parser.h"
 
+#include <stddef.h>
+
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 
diff --git a/gpu/command_buffer/service/cmd_parser.h b/gpu/command_buffer/service/cmd_parser.h
index ac52d86..a8187d7 100644
--- a/gpu/command_buffer/service/cmd_parser.h
+++ b/gpu/command_buffer/service/cmd_parser.h
@@ -7,8 +7,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_CMD_PARSER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_CMD_PARSER_H_
 
-#include "gpu/command_buffer/common/constants.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
+#include "gpu/command_buffer/common/constants.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
@@ -66,7 +69,7 @@ class GPU_EXPORT CommandParser {
   CommandBufferOffset get_;
   CommandBufferOffset put_;
   CommandBufferEntry* buffer_;
-  int32 entry_count_;
+  int32_t entry_count_;
   AsyncAPIInterface* handler_;
 };
 
diff --git a/gpu/command_buffer/service/cmd_parser_test.cc b/gpu/command_buffer/service/cmd_parser_test.cc
index d880830..7df519d 100644
--- a/gpu/command_buffer/service/cmd_parser_test.cc
+++ b/gpu/command_buffer/service/cmd_parser_test.cc
@@ -4,6 +4,8 @@
 
 // Tests for the command parser.
 
+#include <stddef.h>
+
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/cmd_parser.h"
diff --git a/gpu/command_buffer/service/command_buffer_service.cc b/gpu/command_buffer/service/command_buffer_service.cc
index 7781438..368bc1c 100644
--- a/gpu/command_buffer/service/command_buffer_service.cc
+++ b/gpu/command_buffer/service/command_buffer_service.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/command_buffer_service.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 
 #include "base/logging.h"
@@ -48,7 +51,7 @@ CommandBufferService::State CommandBufferService::GetLastState() {
   return state;
 }
 
-int32 CommandBufferService::GetLastToken() {
+int32_t CommandBufferService::GetLastToken() {
   return GetLastState().token;
 }
 
@@ -59,15 +62,15 @@ void CommandBufferService::UpdateState() {
   }
 }
 
-void CommandBufferService::WaitForTokenInRange(int32 start, int32 end) {
+void CommandBufferService::WaitForTokenInRange(int32_t start, int32_t end) {
   DCHECK(error_ != error::kNoError || InRange(start, end, token_));
 }
 
-void CommandBufferService::WaitForGetOffsetInRange(int32 start, int32 end) {
+void CommandBufferService::WaitForGetOffsetInRange(int32_t start, int32_t end) {
   DCHECK(error_ != error::kNoError || InRange(start, end, get_offset_));
 }
 
-void CommandBufferService::Flush(int32 put_offset) {
+void CommandBufferService::Flush(int32_t put_offset) {
   if (put_offset < 0 || put_offset > num_entries_) {
     error_ = gpu::error::kOutOfBounds;
     return;
@@ -79,18 +82,18 @@ void CommandBufferService::Flush(int32 put_offset) {
     put_offset_change_callback_.Run();
 }
 
-void CommandBufferService::OrderingBarrier(int32 put_offset) {
+void CommandBufferService::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
-void CommandBufferService::SetGetBuffer(int32 transfer_buffer_id) {
+void CommandBufferService::SetGetBuffer(int32_t transfer_buffer_id) {
   DCHECK_EQ(-1, ring_buffer_id_);
   DCHECK_EQ(put_offset_, get_offset_);  // Only if it's empty.
   // If the buffer is invalid we handle it gracefully.
   // This means ring_buffer_ can be NULL.
   ring_buffer_ = GetTransferBuffer(transfer_buffer_id);
   ring_buffer_id_ = transfer_buffer_id;
-  int32 size = ring_buffer_.get() ? ring_buffer_->size() : 0;
+  int32_t size = ring_buffer_.get() ? ring_buffer_->size() : 0;
   num_entries_ = size / sizeof(CommandBufferEntry);
   put_offset_ = 0;
   SetGetOffset(0);
@@ -112,13 +115,13 @@ void CommandBufferService::SetSharedStateBuffer(
   UpdateState();
 }
 
-void CommandBufferService::SetGetOffset(int32 get_offset) {
+void CommandBufferService::SetGetOffset(int32_t get_offset) {
   DCHECK(get_offset >= 0 && get_offset < num_entries_);
   get_offset_ = get_offset;
 }
 
 scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
-                                                                 int32* id) {
+                                                                 int32_t* id) {
   *id = -1;
 
   scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
@@ -128,7 +131,7 @@ scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
     return NULL;
   }
 
-  static int32 next_id = 1;
+  static int32_t next_id = 1;
   *id = next_id++;
 
   if (!RegisterTransferBuffer(
@@ -142,7 +145,7 @@ scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
   return GetTransferBuffer(*id);
 }
 
-void CommandBufferService::DestroyTransferBuffer(int32 id) {
+void CommandBufferService::DestroyTransferBuffer(int32_t id) {
   transfer_buffer_manager_->DestroyTransferBuffer(id);
   if (id == ring_buffer_id_) {
     ring_buffer_id_ = -1;
@@ -153,18 +156,18 @@ void CommandBufferService::DestroyTransferBuffer(int32 id) {
   }
 }
 
-scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32 id) {
+scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32_t id) {
   return transfer_buffer_manager_->GetTransferBuffer(id);
 }
 
 bool CommandBufferService::RegisterTransferBuffer(
-    int32 id,
+    int32_t id,
     scoped_ptr<BufferBacking> buffer) {
   return transfer_buffer_manager_->RegisterTransferBuffer(id,
                                                           std::move(buffer));
 }
 
-void CommandBufferService::SetToken(int32 token) {
+void CommandBufferService::SetToken(int32_t token) {
   token_ = token;
   UpdateState();
 }
@@ -182,7 +185,7 @@ void CommandBufferService::SetContextLostReason(
   context_lost_reason_ = reason;
 }
 
-int32 CommandBufferService::GetPutOffset() {
+int32_t CommandBufferService::GetPutOffset() {
   return put_offset_;
 }
 
diff --git a/gpu/command_buffer/service/command_buffer_service.h b/gpu/command_buffer/service/command_buffer_service.h
index ddcfec3..560bf16 100644
--- a/gpu/command_buffer/service/command_buffer_service.h
+++ b/gpu/command_buffer/service/command_buffer_service.h
@@ -5,7 +5,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_COMMAND_BUFFER_SERVICE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_COMMAND_BUFFER_SERVICE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/callback.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 
@@ -16,14 +20,14 @@ class TransferBufferManagerInterface;
 class GPU_EXPORT CommandBufferServiceBase : public CommandBuffer {
  public:
   // Sets the current get offset. This can be called from any thread.
-  virtual void SetGetOffset(int32 get_offset) = 0;
+  virtual void SetGetOffset(int32_t get_offset) = 0;
 
   // Get the transfer buffer associated with an ID. Returns a null buffer for
   // ID 0.
-  virtual scoped_refptr<gpu::Buffer> GetTransferBuffer(int32 id) = 0;
+  virtual scoped_refptr<gpu::Buffer> GetTransferBuffer(int32_t id) = 0;
 
   // Allows the reader to update the current token value.
-  virtual void SetToken(int32 token) = 0;
+  virtual void SetToken(int32_t token) = 0;
 
   // Allows the reader to set the current parse error.
   virtual void SetParseError(error::Error) = 0;
@@ -34,14 +38,14 @@ class GPU_EXPORT CommandBufferServiceBase : public CommandBuffer {
   virtual void SetContextLostReason(error::ContextLostReason) = 0;
 
   // Allows the reader to obtain the current put offset.
-  virtual int32 GetPutOffset() = 0;
+  virtual int32_t GetPutOffset() = 0;
 };
 
 // An object that implements a shared memory command buffer and a synchronous
 // API to manage the put and get pointers.
 class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
  public:
-  typedef base::Callback<bool(int32)> GetBufferChangedCallback;
+  typedef base::Callback<bool(int32_t)> GetBufferChangedCallback;
   explicit CommandBufferService(
       TransferBufferManagerInterface* transfer_buffer_manager);
   ~CommandBufferService() override;
@@ -49,22 +53,22 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   // CommandBuffer implementation:
   bool Initialize() override;
   State GetLastState() override;
-  int32 GetLastToken() override;
-  void Flush(int32 put_offset) override;
-  void OrderingBarrier(int32 put_offset) override;
-  void WaitForTokenInRange(int32 start, int32 end) override;
-  void WaitForGetOffsetInRange(int32 start, int32 end) override;
-  void SetGetBuffer(int32 transfer_buffer_id) override;
-  scoped_refptr<Buffer> CreateTransferBuffer(size_t size, int32* id) override;
-  void DestroyTransferBuffer(int32 id) override;
+  int32_t GetLastToken() override;
+  void Flush(int32_t put_offset) override;
+  void OrderingBarrier(int32_t put_offset) override;
+  void WaitForTokenInRange(int32_t start, int32_t end) override;
+  void WaitForGetOffsetInRange(int32_t start, int32_t end) override;
+  void SetGetBuffer(int32_t transfer_buffer_id) override;
+  scoped_refptr<Buffer> CreateTransferBuffer(size_t size, int32_t* id) override;
+  void DestroyTransferBuffer(int32_t id) override;
 
   // CommandBufferServiceBase implementation:
-  void SetGetOffset(int32 get_offset) override;
-  scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
-  void SetToken(int32 token) override;
+  void SetGetOffset(int32_t get_offset) override;
+  scoped_refptr<Buffer> GetTransferBuffer(int32_t id) override;
+  void SetToken(int32_t token) override;
   void SetParseError(error::Error error) override;
   void SetContextLostReason(error::ContextLostReason) override;
-  int32 GetPutOffset() override;
+  int32_t GetPutOffset() override;
 
   // Sets a callback that is called whenever the put offset is changed. When
   // called with sync==true, the callback must not return until some progress
@@ -88,22 +92,22 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
 
   // Registers an existing shared memory object and get an ID that can be used
   // to identify it in the command buffer.
-  bool RegisterTransferBuffer(int32 id, scoped_ptr<BufferBacking> buffer);
+  bool RegisterTransferBuffer(int32_t id, scoped_ptr<BufferBacking> buffer);
 
  private:
-  int32 ring_buffer_id_;
+  int32_t ring_buffer_id_;
   scoped_refptr<Buffer> ring_buffer_;
   scoped_ptr<BufferBacking> shared_state_buffer_;
   CommandBufferSharedState* shared_state_;
-  int32 num_entries_;
-  int32 get_offset_;
-  int32 put_offset_;
+  int32_t num_entries_;
+  int32_t get_offset_;
+  int32_t put_offset_;
   base::Closure put_offset_change_callback_;
   GetBufferChangedCallback get_buffer_change_callback_;
   base::Closure parse_error_callback_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
-  int32 token_;
-  uint32 generation_;
+  int32_t token_;
+  uint32_t generation_;
   error::Error error_;
   error::ContextLostReason context_lost_reason_;
 
diff --git a/gpu/command_buffer/service/command_buffer_service_unittest.cc b/gpu/command_buffer/service/command_buffer_service_unittest.cc
index 1113fa5..5b39a96 100644
--- a/gpu/command_buffer/service/command_buffer_service_unittest.cc
+++ b/gpu/command_buffer/service/command_buffer_service_unittest.cc
@@ -2,14 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/threading/thread.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 using base::SharedMemory;
 using testing::_;
@@ -33,24 +36,16 @@ class CommandBufferServiceTest : public testing::Test {
     EXPECT_TRUE(command_buffer_->Initialize());
   }
 
-  int32 GetGetOffset() {
-    return command_buffer_->GetLastState().get_offset;
-  }
+  int32_t GetGetOffset() { return command_buffer_->GetLastState().get_offset; }
 
-  int32 GetPutOffset() {
-    return command_buffer_->GetPutOffset();
-  }
+  int32_t GetPutOffset() { return command_buffer_->GetPutOffset(); }
 
-  int32 GetToken() {
-    return command_buffer_->GetLastState().token;
-  }
+  int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
-  int32 GetError() {
-    return command_buffer_->GetLastState().error;
-  }
+  int32_t GetError() { return command_buffer_->GetLastState().error; }
 
   bool Initialize(size_t size) {
-    int32 id;
+    int32_t id;
     command_buffer_->CreateTransferBuffer(size, &id);
     EXPECT_GT(id, 0);
     command_buffer_->SetGetBuffer(id);
@@ -75,13 +70,13 @@ namespace {
 class CallbackTest {
  public:
   virtual void PutOffsetChanged() = 0;
-  virtual bool GetBufferChanged(int32 id) = 0;
+  virtual bool GetBufferChanged(int32_t id) = 0;
 };
 
 class MockCallbackTest : public CallbackTest {
  public:
    MOCK_METHOD0(PutOffsetChanged, void());
-   MOCK_METHOD1(GetBufferChanged, bool(int32));
+   MOCK_METHOD1(GetBufferChanged, bool(int32_t));
 };
 
 }  // anonymous namespace
@@ -118,7 +113,7 @@ TEST_F(CommandBufferServiceTest, CanSyncGetAndPutOffset) {
 }
 
 TEST_F(CommandBufferServiceTest, SetGetBuffer) {
-  int32 ring_buffer_id;
+  int32_t ring_buffer_id;
   command_buffer_->CreateTransferBuffer(1024, &ring_buffer_id);
   EXPECT_GT(ring_buffer_id, 0);
 
diff --git a/gpu/command_buffer/service/common_decoder.cc b/gpu/command_buffer/service/common_decoder.cc
index b945205..a15c496 100644
--- a/gpu/command_buffer/service/common_decoder.cc
+++ b/gpu/command_buffer/service/common_decoder.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/common_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/numerics/safe_math.h"
@@ -37,7 +40,7 @@ void* CommonDecoder::Bucket::GetData(size_t offset, size_t size) const {
 
 void CommonDecoder::Bucket::SetSize(size_t size) {
   if (size != size_) {
-    data_.reset(size ? new int8[size] : NULL);
+    data_.reset(size ? new int8_t[size] : NULL);
     size_ = size;
     memset(data_.get(), 0, size);
   }
@@ -144,12 +147,12 @@ const char* CommonDecoder::GetCommonCommandName(
   return cmd::GetCommandName(command_id);
 }
 
-CommonDecoder::Bucket* CommonDecoder::GetBucket(uint32 bucket_id) const {
+CommonDecoder::Bucket* CommonDecoder::GetBucket(uint32_t bucket_id) const {
   BucketMap::const_iterator iter(buckets_.find(bucket_id));
   return iter != buckets_.end() ? &(*iter->second) : NULL;
 }
 
-CommonDecoder::Bucket* CommonDecoder::CreateBucket(uint32 bucket_id) {
+CommonDecoder::Bucket* CommonDecoder::CreateBucket(uint32_t bucket_id) {
   Bucket* bucket = GetBucket(bucket_id);
   if (!bucket) {
     bucket = new Bucket();
@@ -163,7 +166,7 @@ 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.
@@ -187,7 +190,7 @@ error::Error CommonDecoder::DoCommonCommand(
     unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
         (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
-      uint32 immediate_data_size =
+      uint32_t immediate_data_size =
           (arg_count - info_arg_count) * sizeof(CommandBufferEntry);  // NOLINT
       return (this->*info.cmd_handler)(immediate_data_size, cmd_data);
     } else {
@@ -197,41 +200,37 @@ error::Error CommonDecoder::DoCommonCommand(
   return error::kUnknownCommand;
 }
 
-error::Error CommonDecoder::HandleNoop(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleNoop(uint32_t immediate_data_size,
+                                       const void* cmd_data) {
   return error::kNoError;
 }
 
-error::Error CommonDecoder::HandleSetToken(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleSetToken(uint32_t immediate_data_size,
+                                           const void* cmd_data) {
   const cmd::SetToken& args = *static_cast<const cmd::SetToken*>(cmd_data);
   engine_->set_token(args.token);
   return error::kNoError;
 }
 
-error::Error CommonDecoder::HandleSetBucketSize(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleSetBucketSize(uint32_t immediate_data_size,
+                                                const void* cmd_data) {
   const cmd::SetBucketSize& args =
       *static_cast<const cmd::SetBucketSize*>(cmd_data);
-  uint32 bucket_id = args.bucket_id;
-  uint32 size = args.size;
+  uint32_t bucket_id = args.bucket_id;
+  uint32_t size = args.size;
 
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(size);
   return error::kNoError;
 }
 
-error::Error CommonDecoder::HandleSetBucketData(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleSetBucketData(uint32_t immediate_data_size,
+                                                const void* cmd_data) {
   const cmd::SetBucketData& args =
       *static_cast<const cmd::SetBucketData*>(cmd_data);
-  uint32 bucket_id = args.bucket_id;
-  uint32 offset = args.offset;
-  uint32 size = args.size;
+  uint32_t bucket_id = args.bucket_id;
+  uint32_t offset = args.offset;
+  uint32_t size = args.size;
   const void* data = GetSharedMemoryAs<const void*>(
       args.shared_memory_id, args.shared_memory_offset, size);
   if (!data) {
@@ -249,14 +248,14 @@ error::Error CommonDecoder::HandleSetBucketData(
 }
 
 error::Error CommonDecoder::HandleSetBucketDataImmediate(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const cmd::SetBucketDataImmediate& args =
       *static_cast<const cmd::SetBucketDataImmediate*>(cmd_data);
   const void* data = GetImmediateDataAs<const void*>(args);
-  uint32 bucket_id = args.bucket_id;
-  uint32 offset = args.offset;
-  uint32 size = args.size;
+  uint32_t bucket_id = args.bucket_id;
+  uint32_t offset = args.offset;
+  uint32_t size = args.size;
   if (size > immediate_data_size) {
     return error::kInvalidArguments;
   }
@@ -270,20 +269,19 @@ error::Error CommonDecoder::HandleSetBucketDataImmediate(
   return error::kNoError;
 }
 
-error::Error CommonDecoder::HandleGetBucketStart(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleGetBucketStart(uint32_t immediate_data_size,
+                                                 const void* cmd_data) {
   const cmd::GetBucketStart& args =
       *static_cast<const cmd::GetBucketStart*>(cmd_data);
-  uint32 bucket_id = args.bucket_id;
-  uint32* result = GetSharedMemoryAs<uint32*>(
+  uint32_t bucket_id = args.bucket_id;
+  uint32_t* result = GetSharedMemoryAs<uint32_t*>(
       args.result_memory_id, args.result_memory_offset, sizeof(*result));
-  int32 data_memory_id = args.data_memory_id;
-  uint32 data_memory_offset = args.data_memory_offset;
-  uint32 data_memory_size = args.data_memory_size;
-  uint8* data = NULL;
+  int32_t data_memory_id = args.data_memory_id;
+  uint32_t data_memory_offset = args.data_memory_offset;
+  uint32_t data_memory_size = args.data_memory_size;
+  uint8_t* data = NULL;
   if (data_memory_size != 0 || data_memory_id != 0 || data_memory_offset != 0) {
-    data = GetSharedMemoryAs<uint8*>(
+    data = GetSharedMemoryAs<uint8_t*>(
         args.data_memory_id, args.data_memory_offset, args.data_memory_size);
     if (!data) {
       return error::kInvalidArguments;
@@ -300,23 +298,22 @@ error::Error CommonDecoder::HandleGetBucketStart(
   if (!bucket) {
     return error::kInvalidArguments;
   }
-  uint32 bucket_size = bucket->size();
+  uint32_t bucket_size = bucket->size();
   *result = bucket_size;
   if (data) {
-    uint32 size = std::min(data_memory_size, bucket_size);
+    uint32_t size = std::min(data_memory_size, bucket_size);
     memcpy(data, bucket->GetData(0, size), size);
   }
   return error::kNoError;
 }
 
-error::Error CommonDecoder::HandleGetBucketData(
-    uint32 immediate_data_size,
-    const void* cmd_data) {
+error::Error CommonDecoder::HandleGetBucketData(uint32_t immediate_data_size,
+                                                const void* cmd_data) {
   const cmd::GetBucketData& args =
       *static_cast<const cmd::GetBucketData*>(cmd_data);
-  uint32 bucket_id = args.bucket_id;
-  uint32 offset = args.offset;
-  uint32 size = args.size;
+  uint32_t bucket_id = args.bucket_id;
+  uint32_t offset = args.offset;
+  uint32_t size = args.size;
   void* data = GetSharedMemoryAs<void*>(
       args.shared_memory_id, args.shared_memory_offset, size);
   if (!data) {
diff --git a/gpu/command_buffer/service/common_decoder.h b/gpu/command_buffer/service/common_decoder.h
index 53de875..147b776 100644
--- a/gpu/command_buffer/service/common_decoder.h
+++ b/gpu/command_buffer/service/common_decoder.h
@@ -5,9 +5,13 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_COMMON_DECODER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_COMMON_DECODER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <stack>
 #include <string>
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/common/buffer.h"
@@ -100,7 +104,7 @@ class GPU_EXPORT CommonDecoder : NON_EXPORTED_BASE(public AsyncAPIInterface) {
     }
 
     size_t size_;
-    ::scoped_ptr<int8[]> data_;
+    ::scoped_ptr<int8_t[]> data_;
 
     DISALLOW_COPY_AND_ASSIGN(Bucket);
   };
@@ -116,10 +120,10 @@ class GPU_EXPORT CommonDecoder : NON_EXPORTED_BASE(public AsyncAPIInterface) {
   CommandBufferEngine* engine() const { return engine_; }
 
   // Creates a bucket. If the bucket already exists returns that bucket.
-  Bucket* CreateBucket(uint32 bucket_id);
+  Bucket* CreateBucket(uint32_t bucket_id);
 
   // Gets a bucket. Returns NULL if the bucket does not exist.
-  Bucket* GetBucket(uint32 bucket_id) const;
+  Bucket* GetBucket(uint32_t bucket_id) const;
 
   // Gets the address of shared memory data, given a shared memory ID and an
   // offset. Also checks that the size is consistent with the shared memory
@@ -165,8 +169,8 @@ class GPU_EXPORT CommonDecoder : NON_EXPORTED_BASE(public AsyncAPIInterface) {
  private:
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
-  #define COMMON_COMMAND_BUFFER_CMD_OP(name)             \
-     error::Error Handle##name(uint32 immediate_data_size, const void* data);
+#define COMMON_COMMAND_BUFFER_CMD_OP(name) \
+  error::Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   COMMON_COMMAND_BUFFER_CMDS(COMMON_COMMAND_BUFFER_CMD_OP)
 
@@ -174,19 +178,18 @@ class GPU_EXPORT CommonDecoder : NON_EXPORTED_BASE(public AsyncAPIInterface) {
 
   CommandBufferEngine* engine_;
 
-  typedef std::map<uint32, linked_ptr<Bucket> > BucketMap;
+  typedef std::map<uint32_t, linked_ptr<Bucket>> BucketMap;
   BucketMap buckets_;
 
-  typedef Error (CommonDecoder::*CmdHandler)(
-      uint32 immediate_data_size,
-      const void* data);
+  typedef Error (CommonDecoder::*CmdHandler)(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.
diff --git a/gpu/command_buffer/service/common_decoder_unittest.cc b/gpu/command_buffer/service/common_decoder_unittest.cc
index 73029bf..ac4ba1c 100644
--- a/gpu/command_buffer/service/common_decoder_unittest.cc
+++ b/gpu/command_buffer/service/common_decoder_unittest.cc
@@ -2,8 +2,11 @@
 // 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/common_decoder.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
+#include "gpu/command_buffer/service/common_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
@@ -62,19 +65,19 @@ class TestCommonDecoder : public CommonDecoder {
     return DoCommonCommand(command, arg_count, cmd_data);
   }
 
-  CommonDecoder::Bucket* GetBucket(uint32 id) const {
+  CommonDecoder::Bucket* GetBucket(uint32_t id) const {
     return CommonDecoder::GetBucket(id);
   }
 };
 
 class MockCommandBufferEngine : public CommandBufferEngine {
  public:
-  static const int32 kStartValidShmId = 1;
-  static const int32 kValidShmId = 2;
-  static const int32 kInvalidShmId = 3;
+  static const int32_t kStartValidShmId = 1;
+  static const int32_t kValidShmId = 2;
+  static const int32_t kInvalidShmId = 3;
   static const size_t kBufferSize = 1024;
-  static const int32 kValidOffset = kBufferSize / 2;
-  static const int32 kInvalidOffset = kBufferSize;
+  static const int32_t kValidOffset = kBufferSize / 2;
+  static const int32_t kInvalidOffset = kBufferSize;
 
   MockCommandBufferEngine()
       : CommandBufferEngine(),
@@ -86,42 +89,40 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override {
+  scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32_t shm_id) override {
     if (IsValidSharedMemoryId(shm_id))
       return buffer_;
     return NULL;
   }
 
   template <typename T>
-  T GetSharedMemoryAs(uint32 offset) {
+  T GetSharedMemoryAs(uint32_t offset) {
     DCHECK_LT(offset, kBufferSize);
-    int8* buffer_memory = static_cast<int8*>(buffer_->memory());
+    int8_t* buffer_memory = static_cast<int8_t*>(buffer_->memory());
     return reinterpret_cast<T>(&buffer_memory[offset]);
   }
 
-  int32 GetSharedMemoryOffset(const void* memory) {
-    int8* buffer_memory = static_cast<int8*>(buffer_->memory());
-    ptrdiff_t offset = static_cast<const int8*>(memory) - &buffer_memory[0];
+  int32_t GetSharedMemoryOffset(const void* memory) {
+    int8_t* buffer_memory = static_cast<int8_t*>(buffer_->memory());
+    ptrdiff_t offset = static_cast<const int8_t*>(memory) - &buffer_memory[0];
     DCHECK_GE(offset, 0);
     DCHECK_LT(static_cast<size_t>(offset), kBufferSize);
-    return static_cast<int32>(offset);
+    return static_cast<int32_t>(offset);
   }
 
   // Overridden from CommandBufferEngine.
-  void set_token(int32 token) override { token_ = token; }
+  void set_token(int32_t token) override { token_ = token; }
 
-  int32 token() const {
-    return token_;
-  }
+  int32_t token() const { return token_; }
 
   // Overridden from CommandBufferEngine.
-  bool SetGetBuffer(int32 transfer_buffer_id) override {
+  bool SetGetBuffer(int32_t transfer_buffer_id) override {
     NOTREACHED();
     return false;
   }
 
   // Overridden from CommandBufferEngine.
-  bool SetGetOffset(int32 offset) override {
+  bool SetGetOffset(int32_t offset) override {
     if (static_cast<size_t>(offset) < kBufferSize) {
       get_offset_ = offset;
       return true;
@@ -130,24 +131,24 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  int32 GetGetOffset() override { return get_offset_; }
+  int32_t GetGetOffset() override { return get_offset_; }
 
  private:
-  bool IsValidSharedMemoryId(int32 shm_id) {
+  bool IsValidSharedMemoryId(int32_t shm_id) {
     return shm_id == kValidShmId || shm_id == kStartValidShmId;
   }
 
   scoped_refptr<gpu::Buffer> buffer_;
-  int32 token_;
-  int32 get_offset_;
+  int32_t token_;
+  int32_t get_offset_;
 };
 
-const int32 MockCommandBufferEngine::kStartValidShmId;
-const int32 MockCommandBufferEngine::kValidShmId;
-const int32 MockCommandBufferEngine::kInvalidShmId;
+const int32_t MockCommandBufferEngine::kStartValidShmId;
+const int32_t MockCommandBufferEngine::kValidShmId;
+const int32_t MockCommandBufferEngine::kInvalidShmId;
 const size_t MockCommandBufferEngine::kBufferSize;
-const int32 MockCommandBufferEngine::kValidOffset;
-const int32 MockCommandBufferEngine::kInvalidOffset;
+const int32_t MockCommandBufferEngine::kValidOffset;
+const int32_t MockCommandBufferEngine::kInvalidOffset;
 
 class CommonDecoderTest : public testing::Test {
  protected:
@@ -185,12 +186,12 @@ TEST_F(CommonDecoderTest, DoCommonCommandInvalidCommand) {
 
 TEST_F(CommonDecoderTest, HandleNoop) {
   cmd::Noop cmd;
-  const uint32 kSkipCount = 5;
+  const uint32_t kSkipCount = 5;
   cmd.Init(kSkipCount);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(
                 cmd, kSkipCount * kCommandBufferEntrySize));
-  const uint32 kSkipCount2 = 1;
+  const uint32_t kSkipCount2 = 1;
   cmd.Init(kSkipCount2);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(
@@ -199,7 +200,7 @@ TEST_F(CommonDecoderTest, HandleNoop) {
 
 TEST_F(CommonDecoderTest, SetToken) {
   cmd::SetToken cmd;
-  const int32 kTokenId = 123;
+  const int32_t kTokenId = 123;
   EXPECT_EQ(0, engine_.token());
   cmd.Init(kTokenId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -208,9 +209,9 @@ TEST_F(CommonDecoderTest, SetToken) {
 
 TEST_F(CommonDecoderTest, SetBucketSize) {
   cmd::SetBucketSize cmd;
-  const uint32 kBucketId = 123;
-  const uint32 kBucketLength1 = 1234;
-  const uint32 kBucketLength2 = 78;
+  const uint32_t kBucketId = 123;
+  const uint32_t kBucketLength1 = 1234;
+  const uint32_t kBucketLength2 = 78;
   // Check the bucket does not exist.
   EXPECT_TRUE(NULL == decoder_.GetBucket(kBucketId));
   // Check we can create one.
@@ -239,8 +240,8 @@ TEST_F(CommonDecoderTest, SetBucketData) {
 
   static const char kData[] = "1234567890123456789";
 
-  const uint32 kBucketId = 123;
-  const uint32 kInvalidBucketId = 124;
+  const uint32_t kBucketId = 123;
+  const uint32_t kInvalidBucketId = 124;
 
   size_cmd.Init(kBucketId, sizeof(kData));
   EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
@@ -249,7 +250,7 @@ TEST_F(CommonDecoderTest, SetBucketData) {
   EXPECT_NE(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData)));
 
   // Check we can set it.
-  const uint32 kSomeOffsetInSharedMemory = 50;
+  const uint32_t kSomeOffsetInSharedMemory = 50;
   void* memory = engine_.GetSharedMemoryAs<void*>(kSomeOffsetInSharedMemory);
   memcpy(memory, kData, sizeof(kData));
   cmd.Init(kBucketId, 0, sizeof(kData),
@@ -259,7 +260,7 @@ TEST_F(CommonDecoderTest, SetBucketData) {
 
   // Check we can set it partially.
   static const char kData2[] = "ABCEDFG";
-  const uint32 kSomeOffsetInBucket = 5;
+  const uint32_t kSomeOffsetInBucket = 5;
   memcpy(memory, kData2, sizeof(kData2));
   cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2),
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
@@ -291,14 +292,14 @@ TEST_F(CommonDecoderTest, SetBucketData) {
 
 TEST_F(CommonDecoderTest, SetBucketDataImmediate) {
   cmd::SetBucketSize size_cmd;
-  int8 buffer[1024];
+  int8_t buffer[1024];
   cmd::SetBucketDataImmediate& cmd =
       *reinterpret_cast<cmd::SetBucketDataImmediate*>(&buffer);
 
   static const char kData[] = "1234567890123456789";
 
-  const uint32 kBucketId = 123;
-  const uint32 kInvalidBucketId = 124;
+  const uint32_t kBucketId = 123;
+  const uint32_t kInvalidBucketId = 124;
 
   size_cmd.Init(kBucketId, sizeof(kData));
   EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
@@ -316,7 +317,7 @@ TEST_F(CommonDecoderTest, SetBucketDataImmediate) {
 
   // Check we can set it partially.
   static const char kData2[] = "ABCEDFG";
-  const uint32 kSomeOffsetInBucket = 5;
+  const uint32_t kSomeOffsetInBucket = 5;
   memcpy(memory, kData2, sizeof(kData2));
   cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2));
   EXPECT_EQ(error::kNoError,
@@ -354,23 +355,24 @@ TEST_F(CommonDecoderTest, GetBucketStart) {
   static const char kData[] = "1234567890123456789";
   static const char zero[sizeof(kData)] = { 0, };
 
-  const uint32 kBucketSize = sizeof(kData);
-  const uint32 kBucketId = 123;
-  const uint32 kInvalidBucketId = 124;
+  const uint32_t kBucketSize = sizeof(kData);
+  const uint32_t kBucketId = 123;
+  const uint32_t kInvalidBucketId = 124;
 
   // Put data in the bucket.
   size_cmd.Init(kBucketId, sizeof(kData));
   EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
-  const uint32 kSomeOffsetInSharedMemory = 50;
-  uint8* start = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory);
+  const uint32_t kSomeOffsetInSharedMemory = 50;
+  uint8_t* start =
+      engine_.GetSharedMemoryAs<uint8_t*>(kSomeOffsetInSharedMemory);
   memcpy(start, kData, sizeof(kData));
   set_cmd.Init(kBucketId, 0, sizeof(kData),
                MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
   EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd));
 
   // Check that the size is correct with no data buffer.
-  uint32* memory =
-      engine_.GetSharedMemoryAs<uint32*>(kSomeOffsetInSharedMemory);
+  uint32_t* memory =
+      engine_.GetSharedMemoryAs<uint32_t*>(kSomeOffsetInSharedMemory);
   *memory = 0x0;
   cmd.Init(kBucketId,
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
@@ -379,8 +381,9 @@ TEST_F(CommonDecoderTest, GetBucketStart) {
   EXPECT_EQ(kBucketSize, *memory);
 
   // Check that the data is copied with data buffer.
-  const uint32 kDataOffsetInSharedMemory = 54;
-  uint8* data = engine_.GetSharedMemoryAs<uint8*>(kDataOffsetInSharedMemory);
+  const uint32_t kDataOffsetInSharedMemory = 54;
+  uint8_t* data =
+      engine_.GetSharedMemoryAs<uint8_t*>(kDataOffsetInSharedMemory);
   *memory = 0x0;
   memset(data, 0, sizeof(kData));
   cmd.Init(kBucketId,
@@ -394,7 +397,7 @@ TEST_F(CommonDecoderTest, GetBucketStart) {
   // Check that we can get a piece.
   *memory = 0x0;
   memset(data, 0, sizeof(kData));
-  const uint32 kPieceSize = kBucketSize / 2;
+  const uint32_t kPieceSize = kBucketSize / 2;
   cmd.Init(kBucketId,
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
            kPieceSize, MockCommandBufferEngine::kValidShmId,
@@ -454,13 +457,14 @@ TEST_F(CommonDecoderTest, GetBucketData) {
   static const char kData[] = "1234567890123456789";
   static const char zero[sizeof(kData)] = { 0, };
 
-  const uint32 kBucketId = 123;
-  const uint32 kInvalidBucketId = 124;
+  const uint32_t kBucketId = 123;
+  const uint32_t kInvalidBucketId = 124;
 
   size_cmd.Init(kBucketId, sizeof(kData));
   EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
-  const uint32 kSomeOffsetInSharedMemory = 50;
-  uint8* memory = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory);
+  const uint32_t kSomeOffsetInSharedMemory = 50;
+  uint8_t* memory =
+      engine_.GetSharedMemoryAs<uint8_t*>(kSomeOffsetInSharedMemory);
   memcpy(memory, kData, sizeof(kData));
   set_cmd.Init(kBucketId, 0, sizeof(kData),
                MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
@@ -474,9 +478,9 @@ TEST_F(CommonDecoderTest, GetBucketData) {
   EXPECT_EQ(0, memcmp(memory, kData, sizeof(kData)));
 
   // Check we can get a piece.
-  const uint32 kSomeOffsetInBucket = 5;
-  const uint32 kLengthOfPiece = 6;
-  const uint8 kSentinel = 0xff;
+  const uint32_t kSomeOffsetInBucket = 5;
+  const uint32_t kLengthOfPiece = 6;
+  const uint8_t kSentinel = 0xff;
   memset(memory, 0, sizeof(kData));
   memory[-1] = kSentinel;
   cmd.Init(kBucketId, kSomeOffsetInBucket, kLengthOfPiece,
diff --git a/gpu/command_buffer/service/context_group.cc b/gpu/command_buffer/service/context_group.cc
index b90177c..bbd7c81 100644
--- a/gpu/command_buffer/service/context_group.cc
+++ b/gpu/command_buffer/service/context_group.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/context_group.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 
@@ -84,7 +87,7 @@ ContextGroup::ContextGroup(
   }
 }
 
-static void GetIntegerv(GLenum pname, uint32* var) {
+static void GetIntegerv(GLenum pname, uint32_t* var) {
   GLint value = 0;
   glGetIntegerv(pname, &value);
   *var = value;
@@ -276,18 +279,19 @@ bool ContextGroup::Initialize(GLES2Decoder* decoder,
   if (feature_info_->workarounds().max_fragment_uniform_vectors) {
     max_fragment_uniform_vectors_ = std::min(
         max_fragment_uniform_vectors_,
-        static_cast<uint32>(
+        static_cast<uint32_t>(
             feature_info_->workarounds().max_fragment_uniform_vectors));
   }
   if (feature_info_->workarounds().max_varying_vectors) {
-    max_varying_vectors_ = std::min(
-        max_varying_vectors_,
-        static_cast<uint32>(feature_info_->workarounds().max_varying_vectors));
+    max_varying_vectors_ =
+        std::min(max_varying_vectors_,
+                 static_cast<uint32_t>(
+                     feature_info_->workarounds().max_varying_vectors));
   }
   if (feature_info_->workarounds().max_vertex_uniform_vectors) {
     max_vertex_uniform_vectors_ =
         std::min(max_vertex_uniform_vectors_,
-                 static_cast<uint32>(
+                 static_cast<uint32_t>(
                      feature_info_->workarounds().max_vertex_uniform_vectors));
   }
 
@@ -393,8 +397,8 @@ void ContextGroup::Destroy(GLES2Decoder* decoder, bool have_context) {
   memory_tracker_ = NULL;
 }
 
-uint32 ContextGroup::GetMemRepresented() const {
-  uint32 total = 0;
+uint32_t ContextGroup::GetMemRepresented() const {
+  uint32_t total = 0;
   if (buffer_manager_.get())
     total += buffer_manager_->mem_represented();
   if (renderbuffer_manager_.get())
@@ -425,7 +429,7 @@ bool ContextGroup::CheckGLFeature(GLint min_required, GLint* v) {
   return value >= min_required;
 }
 
-bool ContextGroup::CheckGLFeatureU(GLint min_required, uint32* v) {
+bool ContextGroup::CheckGLFeatureU(GLint min_required, uint32_t* v) {
   GLint value = *v;
   if (enforce_gl_minimums_) {
     value = std::min(min_required, value);
@@ -442,9 +446,10 @@ bool ContextGroup::QueryGLFeature(
   return CheckGLFeature(min_required, v);
 }
 
-bool ContextGroup::QueryGLFeatureU(
-    GLenum pname, GLint min_required, uint32* v) {
-  uint32 value = 0;
+bool ContextGroup::QueryGLFeatureU(GLenum pname,
+                                   GLint min_required,
+                                   uint32_t* v) {
+  uint32_t value = 0;
   GetIntegerv(pname, &value);
   bool result = CheckGLFeatureU(min_required, &value);
   *v = value;
diff --git a/gpu/command_buffer/service/context_group.h b/gpu/command_buffer/service/context_group.h
index e12ba2a..86c239e 100644
--- a/gpu/command_buffer/service/context_group.h
+++ b/gpu/command_buffer/service/context_group.h
@@ -5,9 +5,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
 #define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
 
+#include <stdint.h>
+
 #include <vector>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ -88,43 +90,31 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
     return bind_generates_resource_;
   }
 
-  uint32 max_vertex_attribs() const {
-    return max_vertex_attribs_;
-  }
+  uint32_t max_vertex_attribs() const { return max_vertex_attribs_; }
 
-  uint32 max_texture_units() const {
-    return max_texture_units_;
-  }
+  uint32_t max_texture_units() const { return max_texture_units_; }
 
-  uint32 max_texture_image_units() const {
-    return max_texture_image_units_;
-  }
+  uint32_t max_texture_image_units() const { return max_texture_image_units_; }
 
-  uint32 max_vertex_texture_image_units() const {
+  uint32_t max_vertex_texture_image_units() const {
     return max_vertex_texture_image_units_;
   }
 
-  uint32 max_fragment_uniform_vectors() const {
+  uint32_t max_fragment_uniform_vectors() const {
     return max_fragment_uniform_vectors_;
   }
 
-  uint32 max_varying_vectors() const {
-    return max_varying_vectors_;
-  }
+  uint32_t max_varying_vectors() const { return max_varying_vectors_; }
 
-  uint32 max_vertex_uniform_vectors() const {
+  uint32_t max_vertex_uniform_vectors() const {
     return max_vertex_uniform_vectors_;
   }
 
-  uint32 max_color_attachments() const {
-    return max_color_attachments_;
-  }
+  uint32_t max_color_attachments() const { return max_color_attachments_; }
 
-  uint32 max_draw_buffers() const {
-    return max_draw_buffers_;
-  }
+  uint32_t max_draw_buffers() const { return max_draw_buffers_; }
 
-  uint32 max_dual_source_draw_buffers() const {
+  uint32_t max_dual_source_draw_buffers() const {
     return max_dual_source_draw_buffers_;
   }
 
@@ -182,7 +172,7 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
     return sampler_manager_.get();
   }
 
-  uint32 GetMemRepresented() const;
+  uint32_t GetMemRepresented() const;
 
   // Loses all the context associated with this group.
   void LoseContexts(error::ContextLostReason reason);
@@ -237,9 +227,9 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
   ~ContextGroup();
 
   bool CheckGLFeature(GLint min_required, GLint* v);
-  bool CheckGLFeatureU(GLint min_required, uint32* v);
+  bool CheckGLFeatureU(GLint min_required, uint32_t* v);
   bool QueryGLFeature(GLenum pname, GLint min_required, GLint* v);
-  bool QueryGLFeatureU(GLenum pname, GLint min_required, uint32* v);
+  bool QueryGLFeatureU(GLenum pname, GLint min_required, uint32_t* v);
   bool HaveContexts();
 
   scoped_refptr<MailboxManager> mailbox_manager_;
@@ -253,16 +243,16 @@ class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
   bool enforce_gl_minimums_;
   bool bind_generates_resource_;
 
-  uint32 max_vertex_attribs_;
-  uint32 max_texture_units_;
-  uint32 max_texture_image_units_;
-  uint32 max_vertex_texture_image_units_;
-  uint32 max_fragment_uniform_vectors_;
-  uint32 max_varying_vectors_;
-  uint32 max_vertex_uniform_vectors_;
-  uint32 max_color_attachments_;
-  uint32 max_draw_buffers_;
-  uint32 max_dual_source_draw_buffers_;
+  uint32_t max_vertex_attribs_;
+  uint32_t max_texture_units_;
+  uint32_t max_texture_image_units_;
+  uint32_t max_vertex_texture_image_units_;
+  uint32_t max_fragment_uniform_vectors_;
+  uint32_t max_varying_vectors_;
+  uint32_t max_vertex_uniform_vectors_;
+  uint32_t max_color_attachments_;
+  uint32_t max_draw_buffers_;
+  uint32_t max_dual_source_draw_buffers_;
 
   ProgramCache* program_cache_;
 
diff --git a/gpu/command_buffer/service/context_group_unittest.cc b/gpu/command_buffer/service/context_group_unittest.cc
index af1c9b7..50b6764 100644
--- a/gpu/command_buffer/service/context_group_unittest.cc
+++ b/gpu/command_buffer/service/context_group_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/context_group.h"
 
+#include <stdint.h>
+
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
@@ -70,19 +72,19 @@ TEST_F(ContextGroupTest, InitializeNoExtensions) {
       gl_.get(), DisallowedFeatures(), "", "", kBindGeneratesResource);
   group_->Initialize(decoder_.get(), CONTEXT_TYPE_OPENGLES2,
                      DisallowedFeatures());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kNumVertexAttribs),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kNumVertexAttribs),
             group_->max_vertex_attribs());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kNumTextureUnits),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kNumTextureUnits),
             group_->max_texture_units());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kMaxTextureImageUnits),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kMaxTextureImageUnits),
             group_->max_texture_image_units());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kMaxVertexTextureImageUnits),
-             group_->max_vertex_texture_image_units());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kMaxFragmentUniformVectors),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kMaxVertexTextureImageUnits),
+            group_->max_vertex_texture_image_units());
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kMaxFragmentUniformVectors),
             group_->max_fragment_uniform_vectors());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kMaxVaryingVectors),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kMaxVaryingVectors),
             group_->max_varying_vectors());
-  EXPECT_EQ(static_cast<uint32>(TestHelper::kMaxVertexUniformVectors),
+  EXPECT_EQ(static_cast<uint32_t>(TestHelper::kMaxVertexUniformVectors),
             group_->max_vertex_uniform_vectors());
   EXPECT_TRUE(group_->buffer_manager() != NULL);
   EXPECT_TRUE(group_->framebuffer_manager() != NULL);
diff --git a/gpu/command_buffer/service/context_state.cc b/gpu/command_buffer/service/context_state.cc
index 42a3b7c..2149556 100644
--- a/gpu/command_buffer/service/context_state.cc
+++ b/gpu/command_buffer/service/context_state.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/context_state.h"
 
+#include <stddef.h>
+
 #include <cmath>
 
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
diff --git a/gpu/command_buffer/service/context_state_unittest.cc b/gpu/command_buffer/service/context_state_unittest.cc
index 5a835de..7571f81 100644
--- a/gpu/command_buffer/service/context_state_unittest.cc
+++ b/gpu/command_buffer/service/context_state_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/context_state.h"
 
+#include <stddef.h>
+
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
diff --git a/gpu/command_buffer/service/error_state.cc b/gpu/command_buffer/service/error_state.cc
index 6667e1d..6e05c37 100644
--- a/gpu/command_buffer/service/error_state.cc
+++ b/gpu/command_buffer/service/error_state.cc
@@ -4,8 +4,11 @@
 
 #include "gpu/command_buffer/service/error_state.h"
 
+#include <stdint.h>
+
 #include <string>
 
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ -20,7 +23,7 @@ class ErrorStateImpl : public ErrorState {
   explicit ErrorStateImpl(ErrorStateClient* client, Logger* logger);
   ~ErrorStateImpl() override;
 
-  uint32 GetGLError() override;
+  uint32_t GetGLError() override;
 
   void SetGLError(const char* filename,
                   int line,
@@ -63,7 +66,7 @@ class ErrorStateImpl : public ErrorState {
   // The last error message set.
   std::string last_error_;
   // Current GL error bits.
-  uint32 error_bits_;
+  uint32_t error_bits_;
 
   ErrorStateClient* client_;
   Logger* logger_;
@@ -84,11 +87,11 @@ ErrorStateImpl::ErrorStateImpl(ErrorStateClient* client, Logger* logger)
 
 ErrorStateImpl::~ErrorStateImpl() {}
 
-uint32 ErrorStateImpl::GetGLError() {
+uint32_t ErrorStateImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = GetErrorHandleContextLoss();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
-    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;
diff --git a/gpu/command_buffer/service/error_state_mock.h b/gpu/command_buffer/service/error_state_mock.h
index eb056f3..cdfbf92 100644
--- a/gpu/command_buffer/service/error_state_mock.h
+++ b/gpu/command_buffer/service/error_state_mock.h
@@ -7,6 +7,9 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_ERROR_STATE_MOCK_H_
 #define GPU_COMMAND_BUFFER_SERVICE_ERROR_STATE_MOCK_H_
 
+#include <stdint.h>
+
+#include "base/macros.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
diff --git a/gpu/command_buffer/service/feature_info.cc b/gpu/command_buffer/service/feature_info.cc
index 76494a6..bc0c5cd 100644
--- a/gpu/command_buffer/service/feature_info.cc
+++ b/gpu/command_buffer/service/feature_info.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/feature_info.h"
 
+#include <stddef.h>
+
 #include <set>
 #include <vector>
 
diff --git a/gpu/command_buffer/service/feature_info_unittest.cc b/gpu/command_buffer/service/feature_info_unittest.cc
index bb616ac..7e6c080 100644
--- a/gpu/command_buffer/service/feature_info_unittest.cc
+++ b/gpu/command_buffer/service/feature_info_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/feature_info.h"
 
+#include <stddef.h>
+
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
diff --git a/gpu/command_buffer/service/framebuffer_completeness_cache.h b/gpu/command_buffer/service/framebuffer_completeness_cache.h
index 7200cbd..44741a4 100644
--- a/gpu/command_buffer/service/framebuffer_completeness_cache.h
+++ b/gpu/command_buffer/service/framebuffer_completeness_cache.h
@@ -6,6 +6,7 @@
 #define GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_COMPLETENESS_CACHE_H_
 
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/framebuffer_manager.cc b/gpu/command_buffer/service/framebuffer_manager.cc
index 6f84009..7400552 100644
--- a/gpu/command_buffer/service/framebuffer_manager.cc
+++ b/gpu/command_buffer/service/framebuffer_manager.cc
@@ -3,7 +3,12 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/framebuffer_manager.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/framebuffer_completeness_cache.h"
@@ -69,10 +74,10 @@ class RenderbufferAttachment
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              uint32 max_color_attachments) override {
-    uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
+                              uint32_t max_color_attachments) override {
+    uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
-    uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
+    uint32_t have = GLES2Util::GetChannelsForFormat(internal_format());
     return (need & have) != 0;
   }
 
@@ -187,16 +192,16 @@ class TextureAttachment
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              uint32 max_color_attachments) override {
+                              uint32_t max_color_attachments) override {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
-    uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
+    uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
-    uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
+    uint32_t have = GLES2Util::GetChannelsForFormat(internal_format);
 
     // Workaround for NVIDIA drivers that incorrectly expose these formats as
     // renderable:
@@ -236,8 +241,8 @@ class TextureAttachment
 };
 
 FramebufferManager::FramebufferManager(
-    uint32 max_draw_buffers,
-    uint32 max_color_attachments,
+    uint32_t max_draw_buffers,
+    uint32_t max_color_attachments,
     ContextType context_type,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_combo_complete_cache)
@@ -306,7 +311,7 @@ Framebuffer::Framebuffer(
   DCHECK_GT(manager->max_draw_buffers_, 0u);
   draw_buffers_.reset(new GLenum[manager->max_draw_buffers_]);
   draw_buffers_[0] = GL_COLOR_ATTACHMENT0;
-  for (uint32 i = 1; i < manager->max_draw_buffers_; ++i)
+  for (uint32_t i = 1; i < manager->max_draw_buffers_; ++i)
     draw_buffers_[i] = GL_NONE;
 }
 
@@ -347,7 +352,7 @@ bool Framebuffer::HasUnclearedColorAttachments() const {
 
 void Framebuffer::ChangeDrawBuffersHelper(bool recover) const {
   scoped_ptr<GLenum[]> buffers(new GLenum[manager_->max_draw_buffers_]);
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i)
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i)
     buffers[i] = GL_NONE;
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
@@ -358,7 +363,7 @@ void Framebuffer::ChangeDrawBuffersHelper(bool recover) const {
     }
   }
   bool different = false;
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (buffers[i] != draw_buffers_[i]) {
       different = true;
       break;
@@ -570,7 +575,7 @@ void Framebuffer::SetDrawBuffers(GLsizei n, const GLenum* bufs) {
 }
 
 bool Framebuffer::HasAlphaMRT() const {
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
@@ -585,7 +590,7 @@ bool Framebuffer::HasAlphaMRT() const {
 
 bool Framebuffer::HasSameInternalFormatsMRT() const {
   GLenum internal_format = 0;
-  for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
+  for (uint32_t i = 0; i < manager_->max_draw_buffers_; ++i) {
     if (draw_buffers_[i] != GL_NONE) {
       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
       if (!attachment)
diff --git a/gpu/command_buffer/service/framebuffer_manager.h b/gpu/command_buffer/service/framebuffer_manager.h
index dce2302..4ec9ad5 100644
--- a/gpu/command_buffer/service/framebuffer_manager.h
+++ b/gpu/command_buffer/service/framebuffer_manager.h
@@ -5,10 +5,13 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/context_group.h"
@@ -47,8 +50,8 @@ class GPU_EXPORT Framebuffer : public base::RefCounted<Framebuffer> {
         Renderbuffer* renderbuffer) const = 0;
     virtual bool CanRenderTo() const = 0;
     virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const = 0;
-    virtual bool ValidForAttachmentType(
-        GLenum attachment_type, uint32 max_color_attachments) = 0;
+    virtual bool ValidForAttachmentType(GLenum attachment_type,
+                                        uint32_t max_color_attachments) = 0;
     virtual size_t GetSignatureSize(TextureManager* texture_manager) const = 0;
     virtual void AddToSignature(
         TextureManager* texture_manager, std::string* signature) const = 0;
@@ -236,8 +239,8 @@ struct DecoderFramebufferState {
 // so we can correctly clear them.
 class GPU_EXPORT FramebufferManager {
  public:
-  FramebufferManager(uint32 max_draw_buffers,
-                     uint32 max_color_attachments,
+  FramebufferManager(uint32_t max_draw_buffers,
+                     uint32_t max_color_attachments,
                      ContextType context_type,
                      const scoped_refptr<FramebufferCompletenessCache>&
                          framebuffer_combo_complete_cache);
@@ -300,8 +303,8 @@ class GPU_EXPORT FramebufferManager {
 
   bool have_context_;
 
-  uint32 max_draw_buffers_;
-  uint32 max_color_attachments_;
+  uint32_t max_draw_buffers_;
+  uint32_t max_color_attachments_;
 
   ContextType context_type_;
 
diff --git a/gpu/command_buffer/service/framebuffer_manager_unittest.cc b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
index e5f8f18..8fea247 100644
--- a/gpu/command_buffer/service/framebuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
@@ -2,9 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/error_state_mock.h"
-#include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
@@ -25,8 +28,8 @@ const GLint kMaxRectangleTextureSize = 64;
 const GLint kMax3DTextureSize = 256;
 const GLint kMaxRenderbufferSize = 64;
 const GLint kMaxSamples = 4;
-const uint32 kMaxDrawBuffers = 16;
-const uint32 kMaxColorAttachments = 16;
+const uint32_t kMaxDrawBuffers = 16;
+const uint32_t kMaxColorAttachments = 16;
 const bool kUseDefaultTextures = false;
 
 }  // namespace
diff --git a/gpu/command_buffer/service/gl_state_restorer_impl.h b/gpu/command_buffer/service/gl_state_restorer_impl.h
index d9c4181..494a8cb 100644
--- a/gpu/command_buffer/service/gl_state_restorer_impl.h
+++ b/gpu/command_buffer/service/gl_state_restorer_impl.h
@@ -8,6 +8,7 @@
 #define GPU_COMMAND_BUFFER_SERVICE_GL_STATE_RESTORER_IMPL_H_
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "gpu/gpu_export.h"
 #include "ui/gl/gl_state_restorer.h"
diff --git a/gpu/command_buffer/service/gl_surface_mock.h b/gpu/command_buffer/service/gl_surface_mock.h
index 9db131b..193a3c2 100644
--- a/gpu/command_buffer/service/gl_surface_mock.h
+++ b/gpu/command_buffer/service/gl_surface_mock.h
@@ -5,6 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GL_SURFACE_MOCK_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GL_SURFACE_MOCK_H_
 
+#include "base/macros.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_surface.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.cc b/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.cc
index e805791..6a21c49 100644
--- a/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.cc
+++ b/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.cc
@@ -4,7 +4,6 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h"
 
-#include "base/basictypes.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gfx/geometry/size.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h b/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h
index 6b533f5..750b0d6 100644
--- a/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h
+++ b/gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h
@@ -5,6 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_CLEAR_FRAMEBUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_CLEAR_FRAMEBUFFER_H_
 
+#include "base/macros.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc b/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc
index 2ad1032..f5a9001 100644
--- a/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc
+++ b/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc
@@ -4,9 +4,10 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
-#include "base/basictypes.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_implementation.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h b/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h
index f0438b4..bbd215e 100644
--- a/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h
+++ b/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index b508299..7c47ee80 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 
 #include <algorithm>
@@ -228,10 +230,10 @@ class GLES2DecoderImpl;
 // 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");
 
@@ -242,27 +244,26 @@ static_assert(sizeof(GLfloat) == sizeof(float),  // NOLINT
 // 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;
   }
@@ -500,12 +501,12 @@ struct FenceCallback {
 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;
 }
 
@@ -555,7 +556,7 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
                   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;
@@ -627,13 +628,13 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
 
   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;
@@ -1211,21 +1212,24 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
                                      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.
@@ -1709,10 +1713,13 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
       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 ||
@@ -1770,8 +1777,8 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
   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,
@@ -1887,7 +1894,7 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
   // 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)
 
@@ -1983,7 +1990,7 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
   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
@@ -2066,15 +2073,15 @@ class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
   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.
@@ -2290,7 +2297,7 @@ bool BackTexture::AllocateStorage(
   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);
@@ -2388,7 +2395,7 @@ bool BackRenderbuffer::AllocateStorage(const FeatureInfo* feature_info,
       "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;
@@ -2570,13 +2577,12 @@ GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* 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());
@@ -2700,7 +2706,7 @@ bool GLES2DecoderImpl::Initialize(
 
   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;
@@ -3971,8 +3977,8 @@ void GLES2DecoderImpl::SetWaitFenceSyncCallback(
   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();
@@ -3981,7 +3987,7 @@ bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
   return false;
 }
 
-uint32 GLES2DecoderImpl::GetTextureUploadCount() {
+uint32_t GLES2DecoderImpl::GetTextureUploadCount() {
   return texture_state_.texture_upload_count;
 }
 
@@ -4302,8 +4308,9 @@ bool GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
   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())
@@ -4419,8 +4426,8 @@ error::Error GLES2DecoderImpl::DoCommandsImpl(unsigned int num_commands,
           }
         }
 
-        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);
 
@@ -4714,7 +4721,7 @@ void GLES2DecoderImpl::ClearAllAttributes() const {
   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)
@@ -4735,8 +4742,8 @@ void GLES2DecoderImpl::SetForceShaderNameHashingForTest(bool 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;
 }
@@ -5696,7 +5703,7 @@ void GLES2DecoderImpl::DoBindAttribLocation(GLuint program_id,
 }
 
 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);
@@ -5740,7 +5747,7 @@ error::Error GLES2DecoderImpl::DoBindFragDataLocation(GLuint program_id,
 }
 
 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;
@@ -5793,7 +5800,7 @@ error::Error GLES2DecoderImpl::DoBindFragDataLocationIndexed(
 }
 
 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;
@@ -5830,9 +5837,11 @@ void GLES2DecoderImpl::DoBindUniformLocationCHROMIUM(GLuint program_id,
         "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");
@@ -5851,7 +5860,7 @@ void GLES2DecoderImpl::DoBindUniformLocationCHROMIUM(GLuint program_id,
 }
 
 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*>(
@@ -5870,7 +5879,7 @@ error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUMBucket(
   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);
@@ -5888,7 +5897,7 @@ error::Error GLES2DecoderImpl::HandleDeleteShader(uint32 immediate_data_size,
   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);
@@ -6541,7 +6550,7 @@ bool GLES2DecoderImpl::ValidateRenderbufferStorageMultisample(
     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(
@@ -6768,7 +6777,7 @@ void GLES2DecoderImpl::DoRenderbufferStorage(
     return;
   }
 
-  uint32 estimated_size = 0;
+  uint32_t estimated_size = 0;
   if (!renderbuffer_manager()->ComputeEstimatedRenderbufferSize(
            width, height, 1, internalformat, &estimated_size)) {
     LOCAL_SET_GL_ERROR(
@@ -7767,7 +7776,7 @@ bool GLES2DecoderImpl::SimulateAttrib0(
   // 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) ||
@@ -7894,7 +7903,7 @@ bool GLES2DecoderImpl::SimulateFixedAttribs(
     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(
@@ -7904,8 +7913,8 @@ bool GLES2DecoderImpl::SimulateFixedAttribs(
     }
   }
 
-  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(
@@ -7945,12 +7954,12 @@ bool GLES2DecoderImpl::SimulateFixedAttribs(
         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;
@@ -8052,7 +8061,7 @@ error::Error GLES2DecoderImpl::DoDrawArrays(
   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
@@ -8067,7 +8076,7 @@ error::Error GLES2DecoderImpl::HandleDrawArrays(uint32 immediate_data_size,
 }
 
 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);
@@ -8082,14 +8091,13 @@ error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
                       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;
@@ -8194,37 +8202,31 @@ error::Error GLES2DecoderImpl::DoDrawElements(
   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(
@@ -8339,12 +8341,13 @@ void GLES2DecoderImpl::DoGetShaderiv(
   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()) {
@@ -8356,13 +8359,13 @@ error::Error GLES2DecoderImpl::HandleGetShaderSource(uint32 immediate_data_size,
 }
 
 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");
@@ -8379,12 +8382,12 @@ error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
 }
 
 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");
@@ -8397,12 +8400,12 @@ error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
 }
 
 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) {
@@ -8746,7 +8749,7 @@ void GLES2DecoderImpl::DoVertexAttribI4uiv(GLuint index, const GLuint* 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;
@@ -8834,7 +8837,7 @@ error::Error GLES2DecoderImpl::HandleVertexAttribIPointer(
 }
 
 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);
@@ -8939,7 +8942,7 @@ void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
 }
 
 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);
@@ -8963,20 +8966,23 @@ error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
 }
 
 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;
@@ -8994,7 +9000,7 @@ void GLES2DecoderImpl::FinishReadPixels(
   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*>(
@@ -9044,22 +9050,22 @@ void GLES2DecoderImpl::FinishReadPixels(
   }
 
   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:
@@ -9075,9 +9081,8 @@ void GLES2DecoderImpl::FinishReadPixels(
     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>(
@@ -9085,16 +9090,15 @@ void GLES2DecoderImpl::FinishReadPixels(
               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);
@@ -9114,7 +9118,7 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
     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,
@@ -9142,13 +9146,13 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
             "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;
@@ -9287,8 +9291,8 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
   // 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");
@@ -9313,9 +9317,9 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
     }
     // 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)) {
@@ -9325,7 +9329,7 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
     }
 
     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)) {
@@ -9335,7 +9339,7 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
     }
 
     // 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;
@@ -9399,7 +9403,7 @@ error::Error GLES2DecoderImpl::HandleReadPixels(uint32 immediate_data_size,
   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);
@@ -9499,7 +9503,7 @@ error::Error GLES2DecoderImpl::HandlePixelStorei(uint32 immediate_data_size,
 }
 
 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);
@@ -9536,7 +9540,7 @@ error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
 }
 
 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);
@@ -9581,7 +9585,7 @@ error::Error GLES2DecoderImpl::HandleScheduleOverlayPlaneCHROMIUM(
 }
 
 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);
@@ -9626,7 +9630,9 @@ error::Error GLES2DecoderImpl::HandleScheduleCALayerCHROMIUM(
 }
 
 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(
@@ -9657,7 +9663,7 @@ error::Error GLES2DecoderImpl::GetAttribLocationHelper(
 }
 
 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);
@@ -9674,7 +9680,9 @@ error::Error GLES2DecoderImpl::HandleGetAttribLocation(
 }
 
 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(
@@ -9705,7 +9713,7 @@ error::Error GLES2DecoderImpl::GetUniformLocationHelper(
 }
 
 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);
@@ -9722,7 +9730,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformLocation(
 }
 
 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;
@@ -9774,7 +9782,9 @@ error::Error GLES2DecoderImpl::HandleGetUniformIndices(
 }
 
 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*>(
@@ -9801,7 +9811,7 @@ error::Error GLES2DecoderImpl::GetFragDataLocationHelper(
 }
 
 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;
@@ -9821,8 +9831,8 @@ error::Error GLES2DecoderImpl::HandleGetFragDataLocation(
 
 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 =
@@ -9849,7 +9859,7 @@ error::Error GLES2DecoderImpl::GetFragDataIndexHelper(
 }
 
 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;
@@ -9869,7 +9879,8 @@ error::Error GLES2DecoderImpl::HandleGetFragDataIndexEXT(
 }
 
 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 =
@@ -9900,7 +9911,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformBlockIndex(
   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);
@@ -9986,14 +9997,14 @@ error::Error GLES2DecoderImpl::HandleGetString(uint32 immediate_data_size,
   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) {
@@ -10022,7 +10033,7 @@ bool GLES2DecoderImpl::ClearLevel(Texture* texture,
                                   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) {
@@ -10063,10 +10074,10 @@ bool GLES2DecoderImpl::ClearLevel(Texture* texture,
     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)) {
@@ -10571,9 +10582,9 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
     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();
   }
@@ -10594,7 +10605,7 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
 }
 
 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);
@@ -10605,8 +10616,8 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
   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*>(
@@ -10620,7 +10631,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
 }
 
 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);
@@ -10634,7 +10645,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage2DBucket(
   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) {
@@ -10646,7 +10657,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage2DBucket(
 }
 
 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);
@@ -10661,7 +10672,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DBucket(
   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) {
@@ -10758,9 +10769,9 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage3D(
     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();
   }
@@ -10781,7 +10792,8 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage3D(
 }
 
 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;
 
@@ -10795,8 +10807,8 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage3D(
   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*>(
@@ -10810,7 +10822,8 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage3D(
 }
 
 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;
 
@@ -10827,7 +10840,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexImage3DBucket(
   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) {
@@ -10910,7 +10923,8 @@ void GLES2DecoderImpl::DoCompressedTexSubImage3D(
 }
 
 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 =
@@ -10928,7 +10942,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3DBucket(
   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) {
@@ -10940,7 +10954,7 @@ error::Error GLES2DecoderImpl::HandleCompressedTexSubImage3DBucket(
   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);
@@ -10958,9 +10972,9 @@ error::Error GLES2DecoderImpl::HandleTexImage2D(uint32 immediate_data_size,
   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)) {
@@ -10996,7 +11010,7 @@ error::Error GLES2DecoderImpl::HandleTexImage2D(uint32 immediate_data_size,
   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;
@@ -11016,9 +11030,9 @@ error::Error GLES2DecoderImpl::HandleTexImage3D(uint32 immediate_data_size,
   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)) {
@@ -11165,8 +11179,8 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
 
   // 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(
@@ -11195,7 +11209,7 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
     return;
   }
 
-  uint32 pixels_size = 0;
+  uint32_t pixels_size = 0;
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
@@ -11309,8 +11323,8 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
 
   // 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) {
@@ -11379,7 +11393,7 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
       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)) {
@@ -11409,7 +11423,7 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
   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);
@@ -11427,7 +11441,7 @@ error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32 immediate_data_size,
   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)) {
@@ -11488,7 +11502,7 @@ error::Error GLES2DecoderImpl::DoTexSubImage3D(
   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;
@@ -11511,7 +11525,7 @@ error::Error GLES2DecoderImpl::HandleTexSubImage3D(uint32 immediate_data_size,
   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)) {
@@ -11524,7 +11538,7 @@ error::Error GLES2DecoderImpl::HandleTexSubImage3D(uint32 immediate_data_size,
 }
 
 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);
@@ -11559,8 +11573,8 @@ error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
 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,
@@ -11607,7 +11621,7 @@ bool GLES2DecoderImpl::GetUniformSetup(GLuint program_id,
     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;
@@ -11624,7 +11638,7 @@ bool GLES2DecoderImpl::GetUniformSetup(GLuint program_id,
   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);
@@ -11646,7 +11660,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformiv(uint32 immediate_data_size,
   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;
@@ -11671,7 +11685,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformuiv(uint32 immediate_data_size,
   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);
@@ -11704,7 +11718,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformfv(uint32 immediate_data_size,
 }
 
 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);
@@ -11745,11 +11759,11 @@ error::Error GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
 }
 
 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");
@@ -11757,7 +11771,7 @@ error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
     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) {
@@ -11782,13 +11796,13 @@ error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
 }
 
 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));
@@ -11820,7 +11834,8 @@ error::Error GLES2DecoderImpl::HandleGetActiveUniform(
 }
 
 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 =
@@ -11877,14 +11892,15 @@ error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockiv(
 }
 
 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));
@@ -11930,7 +11946,8 @@ error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockName(
 }
 
 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 =
@@ -11982,13 +11999,14 @@ error::Error GLES2DecoderImpl::HandleGetActiveUniformsiv(
   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));
@@ -12019,7 +12037,7 @@ error::Error GLES2DecoderImpl::HandleGetActiveAttrib(uint32 immediate_data_size,
   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");
@@ -12035,7 +12053,7 @@ error::Error GLES2DecoderImpl::HandleShaderBinary(uint32 immediate_data_size,
     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;
   }
@@ -12208,7 +12226,7 @@ void GLES2DecoderImpl::DoSwapInterval(int 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);
@@ -12255,7 +12273,7 @@ error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
 }
 
 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*>(
@@ -12268,7 +12286,7 @@ error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
 }
 
 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);
@@ -12313,12 +12331,12 @@ error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
 }
 
 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;
@@ -12331,13 +12349,14 @@ error::Error GLES2DecoderImpl::HandleGetProgramInfoCHROMIUM(
 }
 
 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;
@@ -12350,13 +12369,14 @@ error::Error GLES2DecoderImpl::HandleGetUniformBlocksCHROMIUM(
 }
 
 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;
@@ -12369,7 +12389,7 @@ error::Error GLES2DecoderImpl::HandleGetUniformsES3CHROMIUM(
 }
 
 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;
@@ -12377,7 +12397,7 @@ error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVarying(
       *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));
@@ -12428,14 +12448,15 @@ error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVarying(
 }
 
 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;
@@ -12529,17 +12550,17 @@ bool GLES2DecoderImpl::CheckResetStatus() {
 }
 
 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;
 
@@ -12548,7 +12569,7 @@ error::Error GLES2DecoderImpl::HandleWaitSyncPointCHROMIUM(
 }
 
 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);
@@ -12560,25 +12581,25 @@ error::Error GLES2DecoderImpl::HandleInsertFenceSyncCHROMIUM(
 }
 
 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);
@@ -12604,7 +12625,7 @@ error::Error GLES2DecoderImpl::HandleWaitSyncTokenCHROMIUM(
 }
 
 error::Error GLES2DecoderImpl::HandleDiscardBackbufferCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   if (surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
@@ -12681,14 +12702,14 @@ void GLES2DecoderImpl::PerformIdleWork() {
   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:
@@ -12774,12 +12795,12 @@ error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32 immediate_data_size,
   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) {
@@ -12797,15 +12818,16 @@ error::Error GLES2DecoderImpl::HandleEndQueryEXT(uint32 immediate_data_size,
   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:
@@ -12842,11 +12864,12 @@ error::Error GLES2DecoderImpl::HandleQueryCounterEXT(uint32 immediate_data_size,
 }
 
 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;
@@ -12924,7 +12947,7 @@ void GLES2DecoderImpl::DoBindVertexArrayOES(GLuint client_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);
   }
 
@@ -13919,9 +13942,9 @@ void GLES2DecoderImpl::DoTexStorage2DEXT(
   {
     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) ||
@@ -13970,7 +13993,7 @@ void GLES2DecoderImpl::DoTexStorage2DEXT(
 }
 
 error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   return error::kUnknownCommand;
 }
@@ -14345,7 +14368,7 @@ void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
 }
 
 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);
@@ -14859,8 +14882,8 @@ class PathCommandValidatorContext {
                        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;
@@ -14900,15 +14923,16 @@ class PathCommandValidatorContext {
       *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;
@@ -14940,10 +14964,10 @@ class PathCommandValidatorContext {
   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;
@@ -14965,7 +14989,7 @@ class PathCommandValidatorContext {
       // 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
@@ -14983,7 +15007,7 @@ class PathCommandValidatorContext {
 };
 
 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);
@@ -15033,7 +15057,7 @@ error::Error GLES2DecoderImpl::HandleDeletePathsCHROMIUM(
 }
 
 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 =
@@ -15054,13 +15078,13 @@ error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
     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;
@@ -15070,8 +15094,8 @@ error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
   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);
@@ -15115,14 +15139,14 @@ error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
   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);
@@ -15138,7 +15162,7 @@ error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
 }
 
 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 =
@@ -15190,7 +15214,7 @@ error::Error GLES2DecoderImpl::HandlePathParameterfCHROMIUM(
 }
 
 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 =
@@ -15240,7 +15264,7 @@ error::Error GLES2DecoderImpl::HandlePathParameteriCHROMIUM(
 }
 
 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);
@@ -15264,7 +15288,7 @@ error::Error GLES2DecoderImpl::HandleStencilFillPathCHROMIUM(
 }
 
 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);
@@ -15283,7 +15307,7 @@ error::Error GLES2DecoderImpl::HandleStencilStrokePathCHROMIUM(
 }
 
 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);
@@ -15305,7 +15329,7 @@ error::Error GLES2DecoderImpl::HandleCoverFillPathCHROMIUM(
 }
 
 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);
@@ -15327,7 +15351,7 @@ error::Error GLES2DecoderImpl::HandleCoverStrokePathCHROMIUM(
 }
 
 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*>(
@@ -15353,7 +15377,7 @@ error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathCHROMIUM(
 }
 
 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*>(
@@ -15378,7 +15402,7 @@ error::Error GLES2DecoderImpl::HandleStencilThenCoverStrokePathCHROMIUM(
 }
 
 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*>(
@@ -15415,7 +15439,7 @@ error::Error GLES2DecoderImpl::HandleStencilFillPathInstancedCHROMIUM(
 }
 
 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*>(
@@ -15452,7 +15476,7 @@ error::Error GLES2DecoderImpl::HandleStencilStrokePathInstancedCHROMIUM(
 }
 
 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*>(
@@ -15488,7 +15512,7 @@ error::Error GLES2DecoderImpl::HandleCoverFillPathInstancedCHROMIUM(
 }
 
 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*>(
@@ -15524,7 +15548,7 @@ error::Error GLES2DecoderImpl::HandleCoverStrokePathInstancedCHROMIUM(
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM& c =
       *static_cast<
@@ -15566,7 +15590,7 @@ error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathInstancedCHROMIUM(
 
 error::Error
 GLES2DecoderImpl::HandleStencilThenCoverStrokePathInstancedCHROMIUM(
-    uint32 immediate_data_size,
+    uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM& c =
       *static_cast<
@@ -15624,7 +15648,7 @@ void GLES2DecoderImpl::DoBindFragmentInputLocationCHROMIUM(
     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;
@@ -15634,7 +15658,7 @@ void GLES2DecoderImpl::DoBindFragmentInputLocationCHROMIUM(
 }
 
 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*>(
@@ -15658,7 +15682,7 @@ error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
 }
 
 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 =
@@ -15738,15 +15762,15 @@ error::Error GLES2DecoderImpl::HandleProgramPathFragmentInputGenCHROMIUM(
                          "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*>(
@@ -15765,6 +15789,7 @@ error::Error GLES2DecoderImpl::HandleProgramPathFragmentInputGenCHROMIUM(
 // 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
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index ee440dd..9b7cade 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -7,10 +7,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -64,7 +65,7 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
                                 public CommonDecoder {
  public:
   typedef error::Error Error;
-  typedef base::Callback<bool(uint32 id)> WaitSyncPointCallback;
+  typedef base::Callback<bool(uint32_t id)> WaitSyncPointCallback;
   typedef base::Callback<void(uint64_t release)> FenceSyncReleaseCallback;
   typedef base::Callback<bool(gpu::CommandBufferNamespace namespace_id,
                               uint64_t command_buffer_id,
@@ -131,7 +132,7 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
                           bool offscreen,
                           const gfx::Size& offscreen_size,
                           const DisallowedFeatures& disallowed_features,
-                          const std::vector<int32>& attribs) = 0;
+                          const std::vector<int32_t>& attribs) = 0;
 
   // Destroys the graphics context.
   virtual void Destroy(bool have_context) = 0;
@@ -179,7 +180,7 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
 
   virtual void SetIgnoreCachedStateForTest(bool ignore) = 0;
   virtual void SetForceShaderNameHashingForTest(bool force) = 0;
-  virtual uint32 GetAndClearBackbufferClearBitsForTest();
+  virtual uint32_t GetAndClearBackbufferClearBitsForTest();
 
   // Gets the QueryManager for this context.
   virtual QueryManager* GetQueryManager() = 0;
@@ -207,8 +208,8 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
 
   // Get the service texture ID corresponding to a client texture ID.
   // If no such record is found then return false.
-  virtual bool GetServiceTextureId(uint32 client_texture_id,
-                                   uint32* service_texture_id);
+  virtual bool GetServiceTextureId(uint32_t client_texture_id,
+                                   uint32_t* service_texture_id);
 
   // Provides detail about a lost context if one occurred.
   virtual error::ContextLostReason GetContextLostReason() = 0;
@@ -243,7 +244,7 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
       const WaitFenceSyncCallback& callback) = 0;
 
   virtual void WaitForReadPixels(base::Closure callback) = 0;
-  virtual uint32 GetTextureUploadCount() = 0;
+  virtual uint32_t GetTextureUploadCount() = 0;
   virtual base::TimeDelta GetTotalTextureUploadTime() = 0;
   virtual base::TimeDelta GetTotalProcessingCommandsTime() = 0;
   virtual void AddProcessingCommandsTime(base::TimeDelta) = 0;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index 7bf1c69..7cc02c9 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -7,9 +7,12 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_MOCK_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_MOCK_H_
 
+#include <stdint.h>
+
 #include <vector>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -46,13 +49,13 @@ class MockGLES2Decoder : public GLES2Decoder {
                     bool offscreen,
                     const gfx::Size& size,
                     const DisallowedFeatures& disallowed_features,
-                    const std::vector<int32>& attribs));
+                    const std::vector<int32_t>& attribs));
   MOCK_METHOD1(Destroy, void(bool have_context));
   MOCK_METHOD1(SetSurface, void(const scoped_refptr<gfx::GLSurface>& surface));
   MOCK_METHOD1(ProduceFrontBuffer, void(const Mailbox& mailbox));
   MOCK_METHOD1(ResizeOffscreenFrameBuffer, bool(const gfx::Size& size));
   MOCK_METHOD0(MakeCurrent, bool());
-  MOCK_METHOD1(GetServiceIdForTesting, uint32(uint32 client_id));
+  MOCK_METHOD1(GetServiceIdForTesting, uint32_t(uint32_t client_id));
   MOCK_METHOD0(GetGLES2Util, GLES2Util*());
   MOCK_METHOD0(GetGLSurface, gfx::GLSurface*());
   MOCK_METHOD0(GetGLContext, gfx::GLContext*());
@@ -95,8 +98,8 @@ class MockGLES2Decoder : public GLES2Decoder {
                             const void* buffer,
                             int num_entries,
                             int* entries_processed));
-  MOCK_METHOD2(GetServiceTextureId, bool(uint32 client_texture_id,
-                                         uint32* service_texture_id));
+  MOCK_METHOD2(GetServiceTextureId,
+               bool(uint32_t client_texture_id, uint32_t* service_texture_id));
   MOCK_METHOD0(GetContextLostReason, error::ContextLostReason());
   MOCK_CONST_METHOD1(GetCommandName, const char*(unsigned int command_id));
   MOCK_METHOD9(ClearLevel,
@@ -122,7 +125,7 @@ class MockGLES2Decoder : public GLES2Decoder {
                void(const WaitFenceSyncCallback& callback));
   MOCK_METHOD1(WaitForReadPixels,
                void(base::Closure callback));
-  MOCK_METHOD0(GetTextureUploadCount, uint32());
+  MOCK_METHOD0(GetTextureUploadCount, uint32_t());
   MOCK_METHOD0(GetTotalTextureUploadTime, base::TimeDelta());
   MOCK_METHOD0(GetTotalProcessingCommandsTime, base::TimeDelta());
   MOCK_METHOD1(AddProcessingCommandsTime, void(base::TimeDelta));
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index 699b31d..8650c9d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -449,14 +452,14 @@ TEST_P(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
 }
 
 TEST_P(GLES2DecoderTest, EnableFeatureCHROMIUMBadBucket) {
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   EnableFeatureCHROMIUM cmd;
   cmd.Init(kBadBucketId, shared_memory_id_, shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_P(GLES2DecoderTest, RequestExtensionCHROMIUMBadBucket) {
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   RequestExtensionCHROMIUM cmd;
   cmd.Init(kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
@@ -582,8 +585,8 @@ static error::Error ExecuteBeginQueryCmd(GLES2DecoderTestBase* test,
                                          GLenum target,
                                          GLuint client_id,
                                          GLuint service_id,
-                                         int32 shm_id,
-                                         uint32 shm_offset) {
+                                         int32_t shm_id,
+                                         uint32_t shm_offset) {
   if (GL_ANY_SAMPLES_PASSED_EXT == target) {
     EXPECT_CALL(*gl, BeginQuery(target, service_id))
         .Times(1)
@@ -626,14 +629,14 @@ static error::Error ExecuteEndQueryCmd(GLES2DecoderTestBase* test,
 }
 
 static error::Error ExecuteQueryCounterCmd(GLES2DecoderTestBase* test,
-                                         ::gfx::MockGLInterface* gl,
-                                         ::gfx::GPUTimingFake* timing_queries,
-                                         GLenum target,
-                                         GLuint client_id,
-                                         GLuint service_id,
-                                         int32 shm_id,
-                                         uint32 shm_offset,
-                                         uint32_t submit_count) {
+                                           ::gfx::MockGLInterface* gl,
+                                           ::gfx::GPUTimingFake* timing_queries,
+                                           GLenum target,
+                                           GLuint client_id,
+                                           GLuint service_id,
+                                           int32_t shm_id,
+                                           uint32_t shm_offset,
+                                           uint32_t submit_count) {
   if (GL_TIMESTAMP == target) {
     timing_queries->ExpectGPUTimeStampQuery(*gl, false);
   }
@@ -678,8 +681,8 @@ static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
                                              GLuint client_id,
                                              GLuint service_id,
                                              const QueryType& query_type,
-                                             int32 shm_id,
-                                             uint32 shm_offset) {
+                                             int32_t shm_id,
+                                             uint32_t shm_offset) {
   // We need to reset the decoder on each iteration, because we lose the
   // context every time.
   GLES2DecoderTestBase::InitState init;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
index 2d37097..df51b99 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
@@ -4,11 +4,13 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -38,8 +40,9 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
  public:
   GLES2DecoderTest2() { }
 
-  void TestAcceptedUniform(
-      GLenum uniform_type, uint32 accepts_apis, bool es3_enabled) {
+  void TestAcceptedUniform(GLenum uniform_type,
+                           uint32_t accepts_apis,
+                           bool es3_enabled) {
     decoder_->set_unsafe_es3_apis_enabled(es3_enabled);
 
     SetupShaderForUniform(uniform_type);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 17bf4f3..8eb4086 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -906,7 +906,7 @@ TEST_P(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
 }
 
 TEST_P(GLES2DecoderTest2, ShaderSourceBucketValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -918,7 +918,7 @@ TEST_P(GLES2DecoderTest2, ShaderSourceBucketValidArgs) {
 }
 
 TEST_P(GLES2DecoderTest2, ShaderSourceBucketInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -935,7 +935,7 @@ TEST_P(GLES2DecoderTest2, ShaderSourceBucketInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderTest2, ShaderSourceBucketInvalidHeader) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -953,7 +953,7 @@ TEST_P(GLES2DecoderTest2, ShaderSourceBucketInvalidHeader) {
 }
 
 TEST_P(GLES2DecoderTest2, ShaderSourceBucketInvalidStringEnding) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kInvalidStrEnd = '*';
@@ -1224,7 +1224,7 @@ TEST_P(GLES2DecoderTest2, TexStorage3DValidArgs) {
 }
 
 TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -1238,7 +1238,7 @@ TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketValidArgs) {
 }
 
 TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -1255,7 +1255,7 @@ TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketInvalidHeader) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -1273,7 +1273,7 @@ TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketInvalidHeader) {
 }
 
 TEST_P(GLES2DecoderTest2, TransformFeedbackVaryingsBucketInvalidStringEnding) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = {kSource0};
   const char kInvalidStrEnd = '*';
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
index 93dea22..a719e7a 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
@@ -4,11 +4,13 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
@@ -114,8 +116,8 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::ValidateProgram, 0>(
 };
 
 TEST_P(GLES2DecoderTest3, TraceBeginCHROMIUM) {
-  const uint32 kCategoryBucketId = 123;
-  const uint32 kNameBucketId = 234;
+  const uint32_t kCategoryBucketId = 123;
+  const uint32_t kNameBucketId = 234;
 
   const char kCategory[] = "test_category";
   const char kName[] = "test_command";
@@ -134,8 +136,8 @@ TEST_P(GLES2DecoderTest3, TraceEndCHROMIUM) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
-  const uint32 kCategoryBucketId = 123;
-  const uint32 kNameBucketId = 234;
+  const uint32_t kCategoryBucketId = 123;
+  const uint32_t kNameBucketId = 234;
 
   const char kCategory[] = "test_category";
   const char kName[] = "test_command";
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
index e854f53..92738c1 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index c4d6eb0..b567357 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
@@ -84,8 +87,8 @@ void NormalizeInitState(gpu::gles2::GLES2DecoderTestBase::InitState* init) {
   init->extensions += "GL_EXT_framebuffer_object ";
 }
 
-const uint32 kMaxColorAttachments = 16;
-const uint32 kMaxDrawBuffers = 16;
+const uint32_t kMaxColorAttachments = 16;
+const uint32_t kMaxDrawBuffers = 16;
 
 }  // namespace Anonymous
 
@@ -400,24 +403,25 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
       engine_->GetSharedMemoryBuffer(kSharedMemoryId);
   shared_memory_offset_ = kSharedMemoryOffset;
   shared_memory_address_ =
-      reinterpret_cast<int8*>(buffer->memory()) + shared_memory_offset_;
+      reinterpret_cast<int8_t*>(buffer->memory()) + shared_memory_offset_;
   shared_memory_id_ = kSharedMemoryId;
   shared_memory_base_ = buffer->memory();
 
-  static const int32 kLoseContextWhenOutOfMemory = 0x10002;
-  static const int32 kWebGLVersion = 0x10003;
-
-  int32 attributes[] = {EGL_ALPHA_SIZE,
-                        normalized_init.request_alpha ? 8 : 0,
-                        EGL_DEPTH_SIZE,
-                        normalized_init.request_depth ? 24 : 0,
-                        EGL_STENCIL_SIZE,
-                        normalized_init.request_stencil ? 8 : 0,
-                        kLoseContextWhenOutOfMemory,
-                        normalized_init.lose_context_when_out_of_memory ? 1 : 0,
-                        kWebGLVersion,
-                        init.context_type};
-  std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
+  static const int32_t kLoseContextWhenOutOfMemory = 0x10002;
+  static const int32_t kWebGLVersion = 0x10003;
+
+  int32_t attributes[] = {
+      EGL_ALPHA_SIZE,
+      normalized_init.request_alpha ? 8 : 0,
+      EGL_DEPTH_SIZE,
+      normalized_init.request_depth ? 24 : 0,
+      EGL_STENCIL_SIZE,
+      normalized_init.request_stencil ? 8 : 0,
+      kLoseContextWhenOutOfMemory,
+      normalized_init.lose_context_when_out_of_memory ? 1 : 0,
+      kWebGLVersion,
+      init.context_type};
+  std::vector<int32_t> attribs(attributes, attributes + arraysize(attributes));
 
   decoder_.reset(GLES2Decoder::Create(group_.get()));
   decoder_->SetIgnoreCachedStateForTest(ignore_cached_state_for_test_);
@@ -618,14 +622,16 @@ void GLES2DecoderTestBase::SetBucketData(
   }
 }
 
-void GLES2DecoderTestBase::SetBucketAsCString(
-    uint32 bucket_id, const char* str) {
+void GLES2DecoderTestBase::SetBucketAsCString(uint32_t bucket_id,
+                                              const char* str) {
   SetBucketData(bucket_id, str, str ? (strlen(str) + 1) : 0);
 }
 
-void GLES2DecoderTestBase::SetBucketAsCStrings(
-    uint32 bucket_id, GLsizei count, const char** str,
-    GLsizei count_in_header, char str_end) {
+void GLES2DecoderTestBase::SetBucketAsCStrings(uint32_t bucket_id,
+                                               GLsizei count,
+                                               const char** str,
+                                               GLsizei count_in_header,
+                                               char str_end) {
   uint32_t header_size = sizeof(GLint) * (count + 1);
   uint32_t total_size = header_size;
   scoped_ptr<GLint[]> header(new GLint[count + 1]);
@@ -1167,11 +1173,16 @@ void GLES2DecoderTestBase::DoBindTexImage2DCHROMIUM(GLenum target,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-void GLES2DecoderTestBase::DoTexImage2D(
-    GLenum target, GLint level, GLenum internal_format,
-    GLsizei width, GLsizei height, GLint border,
-    GLenum format, GLenum type,
-    uint32 shared_memory_id, uint32 shared_memory_offset) {
+void GLES2DecoderTestBase::DoTexImage2D(GLenum target,
+                                        GLint level,
+                                        GLenum internal_format,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLint border,
+                                        GLenum format,
+                                        GLenum type,
+                                        uint32_t shared_memory_id,
+                                        uint32_t shared_memory_offset) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
@@ -1189,10 +1200,16 @@ void GLES2DecoderTestBase::DoTexImage2D(
 }
 
 void GLES2DecoderTestBase::DoTexImage2DConvertInternalFormat(
-    GLenum target, GLint level, GLenum requested_internal_format,
-    GLsizei width, GLsizei height, GLint border,
-    GLenum format, GLenum type,
-    uint32 shared_memory_id, uint32 shared_memory_offset,
+    GLenum target,
+    GLint level,
+    GLenum requested_internal_format,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLenum format,
+    GLenum type,
+    uint32_t shared_memory_id,
+    uint32_t shared_memory_offset,
     GLenum expected_internal_format) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -1210,10 +1227,14 @@ void GLES2DecoderTestBase::DoTexImage2DConvertInternalFormat(
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-void GLES2DecoderTestBase::DoCompressedTexImage2D(
-    GLenum target, GLint level, GLenum format,
-    GLsizei width, GLsizei height, GLint border,
-    GLsizei size, uint32 bucket_id) {
+void GLES2DecoderTestBase::DoCompressedTexImage2D(GLenum target,
+                                                  GLint level,
+                                                  GLenum format,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLint border,
+                                                  GLsizei size,
+                                                  uint32_t bucket_id) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
@@ -1343,7 +1364,7 @@ void GLES2DecoderTestBase::AddExpectationsForBindVertexArrayOES() {
       .Times(1)
       .RetiresOnSaturation();
   } else {
-    for (uint32 vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
+    for (uint32_t vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
       AddExpectationsForRestoreAttribState(vv);
     }
 
@@ -1422,17 +1443,17 @@ const GLuint GLES2DecoderTestBase::kServiceVertexArrayId;
 const GLuint GLES2DecoderTestBase::kServiceTransformFeedbackId;
 const GLuint GLES2DecoderTestBase::kServiceSyncId;
 
-const int32 GLES2DecoderTestBase::kSharedMemoryId;
+const int32_t GLES2DecoderTestBase::kSharedMemoryId;
 const size_t GLES2DecoderTestBase::kSharedBufferSize;
-const uint32 GLES2DecoderTestBase::kSharedMemoryOffset;
-const int32 GLES2DecoderTestBase::kInvalidSharedMemoryId;
-const uint32 GLES2DecoderTestBase::kInvalidSharedMemoryOffset;
-const uint32 GLES2DecoderTestBase::kInitialResult;
-const uint8 GLES2DecoderTestBase::kInitialMemoryValue;
+const uint32_t GLES2DecoderTestBase::kSharedMemoryOffset;
+const int32_t GLES2DecoderTestBase::kInvalidSharedMemoryId;
+const uint32_t GLES2DecoderTestBase::kInvalidSharedMemoryOffset;
+const uint32_t GLES2DecoderTestBase::kInitialResult;
+const uint8_t GLES2DecoderTestBase::kInitialMemoryValue;
 
-const uint32 GLES2DecoderTestBase::kNewClientId;
-const uint32 GLES2DecoderTestBase::kNewServiceId;
-const uint32 GLES2DecoderTestBase::kInvalidClientId;
+const uint32_t GLES2DecoderTestBase::kNewClientId;
+const uint32_t GLES2DecoderTestBase::kNewServiceId;
+const uint32_t GLES2DecoderTestBase::kInvalidClientId;
 
 const GLuint GLES2DecoderTestBase::kServiceVertexShaderId;
 const GLuint GLES2DecoderTestBase::kServiceFragmentShaderId;
@@ -1918,28 +1939,29 @@ GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::
 
 scoped_refptr<gpu::Buffer>
 GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::GetSharedMemoryBuffer(
-    int32 shm_id) {
+    int32_t shm_id) {
   return shm_id == kSharedMemoryId ? valid_buffer_ : invalid_buffer_;
 }
 
 void GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::set_token(
-    int32 token) {
+    int32_t token) {
   DCHECK(false);
 }
 
 bool GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::SetGetBuffer(
-    int32 /* transfer_buffer_id */) {
+    int32_t /* transfer_buffer_id */) {
   DCHECK(false);
   return false;
 }
 
 bool GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::SetGetOffset(
-   int32 offset) {
+    int32_t offset) {
   DCHECK(false);
   return false;
 }
 
-int32 GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::GetGetOffset() {
+int32_t
+GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::GetGetOffset() {
   DCHECK(false);
   return 0;
 }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index 3e45b9f..764fe6c 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/message_loop/message_loop.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ -25,8 +28,8 @@
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_mock.h"
+#include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace base {
@@ -46,7 +49,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   // Template to call glGenXXX functions.
   template <typename T>
   void GenHelper(GLuint client_id) {
-    int8 buffer[sizeof(T) + sizeof(client_id)];
+    int8_t buffer[sizeof(T) + sizeof(client_id)];
     T& cmd = *reinterpret_cast<T*>(&buffer);
     cmd.Init(1, &client_id);
     EXPECT_EQ(error::kNoError,
@@ -98,8 +101,8 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   }
 
   template <typename T>
-  T GetSharedMemoryAsWithOffset(uint32 offset) {
-    void* ptr = reinterpret_cast<int8*>(shared_memory_address_) + offset;
+  T GetSharedMemoryAsWithOffset(uint32_t offset) {
+    void* ptr = reinterpret_cast<int8_t*>(shared_memory_address_) + offset;
     return reinterpret_cast<T>(ptr);
   }
 
@@ -178,11 +181,14 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   void DoFenceSync(GLuint client_id, GLuint service_id);
 
   void SetBucketData(uint32_t bucket_id, const void* data, uint32_t data_size);
-  void SetBucketAsCString(uint32 bucket_id, const char* str);
+  void SetBucketAsCString(uint32_t bucket_id, const char* str);
   // If we want a valid bucket, just set |count_in_header| as |count|,
   // and set |str_end| as 0.
-  void SetBucketAsCStrings(uint32 bucket_id, GLsizei count, const char** str,
-                           GLsizei count_in_header, char str_end);
+  void SetBucketAsCStrings(uint32_t bucket_id,
+                           GLsizei count,
+                           const char** str,
+                           GLsizei count_in_header,
+                           char str_end);
 
   void set_memory_tracker(MemoryTracker* memory_tracker) {
     memory_tracker_ = memory_tracker;
@@ -227,7 +233,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
     return decoder_.get();
   }
 
-  uint32 GetAndClearBackbufferClearBitsForTest() const {
+  uint32_t GetAndClearBackbufferClearBitsForTest() const {
     return decoder_->GetAndClearBackbufferClearBitsForTest();
   }
 
@@ -291,22 +297,36 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   void DoDeleteShader(GLuint client_id, GLuint service_id);
   void DoDeleteTexture(GLuint client_id, GLuint service_id);
 
-  void DoCompressedTexImage2D(
-      GLenum target, GLint level, GLenum format,
-      GLsizei width, GLsizei height, GLint border,
-      GLsizei size, uint32 bucket_id);
+  void DoCompressedTexImage2D(GLenum target,
+                              GLint level,
+                              GLenum format,
+                              GLsizei width,
+                              GLsizei height,
+                              GLint border,
+                              GLsizei size,
+                              uint32_t bucket_id);
   void DoBindTexImage2DCHROMIUM(GLenum target, GLint image_id);
-  void DoTexImage2D(
-      GLenum target, GLint level, GLenum internal_format,
-      GLsizei width, GLsizei height, GLint border,
-      GLenum format, GLenum type,
-      uint32 shared_memory_id, uint32 shared_memory_offset);
-  void DoTexImage2DConvertInternalFormat(
-      GLenum target, GLint level, GLenum requested_internal_format,
-      GLsizei width, GLsizei height, GLint border,
-      GLenum format, GLenum type,
-      uint32 shared_memory_id, uint32 shared_memory_offset,
-      GLenum expected_internal_format);
+  void DoTexImage2D(GLenum target,
+                    GLint level,
+                    GLenum internal_format,
+                    GLsizei width,
+                    GLsizei height,
+                    GLint border,
+                    GLenum format,
+                    GLenum type,
+                    uint32_t shared_memory_id,
+                    uint32_t shared_memory_offset);
+  void DoTexImage2DConvertInternalFormat(GLenum target,
+                                         GLint level,
+                                         GLenum requested_internal_format,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         uint32_t shared_memory_id,
+                                         uint32_t shared_memory_offset,
+                                         GLenum expected_internal_format);
   void DoRenderbufferStorage(
       GLenum target, GLenum internal_format, GLenum actual_format,
       GLsizei width, GLsizei height, GLenum error);
@@ -434,9 +454,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   void AddExpectationsForBindVertexArrayOES();
   void AddExpectationsForRestoreAttribState(GLuint attrib);
 
-  GLvoid* BufferOffset(unsigned i) {
-    return static_cast<int8 *>(NULL)+(i);
-  }
+  GLvoid* BufferOffset(unsigned i) { return static_cast<int8_t*>(NULL) + (i); }
 
   template <typename Command, typename Result>
   bool IsObjectHelper(GLuint client_id) {
@@ -486,17 +504,17 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   static const GLuint kServiceTransformFeedbackId = 311;
   static const GLuint kServiceSyncId = 312;
 
-  static const int32 kSharedMemoryId = 401;
+  static const int32_t kSharedMemoryId = 401;
   static const size_t kSharedBufferSize = 2048;
-  static const uint32 kSharedMemoryOffset = 132;
-  static const int32 kInvalidSharedMemoryId = 402;
-  static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
-  static const uint32 kInitialResult = 0xBDBDBDBDu;
-  static const uint8 kInitialMemoryValue = 0xBDu;
+  static const uint32_t kSharedMemoryOffset = 132;
+  static const int32_t kInvalidSharedMemoryId = 402;
+  static const uint32_t kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
+  static const uint32_t kInitialResult = 0xBDBDBDBDu;
+  static const uint8_t kInitialMemoryValue = 0xBDu;
 
-  static const uint32 kNewClientId = 501;
-  static const uint32 kNewServiceId = 502;
-  static const uint32 kInvalidClientId = 601;
+  static const uint32_t kNewClientId = 501;
+  static const uint32_t kNewServiceId = 502;
+  static const uint32_t kInvalidClientId = 601;
 
   static const GLuint kServiceVertexShaderId = 321;
   static const GLuint kServiceFragmentShaderId = 322;
@@ -617,15 +635,15 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   GLuint client_transformfeedback_id_;
   GLuint client_sync_id_;
 
-  uint32 shared_memory_id_;
-  uint32 shared_memory_offset_;
+  uint32_t shared_memory_id_;
+  uint32_t shared_memory_offset_;
   void* shared_memory_address_;
   void* shared_memory_base_;
 
   GLuint service_renderbuffer_id_;
   bool service_renderbuffer_valid_;
 
-  uint32 immediate_buffer_[64];
+  uint32_t immediate_buffer_[64];
 
   const bool ignore_cached_state_for_test_;
   bool cached_color_mask_red_;
@@ -660,21 +678,21 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
 
     ~MockCommandBufferEngine() override;
 
-    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override;
+    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32_t shm_id) override;
 
     void ClearSharedMemory() {
       memset(valid_buffer_->memory(), kInitialMemoryValue, kSharedBufferSize);
     }
 
-    void set_token(int32 token) override;
+    void set_token(int32_t token) override;
 
-    bool SetGetBuffer(int32 /* transfer_buffer_id */) override;
+    bool SetGetBuffer(int32_t /* transfer_buffer_id */) override;
 
     // Overridden from CommandBufferEngine.
-    bool SetGetOffset(int32 offset) override;
+    bool SetGetOffset(int32_t offset) override;
 
     // Overridden from CommandBufferEngine.
-    int32 GetGetOffset() override;
+    int32_t GetGetOffset() override;
 
    private:
     scoped_refptr<gpu::Buffer> valid_buffer_;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc
index 389c78f..5af242b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
index 1b3feaa..5301a49 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_context_state.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -86,8 +88,8 @@ class GLES2DecoderRestoreStateTest : public GLES2DecoderManualInitTest {
   void AddExpectationsForActiveTexture(GLenum unit);
   void AddExpectationsForBindTexture(GLenum target, GLuint id);
   void InitializeContextState(ContextState* state,
-                              uint32 non_default_unit,
-                              uint32 active_unit);
+                              uint32_t non_default_unit,
+                              uint32_t active_unit);
 };
 
 INSTANTIATE_TEST_CASE_P(Service,
@@ -106,10 +108,10 @@ void GLES2DecoderRestoreStateTest::AddExpectationsForBindTexture(GLenum target,
 
 void GLES2DecoderRestoreStateTest::InitializeContextState(
     ContextState* state,
-    uint32 non_default_unit,
-    uint32 active_unit) {
+    uint32_t non_default_unit,
+    uint32_t active_unit) {
   state->texture_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) {
     TextureRef* ref_cube_map =
         group().texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
     state->texture_units[tt].bound_texture_cube_map = ref_cube_map;
@@ -136,7 +138,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NullPreviousStateBGR) {
                                 TestHelper::kServiceDefaultTextureCubemapId);
 
   // Expect to restore texture bindings for remaining units.
-  for (uint32 i = 1; i < group().max_texture_units(); ++i) {
+  for (uint32_t i = 1; i < group().max_texture_units(); ++i) {
     AddExpectationsForActiveTexture(GL_TEXTURE0 + i);
     AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                   TestHelper::kServiceDefaultTexture2dId);
@@ -162,7 +164,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NullPreviousState) {
   AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP, 0);
 
   // Expect to restore texture bindings for remaining units.
-  for (uint32 i = 1; i < group().max_texture_units(); ++i) {
+  for (uint32_t i = 1; i < group().max_texture_units(); ++i) {
     AddExpectationsForActiveTexture(GL_TEXTURE0 + i);
     AddExpectationsForBindTexture(GL_TEXTURE_2D, 0);
     AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP, 0);
@@ -183,7 +185,7 @@ TEST_P(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
   ContextState prev_state(NULL, NULL, NULL);
-  InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
+  InitializeContextState(&prev_state, std::numeric_limits<uint32_t>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE0 unit,
@@ -206,7 +208,7 @@ TEST_P(GLES2DecoderRestoreStateTest, WithPreviousState) {
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
   ContextState prev_state(NULL, NULL, NULL);
-  InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
+  InitializeContextState(&prev_state, std::numeric_limits<uint32_t>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE0 unit,
@@ -236,7 +238,7 @@ TEST_P(GLES2DecoderRestoreStateTest, ActiveUnit1) {
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
   ContextState prev_state(NULL, NULL, NULL);
-  InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
+  InitializeContextState(&prev_state, std::numeric_limits<uint32_t>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE1 unit,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
index fefc36b..40d1361 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_drawing.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -2058,9 +2060,9 @@ TEST_P(GLES2DecoderManualInitTest, DrawArraysClearsAfterTexImage2DNULLCubemap) {
   // Fill out all the faces for 2 levels, leave 2 uncleared.
   for (int ii = 0; ii < 6; ++ii) {
     GLenum face = faces[ii];
-    int32 shm_id =
+    int32_t shm_id =
         (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryId;
-    uint32 shm_offset =
+    uint32_t shm_offset =
         (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryOffset;
     DoTexImage2D(face,
                  0,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions.cc
index d295183..c1dee79 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ -163,7 +166,7 @@ TEST_P(GLES2DecoderTestDisabledExtensions, CHROMIUMPathRenderingDisabled) {
   }
   {
     cmds::BindFragmentInputLocationCHROMIUMBucket cmd;
-    const uint32 kBucketId = 123;
+    const uint32_t kBucketId = 123;
     const GLint kLocation = 2;
     const char* kName = "testing";
     SetBucketAsCString(kBucketId, kName);
@@ -248,11 +251,11 @@ class GLES2DecoderTestWithCHROMIUMPathRendering : public GLES2DecoderTest {
                               // since the implementation modifies the memory
                               // area.
     void* paths = NULL;
-    uint32 paths_shm_id = 0;
-    uint32 paths_shm_offset = 0;
+    uint32_t paths_shm_id = 0;
+    uint32_t paths_shm_offset = 0;
     GLfloat* transforms = NULL;
-    uint32 transforms_shm_id = 0;
-    uint32 transforms_shm_offset = 0;
+    uint32_t transforms_shm_id = 0;
+    uint32_t transforms_shm_offset = 0;
 
     if (testcase.transform_values) {
       transforms = GetSharedMemoryAs<GLfloat*>();
@@ -404,10 +407,10 @@ class GLES2DecoderTestWithCHROMIUMPathRendering : public GLES2DecoderTest {
   void CallAllInstancedCommandsWithInvalidSHM(GLsizei num_paths,
                                               const GLuint* paths,
                                               GLuint* paths_shm,
-                                              uint32 paths_shm_id,
-                                              uint32 paths_shm_offset,
-                                              uint32 transforms_shm_id,
-                                              uint32 transforms_shm_offset) {
+                                              uint32_t paths_shm_id,
+                                              uint32_t paths_shm_offset,
+                                              uint32_t transforms_shm_id,
+                                              uint32_t transforms_shm_offset) {
     const GLuint kPathBase = 0;
     const GLenum kFillMode = GL_INVERT;
     const GLuint kMask = 0x80;
@@ -1638,14 +1641,15 @@ TEST_P(GLES2DecoderTestWithCHROMIUMPathRendering, InstancedInvalidSHMValues) {
 
   for (int testcase = kFirstTestcase; testcase <= kLastTestcase; ++testcase) {
     GLfloat* transforms = GetSharedMemoryAs<GLfloat*>();
-    uint32 transforms_shm_id = shared_memory_id_;
-    uint32 transforms_shm_offset = shared_memory_offset_;
+    uint32_t transforms_shm_id = shared_memory_id_;
+    uint32_t transforms_shm_offset = shared_memory_offset_;
     memcpy(transforms, transform_values, sizeof(transform_values));
 
     GLuint* paths =
         GetSharedMemoryAsWithOffset<GLuint*>(sizeof(transform_values));
-    uint32 paths_shm_id = shared_memory_id_;
-    uint32 paths_shm_offset = shared_memory_offset_ + sizeof(transform_values);
+    uint32_t paths_shm_id = shared_memory_id_;
+    uint32_t paths_shm_offset =
+        shared_memory_offset_ + sizeof(transform_values);
 
     if (testcase & kPathsSHMIdInvalid) {
       paths_shm_id = kInvalidSharedMemoryId;
@@ -1669,7 +1673,7 @@ TEST_P(GLES2DecoderTestWithCHROMIUMPathRendering, InstancedInvalidSHMValues) {
 
 TEST_P(GLES2DecoderTestWithCHROMIUMPathRendering,
        BindFragmentInputLocationCHROMIUM) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   const char* kBadName1 = "gl_testing";
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
index c8a7197..5d14251 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -404,8 +407,8 @@ class ReadPixelsEmulator {
         height_(height),
         pack_alignment_(pack_alignment),
         bytes_per_pixel_(bytes_per_pixel),
-        src_pixels_(reinterpret_cast<const int8*>(src_pixels)),
-        expected_pixels_(reinterpret_cast<const int8*>(expected_pixels)) {}
+        src_pixels_(reinterpret_cast<const int8_t*>(src_pixels)),
+        expected_pixels_(reinterpret_cast<const int8_t*>(expected_pixels)) {}
 
   void ReadPixels(GLint x,
                   GLint y,
@@ -419,7 +422,7 @@ class ReadPixelsEmulator {
     DCHECK_LE(x + width, width_);
     DCHECK_LE(y + height, height_);
     for (GLint yy = 0; yy < height; ++yy) {
-      const int8* src = GetPixelAddress(src_pixels_, x, y + yy);
+      const int8_t* src = GetPixelAddress(src_pixels_, x, y + yy);
       const void* dst = ComputePackAlignmentAddress(0, yy, width, pixels);
       memcpy(const_cast<void*>(dst), src, width * bytes_per_pixel_);
     }
@@ -444,7 +447,7 @@ class ReadPixelsEmulator {
     GLint two_rows_size = ComputeImageDataSize(width, 2);
     GLsizei padded_row_size = two_rows_size - unpadded_row_size;
     GLint offset = y * padded_row_size + x * bytes_per_pixel_;
-    return static_cast<const int8*>(address) + offset;
+    return static_cast<const int8_t*>(address) + offset;
   }
 
   GLint ComputeImageDataSize(GLint width, GLint height) const {
@@ -460,7 +463,7 @@ class ReadPixelsEmulator {
   }
 
  private:
-  const int8* GetPixelAddress(const int8* base, GLint x, GLint y) const {
+  const int8_t* GetPixelAddress(const int8_t* base, GLint x, GLint y) const {
     return base + (width_ * y + x) * bytes_per_pixel_;
   }
 
@@ -468,8 +471,8 @@ class ReadPixelsEmulator {
   GLsizei height_;
   GLint pack_alignment_;
   GLint bytes_per_pixel_;
-  const int8* src_pixels_;
-  const int8* expected_pixels_;
+  const int8_t* src_pixels_;
+  const int8_t* expected_pixels_;
 };
 
 }  // anonymous namespace
@@ -484,12 +487,11 @@ void GLES2DecoderTest::CheckReadPixelsOutOfRange(GLint in_read_x,
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
   const GLenum kFormat = GL_RGBA;
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 18, 19, 18, 255, 19, 12, 13, 255, 14, 18, 19, 255,
       18, 19, 13, 255, 29, 28, 23, 255, 22, 21, 22, 255, 21, 29, 28, 255,
       23, 22, 21, 255, 22, 21, 28, 255, 31, 34, 39, 255, 37, 32, 37, 255,
-      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255
-  };
+      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255};
 
   ClearSharedMemory();
 
@@ -525,10 +527,10 @@ void GLES2DecoderTest::CheckReadPixelsOutOfRange(GLint in_read_x,
       kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -566,12 +568,12 @@ void GLES2DecoderTest::CheckReadPixelsOutOfRange(GLint in_read_x,
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   GLint unpadded_row_size = emu.ComputeImageDataSize(in_read_width, 1);
-  scoped_ptr<int8[]> zero(new int8[unpadded_row_size]);
-  scoped_ptr<int8[]> pack(new int8[kPackAlignment]);
+  scoped_ptr<int8_t[]> zero(new int8_t[unpadded_row_size]);
+  scoped_ptr<int8_t[]> pack(new int8_t[kPackAlignment]);
   memset(zero.get(), 0, unpadded_row_size);
   memset(pack.get(), kInitialMemoryValue, kPackAlignment);
   for (GLint yy = 0; yy < in_read_height; ++yy) {
-    const int8* row = static_cast<const int8*>(
+    const int8_t* row = static_cast<const int8_t*>(
         emu.ComputePackAlignmentAddress(0, yy, in_read_width, dest));
     GLint y = in_read_y + yy;
     if (y < 0 || y >= kHeight) {
@@ -616,12 +618,11 @@ TEST_P(GLES2DecoderTest, ReadPixels) {
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 18, 19, 18, 255, 19, 12, 13, 255, 14, 18, 19, 255,
       18, 19, 13, 255, 29, 28, 23, 255, 22, 21, 22, 255, 21, 29, 28, 255,
       23, 22, 21, 255, 22, 21, 28, 255, 31, 34, 39, 255, 37, 32, 37, 255,
-      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255
-  };
+      32, 31, 34, 255, 39, 37, 32, 255, 37, 32, 34, 255};
 
   surface_->SetSize(gfx::Size(INT_MAX, INT_MAX));
 
@@ -629,10 +630,10 @@ TEST_P(GLES2DecoderTest, ReadPixels) {
       kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -687,10 +688,10 @@ TEST_P(GLES3DecoderTest, ReadPixelsBufferBound) {
   const GLint kBytesPerPixel = 4;
   GLint size = kWidth * kHeight * kBytesPerPixel;
   EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(ReadPixels::Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(ReadPixels::Result);
 
   DoBindBuffer(GL_PIXEL_PACK_BUFFER, client_buffer_id_, kServiceBufferId);
   DoBufferData(GL_PIXEL_PACK_BUFFER, size);
@@ -813,12 +814,12 @@ TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
-  static const uint8 kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 255, 19, 18, 19, 255, 13, 14, 18, 255,
       29, 28, 23, 255, 21, 22, 21, 255, 28, 23, 22, 255,
       31, 34, 39, 255, 32, 37, 32, 255, 34, 39, 37, 255,
   };
-  static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
+  static const uint8_t kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
       12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 29, 28, 23, 22, 21, 22,
       21, 29, 28, 23, 22, 21, 31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32,
   };
@@ -833,10 +834,10 @@ TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
                          kPackAlignment);
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   void* dest = &result[1];
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -897,10 +898,10 @@ TEST_P(GLES2DecoderTest, ReadPixelsOutOfRange) {
 
 TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
   ReadPixels cmd;
   cmd.Init(0,
@@ -1005,10 +1006,10 @@ TEST_P(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
 
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
 
   EXPECT_CALL(*gl_, GetError())
       // first error check must pass to get to the test
@@ -1992,10 +1993,10 @@ TEST_P(GLES2DecoderTest, ReadPixelsGLError) {
   GLsizei width = 2;
   GLsizei height = 4;
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
@@ -2123,10 +2124,10 @@ TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
       .Times(1)
       .RetiresOnSaturation();
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   ReadPixels cmd;
   cmd.Init(0,
            0,
@@ -2452,10 +2453,10 @@ TEST_P(GLES2DecoderManualInitTest,
       .Times(1)
       .RetiresOnSaturation();
   typedef ReadPixels::Result Result;
-  uint32 result_shm_id = kSharedMemoryId;
-  uint32 result_shm_offset = kSharedMemoryOffset;
-  uint32 pixels_shm_id = kSharedMemoryId;
-  uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
+  uint32_t result_shm_id = kSharedMemoryId;
+  uint32_t result_shm_offset = kSharedMemoryOffset;
+  uint32_t pixels_shm_id = kSharedMemoryId;
+  uint32_t pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   ReadPixels cmd;
   cmd.Init(0,
            0,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
index 5571adf..be022e1 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -49,7 +52,7 @@ namespace gles2 {
 using namespace cmds;
 
 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetProgramInfoCHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -58,7 +61,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetProgramInfoCHROMIUM cmd;
@@ -77,7 +80,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetUniformBlocksCHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
@@ -100,7 +103,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMValidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetUniformBlocksCHROMIUM cmd;
@@ -118,7 +121,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetUniformsES3CHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
@@ -141,7 +144,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMValidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetUniformsES3CHROMIUM cmd;
@@ -160,7 +163,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMInvalidArgs) {
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetTransformFeedbackVaryingsCHROMIUMValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetTransformFeedbackVaryingsCHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_CALL(*(gl_.get()),
@@ -194,7 +197,7 @@ TEST_P(GLES2DecoderWithShaderTest,
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetTransformFeedbackVaryingsCHROMIUMInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetTransformFeedbackVaryingsCHROMIUM cmd;
@@ -225,7 +228,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
@@ -242,7 +245,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
@@ -334,7 +337,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformuivSucceeds) {
   decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
   decoder_->set_unsafe_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
@@ -354,7 +357,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformuivArrayElementSucceeds) {
   decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformuivBadProgramFails) {
@@ -448,7 +451,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
@@ -465,7 +468,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetElementCountForUniformType(kUniform2Type),
-            static_cast<uint32>(result->GetNumResults()));
+            static_cast<uint32_t>(result->GetNumResults()));
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
@@ -676,7 +679,7 @@ TEST_P(GLES2DecoderWithShaderTest,
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
   const GLuint kUniformIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -701,7 +704,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
   const GLuint kUniformIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -716,7 +719,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
   const GLuint kUniformIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -743,7 +746,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -760,7 +763,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
   const GLuint kUniformIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniform cmd;
   cmd.Init(client_program_id_,
            kUniformIndex,
@@ -777,7 +780,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameSucceeds) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -815,7 +818,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameSucceeds) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameUnlinkedProgram) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -836,7 +839,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameUnlinkedProgram) {
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockNameResultNotInitFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -851,7 +854,7 @@ TEST_P(GLES2DecoderWithShaderTest,
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameBadProgramFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   typedef GetActiveUniformBlockName::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -869,7 +872,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameBadProgramFails) {
 
 TEST_P(GLES2DecoderWithShaderTest,
        GetActiveUniformBlockNameBadSharedMemoryFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveUniformBlockName cmd;
   decoder_->set_unsafe_es3_apis_enabled(true);
   cmd.Init(client_program_id_,
@@ -1057,7 +1060,7 @@ TEST_P(GLES2DecoderWithShaderTest,
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
   const GLuint kAttribIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1081,7 +1084,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
   const GLuint kAttribIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1096,7 +1099,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
   const GLuint kAttribIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1123,7 +1126,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1140,7 +1143,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
   const GLuint kAttribIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetActiveAttrib cmd;
   cmd.Init(client_program_id_,
            kAttribIndex,
@@ -1157,7 +1160,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesSucceeds) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
@@ -1195,7 +1198,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesSucceeds) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadProgramFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
@@ -1230,7 +1233,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadProgramFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadParamsFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
@@ -1263,7 +1266,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadParamsFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesResultNotInitFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
@@ -1283,7 +1286,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesResultNotInitFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadSharedMemoryFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName0[] = "Cow";
   const char kName1[] = "Chicken";
   const char* kNames[] = { kName0, kName1 };
@@ -1309,7 +1312,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadSharedMemoryFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivSucceeds) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const GLint kResults[] = { 1976, 321 };
   const size_t kCount = arraysize(kIndices);
@@ -1347,7 +1350,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivSucceeds) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadProgramFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
@@ -1381,7 +1384,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadProgramFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadParamsFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const GLint kResults[] = { 1976, 321 };
   const size_t kCount = arraysize(kIndices);
@@ -1414,7 +1417,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadParamsFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadPnameFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
@@ -1445,7 +1448,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadPnameFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivResultNotInitFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
@@ -1463,7 +1466,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivResultNotInitFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadSharedMemoryFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndices[] = { 1, 2 };
   const size_t kCount = arraysize(kIndices);
   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
@@ -1488,7 +1491,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadSharedMemoryFails) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "void main() { gl_Position = vec4(1.0); }";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -1525,7 +1528,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetShaderInfoLog cmd;
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -1534,7 +1537,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingSucceeds) {
   const GLuint kIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kName[] = "HolyCow";
   const GLsizei kBufferSize = static_cast<GLsizei>(strlen(kName) + 1);
   const GLsizei kSize = 2;
@@ -1583,7 +1586,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingSucceeds) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingNotInitFails) {
   const GLuint kIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1599,7 +1602,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingNotInitFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadProgramFails) {
   const GLuint kIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1617,7 +1620,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadProgramFails) {
 
 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadParamsFails) {
   const GLuint kIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLsizei kBufferSize = 10;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
@@ -1653,7 +1656,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadParamsFails) {
 TEST_P(GLES2DecoderWithShaderTest,
        GetTransformFeedbackVaryingBadSharedMemoryFails) {
   const GLuint kIndex = 1;
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   GetTransformFeedbackVarying cmd;
   typedef GetTransformFeedbackVarying::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1675,7 +1678,7 @@ TEST_P(GLES2DecoderWithShaderTest,
 
 TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
   // ShaderSource should not actually call any GL calls yet.
-  const uint32 kInBucketId = 123;
+  const uint32_t kInBucketId = 123;
   const char kSource0[] = "void main() { gl_Position = vec4(1.0); }";
   const char* kSource[] = {kSource0};
   const char kValidStrEnd = 0;
@@ -1724,8 +1727,8 @@ TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
-  const uint32 kInBucketId = 123;
-  const uint32 kOutBucketId = 125;
+  const uint32_t kInBucketId = 123;
+  const uint32_t kOutBucketId = 125;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
@@ -1746,7 +1749,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
 
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 TEST_P(GLES2DecoderTest, ShaderSourceBucketWithProgramId) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
@@ -1759,7 +1762,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceBucketWithProgramId) {
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 
 TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
-  const uint32 kInBucketId = 123;
+  const uint32_t kInBucketId = 123;
   const char kSource0[] = "hello/*te\ast*/world//a\ab";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
@@ -1967,7 +1970,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform4uivImmediateValidArgs) {
 }
 
 TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   EXPECT_CALL(*gl_,
@@ -1980,7 +1983,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
 }
 
 TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
@@ -2000,7 +2003,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char* kNonExistentName = "foobar";
   typedef GetAttribLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
@@ -2018,7 +2021,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   typedef GetAttribLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
@@ -2048,7 +2051,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocation) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   typedef GetFragDataLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   SetBucketAsCString(kBucketId, kOutputVariable1NameESSL3);
@@ -2063,7 +2066,7 @@ TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocation) {
 }
 
 TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocationInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   typedef GetFragDataLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
@@ -2095,7 +2098,7 @@ TEST_P(GLES3DecoderWithESSL3ShaderTest, GetFragDataLocationInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndex) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLuint kIndex = 10;
   const char* kName = "color";
   typedef GetUniformBlockIndex::Result Result;
@@ -2115,7 +2118,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndex) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndexInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   typedef GetUniformBlockIndex::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = GL_INVALID_INDEX;
@@ -2147,7 +2150,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndexInvalidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const char* kNonExistentName = "foobar";
   typedef GetUniformLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
@@ -2165,7 +2168,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   typedef GetUniformLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
@@ -2207,7 +2210,7 @@ TEST_P(GLES2DecoderWithShaderTest, UniformBlockBindingValidArgs) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUMBucket) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   const char* kBadName1 = "gl_testing";
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index 58443ec..b0f2162 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ -700,8 +703,8 @@ TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexImage3DBucket) {
-  const uint32 kBucketId = 123;
-  const uint32 kBadBucketId = 99;
+  const uint32_t kBucketId = 123;
+  const uint32_t kBadBucketId = 99;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
@@ -747,7 +750,7 @@ TEST_P(GLES3DecoderTest, CompressedTexImage3DBucket) {
 }
 
 TEST_P(GLES2DecoderTest, CompressedTexImage3DFailsOnES2) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
@@ -786,7 +789,7 @@ TEST_P(GLES2DecoderTest, CompressedTexImage3DFailsOnES2) {
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexImage3DFailsWithBadImageSize) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
@@ -813,7 +816,7 @@ TEST_P(GLES3DecoderTest, CompressedTexImage3DFailsWithBadImageSize) {
 }
 
 TEST_P(GLES3DecoderTest, CompressedTexSubImage3DFails) {
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
   const GLint kLevel = 0;
   const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
@@ -952,7 +955,7 @@ TEST_P(GLES3DecoderTest, CompressedTexSubImage3DFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Bad bucket id.
-  const uint32 kBadBucketId = 444;
+  const uint32_t kBadBucketId = 444;
   cmd.Init(kTarget,
            kLevel,
            kXOffset,
@@ -973,7 +976,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
   init.bind_generates_resource = true;
   InitDecoder(init);
 
-  const uint32 kBadBucketId = 123;
+  const uint32_t kBadBucketId = 123;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   CompressedTexImage2DBucket cmd;
   cmd.Init(GL_TEXTURE_2D,
@@ -1009,7 +1012,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.bind_generates_resource = true;
   InitDecoder(init);
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
@@ -1167,7 +1170,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
-  const uint32 kBucketId = 123;
+  const uint32_t kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
@@ -1285,7 +1288,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
                 GL_TEXTURE_BINDING_EXTERNAL_OES),
             result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
+  EXPECT_EQ(client_texture_id_, (uint32_t)result->GetData()[0]);
 }
 
 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
@@ -1690,7 +1693,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
                 GL_TEXTURE_BINDING_RECTANGLE_ARB),
             result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
+  EXPECT_EQ(client_texture_id_, (uint32_t)result->GetData()[0]);
 }
 
 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
@@ -2866,7 +2869,7 @@ TEST_P(GLES2DecoderWithShaderTest, CopyTexImage) {
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
-  const int32 kImageId = 1;
+  const int32_t kImageId = 1;
   scoped_refptr<MockGLImage> image(new MockGLImage);
   GetImageManager()->AddImage(image.get(), kImageId);
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_valuebuffer.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_valuebuffer.cc
index 47e6a6b..8f1b0e0 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_valuebuffer.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_valuebuffer.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ -24,7 +26,7 @@ namespace gles2 {
 using namespace cmds;
 
 TEST_P(GLES2DecoderWithShaderTest, ValuebufferBasic) {
-  const uint32 kBufferId = 123;
+  const uint32_t kBufferId = 123;
   ValueState valuestate;
   valuestate.int_value[0] = 111;
   valuestate.int_value[1] = 222;
@@ -48,7 +50,7 @@ TEST_P(GLES2DecoderWithShaderTest, ValuebufferBasic) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, SubscribeValuebufferNotBound) {
-  const uint32 kBufferId = 123;
+  const uint32_t kBufferId = 123;
   ValueState valuestate;
   valuestate.int_value[0] = 111;
   valuestate.int_value[1] = 222;
@@ -62,7 +64,7 @@ TEST_P(GLES2DecoderWithShaderTest, SubscribeValuebufferNotBound) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, PopulateValuebufferNoSubscription) {
-  const uint32 kBufferId = 123;
+  const uint32_t kBufferId = 123;
   ValueState valuestate;
   valuestate.int_value[0] = 111;
   valuestate.int_value[1] = 222;
@@ -79,7 +81,7 @@ TEST_P(GLES2DecoderWithShaderTest, PopulateValuebufferNoSubscription) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, UniformValuebufferNoState) {
-  const uint32 kBufferId = 123;
+  const uint32_t kBufferId = 123;
   ValueState valuestate;
   valuestate.int_value[0] = 111;
   valuestate.int_value[1] = 222;
@@ -101,7 +103,7 @@ TEST_P(GLES2DecoderWithShaderTest, UniformValuebufferNoState) {
 }
 
 TEST_P(GLES2DecoderWithShaderTest, UniformValuebufferInvalidLocation) {
-  const uint32 kBufferId = 123;
+  const uint32_t kBufferId = 123;
   ValueState valuestate;
   valuestate.int_value[0] = 111;
   valuestate.int_value[1] = 222;
diff --git a/gpu/command_buffer/service/gles2_cmd_validation.cc b/gpu/command_buffer/service/gles2_cmd_validation.cc
index 8d4fd71..3631613 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation.cc
+++ b/gpu/command_buffer/service/gles2_cmd_validation.cc
@@ -4,7 +4,6 @@
 
 // Contains various validation functions for the GLES2 service.
 
-#include "base/basictypes.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gl_utils.h"
diff --git a/gpu/command_buffer/service/gpu_scheduler.cc b/gpu/command_buffer/service/gpu_scheduler.cc
index aa311b6..836109e 100644
--- a/gpu/command_buffer/service/gpu_scheduler.cc
+++ b/gpu/command_buffer/service/gpu_scheduler.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ -67,7 +69,7 @@ void GpuScheduler::PutChanged() {
     // TODO(piman): various classes duplicate various pieces of state, leading
     // to needlessly complex update logic. It should be possible to simply
     // share the state across all of them.
-    command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
+    command_buffer_->SetGetOffset(static_cast<int32_t>(parser_->get()));
 
     if (error::IsError(error)) {
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
@@ -117,15 +119,15 @@ void GpuScheduler::SetSchedulingChangedCallback(
   scheduling_changed_callback_ = callback;
 }
 
-scoped_refptr<Buffer> GpuScheduler::GetSharedMemoryBuffer(int32 shm_id) {
+scoped_refptr<Buffer> GpuScheduler::GetSharedMemoryBuffer(int32_t shm_id) {
   return command_buffer_->GetTransferBuffer(shm_id);
 }
 
-void GpuScheduler::set_token(int32 token) {
+void GpuScheduler::set_token(int32_t token) {
   command_buffer_->SetToken(token);
 }
 
-bool GpuScheduler::SetGetBuffer(int32 transfer_buffer_id) {
+bool GpuScheduler::SetGetBuffer(int32_t transfer_buffer_id) {
   scoped_refptr<Buffer> ring_buffer =
       command_buffer_->GetTransferBuffer(transfer_buffer_id);
   if (!ring_buffer.get()) {
@@ -143,15 +145,15 @@ bool GpuScheduler::SetGetBuffer(int32 transfer_buffer_id) {
   return true;
 }
 
-bool GpuScheduler::SetGetOffset(int32 offset) {
+bool GpuScheduler::SetGetOffset(int32_t offset) {
   if (parser_->set_get(offset)) {
-    command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
+    command_buffer_->SetGetOffset(static_cast<int32_t>(parser_->get()));
     return true;
   }
   return false;
 }
 
-int32 GpuScheduler::GetGetOffset() {
+int32_t GpuScheduler::GetGetOffset() {
   return parser_->get();
 }
 
diff --git a/gpu/command_buffer/service/gpu_scheduler.h b/gpu/command_buffer/service/gpu_scheduler.h
index 11a6d31..b3fd7e7 100644
--- a/gpu/command_buffer/service/gpu_scheduler.h
+++ b/gpu/command_buffer/service/gpu_scheduler.h
@@ -5,11 +5,14 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GPU_SCHEDULER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_SCHEDULER_H_
 
+#include <stdint.h>
+
 #include <queue>
 
 #include "base/atomic_ref_count.h"
 #include "base/atomicops.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -85,11 +88,11 @@ class GPU_EXPORT GpuScheduler
   void SetSchedulingChangedCallback(const SchedulingChangedCallback& callback);
 
   // Implementation of CommandBufferEngine.
-  scoped_refptr<Buffer> GetSharedMemoryBuffer(int32 shm_id) override;
-  void set_token(int32 token) override;
-  bool SetGetBuffer(int32 transfer_buffer_id) override;
-  bool SetGetOffset(int32 offset) override;
-  int32 GetGetOffset() override;
+  scoped_refptr<Buffer> GetSharedMemoryBuffer(int32_t shm_id) override;
+  void set_token(int32_t token) override;
+  bool SetGetBuffer(int32_t transfer_buffer_id) override;
+  bool SetGetOffset(int32_t offset) override;
+  int32_t GetGetOffset() override;
 
   void SetCommandProcessedCallback(const base::Closure& callback);
 
diff --git a/gpu/command_buffer/service/gpu_scheduler_unittest.cc b/gpu/command_buffer/service/gpu_scheduler_unittest.cc
index 77d9473..a3ab1e0 100644
--- a/gpu/command_buffer/service/gpu_scheduler_unittest.cc
+++ b/gpu/command_buffer/service/gpu_scheduler_unittest.cc
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/command_buffer_mock.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
@@ -24,12 +27,12 @@ const size_t kRingBufferSize = 1024;
 
 class GpuSchedulerTest : public testing::Test {
  protected:
-  static const int32 kTransferBufferId = 123;
+  static const int32_t kTransferBufferId = 123;
 
   void SetUp() override {
     scoped_ptr<base::SharedMemory> shared_memory(new ::base::SharedMemory);
     shared_memory->CreateAndMapAnonymous(kRingBufferSize);
-    buffer_ = static_cast<int32*>(shared_memory->memory());
+    buffer_ = static_cast<int32_t*>(shared_memory->memory());
     shared_memory_buffer_ =
         MakeBufferFromSharedMemory(std::move(shared_memory), kRingBufferSize);
     memset(buffer_, 0, kRingBufferSize);
@@ -69,7 +72,7 @@ class GpuSchedulerTest : public testing::Test {
 
   scoped_ptr<MockCommandBuffer> command_buffer_;
   scoped_refptr<Buffer> shared_memory_buffer_;
-  int32* buffer_;
+  int32_t* buffer_;
   scoped_ptr<gles2::MockGLES2Decoder> decoder_;
   scoped_ptr<GpuScheduler> scheduler_;
   base::MessageLoop message_loop_;
diff --git a/gpu/command_buffer/service/gpu_state_tracer.cc b/gpu/command_buffer/service/gpu_state_tracer.cc
index 9b8db2a..7acc346 100644
--- a/gpu/command_buffer/service/gpu_state_tracer.cc
+++ b/gpu/command_buffer/service/gpu_state_tracer.cc
@@ -5,6 +5,7 @@
 #include "gpu/command_buffer/service/gpu_state_tracer.h"
 
 #include "base/base64.h"
+#include "base/macros.h"
 #include "base/trace_event/trace_event.h"
 #include "context_state.h"
 #include "ui/gfx/codec/png_codec.h"
diff --git a/gpu/command_buffer/service/gpu_state_tracer.h b/gpu/command_buffer/service/gpu_state_tracer.h
index 38998f3..1cb7fe9 100644
--- a/gpu/command_buffer/service/gpu_state_tracer.h
+++ b/gpu/command_buffer/service/gpu_state_tracer.h
@@ -5,7 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GPU_STATE_TRACER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_STATE_TRACER_H_
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace gfx {
diff --git a/gpu/command_buffer/service/gpu_tracer.cc b/gpu/command_buffer/service/gpu_tracer.cc
index 3ea2ade..5ece0d4 100644
--- a/gpu/command_buffer/service/gpu_tracer.cc
+++ b/gpu/command_buffer/service/gpu_tracer.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/gpu_tracer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <deque>
 
 #include "base/bind.h"
@@ -61,8 +64,8 @@ TraceOutputter::~TraceOutputter() { g_outputter_thread = NULL; }
 void TraceOutputter::TraceDevice(GpuTracerSource source,
                                  const std::string& category,
                                  const std::string& name,
-                                 int64 start_time,
-                                 int64 end_time) {
+                                 int64_t start_time,
+                                 int64_t end_time) {
   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
   TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2(
       TRACE_DISABLED_BY_DEFAULT("gpu.device"),
@@ -109,7 +112,7 @@ void TraceOutputter::TraceServiceEnd(GpuTracerSource source,
                                      const std::string& name) {
   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
   DCHECK(!trace_service_id_stack_[source].empty());
-  const uint64 local_trace_id = trace_service_id_stack_[source].top();
+  const uint64_t local_trace_id = trace_service_id_stack_[source].top();
   trace_service_id_stack_[source].pop();
 
   TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2(
@@ -171,8 +174,8 @@ void GPUTrace::Process() {
   if (gpu_timer_.get() && device_enabled_) {
     DCHECK(IsAvailable());
 
-    int64 start = 0;
-    int64 end = 0;
+    int64_t start = 0;
+    int64_t end = 0;
     gpu_timer_->GetStartEndTimestamps(&start, &end);
     outputter_->TraceDevice(source_, category_, name_, start, end);
   }
@@ -376,7 +379,7 @@ scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
 }
 
 bool GPUTracer::CheckDisjointStatus() {
-  const int64 current_time = gpu_timing_client_->GetCurrentCPUTime();
+  const int64_t current_time = gpu_timing_client_->GetCurrentCPUTime();
   if (*gpu_trace_dev_category == 0)
     return false;
 
diff --git a/gpu/command_buffer/service/gpu_tracer.h b/gpu/command_buffer/service/gpu_tracer.h
index cb3f8902c..c54008c 100644
--- a/gpu/command_buffer/service/gpu_tracer.h
+++ b/gpu/command_buffer/service/gpu_tracer.h
@@ -6,12 +6,14 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GPU_TRACER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_TRACER_H_
 
+#include <stdint.h>
+
 #include <deque>
 #include <stack>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
@@ -97,7 +99,7 @@ class GPU_EXPORT GPUTracer
   const unsigned char* gpu_trace_srv_category;
   const unsigned char* gpu_trace_dev_category;
   gles2::GLES2Decoder* decoder_;
-  int64 disjoint_time_ = 0;
+  int64_t disjoint_time_ = 0;
 
   bool gpu_executing_ = false;
   bool began_device_traces_ = false;
@@ -111,8 +113,8 @@ class Outputter : public base::RefCounted<Outputter> {
   virtual void TraceDevice(GpuTracerSource source,
                            const std::string& category,
                            const std::string& name,
-                           int64 start_time,
-                           int64 end_time) = 0;
+                           int64_t start_time,
+                           int64_t end_time) = 0;
 
   virtual void TraceServiceBegin(GpuTracerSource source,
                                  const std::string& category,
@@ -133,8 +135,8 @@ class TraceOutputter : public Outputter {
   void TraceDevice(GpuTracerSource source,
                    const std::string& category,
                    const std::string& name,
-                   int64 start_time,
-                   int64 end_time) override;
+                   int64_t start_time,
+                   int64_t end_time) override;
 
   void TraceServiceBegin(GpuTracerSource source,
                          const std::string& category,
@@ -150,10 +152,10 @@ class TraceOutputter : public Outputter {
   ~TraceOutputter() override;
 
   base::Thread named_thread_;
-  uint64 local_trace_device_id_ = 0;
-  uint64 local_trace_service_id_ = 0;
+  uint64_t local_trace_device_id_ = 0;
+  uint64_t local_trace_service_id_ = 0;
 
-  std::stack<uint64> trace_service_id_stack_[NUM_TRACER_SOURCES];
+  std::stack<uint64_t> trace_service_id_stack_[NUM_TRACER_SOURCES];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TraceOutputter);
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index 59ed662..cf5589a 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
@@ -22,8 +24,8 @@ using ::testing::Exactly;
 using ::testing::Invoke;
 using ::testing::Return;
 
-int64 g_fakeCPUTime = 0;
-int64 FakeCpuTime() {
+int64_t g_fakeCPUTime = 0;
+int64_t FakeCpuTime() {
   return g_fakeCPUTime;
 }
 
@@ -32,8 +34,10 @@ class MockOutputter : public Outputter {
   MockOutputter() {}
   MOCK_METHOD5(TraceDevice,
                void(GpuTracerSource source,
-                    const std::string& category, const std::string& name,
-                    int64 start_time, int64 end_time));
+                    const std::string& category,
+                    const std::string& name,
+                    int64_t start_time,
+                    int64_t end_time));
 
   MOCK_METHOD3(TraceServiceBegin,
                void(GpuTracerSource source,
@@ -144,8 +148,9 @@ class BaseGpuTest : public GpuServiceTest {
   void ExpectOutputterEndMocks(MockOutputter* outputter,
                                GpuTracerSource source,
                                const std::string& category,
-                               const std::string& name, int64 expect_start_time,
-                               int64 expect_end_time,
+                               const std::string& name,
+                               int64_t expect_start_time,
+                               int64_t expect_end_time,
                                bool trace_service,
                                bool trace_device) {
     if (trace_service) {
@@ -166,8 +171,8 @@ class BaseGpuTest : public GpuServiceTest {
   }
 
   void ExpectDisjointOutputMocks(MockOutputter* outputter,
-                                 int64 expect_start_time,
-                                 int64 expect_end_time) {
+                                 int64_t expect_start_time,
+                                 int64_t expect_end_time) {
     EXPECT_CALL(*outputter,
                 TraceDevice(kTraceDisjoint, "DisjointEvent", _,
                             expect_start_time, expect_end_time))
@@ -185,8 +190,9 @@ class BaseGpuTest : public GpuServiceTest {
                             bool tracing_device,
                             GpuTracerSource source,
                             const std::string& category,
-                            const std::string& name, int64 expect_start_time,
-                            int64 expect_end_time) {
+                            const std::string& name,
+                            int64_t expect_start_time,
+                            int64_t expect_end_time) {
     if (tracing_service)
       ExpectOutputterBeginMocks(outputter, source, category, name);
     const bool valid_timer = tracing_device &&
@@ -224,13 +230,13 @@ class BaseGpuTraceTest : public BaseGpuTest {
     const GpuTracerSource tracer_source = kTraceCHROMIUM;
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     ExpectOutputterMocks(outputter_ref_.get(), tracing_service, tracing_device,
@@ -366,13 +372,13 @@ class BaseGpuTracerTest : public BaseGpuTest {
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
@@ -442,9 +448,9 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
     const bool valid_timer = gpu_timing_client_->IsAvailable();
@@ -518,13 +524,13 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
@@ -580,13 +586,13 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
diff --git a/gpu/command_buffer/service/id_manager.h b/gpu/command_buffer/service/id_manager.h
index 0bc0674..7afb5fd 100644
--- a/gpu/command_buffer/service/id_manager.h
+++ b/gpu/command_buffer/service/id_manager.h
@@ -5,8 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_ID_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_ID_MANAGER_H_
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/image_manager.cc b/gpu/command_buffer/service/image_manager.cc
index 7464734..7c7c6e6 100644
--- a/gpu/command_buffer/service/image_manager.cc
+++ b/gpu/command_buffer/service/image_manager.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/image_manager.h"
 
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "ui/gl/gl_image.h"
 
@@ -23,19 +25,19 @@ void ImageManager::Destroy(bool have_context) {
   images_.clear();
 }
 
-void ImageManager::AddImage(gl::GLImage* image, int32 service_id) {
+void ImageManager::AddImage(gl::GLImage* image, int32_t service_id) {
   DCHECK(images_.find(service_id) == images_.end());
   images_[service_id] = image;
 }
 
-void ImageManager::RemoveImage(int32 service_id) {
+void ImageManager::RemoveImage(int32_t service_id) {
   GLImageMap::iterator iter = images_.find(service_id);
   DCHECK(iter != images_.end());
   iter->second.get()->Destroy(true);
   images_.erase(iter);
 }
 
-gl::GLImage* ImageManager::LookupImage(int32 service_id) {
+gl::GLImage* ImageManager::LookupImage(int32_t service_id) {
   GLImageMap::const_iterator iter = images_.find(service_id);
   if (iter != images_.end())
     return iter->second.get();
diff --git a/gpu/command_buffer/service/image_manager.h b/gpu/command_buffer/service/image_manager.h
index 8ec1e3f..1ad020e 100644
--- a/gpu/command_buffer/service/image_manager.h
+++ b/gpu/command_buffer/service/image_manager.h
@@ -5,8 +5,10 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_IMAGE_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IMAGE_MANAGER_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/gpu_export.h"
 
@@ -24,12 +26,12 @@ class GPU_EXPORT ImageManager {
   ~ImageManager();
 
   void Destroy(bool have_context);
-  void AddImage(gl::GLImage* image, int32 service_id);
-  void RemoveImage(int32 service_id);
-  gl::GLImage* LookupImage(int32 service_id);
+  void AddImage(gl::GLImage* image, int32_t service_id);
+  void RemoveImage(int32_t service_id);
+  gl::GLImage* LookupImage(int32_t service_id);
 
  private:
-  typedef base::hash_map<int32, scoped_refptr<gl::GLImage>> GLImageMap;
+  typedef base::hash_map<int32_t, scoped_refptr<gl::GLImage>> GLImageMap;
   GLImageMap images_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageManager);
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index ae5b3698..ef3097f 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <queue>
 #include <set>
 #include <utility>
@@ -237,7 +240,7 @@ void InProcessCommandBuffer::PumpCommands() {
   gpu_scheduler_->PutChanged();
 }
 
-bool InProcessCommandBuffer::GetBufferChanged(int32 transfer_buffer_id) {
+bool InProcessCommandBuffer::GetBufferChanged(int32_t transfer_buffer_id) {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
   command_buffer_->SetGetBuffer(transfer_buffer_id);
@@ -249,7 +252,7 @@ bool InProcessCommandBuffer::Initialize(
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
-    const std::vector<int32>& attribs,
+    const std::vector<int32_t>& attribs,
     gfx::GpuPreference gpu_preference,
     const base::Closure& context_lost_callback,
     InProcessCommandBuffer* share_group,
@@ -502,13 +505,13 @@ CommandBuffer::State InProcessCommandBuffer::GetLastState() {
   return last_state_;
 }
 
-int32 InProcessCommandBuffer::GetLastToken() {
+int32_t InProcessCommandBuffer::GetLastToken() {
   CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset,
+void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset,
                                               uint32_t order_num) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
@@ -565,7 +568,7 @@ void InProcessCommandBuffer::ScheduleDelayedWorkOnGpuThread() {
       &InProcessCommandBuffer::PerformDelayedWork, gpu_thread_weak_ptr_));
 }
 
-void InProcessCommandBuffer::Flush(int32 put_offset) {
+void InProcessCommandBuffer::Flush(int32_t put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
@@ -586,18 +589,19 @@ void InProcessCommandBuffer::Flush(int32 put_offset) {
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
-void InProcessCommandBuffer::OrderingBarrier(int32 put_offset) {
+void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
-void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
+void InProcessCommandBuffer::WaitForTokenInRange(int32_t start, int32_t end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
          last_state_.error == gpu::error::kNoError)
     flush_event_.Wait();
 }
 
-void InProcessCommandBuffer::WaitForGetOffsetInRange(int32 start, int32 end) {
+void InProcessCommandBuffer::WaitForGetOffsetInRange(int32_t start,
+                                                     int32_t end) {
   CheckSequencedThread();
 
   GetStateFast();
@@ -608,7 +612,7 @@ void InProcessCommandBuffer::WaitForGetOffsetInRange(int32 start, int32 end) {
   }
 }
 
-void InProcessCommandBuffer::SetGetBuffer(int32 shm_id) {
+void InProcessCommandBuffer::SetGetBuffer(int32_t shm_id) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
@@ -627,7 +631,7 @@ void InProcessCommandBuffer::SetGetBuffer(int32 shm_id) {
 }
 
 void InProcessCommandBuffer::SetGetBufferOnGpuThread(
-    int32 shm_id,
+    int32_t shm_id,
     base::WaitableEvent* completion) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->SetGetBuffer(shm_id);
@@ -635,14 +639,15 @@ void InProcessCommandBuffer::SetGetBufferOnGpuThread(
   completion->Signal();
 }
 
-scoped_refptr<Buffer> InProcessCommandBuffer::CreateTransferBuffer(size_t size,
-                                                                   int32* id) {
+scoped_refptr<Buffer> InProcessCommandBuffer::CreateTransferBuffer(
+    size_t size,
+    int32_t* id) {
   CheckSequencedThread();
   base::AutoLock lock(command_buffer_lock_);
   return command_buffer_->CreateTransferBuffer(size, id);
 }
 
-void InProcessCommandBuffer::DestroyTransferBuffer(int32 id) {
+void InProcessCommandBuffer::DestroyTransferBuffer(int32_t id) {
   CheckSequencedThread();
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::DestroyTransferBufferOnGpuThread,
@@ -652,7 +657,7 @@ void InProcessCommandBuffer::DestroyTransferBuffer(int32 id) {
   QueueTask(task);
 }
 
-void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32 id) {
+void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32_t id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
@@ -661,10 +666,10 @@ gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
-int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
-                                          size_t width,
-                                          size_t height,
-                                          unsigned internalformat) {
+int32_t InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
+                                            size_t width,
+                                            size_t height,
+                                            unsigned internalformat) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
@@ -672,7 +677,7 @@ int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
       gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
-  int32 new_id = next_image_id_.GetNext();
+  int32_t new_id = next_image_id_.GetNext();
 
   DCHECK(gpu::ImageFactory::IsGpuMemoryBufferFormatSupported(
       gpu_memory_buffer->GetFormat(), capabilities_));
@@ -717,11 +722,11 @@ int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
-    int32 id,
+    int32_t id,
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
-    uint32 internalformat,
+    uint32_t internalformat,
     uint32_t order_num,
     uint64_t fence_sync) {
   ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
@@ -780,7 +785,7 @@ void InProcessCommandBuffer::CreateImageOnGpuThread(
   }
 }
 
-void InProcessCommandBuffer::DestroyImage(int32 id) {
+void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
   QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
@@ -788,7 +793,7 @@ void InProcessCommandBuffer::DestroyImage(int32 id) {
                        id));
 }
 
-void InProcessCommandBuffer::DestroyImageOnGpuThread(int32 id) {
+void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
   if (!decoder_)
     return;
 
@@ -802,7 +807,7 @@ void InProcessCommandBuffer::DestroyImageOnGpuThread(int32 id) {
   image_manager->RemoveImage(id);
 }
 
-int32 InProcessCommandBuffer::CreateGpuMemoryBufferImage(
+int32_t InProcessCommandBuffer::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
@@ -821,25 +826,25 @@ int32 InProcessCommandBuffer::CreateGpuMemoryBufferImage(
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
-uint32 InProcessCommandBuffer::InsertSyncPoint() {
-  uint32 sync_point = service_->sync_point_manager()->GenerateSyncPoint();
+uint32_t InProcessCommandBuffer::InsertSyncPoint() {
+  uint32_t sync_point = service_->sync_point_manager()->GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
-uint32 InProcessCommandBuffer::InsertFutureSyncPoint() {
+uint32_t InProcessCommandBuffer::InsertFutureSyncPoint() {
   return service_->sync_point_manager()->GenerateSyncPoint();
 }
 
-void InProcessCommandBuffer::RetireSyncPoint(uint32 sync_point) {
+void InProcessCommandBuffer::RetireSyncPoint(uint32_t sync_point) {
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
 }
 
-void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
+void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32_t sync_point) {
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
@@ -1021,8 +1026,8 @@ bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
   return false;
 }
 
-uint32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
-    uint32 client_texture_id) {
+uint32_t InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
+    uint32_t client_texture_id) {
 #if defined(OS_ANDROID)
   return stream_texture_manager_->CreateStreamTexture(
       client_texture_id, decoder_->GetContextGroup()->texture_manager());
@@ -1078,20 +1083,20 @@ base::Closure InProcessCommandBuffer::WrapCallback(
 }
 
 #if defined(OS_ANDROID)
-scoped_refptr<gfx::SurfaceTexture>
-InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
+scoped_refptr<gfx::SurfaceTexture> InProcessCommandBuffer::GetSurfaceTexture(
+    uint32_t stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 
-uint32 InProcessCommandBuffer::CreateStreamTexture(uint32 texture_id) {
+uint32_t InProcessCommandBuffer::CreateStreamTexture(uint32_t texture_id) {
   base::WaitableEvent completion(true, false);
-  uint32 stream_id = 0;
-  base::Callback<uint32(void)> task =
+  uint32_t stream_id = 0;
+  base::Callback<uint32_t(void)> task =
       base::Bind(&InProcessCommandBuffer::CreateStreamTextureOnGpuThread,
                  base::Unretained(this), texture_id);
   QueueTask(
-      base::Bind(&RunTaskWithResult<uint32>, task, &stream_id, &completion));
+      base::Bind(&RunTaskWithResult<uint32_t>, task, &stream_id, &completion));
   completion.Wait();
   return stream_id;
 }
diff --git a/gpu/command_buffer/service/in_process_command_buffer.h b/gpu/command_buffer/service/in_process_command_buffer.h
index 91ecd74..6f9e2430 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.h
+++ b/gpu/command_buffer/service/in_process_command_buffer.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <vector>
 
@@ -12,6 +15,7 @@
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/scoped_ptr_hash_map.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ -85,7 +89,7 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
                   bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
-                  const std::vector<int32>& attribs,
+                  const std::vector<int32_t>& attribs,
                   gfx::GpuPreference gpu_preference,
                   const base::Closure& context_lost_callback,
                   InProcessCommandBuffer* share_group,
@@ -96,34 +100,34 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
   // CommandBuffer implementation:
   bool Initialize() override;
   State GetLastState() override;
-  int32 GetLastToken() override;
-  void Flush(int32 put_offset) override;
-  void OrderingBarrier(int32 put_offset) override;
-  void WaitForTokenInRange(int32 start, int32 end) override;
-  void WaitForGetOffsetInRange(int32 start, int32 end) override;
-  void SetGetBuffer(int32 shm_id) override;
+  int32_t GetLastToken() override;
+  void Flush(int32_t put_offset) override;
+  void OrderingBarrier(int32_t put_offset) override;
+  void WaitForTokenInRange(int32_t start, int32_t end) override;
+  void WaitForGetOffsetInRange(int32_t start, int32_t end) override;
+  void SetGetBuffer(int32_t shm_id) override;
   scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
-                                                  int32* id) override;
-  void DestroyTransferBuffer(int32 id) override;
+                                                  int32_t* id) override;
+  void DestroyTransferBuffer(int32_t id) override;
   gpu::error::Error GetLastError() override;
 
   // GpuControl implementation:
   gpu::Capabilities GetCapabilities() override;
-  int32 CreateImage(ClientBuffer buffer,
-                    size_t width,
-                    size_t height,
-                    unsigned internalformat) override;
-  void DestroyImage(int32 id) override;
-  int32 CreateGpuMemoryBufferImage(size_t width,
-                                   size_t height,
-                                   unsigned internalformat,
-                                   unsigned usage) override;
-  uint32 InsertSyncPoint() override;
-  uint32 InsertFutureSyncPoint() override;
-  void RetireSyncPoint(uint32 sync_point) override;
-  void SignalSyncPoint(uint32 sync_point,
+  int32_t CreateImage(ClientBuffer buffer,
+                      size_t width,
+                      size_t height,
+                      unsigned internalformat) override;
+  void DestroyImage(int32_t id) override;
+  int32_t CreateGpuMemoryBufferImage(size_t width,
+                                     size_t height,
+                                     unsigned internalformat,
+                                     unsigned usage) override;
+  uint32_t InsertSyncPoint() override;
+  uint32_t InsertFutureSyncPoint() override;
+  void RetireSyncPoint(uint32_t sync_point) override;
+  void SignalSyncPoint(uint32_t sync_point,
                        const base::Closure& callback) override;
-  void SignalQuery(uint32 query_id, const base::Closure& callback) override;
+  void SignalQuery(uint32_t query_id, const base::Closure& callback) override;
   void SetLock(base::Lock*) override;
   bool IsGpuChannelLost() override;
   CommandBufferNamespace GetNamespaceID() const override;
@@ -174,9 +178,8 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
   };
 
 #if defined(OS_ANDROID)
-  scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
-      uint32 stream_id);
-  uint32 CreateStreamTexture(uint32 texture_id);
+  scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(uint32_t stream_id);
+  uint32_t CreateStreamTexture(uint32_t texture_id);
 #endif
 
  private:
@@ -184,7 +187,7 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
     bool is_offscreen;
     gfx::AcceleratedWidget window;
     const gfx::Size& size;
-    const std::vector<int32>& attribs;
+    const std::vector<int32_t>& attribs;
     gfx::GpuPreference gpu_preference;
     gpu::Capabilities* capabilities;  // Ouptut.
     InProcessCommandBuffer* context_group;
@@ -193,7 +196,7 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
     InitializeOnGpuThreadParams(bool is_offscreen,
                                 gfx::AcceleratedWidget window,
                                 const gfx::Size& size,
-                                const std::vector<int32>& attribs,
+                                const std::vector<int32_t>& attribs,
                                 gfx::GpuPreference gpu_preference,
                                 gpu::Capabilities* capabilities,
                                 InProcessCommandBuffer* share_group,
@@ -210,16 +213,16 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
 
   bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
   bool DestroyOnGpuThread();
-  void FlushOnGpuThread(int32 put_offset, uint32_t order_num);
+  void FlushOnGpuThread(int32_t put_offset, uint32_t order_num);
   void ScheduleDelayedWorkOnGpuThread();
-  uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
+  uint32_t CreateStreamTextureOnGpuThread(uint32_t client_texture_id);
   bool MakeCurrent();
   base::Closure WrapCallback(const base::Closure& callback);
   State GetStateFast();
   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
   void CheckSequencedThread();
-  void RetireSyncPointOnGpuThread(uint32 sync_point);
-  bool WaitSyncPointOnGpuThread(uint32 sync_point);
+  void RetireSyncPointOnGpuThread(uint32_t sync_point);
+  bool WaitSyncPointOnGpuThread(uint32_t sync_point);
   void FenceSyncReleaseOnGpuThread(uint64_t release);
   bool WaitFenceSyncOnGpuThread(gpu::CommandBufferNamespace namespace_id,
                                 uint64_t command_buffer_id,
@@ -227,20 +230,20 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
   void SignalSyncTokenOnGpuThread(const SyncToken& sync_token,
                                   const base::Closure& callback);
   void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
-  void DestroyTransferBufferOnGpuThread(int32 id);
-  void CreateImageOnGpuThread(int32 id,
+  void DestroyTransferBufferOnGpuThread(int32_t id);
+  void CreateImageOnGpuThread(int32_t id,
                               const gfx::GpuMemoryBufferHandle& handle,
                               const gfx::Size& size,
                               gfx::BufferFormat format,
-                              uint32 internalformat,
+                              uint32_t internalformat,
                               uint32_t order_num,
                               uint64_t fence_sync);
-  void DestroyImageOnGpuThread(int32 id);
-  void SetGetBufferOnGpuThread(int32 shm_id, base::WaitableEvent* completion);
+  void DestroyImageOnGpuThread(int32_t id);
+  void SetGetBufferOnGpuThread(int32_t shm_id, base::WaitableEvent* completion);
 
   // Callbacks:
   void OnContextLost();
-  bool GetBufferChanged(int32 transfer_buffer_id);
+  bool GetBufferChanged(int32_t transfer_buffer_id);
   void PumpCommands();
   void PerformDelayedWork();
 
@@ -262,7 +265,7 @@ class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
 
   // Members accessed on the client thread:
   State last_state_;
-  int32 last_put_offset_;
+  int32_t last_put_offset_;
   gpu::Capabilities capabilities_;
   GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   base::AtomicSequenceNumber next_image_id_;
diff --git a/gpu/command_buffer/service/logger.h b/gpu/command_buffer/service/logger.h
index 4691443..a1b0a93 100644
--- a/gpu/command_buffer/service/logger.h
+++ b/gpu/command_buffer/service/logger.h
@@ -7,15 +7,18 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_LOGGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_LOGGER_H_
 
+#include <stdint.h>
+
 #include <string>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
-typedef base::Callback<void(int32 id, const std::string& msg)> MsgCallback;
+typedef base::Callback<void(int32_t id, const std::string& msg)> MsgCallback;
 
 class DebugMarkerManager;
 
diff --git a/gpu/command_buffer/service/mailbox_manager.h b/gpu/command_buffer/service/mailbox_manager.h
index a914f5e..dd6dd73 100644
--- a/gpu/command_buffer/service/mailbox_manager.h
+++ b/gpu/command_buffer/service/mailbox_manager.h
@@ -5,6 +5,7 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_MAILBOX_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_MAILBOX_MANAGER_H_
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/gpu_export.h"
diff --git a/gpu/command_buffer/service/mailbox_manager_impl.cc b/gpu/command_buffer/service/mailbox_manager_impl.cc
index db7b4c2..58e98f0 100644
--- a/gpu/command_buffer/service/mailbox_manager_impl.cc
+++ b/gpu/command_buffer/service/mailbox_manager_impl.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
 #include "gpu/command_buffer/service/texture_manager.h"
diff --git a/gpu/command_buffer/service/mailbox_manager_impl.h b/gpu/command_buffer/service/mailbox_manager_impl.h
index 135b826..4a3a615 100644
--- a/gpu/command_buffer/service/mailbox_manager_impl.h
+++ b/gpu/command_buffer/service/mailbox_manager_impl.h
@@ -8,6 +8,7 @@
 #include <map>
 #include <utility>
 
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/common/constants.h"
diff --git a/gpu/command_buffer/service/mailbox_manager_sync.cc b/gpu/command_buffer/service/mailbox_manager_sync.cc
index 8391450..d6cac10 100644
--- a/gpu/command_buffer/service/mailbox_manager_sync.cc
+++ b/gpu/command_buffer/service/mailbox_manager_sync.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/mailbox_manager_sync.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <queue>
 
diff --git a/gpu/command_buffer/service/mailbox_manager_sync.h b/gpu/command_buffer/service/mailbox_manager_sync.h
index ff16dd7..bdc31ff 100644
--- a/gpu/command_buffer/service/mailbox_manager_sync.h
+++ b/gpu/command_buffer/service/mailbox_manager_sync.h
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/mailbox.h"
diff --git a/gpu/command_buffer/service/mailbox_manager_unittest.cc b/gpu/command_buffer/service/mailbox_manager_unittest.cc
index e6ce523..a70a186 100644
--- a/gpu/command_buffer/service/mailbox_manager_unittest.cc
+++ b/gpu/command_buffer/service/mailbox_manager_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/macros.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
diff --git a/gpu/command_buffer/service/memory_program_cache.cc b/gpu/command_buffer/service/memory_program_cache.cc
index 1841348..3d6876f 100644
--- a/gpu/command_buffer/service/memory_program_cache.cc
+++ b/gpu/command_buffer/service/memory_program_cache.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/memory_program_cache.h"
 
+#include <stddef.h>
+
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/command_line.h"
diff --git a/gpu/command_buffer/service/memory_program_cache.h b/gpu/command_buffer/service/memory_program_cache.h
index 7e9b83d..73115d8 100644
--- a/gpu/command_buffer/service/memory_program_cache.h
+++ b/gpu/command_buffer/service/memory_program_cache.h
@@ -5,11 +5,14 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_MEMORY_PROGRAM_CACHE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_MEMORY_PROGRAM_CACHE_H_
 
+#include <stddef.h>
+
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
diff --git a/gpu/command_buffer/service/memory_program_cache_unittest.cc b/gpu/command_buffer/service/memory_program_cache_unittest.cc
index f92860f..9b98e56 100644
--- a/gpu/command_buffer/service/memory_program_cache_unittest.cc
+++ b/gpu/command_buffer/service/memory_program_cache_unittest.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/memory_program_cache.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ -81,7 +84,7 @@ class MemoryProgramCacheTest : public GpuServiceTest {
     shader_cache_shader_ = shader;
   }
 
-  int32 shader_cache_count() { return shader_cache_count_; }
+  int32_t shader_cache_count() { return shader_cache_count_; }
   const std::string& shader_cache_shader() { return shader_cache_shader_; }
 
  protected:
@@ -181,7 +184,7 @@ class MemoryProgramCacheTest : public GpuServiceTest {
   ShaderManager shader_manager_;
   Shader* vertex_shader_;
   Shader* fragment_shader_;
-  int32 shader_cache_count_;
+  int32_t shader_cache_count_;
   std::string shader_cache_shader_;
   std::vector<std::string> varyings_;
 };
diff --git a/gpu/command_buffer/service/memory_tracking.h b/gpu/command_buffer/service/memory_tracking.h
index 5b0cd22..0c3fdd9 100644
--- a/gpu/command_buffer/service/memory_tracking.h
+++ b/gpu/command_buffer/service/memory_tracking.h
@@ -5,9 +5,12 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_MEMORY_TRACKING_H_
 #define GPU_COMMAND_BUFFER_SERVICE_MEMORY_TRACKING_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/trace_event.h"
 
diff --git a/gpu/command_buffer/service/mocks.h b/gpu/command_buffer/service/mocks.h
index a9a7efb..8c414b5 100644
--- a/gpu/command_buffer/service/mocks.h
+++ b/gpu/command_buffer/service/mocks.h
@@ -10,12 +10,15 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
 #define GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
-#include "gpu/command_buffer/service/cmd_parser.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
+#include "gpu/command_buffer/service/cmd_parser.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_cache.h"
 #include "gpu/command_buffer/service/shader_translator.h"
diff --git a/gpu/command_buffer/service/path_manager.h b/gpu/command_buffer/service/path_manager.h
index 78a53b7..d334a86 100644
--- a/gpu/command_buffer/service/path_manager.h
+++ b/gpu/command_buffer/service/path_manager.h
@@ -7,7 +7,7 @@
 
 #include <map>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/gpu_export.h"
 
diff --git a/gpu/command_buffer/service/program_cache.cc b/gpu/command_buffer/service/program_cache.cc
index ee1a736..56c84b8 100644
--- a/gpu/command_buffer/service/program_cache.cc
+++ b/gpu/command_buffer/service/program_cache.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/program_cache.h"
 
+#include <stddef.h>
+
 #include <string>
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/shader_manager.h"
diff --git a/gpu/command_buffer/service/program_cache.h b/gpu/command_buffer/service/program_cache.h
index 44593df..661bd71 100644
--- a/gpu/command_buffer/service/program_cache.h
+++ b/gpu/command_buffer/service/program_cache.h
@@ -5,10 +5,13 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_
 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_
 
+#include <stddef.h>
+
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/sha1.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
diff --git a/gpu/command_buffer/service/program_manager.cc b/gpu/command_buffer/service/program_manager.cc
index 45b0c55..910f864 100644
--- a/gpu/command_buffer/service/program_manager.cc
+++ b/gpu/command_buffer/service/program_manager.cc
@@ -4,12 +4,14 @@
 
 #include "gpu/command_buffer/service/program_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
@@ -73,7 +75,7 @@ bool GetUniformNameSansElement(
   base::CheckedNumeric<GLint> index = 0;
   size_t last = name.size() - 1;
   for (size_t pos = open_pos + 1; pos < last; ++pos) {
-    int8 digit = name[pos] - '0';
+    int8_t digit = name[pos] - '0';
     if (digit < 0 || digit > 9) {
       return false;
     }
@@ -110,9 +112,9 @@ bool IsBuiltInInvariant(
   return hit->second.isInvariant;
 }
 
-uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+uint32_t ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8_t*>(position) -
+         static_cast<const uint8_t*>(start);
 }
 
 }  // anonymous namespace.
@@ -323,8 +325,7 @@ void Program::UpdateLogInfo() {
   set_log_info(ProcessLogInfo(log).c_str());
 }
 
-void Program::ClearUniforms(
-    std::vector<uint8>* zero_buffer) {
+void Program::ClearUniforms(std::vector<uint8_t>* zero_buffer) {
   DCHECK(zero_buffer);
   if (uniforms_cleared_) {
     return;
@@ -333,11 +334,11 @@ void Program::ClearUniforms(
   for (const UniformInfo& uniform_info : uniform_infos_) {
     GLint location = uniform_info.element_locations[0];
     GLsizei size = uniform_info.size;
-    uint32 unit_size =
+    uint32_t unit_size =
         GLES2Util::GetElementCountForUniformType(uniform_info.type) *
         GLES2Util::GetElementSizeForUniformType(uniform_info.type);
     DCHECK_LT(0u, unit_size);
-    uint32 size_needed = size * unit_size;
+    uint32_t size_needed = size * unit_size;
     if (size_needed > zero_buffer->size()) {
       zero_buffer->resize(size_needed, 0u);
     }
@@ -1833,8 +1834,8 @@ void Program::GetProgramInfo(
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
   // of an identifier is 256 characters.
-  uint32 num_locations = 0;
-  uint32 total_string_size = 0;
+  uint32_t num_locations = 0;
+  uint32_t total_string_size = 0;
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
@@ -1847,17 +1848,17 @@ void Program::GetProgramInfo(
     total_string_size += info.name.size();
   }
 
-  uint32 num_inputs = attrib_infos_.size() + uniform_infos_.size();
-  uint32 input_size = num_inputs * sizeof(ProgramInput);
-  uint32 location_size = num_locations * sizeof(int32);
-  uint32 size = sizeof(ProgramInfoHeader) +
-      input_size + location_size + total_string_size;
+  uint32_t num_inputs = attrib_infos_.size() + uniform_infos_.size();
+  uint32_t input_size = num_inputs * sizeof(ProgramInput);
+  uint32_t location_size = num_locations * sizeof(int32_t);
+  uint32_t size = sizeof(ProgramInfoHeader) + input_size + location_size +
+                  total_string_size;
 
   bucket->SetSize(size);
   ProgramInfoHeader* header = bucket->GetDataAs<ProgramInfoHeader*>(0, size);
   ProgramInput* inputs = bucket->GetDataAs<ProgramInput*>(
       sizeof(ProgramInfoHeader), input_size);
-  int32* locations = bucket->GetDataAs<int32*>(
+  int32_t* locations = bucket->GetDataAs<int32_t*>(
       sizeof(ProgramInfoHeader) + input_size, location_size);
   char* strings = bucket->GetDataAs<char*>(
       sizeof(ProgramInfoHeader) + input_size + location_size,
@@ -2267,8 +2268,8 @@ Program::~Program() {
 }
 
 ProgramManager::ProgramManager(ProgramCache* program_cache,
-                               uint32 max_varying_vectors,
-                               uint32 max_dual_source_draw_buffers,
+                               uint32_t max_varying_vectors,
+                               uint32_t max_dual_source_draw_buffers,
                                FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
@@ -2383,7 +2384,7 @@ void ProgramManager::ClearUniforms(Program* program) {
   program->ClearUniforms(&zero_);
 }
 
-int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
+int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
diff --git a/gpu/command_buffer/service/program_manager.h b/gpu/command_buffer/service/program_manager.h
index eb3be7c..a33e32f 100644
--- a/gpu/command_buffer/service/program_manager.h
+++ b/gpu/command_buffer/service/program_manager.h
@@ -5,11 +5,14 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <string>
 #include <vector>
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ -96,7 +99,7 @@ class GPU_EXPORT Program : public base::RefCounted<Program> {
 
     GLsizei size;
     GLenum type;
-    uint32 accepts_api_type;
+    uint32_t accepts_api_type;
     GLint fake_location_base;
     bool is_array;
     std::string name;
@@ -432,7 +435,7 @@ class GPU_EXPORT Program : public base::RefCounted<Program> {
   void GatherInterfaceBlockInfo();
 
   // Clears all the uniforms.
-  void ClearUniforms(std::vector<uint8>* zero_buffer);
+  void ClearUniforms(std::vector<uint8_t>* zero_buffer);
 
   // If long attribate names are mapped during shader translation, call
   // glBindAttribLocation() again with the mapped names.
@@ -539,8 +542,8 @@ class GPU_EXPORT Program : public base::RefCounted<Program> {
 class GPU_EXPORT ProgramManager {
  public:
   explicit ProgramManager(ProgramCache* program_cache,
-                          uint32 max_varying_vectors,
-                          uint32 max_dual_source_draw_buffers,
+                          uint32_t max_varying_vectors,
+                          uint32_t max_dual_source_draw_buffers,
                           FeatureInfo* feature_info);
   ~ProgramManager();
 
@@ -578,13 +581,11 @@ class GPU_EXPORT ProgramManager {
   // Check if a Program is owned by this ProgramManager.
   bool IsOwned(Program* program) const;
 
-  static int32 MakeFakeLocation(int32 index, int32 element);
+  static int32_t MakeFakeLocation(int32_t index, int32_t element);
 
-  uint32 max_varying_vectors() const {
-    return max_varying_vectors_;
-  }
+  uint32_t max_varying_vectors() const { return max_varying_vectors_; }
 
-  uint32 max_dual_source_draw_buffers() const {
+  uint32_t max_dual_source_draw_buffers() const {
     return max_dual_source_draw_buffers_;
   }
 
@@ -609,12 +610,12 @@ class GPU_EXPORT ProgramManager {
   bool have_context_;
 
   // Used to clear uniforms.
-  std::vector<uint8> zero_;
+  std::vector<uint8_t> zero_;
 
   ProgramCache* program_cache_;
 
-  uint32 max_varying_vectors_;
-  uint32 max_dual_source_draw_buffers_;
+  uint32_t max_varying_vectors_;
+  uint32_t max_dual_source_draw_buffers_;
 
   scoped_refptr<FeatureInfo> feature_info_;
 
diff --git a/gpu/command_buffer/service/program_manager_unittest.cc b/gpu/command_buffer/service/program_manager_unittest.cc
index 8343e56..eafe75d 100644
--- a/gpu/command_buffer/service/program_manager_unittest.cc
+++ b/gpu/command_buffer/service/program_manager_unittest.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/program_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/command_line.h"
@@ -38,15 +41,15 @@ namespace gpu {
 namespace gles2 {
 
 namespace {
-const uint32 kMaxVaryingVectors = 8;
-const uint32 kMaxDrawBuffers = 8;
-const uint32 kMaxDualSourceDrawBuffers = 8;
+const uint32_t kMaxVaryingVectors = 8;
+const uint32_t kMaxDrawBuffers = 8;
+const uint32_t kMaxDualSourceDrawBuffers = 8;
 
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
 
-uint32 ComputeOffset(const void* start, const void* position) {
-  return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+uint32_t ComputeOffset(const void* start, const void* position) {
+  return static_cast<const uint8_t*>(position) -
+         static_cast<const uint8_t*>(start);
 }
 
 }  // namespace anonymous
@@ -1062,12 +1065,12 @@ TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
   ASSERT_TRUE(inputs != NULL);
   const ProgramInput* input = inputs;
   // TODO(gman): Don't assume these are in order.
-  for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_attribs; ++ii) {
     const AttribInfo& expected = kAttribs[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
-    const int32* location = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32));
+    const int32_t* location = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t));
     ASSERT_TRUE(location != NULL);
     EXPECT_EQ(expected.location, *location);
     const char* name_buf = bucket.GetDataAs<const char*>(
@@ -1078,14 +1081,14 @@ TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
     ++input;
   }
   // TODO(gman): Don't assume these are in order.
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
-    const int32* locations = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32) * input->size);
+    const int32_t* locations = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t) * input->size);
     ASSERT_TRUE(locations != NULL);
-    for (int32 jj = 0; jj < input->size; ++jj) {
+    for (int32_t jj = 0; jj < input->size; ++jj) {
       EXPECT_EQ(
           ProgramManager::MakeFakeLocation(expected.fake_location, jj),
           locations[jj]);
@@ -1098,7 +1101,7 @@ TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
     ++input;
   }
   EXPECT_EQ(header->num_attribs + header->num_uniforms,
-            static_cast<uint32>(input - inputs));
+            static_cast<uint32_t>(input - inputs));
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetUniformBlocksNone) {
@@ -1494,16 +1497,16 @@ TEST_F(ProgramManagerWithShaderTest, UnusedUniformArrayElements) {
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   ASSERT_TRUE(inputs != NULL);
   const ProgramInput* input = inputs + header->num_attribs;
-  for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
-    const int32* locations = bucket.GetDataAs<const int32*>(
-        input->location_offset, sizeof(int32) * input->size);
+    const int32_t* locations = bucket.GetDataAs<const int32_t*>(
+        input->location_offset, sizeof(int32_t) * input->size);
     ASSERT_TRUE(locations != NULL);
     EXPECT_EQ(
         ProgramManager::MakeFakeLocation(expected.fake_location, 0),
         locations[0]);
-    for (int32 jj = 1; jj < input->size; ++jj)
+    for (int32_t jj = 1; jj < input->size; ++jj)
       EXPECT_EQ(-1, locations[jj]);
     ++input;
   }
@@ -1512,7 +1515,7 @@ TEST_F(ProgramManagerWithShaderTest, UnusedUniformArrayElements) {
 TEST_F(ProgramManagerWithShaderTest, BindAttribLocationConflicts) {
   // Set up shader
   AttributeMap attrib_map;
-  for (uint32 ii = 0; ii < kNumAttribs; ++ii) {
+  for (uint32_t ii = 0; ii < kNumAttribs; ++ii) {
     attrib_map[kAttribs[ii].name] = TestHelper::ConstructAttribute(
         kAttribs[ii].type,
         kAttribs[ii].size,
diff --git a/gpu/command_buffer/service/query_manager.cc b/gpu/command_buffer/service/query_manager.cc
index 6c1e262..a1938e5 100644
--- a/gpu/command_buffer/service/query_manager.cc
+++ b/gpu/command_buffer/service/query_manager.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/query_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
@@ -25,8 +28,10 @@ namespace gles2 {
 
 class AbstractIntegerQuery : public QueryManager::Query {
  public:
-  AbstractIntegerQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  AbstractIntegerQuery(QueryManager* manager,
+                       GLenum target,
+                       int32_t shm_id,
+                       uint32_t shm_offset);
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
@@ -42,8 +47,10 @@ class AbstractIntegerQuery : public QueryManager::Query {
   std::vector<GLuint> service_ids_;
 };
 
-AbstractIntegerQuery::AbstractIntegerQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
+AbstractIntegerQuery::AbstractIntegerQuery(QueryManager* manager,
+                                           GLenum target,
+                                           int32_t shm_id,
+                                           uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
   GLuint service_id = 0;
   glGenQueries(1, &service_id);
@@ -107,18 +114,21 @@ bool AbstractIntegerQuery::AreAllResultsAvailable() {
 
 class BooleanQuery : public AbstractIntegerQuery {
  public:
-  BooleanQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  BooleanQuery(QueryManager* manager,
+               GLenum target,
+               int32_t shm_id,
+               uint32_t shm_offset);
   bool Process(bool did_finish) override;
 
  protected:
   ~BooleanQuery() override;
 };
 
-BooleanQuery::BooleanQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {
-}
+BooleanQuery::BooleanQuery(QueryManager* manager,
+                           GLenum target,
+                           int32_t shm_id,
+                           uint32_t shm_offset)
+    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {}
 
 BooleanQuery::~BooleanQuery() {
 }
@@ -140,18 +150,21 @@ bool BooleanQuery::Process(bool did_finish) {
 
 class SummedIntegerQuery : public AbstractIntegerQuery {
  public:
-  SummedIntegerQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  SummedIntegerQuery(QueryManager* manager,
+                     GLenum target,
+                     int32_t shm_id,
+                     uint32_t shm_offset);
   bool Process(bool did_finish) override;
 
  protected:
   ~SummedIntegerQuery() override;
 };
 
-SummedIntegerQuery::SummedIntegerQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {
-}
+SummedIntegerQuery::SummedIntegerQuery(QueryManager* manager,
+                                       GLenum target,
+                                       int32_t shm_id,
+                                       uint32_t shm_offset)
+    : AbstractIntegerQuery(manager, target, shm_id, shm_offset) {}
 
 SummedIntegerQuery::~SummedIntegerQuery() {
 }
@@ -173,8 +186,10 @@ bool SummedIntegerQuery::Process(bool did_finish) {
 
 class CommandsIssuedQuery : public QueryManager::Query {
  public:
-  CommandsIssuedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  CommandsIssuedQuery(QueryManager* manager,
+                      GLenum target,
+                      int32_t shm_id,
+                      uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
@@ -191,10 +206,11 @@ class CommandsIssuedQuery : public QueryManager::Query {
   base::TimeTicks begin_time_;
 };
 
-CommandsIssuedQuery::CommandsIssuedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+CommandsIssuedQuery::CommandsIssuedQuery(QueryManager* manager,
+                                         GLenum target,
+                                         int32_t shm_id,
+                                         uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsIssuedQuery::Begin() {
   MarkAsActive();
@@ -237,8 +253,10 @@ CommandsIssuedQuery::~CommandsIssuedQuery() {
 
 class CommandLatencyQuery : public QueryManager::Query {
  public:
-  CommandLatencyQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  CommandLatencyQuery(QueryManager* manager,
+                      GLenum target,
+                      int32_t shm_id,
+                      uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
@@ -252,10 +270,11 @@ class CommandLatencyQuery : public QueryManager::Query {
   ~CommandLatencyQuery() override;
 };
 
-CommandLatencyQuery::CommandLatencyQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+CommandLatencyQuery::CommandLatencyQuery(QueryManager* manager,
+                                         GLenum target,
+                                         int32_t shm_id,
+                                         uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandLatencyQuery::Begin() {
   MarkAsActive();
@@ -300,8 +319,10 @@ class AsyncReadPixelsCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncReadPixelsCompletedQuery> {
  public:
-  AsyncReadPixelsCompletedQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  AsyncReadPixelsCompletedQuery(QueryManager* manager,
+                                GLenum target,
+                                int32_t shm_id,
+                                uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
@@ -320,10 +341,11 @@ class AsyncReadPixelsCompletedQuery
 };
 
 AsyncReadPixelsCompletedQuery::AsyncReadPixelsCompletedQuery(
-    QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset),
-      complete_result_(false) {
-}
+    QueryManager* manager,
+    GLenum target,
+    int32_t shm_id,
+    uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset), complete_result_(false) {}
 
 bool AsyncReadPixelsCompletedQuery::Begin() {
   MarkAsActive();
@@ -375,8 +397,10 @@ AsyncReadPixelsCompletedQuery::~AsyncReadPixelsCompletedQuery() {
 
 class GetErrorQuery : public QueryManager::Query {
  public:
-  GetErrorQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+  GetErrorQuery(QueryManager* manager,
+                GLenum target,
+                int32_t shm_id,
+                uint32_t shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
@@ -392,10 +416,11 @@ class GetErrorQuery : public QueryManager::Query {
  private:
 };
 
-GetErrorQuery::GetErrorQuery(
-      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
-    : Query(manager, target, shm_id, shm_offset) {
-}
+GetErrorQuery::GetErrorQuery(QueryManager* manager,
+                             GLenum target,
+                             int32_t shm_id,
+                             uint32_t shm_offset)
+    : Query(manager, target, shm_id, shm_offset) {}
 
 bool GetErrorQuery::Begin() {
   MarkAsActive();
@@ -438,8 +463,8 @@ class CommandsCompletedQuery : public QueryManager::Query {
  public:
   CommandsCompletedQuery(QueryManager* manager,
                          GLenum target,
-                         int32 shm_id,
-                         uint32 shm_offset);
+                         int32_t shm_id,
+                         uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
@@ -460,8 +485,8 @@ class CommandsCompletedQuery : public QueryManager::Query {
 
 CommandsCompletedQuery::CommandsCompletedQuery(QueryManager* manager,
                                                GLenum target,
-                                               int32 shm_id,
-                                               uint32 shm_offset)
+                                               int32_t shm_id,
+                                               uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsCompletedQuery::Begin() {
@@ -513,8 +538,8 @@ class TimeElapsedQuery : public QueryManager::Query {
  public:
   TimeElapsedQuery(QueryManager* manager,
                    GLenum target,
-                   int32 shm_id,
-                   uint32 shm_offset);
+                   int32_t shm_id,
+                   uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
@@ -534,11 +559,10 @@ class TimeElapsedQuery : public QueryManager::Query {
 
 TimeElapsedQuery::TimeElapsedQuery(QueryManager* manager,
                                    GLenum target,
-                                   int32 shm_id,
-                                   uint32 shm_offset)
+                                   int32_t shm_id,
+                                   uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
-      gpu_timer_(manager->CreateGPUTimer(true)) {
-}
+      gpu_timer_(manager->CreateGPUTimer(true)) {}
 
 bool TimeElapsedQuery::Begin() {
   // Reset the disjoint value before the query begins if it is safe.
@@ -591,8 +615,8 @@ class TimeStampQuery : public QueryManager::Query {
  public:
   TimeStampQuery(QueryManager* manager,
                  GLenum target,
-                 int32 shm_id,
-                 uint32 shm_offset);
+                 int32_t shm_id,
+                 uint32_t shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
@@ -612,8 +636,8 @@ class TimeStampQuery : public QueryManager::Query {
 
 TimeStampQuery::TimeStampQuery(QueryManager* manager,
                                GLenum target,
-                               int32 shm_id,
-                               uint32 shm_offset)
+                               int32_t shm_id,
+                               uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
       gpu_timer_(manager->CreateGPUTimer(false)) {}
 
@@ -721,7 +745,7 @@ void QueryManager::Destroy(bool have_context) {
   }
 }
 
-void QueryManager::SetDisjointSync(int32 shm_id, uint32 shm_offset) {
+void QueryManager::SetDisjointSync(int32_t shm_id, uint32_t shm_offset) {
   DCHECK(disjoint_notify_shm_id_ == -1);
   DCHECK(shm_id != -1);
 
@@ -735,8 +759,10 @@ void QueryManager::SetDisjointSync(int32 shm_id, uint32 shm_offset) {
   disjoint_notify_shm_offset_ = shm_offset;
 }
 
-QueryManager::Query* QueryManager::CreateQuery(
-    GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset) {
+QueryManager::Query* QueryManager::CreateQuery(GLenum target,
+                                               GLuint client_id,
+                                               int32_t shm_id,
+                                               uint32_t shm_offset) {
   scoped_refptr<Query> query;
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
@@ -896,8 +922,10 @@ void QueryManager::SafelyResetDisjointValue() {
   }
 }
 
-QueryManager::Query::Query(
-     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
+QueryManager::Query::Query(QueryManager* manager,
+                           GLenum target,
+                           int32_t shm_id,
+                           uint32_t shm_offset)
     : manager_(manager),
       target_(target),
       shm_id_(shm_id),
@@ -935,7 +963,7 @@ QueryManager::Query::~Query() {
   }
 }
 
-bool QueryManager::Query::MarkAsCompleted(uint64 result) {
+bool QueryManager::Query::MarkAsCompleted(uint64_t result) {
   UnmarkAsPending();
   QuerySync* sync = manager_->decoder_->GetSharedMemoryAs<QuerySync*>(
       shm_id_, shm_offset_, sizeof(*sync));
diff --git a/gpu/command_buffer/service/query_manager.h b/gpu/command_buffer/service/query_manager.h
index 204c100..f9f6816 100644
--- a/gpu/command_buffer/service/query_manager.h
+++ b/gpu/command_buffer/service/query_manager.h
@@ -5,12 +5,14 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_QUERY_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_QUERY_MANAGER_H_
 
+#include <stdint.h>
+
 #include <deque>
 #include <vector>
 #include "base/atomicops.h"
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ -35,8 +37,10 @@ class GPU_EXPORT QueryManager {
  public:
   class GPU_EXPORT Query : public base::RefCounted<Query> {
    public:
-    Query(
-        QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
+    Query(QueryManager* manager,
+          GLenum target,
+          int32_t shm_id,
+          uint32_t shm_offset);
 
     GLenum target() const {
       return target_;
@@ -66,13 +70,9 @@ class GPU_EXPORT QueryManager {
       return query_state_ == kQueryState_Finished;
     }
 
-    int32 shm_id() const {
-      return shm_id_;
-    }
+    int32_t shm_id() const { return shm_id_; }
 
-    uint32 shm_offset() const {
-      return shm_offset_;
-    }
+    uint32_t shm_offset() const { return shm_offset_; }
 
     // Returns false if shared memory for sync is invalid.
     virtual bool Begin() = 0;
@@ -126,7 +126,7 @@ class GPU_EXPORT QueryManager {
     }
 
     // Returns false if shared memory for sync is invalid.
-    bool MarkAsCompleted(uint64 result);
+    bool MarkAsCompleted(uint64_t result);
 
     void UnmarkAsPending() {
       DCHECK(query_state_ == kQueryState_Pending);
@@ -179,8 +179,8 @@ class GPU_EXPORT QueryManager {
     GLenum target_;
 
     // The shared memory used with this Query.
-    int32 shm_id_;
-    uint32 shm_offset_;
+    int32_t shm_id_;
+    uint32_t shm_offset_;
 
     // Count to set process count do when completed.
     base::subtle::Atomic32 submit_count_;
@@ -210,11 +210,13 @@ class GPU_EXPORT QueryManager {
   void Destroy(bool have_context);
 
   // Sets up a location to be incremented whenever a disjoint is detected.
-  void SetDisjointSync(int32 shm_id, uint32 shm_offset);
+  void SetDisjointSync(int32_t shm_id, uint32_t shm_offset);
 
   // Creates a Query for the given query.
-  Query* CreateQuery(
-      GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset);
+  Query* CreateQuery(GLenum target,
+                     GLuint client_id,
+                     int32_t shm_id,
+                     uint32_t shm_offset);
 
   // Gets the query info for the given query.
   Query* GetQuery(GLuint client_id);
diff --git a/gpu/command_buffer/service/query_manager_unittest.cc b/gpu/command_buffer/service/query_manager_unittest.cc
index 4f23f45..8f61ff2 100644
--- a/gpu/command_buffer/service/query_manager_unittest.cc
+++ b/gpu/command_buffer/service/query_manager_unittest.cc
@@ -2,7 +2,9 @@
 // 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/query_manager.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
@@ -10,6 +12,7 @@
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
+#include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_context.h"
@@ -27,15 +30,15 @@ namespace gles2 {
 
 class QueryManagerTest : public GpuServiceTest {
  public:
-  static const int32 kSharedMemoryId = 401;
-  static const uint32 kSharedMemoryOffset = 132;
-  static const int32 kSharedMemory2Id = 402;
-  static const uint32 kSharedMemory2Offset = 232;
+  static const int32_t kSharedMemoryId = 401;
+  static const uint32_t kSharedMemoryOffset = 132;
+  static const int32_t kSharedMemory2Id = 402;
+  static const uint32_t kSharedMemory2Offset = 232;
   static const size_t kSharedBufferSize = 2048;
-  static const int32 kInvalidSharedMemoryId = 403;
-  static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
-  static const uint32 kInitialResult = 0xBDBDBDBDu;
-  static const uint8 kInitialMemoryValue = 0xBDu;
+  static const int32_t kInvalidSharedMemoryId = 403;
+  static const uint32_t kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
+  static const uint32_t kInitialResult = 0xBDBDBDBDu;
+  static const uint8_t kInitialMemoryValue = 0xBDu;
 
   QueryManagerTest() {
   }
@@ -70,9 +73,11 @@ class QueryManagerTest : public GpuServiceTest {
     manager_.reset(new QueryManager(decoder_.get(), feature_info.get()));
   }
 
-  QueryManager::Query* CreateQuery(
-      GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset,
-      GLuint service_id) {
+  QueryManager::Query* CreateQuery(GLenum target,
+                                   GLuint client_id,
+                                   int32_t shm_id,
+                                   uint32_t shm_offset,
+                                   GLuint service_id) {
     EXPECT_CALL(*gl_, GenQueries(1, _))
        .WillOnce(SetArgumentPointee<1>(service_id))
        .RetiresOnSaturation();
@@ -114,7 +119,7 @@ class QueryManagerTest : public GpuServiceTest {
 
     ~MockCommandBufferEngine() override {}
 
-    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) override {
+    scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32_t shm_id) override {
       switch (shm_id) {
         case kSharedMemoryId: return valid_buffer_;
         case kSharedMemory2Id: return valid_buffer2_;
@@ -127,21 +132,21 @@ class QueryManagerTest : public GpuServiceTest {
       memset(valid_buffer2_->memory(), kInitialMemoryValue, kSharedBufferSize);
     }
 
-    void set_token(int32 token) override { DCHECK(false); }
+    void set_token(int32_t token) override { DCHECK(false); }
 
-    bool SetGetBuffer(int32 /* transfer_buffer_id */) override {
+    bool SetGetBuffer(int32_t /* transfer_buffer_id */) override {
       DCHECK(false);
       return false;
     }
 
     // Overridden from CommandBufferEngine.
-    bool SetGetOffset(int32 offset) override {
+    bool SetGetOffset(int32_t offset) override {
       DCHECK(false);
       return false;
     }
 
     // Overridden from CommandBufferEngine.
-    int32 GetGetOffset() override {
+    int32_t GetGetOffset() override {
       DCHECK(false);
       return 0;
     }
@@ -164,15 +169,15 @@ class QueryManagerManualSetupTest : public QueryManagerTest {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
-const int32 QueryManagerTest::kSharedMemoryId;
-const uint32 QueryManagerTest::kSharedMemoryOffset;
-const int32 QueryManagerTest::kSharedMemory2Id;
-const uint32 QueryManagerTest::kSharedMemory2Offset;
+const int32_t QueryManagerTest::kSharedMemoryId;
+const uint32_t QueryManagerTest::kSharedMemoryOffset;
+const int32_t QueryManagerTest::kSharedMemory2Id;
+const uint32_t QueryManagerTest::kSharedMemory2Offset;
 const size_t QueryManagerTest::kSharedBufferSize;
-const int32 QueryManagerTest::kInvalidSharedMemoryId;
-const uint32 QueryManagerTest::kInvalidSharedMemoryOffset;
-const uint32 QueryManagerTest::kInitialResult;
-const uint8 QueryManagerTest::kInitialMemoryValue;
+const int32_t QueryManagerTest::kInvalidSharedMemoryId;
+const uint32_t QueryManagerTest::kInvalidSharedMemoryOffset;
+const uint32_t QueryManagerTest::kInitialResult;
+const uint8_t QueryManagerTest::kInitialMemoryValue;
 #endif
 
 TEST_F(QueryManagerTest, Basic) {
diff --git a/gpu/command_buffer/service/renderbuffer_manager.cc b/gpu/command_buffer/service/renderbuffer_manager.cc
index a8416f0..f368209 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ -78,7 +81,7 @@ RenderbufferManager::~RenderbufferManager() {
 }
 
 size_t Renderbuffer::EstimatedSize() {
-  uint32 size = 0;
+  uint32_t size = 0;
   manager_->ComputeEstimatedRenderbufferSize(
       width_, height_, samples_, internal_format_, &size);
   return size;
@@ -199,14 +202,15 @@ void RenderbufferManager::RemoveRenderbuffer(GLuint client_id) {
   }
 }
 
-bool RenderbufferManager::ComputeEstimatedRenderbufferSize(int width,
-                                                           int height,
-                                                           int samples,
-                                                           int internal_format,
-                                                           uint32* size) const {
+bool RenderbufferManager::ComputeEstimatedRenderbufferSize(
+    int width,
+    int height,
+    int samples,
+    int internal_format,
+    uint32_t* size) const {
   DCHECK(size);
 
-  uint32 temp = 0;
+  uint32_t temp = 0;
   if (!SafeMultiplyUint32(width, height, &temp)) {
     return false;
   }
diff --git a/gpu/command_buffer/service/renderbuffer_manager.h b/gpu/command_buffer/service/renderbuffer_manager.h
index 72b0aae..d44b576 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.h
+++ b/gpu/command_buffer/service/renderbuffer_manager.h
@@ -5,9 +5,12 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_RENDERBUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_RENDERBUFFER_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ -171,7 +174,7 @@ class GPU_EXPORT RenderbufferManager
                                         int height,
                                         int samples,
                                         int internal_format,
-                                        uint32* size) const;
+                                        uint32_t* size) const;
   GLenum InternalRenderbufferFormatToImplFormat(GLenum impl_format) const;
 
   // base::trace_event::MemoryDumpProvider implementation.
diff --git a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
index beebe0e..e98b3c1 100644
--- a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 
+#include <stdint.h>
+
 #include <set>
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ -191,8 +193,8 @@ TEST_F(RenderbufferManagerMemoryTrackerTest, Basic) {
   const GLsizei kWidth = 128;
   const GLsizei kHeight1 = 64;
   const GLsizei kHeight2 = 32;
-  uint32 expected_size_1 = 0;
-  uint32 expected_size_2 = 0;
+  uint32_t expected_size_1 = 0;
+  uint32_t expected_size_2 = 0;
   manager_->ComputeEstimatedRenderbufferSize(
       kWidth, kHeight1, kSamples, kFormat, &expected_size_1);
   manager_->ComputeEstimatedRenderbufferSize(
diff --git a/gpu/command_buffer/service/sampler_manager.h b/gpu/command_buffer/service/sampler_manager.h
index 101524d..840fdac 100644
--- a/gpu/command_buffer/service/sampler_manager.h
+++ b/gpu/command_buffer/service/sampler_manager.h
@@ -6,9 +6,9 @@
 #define GPU_COMMAND_BUFFER_SERVICE_SAMPLER_MANAGER_H_
 
 #include <vector>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/feature_info.h"
diff --git a/gpu/command_buffer/service/shader_manager.cc b/gpu/command_buffer/service/shader_manager.cc
index 22df5f7..94ffe42 100644
--- a/gpu/command_buffer/service/shader_manager.cc
+++ b/gpu/command_buffer/service/shader_manager.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/shader_manager.h"
 
+#include <stddef.h>
+
 #include <utility>
 
 #include "base/logging.h"
diff --git a/gpu/command_buffer/service/shader_manager.h b/gpu/command_buffer/service/shader_manager.h
index 1869371..6e682ad 100644
--- a/gpu/command_buffer/service/shader_manager.h
+++ b/gpu/command_buffer/service/shader_manager.h
@@ -6,9 +6,9 @@
 #define GPU_COMMAND_BUFFER_SERVICE_SHADER_MANAGER_H_
 
 #include <string>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gl_utils.h"
diff --git a/gpu/command_buffer/service/shader_translator.cc b/gpu/command_buffer/service/shader_translator.cc
index 255caff..5018b06 100644
--- a/gpu/command_buffer/service/shader_translator.cc
+++ b/gpu/command_buffer/service/shader_translator.cc
@@ -4,8 +4,9 @@
 
 #include "gpu/command_buffer/service/shader_translator.h"
 
-#include <string.h>
 #include <GLES2/gl2.h>
+#include <stddef.h>
+#include <string.h>
 #include <algorithm>
 
 #include "base/at_exit.h"
diff --git a/gpu/command_buffer/service/shader_translator.h b/gpu/command_buffer/service/shader_translator.h
index 5a4914d..a17f6ce 100644
--- a/gpu/command_buffer/service/shader_translator.h
+++ b/gpu/command_buffer/service/shader_translator.h
@@ -7,8 +7,8 @@
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
diff --git a/gpu/command_buffer/service/shader_translator_cache.h b/gpu/command_buffer/service/shader_translator_cache.h
index 471b081..06f00f7 100644
--- a/gpu/command_buffer/service/shader_translator_cache.h
+++ b/gpu/command_buffer/service/shader_translator_cache.h
@@ -9,6 +9,7 @@
 
 #include <map>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "third_party/angle/include/GLSLANG/ShaderLang.h"
diff --git a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
index 7cf814a..35a7a84 100644
--- a/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
+++ b/gpu/command_buffer/service/stream_texture_manager_in_process_android.cc
@@ -4,8 +4,11 @@
 
 #include "gpu/command_buffer/service/stream_texture_manager_in_process_android.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/android/surface_texture.h"
@@ -19,7 +22,7 @@ namespace {
 // Simply wraps a SurfaceTexture reference as a GLImage.
 class GLImageImpl : public gl::GLImage {
  public:
-  GLImageImpl(uint32 texture_id,
+  GLImageImpl(uint32_t texture_id,
               gles2::TextureManager* texture_manager,
               const scoped_refptr<gfx::SurfaceTexture>& surface_texture,
               const base::Closure& release_callback);
@@ -46,7 +49,7 @@ class GLImageImpl : public gl::GLImage {
  private:
   ~GLImageImpl() override;
 
-  uint32 texture_id_;
+  uint32_t texture_id_;
   gles2::TextureManager* texture_manager_;
   scoped_refptr<gfx::SurfaceTexture> surface_texture_;
   base::Closure release_callback_;
@@ -55,7 +58,7 @@ class GLImageImpl : public gl::GLImage {
 };
 
 GLImageImpl::GLImageImpl(
-    uint32 texture_id,
+    uint32_t texture_id,
     gles2::TextureManager* texture_manager,
     const scoped_refptr<gfx::SurfaceTexture>& surface_texture,
     const base::Closure& release_callback)
@@ -150,7 +153,7 @@ StreamTextureManagerInProcess::~StreamTextureManagerInProcess() {
 }
 
 GLuint StreamTextureManagerInProcess::CreateStreamTexture(
-    uint32 client_texture_id,
+    uint32_t client_texture_id,
     gles2::TextureManager* texture_manager) {
   CalledOnValidThread();
 
@@ -164,7 +167,7 @@ GLuint StreamTextureManagerInProcess::CreateStreamTexture(
   scoped_refptr<gfx::SurfaceTexture> surface_texture(
       gfx::SurfaceTexture::Create(texture->service_id()));
 
-  uint32 stream_id = next_id_++;
+  uint32_t stream_id = next_id_++;
   base::Closure release_callback =
       base::Bind(&StreamTextureManagerInProcess::OnReleaseStreamTexture,
                  weak_factory_.GetWeakPtr(), stream_id);
@@ -191,7 +194,7 @@ GLuint StreamTextureManagerInProcess::CreateStreamTexture(
   return stream_id;
 }
 
-void StreamTextureManagerInProcess::OnReleaseStreamTexture(uint32 stream_id) {
+void StreamTextureManagerInProcess::OnReleaseStreamTexture(uint32_t stream_id) {
   CalledOnValidThread();
   base::AutoLock lock(map_lock_);
   textures_.erase(stream_id);
@@ -199,7 +202,7 @@ void StreamTextureManagerInProcess::OnReleaseStreamTexture(uint32 stream_id) {
 
 // This can get called from any thread.
 scoped_refptr<gfx::SurfaceTexture>
-StreamTextureManagerInProcess::GetSurfaceTexture(uint32 stream_id) {
+StreamTextureManagerInProcess::GetSurfaceTexture(uint32_t stream_id) {
   base::AutoLock lock(map_lock_);
   TextureMap::const_iterator it = textures_.find(stream_id);
   if (it != textures_.end())
diff --git a/gpu/command_buffer/service/stream_texture_manager_in_process_android.h b/gpu/command_buffer/service/stream_texture_manager_in_process_android.h
index 8b507b0..1f503bf 100644
--- a/gpu/command_buffer/service/stream_texture_manager_in_process_android.h
+++ b/gpu/command_buffer/service/stream_texture_manager_in_process_android.h
@@ -5,8 +5,11 @@
 #ifndef GPU_STREAM_TEXTURE_MANAGER_IN_PROCESS_ANDROID_H_
 #define GPU_STREAM_TEXTURE_MANAGER_IN_PROCESS_ANDROID_H_
 
+#include <stdint.h>
+
 #include <map>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
@@ -27,19 +30,19 @@ class StreamTextureManagerInProcess : public base::NonThreadSafe {
   StreamTextureManagerInProcess();
   ~StreamTextureManagerInProcess();
 
-  uint32 CreateStreamTexture(uint32 client_texture_id,
-                             gles2::TextureManager* texture_manager);
+  uint32_t CreateStreamTexture(uint32_t client_texture_id,
+                               gles2::TextureManager* texture_manager);
 
   // This method can be called from any thread.
-  scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(uint32 stream_id);
+  scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(uint32_t stream_id);
 
  private:
-  void OnReleaseStreamTexture(uint32 stream_id);
+  void OnReleaseStreamTexture(uint32_t stream_id);
 
-  typedef std::map<uint32, scoped_refptr<gfx::SurfaceTexture> > TextureMap;
+  typedef std::map<uint32_t, scoped_refptr<gfx::SurfaceTexture>> TextureMap;
   TextureMap textures_;
   base::Lock map_lock_;
-  uint32 next_id_;
+  uint32_t next_id_;
 
   base::WeakPtrFactory<StreamTextureManagerInProcess> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(StreamTextureManagerInProcess);
diff --git a/gpu/command_buffer/service/sync_point_manager.cc b/gpu/command_buffer/service/sync_point_manager.cc
index 8a88c72..435d0b2 100644
--- a/gpu/command_buffer/service/sync_point_manager.cc
+++ b/gpu/command_buffer/service/sync_point_manager.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/sync_point_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <climits>
 
 #include "base/bind.h"
@@ -352,9 +355,9 @@ scoped_refptr<SyncPointClientState> SyncPointManager::GetSyncPointClientState(
   return nullptr;
 }
 
-uint32 SyncPointManager::GenerateSyncPoint() {
+uint32_t SyncPointManager::GenerateSyncPoint() {
   base::AutoLock lock(lock_);
-  uint32 sync_point = next_sync_point_++;
+  uint32_t sync_point = next_sync_point_++;
   // When an integer overflow occurs, don't return 0.
   if (!sync_point)
     sync_point = next_sync_point_++;
@@ -369,7 +372,7 @@ uint32 SyncPointManager::GenerateSyncPoint() {
   return sync_point;
 }
 
-void SyncPointManager::RetireSyncPoint(uint32 sync_point) {
+void SyncPointManager::RetireSyncPoint(uint32_t sync_point) {
   ClosureList list;
   {
     base::AutoLock lock(lock_);
@@ -388,7 +391,7 @@ void SyncPointManager::RetireSyncPoint(uint32 sync_point) {
     i->Run();
 }
 
-void SyncPointManager::AddSyncPointCallback(uint32 sync_point,
+void SyncPointManager::AddSyncPointCallback(uint32_t sync_point,
                                             const base::Closure& callback) {
   {
     base::AutoLock lock(lock_);
@@ -401,12 +404,12 @@ void SyncPointManager::AddSyncPointCallback(uint32 sync_point,
   callback.Run();
 }
 
-bool SyncPointManager::IsSyncPointRetired(uint32 sync_point) {
+bool SyncPointManager::IsSyncPointRetired(uint32_t sync_point) {
   base::AutoLock lock(lock_);
   return IsSyncPointRetiredLocked(sync_point);
 }
 
-void SyncPointManager::WaitSyncPoint(uint32 sync_point) {
+void SyncPointManager::WaitSyncPoint(uint32_t sync_point) {
   if (!allow_threaded_wait_) {
     DCHECK(IsSyncPointRetired(sync_point));
     return;
@@ -418,7 +421,7 @@ void SyncPointManager::WaitSyncPoint(uint32 sync_point) {
   }
 }
 
-bool SyncPointManager::IsSyncPointRetiredLocked(uint32 sync_point) {
+bool SyncPointManager::IsSyncPointRetiredLocked(uint32_t sync_point) {
   lock_.AssertAcquired();
   return sync_point_map_.find(sync_point) == sync_point_map_.end();
 }
diff --git a/gpu/command_buffer/service/sync_point_manager.h b/gpu/command_buffer/service/sync_point_manager.h
index c71b471..cecf9fe 100644
--- a/gpu/command_buffer/service/sync_point_manager.h
+++ b/gpu/command_buffer/service/sync_point_manager.h
@@ -5,6 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 
+#include <stdint.h>
+
 #include <functional>
 #include <queue>
 #include <vector>
@@ -279,33 +281,33 @@ class GPU_EXPORT SyncPointManager {
 
   // Generates a sync point, returning its ID. This can me called on any thread.
   // IDs start at a random number. Never return 0.
-  uint32 GenerateSyncPoint();
+  uint32_t GenerateSyncPoint();
 
   // Retires a sync point. This will call all the registered callbacks for this
   // sync point. This can only be called on the main thread.
-  void RetireSyncPoint(uint32 sync_point);
+  void RetireSyncPoint(uint32_t sync_point);
 
   // Adds a callback to the sync point. The callback will be called when the
   // sync point is retired, or immediately (from within that function) if the
   // sync point was already retired (or not created yet). This can only be
   // called on the main thread.
-  void AddSyncPointCallback(uint32 sync_point, const base::Closure& callback);
+  void AddSyncPointCallback(uint32_t sync_point, const base::Closure& callback);
 
-  bool IsSyncPointRetired(uint32 sync_point);
+  bool IsSyncPointRetired(uint32_t sync_point);
 
   // Block and wait until a sync point is signaled. This is only useful when
   // the sync point is signaled on another thread.
-  void WaitSyncPoint(uint32 sync_point);
+  void WaitSyncPoint(uint32_t sync_point);
 
  private:
   friend class SyncPointClient;
   friend class SyncPointOrderData;
 
   typedef std::vector<base::Closure> ClosureList;
-  typedef base::hash_map<uint32, ClosureList> SyncPointMap;
+  typedef base::hash_map<uint32_t, ClosureList> SyncPointMap;
   typedef base::hash_map<uint64_t, SyncPointClient*> ClientMap;
 
-  bool IsSyncPointRetiredLocked(uint32 sync_point);
+  bool IsSyncPointRetiredLocked(uint32_t sync_point);
   uint32_t GenerateOrderNumber();
   void DestroySyncPointClient(CommandBufferNamespace namespace_id,
                               uint64_t client_id);
@@ -323,7 +325,7 @@ class GPU_EXPORT SyncPointManager {
   // held.
   base::Lock lock_;
   SyncPointMap sync_point_map_;
-  uint32 next_sync_point_;
+  uint32_t next_sync_point_;
   base::ConditionVariable retire_cond_var_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointManager);
diff --git a/gpu/command_buffer/service/sync_point_manager_unittest.cc b/gpu/command_buffer/service/sync_point_manager_unittest.cc
index 0b42505..28321c4 100644
--- a/gpu/command_buffer/service/sync_point_manager_unittest.cc
+++ b/gpu/command_buffer/service/sync_point_manager_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include <queue>
 
 #include "base/bind.h"
diff --git a/gpu/command_buffer/service/test_helper.cc b/gpu/command_buffer/service/test_helper.cc
index 40c285a..a18b701 100644
--- a/gpu/command_buffer/service/test_helper.cc
+++ b/gpu/command_buffer/service/test_helper.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/test_helper.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 
@@ -418,7 +421,7 @@ void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
   InSequence sequence;
 
   EXPECT_CALL(*gl, GetString(GL_VERSION))
-      .WillOnce(Return(reinterpret_cast<const uint8*>(gl_version)))
+      .WillOnce(Return(reinterpret_cast<const uint8_t*>(gl_version)))
       .RetiresOnSaturation();
 
   // Persistent storage is needed for the split extension string.
@@ -435,21 +438,21 @@ void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         .RetiresOnSaturation();
     for (size_t ii = 0; ii < split_extensions_.size(); ++ii) {
       EXPECT_CALL(*gl, GetStringi(GL_EXTENSIONS, ii))
-          .WillOnce(Return(reinterpret_cast<const uint8*>(
-              split_extensions_[ii].c_str())))
+          .WillOnce(Return(
+              reinterpret_cast<const uint8_t*>(split_extensions_[ii].c_str())))
           .RetiresOnSaturation();
     }
   } else {
     EXPECT_CALL(*gl, GetString(GL_EXTENSIONS))
-        .WillOnce(Return(reinterpret_cast<const uint8*>(extensions)))
+        .WillOnce(Return(reinterpret_cast<const uint8_t*>(extensions)))
         .RetiresOnSaturation();
   }
 
   EXPECT_CALL(*gl, GetString(GL_VERSION))
-      .WillOnce(Return(reinterpret_cast<const uint8*>(gl_version)))
+      .WillOnce(Return(reinterpret_cast<const uint8_t*>(gl_version)))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl, GetString(GL_RENDERER))
-      .WillOnce(Return(reinterpret_cast<const uint8*>(gl_renderer)))
+      .WillOnce(Return(reinterpret_cast<const uint8_t*>(gl_renderer)))
       .RetiresOnSaturation();
 
   if ((strstr(extensions, "GL_ARB_texture_float") ||
diff --git a/gpu/command_buffer/service/test_helper.h b/gpu/command_buffer/service/test_helper.h
index 7072428..272c9aa 100644
--- a/gpu/command_buffer/service/test_helper.h
+++ b/gpu/command_buffer/service/test_helper.h
@@ -5,6 +5,8 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_TEST_HELPER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TEST_HELPER_H_
 
+#include <stddef.h>
+
 #include <string>
 #include <vector>
 
diff --git a/gpu/command_buffer/service/texture_definition.cc b/gpu/command_buffer/service/texture_definition.cc
index ed3e8b6..e9d52aa 100644
--- a/gpu/command_buffer/service/texture_definition.cc
+++ b/gpu/command_buffer/service/texture_definition.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/texture_definition.h"
 
+#include <stdint.h>
+
 #include <list>
 
 #include "base/lazy_instance.h"
@@ -17,6 +19,7 @@
 #include "ui/gl/scoped_binders.h"
 
 #if !defined(OS_MACOSX)
+#include "base/macros.h"
 #include "ui/gl/gl_surface_egl.h"
 #endif
 
diff --git a/gpu/command_buffer/service/texture_definition.h b/gpu/command_buffer/service/texture_definition.h
index bc1393c..2f49c3a 100644
--- a/gpu/command_buffer/service/texture_definition.h
+++ b/gpu/command_buffer/service/texture_definition.h
@@ -7,6 +7,7 @@
 
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "ui/gfx/geometry/rect.h"
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index e743936..1bce494 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <set>
 #include <utility>
@@ -591,7 +594,7 @@ bool Texture::CanGenerateMipmaps(
 
   // Can't generate mips for depth or stencil textures.
   const Texture::LevelInfo& base = face_infos_[0].level_infos[base_level_];
-  uint32 channels = GLES2Util::GetChannelsForFormat(base.format);
+  uint32_t channels = GLES2Util::GetChannelsForFormat(base.format);
   if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
     return false;
   }
@@ -904,9 +907,9 @@ bool Texture::ValidForTexture(
   if (level >= 0 && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
-    int32 max_x;
-    int32 max_y;
-    int32 max_z;
+    int32_t max_x;
+    int32_t max_y;
+    int32_t max_z;
     return SafeAddInt32(xoffset, width, &max_x) &&
            SafeAddInt32(yoffset, height, &max_y) &&
            SafeAddInt32(zoffset, depth, &max_z) &&
@@ -1469,7 +1472,7 @@ scoped_refptr<TextureRef>
     TextureManager::CreateDefaultAndBlackTextures(
         GLenum target,
         GLuint* black_texture) {
-  static uint8 black[] = {0, 0, 0, 255};
+  static uint8_t black[] = {0, 0, 0, 255};
 
   // Sampling a texture not associated with any EGLImage sibling will return
   // black values according to the spec.
@@ -1852,7 +1855,7 @@ bool TextureManager::ValidateTextureParameters(
     return false;
   }
   if (!feature_info_->IsES3Enabled()) {
-    uint32 channels = GLES2Util::GetChannelsForFormat(format);
+    uint32_t channels = GLES2Util::GetChannelsForFormat(format);
     if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
       ERRORSTATE_SET_GL_ERROR(
           error_state, GL_INVALID_OPERATION, function_name,
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index 2f118de..1a2b532 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -5,13 +5,16 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ -109,9 +112,7 @@ class GPU_EXPORT Texture {
     return num_uncleared_mips_;
   }
 
-  uint32 estimated_size() const {
-    return estimated_size_;
-  }
+  uint32_t estimated_size() const { return estimated_size_; }
 
   bool CanRenderTo() const {
     return target_ != GL_TEXTURE_EXTERNAL_OES;
@@ -265,7 +266,7 @@ class GPU_EXPORT Texture {
     GLenum type;
     scoped_refptr<gl::GLImage> image;
     ImageState image_state;
-    uint32 estimated_size;
+    uint32_t estimated_size;
   };
 
   struct FaceInfo {
@@ -497,7 +498,7 @@ class GPU_EXPORT Texture {
   bool has_images_;
 
   // Size in bytes this texture is assumed to take in memory.
-  uint32 estimated_size_;
+  uint32_t estimated_size_;
 
   // Cache of the computed CanRenderCondition flag.
   CanRenderCondition can_render_condition_;
@@ -859,7 +860,7 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
     GLenum format;
     GLenum type;
     const void* pixels;
-    uint32 pixels_size;
+    uint32_t pixels_size;
     TexImageCommandType command_type;
   };
 
@@ -888,7 +889,7 @@ class GPU_EXPORT TextureManager : public base::trace_event::MemoryDumpProvider {
     GLenum format;
     GLenum type;
     const void* pixels;
-    uint32 pixels_size;
+    uint32_t pixels_size;
     // TODO(kkinnunen): currently this is used only for TexSubImage2D.
   };
 
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 4f026d1..740e8f4 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -4,9 +4,13 @@
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
diff --git a/gpu/command_buffer/service/transfer_buffer_manager.cc b/gpu/command_buffer/service/transfer_buffer_manager.cc
index 46f7cf7..f9db75e 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 
+#include <stdint.h>
+
 #include <limits>
 
 #include "base/logging.h"
@@ -55,7 +57,7 @@ bool TransferBufferManager::Initialize() {
 }
 
 bool TransferBufferManager::RegisterTransferBuffer(
-    int32 id,
+    int32_t id,
     scoped_ptr<BufferBacking> buffer_backing) {
   if (id <= 0) {
     DVLOG(0) << "Cannot register transfer buffer with non-positive ID.";
@@ -82,7 +84,7 @@ bool TransferBufferManager::RegisterTransferBuffer(
   return true;
 }
 
-void TransferBufferManager::DestroyTransferBuffer(int32 id) {
+void TransferBufferManager::DestroyTransferBuffer(int32_t id) {
   BufferMap::iterator it = registered_buffers_.find(id);
   if (it == registered_buffers_.end()) {
     DVLOG(0) << "Transfer buffer ID was not registered.";
@@ -95,7 +97,7 @@ void TransferBufferManager::DestroyTransferBuffer(int32 id) {
   registered_buffers_.erase(it);
 }
 
-scoped_refptr<Buffer> TransferBufferManager::GetTransferBuffer(int32 id) {
+scoped_refptr<Buffer> TransferBufferManager::GetTransferBuffer(int32_t id) {
   if (id == 0)
     return NULL;
 
@@ -110,7 +112,7 @@ bool TransferBufferManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& buffer_entry : registered_buffers_) {
-    int32 buffer_id = buffer_entry.first;
+    int32_t buffer_id = buffer_entry.first;
     const Buffer* buffer = buffer_entry.second.get();
     std::string dump_name =
         base::StringPrintf("gpu/transfer_memory/client_%d/buffer_%d",
diff --git a/gpu/command_buffer/service/transfer_buffer_manager.h b/gpu/command_buffer/service/transfer_buffer_manager.h
index a23f7c7..8843160 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.h
+++ b/gpu/command_buffer/service/transfer_buffer_manager.h
@@ -5,12 +5,15 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_TRANSFER_BUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TRANSFER_BUFFER_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
@@ -23,10 +26,10 @@ class MemoryTracker;
 class GPU_EXPORT TransferBufferManagerInterface :
     public base::RefCounted<TransferBufferManagerInterface> {
  public:
-  virtual bool RegisterTransferBuffer(int32 id,
+  virtual bool RegisterTransferBuffer(int32_t id,
                                       scoped_ptr<BufferBacking> buffer) = 0;
-  virtual void DestroyTransferBuffer(int32 id) = 0;
-  virtual scoped_refptr<Buffer> GetTransferBuffer(int32 id) = 0;
+  virtual void DestroyTransferBuffer(int32_t id) = 0;
+  virtual scoped_refptr<Buffer> GetTransferBuffer(int32_t id) = 0;
 
  protected:
   friend class base::RefCounted<TransferBufferManagerInterface>;
@@ -46,15 +49,15 @@ class GPU_EXPORT TransferBufferManager
 
   bool Initialize();
   bool RegisterTransferBuffer(
-      int32 id,
+      int32_t id,
       scoped_ptr<BufferBacking> buffer_backing) override;
-  void DestroyTransferBuffer(int32 id) override;
-  scoped_refptr<Buffer> GetTransferBuffer(int32 id) override;
+  void DestroyTransferBuffer(int32_t id) override;
+  scoped_refptr<Buffer> GetTransferBuffer(int32_t id) override;
 
  private:
   ~TransferBufferManager() override;
 
-  typedef base::hash_map<int32, scoped_refptr<Buffer> > BufferMap;
+  typedef base::hash_map<int32_t, scoped_refptr<Buffer>> BufferMap;
   BufferMap registered_buffers_;
   size_t shared_memory_bytes_allocated_;
   gles2::MemoryTracker* memory_tracker_;
diff --git a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
index bde9493..56edaed 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
@@ -4,9 +4,11 @@
 
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 
+#include <stddef.h>
+
 #include "base/memory/scoped_ptr.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 using base::SharedMemory;
 
diff --git a/gpu/command_buffer/service/valuebuffer_manager.cc b/gpu/command_buffer/service/valuebuffer_manager.cc
index 96a50aa..d2af500 100644
--- a/gpu/command_buffer/service/valuebuffer_manager.cc
+++ b/gpu/command_buffer/service/valuebuffer_manager.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
@@ -159,7 +161,7 @@ void ValuebufferManager::UpdateValuebufferState(Valuebuffer* valuebuffer) {
   valuebuffer->UpdateState(pending_state_map_.get());
 }
 
-uint32 ValuebufferManager::ApiTypeForSubscriptionTarget(unsigned int target) {
+uint32_t ValuebufferManager::ApiTypeForSubscriptionTarget(unsigned int target) {
   switch (target) {
     case GL_MOUSE_POSITION_CHROMIUM:
       return Program::kUniform2i;
diff --git a/gpu/command_buffer/service/valuebuffer_manager.h b/gpu/command_buffer/service/valuebuffer_manager.h
index 774b3a3..0af7400 100644
--- a/gpu/command_buffer/service/valuebuffer_manager.h
+++ b/gpu/command_buffer/service/valuebuffer_manager.h
@@ -5,8 +5,10 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_VALUEBUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_VALUEBUFFER_MANAGER_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
@@ -125,7 +127,7 @@ class GPU_EXPORT ValuebufferManager {
   // Updates the value state for the given Valuebuffer
   void UpdateValuebufferState(Valuebuffer* valuebuffer);
 
-  static uint32 ApiTypeForSubscriptionTarget(unsigned int target);
+  static uint32_t ApiTypeForSubscriptionTarget(unsigned int target);
 
  private:
   friend class Valuebuffer;
diff --git a/gpu/command_buffer/service/vertex_array_manager.cc b/gpu/command_buffer/service/vertex_array_manager.cc
index 0809eda..0f48a2a 100644
--- a/gpu/command_buffer/service/vertex_array_manager.cc
+++ b/gpu/command_buffer/service/vertex_array_manager.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ -32,7 +34,7 @@ void VertexArrayManager::Destroy(bool have_context) {
 scoped_refptr<VertexAttribManager>
 VertexArrayManager::CreateVertexAttribManager(GLuint client_id,
                                               GLuint service_id,
-                                              uint32 num_vertex_attribs,
+                                              uint32_t num_vertex_attribs,
                                               bool client_visible) {
   scoped_refptr<VertexAttribManager> vertex_attrib_manager(
     new VertexAttribManager(this, service_id, num_vertex_attribs));
diff --git a/gpu/command_buffer/service/vertex_array_manager.h b/gpu/command_buffer/service/vertex_array_manager.h
index 97ecc1a..5649da1 100644
--- a/gpu/command_buffer/service/vertex_array_manager.h
+++ b/gpu/command_buffer/service/vertex_array_manager.h
@@ -5,9 +5,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_VERTEX_ARRAY_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_VERTEX_ARRAY_MANAGER_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gl_utils.h"
@@ -33,7 +35,7 @@ class GPU_EXPORT VertexArrayManager {
   scoped_refptr<VertexAttribManager> CreateVertexAttribManager(
       GLuint client_id,
       GLuint service_id,
-      uint32 num_vertex_attribs,
+      uint32_t num_vertex_attribs,
       bool client_visible);
 
   // Gets the vertex attrib manager for the given vertex array.
diff --git a/gpu/command_buffer/service/vertex_array_manager_unittest.cc b/gpu/command_buffer/service/vertex_array_manager_unittest.cc
index 0d3d1d0..73f9bc7 100644
--- a/gpu/command_buffer/service/vertex_array_manager_unittest.cc
+++ b/gpu/command_buffer/service/vertex_array_manager_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 
@@ -20,7 +22,7 @@ namespace gles2 {
 
 class VertexArrayManagerTest : public GpuServiceTest {
  public:
-  static const uint32 kNumVertexAttribs = 8;
+  static const uint32_t kNumVertexAttribs = 8;
 
   VertexArrayManagerTest() {
   }
@@ -43,7 +45,7 @@ class VertexArrayManagerTest : public GpuServiceTest {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
-const uint32 VertexArrayManagerTest::kNumVertexAttribs;
+const uint32_t VertexArrayManagerTest::kNumVertexAttribs;
 #endif
 
 TEST_F(VertexArrayManagerTest, Basic) {
diff --git a/gpu/command_buffer/service/vertex_attrib_manager.cc b/gpu/command_buffer/service/vertex_attrib_manager.cc
index 7d2752f..a0fe10d 100644
--- a/gpu/command_buffer/service/vertex_attrib_manager.cc
+++ b/gpu/command_buffer/service/vertex_attrib_manager.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 
+#include <stdint.h>
+
 #include <list>
 
 #include "base/logging.h"
@@ -84,7 +86,7 @@ bool VertexAttrib::CanAccess(GLuint index) const {
     return false;
   }
 
-  uint32 usable_size = buffer_size - offset_;
+  uint32_t usable_size = buffer_size - offset_;
   GLuint num_elements = usable_size / real_stride_ +
       ((usable_size % real_stride_) >=
        (GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type_) * size_) ? 1 : 0);
@@ -99,8 +101,9 @@ VertexAttribManager::VertexAttribManager()
       service_id_(0) {
 }
 
-VertexAttribManager::VertexAttribManager(
-    VertexArrayManager* manager, GLuint service_id, uint32 num_vertex_attribs)
+VertexAttribManager::VertexAttribManager(VertexArrayManager* manager,
+                                         GLuint service_id,
+                                         uint32_t num_vertex_attribs)
     : num_fixed_attribs_(0),
       element_array_buffer_(NULL),
       manager_(manager),
@@ -121,11 +124,11 @@ VertexAttribManager::~VertexAttribManager() {
   }
 }
 
-void VertexAttribManager::Initialize(
-    uint32 max_vertex_attribs, bool init_attribs) {
+void VertexAttribManager::Initialize(uint32_t max_vertex_attribs,
+                                     bool init_attribs) {
   vertex_attribs_.resize(max_vertex_attribs);
 
-  for (uint32 vv = 0; vv < vertex_attribs_.size(); ++vv) {
+  for (uint32_t vv = 0; vv < vertex_attribs_.size(); ++vv) {
     vertex_attribs_[vv].set_index(vv);
     vertex_attribs_[vv].SetList(&disabled_vertex_attribs_);
 
@@ -155,7 +158,7 @@ void VertexAttribManager::Unbind(Buffer* buffer) {
   if (element_array_buffer_.get() == buffer) {
     element_array_buffer_ = NULL;
   }
-  for (uint32 vv = 0; vv < vertex_attribs_.size(); ++vv) {
+  for (uint32_t vv = 0; vv < vertex_attribs_.size(); ++vv) {
     vertex_attribs_[vv].Unbind(buffer);
   }
 }
diff --git a/gpu/command_buffer/service/vertex_attrib_manager.h b/gpu/command_buffer/service/vertex_attrib_manager.h
index f7fd495..875e15a 100644
--- a/gpu/command_buffer/service/vertex_attrib_manager.h
+++ b/gpu/command_buffer/service/vertex_attrib_manager.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_VERTEX_ATTRIB_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_VERTEX_ATTRIB_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 #include <vector>
 #include "base/logging.h"
@@ -177,7 +180,7 @@ class GPU_EXPORT VertexAttribManager :
 
   VertexAttribManager();
 
-  void Initialize(uint32 num_vertex_attribs, bool init_attribs);
+  void Initialize(uint32_t num_vertex_attribs, bool init_attribs);
 
   bool Enable(GLuint index, bool enable);
 
@@ -263,8 +266,9 @@ class GPU_EXPORT VertexAttribManager :
   friend class base::RefCounted<VertexAttribManager>;
 
   // Used when creating from a VertexArrayManager
-  VertexAttribManager(VertexArrayManager* manager, GLuint service_id,
-      uint32 num_vertex_attribs);
+  VertexAttribManager(VertexArrayManager* manager,
+                      GLuint service_id,
+                      uint32_t num_vertex_attribs);
 
   ~VertexAttribManager();
 
diff --git a/gpu/command_buffer/service/vertex_attrib_manager_unittest.cc b/gpu/command_buffer/service/vertex_attrib_manager_unittest.cc
index 9c52194..2e31c16 100644
--- a/gpu/command_buffer/service/vertex_attrib_manager_unittest.cc
+++ b/gpu/command_buffer/service/vertex_attrib_manager_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 
+#include <stdint.h>
+
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
@@ -21,7 +23,7 @@ namespace gles2 {
 
 class VertexAttribManagerTest : public GpuServiceTest {
  public:
-  static const uint32 kNumVertexAttribs = 8;
+  static const uint32_t kNumVertexAttribs = 8;
 
   VertexAttribManagerTest() {
   }
@@ -32,7 +34,7 @@ class VertexAttribManagerTest : public GpuServiceTest {
   void SetUp() override {
     GpuServiceTest::SetUp();
 
-    for (uint32 ii = 0; ii < kNumVertexAttribs; ++ii) {
+    for (uint32_t ii = 0; ii < kNumVertexAttribs; ++ii) {
       EXPECT_CALL(*gl_, VertexAttrib4f(ii, 0.0f, 0.0f, 0.0f, 1.0f))
           .Times(1)
           .RetiresOnSaturation();
@@ -47,7 +49,7 @@ class VertexAttribManagerTest : public GpuServiceTest {
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
-const uint32 VertexAttribManagerTest::kNumVertexAttribs;
+const uint32_t VertexAttribManagerTest::kNumVertexAttribs;
 #endif
 
 TEST_F(VertexAttribManagerTest, Basic) {
@@ -58,7 +60,7 @@ TEST_F(VertexAttribManagerTest, Basic) {
       manager_->GetEnabledVertexAttribs();
   EXPECT_EQ(0u, enabled_attribs.size());
 
-  for (uint32 ii = 0; ii < kNumVertexAttribs; ii += kNumVertexAttribs - 1) {
+  for (uint32_t ii = 0; ii < kNumVertexAttribs; ii += kNumVertexAttribs - 1) {
     VertexAttrib* attrib = manager_->GetVertexAttrib(ii);
     ASSERT_TRUE(attrib != NULL);
     EXPECT_EQ(ii, attrib->index());
diff --git a/gpu/command_buffer/tests/compressed_texture_test.cc b/gpu/command_buffer/tests/compressed_texture_test.cc
index 754e2d4..03a31d2 100644
--- a/gpu/command_buffer/tests/compressed_texture_test.cc
+++ b/gpu/command_buffer/tests/compressed_texture_test.cc
@@ -5,8 +5,8 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
-#include "base/basictypes.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -15,20 +15,20 @@
 
 namespace gpu {
 
-static const uint16 kRedMask = 0xF800;
-static const uint16 kGreenMask = 0x07E0;
-static const uint16 kBlueMask = 0x001F;
+static const uint16_t kRedMask = 0xF800;
+static const uint16_t kGreenMask = 0x07E0;
+static const uint16_t kBlueMask = 0x001F;
 
 // Color palette in 565 format.
-static const uint16 kPalette[] = {
-  kGreenMask | kBlueMask,   // Cyan.
-  kBlueMask  | kRedMask,    // Magenta.
-  kRedMask   | kGreenMask,  // Yellow.
-  0x0000,                   // Black.
-  kRedMask,                 // Red.
-  kGreenMask,               // Green.
-  kBlueMask,                // Blue.
-  0xFFFF,                   // White.
+static const uint16_t kPalette[] = {
+    kGreenMask | kBlueMask,  // Cyan.
+    kBlueMask | kRedMask,    // Magenta.
+    kRedMask | kGreenMask,   // Yellow.
+    0x0000,                  // Black.
+    kRedMask,                // Red.
+    kGreenMask,              // Green.
+    kBlueMask,               // Blue.
+    0xFFFF,                  // White.
 };
 static const unsigned kBlockSize = 4;
 static const unsigned kPaletteSize = sizeof(kPalette) / sizeof(kPalette[0]);
@@ -52,8 +52,8 @@ static const char* extension(GLenum format) {
 
 // Index that chooses the given colors (color_0 and color_1),
 // not the interpolated colors (color_2 and color_3).
-static const uint16 kColor0 = 0x0000;
-static const uint16 kColor1 = 0x5555;
+static const uint16_t kColor0 = 0x0000;
+static const uint16_t kColor1 = 0x5555;
 
 static GLuint LoadCompressedTexture(const void* data,
                                     GLsizeiptr size,
@@ -74,7 +74,7 @@ static GLuint LoadCompressedTexture(const void* data,
 
 GLuint LoadTextureDXT1(bool alpha) {
   const unsigned kStride = 4;
-  uint16 data[kStride * kPaletteSize];
+  uint16_t data[kStride * kPaletteSize];
   for (unsigned i = 0; i < kPaletteSize; ++i) {
     // Each iteration defines a 4x4 block of texture.
     unsigned j = kStride * i;
@@ -91,8 +91,8 @@ GLuint LoadTextureDXT1(bool alpha) {
 
 GLuint LoadTextureDXT3() {
   const unsigned kStride = 8;
-  const uint16 kOpaque = 0xFFFF;
-  uint16 data[kStride * kPaletteSize];
+  const uint16_t kOpaque = 0xFFFF;
+  uint16_t data[kStride * kPaletteSize];
   for (unsigned i = 0; i < kPaletteSize; ++i) {
     // Each iteration defines a 4x4 block of texture.
     unsigned j = kStride * i;
@@ -114,9 +114,9 @@ GLuint LoadTextureDXT3() {
 
 GLuint LoadTextureDXT5() {
   const unsigned kStride = 8;
-  const uint16 kClear = 0x0000;
-  const uint16 kAlpha7 = 0xFFFF;  // Opaque alpha index.
-  uint16 data[kStride * kPaletteSize];
+  const uint16_t kClear = 0x0000;
+  const uint16_t kAlpha7 = 0xFFFF;  // Opaque alpha index.
+  uint16_t data[kStride * kPaletteSize];
   for (unsigned i = 0; i < kPaletteSize; ++i) {
     // Each iteration defines a 4x4 block of texture.
     unsigned j = kStride * i;
@@ -136,10 +136,10 @@ GLuint LoadTextureDXT5() {
                                kTextureHeight);
 }
 
-static void ToRGB888(uint16 rgb565, uint8 rgb888[]) {
-  uint8 r5 = (rgb565 & kRedMask)   >> 11;
-  uint8 g6 = (rgb565 & kGreenMask) >> 5;
-  uint8 b5 = (rgb565 & kBlueMask);
+static void ToRGB888(uint16_t rgb565, uint8_t rgb888[]) {
+  uint8_t r5 = (rgb565 & kRedMask) >> 11;
+  uint8_t g6 = (rgb565 & kGreenMask) >> 5;
+  uint8_t b5 = (rgb565 & kBlueMask);
   // Replicate upper bits to lower empty bits.
   rgb888[0] = (r5 << 3) | (r5 >> 2);
   rgb888[1] = (g6 << 2) | (g6 >> 4);
@@ -229,7 +229,7 @@ TEST_P(CompressedTextureTest, Draw) {
 
   // Verify results.
   int origin[] = {0, 0};
-  uint8 expected_rgba[] = {0, 0, 0, 255};
+  uint8_t expected_rgba[] = {0, 0, 0, 255};
   for (unsigned i = 0; i < kPaletteSize; ++i) {
     origin[0] = kBlockSize * i;
     ToRGB888(kPalette[i], expected_rgba);
diff --git a/gpu/command_buffer/tests/gl_bind_uniform_location_unittest.cc b/gpu/command_buffer/tests/gl_bind_uniform_location_unittest.cc
index 5c19cf0..3afb5f7 100644
--- a/gpu/command_buffer/tests/gl_bind_uniform_location_unittest.cc
+++ b/gpu/command_buffer/tests/gl_bind_uniform_location_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -93,7 +94,7 @@ TEST_P(BindUniformLocationTest, Basic) {
 
   glDrawArrays(GL_TRIANGLES, 0, 6);
 
-  static const uint8 expected[] = { 64, 128, 192, 255 };
+  static const uint8_t expected[] = {64, 128, 192, 255};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, kResolution, kResolution, 1, expected));
 
@@ -260,7 +261,7 @@ TEST_P(BindUniformLocationTest, Compositor) {
 
   glDrawArrays(GL_TRIANGLES, 0, 6);
 
-  static const uint8 expected[] = { 204, 204, 204, 204 };
+  static const uint8_t expected[] = {204, 204, 204, 204};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, kResolution, kResolution, 1, expected));
 
diff --git a/gpu/command_buffer/tests/gl_chromium_framebuffer_multisample_unittest.cc b/gpu/command_buffer/tests/gl_chromium_framebuffer_multisample_unittest.cc
index 8268b66..ece68710 100644
--- a/gpu/command_buffer/tests/gl_chromium_framebuffer_multisample_unittest.cc
+++ b/gpu/command_buffer/tests/gl_chromium_framebuffer_multisample_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -146,8 +147,8 @@ TEST_F(GLChromiumFramebufferMultisampleTest, DrawAndResolve) {
                             GL_NEAREST);
 
   // Verify.
-  const uint8 green[] = {0, 255, 0, 255};
-  const uint8 black[] = {0, 0, 0, 0};
+  const uint8_t green[] = {0, 255, 0, 255};
+  const uint8_t black[] = {0, 0, 0, 0};
   glBindFramebuffer(GL_READ_FRAMEBUFFER, resolve_fbo);
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(width / 4, (3 * height) / 4, 1, 1, 0, green));
diff --git a/gpu/command_buffer/tests/gl_chromium_path_rendering_unittest.cc b/gpu/command_buffer/tests/gl_chromium_path_rendering_unittest.cc
index 2120c81..cc2a4ca 100644
--- a/gpu/command_buffer/tests/gl_chromium_path_rendering_unittest.cc
+++ b/gpu/command_buffer/tests/gl_chromium_path_rendering_unittest.cc
@@ -5,6 +5,8 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <cmath>
 
 #include "base/command_line.h"
@@ -148,7 +150,7 @@ class CHROMIUMPathRenderingDrawTest : public CHROMIUMPathRenderingTest {
     SCOPED_TRACE(testing::Message() << "Verifying fill at " << x << "," << y);
     static const float kFillCoords[] = {55.0f, 54.0f, 50.0f,
                                         28.0f, 66.0f, 63.0f};
-    static const uint8 kBlue[] = {0, 0, 255, 255};
+    static const uint8_t kBlue[] = {0, 0, 255, 255};
 
     for (size_t i = 0; i < arraysize(kFillCoords); i += 2) {
       float fx = kFillCoords[i];
@@ -162,7 +164,7 @@ class CHROMIUMPathRenderingDrawTest : public CHROMIUMPathRenderingTest {
     SCOPED_TRACE(testing::Message() << "Verifying background at " << x << ","
                                     << y);
     const float kBackgroundCoords[] = {80.0f, 80.0f, 20.0f, 20.0f, 90.0f, 1.0f};
-    const uint8 kExpectedColor[] = {0, 0, 0, 0};
+    const uint8_t kExpectedColor[] = {0, 0, 0, 0};
 
     for (size_t i = 0; i < arraysize(kBackgroundCoords); i += 2) {
       float bx = kBackgroundCoords[i];
@@ -176,12 +178,12 @@ class CHROMIUMPathRenderingDrawTest : public CHROMIUMPathRenderingTest {
   void VerifyTestPatternStroke(float x, float y) {
     SCOPED_TRACE(testing::Message() << "Verifying stroke at " << x << "," << y);
     // Inside the stroke we should have green.
-    const uint8 kGreen[] = {0, 255, 0, 255};
+    const uint8_t kGreen[] = {0, 255, 0, 255};
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 50, y + 53, 1, 1, 0, kGreen));
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 26, y + 76, 1, 1, 0, kGreen));
 
     // Outside the path we should have black.
-    const uint8 black[] = {0, 0, 0, 0};
+    const uint8_t black[] = {0, 0, 0, 0};
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 10, y + 10, 1, 1, 0, black));
     EXPECT_TRUE(GLTestHelper::CheckPixels(x + 80, y + 80, 1, 1, 0, black));
   }
@@ -454,7 +456,7 @@ TEST_F(CHROMIUMPathRenderingTest, TestPathObjectState) {
 
   // Make sure nothing got drawn by the drawing commands that should not produce
   // anything.
-  const uint8 black[] = {0, 0, 0, 0};
+  const uint8_t black[] = {0, 0, 0, 0};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, kResolution, kResolution, 0, black));
 }
@@ -1079,7 +1081,7 @@ TEST_P(CHROMIUMPathRenderingWithTexturingTest,
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4];
+        uint8_t color[4];
         color[0] = roundf((px + fx) / kResolution * 255.0f);
         color[1] = roundf((py + fy) / kResolution * 255.0f);
         color[2] = 0;
@@ -1179,7 +1181,7 @@ TEST_P(CHROMIUMPathRenderingWithTexturingTest,
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4];
+        uint8_t color[4];
         color[0] = roundf(fx / kShapeWidth * 255.0f);
         color[1] = roundf(fy / kShapeHeight * 255.0f);
         color[2] = 0;
@@ -1582,7 +1584,7 @@ TEST_P(CHROMIUMPathRenderingWithTexturingTest,
           float px = i * kShapeWidth;
           float py = j * kShapeHeight;
 
-          uint8 color[4] = {0, 255, 0, 255};
+          uint8_t color[4] = {0, 255, 0, 255};
 
           EXPECT_TRUE(
               GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
@@ -1676,7 +1678,7 @@ TEST_P(CHROMIUMPathRenderingWithTexturingTest,
         float px = i * kShapeWidth;
         float py = j * kShapeHeight;
 
-        uint8 color[4] = {0, 255, 0, 255};
+        uint8_t color[4] = {0, 255, 0, 255};
 
         EXPECT_TRUE(
             GLTestHelper::CheckPixels(px + fx, py + fy, 1, 1, 2, color));
diff --git a/gpu/command_buffer/tests/gl_clear_framebuffer_unittest.cc b/gpu/command_buffer/tests/gl_clear_framebuffer_unittest.cc
index 3ce80f9..496b3ef 100644
--- a/gpu/command_buffer/tests/gl_clear_framebuffer_unittest.cc
+++ b/gpu/command_buffer/tests/gl_clear_framebuffer_unittest.cc
@@ -9,6 +9,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include <vector>
 
@@ -111,7 +112,7 @@ TEST_P(GLClearFramebufferTest, ClearColor) {
   glClear(GL_COLOR_BUFFER_BIT);
 
   // Verify.
-  const uint8 expected[] = {255, 128, 64, 128};
+  const uint8_t expected[] = {255, 128, 64, 128};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, 1, 1, 1 /* tolerance */, expected));
 }
@@ -122,7 +123,7 @@ TEST_P(GLClearFramebufferTest, ClearColorWithMask) {
   glClear(GL_COLOR_BUFFER_BIT);
 
   // Verify.
-  const uint8 expected[] = {255, 0, 0, 0};
+  const uint8_t expected[] = {255, 0, 0, 0};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, 1, 1, 0 /* tolerance */, expected));
 }
@@ -134,7 +135,7 @@ TEST_P(GLClearFramebufferTest, ClearColorWithScissor) {
   glClear(GL_COLOR_BUFFER_BIT);
 
   // Verify.
-  const uint8 expected[] = {255, 255, 255, 255};
+  const uint8_t expected[] = {255, 255, 255, 255};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, 1, 1, 0 /* tolerance */, expected));
 
@@ -155,8 +156,8 @@ TEST_P(GLClearFramebufferTest, ClearDepthStencil) {
   SetDrawColor(1.0f, 0.0f, 0.0f, 1.0f);
   DrawQuad();
   // Verify.
-  const uint8 kRed[] = {255, 0, 0, 255};
-  const uint8 kGreen[] = {0, 255, 0, 255};
+  const uint8_t kRed[] = {255, 0, 0, 255};
+  const uint8_t kGreen[] = {0, 255, 0, 255};
   EXPECT_TRUE(
       GLTestHelper::CheckPixels(0, 0, 1, 1, 0 /* tolerance */, kRed));
 
diff --git a/gpu/command_buffer/tests/gl_compressed_copy_texture_CHROMIUM_unittest.cc b/gpu/command_buffer/tests/gl_compressed_copy_texture_CHROMIUM_unittest.cc
index 1197d42..b444bb9 100644
--- a/gpu/command_buffer/tests/gl_compressed_copy_texture_CHROMIUM_unittest.cc
+++ b/gpu/command_buffer/tests/gl_compressed_copy_texture_CHROMIUM_unittest.cc
@@ -9,6 +9,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -27,54 +28,52 @@ const CopyType kCopyTypes[] = {
     TexSubImage,
 };
 
-const uint8 kCompressedImageColor[4] = { 255u, 0u, 0u, 255u };
+const uint8_t kCompressedImageColor[4] = {255u, 0u, 0u, 255u};
 
 // Single compressed ATC block of source pixels all set to:
 // kCompressedImageColor.
-const uint8 kCompressedImageATC[8] = {
-    0x0, 0x7c, 0x0, 0xf8, 0x55, 0x55, 0x55, 0x55 };
+const uint8_t kCompressedImageATC[8] = {0x0,  0x7c, 0x0,  0xf8,
+                                        0x55, 0x55, 0x55, 0x55};
 
 // Single compressed ATCIA block of source pixels all set to:
 // kCompressedImageColor.
-const uint8 kCompressedImageATCIA[16] = {
-    0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-    0x7c, 0x0, 0xf8, 0x55, 0x55, 0x55, 0x55 };
+const uint8_t kCompressedImageATCIA[16] = {0xff, 0xff, 0x0,  0x0,  0x0, 0x0,
+                                           0x0,  0x0,  0x0,  0x7c, 0x0, 0xf8,
+                                           0x55, 0x55, 0x55, 0x55};
 
 // Single compressed DXT1 block of source pixels all set to:
 // kCompressedImageColor.
-const uint8 kCompressedImageDXT1[8] = {
-    0x00, 0xf8, 0x00, 0xf8, 0xaa, 0xaa, 0xaa, 0xaa };
+const uint8_t kCompressedImageDXT1[8] = {0x00, 0xf8, 0x00, 0xf8,
+                                         0xaa, 0xaa, 0xaa, 0xaa};
 
 // Four compressed DXT1 blocks solidly colored in red, green, blue and black:
 // [R][G]
 // [B][b]
-const uint8 kCompressedImageDXT1RGB[32] = {
-    0x0, 0xf8, 0x0, 0xf8, 0xaa, 0xaa, 0xaa, 0xaa,
-    0xe0, 0x7, 0xe0, 0x7, 0xaa, 0xaa, 0xaa, 0xaa,
-    0x1f, 0x0, 0x1f, 0x0, 0xaa, 0xaa, 0xaa, 0xaa,
-    0x0, 0x0, 0x0, 0x0, 0xaa, 0xaa, 0xaa, 0xaa };
+const uint8_t kCompressedImageDXT1RGB[32] = {
+    0x0,  0xf8, 0x0,  0xf8, 0xaa, 0xaa, 0xaa, 0xaa, 0xe0, 0x7,  0xe0,
+    0x7,  0xaa, 0xaa, 0xaa, 0xaa, 0x1f, 0x0,  0x1f, 0x0,  0xaa, 0xaa,
+    0xaa, 0xaa, 0x0,  0x0,  0x0,  0x0,  0xaa, 0xaa, 0xaa, 0xaa};
 
 // Single compressed DXT5 block of source pixels all set to:
 // kCompressedImageColor.
-const uint8 kCompressedImageDXT5[16] = {
-    0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-    0xf8, 0x0, 0xf8, 0xaa, 0xaa, 0xaa, 0xaa };
+const uint8_t kCompressedImageDXT5[16] = {0xff, 0xff, 0x0,  0x0,  0x0, 0x0,
+                                          0x0,  0x0,  0x0,  0xf8, 0x0, 0xf8,
+                                          0xaa, 0xaa, 0xaa, 0xaa};
 
 // Single compressed DXT1 block of source pixels all set to:
 // kCompressedImageColor.
-const uint8 kCompressedImageETC1[8] = {
-    0x0, 0x0, 0xf8, 0x2, 0xff, 0xff, 0x0, 0x0 };
+const uint8_t kCompressedImageETC1[8] = {0x0,  0x0,  0xf8, 0x2,
+                                         0xff, 0xff, 0x0,  0x0};
 
 // Single block of zeroes, used for texture pre-allocation.
-const uint8 kInvalidCompressedImage[8] = {
-    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
+const uint8_t kInvalidCompressedImage[8] = {0x0, 0x0, 0x0, 0x0,
+                                            0x0, 0x0, 0x0, 0x0};
 
 // Four blocks of zeroes, used for texture pre-allocation.
-const uint8 kInvalidCompressedImageLarge[32] = {
-    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
+const uint8_t kInvalidCompressedImageLarge[32] = {
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
 
 void glEnableDisable(GLint param, GLboolean value) {
   if (value)
@@ -199,11 +198,11 @@ TEST_P(GLCompressedCopyTextureCHROMIUMTest, InternalFormat) {
 
   struct Image {
     const GLint format;
-    const uint8* data;
+    const uint8_t* data;
     const GLsizei data_size;
 
-    Image(const GLint format, const uint8* data, const GLsizei data_size) :
-      format(format), data(data), data_size(data_size) {}
+    Image(const GLint format, const uint8_t* data, const GLsizei data_size)
+        : format(format), data(data), data_size(data_size) {}
   };
   std::vector<scoped_ptr<Image>> supported_formats;
 
@@ -279,7 +278,7 @@ TEST_P(GLCompressedCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
 
   CopyType copy_type = GetParam();
 
-  const uint8 kUncompressedPixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  const uint8_t kUncompressedPixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -635,10 +634,10 @@ TEST_F(GLCompressedCopyTextureCHROMIUMTest, CopySubTextureOffset) {
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glUniform1i(texture_loc, 0);
 
-  const uint8 kBlack[1 * 4] = {0u, 0u, 0u, 255u};
-  const uint8 kRed[1 * 4] = {255u, 0u, 0u, 255u};
-  const uint8 kGreen[1 * 4] = {0u, 255u, 0u, 255u};
-  const uint8 kBlue[1 * 4] = {0u, 0u, 255u, 255u};
+  const uint8_t kBlack[1 * 4] = {0u, 0u, 0u, 255u};
+  const uint8_t kRed[1 * 4] = {255u, 0u, 0u, 255u};
+  const uint8_t kGreen[1 * 4] = {0u, 255u, 0u, 255u};
+  const uint8_t kBlue[1 * 4] = {0u, 0u, 255u, 255u};
 
   // Copy each block one by one in a clockwise fashion. Note that we reset the
   // destination texture after each copy operation. That's because on some
@@ -757,9 +756,9 @@ TEST_F(GLCompressedCopyTextureCHROMIUMTest, CopySubTexturePreservation) {
   glDrawArrays(GL_TRIANGLES, 0, 6);
   glFlush();
 
-  const uint8 kBlack[1 * 4] = {0u, 0u, 0u, 255u};
-  const uint8 kRed[1 * 4] = {255u, 0u, 0u, 255u};
-  const uint8 kBlue[1 * 4] = {0u, 0u, 255u, 255u};
+  const uint8_t kBlack[1 * 4] = {0u, 0u, 0u, 255u};
+  const uint8_t kRed[1 * 4] = {255u, 0u, 0u, 255u};
+  const uint8_t kBlue[1 * 4] = {0u, 0u, 255u, 255u};
 
   // Note that while destination texture is 8 x 8 pixels the viewport is only
   // 4 x 4.
diff --git a/gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc b/gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc
index 7fdd252..7cdfb0c 100644
--- a/gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc
+++ b/gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc
@@ -9,6 +9,8 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -67,7 +69,7 @@ INSTANTIATE_TEST_CASE_P(CopyType,
 // Test to ensure that the basic functionality of the extension works.
 TEST_P(GLCopyTextureCHROMIUMTest, Basic) {
   CopyType copy_type = GetParam();
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
@@ -107,7 +109,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
   }
   CopyType copy_type = GetParam();
 
-  uint8 pixels[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 1, 1);
@@ -210,8 +212,8 @@ TEST_P(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
-  uint8 pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
-                         255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
+  uint8_t pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
+                           255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(
@@ -280,7 +282,7 @@ void glEnableDisable(GLint param, GLboolean value) {
 // the extension.
 TEST_P(GLCopyTextureCHROMIUMTest, BasicStatePreservation) {
   CopyType copy_type = GetParam();
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
@@ -346,7 +348,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, BasicStatePreservation) {
 TEST_P(GLCopyTextureCHROMIUMTest, TextureStatePreserved) {
   CopyType copy_type = GetParam();
   // Setup the texture used for the extension invocation.
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
@@ -400,7 +402,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, TextureStatePreserved) {
 TEST_P(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
   CopyType copy_type = GetParam();
   // Setup the texture used for the extension invocation.
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
@@ -433,7 +435,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
       GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   // Test that we can write to the bound framebuffer
-  uint8 expected_color[4] = { 255u, 255u, 0, 255u };
+  uint8_t expected_color[4] = {255u, 255u, 0, 255u};
   glClearColor(1.0, 1.0, 0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
@@ -452,7 +454,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
   // Ensure that reading from the framebuffer produces correct pixels.
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
 
-  uint8 expected_color2[4] = { 255u, 0, 255u, 255u };
+  uint8_t expected_color2[4] = {255u, 0, 255u, 255u};
   glClearColor(1.0, 0, 1.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color2);
@@ -535,15 +537,19 @@ TEST_P(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) {
   GLTestHelper::SetupUnitQuad(position_loc);
 
   // test using program before
-  uint8 expected[] = { 0, 255, 0, 255, };
-  uint8 zero[] = { 0, 0, 0, 0, };
+  uint8_t expected[] = {
+      0, 255, 0, 255,
+  };
+  uint8_t zero[] = {
+      0, 0, 0, 0,
+  };
   glClear(GL_COLOR_BUFFER_BIT);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
 
   // Call copyTextureCHROMIUM
-  uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
@@ -591,7 +597,7 @@ TEST_P(GLCopyTextureCHROMIUMTest, UninitializedSource) {
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
-  uint8 pixels[kHeight][kWidth][4] = {{{1}}};
+  uint8_t pixels[kHeight][kWidth][4] = {{{1}}};
   glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   for (int x = 0; x < kWidth; ++x) {
     for (int y = 0; y < kHeight; ++y) {
@@ -692,28 +698,14 @@ TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureInvalidTextureIds) {
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
-  uint8 rgba_pixels[4 * 4] = {255u,
-                              0u,
-                              0u,
-                              255u,
-                              0u,
-                              255u,
-                              0u,
-                              255u,
-                              0u,
-                              0u,
-                              255u,
-                              255u,
-                              0u,
-                              0u,
-                              0u,
-                              255u};
+  uint8_t rgba_pixels[4 * 4] = {255u, 0u, 0u,   255u, 0u, 255u, 0u, 255u,
+                                0u,   0u, 255u, 255u, 0u, 0u,   0u, 255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                rgba_pixels);
 
-  uint8 transparent_pixels[4 * 4] = {
-      0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
+  uint8_t transparent_pixels[4 * 4] = {0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                                       0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                transparent_pixels);
@@ -738,10 +730,10 @@ TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
-  uint8 transparent[1 * 4] = {0u, 0u, 0u, 0u};
-  uint8 red[1 * 4] = {255u, 0u, 0u, 255u};
-  uint8 green[1 * 4] = {0u, 255u, 0u, 255u};
-  uint8 blue[1 * 4] = {0u, 0u, 255u, 255u};
+  uint8_t transparent[1 * 4] = {0u, 0u, 0u, 0u};
+  uint8_t red[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8_t green[1 * 4] = {0u, 255u, 0u, 255u};
+  uint8_t blue[1 * 4] = {0u, 0u, 255u, 255u};
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent);
   GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red);
   GLTestHelper::CheckPixels(1, 0, 1, 1, 0, green);
diff --git a/gpu/command_buffer/tests/gl_cube_map_texture_unittest.cc b/gpu/command_buffer/tests/gl_cube_map_texture_unittest.cc
index e465cb3..067f0af 100644
--- a/gpu/command_buffer/tests/gl_cube_map_texture_unittest.cc
+++ b/gpu/command_buffer/tests/gl_cube_map_texture_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <GLES2/gl2.h>
+#include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ -59,7 +60,7 @@ class GLCubeMapTextureTest : public testing::TestWithParam<GLenum> {
   }
 
   GLManager gl_;
-  uint8 pixels_[256 * 4];
+  uint8_t pixels_[256 * 4];
   const int width_ = 16;
   GLuint texture_;
   GLuint framebuffer_id_;
@@ -138,7 +139,7 @@ TEST_P(GLCubeMapTextureTest, ReadPixelsFromIncompleteCubeTexture) {
   // by (POSITIVE_X, NEGATIVE_Z) order only once. If users call texImage2D again
   // after defining all faces, glReadPixels fails.
   GLsizei size = width_ * width_ * 4;
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
   glReadPixels(0, 0, width_, width_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
 #else
   // Without force_cube_complete workaround,
diff --git a/gpu/command_buffer/tests/gl_depth_texture_unittest.cc b/gpu/command_buffer/tests/gl_depth_texture_unittest.cc
index 5bbbb06..6a76065 100644
--- a/gpu/command_buffer/tests/gl_depth_texture_unittest.cc
+++ b/gpu/command_buffer/tests/gl_depth_texture_unittest.cc
@@ -4,6 +4,8 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -181,7 +183,9 @@ TEST_F(DepthTextureTest, RenderTo) {
       continue;
     }
 
-    uint8 actual_pixels[kResolution * kResolution * 4] = { 0, };
+    uint8_t actual_pixels[kResolution * kResolution * 4] = {
+        0,
+    };
     glReadPixels(
         0, 0, kResolution, kResolution, GL_RGBA, GL_UNSIGNED_BYTE,
         actual_pixels);
@@ -198,9 +202,9 @@ TEST_F(DepthTextureTest, RenderTo) {
     int bad_count = 0;  // used to not spam the log with too many messages.
     for (GLint yy = 0; bad_count < 16 && yy < kResolution; ++yy) {
       for (GLint xx = 0; bad_count < 16 && xx < kResolution; ++xx) {
-        const uint8* actual = &actual_pixels[(yy * kResolution + xx) * 4];
-        const uint8* left = actual - 4;
-        const uint8* down = actual - kResolution * 4;
+        const uint8_t* actual = &actual_pixels[(yy * kResolution + xx) * 4];
+        const uint8_t* left = actual - 4;
+        const uint8_t* down = actual - kResolution * 4;
 
         // NOTE: Qualcomm on Nexus 4 the right most column has the same
         // values as the next to right most column. (bad interpolator?)
diff --git a/gpu/command_buffer/tests/gl_ext_blend_func_extended_unittest.cc b/gpu/command_buffer/tests/gl_ext_blend_func_extended_unittest.cc
index d2f01ab..35d74b1 100644
--- a/gpu/command_buffer/tests/gl_ext_blend_func_extended_unittest.cc
+++ b/gpu/command_buffer/tests/gl_ext_blend_func_extended_unittest.cc
@@ -6,6 +6,7 @@
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ -44,7 +45,7 @@ template <int RGBs, int RGBd, int As, int Ad>
 void BlendEquationFuncAdd(float dst[4],
                           float src[4],
                           float src1[4],
-                          uint8 result[4]) {
+                          uint8_t result[4]) {
   float r[4];
   r[0] = src[0] * Weight<RGBs, 0>(dst, src, src1) +
          dst[0] * Weight<RGBd, 0>(dst, src, src1);
@@ -55,7 +56,7 @@ void BlendEquationFuncAdd(float dst[4],
   r[3] = src[3] * Weight<As, 3>(dst, src, src1) +
          dst[3] * Weight<Ad, 3>(dst, src, src1);
   for (int i = 0; i < 4; ++i) {
-    result[i] = static_cast<uint8>(
+    result[i] = static_cast<uint8_t>(
         std::floor(std::max(0.0f, std::min(1.0f, r[i])) * 255.0f));
   }
 }
@@ -180,7 +181,7 @@ class EXTBlendFuncExtendedDrawTest : public testing::TestWithParam<bool> {
     glDrawArrays(GL_TRIANGLES, 0, 6);
     EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
     // Verify.
-    uint8 color[4];
+    uint8_t color[4];
     BlendEquationFuncAdd<GL_SRC1_COLOR_EXT, GL_SRC_ALPHA,
                          GL_ONE_MINUS_SRC1_COLOR_EXT,
                          GL_ONE_MINUS_SRC1_ALPHA_EXT>(kDst, kSrc, kSrc1, color);
diff --git a/gpu/command_buffer/tests/gl_ext_multisample_compatibility_unittest.cc b/gpu/command_buffer/tests/gl_ext_multisample_compatibility_unittest.cc
index 37fc923..d3d51a6 100644
--- a/gpu/command_buffer/tests/gl_ext_multisample_compatibility_unittest.cc
+++ b/gpu/command_buffer/tests/gl_ext_multisample_compatibility_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -153,7 +154,7 @@ TEST_F(EXTMultisampleCompatibilityTest, DrawAndResolve) {
   // values. These might be due to different MSAA sample counts causing
   // different samples to hit.  Other option is driver bugs. Just test that
   // disabling multisample causes a difference.
-  scoped_ptr<uint8[]> results[3];
+  scoped_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
   for (int pass = 0; pass < 3; pass++) {
     PrepareForDraw();
@@ -175,7 +176,7 @@ TEST_F(EXTMultisampleCompatibilityTest, DrawAndResolve) {
       glEnable(GL_MULTISAMPLE_EXT);
     }
     PrepareForVerify();
-    results[pass].reset(new uint8[kResultSize]);
+    results[pass].reset(new uint8_t[kResultSize]);
     memset(results[pass].get(), GLTestHelper::kCheckClearValue, kResultSize);
     glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                  results[pass].get());
@@ -205,7 +206,7 @@ TEST_F(EXTMultisampleCompatibilityTest, DrawAlphaOneAndResolve) {
   // even approximate sample values is not that easy.  Thus, just test
   // representative positions which have fractional pixels, inspecting that
   // normal rendering is different to SAMPLE_ALPHA_TO_ONE rendering.
-  scoped_ptr<uint8[]> results[3];
+  scoped_ptr<uint8_t[]> results[3];
   const GLint kResultSize = kWidth * kHeight * 4;
 
   for (int pass = 0; pass < 3; ++pass) {
@@ -225,7 +226,7 @@ TEST_F(EXTMultisampleCompatibilityTest, DrawAlphaOneAndResolve) {
     glDrawArrays(GL_TRIANGLES, 6, 3);
 
     PrepareForVerify();
-    results[pass].reset(new uint8[kResultSize]);
+    results[pass].reset(new uint8_t[kResultSize]);
     memset(results[pass].get(), GLTestHelper::kCheckClearValue, kResultSize);
     glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                  results[pass].get());
diff --git a/gpu/command_buffer/tests/gl_ext_srgb_unittest.cc b/gpu/command_buffer/tests/gl_ext_srgb_unittest.cc
index 53b3c24..139f8e6 100644
--- a/gpu/command_buffer/tests/gl_ext_srgb_unittest.cc
+++ b/gpu/command_buffer/tests/gl_ext_srgb_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -34,10 +35,10 @@ TEST_F(GLEXTSRGBTest, TexImageSRGBALPHAFormat) {
   static const int kSubImageY = kHeight / 2;
   static const int kSubImageWidth = kWidth / 2;
   static const int kSubImageHeight = kHeight / 2;
-  static const uint8 kImageColor[] = {255, 255, 255, 255};
-  static const uint8 kSubImageColor[] = {128, 128, 128, 128};
+  static const uint8_t kImageColor[] = {255, 255, 255, 255};
+  static const uint8_t kSubImageColor[] = {128, 128, 128, 128};
 
-  uint8 pixels[kWidth * kHeight * 4];
+  uint8_t pixels[kWidth * kHeight * 4];
 
   GLuint tex = 0;
   glGenTextures(1, &tex);
diff --git a/gpu/command_buffer/tests/gl_gpu_memory_buffer_unittest.cc b/gpu/command_buffer/tests/gl_gpu_memory_buffer_unittest.cc
index 18b1e8d..5f1e1e0 100644
--- a/gpu/command_buffer/tests/gl_gpu_memory_buffer_unittest.cc
+++ b/gpu/command_buffer/tests/gl_gpu_memory_buffer_unittest.cc
@@ -6,6 +6,7 @@
 #include <GLES2/gl2chromium.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
diff --git a/gpu/command_buffer/tests/gl_lose_context_chromium_unittest.cc b/gpu/command_buffer/tests/gl_lose_context_chromium_unittest.cc
index 94381ac..9202437 100644
--- a/gpu/command_buffer/tests/gl_lose_context_chromium_unittest.cc
+++ b/gpu/command_buffer/tests/gl_lose_context_chromium_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "base/logging.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ -49,11 +50,9 @@ TEST_F(GLLoseContextTest, ShareGroup) {
   glLoseContextCHROMIUM(
       GL_GUILTY_CONTEXT_RESET_EXT, GL_INNOCENT_CONTEXT_RESET_EXT);
 
-  uint8 expected_no_draw[] = {
-    GLTestHelper::kCheckClearValue,
-    GLTestHelper::kCheckClearValue,
-    GLTestHelper::kCheckClearValue,
-    GLTestHelper::kCheckClearValue,
+  uint8_t expected_no_draw[] = {
+      GLTestHelper::kCheckClearValue, GLTestHelper::kCheckClearValue,
+      GLTestHelper::kCheckClearValue, GLTestHelper::kCheckClearValue,
   };
   // Expect the read will fail.
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_no_draw));
@@ -61,7 +60,9 @@ TEST_F(GLLoseContextTest, ShareGroup) {
   // Expect the read will fail.
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_no_draw));
   gl2_.MakeCurrent();
-  uint8 expected_draw[] = { 0, 0, 0, 0, };
+  uint8_t expected_draw[] = {
+      0, 0, 0, 0,
+  };
   // Expect the read will succeed.
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_draw));
 }
diff --git a/gpu/command_buffer/tests/gl_manager.cc b/gpu/command_buffer/tests/gl_manager.cc
index d72994b..9ad141e 100644
--- a/gpu/command_buffer/tests/gl_manager.cc
+++ b/gpu/command_buffer/tests/gl_manager.cc
@@ -7,6 +7,8 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <vector>
 
@@ -64,8 +66,8 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   void* memory(size_t plane) override {
     DCHECK(mapped_);
     DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
-    return reinterpret_cast<uint8*>(&bytes_->data().front()) +
-         gfx::BufferOffsetForBufferFormat(size_, format_, plane);
+    return reinterpret_cast<uint8_t*>(&bytes_->data().front()) +
+           gfx::BufferOffsetForBufferFormat(size_, format_, plane);
   }
   void Unmap() override {
     DCHECK(mapped_);
@@ -147,7 +149,7 @@ GLManager::~GLManager() {
 scoped_ptr<gfx::GpuMemoryBuffer> GLManager::CreateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format) {
-  std::vector<uint8> data(gfx::BufferSizeForBufferFormat(size, format), 0);
+  std::vector<uint8_t> data(gfx::BufferSizeForBufferFormat(size, format), 0);
   scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
       new GpuMemoryBufferImpl(bytes.get(), size, format));
@@ -159,7 +161,7 @@ void GLManager::Initialize(const GLManager::Options& options) {
 
 void GLManager::InitializeWithCommandLine(const GLManager::Options& options,
                                           base::CommandLine* command_line) {
-  const int32 kCommandBufferSize = 1024 * 1024;
+  const int32_t kCommandBufferSize = 1024 * 1024;
   const size_t kStartTransferBufferSize = 4 * 1024 * 1024;
   const size_t kMinTransferBufferSize = 1 * 256 * 1024;
   const size_t kMaxTransferBufferSize = 16 * 1024 * 1024;
@@ -199,7 +201,7 @@ void GLManager::InitializeWithCommandLine(const GLManager::Options& options,
       share_group ? share_group : new gfx::GLShareGroup;
 
   gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
-  std::vector<int32> attribs;
+  std::vector<int32_t> attribs;
   gles2::ContextCreationAttribHelper attrib_helper;
   attrib_helper.red_size = 8;
   attrib_helper.green_size = 8;
@@ -417,7 +419,7 @@ void GLManager::PumpCommands() {
   }
 }
 
-bool GLManager::GetBufferChanged(int32 transfer_buffer_id) {
+bool GLManager::GetBufferChanged(int32_t transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
@@ -425,10 +427,10 @@ Capabilities GLManager::GetCapabilities() {
   return decoder_->GetCapabilities();
 }
 
-int32 GLManager::CreateImage(ClientBuffer buffer,
-                             size_t width,
-                             size_t height,
-                             unsigned internalformat) {
+int32_t GLManager::CreateImage(ClientBuffer buffer,
+                               size_t width,
+                               size_t height,
+                               unsigned internalformat) {
   GpuMemoryBufferImpl* gpu_memory_buffer =
       GpuMemoryBufferImpl::FromClientBuffer(buffer);
 
@@ -440,8 +442,8 @@ int32 GLManager::CreateImage(ClientBuffer buffer,
     return -1;
   }
 
-  static int32 next_id = 1;
-  int32 new_id = next_id++;
+  static int32_t next_id = 1;
+  int32_t new_id = next_id++;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
@@ -449,42 +451,42 @@ int32 GLManager::CreateImage(ClientBuffer buffer,
   return new_id;
 }
 
-int32 GLManager::CreateGpuMemoryBufferImage(size_t width,
-                                            size_t height,
-                                            unsigned internalformat,
-                                            unsigned usage) {
+int32_t GLManager::CreateGpuMemoryBufferImage(size_t width,
+                                              size_t height,
+                                              unsigned internalformat,
+                                              unsigned usage) {
   DCHECK_EQ(usage, static_cast<unsigned>(GL_READ_WRITE_CHROMIUM));
   scoped_ptr<gfx::GpuMemoryBuffer> buffer = GLManager::CreateGpuMemoryBuffer(
       gfx::Size(width, height), gfx::BufferFormat::RGBA_8888);
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
-void GLManager::DestroyImage(int32 id) {
+void GLManager::DestroyImage(int32_t id) {
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   image_manager->RemoveImage(id);
 }
 
-uint32 GLManager::InsertSyncPoint() {
+uint32_t GLManager::InsertSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-uint32 GLManager::InsertFutureSyncPoint() {
+uint32_t GLManager::InsertFutureSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-void GLManager::RetireSyncPoint(uint32 sync_point) {
+void GLManager::RetireSyncPoint(uint32_t sync_point) {
   NOTIMPLEMENTED();
 }
 
-void GLManager::SignalSyncPoint(uint32 sync_point,
+void GLManager::SignalSyncPoint(uint32_t sync_point,
                                 const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
-void GLManager::SignalQuery(uint32 query, const base::Closure& callback) {
+void GLManager::SignalQuery(uint32_t query, const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
diff --git a/gpu/command_buffer/tests/gl_manager.h b/gpu/command_buffer/tests/gl_manager.h
index 3ae38ea..10a0674 100644
--- a/gpu/command_buffer/tests/gl_manager.h
+++ b/gpu/command_buffer/tests/gl_manager.h
@@ -5,6 +5,9 @@
 #ifndef GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
 #define GPU_COMMAND_BUFFER_TESTS_GL_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -113,21 +116,21 @@ class GLManager : private GpuControl {
 
   // GpuControl implementation.
   Capabilities GetCapabilities() override;
-  int32 CreateImage(ClientBuffer buffer,
-                    size_t width,
-                    size_t height,
-                    unsigned internalformat) override;
-  void DestroyImage(int32 id) override;
-  int32 CreateGpuMemoryBufferImage(size_t width,
-                                   size_t height,
-                                   unsigned internalformat,
-                                   unsigned usage) override;
-  uint32 InsertSyncPoint() override;
-  uint32 InsertFutureSyncPoint() override;
-  void RetireSyncPoint(uint32 sync_point) override;
-  void SignalSyncPoint(uint32 sync_point,
+  int32_t CreateImage(ClientBuffer buffer,
+                      size_t width,
+                      size_t height,
+                      unsigned internalformat) override;
+  void DestroyImage(int32_t id) override;
+  int32_t CreateGpuMemoryBufferImage(size_t width,
+                                     size_t height,
+                                     unsigned internalformat,
+                                     unsigned usage) override;
+  uint32_t InsertSyncPoint() override;
+  uint32_t InsertFutureSyncPoint() override;
+  void RetireSyncPoint(uint32_t sync_point) override;
+  void SignalSyncPoint(uint32_t sync_point,
                        const base::Closure& callback) override;
-  void SignalQuery(uint32 query, const base::Closure& callback) override;
+  void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetLock(base::Lock*) override;
   bool IsGpuChannelLost() override;
   gpu::CommandBufferNamespace GetNamespaceID() const override;
@@ -143,7 +146,7 @@ class GLManager : private GpuControl {
 
  private:
   void PumpCommands();
-  bool GetBufferChanged(int32 transfer_buffer_id);
+  bool GetBufferChanged(int32_t transfer_buffer_id);
   void SetupBaseContext();
   void OnFenceSyncRelease(uint64_t release);
   bool OnWaitFenceSync(gpu::CommandBufferNamespace namespace_id,
diff --git a/gpu/command_buffer/tests/gl_pointcoord_unittest.cc b/gpu/command_buffer/tests/gl_pointcoord_unittest.cc
index d9501b0..1828aff 100644
--- a/gpu/command_buffer/tests/gl_pointcoord_unittest.cc
+++ b/gpu/command_buffer/tests/gl_pointcoord_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -133,11 +134,9 @@ TEST_F(PointCoordTest, MAYBE_RenderTo) {
           GLint yf = s2p(point_y + v * point_width);
           GLfloat s = 0.5 + (xf + 0.5 - xw) / max_point_size;
           GLfloat t = 0.5 + (yf + 0.5 - yw) / max_point_size;
-          uint8 color[4] = {
-            static_cast<uint8>(s * 255),
-            static_cast<uint8>((1 - t) * 255),
-            0,
-            255,
+          uint8_t color[4] = {
+              static_cast<uint8_t>(s * 255),
+              static_cast<uint8_t>((1 - t) * 255), 0, 255,
           };
           GLTestHelper::CheckPixels(xf, yf, 1, 1, 4, color);
         }
diff --git a/gpu/command_buffer/tests/gl_program_unittest.cc b/gpu/command_buffer/tests/gl_program_unittest.cc
index fa3897e..55e1d9e 100644
--- a/gpu/command_buffer/tests/gl_program_unittest.cc
+++ b/gpu/command_buffer/tests/gl_program_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
@@ -127,7 +128,9 @@ TEST_F(GLProgramTest, NewShaderInCurrentProgram) {
   GLuint position_loc = glGetAttribLocation(program, "a_position");
   GLTestHelper::SetupUnitQuad(position_loc);
   glDrawArrays(GL_TRIANGLES, 0, 6);
-  uint8 expected_color[] = { 0, 0, 255, 255, };
+  uint8_t expected_color[] = {
+      0, 0, 255, 255,
+  };
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color));
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
@@ -193,7 +196,9 @@ TEST_F(GLProgramTest, UniformsInCurrentProgram) {
   GLuint position_loc = glGetAttribLocation(program, "a_position");
   GLTestHelper::SetupUnitQuad(position_loc);
   glDrawArrays(GL_TRIANGLES, 0, 6);
-  uint8 expected_color[] = { 0, 0, 255, 255, };
+  uint8_t expected_color[] = {
+      0, 0, 255, 255,
+  };
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color));
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
diff --git a/gpu/command_buffer/tests/gl_query_unittest.cc b/gpu/command_buffer/tests/gl_query_unittest.cc
index b12adc3..09d08e9 100644
--- a/gpu/command_buffer/tests/gl_query_unittest.cc
+++ b/gpu/command_buffer/tests/gl_query_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "base/threading/platform_thread.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
@@ -72,7 +73,7 @@ TEST_F(QueryTest, MultipleQueries) {
                          &available);
   EXPECT_TRUE(available);
   glGetQueryObjectuivEXT(error_query, GL_QUERY_RESULT_EXT, &result);
-  EXPECT_EQ(static_cast<uint32>(GL_INVALID_ENUM), result);
+  EXPECT_EQ(static_cast<uint32_t>(GL_INVALID_ENUM), result);
 }
 
 TEST_F(QueryTest, GetErrorBasic) {
@@ -95,7 +96,7 @@ TEST_F(QueryTest, GetErrorBasic) {
   glGetQueryObjectuivEXT(query, GL_QUERY_RESULT_AVAILABLE_EXT, &result);
   EXPECT_TRUE(result);
   glGetQueryObjectuivEXT(query, GL_QUERY_RESULT_EXT, &query_status);
-  EXPECT_EQ(static_cast<uint32>(GL_INVALID_ENUM), query_status);
+  EXPECT_EQ(static_cast<uint32_t>(GL_INVALID_ENUM), query_status);
 }
 
 TEST_F(QueryTest, DISABLED_LatencyQueryBasic) {
diff --git a/gpu/command_buffer/tests/gl_readback_unittest.cc b/gpu/command_buffer/tests/gl_readback_unittest.cc
index b4a88ee..d629564 100644
--- a/gpu/command_buffer/tests/gl_readback_unittest.cc
+++ b/gpu/command_buffer/tests/gl_readback_unittest.cc
@@ -5,10 +5,11 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <cmath>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/run_loop.h"
@@ -86,14 +87,14 @@ TEST_F(GLReadbackTest, ReadPixelsWithPBOAndQuery) {
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
 
-static float HalfToFloat32(uint16 value) {
-  int32 s = (value >> 15) & 0x00000001;
-  int32 e = (value >> 10) & 0x0000001f;
-  int32 m =  value        & 0x000003ff;
+static float HalfToFloat32(uint16_t value) {
+  int32_t s = (value >> 15) & 0x00000001;
+  int32_t e = (value >> 10) & 0x0000001f;
+  int32_t m = value & 0x000003ff;
 
   if (e == 0) {
     if (m == 0) {
-      uint32 result = s << 31;
+      uint32_t result = s << 31;
       return bit_cast<float>(result);
     } else {
       while (!(m & 0x00000400)) {
@@ -106,10 +107,10 @@ static float HalfToFloat32(uint16 value) {
     }
   } else if (e == 31) {
     if (m == 0) {
-      uint32 result = (s << 31) | 0x7f800000;
+      uint32_t result = (s << 31) | 0x7f800000;
       return bit_cast<float>(result);
     } else {
-      uint32 result = (s << 31) | 0x7f800000 | (m << 13);
+      uint32_t result = (s << 31) | 0x7f800000 | (m << 13);
       return bit_cast<float>(result);
     }
   }
@@ -117,7 +118,7 @@ static float HalfToFloat32(uint16 value) {
   e = e + (127 - 15);
   m = m << 13;
 
-  uint32 result = (s << 31) | (e << 23) | m;
+  uint32_t result = (s << 31) | (e << 23) | m;
   return bit_cast<float>(result);
 }
 
@@ -146,7 +147,7 @@ TEST_F(GLReadbackTest, ReadPixelsFloat) {
   struct TestFormat {
     GLint format;
     GLint type;
-    uint32 comp_count;
+    uint32_t comp_count;
   };
   TestFormat test_formats[4];
   size_t test_count = 0;
@@ -260,7 +261,7 @@ TEST_F(GLReadbackTest, ReadPixelsFloat) {
         glClear(GL_COLOR_BUFFER_BIT);
         glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-        uint32 read_comp_count = 0;
+        uint32_t read_comp_count = 0;
         switch (read_format) {
           case GL_RGB:
             read_comp_count = 3;
@@ -278,8 +279,8 @@ TEST_F(GLReadbackTest, ReadPixelsFloat) {
                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
                 buf.get());
             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
-            for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
-              for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
+            for (uint32_t jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
+              for (uint32_t kk = 0; kk < test_formats[ii].comp_count; ++kk) {
                 EXPECT_LE(
                     std::abs(HalfToFloat32(buf[jj * read_comp_count + kk]) -
                         kDrawColor[kk]),
@@ -295,8 +296,8 @@ TEST_F(GLReadbackTest, ReadPixelsFloat) {
                 0, 0, kTextureSize, kTextureSize, read_format, read_type,
                 buf.get());
             EXPECT_EQ(glGetError(), GLenum(GL_NO_ERROR));
-            for (uint32 jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
-              for (uint32 kk = 0; kk < test_formats[ii].comp_count; ++kk) {
+            for (uint32_t jj = 0; jj < kTextureSize * kTextureSize; ++jj) {
+              for (uint32_t kk = 0; kk < test_formats[ii].comp_count; ++kk) {
                 EXPECT_LE(
                     std::abs(buf[jj * read_comp_count + kk] - kDrawColor[kk]),
                     std::abs(kDrawColor[kk] * kEpsilon));
diff --git a/gpu/command_buffer/tests/gl_stream_draw_unittest.cc b/gpu/command_buffer/tests/gl_stream_draw_unittest.cc
index 90968c8..9722f02 100644
--- a/gpu/command_buffer/tests/gl_stream_draw_unittest.cc
+++ b/gpu/command_buffer/tests/gl_stream_draw_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -63,8 +64,12 @@ GLuint SetupProgram() {
 TEST_F(GLStreamDrawTest, Basic) {
   static GLfloat float_red[4] = { 1.0f, 0.0f, 0.0f, 1.0f, };
   static GLfloat float_green[4] = { 0.0f, 1.0f, 0.0f, 1.0f, };
-  static uint8 expected_red[4] =  {255, 0, 0, 255, };
-  static uint8 expected_green[4] =  {0, 255, 0, 255, };
+  static uint8_t expected_red[4] = {
+      255, 0, 0, 255,
+  };
+  static uint8_t expected_green[4] = {
+      0, 255, 0, 255,
+  };
 
   GLuint program = SetupProgram();
   GLuint position_loc = glGetAttribLocation(program, "a_position");
@@ -85,8 +90,12 @@ TEST_F(GLStreamDrawTest, Basic) {
 TEST_F(GLStreamDrawTest, DrawElements) {
   static GLfloat float_red[4] = { 1.0f, 0.0f, 0.0f, 1.0f, };
   static GLfloat float_green[4] = { 0.0f, 1.0f, 0.0f, 1.0f, };
-  static uint8 expected_red[4] =  {255, 0, 0, 255, };
-  static uint8 expected_green[4] =  {0, 255, 0, 255, };
+  static uint8_t expected_red[4] = {
+      255, 0, 0, 255,
+  };
+  static uint8_t expected_green[4] = {
+      0, 255, 0, 255,
+  };
 
   GLuint program = SetupProgram();
   GLuint position_loc = glGetAttribLocation(program, "a_position");
@@ -120,8 +129,12 @@ TEST_F(GLStreamDrawTest, VertexArrayObjects) {
 
   static GLfloat float_red[4] = { 1.0f, 0.0f, 0.0f, 1.0f, };
   static GLfloat float_green[4] = { 0.0f, 1.0f, 0.0f, 1.0f, };
-  static uint8 expected_red[4] =  {255, 0, 0, 255, };
-  static uint8 expected_green[4] =  {0, 255, 0, 255, };
+  static uint8_t expected_red[4] = {
+      255, 0, 0, 255,
+  };
+  static uint8_t expected_green[4] = {
+      0, 255, 0, 255,
+  };
 
   GLuint program = SetupProgram();
   GLuint position_loc = glGetAttribLocation(program, "a_position");
diff --git a/gpu/command_buffer/tests/gl_test_utils.cc b/gpu/command_buffer/tests/gl_test_utils.cc
index 7582a5d..4878b14 100644
--- a/gpu/command_buffer/tests/gl_test_utils.cc
+++ b/gpu/command_buffer/tests/gl_test_utils.cc
@@ -3,15 +3,18 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/tests/gl_test_utils.h"
-#include <string>
+
+#include <stdint.h>
 #include <stdio.h>
-#include "base/basictypes.h"
+
+#include <string>
+
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // GCC requires these declarations, but MSVC requires they not be present.
 #ifndef COMPILER_MSVC
-const uint8 GLTestHelper::kCheckClearValue;
+const uint8_t GLTestHelper::kCheckClearValue;
 #endif
 
 bool GLTestHelper::HasExtension(const char* extension) {
@@ -139,11 +142,14 @@ GLuint GLTestHelper::SetupColorsForUnitQuad(
   return vbo;
 }
 
-bool GLTestHelper::CheckPixels(
-    GLint x, GLint y, GLsizei width, GLsizei height, GLint tolerance,
-    const uint8* color) {
+bool GLTestHelper::CheckPixels(GLint x,
+                               GLint y,
+                               GLsizei width,
+                               GLsizei height,
+                               GLint tolerance,
+                               const uint8_t* color) {
   GLsizei size = width * height * 4;
-  scoped_ptr<uint8[]> pixels(new uint8[size]);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[size]);
   memset(pixels.get(), kCheckClearValue, size);
   glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
   int bad_count = 0;
@@ -151,8 +157,8 @@ bool GLTestHelper::CheckPixels(
     for (GLint xx = 0; xx < width; ++xx) {
       int offset = yy * width * 4 + xx * 4;
       for (int jj = 0; jj < 4; ++jj) {
-        uint8 actual = pixels[offset + jj];
-        uint8 expected = color[jj];
+        uint8_t actual = pixels[offset + jj];
+        uint8_t expected = color[jj];
         int diff = actual - expected;
         diff = diff < 0 ? -diff: diff;
         if (diff > tolerance) {
@@ -173,12 +179,12 @@ bool GLTestHelper::CheckPixels(
 
 namespace {
 
-void Set16BitValue(uint8 dest[2], uint16 value) {
+void Set16BitValue(uint8_t dest[2], uint16_t value) {
   dest[0] = value & 0xFFu;
   dest[1] = value >> 8;
 }
 
-void Set32BitValue(uint8 dest[4], uint32 value) {
+void Set32BitValue(uint8_t dest[4], uint32_t value) {
   dest[0] = (value >> 0) & 0xFFu;
   dest[1] = (value >> 8) & 0xFFu;
   dest[2] = (value >> 16) & 0xFFu;
@@ -186,24 +192,24 @@ void Set32BitValue(uint8 dest[4], uint32 value) {
 }
 
 struct BitmapHeaderFile {
-  uint8 magic[2];
-  uint8 size[4];
-  uint8 reserved[4];
-  uint8 offset[4];
+  uint8_t magic[2];
+  uint8_t size[4];
+  uint8_t reserved[4];
+  uint8_t offset[4];
 };
 
 struct BitmapInfoHeader{
-  uint8 size[4];
-  uint8 width[4];
-  uint8 height[4];
-  uint8 planes[2];
-  uint8 bit_count[2];
-  uint8 compression[4];
-  uint8 size_image[4];
-  uint8 x_pels_per_meter[4];
-  uint8 y_pels_per_meter[4];
-  uint8 clr_used[4];
-  uint8 clr_important[4];
+  uint8_t size[4];
+  uint8_t width[4];
+  uint8_t height[4];
+  uint8_t planes[2];
+  uint8_t bit_count[2];
+  uint8_t compression[4];
+  uint8_t size_image[4];
+  uint8_t x_pels_per_meter[4];
+  uint8_t y_pels_per_meter[4];
+  uint8_t clr_used[4];
+  uint8_t clr_important[4];
 };
 
 }
@@ -215,14 +221,14 @@ bool GLTestHelper::SaveBackbufferAsBMP(
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   int num_pixels = width * height;
   int size = num_pixels * 4;
-  scoped_ptr<uint8[]> data(new uint8[size]);
-  uint8* pixels = data.get();
+  scoped_ptr<uint8_t[]> data(new uint8_t[size]);
+  uint8_t* pixels = data.get();
   glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
   // RGBA to BGRA
   for (int ii = 0; ii < num_pixels; ++ii) {
     int offset = ii * 4;
-    uint8 t = pixels[offset + 0];
+    uint8_t t = pixels[offset + 0];
     pixels[offset + 0] = pixels[offset + 2];
     pixels[offset + 2] = t;
   }
diff --git a/gpu/command_buffer/tests/gl_test_utils.h b/gpu/command_buffer/tests/gl_test_utils.h
index 802d54d..537442f 100644
--- a/gpu/command_buffer/tests/gl_test_utils.h
+++ b/gpu/command_buffer/tests/gl_test_utils.h
@@ -8,11 +8,11 @@
 #define GPU_COMMAND_BUFFER_TESTS_GL_TEST_UTILS_H_
 
 #include <GLES2/gl2.h>
-#include "base/basictypes.h"
+#include <stdint.h>
 
 class GLTestHelper {
  public:
-  static const uint8 kCheckClearValue = 123u;
+  static const uint8_t kCheckClearValue = 123u;
 
   static bool HasExtension(const char* extension);
   static bool CheckGLError(const char* msg, int line);
@@ -49,9 +49,12 @@ class GLTestHelper {
       GLint location, const GLfloat color[4], GLenum usage);
 
   // Checks an area of pixels for a color.
-  static bool CheckPixels(
-      GLint x, GLint y, GLsizei width, GLsizei height, GLint tolerance,
-      const uint8* color);
+  static bool CheckPixels(GLint x,
+                          GLint y,
+                          GLsizei width,
+                          GLsizei height,
+                          GLint tolerance,
+                          const uint8_t* color);
 
   // Uses ReadPixels to save an area of the current FBO/Backbuffer.
   static bool SaveBackbufferAsBMP(const char* filename, int width, int height);
diff --git a/gpu/command_buffer/tests/gl_texture_mailbox_unittest.cc b/gpu/command_buffer/tests/gl_texture_mailbox_unittest.cc
index 6025427..beacdfb 100644
--- a/gpu/command_buffer/tests/gl_texture_mailbox_unittest.cc
+++ b/gpu/command_buffer/tests/gl_texture_mailbox_unittest.cc
@@ -5,6 +5,8 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/common/mailbox.h"
@@ -18,7 +20,7 @@
 namespace gpu {
 
 namespace {
-uint32 ReadTexel(GLuint id, GLint x, GLint y) {
+uint32_t ReadTexel(GLuint id, GLint x, GLint y) {
   GLint old_fbo = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_fbo);
 
@@ -40,7 +42,7 @@ uint32 ReadTexel(GLuint id, GLint x, GLint y) {
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
-  uint32 texel = 0;
+  uint32_t texel = 0;
   glReadPixels(x, y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &texel);
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
@@ -83,7 +85,7 @@ TEST_F(GLTextureMailboxTest, ProduceAndConsumeTexture) {
   glGenTextures(1, &tex1);
 
   glBindTexture(GL_TEXTURE_2D, tex1);
-  uint32 source_pixel = 0xFF0000FF;
+  uint32_t source_pixel = 0xFF0000FF;
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
@@ -127,7 +129,7 @@ TEST_F(GLTextureMailboxTest, ProduceAndConsumeTextureRGB) {
   glGenTextures(1, &tex1);
 
   glBindTexture(GL_TEXTURE_2D, tex1);
-  uint32 source_pixel = 0xFF000000;
+  uint32_t source_pixel = 0xFF000000;
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGB,
@@ -171,7 +173,7 @@ TEST_F(GLTextureMailboxTest, ProduceAndConsumeTextureDirect) {
   glGenTextures(1, &tex1);
 
   glBindTexture(GL_TEXTURE_2D, tex1);
-  uint32 source_pixel = 0xFF0000FF;
+  uint32_t source_pixel = 0xFF0000FF;
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
@@ -204,7 +206,7 @@ TEST_F(GLTextureMailboxTest, ConsumeTextureValidatesKey) {
   glGenTextures(1, &tex);
 
   glBindTexture(GL_TEXTURE_2D, tex);
-  uint32 source_pixel = 0xFF0000FF;
+  uint32_t source_pixel = 0xFF0000FF;
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
@@ -233,7 +235,7 @@ TEST_F(GLTextureMailboxTest, SharedTextures) {
   glGenTextures(1, &tex1);
 
   glBindTexture(GL_TEXTURE_2D, tex1);
-  uint32 source_pixel = 0xFF0000FF;
+  uint32_t source_pixel = 0xFF0000FF;
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGBA,
@@ -384,7 +386,7 @@ TEST_F(GLTextureMailboxTest, ProduceTextureDirectInvalidTarget) {
   glGenTextures(1, &tex1);
 
   glBindTexture(GL_TEXTURE_CUBE_MAP, tex1);
-  uint32 source_pixel = 0xFF0000FF;
+  uint32_t source_pixel = 0xFF0000FF;
   glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
                0,
                GL_RGBA,
diff --git a/gpu/command_buffer/tests/gl_texture_storage_unittest.cc b/gpu/command_buffer/tests/gl_texture_storage_unittest.cc
index 8c1162f..f5d9a61 100644
--- a/gpu/command_buffer/tests/gl_texture_storage_unittest.cc
+++ b/gpu/command_buffer/tests/gl_texture_storage_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -56,9 +57,7 @@ TEST_F(TextureStorageTest, CorrectPixels) {
   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                          tex_, 0);
 
-  uint8 source_pixels[16] = {
-      1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4
-  };
+  uint8_t source_pixels[16] = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4};
   glTexSubImage2D(GL_TEXTURE_2D,
                   0,
                   0, 0,
@@ -85,7 +84,7 @@ TEST_F(TextureStorageTest, OneLevel) {
 
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 4, 4);
 
-  uint8 source_pixels[64] = { 0 };
+  uint8_t source_pixels[64] = {0};
 
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4,
@@ -102,7 +101,7 @@ TEST_F(TextureStorageTest, MultipleLevels) {
 
   glTexStorage2DEXT(GL_TEXTURE_2D, 2, GL_RGBA8_OES, 2, 2);
 
-  uint8 source_pixels[16] = { 0 };
+  uint8_t source_pixels[16] = {0};
 
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2,
diff --git a/gpu/command_buffer/tests/gl_unittest.cc b/gpu/command_buffer/tests/gl_unittest.cc
index 70d35df..2eb1211 100644
--- a/gpu/command_buffer/tests/gl_unittest.cc
+++ b/gpu/command_buffer/tests/gl_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/tests/gl_manager.h"
@@ -26,7 +27,9 @@ class GLTest : public testing::Test {
 TEST_F(GLTest, Basic) {
   glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
   glClear(GL_COLOR_BUFFER_BIT);
-  uint8 expected[] = { 0, 255, 0, 255, };
+  uint8_t expected[] = {
+      0, 255, 0, 255,
+  };
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
   GLTestHelper::CheckGLError("no errors", __LINE__);
 }
@@ -37,7 +40,7 @@ TEST_F(GLTest, BasicFBO) {
   GLuint fbo = 0;
   glGenFramebuffers(1, &fbo);
   glBindTexture(GL_TEXTURE_2D, tex);
-  scoped_ptr<uint8[]> pixels(new uint8 [16*16*4]);
+  scoped_ptr<uint8_t[]> pixels(new uint8_t[16 * 16 * 4]);
   memset(pixels.get(), 0, 16*16*4);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels.get());
@@ -53,7 +56,9 @@ TEST_F(GLTest, BasicFBO) {
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
   glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
   glClear(GL_COLOR_BUFFER_BIT);
-  uint8 expected[] = { 0, 255, 0, 255, };
+  uint8_t expected[] = {
+      0, 255, 0, 255,
+  };
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 16, 16, 0, expected));
   glDeleteFramebuffers(1, &fbo);
   glDeleteTextures(1, &tex);
@@ -80,11 +85,15 @@ TEST_F(GLTest, SimpleShader) {
 
   GLTestHelper::SetupUnitQuad(position_loc);
 
-  uint8 expected_clear[] = { 127, 0, 255, 0, };
+  uint8_t expected_clear[] = {
+      127, 0, 255, 0,
+  };
   glClearColor(0.5f, 0.0f, 1.0f, 0.0f);
   glClear(GL_COLOR_BUFFER_BIT);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 1, expected_clear));
-  uint8 expected_draw[] = { 0, 255, 0, 255, };
+  uint8_t expected_draw[] = {
+      0, 255, 0, 255,
+  };
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_draw));
 }
diff --git a/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc b/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
index a0e4d54..d161ff6 100644
--- a/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
+++ b/gpu/command_buffer/tests/gl_virtual_contexts_unittest.cc
@@ -5,6 +5,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
@@ -23,8 +24,8 @@ class GLVirtualContextsTest : public testing::Test {
 
   static const GLfloat kFloatRed[4];
   static const GLfloat kFloatGreen[4];
-  static const uint8 kExpectedRed[4];
-  static const uint8 kExpectedGreen[4];
+  static const uint8_t kExpectedRed[4];
+  static const uint8_t kExpectedGreen[4];
 
   void SetUp() override {
     GLManager::Options options;
@@ -91,16 +92,16 @@ const GLfloat GLVirtualContextsTest::kFloatRed[4] = {
 const GLfloat GLVirtualContextsTest::kFloatGreen[4] = {
     0.0f, 1.0f, 0.0f, 1.0f,
 };
-const uint8 GLVirtualContextsTest::kExpectedRed[4] = {
+const uint8_t GLVirtualContextsTest::kExpectedRed[4] = {
     255, 0, 0, 255,
 };
-const uint8 GLVirtualContextsTest::kExpectedGreen[4] = {
+const uint8_t GLVirtualContextsTest::kExpectedGreen[4] = {
     0, 255, 0, 255,
 };
 
 namespace {
 
-void SetupSimpleShader(const uint8* color) {
+void SetupSimpleShader(const uint8_t* color) {
   static const char* v_shader_str = SHADER(
       attribute vec4 a_Position;
       void main()
@@ -135,7 +136,9 @@ void SetupSimpleShader(const uint8* color) {
 }
 
 void TestDraw(int size) {
-  uint8 expected_clear[] = { 127, 0, 255, 0, };
+  uint8_t expected_clear[] = {
+      127, 0, 255, 0,
+  };
   glClearColor(0.5f, 0.0f, 1.0f, 0.0f);
   glClear(GL_COLOR_BUFFER_BIT);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, size, size, 1, expected_clear));
@@ -148,7 +151,7 @@ void TestDraw(int size) {
 TEST_F(GLVirtualContextsTest, Basic) {
   struct TestInfo {
     int size;
-    uint8 color[4];
+    uint8_t color[4];
     GLManager* manager;
   };
   const int kNumTests = 3;
diff --git a/gpu/config/gpu_blacklist.h b/gpu/config/gpu_blacklist.h
index 6b2138a..7953507 100644
--- a/gpu/config/gpu_blacklist.h
+++ b/gpu/config/gpu_blacklist.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "base/macros.h"
 #include "gpu/config/gpu_control_list.h"
 
 namespace gpu {
diff --git a/gpu/config/gpu_control_list.cc b/gpu/config/gpu_control_list.cc
index 5433b61..00920d6 100644
--- a/gpu/config/gpu_control_list.cc
+++ b/gpu/config/gpu_control_list.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_control_list.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
@@ -379,7 +382,7 @@ GpuControlList::GpuControlListEntry::GetEntryFromValue(
   size_t dictionary_entry_count = 0;
 
   if (top_level) {
-    uint32 id;
+    uint32_t id;
     if (!value->GetInteger("id", reinterpret_cast<int*>(&id)) ||
         !entry->SetId(id)) {
       LOG(WARNING) << "Malformed id entry " << entry->id();
@@ -802,7 +805,7 @@ GpuControlList::GpuControlListEntry::GpuControlListEntry()
 
 GpuControlList::GpuControlListEntry::~GpuControlListEntry() { }
 
-bool GpuControlList::GpuControlListEntry::SetId(uint32 id) {
+bool GpuControlList::GpuControlListEntry::SetId(uint32_t id) {
   if (id != 0) {
     id_ = id;
     return true;
@@ -832,7 +835,7 @@ bool GpuControlList::GpuControlListEntry::SetVendorId(
 
 bool GpuControlList::GpuControlListEntry::AddDeviceId(
     const std::string& device_id_string) {
-  uint32 device_id = 0;
+  uint32_t device_id = 0;
   if (base::HexStringToUInt(device_id_string, &device_id) && device_id != 0) {
     device_id_list_.push_back(device_id);
     return true;
@@ -1304,7 +1307,7 @@ GpuControlList::OsType GpuControlList::GpuControlListEntry::GetOsType() const {
   return os_info_->type();
 }
 
-uint32 GpuControlList::GpuControlListEntry::id() const {
+uint32_t GpuControlList::GpuControlListEntry::id() const {
   return id_;
 }
 
@@ -1381,7 +1384,7 @@ bool GpuControlList::LoadList(const base::DictionaryValue& parsed_json,
   if (!parsed_json.GetList("entries", &list))
     return false;
 
-  uint32 max_entry_id = 0;
+  uint32_t max_entry_id = 0;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* list_item = NULL;
     bool valid = list->GetDictionary(i, &list_item);
@@ -1464,8 +1467,8 @@ std::set<int> GpuControlList::MakeDecision(
   return features;
 }
 
-void GpuControlList::GetDecisionEntries(
-    std::vector<uint32>* entry_ids, bool disabled) const {
+void GpuControlList::GetDecisionEntries(std::vector<uint32_t>* entry_ids,
+                                        bool disabled) const {
   DCHECK(entry_ids);
   entry_ids->clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
@@ -1526,7 +1529,7 @@ size_t GpuControlList::num_entries() const {
   return entries_.size();
 }
 
-uint32 GpuControlList::max_entry_id() const {
+uint32_t GpuControlList::max_entry_id() const {
   return max_entry_id_;
 }
 
diff --git a/gpu/config/gpu_control_list.h b/gpu/config/gpu_control_list.h
index ea9252a..4728238 100644
--- a/gpu/config/gpu_control_list.h
+++ b/gpu/config/gpu_control_list.h
@@ -5,11 +5,13 @@
 #ifndef GPU_CONFIG_GPU_CONTROL_LIST_H_
 #define GPU_CONFIG_GPU_CONTROL_LIST_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -57,7 +59,7 @@ class GPU_EXPORT GpuControlList {
   // Collects the active entries from the last MakeDecision() call.
   // If disabled set to true, return entries that are disabled; otherwise,
   // return enabled entries.
-  void GetDecisionEntries(std::vector<uint32>* entry_ids,
+  void GetDecisionEntries(std::vector<uint32_t>* entry_ids,
                           bool disabled) const;
 
   // Collects all disabled extensions.
@@ -76,7 +78,7 @@ class GPU_EXPORT GpuControlList {
       base::ListValue* problem_list, const std::string& tag) const;
 
   // Return the largest entry id.  This is used for histogramming.
-  uint32 max_entry_id() const;
+  uint32_t max_entry_id() const;
 
   // Returns the version of the control list.
   std::string version() const;
@@ -274,7 +276,7 @@ class GPU_EXPORT GpuControlList {
     OsType GetOsType() const;
 
     // Returns the entry's unique id.  0 is reserved.
-    uint32 id() const;
+    uint32_t id() const;
 
     // Returns whether the entry is disabled.
     bool disabled() const;
@@ -330,7 +332,7 @@ class GPU_EXPORT GpuControlList {
     GpuControlListEntry();
     ~GpuControlListEntry();
 
-    bool SetId(uint32 id);
+    bool SetId(uint32_t id);
 
     void SetDisabled(bool disabled);
 
@@ -428,15 +430,15 @@ class GPU_EXPORT GpuControlList {
     // See GLType declaration.
     static GLType GetDefaultGLType();
 
-    uint32 id_;
+    uint32_t id_;
     bool disabled_;
     std::string description_;
     std::vector<int> cr_bugs_;
     std::vector<int> webkit_bugs_;
     std::vector<std::string> disabled_extensions_;
     scoped_ptr<OsInfo> os_info_;
-    uint32 vendor_id_;
-    std::vector<uint32> device_id_list_;
+    uint32_t vendor_id_;
+    std::vector<uint32_t> device_id_list_;
     MultiGpuStyle multi_gpu_style_;
     MultiGpuCategory multi_gpu_category_;
     GLType gl_type_;
@@ -478,7 +480,7 @@ class GPU_EXPORT GpuControlList {
   // used later by GetDecisionEntries().
   std::vector<ScopedGpuControlListEntry> active_entries_;
 
-  uint32 max_entry_id_;
+  uint32_t max_entry_id_;
 
   bool needs_more_info_;
 
diff --git a/gpu/config/gpu_control_list_entry_unittest.cc b/gpu/config/gpu_control_list_entry_unittest.cc
index 011c30a..91504c1 100644
--- a/gpu/config/gpu_control_list_entry_unittest.cc
+++ b/gpu/config/gpu_control_list_entry_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "base/json/json_reader.h"
 #include "gpu/config/gpu_control_list.h"
 #include "gpu/config/gpu_info.h"
diff --git a/gpu/config/gpu_control_list_number_info_unittest.cc b/gpu/config/gpu_control_list_number_info_unittest.cc
index f3324d2..f2fffff 100644
--- a/gpu/config/gpu_control_list_number_info_unittest.cc
+++ b/gpu/config/gpu_control_list_number_info_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "gpu/config/gpu_control_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/gpu/config/gpu_control_list_os_info_unittest.cc b/gpu/config/gpu_control_list_os_info_unittest.cc
index 652b005d..510487c 100644
--- a/gpu/config/gpu_control_list_os_info_unittest.cc
+++ b/gpu/config/gpu_control_list_os_info_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "gpu/config/gpu_control_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/gpu/config/gpu_control_list_unittest.cc b/gpu/config/gpu_control_list_unittest.cc
index 402998b..038f36c 100644
--- a/gpu/config/gpu_control_list_unittest.cc
+++ b/gpu/config/gpu_control_list_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ -10,9 +12,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 const char kOsVersion[] = "10.6.4";
-const uint32 kIntelVendorId = 0x8086;
-const uint32 kNvidiaVendorId = 0x10de;
-const uint32 kAmdVendorId = 0x10de;
+const uint32_t kIntelVendorId = 0x8086;
+const uint32_t kNvidiaVendorId = 0x10de;
+const uint32_t kAmdVendorId = 0x10de;
 
 #define LONG_STRING_CONST(...) #__VA_ARGS__
 
@@ -136,7 +138,7 @@ TEST_F(GpuControlListTest, DetailedEntryAndInvalidJson) {
   features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
-  std::vector<uint32> entries;
+  std::vector<uint32_t> entries;
   control_list->GetDecisionEntries(&entries, false);
   ASSERT_EQ(1u, entries.size());
   EXPECT_EQ(5u, entries[0]);
@@ -278,7 +280,7 @@ TEST_F(GpuControlListTest, DisabledEntry) {
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info());
   EXPECT_EMPTY_SET(features);
-  std::vector<uint32> flag_entries;
+  std::vector<uint32_t> flag_entries;
   control_list->GetDecisionEntries(&flag_entries, false);
   EXPECT_EQ(0u, flag_entries.size());
   control_list->GetDecisionEntries(&flag_entries, true);
@@ -318,7 +320,7 @@ TEST_F(GpuControlListTest, NeedsMoreInfo) {
       GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
   EXPECT_TRUE(control_list->needs_more_info());
-  std::vector<uint32> decision_entries;
+  std::vector<uint32_t> decision_entries;
   control_list->GetDecisionEntries(&decision_entries, false);
   EXPECT_EQ(0u, decision_entries.size());
 
diff --git a/gpu/config/gpu_control_list_version_info_unittest.cc b/gpu/config/gpu_control_list_version_info_unittest.cc
index a2d425f..bde9d0c 100644
--- a/gpu/config/gpu_control_list_version_info_unittest.cc
+++ b/gpu/config/gpu_control_list_version_info_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "gpu/config/gpu_control_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/gpu/config/gpu_driver_bug_list.cc b/gpu/config/gpu_driver_bug_list.cc
index bda38b6..a8bc2b0 100644
--- a/gpu/config/gpu_driver_bug_list.cc
+++ b/gpu/config/gpu_driver_bug_list.cc
@@ -4,7 +4,6 @@
 
 #include "gpu/config/gpu_driver_bug_list.h"
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "gpu/config/gpu_switches.h"
diff --git a/gpu/config/gpu_driver_bug_list.h b/gpu/config/gpu_driver_bug_list.h
index ba24944..8db219f 100644
--- a/gpu/config/gpu_driver_bug_list.h
+++ b/gpu/config/gpu_driver_bug_list.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "base/command_line.h"
+#include "base/macros.h"
 #include "gpu/config/gpu_control_list.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "gpu/gpu_export.h"
diff --git a/gpu/config/gpu_driver_bug_list_unittest.cc b/gpu/config/gpu_driver_bug_list_unittest.cc
index 1e4090b..e7eaaa5 100644
--- a/gpu/config/gpu_driver_bug_list_unittest.cc
+++ b/gpu/config/gpu_driver_bug_list_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ -107,7 +109,7 @@ TEST_F(GpuDriverBugListTest, GpuSwitching) {
       GpuControlList::kOsMacosx, "10.8", gpu_info());
   EXPECT_EQ(1u, switching.size());
   EXPECT_EQ(1u, switching.count(FORCE_DISCRETE_GPU));
-  std::vector<uint32> entries;
+  std::vector<uint32_t> entries;
   driver_bug_list->GetDecisionEntries(&entries, false);
   ASSERT_EQ(1u, entries.size());
   EXPECT_EQ(1u, entries[0]);
diff --git a/gpu/config/gpu_info.cc b/gpu/config/gpu_info.cc
index 3a753e5..e9f354b 100644
--- a/gpu/config/gpu_info.cc
+++ b/gpu/config/gpu_info.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "gpu/config/gpu_info.h"
 
 namespace {
@@ -90,7 +92,7 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     Version display_link_version;
     GPUDevice gpu;
     std::vector<GPUDevice> secondary_gpus;
-    uint64 adapter_luid;
+    uint64_t adapter_luid;
     std::string driver_vendor;
     std::string driver_version;
     std::string driver_date;
@@ -106,7 +108,7 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     std::string gl_ws_vendor;
     std::string gl_ws_version;
     std::string gl_ws_extensions;
-    uint32 gl_reset_notification_strategy;
+    uint32_t gl_reset_notification_strategy;
     bool can_lose_context;
     bool software_rendering;
     bool direct_rendering;
diff --git a/gpu/config/gpu_info.h b/gpu/config/gpu_info.h
index d803cc3..8003c93 100644
--- a/gpu/config/gpu_info.h
+++ b/gpu/config/gpu_info.h
@@ -8,10 +8,11 @@
 // Provides access to the GPU information for the system
 // on which chrome is currently running.
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/time/time.h"
 #include "base/version.h"
 #include "build/build_config.h"
@@ -75,8 +76,8 @@ struct GPU_EXPORT VideoDecodeAcceleratorCapabilities {
 struct GPU_EXPORT VideoEncodeAcceleratorSupportedProfile {
   VideoCodecProfile profile;
   gfx::Size max_resolution;
-  uint32 max_framerate_numerator;
-  uint32 max_framerate_denominator;
+  uint32_t max_framerate_numerator;
+  uint32_t max_framerate_denominator;
 };
 using VideoEncodeAcceleratorSupportedProfiles =
     std::vector<VideoEncodeAcceleratorSupportedProfile>;
@@ -86,12 +87,12 @@ struct GPU_EXPORT GPUInfo {
     GPUDevice();
     ~GPUDevice();
 
-    // The DWORD (uint32) representing the graphics card vendor id.
-    uint32 vendor_id;
+    // The DWORD (uint32_t) representing the graphics card vendor id.
+    uint32_t vendor_id;
 
-    // The DWORD (uint32) representing the graphics card device id.
+    // The DWORD (uint32_t) representing the graphics card device id.
     // Device ids are unique to vendor, not to one another.
-    uint32 device_id;
+    uint32_t device_id;
 
     // Whether this GPU is the currently used one.
     // Currently this field is only supported and meaningful on OS X.
@@ -140,7 +141,7 @@ struct GPU_EXPORT GPUInfo {
   // on the primary adapter. Note that the primary adapter can change at any
   // time so it is better to specify a particular LUID. Note that valid LUIDs
   // are always non-zero.
-  uint64 adapter_luid;
+  uint64_t adapter_luid;
 
   // The vendor of the graphics driver currently installed.
   std::string driver_vendor;
@@ -196,7 +197,7 @@ struct GPU_EXPORT GPUInfo {
 
   // GL reset notification strategy as defined by GL_ARB_robustness. 0 if GPU
   // reset detection or notification not available.
-  uint32 gl_reset_notification_strategy;
+  uint32_t gl_reset_notification_strategy;
 
   // The device semantics, i.e. whether the Vista and Windows 7 specific
   // semantics are available.
@@ -246,7 +247,7 @@ struct GPU_EXPORT GPUInfo {
     // is the root object, but calls to BeginGPUDevice/EndGPUDevice and
     // BeginAuxAttributes/EndAuxAttributes change the object to which these
     // calls should apply.
-    virtual void AddInt64(const char* name, int64 value) = 0;
+    virtual void AddInt64(const char* name, int64_t value) = 0;
     virtual void AddInt(const char* name, int value) = 0;
     virtual void AddString(const char* name, const std::string& value) = 0;
     virtual void AddBool(const char* name, bool value) = 0;
diff --git a/gpu/config/gpu_info_collector.cc b/gpu/config/gpu_info_collector.cc
index 1709da1..44df9f1 100644
--- a/gpu/config/gpu_info_collector.cc
+++ b/gpu/config/gpu_info_collector.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_info_collector.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
@@ -218,18 +221,17 @@ void IdentifyActiveGPU(GPUInfo* gpu_info) {
   const std::string kVendorNames[] = {
       kNVidiaName, kIntelName, kAMDName, kATIName};
 
-  const uint32 kNVidiaID = 0x10de;
-  const uint32 kIntelID = 0x8086;
-  const uint32 kAMDID = 0x1002;
-  const uint32 kATIID = 0x1002;
-  const uint32 kVendorIDs[] = {
-      kNVidiaID, kIntelID, kAMDID, kATIID};
+  const uint32_t kNVidiaID = 0x10de;
+  const uint32_t kIntelID = 0x8086;
+  const uint32_t kAMDID = 0x1002;
+  const uint32_t kATIID = 0x1002;
+  const uint32_t kVendorIDs[] = {kNVidiaID, kIntelID, kAMDID, kATIID};
 
   DCHECK(gpu_info);
   if (gpu_info->secondary_gpus.size() == 0)
     return;
 
-  uint32 active_vendor_id = 0;
+  uint32_t active_vendor_id = 0;
   if (!gpu_info->gl_vendor.empty()) {
     std::string gl_vendor_lower = base::ToLowerASCII(gpu_info->gl_vendor);
     int index = StringContainsName(
diff --git a/gpu/config/gpu_info_collector.h b/gpu/config/gpu_info_collector.h
index 0fda54b..840dc1d 100644
--- a/gpu/config/gpu_info_collector.h
+++ b/gpu/config/gpu_info_collector.h
@@ -5,7 +5,8 @@
 #ifndef GPU_CONFIG_GPU_INFO_COLLECTOR_H_
 #define GPU_CONFIG_GPU_INFO_COLLECTOR_H_
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "build/build_config.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/gpu_export.h"
@@ -13,7 +14,8 @@
 namespace gpu {
 
 // Collect GPU vendor_id and device ID.
-GPU_EXPORT CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id);
+GPU_EXPORT CollectInfoResult CollectGpuID(uint32_t* vendor_id,
+                                          uint32_t* device_id);
 
 // Collects basic GPU info without creating a GL/DirectX context (and without
 // the danger of crashing), including vendor_id and device_id.
diff --git a/gpu/config/gpu_info_collector_android.cc b/gpu/config/gpu_info_collector_android.cc
index e8f7a47..de964e2 100644
--- a/gpu/config/gpu_info_collector_android.cc
+++ b/gpu/config/gpu_info_collector_android.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_info_collector.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/android/build_info.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ -252,7 +255,7 @@ CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   return CollectBasicGraphicsInfo(gpu_info);
 }
 
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
   DCHECK(vendor_id && device_id);
   *vendor_id = 0;
   *device_id = 0;
diff --git a/gpu/config/gpu_info_collector_linux.cc b/gpu/config/gpu_info_collector_linux.cc
index e93a79c..e201ce0 100644
--- a/gpu/config/gpu_info_collector_linux.cc
+++ b/gpu/config/gpu_info_collector_linux.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_info_collector_linux.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 
 #include "base/command_line.h"
@@ -71,9 +74,9 @@ std::string CollectDriverVersionATI() {
   return std::string();
 }
 
-const uint32 kVendorIDIntel = 0x8086;
-const uint32 kVendorIDNVidia = 0x10de;
-const uint32 kVendorIDAMD = 0x1002;
+const uint32_t kVendorIDIntel = 0x8086;
+const uint32_t kVendorIDNVidia = 0x10de;
+const uint32_t kVendorIDAMD = 0x1002;
 
 CollectInfoResult CollectPCIVideoCardInfo(GPUInfo* gpu_info) {
   DCHECK(gpu_info);
@@ -183,7 +186,7 @@ CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   return result;
 }
 
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
   DCHECK(vendor_id && device_id);
   *vendor_id = 0;
   *device_id = 0;
diff --git a/gpu/config/gpu_info_collector_mac.mm b/gpu/config/gpu_info_collector_mac.mm
index 6105064..f6d81fd 100644
--- a/gpu/config/gpu_info_collector_mac.mm
+++ b/gpu/config/gpu_info_collector_mac.mm
@@ -23,6 +23,8 @@
 #import <Cocoa/Cocoa.h>
 #import <Foundation/Foundation.h>
 #import <IOKit/IOKitLib.h>
+#include <stddef.h>
+#include <stdint.h>
 
 namespace gpu {
 
@@ -175,7 +177,7 @@ CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   return result;
 }
 
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
   DCHECK(vendor_id && device_id);
 
   GPUInfo::GPUDevice gpu = GetActiveGPU();
@@ -190,7 +192,7 @@ CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
 CollectInfoResult CollectBasicGraphicsInfo(GPUInfo* gpu_info) {
   DCHECK(gpu_info);
 
-  int32 model_major = 0, model_minor = 0;
+  int32_t model_major = 0, model_minor = 0;
   base::mac::ParseModelIdentifier(base::mac::GetModelIdentifier(),
                                   &gpu_info->machine_model_name,
                                   &model_major, &model_minor);
diff --git a/gpu/config/gpu_info_collector_unittest.cc b/gpu/config/gpu_info_collector_unittest.cc
index 9f038a9..3e35d00 100644
--- a/gpu/config/gpu_info_collector_unittest.cc
+++ b/gpu/config/gpu_info_collector_unittest.cc
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "gpu/config/gpu_info.h"
@@ -142,7 +145,7 @@ class GPUInfoCollectorTest
           .WillRepeatedly(SetArgPointee<1>(split_extensions_.size()));
       for (size_t ii = 0; ii < split_extensions_.size(); ++ii) {
         EXPECT_CALL(*gl_, GetStringi(GL_EXTENSIONS, ii))
-            .WillRepeatedly(Return(reinterpret_cast<const uint8*>(
+            .WillRepeatedly(Return(reinterpret_cast<const uint8_t*>(
                 split_extensions_[ii].c_str())));
       }
     }
diff --git a/gpu/config/gpu_info_collector_win.cc b/gpu/config/gpu_info_collector_win.cc
index f51764d..45087ee 100644
--- a/gpu/config/gpu_info_collector_win.cc
+++ b/gpu/config/gpu_info_collector_win.cc
@@ -13,6 +13,8 @@
 #include <d3d11.h>
 #include <dxgi.h>
 #include <setupapi.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
@@ -89,8 +91,8 @@ bool IsLenovoDCuteInstalled() {
 }
 
 void DeviceIDToVendorAndDevice(const std::wstring& id,
-                               uint32* vendor_id,
-                               uint32* device_id) {
+                               uint32_t* vendor_id,
+                               uint32_t* device_id) {
   *vendor_id = 0;
   *device_id = 0;
   if (id.length() < 21)
@@ -217,7 +219,7 @@ CollectInfoResult CollectDriverInfoD3D(const std::wstring& device_id,
           if (id.compare(0, device_id.size(), device_id) == 0)
             primary_device = drivers.size();
 
-          uint32 vendor_id = 0, device_id = 0;
+          uint32_t vendor_id = 0, device_id = 0;
           DeviceIDToVendorAndDevice(id, &vendor_id, &device_id);
           driver.device.vendor_id = vendor_id;
           driver.device.device_id = device_id;
@@ -354,7 +356,7 @@ CollectInfoResult CollectContextGraphicsInfo(GPUInfo* gpu_info) {
   return kCollectInfoSuccess;
 }
 
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
   DCHECK(vendor_id && device_id);
   *vendor_id = 0;
   *device_id = 0;
diff --git a/gpu/config/gpu_test_config.cc b/gpu/config/gpu_test_config.cc
index a7cc4b4..d8fc2ba 100644
--- a/gpu/config/gpu_test_config.cc
+++ b/gpu/config/gpu_test_config.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_test_config.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "gpu/config/gpu_info.h"
@@ -26,9 +29,9 @@ GPUTestConfig::OS GetCurrentOS() {
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
   return GPUTestConfig::kOsLinux;
 #elif defined(OS_WIN)
-  int32 major_version = 0;
-  int32 minor_version = 0;
-  int32 bugfix_version = 0;
+  int32_t major_version = 0;
+  int32_t minor_version = 0;
+  int32_t bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &major_version, &minor_version, &bugfix_version);
   if (major_version == 5)
@@ -42,9 +45,9 @@ GPUTestConfig::OS GetCurrentOS() {
   if (major_version == 10)
     return GPUTestConfig::kOsWin10;
 #elif defined(OS_MACOSX)
-  int32 major_version = 0;
-  int32 minor_version = 0;
-  int32 bugfix_version = 0;
+  int32_t major_version = 0;
+  int32_t minor_version = 0;
+  int32_t bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &major_version, &minor_version, &bugfix_version);
   if (major_version == 10) {
@@ -83,28 +86,28 @@ GPUTestConfig::GPUTestConfig()
 GPUTestConfig::~GPUTestConfig() {
 }
 
-void GPUTestConfig::set_os(int32 os) {
+void GPUTestConfig::set_os(int32_t os) {
   DCHECK_EQ(0, os & ~(kOsAndroid | kOsWin | kOsMac | kOsLinux | kOsChromeOS));
   os_ = os;
 }
 
-void GPUTestConfig::AddGPUVendor(uint32 gpu_vendor) {
+void GPUTestConfig::AddGPUVendor(uint32_t gpu_vendor) {
   DCHECK_NE(0u, gpu_vendor);
   for (size_t i = 0; i < gpu_vendor_.size(); ++i)
     DCHECK_NE(gpu_vendor_[i], gpu_vendor);
   gpu_vendor_.push_back(gpu_vendor);
 }
 
-void GPUTestConfig::set_gpu_device_id(uint32 id) {
+void GPUTestConfig::set_gpu_device_id(uint32_t id) {
   gpu_device_id_ = id;
 }
 
-void GPUTestConfig::set_build_type(int32 build_type) {
+void GPUTestConfig::set_build_type(int32_t build_type) {
   DCHECK_EQ(0, build_type & ~(kBuildTypeRelease | kBuildTypeDebug));
   build_type_ = build_type;
 }
 
-void GPUTestConfig::set_api(int32 api) {
+void GPUTestConfig::set_api(int32_t api) {
   DCHECK_EQ(0, api & ~(kAPID3D9 | kAPID3D11 | kAPIGLDesktop | kAPIGLES));
   api_ = api;
 }
@@ -157,7 +160,7 @@ void GPUTestConfig::ClearGPUVendor() {
 GPUTestBotConfig::~GPUTestBotConfig() {
 }
 
-void GPUTestBotConfig::AddGPUVendor(uint32 gpu_vendor) {
+void GPUTestBotConfig::AddGPUVendor(uint32_t gpu_vendor) {
   DCHECK_EQ(0u, GPUTestConfig::gpu_vendor().size());
   GPUTestConfig::AddGPUVendor(gpu_vendor);
 }
diff --git a/gpu/config/gpu_test_config.h b/gpu/config/gpu_test_config.h
index b5431e6..c1df306 100644
--- a/gpu/config/gpu_test_config.h
+++ b/gpu/config/gpu_test_config.h
@@ -5,10 +5,11 @@
 #ifndef GPU_CONFIG_GPU_TEST_CONFIG_H_
 #define GPU_CONFIG_GPU_TEST_CONFIG_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "gpu/gpu_export.h"
 
@@ -58,18 +59,18 @@ class GPU_EXPORT GPUTestConfig {
   GPUTestConfig();
   virtual ~GPUTestConfig();
 
-  void set_os(int32 os);
-  void set_gpu_device_id(uint32 id);
-  void set_build_type(int32 build_type);
-  void set_api(int32 api);
+  void set_os(int32_t os);
+  void set_gpu_device_id(uint32_t id);
+  void set_build_type(int32_t build_type);
+  void set_api(int32_t api);
 
-  virtual void AddGPUVendor(uint32 gpu_vendor);
+  virtual void AddGPUVendor(uint32_t gpu_vendor);
 
-  int32 os() const { return os_; }
-  const std::vector<uint32>& gpu_vendor() const { return gpu_vendor_; }
-  uint32 gpu_device_id() const { return gpu_device_id_; }
-  int32 build_type() const { return build_type_; }
-  int32 api() const { return api_; }
+  int32_t os() const { return os_; }
+  const std::vector<uint32_t>& gpu_vendor() const { return gpu_vendor_; }
+  uint32_t gpu_device_id() const { return gpu_device_id_; }
+  int32_t build_type() const { return build_type_; }
+  int32_t api() const { return api_; }
 
   // Check if the config is valid. For example, if gpu_device_id_ is set, but
   // gpu_vendor_ is unknown, then it's invalid.
@@ -91,19 +92,19 @@ class GPU_EXPORT GPUTestConfig {
 
  private:
   // operating system.
-  int32 os_;
+  int32_t os_;
 
   // GPU vendor.
-  std::vector<uint32> gpu_vendor_;
+  std::vector<uint32_t> gpu_vendor_;
 
   // GPU device id (unique to each vendor).
-  uint32 gpu_device_id_;
+  uint32_t gpu_device_id_;
 
   // Release or Debug.
-  int32 build_type_;
+  int32_t build_type_;
 
   // Back-end rendering APIs.
-  int32 api_;
+  int32_t api_;
 };
 
 class GPU_EXPORT GPUTestBotConfig : public GPUTestConfig {
@@ -112,7 +113,7 @@ class GPU_EXPORT GPUTestBotConfig : public GPUTestConfig {
   ~GPUTestBotConfig() override;
 
   // This should only be called when no gpu_vendor is added.
-  void AddGPUVendor(uint32 gpu_vendor) override;
+  void AddGPUVendor(uint32_t gpu_vendor) override;
 
   // Return false if gpu_info does not have valid vendor_id and device_id.
   bool SetGPUInfo(const GPUInfo& gpu_info);
diff --git a/gpu/config/gpu_test_expectations_parser.cc b/gpu/config/gpu_test_expectations_parser.cc
index 6dac74e..2ae972b 100644
--- a/gpu/config/gpu_test_expectations_parser.cc
+++ b/gpu/config/gpu_test_expectations_parser.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/config/gpu_test_expectations_parser.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ -77,7 +80,7 @@ enum Token {
 
 struct TokenInfo {
   const char* name;
-  int32 flag;
+  int32_t flag;
 };
 
 const TokenInfo kTokenData[] = {
@@ -151,7 +154,7 @@ Token ParseToken(const std::string& word) {
   if (base::StartsWith(word, "0x", base::CompareCase::INSENSITIVE_ASCII))
     return kConfigGPUDeviceID;
 
-  for (int32 i = 0; i < kNumberOfExactMatchTokens; ++i) {
+  for (int32_t i = 0; i < kNumberOfExactMatchTokens; ++i) {
     if (base::LowerCaseEqualsASCII(word, kTokenData[i].name))
       return static_cast<Token>(i);
   }
@@ -217,7 +220,7 @@ bool GPUTestExpectationsParser::LoadTestExpectations(
   return LoadTestExpectations(data);
 }
 
-int32 GPUTestExpectationsParser::GetTestExpectation(
+int32_t GPUTestExpectationsParser::GetTestExpectation(
     const std::string& test_name,
     const GPUTestBotConfig& bot_config) const {
   for (size_t i = 0; i < entries_.size(); ++i) {
@@ -291,7 +294,7 @@ bool GPUTestExpectationsParser::ParseLine(
   std::vector<std::string> tokens = base::SplitString(
       line_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
       base::SPLIT_WANT_NONEMPTY);
-  int32 stage = kLineParserBegin;
+  int32_t stage = kLineParserBegin;
   GPUTestExpectationEntry entry;
   entry.line_number = line_number;
   GPUTestConfig& config = entry.test_config;
@@ -419,8 +422,9 @@ bool GPUTestExpectationsParser::ParseLine(
   return false;
 }
 
-bool GPUTestExpectationsParser::UpdateTestConfig(
-    GPUTestConfig* config, int32 token, size_t line_number) {
+bool GPUTestExpectationsParser::UpdateTestConfig(GPUTestConfig* config,
+                                                 int32_t token,
+                                                 size_t line_number) {
   DCHECK(config);
   switch (token) {
     case kConfigWinXP:
@@ -452,8 +456,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     case kConfigIntel:
     case kConfigVMWare:
       {
-        uint32 gpu_vendor =
-            static_cast<uint32>(kTokenData[token].flag);
+      uint32_t gpu_vendor = static_cast<uint32_t>(kTokenData[token].flag);
         for (size_t i = 0; i < config->gpu_vendor().size(); ++i) {
           if (config->gpu_vendor()[i] == gpu_vendor) {
             PushErrorMessage(
@@ -499,7 +502,7 @@ bool GPUTestExpectationsParser::UpdateTestConfig(
     const std::string& gpu_device_id,
     size_t line_number) {
   DCHECK(config);
-  uint32 device_id = 0;
+  uint32_t device_id = 0;
   if (config->gpu_device_id() != 0 ||
       !base::HexStringToUInt(gpu_device_id, &device_id) ||
       device_id == 0) {
diff --git a/gpu/config/gpu_test_expectations_parser.h b/gpu/config/gpu_test_expectations_parser.h
index a69f7e9..d943e44 100644
--- a/gpu/config/gpu_test_expectations_parser.h
+++ b/gpu/config/gpu_test_expectations_parser.h
@@ -5,10 +5,12 @@
 #ifndef GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
 #define GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "gpu/config/gpu_test_config.h"
 #include "gpu/gpu_export.h"
@@ -38,8 +40,8 @@ class GPU_EXPORT GPUTestExpectationsParser {
   const std::vector<std::string>& GetErrorMessages() const;
 
   // Get the test expectation of a given test on a given bot.
-  int32 GetTestExpectation(const std::string& test_name,
-                           const GPUTestBotConfig& bot_config) const;
+  int32_t GetTestExpectation(const std::string& test_name,
+                             const GPUTestBotConfig& bot_config) const;
 
   // Parse a list of config modifiers. If we have a valid entry with no
   // conflicts, | config | stores it, and the function returns true.
@@ -51,7 +53,7 @@ class GPU_EXPORT GPUTestExpectationsParser {
 
     std::string test_name;
     GPUTestConfig test_config;
-    int32 test_expectation;
+    int32_t test_expectation;
     size_t line_number;
   };
 
@@ -60,8 +62,9 @@ class GPU_EXPORT GPUTestExpectationsParser {
   bool ParseLine(const std::string& line_data, size_t line_number);
 
   // Update OS/GPUVendor/BuildType modifiers. May generate an error message.
-  bool UpdateTestConfig(
-      GPUTestConfig* config, int32 token, size_t line_number);
+  bool UpdateTestConfig(GPUTestConfig* config,
+                        int32_t token,
+                        size_t line_number);
 
   // Update GPUDeviceID modifier. May generate an error message.
   bool UpdateTestConfig(GPUTestConfig* config,
diff --git a/gpu/config/gpu_test_expectations_parser_unittest.cc b/gpu/config/gpu_test_expectations_parser_unittest.cc
index b69703e..56e320a 100644
--- a/gpu/config/gpu_test_expectations_parser_unittest.cc
+++ b/gpu/config/gpu_test_expectations_parser_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ -78,7 +80,7 @@ class GPUTestExpectationsParserTest : public testing::Test {
 
   void TearDown() override {}
 
-  void set_os(int32 os) {
+  void set_os(int32_t os) {
     bot_config_.set_os(os);
     ASSERT_TRUE(bot_config_.IsValid());
   }
diff --git a/gpu/gles2_conform_support/egl/config.h b/gpu/gles2_conform_support/egl/config.h
index ef2ae1d..53bb568 100644
--- a/gpu/gles2_conform_support/egl/config.h
+++ b/gpu/gles2_conform_support/egl/config.h
@@ -7,7 +7,7 @@
 
 #include <EGL/egl.h>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 
 namespace egl {
 
diff --git a/gpu/gles2_conform_support/egl/display.cc b/gpu/gles2_conform_support/egl/display.cc
index f79a453..b828079 100644
--- a/gpu/gles2_conform_support/egl/display.cc
+++ b/gpu/gles2_conform_support/egl/display.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/gles2_conform_support/egl/display.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ -21,8 +24,8 @@
 #include "gpu/gles2_conform_support/egl/surface.h"
 
 namespace {
-const int32 kCommandBufferSize = 1024 * 1024;
-const int32 kTransferBufferSize = 512 * 1024;
+const int32_t kCommandBufferSize = 1024 * 1024;
+const int32_t kTransferBufferSize = 512 * 1024;
 }
 
 namespace egl {
@@ -161,7 +164,7 @@ EGLSurface Display::CreateWindowSurface(EGLConfig config,
   GetConfigAttrib(config, EGL_DEPTH_SIZE, &depth_size);
   GetConfigAttrib(config, EGL_ALPHA_SIZE, &alpha_size);
   GetConfigAttrib(config, EGL_STENCIL_SIZE, &stencil_size);
-  std::vector<int32> attribs;
+  std::vector<int32_t> attribs;
   attribs.push_back(EGL_DEPTH_SIZE);
   attribs.push_back(depth_size);
   attribs.push_back(EGL_ALPHA_SIZE);
@@ -293,7 +296,7 @@ int32_t Display::CreateImage(ClientBuffer buffer,
   return -1;
 }
 
-void Display::DestroyImage(int32 id) {
+void Display::DestroyImage(int32_t id) {
   NOTIMPLEMENTED();
 }
 
@@ -305,26 +308,26 @@ int32_t Display::CreateGpuMemoryBufferImage(size_t width,
   return -1;
 }
 
-uint32 Display::InsertSyncPoint() {
+uint32_t Display::InsertSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-uint32 Display::InsertFutureSyncPoint() {
+uint32_t Display::InsertFutureSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-void Display::RetireSyncPoint(uint32 sync_point) {
+void Display::RetireSyncPoint(uint32_t sync_point) {
   NOTIMPLEMENTED();
 }
 
-void Display::SignalSyncPoint(uint32 sync_point,
+void Display::SignalSyncPoint(uint32_t sync_point,
                               const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
-void Display::SignalQuery(uint32 query, const base::Closure& callback) {
+void Display::SignalQuery(uint32_t query, const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
diff --git a/gpu/gles2_conform_support/egl/display.h b/gpu/gles2_conform_support/egl/display.h
index ffc96c4..66d0d5b 100644
--- a/gpu/gles2_conform_support/egl/display.h
+++ b/gpu/gles2_conform_support/egl/display.h
@@ -6,7 +6,10 @@
 #define GPU_GLES2_CONFORM_SUPPORT_EGL_DISPLAY_H_
 
 #include <EGL/egl.h>
+#include <stddef.h>
+#include <stdint.h>
 
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gpu_control.h"
@@ -88,12 +91,12 @@ class Display : private gpu::GpuControl {
                                      size_t height,
                                      unsigned internalformat,
                                      unsigned usage) override;
-  uint32 InsertSyncPoint() override;
-  uint32 InsertFutureSyncPoint() override;
-  void RetireSyncPoint(uint32 sync_point) override;
-  void SignalSyncPoint(uint32 sync_point,
+  uint32_t InsertSyncPoint() override;
+  uint32_t InsertFutureSyncPoint() override;
+  void RetireSyncPoint(uint32_t sync_point) override;
+  void SignalSyncPoint(uint32_t sync_point,
                        const base::Closure& callback) override;
-  void SignalQuery(uint32 query, const base::Closure& callback) override;
+  void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetLock(base::Lock*) override;
   bool IsGpuChannelLost() override;
   gpu::CommandBufferNamespace GetNamespaceID() const override;
diff --git a/gpu/gles2_conform_support/egl/egl.cc b/gpu/gles2_conform_support/egl/egl.cc
index 200f892..3a39728 100644
--- a/gpu/gles2_conform_support/egl/egl.cc
+++ b/gpu/gles2_conform_support/egl/egl.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <EGL/egl.h>
+#include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/environment.h"
diff --git a/gpu/gles2_conform_support/egl/surface.h b/gpu/gles2_conform_support/egl/surface.h
index 3b66de0..3db553e 100644
--- a/gpu/gles2_conform_support/egl/surface.h
+++ b/gpu/gles2_conform_support/egl/surface.h
@@ -7,7 +7,7 @@
 
 #include <EGL/egl.h>
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 
 namespace egl {
 
diff --git a/gpu/gles2_conform_support/gles2_conform_test.cc b/gpu/gles2_conform_support/gles2_conform_test.cc
index 42964e4..054d378 100644
--- a/gpu/gles2_conform_support/gles2_conform_test.cc
+++ b/gpu/gles2_conform_support/gles2_conform_test.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/gles2_conform_support/gles2_conform_test.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/at_exit.h"
@@ -47,7 +50,7 @@ bool RunGLES2ConformTest(const char* path) {
 
   // Set the bot config api based on the OS and command line
   base::CommandLine* current_cmd_line = base::CommandLine::ForCurrentProcess();
-  int32 config_os = bot_config.os();
+  int32_t config_os = bot_config.os();
   if ((config_os & gpu::GPUTestConfig::kOsWin) != 0) {
     std::string angle_renderer =
         current_cmd_line->HasSwitch("use-angle")
@@ -81,8 +84,8 @@ bool RunGLES2ConformTest(const char* path) {
   std::string path_string(path);
   std::string test_name;
   base::ReplaceChars(path_string, "\\/.", "_", &test_name);
-  int32 expectation =
-    test_expectations.GetTestExpectation(test_name, bot_config);
+  int32_t expectation =
+      test_expectations.GetTestExpectation(test_name, bot_config);
   if (expectation != gpu::GPUTestExpectationsParser::kGpuTestPass) {
     LOG(WARNING) << "Test " << test_name << " is bypassed";
     return true;
diff --git a/gpu/gles2_conform_support/native/main.cc b/gpu/gles2_conform_support/native/main.cc
index 1dc377b..313663a 100644
--- a/gpu/gles2_conform_support/native/main.cc
+++ b/gpu/gles2_conform_support/native/main.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
diff --git a/gpu/ipc/gpu_command_buffer_traits.cc b/gpu/ipc/gpu_command_buffer_traits.cc
index faed0e2..7580774 100644
--- a/gpu/ipc/gpu_command_buffer_traits.cc
+++ b/gpu/ipc/gpu_command_buffer_traits.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/ipc/gpu_command_buffer_traits.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/common/value_state.h"
diff --git a/gpu/khronos_glcts_support/khronos_glcts_test.cc b/gpu/khronos_glcts_support/khronos_glcts_test.cc
index 287b5d0..d75e824 100644
--- a/gpu/khronos_glcts_support/khronos_glcts_test.cc
+++ b/gpu/khronos_glcts_support/khronos_glcts_test.cc
@@ -4,6 +4,9 @@
 
 #include "gpu/khronos_glcts_support/khronos_glcts_test.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/at_exit.h"
@@ -50,7 +53,7 @@ bool RunKhronosGLCTSTest(const char* test_name) {
 
   const ::testing::TestInfo* const test_info =
       ::testing::UnitTest::GetInstance()->current_test_info();
-  int32 expectation =
+  int32_t expectation =
       test_expectations.GetTestExpectation(test_info->name(), bot_config);
   if (expectation != gpu::GPUTestExpectationsParser::kGpuTestPass) {
     LOG(WARNING) << "Test " << test_info->name() << " is bypassed";
diff --git a/gpu/perftests/measurements.cc b/gpu/perftests/measurements.cc
index 8909b28..0f5932f 100644
--- a/gpu/perftests/measurements.cc
+++ b/gpu/perftests/measurements.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/perftests/measurements.h"
 
+#include <stdint.h>
+
 #include "base/logging.h"
 #include "testing/perf/perf_test.h"
 #include "ui/gl/gpu_timing.h"
@@ -88,7 +90,7 @@ Measurement MeasurementTimers::GetAsMeasurement(const std::string& name) {
   if (!base::ThreadTicks::IsSupported()) {
     cpu_time_ = base::TimeDelta::FromMicroseconds(-1);
   }
-  int64 gpu_time = -1;
+  int64_t gpu_time = -1;
   if (gpu_timer_.get() != nullptr && gpu_timer_->IsAvailable()) {
     gpu_time = gpu_timer_->GetDeltaElapsed();
   }
diff --git a/gpu/perftests/texture_upload_perftest.cc b/gpu/perftests/texture_upload_perftest.cc
index a70e0f1..c3f3dfb 100644
--- a/gpu/perftests/texture_upload_perftest.cc
+++ b/gpu/perftests/texture_upload_perftest.cc
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <vector>
 
@@ -116,7 +119,7 @@ GLenum GLFormatToStorageFormat(GLenum format) {
 void GenerateTextureData(const gfx::Size& size,
                          int bytes_per_pixel,
                          const int seed,
-                         std::vector<uint8>* const pixels) {
+                         std::vector<uint8_t>* const pixels) {
   // Row bytes has to be multiple of 4 (GL_PACK_ALIGNMENT defaults to 4).
   int stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3;
   pixels->resize(size.height() * stride);
@@ -135,8 +138,8 @@ void GenerateTextureData(const gfx::Size& size,
 // RGBA buffer.
 bool CompareBufferToRGBABuffer(GLenum format,
                                const gfx::Size& size,
-                               const std::vector<uint8>& pixels,
-                               const std::vector<uint8>& rgba) {
+                               const std::vector<uint8_t>& pixels,
+                               const std::vector<uint8_t>& rgba) {
   int bytes_per_pixel = GLFormatBytePerPixel(format);
   int pixels_stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3;
   int rgba_stride = size.width() * GLFormatBytePerPixel(GL_RGBA);
@@ -144,7 +147,7 @@ bool CompareBufferToRGBABuffer(GLenum format,
     for (int x = 0; x < size.width(); ++x) {
       int rgba_index = y * rgba_stride + x * GLFormatBytePerPixel(GL_RGBA);
       int pixels_index = y * pixels_stride + x * bytes_per_pixel;
-      uint8 expected[4] = {0};
+      uint8_t expected[4] = {0};
       switch (format) {
         case GL_LUMINANCE:  // (L_t, L_t, L_t, 1)
           expected[1] = pixels[pixels_index];
@@ -330,7 +333,7 @@ class TextureUploadPerfTest : public testing::Test {
 
   void UploadTexture(GLuint texture_id,
                      const gfx::Size& size,
-                     const std::vector<uint8>& pixels,
+                     const std::vector<uint8_t>& pixels,
                      GLenum format,
                      const bool subimage) {
     if (subimage) {
@@ -350,7 +353,7 @@ class TextureUploadPerfTest : public testing::Test {
   // time elapsed in milliseconds.
   std::vector<Measurement> UploadAndDraw(GLuint texture_id,
                                          const gfx::Size& size,
-                                         const std::vector<uint8>& pixels,
+                                         const std::vector<uint8_t>& pixels,
                                          const GLenum format,
                                          const bool subimage) {
     MeasurementTimers tex_timers(gpu_timing_client_.get());
@@ -370,7 +373,7 @@ class TextureUploadPerfTest : public testing::Test {
     CheckNoGlError("glFinish");
     finish_timers.Record();
 
-    std::vector<uint8> pixels_rendered(size.GetArea() * 4);
+    std::vector<uint8_t> pixels_rendered(size.GetArea() * 4);
     glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError("glReadPixels");
@@ -396,7 +399,7 @@ class TextureUploadPerfTest : public testing::Test {
   void RunUploadAndDrawMultipleTimes(const gfx::Size& size,
                                      const GLenum format,
                                      const bool subimage) {
-    std::vector<uint8> pixels;
+    std::vector<uint8_t> pixels;
     base::SmallMap<std::map<std::string, Measurement>>
         aggregates;  // indexed by name
     int successful_runs = 0;
@@ -496,7 +499,7 @@ TEST_F(TextureUploadPerfTest, upload) {
 TEST_F(TextureUploadPerfTest, renaming) {
   gfx::Size texture_size(fbo_size_.width() / 2, fbo_size_.height() / 2);
 
-  std::vector<uint8> pixels[4];
+  std::vector<uint8_t> pixels[4];
   for (int i = 0; i < 4; ++i) {
     GenerateTextureData(texture_size, 4, i + 1, &pixels[i]);
   }
@@ -533,7 +536,7 @@ TEST_F(TextureUploadPerfTest, renaming) {
   glDeleteTextures(1, &texture_id);
 
   for (int i = 0; i < 4; ++i) {
-    std::vector<uint8> pixels_rendered(texture_size.GetArea() * 4);
+    std::vector<uint8_t> pixels_rendered(texture_size.GetArea() * 4);
     glReadPixels(texture_size.width() * positions[i].x(),
                  texture_size.height() * positions[i].y(), texture_size.width(),
                  texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
diff --git a/gpu/tools/compositor_model_bench/compositor_model_bench.cc b/gpu/tools/compositor_model_bench/compositor_model_bench.cc
index 7ee5e73..3d3d57f 100644
--- a/gpu/tools/compositor_model_bench/compositor_model_bench.cc
+++ b/gpu/tools/compositor_model_bench/compositor_model_bench.cc
@@ -22,7 +22,6 @@
 #include <vector>
 
 #include "base/at_exit.h"
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
diff --git a/gpu/tools/compositor_model_bench/forward_render_model.cc b/gpu/tools/compositor_model_bench/forward_render_model.cc
index 03e8b1e..ec7248f 100644
--- a/gpu/tools/compositor_model_bench/forward_render_model.cc
+++ b/gpu/tools/compositor_model_bench/forward_render_model.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/tools/compositor_model_bench/forward_render_model.h"
 
+#include <stddef.h>
+
 #include <cstdlib>
 #include <vector>
 
diff --git a/gpu/tools/compositor_model_bench/forward_render_model.h b/gpu/tools/compositor_model_bench/forward_render_model.h
index 5495c18..ec34948 100644
--- a/gpu/tools/compositor_model_bench/forward_render_model.h
+++ b/gpu/tools/compositor_model_bench/forward_render_model.h
@@ -7,7 +7,7 @@
 #ifndef GPU_TOOLS_COMPOSITOR_MODEL_BENCH_FORWARD_RENDER_MODEL_H_
 #define GPU_TOOLS_COMPOSITOR_MODEL_BENCH_FORWARD_RENDER_MODEL_H_
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/tools/compositor_model_bench/render_model_utils.h"
 #include "gpu/tools/compositor_model_bench/render_models.h"
diff --git a/gpu/tools/compositor_model_bench/render_model_utils.cc b/gpu/tools/compositor_model_bench/render_model_utils.cc
index 7e1eb5c..e73ebea 100644
--- a/gpu/tools/compositor_model_bench/render_model_utils.cc
+++ b/gpu/tools/compositor_model_bench/render_model_utils.cc
@@ -6,6 +6,9 @@
 
 #include "gpu/tools/compositor_model_bench/render_model_utils.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <cstdlib>
 #include <map>
 #include <set>
@@ -136,9 +139,9 @@ void TextureGenerator::GenerateImageForTexture(int texID,
   int bytes_per_pixel = FormatBytesPerPixel(format);
   DCHECK_LE(bytes_per_pixel, 4);
   int imgID = images_generated_++;
-  image_data_[imgID].reset(new uint8[width*height*bytes_per_pixel]);
+  image_data_[imgID].reset(new uint8_t[width * height * bytes_per_pixel]);
   // Pick random colors to use for this texture.
-  uint8 random_color[4];
+  uint8_t random_color[4];
   for (int c = 0; c < 4; ++c) {
     random_color[c] = std::rand() % 255;
   }
@@ -148,7 +151,7 @@ void TextureGenerator::GenerateImageForTexture(int texID,
       int pix_addr = (y * width + x) * bytes_per_pixel;
       for (int c = 0; c < bytes_per_pixel; ++c) {
         bool on = ((x/8) + (y/8)) % 2;
-        uint8 v = on ? random_color[c] : ~random_color[c];
+        uint8_t v = on ? random_color[c] : ~random_color[c];
         (image_data_[imgID])[pix_addr + c] = v;
       }
       if (bytes_per_pixel == 4) {    // Randomize alpha.
diff --git a/gpu/tools/compositor_model_bench/render_model_utils.h b/gpu/tools/compositor_model_bench/render_model_utils.h
index 8d6ed3c..9162768 100644
--- a/gpu/tools/compositor_model_bench/render_model_utils.h
+++ b/gpu/tools/compositor_model_bench/render_model_utils.h
@@ -7,6 +7,8 @@
 #ifndef GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_MODEL_UTILS_H_
 #define GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_MODEL_UTILS_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <vector>
@@ -21,7 +23,7 @@
 // texture ID's in the tree, replacing them with the matching new textures.
 class TextureGenerator : public RenderNodeVisitor {
  public:
-  typedef scoped_ptr<uint8[]> ImagePtr;
+  typedef scoped_ptr<uint8_t[]> ImagePtr;
   typedef std::vector<Tile>::iterator tile_iter;
 
   explicit TextureGenerator(RenderNode* root);
diff --git a/gpu/tools/compositor_model_bench/render_models.h b/gpu/tools/compositor_model_bench/render_models.h
index 9da592b..5d04a3f2 100644
--- a/gpu/tools/compositor_model_bench/render_models.h
+++ b/gpu/tools/compositor_model_bench/render_models.h
@@ -10,7 +10,7 @@
 
 #include "gpu/tools/compositor_model_bench/render_tree.h"
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 
 enum RenderModel {
diff --git a/gpu/tools/compositor_model_bench/render_tree.h b/gpu/tools/compositor_model_bench/render_tree.h
index a1b5321..5910474 100644
--- a/gpu/tools/compositor_model_bench/render_tree.h
+++ b/gpu/tools/compositor_model_bench/render_tree.h
@@ -8,6 +8,8 @@
 #ifndef GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_
 #define GPU_TOOLS_COMPOSITOR_MODEL_BENCH_RENDER_TREE_H_
 
+#include <stddef.h>
+
 #include <string>
 #include <vector>
 
diff --git a/gpu/tools/compositor_model_bench/shaders.cc b/gpu/tools/compositor_model_bench/shaders.cc
index 66f5aac..0ea6275 100644
--- a/gpu/tools/compositor_model_bench/shaders.cc
+++ b/gpu/tools/compositor_model_bench/shaders.cc
@@ -4,6 +4,8 @@
 
 #include "gpu/tools/compositor_model_bench/shaders.h"
 
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "gpu/tools/compositor_model_bench/render_model_utils.h"