Switch to standard integer types in gpu/.

gpu/gles2_conform_support/egl/display.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.
 
 #include "gpu/gles2_conform_support/egl/display.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "gpu/gles2_conform_support/egl/config.h"
 #include "gpu/gles2_conform_support/egl/surface.h"
 
 namespace {
-const int32 kCommandBufferSize = 1024 * 1024;
-const int32 kTransferBufferSize = 512 * 1024;
+const int32_t kCommandBufferSize = 1024 * 1024;
+const int32_t kTransferBufferSize = 512 * 1024;
 }
 
 namespace egl {
 
 Display::Display(EGLNativeDisplayType display_id)
     : display_id_(display_id),
       is_initialized_(false),
 #if defined(COMMAND_BUFFER_GLES_LIB_SUPPORT_ONLY)
       exit_manager_(new base::AtExitManager),
 #endif
@@ skipping 118 matching lines @@
     return EGL_NO_SURFACE;
 
   gl_context_->MakeCurrent(gl_surface_.get());
 
   EGLint depth_size = 0;
   EGLint alpha_size = 0;
   EGLint stencil_size = 0;
   GetConfigAttrib(config, EGL_DEPTH_SIZE, &depth_size);
   GetConfigAttrib(config, EGL_ALPHA_SIZE, &alpha_size);
   GetConfigAttrib(config, EGL_STENCIL_SIZE, &stencil_size);
-  std::vector<int32> attribs;
+  std::vector<int32_t> attribs;
   attribs.push_back(EGL_DEPTH_SIZE);
   attribs.push_back(depth_size);
   attribs.push_back(EGL_ALPHA_SIZE);
   attribs.push_back(alpha_size);
   attribs.push_back(EGL_STENCIL_SIZE);
   attribs.push_back(stencil_size);
   // TODO(gman): Insert attrib_list. Although ES 1.1 says it must be null
   attribs.push_back(EGL_NONE);
 
   if (!decoder_->Initialize(gl_surface_.get(),
@@ skipping 111 matching lines @@
 }
 
 int32_t Display::CreateImage(ClientBuffer buffer,
                              size_t width,
                              size_t height,
                              unsigned internalformat) {
   NOTIMPLEMENTED();
   return -1;
 }
 
-void Display::DestroyImage(int32 id) {
+void Display::DestroyImage(int32_t id) {
   NOTIMPLEMENTED();
 }
 
 int32_t Display::CreateGpuMemoryBufferImage(size_t width,
                                             size_t height,
                                             unsigned internalformat,
                                             unsigned usage) {
   NOTIMPLEMENTED();
   return -1;
 }
 
-uint32 Display::InsertSyncPoint() {
+uint32_t Display::InsertSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-uint32 Display::InsertFutureSyncPoint() {
+uint32_t Display::InsertFutureSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-void Display::RetireSyncPoint(uint32 sync_point) {
+void Display::RetireSyncPoint(uint32_t sync_point) {
   NOTIMPLEMENTED();
 }
 
-void Display::SignalSyncPoint(uint32 sync_point,
+void Display::SignalSyncPoint(uint32_t sync_point,
                               const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
-void Display::SignalQuery(uint32 query, const base::Closure& callback) {
+void Display::SignalQuery(uint32_t query, const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 void Display::SetLock(base::Lock*) {
   NOTIMPLEMENTED();
 }
 
 bool Display::IsGpuChannelLost() {
   NOTIMPLEMENTED();
   return false;
@@ skipping 30 matching lines @@
 void Display::SignalSyncToken(const gpu::SyncToken& sync_token,
                               const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 bool Display::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace egl