Switch to standard integer types in gpu/.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h

 // 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.
 
 #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"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_context_mock.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #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_mock.h"
 #include "ui/gl/gl_surface_stub.h"
-#include "ui/gl/gl_mock.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace base {
 class CommandLine;
 }
 
 namespace gpu {
 namespace gles2 {
 
 class MemoryTracker;
 
 class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
  public:
   GLES2DecoderTestBase();
   virtual ~GLES2DecoderTestBase();
 
   // 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,
               ExecuteImmediateCmd(cmd, sizeof(client_id)));
   }
 
   // This template exists solely so we can specialize it for
   // certain commands.
   template <typename T, int id>
   void SpecializedSetup(bool valid) {
@@ skipping 31 matching lines @@
     return decoder_->DoCommands(
         1, (const void*)&cmd, ComputeNumEntries(sizeof(cmd) + data_size), 0);
   }
 
   template <typename T>
   T GetSharedMemoryAs() {
     return reinterpret_cast<T>(shared_memory_address_);
   }
 
   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);
   }
 
   Buffer* GetBuffer(GLuint service_id) {
     return group_->buffer_manager()->GetBuffer(service_id);
   }
 
   Framebuffer* GetFramebuffer(GLuint service_id) {
     return group_->framebuffer_manager()->GetFramebuffer(service_id);
   }
@@ skipping 58 matching lines @@
     return group_->feature_info();
   }
 
   ImageManager* GetImageManager() { return decoder_->GetImageManager(); }
 
   void DoCreateProgram(GLuint client_id, GLuint service_id);
   void DoCreateShader(GLenum shader_type, GLuint client_id, GLuint service_id);
   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;
   }
 
   struct InitState {
     InitState();
 
     std::string extensions;
     std::string gl_version;
@@ skipping 24 matching lines @@
   }
 
   ::testing::StrictMock< ::gfx::MockGLInterface>* GetGLMock() const {
     return gl_.get();
   }
 
   GLES2Decoder* GetDecoder() const {
     return decoder_.get();
   }
 
-  uint32 GetAndClearBackbufferClearBitsForTest() const {
+  uint32_t GetAndClearBackbufferClearBitsForTest() const {
     return decoder_->GetAndClearBackbufferClearBitsForTest();
   }
 
   typedef TestHelper::AttribInfo AttribInfo;
   typedef TestHelper::UniformInfo UniformInfo;
 
   void SetupShader(
       AttribInfo* attribs, size_t num_attribs,
       UniformInfo* uniforms, size_t num_uniforms,
       GLuint client_id, GLuint service_id,
@@ skipping 43 matching lines @@
   void DoDeleteBuffer(GLuint client_id, GLuint service_id);
   void DoDeleteFramebuffer(
       GLuint client_id, GLuint service_id,
       bool reset_draw, GLenum draw_target, GLuint draw_id,
       bool reset_read, GLenum read_target, GLuint read_id);
   void DoDeleteProgram(GLuint client_id, GLuint service_id);
   void DoDeleteRenderbuffer(GLuint client_id, GLuint service_id);
   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);
   void DoFramebufferRenderbuffer(
       GLenum target,
       GLenum attachment,
       GLenum renderbuffer_target,
       GLuint renderbuffer_client_id,
       GLuint renderbuffer_service_id,
       GLenum error);
@@ skipping 107 matching lines @@
 
   void AddExpectationsForSimulatedAttrib0(
       GLsizei num_vertices, GLuint buffer_id);
 
   void AddExpectationsForGenVertexArraysOES();
   void AddExpectationsForDeleteVertexArraysOES();
   void AddExpectationsForDeleteBoundVertexArraysOES();
   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) {
     Result* result = static_cast<Result*>(shared_memory_address_);
     Command cmd;
     cmd.Init(client_id, kSharedMemoryId, kSharedMemoryOffset);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     bool isObject = static_cast<bool>(*result);
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
     return isObject;
@@ skipping 29 matching lines @@
   static const GLuint kServiceTextureId = 304;
   static const GLuint kServiceProgramId = 305;
   static const GLuint kServiceSamplerId = 306;
   static const GLuint kServiceShaderId = 307;
   static const GLuint kServiceElementBufferId = 308;
   static const GLuint kServiceQueryId = 309;
   static const GLuint kServiceVertexArrayId = 310;
   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;
 
   static const GLuint kServiceCopyTextureChromiumShaderId = 701;
   static const GLuint kServiceCopyTextureChromiumProgramId = 721;
 
   static const GLuint kServiceCopyTextureChromiumTextureBufferId = 751;
   static const GLuint kServiceCopyTextureChromiumVertexBufferId = 752;
   static const GLuint kServiceCopyTextureChromiumFBOId = 753;
@@ skipping 100 matching lines @@
   GLuint client_texture_id_;
   GLuint client_element_buffer_id_;
   GLuint client_vertex_shader_id_;
   GLuint client_fragment_shader_id_;
   GLuint client_query_id_;
   GLuint client_vertexarray_id_;
   GLuint client_valuebuffer_id_;
   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_;
   bool cached_color_mask_green_;
   bool cached_color_mask_blue_;
   bool cached_color_mask_alpha_;
   bool cached_depth_mask_;
   GLuint cached_stencil_front_mask_;
   GLuint cached_stencil_back_mask_;
 
@@ skipping 14 matching lines @@
 
   int shader_language_version_;
 
  private:
   class MockCommandBufferEngine : public CommandBufferEngine {
    public:
     MockCommandBufferEngine();
 
     ~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_;
     scoped_refptr<gpu::Buffer> invalid_buffer_;
   };
 
   // MockGLStates is used to track GL states and emulate driver
   // behaviors on top of MockGLInterface.
   class MockGLStates {
    public:
@@ skipping 49 matching lines @@
 };
 
 // SpecializedSetup specializations that are needed in multiple unittest files.
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(bool valid);
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_