Switch to standard integer types in gpu/.

gpu/command_buffer/client/gles2_implementation.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_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "gpu/command_buffer/client/buffer_tracker.h"
 #include "gpu/command_buffer/client/client_context_state.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_impl_export.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ skipping 109 matching lines @@
     ~GLStaticState();
 
     typedef std::pair<GLenum, GLenum> ShaderPrecisionKey;
     typedef std::map<ShaderPrecisionKey,
                      cmds::GetShaderPrecisionFormat::Result>
         ShaderPrecisionMap;
     ShaderPrecisionMap shader_precisions;
   };
 
   // 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;
 
   // Size in bytes to issue async flush for transfer buffer.
   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;
 
   // GL names for the buffers used to emulate client side buffers.
   static const GLuint kClientSideArrayId = 0xFEDCBA98u;
   static const GLuint kClientSideElementArrayId = 0xFEDCBA99u;
 
   // Number of swap buffers allowed before waiting.
   static const size_t kMaxSwapBuffers = 2;
@@ skipping 39 matching lines @@
   void CommitOverlayPlanes() override;
   void ScheduleOverlayPlane(int plane_z_order,
                             gfx::OverlayTransform plane_transform,
                             unsigned overlay_texture_id,
                             const gfx::Rect& display_bounds,
                             const gfx::RectF& uv_rect) override;
   GLuint InsertFutureSyncPointCHROMIUM() override;
   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);
   GLint GetFragDataLocationHelper(GLuint program, const char* name);
   bool GetActiveAttribHelper(
       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
       GLint* size, GLenum* type, char* name);
   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);
   bool GetUniformIndicesHelper(
       GLuint program, GLsizei count, const char* const* names, GLuint* indices);
   bool GetActiveUniformsivHelper(
       GLuint program, GLsizei count, const GLuint* indices,
       GLenum pname, GLint* params);
   bool GetSyncivHelper(
       GLsync sync, GLenum pname, GLsizei bufsize, GLsizei* length,
       GLint* values);
   bool GetQueryObjectValueHelper(
       const char* function_name, GLuint id, GLenum pname, GLuint64* params);
 
   void FreeUnusedSharedMemory();
   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.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
   void SetErrorMessageCallback(
       GLES2ImplementationErrorMessageCallback* callback) {
     error_message_callback_ = callback;
   }
@@ skipping 135 matching lines @@
     GLES2Implementation* gles2_implementation_;
   };
 
   // Gets the value of the result.
   template <typename T>
   T GetResultAs() {
     return static_cast<T>(GetResultBuffer());
   }
 
   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();
   bool IsChromiumFramebufferMultisampleAvailable();
 
   bool IsExtensionAvailableHelper(
       const char* extension, ExtensionStatus* status);
 
   // Gets the GLError through our wrapper.
   GLenum GetGLError();
 
   // Sets our wrapper for the GLError.
   void SetGLError(GLenum error, const char* function_name, const char* msg);
   void SetGLErrorInvalidEnum(
       const char* function_name, GLenum value, const char* label);
 
   // Returns the last error and clears it. Useful for debugging.
   const std::string& GetLastError() {
     return last_error_;
   }
 
   // Waits for all commands to execute.
   void WaitForCmd();
 
   // TODO(gman): These bucket functions really seem like they belong in
   // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need
   // 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);
   bool IsFramebufferReservedId(GLuint id) { return false; }
   bool IsRenderbufferReservedId(GLuint id) { return false; }
   bool IsTextureReservedId(GLuint id) { return false; }
   bool IsVertexArrayReservedId(GLuint id) { return false; }
   bool IsProgramReservedId(GLuint id) { return false; }
   bool IsValuebufferReservedId(GLuint id) { return false; }
   bool IsSamplerReservedId(GLuint id) { return false; }
@@ skipping 71 matching lines @@
                                    GLsizei width,
                                    GLsizei height,
                                    GLenum internalformat);
   void DestroyImageCHROMIUMHelper(GLuint image_id);
   GLuint CreateGpuMemoryBufferImageCHROMIUMHelper(GLsizei width,
                                                   GLsizei height,
                                                   GLenum internalformat,
                                                   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);
 
   void WaitAllAsyncTexImage2DCHROMIUMHelper();
 
   void RestoreElementAndArrayBuffers(bool restore);
   void RestoreArrayBuffer(bool restrore);
 
   // 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);
   GLuint GetBoundBufferHelper(GLenum target);
   bool GetBooleanvHelper(GLenum pname, GLboolean* params);
   bool GetBufferParameteri64vHelper(
       GLenum target, GLenum pname, GLint64* params);
   bool GetBufferParameterivHelper(GLenum target, GLenum pname, GLint* params);
   bool GetFloatvHelper(GLenum pname, GLfloat* params);
   bool GetFramebufferAttachmentParameterivHelper(
@@ skipping 63 matching lines @@
 
   const std::string& GetLogPrefix() const;
 
   bool PrepareInstancedPathCommand(const char* function_name,
                                    GLsizei num_paths,
                                    GLenum path_name_type,
                                    const void* paths,
                                    GLenum transform_type,
                                    const GLfloat* transform_values,
                                    ScopedTransferBufferPtr* buffer,
-                                   uint32* out_paths_shm_id,
+                                   uint32_t* out_paths_shm_id,
                                    size_t* out_paths_offset,
-                                   uint32* out_transforms_shm_id,
+                                   uint32_t* out_transforms_shm_id,
                                    size_t* out_transforms_offset);
 #if defined(GL_CLIENT_FAIL_GL_ERRORS)
   void CheckGLError();
   void FailGLError(GLenum error);
 #else
   void CheckGLError() { }
   void FailGLError(GLenum /* error */) { }
 #endif
 
   void RemoveMappedBufferRangeByTarget(GLenum target);
   void RemoveMappedBufferRangeById(GLuint buffer);
   void ClearMappedBufferRangeMap();
 
   void DrawElementsImpl(GLenum mode, GLsizei count, GLenum type,
                         const void* indices, const char* func_name);
 
   GLES2Util util_;
   GLES2CmdHelper* helper_;
   TransferBufferInterface* transfer_buffer_;
   std::string last_error_;
   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_;
 
   GLStaticState static_state_;
   ClientContextState state_;
 
   // pack alignment as last set by glPixelStorei
   GLint pack_alignment_;
 
@@ skipping 52 matching lines @@
   GLuint bound_pixel_pack_transfer_buffer_id_;
   GLuint bound_pixel_unpack_transfer_buffer_id_;
 
   // Client side management for vertex array objects. Needed to correctly
   // track client side arrays.
   scoped_ptr<VertexArrayObjectManager> vertex_array_object_manager_;
 
   GLuint reserved_ids_[2];
 
   // Current GL error bits.
-  uint32 error_bits_;
+  uint32_t error_bits_;
 
   // Whether or not to print debugging info.
   bool debug_;
 
   // When true, the context is lost when a GL_OUT_OF_MEMORY error occurs.
   const bool lose_context_when_out_of_memory_;
 
   // Whether or not to support client side arrays.
   const bool support_client_side_arrays_;
 
   // Used to check for single threaded access.
   int use_count_;
 
   // Maximum amount of extra memory from the mapped memory pool to use when
   // needing to transfer something exceeding the default transfer buffer.
   // This should be 0 for low memory devices since they are already memory
   // constrained.
   const uint32_t max_extra_transfer_buffer_size_;
 
   // 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
   // have an enum for this so handle it separately.
   std::set<std::string> requestable_extensions_set_;
 
   typedef std::map<const void*, MappedBuffer> MappedBufferMap;
   MappedBufferMap mapped_buffers_;
 
   // TODO(zmo): Consolidate |mapped_buffers_| and |mapped_buffer_range_map_|.
@@ skipping 65 matching lines @@
 
 inline bool GLES2Implementation::GetTexParameterivHelper(
     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_