Switch to standard integer types in gpu/.

gpu/command_buffer/tests/gl_manager.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/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted_memory.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.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"
@@ skipping 37 matching lines @@
 
   // Overridden from gfx::GpuMemoryBuffer:
   bool Map() override {
     DCHECK(!mapped_);
     mapped_ = true;
     return true;
   }
   void* memory(size_t plane) override {
     DCHECK(mapped_);
     DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
-    return reinterpret_cast<uint8*>(&bytes_->data().front()) +
-         gfx::BufferOffsetForBufferFormat(size_, format_, plane);
+    return reinterpret_cast<uint8_t*>(&bytes_->data().front()) +
+           gfx::BufferOffsetForBufferFormat(size_, format_, plane);
   }
   void Unmap() override {
     DCHECK(mapped_);
     mapped_ = false;
   }
   gfx::Size GetSize() const override { return size_; }
   gfx::BufferFormat GetFormat() const override { return format_; }
   int stride(size_t plane) const override {
     DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
     return gfx::RowSizeForBufferFormat(size_.width(), format_, plane);
@@ skipping 61 matching lines @@
       delete base_context_;
       base_context_ = NULL;
     }
   }
 }
 
 // static
 scoped_ptr<gfx::GpuMemoryBuffer> GLManager::CreateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format) {
-  std::vector<uint8> data(gfx::BufferSizeForBufferFormat(size, format), 0);
+  std::vector<uint8_t> data(gfx::BufferSizeForBufferFormat(size, format), 0);
   scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
   return make_scoped_ptr<gfx::GpuMemoryBuffer>(
       new GpuMemoryBufferImpl(bytes.get(), size, format));
 }
 
 void GLManager::Initialize(const GLManager::Options& options) {
   InitializeWithCommandLine(options, nullptr);
 }
 
 void GLManager::InitializeWithCommandLine(const GLManager::Options& options,
                                           base::CommandLine* command_line) {
-  const int32 kCommandBufferSize = 1024 * 1024;
+  const int32_t kCommandBufferSize = 1024 * 1024;
   const size_t kStartTransferBufferSize = 4 * 1024 * 1024;
   const size_t kMinTransferBufferSize = 1 * 256 * 1024;
   const size_t kMaxTransferBufferSize = 16 * 1024 * 1024;
 
   context_lost_allowed_ = options.context_lost_allowed;
 
   gles2::MailboxManager* mailbox_manager = NULL;
   if (options.share_mailbox_manager) {
     mailbox_manager = options.share_mailbox_manager->mailbox_manager();
   } else if (options.share_group_manager) {
@@ skipping 19 matching lines @@
   if (options.virtual_manager) {
     real_gl_context = options.virtual_manager->context();
   }
 
   mailbox_manager_ =
       mailbox_manager ? mailbox_manager : new gles2::MailboxManagerImpl;
   share_group_ =
       share_group ? share_group : new gfx::GLShareGroup;
 
   gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
-  std::vector<int32> attribs;
+  std::vector<int32_t> attribs;
   gles2::ContextCreationAttribHelper attrib_helper;
   attrib_helper.red_size = 8;
   attrib_helper.green_size = 8;
   attrib_helper.blue_size = 8;
   attrib_helper.alpha_size = 8;
   attrib_helper.depth_size = 16;
   attrib_helper.stencil_size = 8;
   attrib_helper.context_type = options.context_type;
 
   attrib_helper.Serialize(&attribs);
@@ skipping 197 matching lines @@
   if (!context_lost_allowed_) {
     ASSERT_EQ(::gpu::error::kNoError, state.error);
   }
 
   if (sync_point_manager_) {
     // Finish processing order number here.
     sync_point_order_data_->FinishProcessingOrderNumber(order_num);
   }
 }
 
-bool GLManager::GetBufferChanged(int32 transfer_buffer_id) {
+bool GLManager::GetBufferChanged(int32_t transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
 Capabilities GLManager::GetCapabilities() {
   return decoder_->GetCapabilities();
 }
 
-int32 GLManager::CreateImage(ClientBuffer buffer,
-                             size_t width,
-                             size_t height,
-                             unsigned internalformat) {
+int32_t GLManager::CreateImage(ClientBuffer buffer,
+                               size_t width,
+                               size_t height,
+                               unsigned internalformat) {
   GpuMemoryBufferImpl* gpu_memory_buffer =
       GpuMemoryBufferImpl::FromClientBuffer(buffer);
 
   scoped_refptr<gl::GLImageRefCountedMemory> image(
       new gl::GLImageRefCountedMemory(gfx::Size(width, height),
                                       internalformat));
   if (!image->Initialize(gpu_memory_buffer->bytes(),
                          gpu_memory_buffer->GetFormat())) {
     return -1;
   }
 
-  static int32 next_id = 1;
-  int32 new_id = next_id++;
+  static int32_t next_id = 1;
+  int32_t new_id = next_id++;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   image_manager->AddImage(image.get(), new_id);
   return new_id;
 }
 
-int32 GLManager::CreateGpuMemoryBufferImage(size_t width,
-                                            size_t height,
-                                            unsigned internalformat,
-                                            unsigned usage) {
+int32_t GLManager::CreateGpuMemoryBufferImage(size_t width,
+                                              size_t height,
+                                              unsigned internalformat,
+                                              unsigned usage) {
   DCHECK_EQ(usage, static_cast<unsigned>(GL_READ_WRITE_CHROMIUM));
   scoped_ptr<gfx::GpuMemoryBuffer> buffer = GLManager::CreateGpuMemoryBuffer(
       gfx::Size(width, height), gfx::BufferFormat::RGBA_8888);
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
-void GLManager::DestroyImage(int32 id) {
+void GLManager::DestroyImage(int32_t id) {
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   image_manager->RemoveImage(id);
 }
 
-uint32 GLManager::InsertSyncPoint() {
+uint32_t GLManager::InsertSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-uint32 GLManager::InsertFutureSyncPoint() {
+uint32_t GLManager::InsertFutureSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
-void GLManager::RetireSyncPoint(uint32 sync_point) {
+void GLManager::RetireSyncPoint(uint32_t sync_point) {
   NOTIMPLEMENTED();
 }
 
-void GLManager::SignalSyncPoint(uint32 sync_point,
+void GLManager::SignalSyncPoint(uint32_t sync_point,
                                 const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
-void GLManager::SignalQuery(uint32 query, const base::Closure& callback) {
+void GLManager::SignalQuery(uint32_t query, const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 void GLManager::SetLock(base::Lock*) {
   NOTIMPLEMENTED();
 }
 
 bool GLManager::IsGpuChannelLost() {
   NOTIMPLEMENTED();
   return false;
@@ skipping 30 matching lines @@
 void GLManager::SignalSyncToken(const gpu::SyncToken& sync_token,
                                 const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace gpu