Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/command_line.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.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
@@ skipping 139 matching lines @@
     cmds::StencilThenCoverStrokePathInstancedCHROMIUM cmd;
     GLuint* paths = GetSharedMemoryAs<GLuint*>();
     paths[0] = kClientPathId;
     cmd.Init(1, GL_UNSIGNED_INT, shared_memory_id_, shared_memory_offset_, 0,
              0x80, 0x80, GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM, GL_NONE, 0,
              0);
     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
   }
   {
     cmds::BindFragmentInputLocationCHROMIUMBucket cmd;
-    const uint32 kBucketId = 123;
+    const uint32_t kBucketId = 123;
     const GLint kLocation = 2;
     const char* kName = "testing";
     SetBucketAsCString(kBucketId, kName);
     cmd.Init(client_program_id_, kLocation, kBucketId);
     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
   }
   {
     cmds::ProgramPathFragmentInputGenCHROMIUM cmd;
     const GLint kLocation = 2;
     cmd.Init(client_program_id_, kLocation, 0, GL_NONE, 0, 0);
@@ skipping 64 matching lines @@
   void CallAllInstancedCommands(const InstancedTestcase& testcase) {
     // Note: for testcases that expect a call, We do not compare the 'paths'
     // array during EXPECT_CALL due to it being void*. Instead, we rely on the
     // fact that if the path base was not added correctly, the paths wouldn't
     // exists and the call wouldn't come through.
 
     bool copy_paths = false;  // Paths are copied for each call that has paths,
                               // 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*>();
       transforms_shm_id = shared_memory_id_;
       transforms_shm_offset = shared_memory_offset_;
       memcpy(transforms, testcase.transform_values,
              testcase.sizeof_transform_values);
     } else {
       DCHECK(testcase.sizeof_transform_values == 0);
     }
@@ skipping 131 matching lines @@
                      testcase.transform_type, transforms_shm_id,
                      transforms_shm_offset);
       EXPECT_EQ(testcase.expected_error, ExecuteCmd(stcsi_cmd));
       EXPECT_EQ(testcase.expected_gl_error, GetGLError());
     }
   }
 
   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;
     const GLuint kReference = 0xFF;
     const GLuint kTransformType = GL_AFFINE_3D_CHROMIUM;
     memcpy(paths_shm, paths, sizeof(GLuint) * num_paths);
     {
       cmds::StencilFillPathInstancedCHROMIUM sfi_cmd;
       sfi_cmd.Init(num_paths, GL_UNSIGNED_INT, paths_shm_id, paths_shm_offset,
                    kPathBase, kFillMode, kMask, kTransformType,
@@ skipping 1210 matching lines @@
     kPathsSHMIdInvalid = 1,
     kPathsSHMOffsetInvalid = 1 << 1,
     kTransformsHMIdInvalid = 1 << 2,
     kTransformsHMOffsetInvalid = 1 << 3,
     kFirstTestcase = kPathsSHMIdInvalid,
     kLastTestcase = kTransformsHMOffsetInvalid
   };
 
   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;
     }
     if (testcase & kPathsSHMOffsetInvalid) {
       paths_shm_offset = kInvalidSharedMemoryOffset;
     }
     if (testcase & kTransformsHMIdInvalid) {
       transforms_shm_id = kInvalidSharedMemoryId;
     }
     if (testcase & kTransformsHMOffsetInvalid) {
       transforms_shm_offset = kInvalidSharedMemoryOffset;
     }
     SCOPED_TRACE(testing::Message() << "InstancedInvalidSHMValues testcase "
                                     << testcase);
     CallAllInstancedCommandsWithInvalidSHM(
         kPathCount, kPaths, paths, paths_shm_id, paths_shm_offset,
         transforms_shm_id, transforms_shm_offset);
   }
 }
 
 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";
 
   SetBucketAsCString(kBucketId, kName);
   cmds::BindFragmentInputLocationCHROMIUMBucket cmd;
   cmd.Init(client_program_id_, kLocation, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check negative location.
@@ skipping 16 matching lines @@
   SetBucketAsCString(kBucketId, kBadName1);
   cmd.Init(client_program_id_, kLocation, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_extensions_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu