Switch to standard integer types in gpu/.

gpu/command_buffer/service/common_decoder.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_COMMON_DECODER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_COMMON_DECODER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <stack>
 #include <string>
+#include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/common/buffer.h"
 #include "gpu/command_buffer/service/cmd_parser.h"
 #include "gpu/gpu_export.h"
 
 // Forwardly declare a few GL types to avoid including GL header files.
 typedef int GLsizei;
 typedef int GLint;
 
@@ skipping 72 matching lines @@
                       std::vector<char*>* _string,
                       std::vector<GLint>* _length);
 
    private:
     bool OffsetSizeValid(size_t offset, size_t size) const {
       size_t temp = offset + size;
       return temp <= size_ && temp >= offset;
     }
 
     size_t size_;
-    ::scoped_ptr<int8[]> data_;
+    ::scoped_ptr<int8_t[]> data_;
 
     DISALLOW_COPY_AND_ASSIGN(Bucket);
   };
 
   CommonDecoder();
   ~CommonDecoder() override;
 
   // Sets the engine, to get shared memory buffers from, and to set the token
   // to.
   void set_engine(CommandBufferEngine* engine) {
     engine_ = engine;
   }
   CommandBufferEngine* engine() const { return engine_; }
 
   // Creates a bucket. If the bucket already exists returns that bucket.
-  Bucket* CreateBucket(uint32 bucket_id);
+  Bucket* CreateBucket(uint32_t bucket_id);
 
   // Gets a bucket. Returns NULL if the bucket does not exist.
-  Bucket* GetBucket(uint32 bucket_id) const;
+  Bucket* GetBucket(uint32_t bucket_id) const;
 
   // Gets the address of shared memory data, given a shared memory ID and an
   // offset. Also checks that the size is consistent with the shared memory
   // size.
   // Parameters:
   //   shm_id: the id of the shared memory buffer.
   //   offset: the offset of the data in the shared memory buffer.
   //   size: the size of the data.
   // Returns:
   //   NULL if shm_id isn't a valid shared memory buffer ID or if the size
@@ skipping 25 matching lines @@
       unsigned int command,
       unsigned int arg_count,
       const void* cmd_data);
 
   // Gets an name for a common command.
   const char* GetCommonCommandName(cmd::CommandId command_id) const;
 
  private:
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
-  #define COMMON_COMMAND_BUFFER_CMD_OP(name)             \
-     error::Error Handle##name(uint32 immediate_data_size, const void* data);
+#define COMMON_COMMAND_BUFFER_CMD_OP(name) \
+  error::Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   COMMON_COMMAND_BUFFER_CMDS(COMMON_COMMAND_BUFFER_CMD_OP)
 
   #undef COMMON_COMMAND_BUFFER_CMD_OP
 
   CommandBufferEngine* engine_;
 
-  typedef std::map<uint32, linked_ptr<Bucket> > BucketMap;
+  typedef std::map<uint32_t, linked_ptr<Bucket>> BucketMap;
   BucketMap buckets_;
 
-  typedef Error (CommonDecoder::*CmdHandler)(
-      uint32 immediate_data_size,
-      const void* data);
+  typedef Error (CommonDecoder::*CmdHandler)(uint32_t immediate_data_size,
+                                             const void* data);
 
   // A struct to hold info about each command.
   struct CommandInfo {
     CmdHandler cmd_handler;
-    uint8 arg_flags;   // How to handle the arguments for this command
-    uint8 cmd_flags;   // How to handle this command
-    uint16 arg_count;  // How many arguments are expected for this command.
+    uint8_t arg_flags;   // How to handle the arguments for this command
+    uint8_t cmd_flags;   // How to handle this command
+    uint16_t arg_count;  // How many arguments are expected for this command.
   };
 
   // A table of CommandInfo for all the commands.
   static const CommandInfo command_info[];
 
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_COMMON_DECODER_H_