Switch to standard integer types in gpu/.

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include "base/compiler_specific.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "gpu/command_buffer/client/query_tracker.h"
 #include "gpu/command_buffer/client/ring_buffer.h"
 #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/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "testing/gmock/include/gmock/gmock.h"
 
 #if !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
 using testing::_;
 using testing::AtLeast;
 using testing::AnyNumber;
 using testing::DoAll;
 using testing::InSequence;
@@ skipping 18 matching lines @@
 // Used to help set the transfer buffer result to SizedResult of a single value.
 template <typename T>
 class SizedResultHelper {
  public:
   explicit SizedResultHelper(T result)
       : size_(sizeof(result)) {
     memcpy(result_, &result, sizeof(T));
   }
 
  private:
-  uint32 size_;
+  uint32_t size_;
   char result_[sizeof(T)];
 };
 
 // Struct to make it easy to pass a vec4 worth of floats.
 struct FourFloats {
   FourFloats(float _x, float _y, float _z, float _w)
       : x(_x),
         y(_y),
         z(_z),
         w(_w) {
   }
 
   float x;
   float y;
   float z;
   float w;
 };
 
 #pragma pack(push, 1)
 // Struct that holds 7 characters.
 struct Str7 {
   char str[7];
 };
 #pragma pack(pop)
 
 class MockTransferBuffer : public TransferBufferInterface {
  public:
   struct ExpectedMemoryInfo {
-    uint32 offset;
-    int32 id;
-    uint8* ptr;
+    uint32_t offset;
+    int32_t id;
+    uint8_t* ptr;
   };
 
   MockTransferBuffer(
       CommandBuffer* command_buffer,
       unsigned int size,
       unsigned int result_size,
       unsigned int alignment,
       bool initialize_fail)
       : command_buffer_(command_buffer),
         size_(size),
@@ skipping 47 matching lines @@
 
   bool InSync() {
     return expected_buffer_index_ == actual_buffer_index_ &&
            expected_offset_ == actual_offset_;
   }
 
   ExpectedMemoryInfo GetExpectedMemory(size_t size) {
     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;
   }
 
   ExpectedMemoryInfo GetExpectedResultMemory(size_t size) {
     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;
   }
 
  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
     // reallocated.
     expected_buffer_index_ = (expected_buffer_index_ + 1) % kNumBuffers;
 
     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;
   }
 
   int GetExpectedResultBufferId() {
     return buffer_ids_[expected_buffer_index_];
   }
 
-  uint32 GetExpectedResultBufferOffset() {
+  uint32_t GetExpectedResultBufferOffset() {
     return expected_buffer_index_ * alignment_;
   }
 
   int GetExpectedTransferBufferId() {
     return buffer_ids_[expected_buffer_index_];
   }
 
   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);
 };
 
 bool MockTransferBuffer::Initialize(
     unsigned int starting_buffer_size,
     unsigned int result_size,
     unsigned int /* min_buffer_size */,
     unsigned int /* max_buffer_size */,
@@ skipping 31 matching lines @@
   EXPECT_TRUE(last_alloc_ == NULL);
 
   // Toggle which buffer we get each time to simulate the buffer being
   // reallocated.
   actual_buffer_index_ = (actual_buffer_index_ + 1) % kNumBuffers;
 
   size = std::min(static_cast<size_t>(size), MaxTransferBufferSize());
   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;
 
   // Make sure each buffer has a different offset.
   last_alloc_ = actual_buffer() + offset + actual_buffer_index_ * alignment_;
   return last_alloc_;
 }
 
 void* MockTransferBuffer::Alloc(unsigned int size) {
   EXPECT_LE(size, MaxTransferBufferSize());
   unsigned int temp = 0;
   void* p = AllocUpTo(size, &temp);
   EXPECT_EQ(temp, size);
   return p;
 }
 
 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) {
   EXPECT_EQ(last_alloc_, p);
   last_alloc_ = NULL;
 }
 
 void MockTransferBuffer::FreePendingToken(void* p, unsigned int /* token */) {
   EXPECT_EQ(last_alloc_, p);
   last_alloc_ = NULL;
@@ skipping 59 matching lines @@
   static void Delete(GLES2Implementation* gl_impl,
                      GLsizei n,
                      const GLuint* ids) {
     gl_impl->DeleteTextures(n, ids);
   }
 };
 
 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;
 
   static const GLint kMaxCombinedTextureImageUnits = 8;
   static const GLint kMaxCubeMapTextureSize = 64;
   static const GLint kMaxFragmentUniformVectors = 16;
   static const GLint kMaxRenderbufferSize = 64;
   static const GLint kMaxTextureImageUnits = 8;
   static const GLint kMaxTextureSize = 128;
   static const GLint kMaxVaryingVectors = 8;
@@ skipping 139 matching lines @@
     int token_;
   };
 
   GLES2ImplementationTest() : commands_(NULL) {}
 
   void SetUp() override;
   void TearDown() override;
 
   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;
       }
     }
     return true;
   }
 
   QueryTracker::Query* GetQuery(GLuint id) {
     return gl_->query_tracker_->GetQuery(id);
@@ skipping 77 matching lines @@
   }
 
   ExpectedMemoryInfo GetExpectedResultMemory(size_t size) {
     return transfer_buffer_->GetExpectedResultMemory(size);
   }
 
   ExpectedMemoryInfo GetExpectedMappedMemory(size_t size) {
     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;
   }
 
   // Sets the ProgramInfoManager. The manager will be owned
   // by the ShareGroup.
   void SetProgramInfoManager(ProgramInfoManager* manager) {
     gl_->share_group()->set_program_info_manager(manager);
   }
 
   int CheckError() {
     ExpectedMemoryInfo result =
         GetExpectedResultMemory(sizeof(cmds::GetError::Result));
     EXPECT_CALL(*command_buffer(), OnFlush())
         .WillOnce(SetMemory(result.ptr, GLuint(GL_NO_ERROR)))
         .RetiresOnSaturation();
     return gl_->GetError();
   }
 
   const std::string& GetLastError() {
     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);
   }
 
   bool AllowExtraTransferBufferSize() {
     return gl_->max_extra_transfer_buffer_size_ > 0;
   }
 
   TestContext test_contexts_[kNumTestContexts];
 
   scoped_refptr<ShareGroup> share_group_;
@@ skipping 110 matching lines @@
 
 void GLES2ImplementationStrictSharedTest::SetUp() {
   ContextInitOptions init_options;
   init_options.bind_generates_resource_client = false;
   init_options.bind_generates_resource_service = false;
   ASSERT_TRUE(Initialize(init_options));
 }
 
 // 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;
 const GLint GLES2ImplementationTest::kMaxFragmentUniformVectors;
 const GLint GLES2ImplementationTest::kMaxRenderbufferSize;
 const GLint GLES2ImplementationTest::kMaxTextureImageUnits;
 const GLint GLES2ImplementationTest::kMaxTextureSize;
 const GLint GLES2ImplementationTest::kMaxVaryingVectors;
 const GLint GLES2ImplementationTest::kMaxVertexAttribs;
 const GLint GLES2ImplementationTest::kMaxVertexTextureImageUnits;
@@ skipping 11 matching lines @@
 const GLuint GLES2ImplementationTest::kQueriesStartId;
 const GLuint GLES2ImplementationTest::kVertexArraysStartId;
 const GLuint GLES2ImplementationTest::kValuebuffersStartId;
 #endif
 
 TEST_F(GLES2ImplementationTest, Basic) {
   EXPECT_TRUE(gl_->share_group() != NULL);
 }
 
 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;
   }
 
   struct Cmds {
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token2;
     cmd::SetBucketSize set_bucket_size2;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
-  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32));
+  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32_t));
   ExpectedMemoryInfo mem2 = GetExpectedMemory(
       kTestSize - MaxTransferBufferSize());
 
   Cmds expected;
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.get_bucket_data.Init(
       kBucketId, MaxTransferBufferSize(),
       kTestSize - MaxTransferBufferSize(), mem2.id, mem2.offset);
   expected.set_bucket_size2.Init(kBucketId, 0);
   expected.set_token2.Init(GetNextToken());
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(DoAll(
           SetMemory(result1.ptr, kTestSize),
           SetMemoryFromArray(
               mem1.ptr, expected_data, MaxTransferBufferSize())))
       .WillOnce(SetMemoryFromArray(
           mem2.ptr, expected_data + MaxTransferBufferSize(),
           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());
   EXPECT_EQ(0, memcmp(expected_data, &data[0], data.size()));
 }
 
 TEST_F(GLES2ImplementationTest, GetShaderPrecisionFormat) {
   struct Cmds {
     cmds::GetShaderPrecisionFormat cmd;
   };
@@ skipping 64 matching lines @@
   gl_->GetShaderPrecisionFormat(GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT, range4,
                                 &precision4);
   const void* commands5 = GetPut();
   EXPECT_EQ(commands4, commands5);
   EXPECT_EQ(range4[0], 3);
   EXPECT_EQ(range4[1], 5);
   EXPECT_EQ(precision4, 7);
 }
 
 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;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetShaderSource get_shader_source;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
-  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32));
+  ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32_t));
 
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_shader_source.Init(kShaderId, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   char buf[sizeof(kString) + 1];
   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();
 
   GLsizei length = 0;
   gl_->GetShaderSource(kShaderId, sizeof(buf), &length, buf);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(sizeof(kString) - 1, static_cast<size_t>(length));
   EXPECT_STREQ(kString.str, buf);
   EXPECT_EQ(buf[sizeof(kString)], kBad);
 }
@@ skipping 135 matching lines @@
   gl_->DrawArraysInstancedANGLE(GL_POINTS, kFirst, kCount, 1);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 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;
     cmds::EnableVertexAttribArray enable2;
     cmds::BindBuffer bind_to_index_emu;
     cmds::BufferData set_index_size;
     cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
     cmds::BindBuffer bind_to_emu;
     cmds::BufferData set_size;
@@ skipping 62 matching lines @@
   gl_->DrawElements(GL_POINTS, kCount, GL_UNSIGNED_SHORT, indices);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffersIndexUint) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 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;
     cmds::EnableVertexAttribArray enable2;
     cmds::BindBuffer bind_to_index_emu;
     cmds::BufferData set_index_size;
     cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
     cmds::BindBuffer bind_to_emu;
     cmds::BufferData set_size;
@@ skipping 62 matching lines @@
   gl_->DrawElements(GL_POINTS, kCount, GL_UNSIGNED_INT, indices);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffersInvalidIndexUint) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 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;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
   const GLsizei kCount = 2;
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .Times(1)
@@ skipping 44 matching lines @@
   const GLsizei kClientStride = sizeof(verts[0]);
   const GLsizei kCount = 2;
   const GLsizei kSize1 =
       arraysize(verts) * kNumComponents1 * sizeof(verts[0][0]);
   const GLsizei kSize2 =
       arraysize(verts) * kNumComponents2 * sizeof(verts[0][0]);
   const GLsizei kEmuOffset1 = 0;
   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);
 
 
   Cmds expected;
   expected.enable1.Init(kAttribIndex1);
   expected.enable2.Init(kAttribIndex2);
   expected.bind_to_index.Init(GL_ELEMENT_ARRAY_BUFFER, kClientIndexBufferId);
   expected.get_max.Init(kClientIndexBufferId, kCount, GL_UNSIGNED_SHORT,
                         kIndexOffset, mem1.id, mem1.offset);
@@ skipping 27 matching lines @@
                     reinterpret_cast<const void*>(kIndexOffset));
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, DrawElementsInstancedANGLEClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 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;
     cmds::EnableVertexAttribArray enable2;
     cmds::VertexAttribDivisorANGLE divisor;
     cmds::BindBuffer bind_to_index_emu;
     cmds::BufferData set_index_size;
     cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
     cmds::BindBuffer bind_to_emu;
@@ skipping 256 matching lines @@
   Cmds expected;
   expected.read1.Init(
       0, 0, kWidth, kHeight / 2, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset,
       false);
   expected.set_token1.Init(GetNextToken());
   expected.read2.Init(
       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());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, ReadPixelsBadFormatType) {
   struct Cmds {
     cmds::ReadPixels read;
     cmd::SetToken set_token;
   };
   const GLint kBytesPerPixel = 4;
   const GLint kWidth = 2;
   const GLint kHeight = 2;
   const GLenum kFormat = 0;
   const GLenum kType = 0;
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(kWidth * kHeight * kBytesPerPixel);
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmds::ReadPixels::Result));
 
   Cmds expected;
   expected.read.Init(
       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)
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
 }
 
 TEST_F(GLES2ImplementationTest, FreeUnusedSharedMemory) {
   struct Cmds {
@@ skipping 23 matching lines @@
 
 TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUM) {
   struct Cmds {
     cmds::BufferSubData buf;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
-  uint32 offset = 0;
+  uint32_t offset = 0;
   Cmds expected;
   expected.buf.Init(
       kTarget, kOffset, kSize,
       command_buffer()->GetNextFreeTransferBufferId(), offset);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapBufferSubDataCHROMIUM(
       kTarget, kOffset, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem != NULL);
   gl_->UnmapBufferSubDataCHROMIUM(mem);
@@ skipping 43 matching lines @@
     cmd::SetToken set_token;
   };
   const GLint kLevel = 1;
   const GLint kXOffset = 2;
   const GLint kYOffset = 3;
   const GLint kWidth = 4;
   const GLint kHeight = 5;
   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,
       kType,
       command_buffer()->GetNextFreeTransferBufferId(), offset, GL_FALSE);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapTexSubImage2DCHROMIUM(
       GL_TEXTURE_2D,
       kLevel,
@@ skipping 116 matching lines @@
     kType,
     GL_READ_ONLY);
   EXPECT_TRUE(mem == NULL);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), gl_->GetError());
   const char* kPtr = "something";
   gl_->UnmapTexSubImage2DCHROMIUM(kPtr);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
 }
 
 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;
   const Str7 kString = {"foobar"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   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();
 
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_program_info.Init(kProgramId, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   gl_->GetProgramInfoCHROMIUM(kProgramId, sizeof(buf), &size, &buf);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
   EXPECT_EQ(sizeof(kString), static_cast<size_t>(size));
   EXPECT_STREQ(kString.str, buf);
   EXPECT_EQ(buf[sizeof(kString)], kBad);
 }
 
 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"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
       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)))
       .RetiresOnSaturation();
 
   // try bufsize not big enough.
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketStart get_bucket_start;
@@ skipping 18 matching lines @@
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
   ClearCommands();
   // try no size ptr.
   gl_->GetProgramInfoCHROMIUM(kProgramId, sizeof(buf), NULL, &buf);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
 }
 
 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;
   const Str7 kString = {"foobar"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   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();
 
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetUniformBlocksCHROMIUM get_uniform_blocks;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_uniform_blocks.Init(kProgramId, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   gl_->GetUniformBlocksCHROMIUM(kProgramId, sizeof(buf), &size, &buf);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
   EXPECT_EQ(sizeof(kString), static_cast<size_t>(size));
   EXPECT_STREQ(kString.str, buf);
   EXPECT_EQ(buf[sizeof(kString)], kBad);
 }
 
 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"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
       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)))
       .RetiresOnSaturation();
 
   // try bufsize not big enough.
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetUniformBlocksCHROMIUM get_uniform_blocks;
     cmd::GetBucketStart get_bucket_start;
@@ skipping 137 matching lines @@
 
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
   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)) {
     return false;
   }
 
   int r2_stride = static_cast<int>(padded_row_size);
 
   for (int y = 0; y < height; ++y) {
     if (memcmp(r1, r2, unpadded_row_size) != 0) {
@@ skipping 20 matching lines @@
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 4;
   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));
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   expected.set_token.Init(GetNextToken());
   gl_->TexImage2D(
@@ skipping 16 matching lines @@
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLsizei kWidth = 3;
   const GLint kBorder = 0;
   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));
   const GLsizei kMaxHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
   const GLsizei kHeight = kMaxHeight * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       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);
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   expected.set_token.Init(GetNextToken());
   gl_->TexImage2D(
@@ skipping 18 matching lines @@
     cmd::SetToken set_token2;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   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));
   const GLsizei kHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
   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);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(half_size);
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, 0, kWidth, kHeight / 2, kFormat, kType,
       mem1.id, mem1.offset, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, 0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
       mem2.id, mem2.offset, true);
   expected.set_token2.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer(), OnFlush())
   //     .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(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
       pixels.get() + kHeight / 2 * padded_row_size, mem2.ptr));
 }
@@ skipping 26 matching lines @@
     cmds::PixelStorei pixel_store_i;
     cmds::TexImage2D tex_image_2d;
   } texImageExpected;
 
   struct  {
     cmds::PixelStorei pixel_store_i;
     cmds::TexImage2D tex_image_2d;
     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));
       ASSERT_TRUE(size <= MaxTransferBufferSize());
       ExpectedMemoryInfo mem = GetExpectedMemory(size);
 
       const void* commands = GetPut();
       gl_->PixelStorei(GL_UNPACK_ALIGNMENT, alignment);
       gl_->PixelStorei(GL_UNPACK_ROW_LENGTH_EXT, kSrcWidth);
       gl_->PixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, kSrcSubImageX0);
@@ skipping 22 matching lines @@
             GL_TEXTURE_2D, kLevel, kFormat,
             kSrcSubImageWidth, kSrcSubImageHeight, kBorder, kFormat, kType,
             src_pixels.get());
         texImageExpected.pixel_store_i.Init(GL_UNPACK_ALIGNMENT, alignment);
         texImageExpected.tex_image_2d.Init(
             GL_TEXTURE_2D, kLevel, kFormat, kSrcSubImageWidth,
             kSrcSubImageHeight, kFormat, kType, mem.id, mem.offset);
         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();
     }
   }
 }
 
 // Test texture related calls with invalid arguments.
 TEST_F(GLES2ImplementationTest, TextureInvalidArguments) {
   struct Cmds {
     cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 4;
   const GLint kBorder = 0;
   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.
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sizeof(pixels));
 
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
@@ skipping 50 matching lines @@
   };
   const GLenum kTarget = GL_TEXTURE_3D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLenum kFormat = GL_RGB;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   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));
   // Makes sure we can just send over the data in one command.
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       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);
 
   Cmds expected;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
 
   gl_->TexImage3D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth, kBorder,
       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) {
   if (!AllowExtraTransferBufferSize()) {
     LOG(WARNING) << "Low memory device do not support MappedMem. Skipping test";
     return;
   }
 
   struct Cmds {
     cmds::TexImage3D tex_image_3d;
   };
   const GLenum kTarget = GL_TEXTURE_3D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLenum kFormat = GL_RGB;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   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));
   // Makes sure we can just send over the data in one command.
   const GLsizei kMaxHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
   const GLsizei kHeight = kMaxHeight * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       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);
 
   Cmds expected;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
       kFormat, kType, mem.id, mem.offset);
 
   gl_->TexImage3D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kDepth, kBorder,
       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) {
   // Set limit to 1 to effectively disable mapped memory.
   SetMappedMemoryLimit(1);
 
   struct Cmds {
     cmds::TexImage3D tex_image_3d;
     cmds::TexSubImage3D tex_sub_image_3d1;
     cmd::SetToken set_token;
     cmds::TexSubImage3D tex_sub_image_3d2;
   };
   const GLenum kTarget = GL_TEXTURE_3D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLenum kFormat = GL_RGB;
   const GLenum kType = GL_UNSIGNED_BYTE;
   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));
   // Makes sure the data is more than one command can hold.
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 3;
   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;
   expected.tex_image_3d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, 1, kFormat, kType, 0, 0);
   expected.tex_sub_image_3d1.Init(
       kTarget, kLevel, 0, 0, 0, kWidth, kHeight - 3, 1, kFormat, kType,
       mem1.id, mem1.offset, GL_TRUE);
   expected.tex_sub_image_3d2.Init(
       kTarget, kLevel, 0, kHeight - 3, 0, kWidth, 3, 1, kFormat, kType,
@@ skipping 21 matching lines @@
   const GLint kLevel = 0;
   const GLint kXOffset = 0;
   const GLint kYOffset = 0;
   const GLint kZOffset = 0;
   const GLenum kFormat = GL_RGB;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   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));
   const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 2;
   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);
   ExpectedMemoryInfo mem1_2 = GetExpectedMemory(second_size);
   ExpectedMemoryInfo mem2_1 = GetExpectedMemory(third_size);
   ExpectedMemoryInfo mem2_2 = GetExpectedMemory(fourth_size);
 
   Cmds expected;
   expected.tex_sub_image_3d1_1.Init(
       kTarget, kLevel, kXOffset, kYOffset, kZOffset,
@@ skipping 11 matching lines @@
       kWidth, 2, 1, kFormat, kType, mem2_2.id, mem2_2.offset, GL_FALSE);
   expected.set_token1.Init(GetNextToken());
   expected.set_token2.Init(GetNextToken());
   expected.set_token3.Init(GetNextToken());
 
   gl_->TexSubImage3D(
       kTarget, kLevel, kXOffset, kYOffset, kZOffset, kWidth, kHeight, kDepth,
       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
 // flushed by glFlush.
 TEST_F(GLES2ImplementationStrictSharedTest, FlushGenerationTestBuffers) {
   FlushGenerationTest<GenBuffersAPI>();
 }
 TEST_F(GLES2ImplementationStrictSharedTest, FlushGenerationTestFramebuffers) {
   FlushGenerationTest<GenFramebuffersAPI>();
 }
@@ skipping 35 matching lines @@
 TEST_F(GLES2ImplementationStrictSharedTest,
        CrossContextGenerationAutoFlushTestRenderbuffers) {
   CrossContextGenerationAutoFlushTest<GenRenderbuffersAPI>();
 }
 TEST_F(GLES2ImplementationStrictSharedTest,
        CrossContextGenerationAutoFlushTestTextures) {
   CrossContextGenerationAutoFlushTest<GenTexturesAPI>();
 }
 
 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 =
       "foobar "
       "GL_EXT_unpack_subimage "
       "GL_CHROMIUM_map_sub";
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     cmds::GetString get_string;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_string.Init(GL_EXTENSIONS, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   char buf[sizeof(kString) + 1];
   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();
 
   const GLubyte* result = gl_->GetString(GL_EXTENSIONS);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_STREQ(expected_str, reinterpret_cast<const char*>(result));
 }
 
 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;
     cmds::GetString get_string;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
     cmds::PixelStorei pixel_store;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
 
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_string.Init(GL_EXTENSIONS, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   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();
 
   gl_->PixelStorei(GL_PACK_REVERSE_ROW_ORDER_ANGLE, 1);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, CreateProgram) {
   struct Cmds {
     cmds::CreateProgram cmd;
   };
 
   Cmds expected;
   expected.cmd.Init(kProgramsAndShadersStartId);
   GLuint id = gl_->CreateProgram();
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(kProgramsAndShadersStartId, id);
 }
 
 TEST_F(GLES2ImplementationTest, BufferDataLargerThanTransferBuffer) {
   struct Cmds {
     cmds::BufferData set_size;
     cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
     cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
   };
   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);
 
   Cmds expected;
   expected.set_size.Init(
       GL_ARRAY_BUFFER, arraysize(buf), 0, 0, GL_DYNAMIC_DRAW);
   expected.copy_data1.Init(
       GL_ARRAY_BUFFER, 0, kUsableSize, mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
@@ skipping 501 matching lines @@
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, LimitSizeAndOffsetTo32Bit) {
   GLsizeiptr size;
   GLintptr offset;
   if (sizeof(size) <= 4 || sizeof(offset) <= 4)
     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);
 
   const char kSizeOverflowMessage[] = "size more than 32-bit";
   const char kOffsetOverflowMessage[] = "offset more than 32-bit";
 
   const GLfloat buf[] = { 1.0, 1.0, 1.0, 1.0 };
   const GLubyte indices[] = { 0 };
 
   const GLuint kClientArrayBufferId = 0x789;
@@ skipping 77 matching lines @@
 
   // VertexAttribPointer: offset
   gl_->VertexAttribPointer(
       kAttribIndex, 1, GL_FLOAT, GL_FALSE, kStride,
       reinterpret_cast<void*>(offset));
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_STREQ(kOffsetOverflowMessage, GetLastError().c_str());
 }
 
 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 =
       transfer_buffer_->RoundToAlignment(category_name.size() + 1);
   const size_t kPaddedString2Size =
       transfer_buffer_->RoundToAlignment(trace_name.size() + 1);
 
   gl_->TraceBeginCHROMIUM(category_name.c_str(), trace_name.c_str());
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
@@ skipping 547 matching lines @@
   init_options.bind_generates_resource_service = false;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
+#include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu