Switch to standard integer types in mojo/.

mojo/gles2/command_buffer_client_impl.cc

 // Copyright 2014 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 "mojo/gles2/command_buffer_client_impl.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/mojo_buffer_backing.h"
 #include "components/mus/gles2/mojo_gpu_memory_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
@@ skipping 98 matching lines @@
   DCHECK_EQ(gpu::CommandBufferNamespace::MOJO, info->command_buffer_namespace);
   command_buffer_id_ = info->command_buffer_id;
   capabilities_ = info->capabilities.To<gpu::Capabilities>();
   return true;
 }
 
 gpu::CommandBuffer::State CommandBufferClientImpl::GetLastState() {
   return last_state_;
 }
 
-int32 CommandBufferClientImpl::GetLastToken() {
+int32_t CommandBufferClientImpl::GetLastToken() {
   TryUpdateState();
   return last_state_.token;
 }
 
-void CommandBufferClientImpl::Flush(int32 put_offset) {
+void CommandBufferClientImpl::Flush(int32_t put_offset) {
   if (last_put_offset_ == put_offset)
     return;
 
   last_put_offset_ = put_offset;
   command_buffer_->Flush(put_offset);
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void CommandBufferClientImpl::OrderingBarrier(int32_t put_offset) {
   // TODO(jamesr): Implement this more efficiently.
   Flush(put_offset);
 }
 
-void CommandBufferClientImpl::WaitForTokenInRange(int32 start, int32 end) {
+void CommandBufferClientImpl::WaitForTokenInRange(int32_t start, int32_t end) {
   TryUpdateState();
   while (!InRange(start, end, last_state_.token) &&
          last_state_.error == gpu::error::kNoError) {
     MakeProgressAndUpdateState();
     TryUpdateState();
   }
 }
 
-void CommandBufferClientImpl::WaitForGetOffsetInRange(int32 start, int32 end) {
+void CommandBufferClientImpl::WaitForGetOffsetInRange(int32_t start,
+                                                      int32_t end) {
   TryUpdateState();
   while (!InRange(start, end, last_state_.get_offset) &&
          last_state_.error == gpu::error::kNoError) {
     MakeProgressAndUpdateState();
     TryUpdateState();
   }
 }
 
-void CommandBufferClientImpl::SetGetBuffer(int32 shm_id) {
+void CommandBufferClientImpl::SetGetBuffer(int32_t shm_id) {
   command_buffer_->SetGetBuffer(shm_id);
   last_put_offset_ = -1;
 }
 
 scoped_refptr<gpu::Buffer> CommandBufferClientImpl::CreateTransferBuffer(
     size_t size,
-    int32* id) {
+    int32_t* id) {
   if (size >= std::numeric_limits<uint32_t>::max())
     return NULL;
 
   void* memory = NULL;
   mojo::ScopedSharedBufferHandle handle;
   mojo::ScopedSharedBufferHandle duped;
   if (!CreateMapAndDupSharedBuffer(size, &memory, &handle, &duped)) {
     if (last_state_.error == gpu::error::kNoError)
       last_state_.error = gpu::error::kLostContext;
     return NULL;
   }
 
   *id = ++next_transfer_buffer_id_;
 
   command_buffer_->RegisterTransferBuffer(*id, std::move(duped),
                                           static_cast<uint32_t>(size));
 
   scoped_ptr<gpu::BufferBacking> backing(
       new mus::MojoBufferBacking(std::move(handle), memory, size));
   scoped_refptr<gpu::Buffer> buffer(new gpu::Buffer(std::move(backing)));
   return buffer;
 }
 
-void CommandBufferClientImpl::DestroyTransferBuffer(int32 id) {
+void CommandBufferClientImpl::DestroyTransferBuffer(int32_t id) {
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities CommandBufferClientImpl::GetCapabilities() {
   return capabilities_;
 }
 
 int32_t CommandBufferClientImpl::CreateImage(ClientBuffer buffer,
                                              size_t width,
                                              size_t height,
                                              unsigned internalformat) {
-  int32 new_id = ++next_image_id_;
+  int32_t new_id = ++next_image_id_;
 
   mojo::SizePtr size = mojo::Size::New();
   size->width = static_cast<int32_t>(width);
   size->height = static_cast<int32_t>(height);
 
   mus::MojoGpuMemoryBufferImpl* gpu_memory_buffer =
       mus::MojoGpuMemoryBufferImpl::FromClientBuffer(buffer);
   gfx::GpuMemoryBufferHandle handle = gpu_memory_buffer->GetHandle();
 
   bool requires_sync_point = false;
@@ skipping 27 matching lines @@
     NOTIMPLEMENTED();
     // TODO(jam): need to support this if we support types other than
     // SHARED_MEMORY_BUFFER.
     //gpu_memory_buffer_manager->SetDestructionSyncPoint(gpu_memory_buffer,
     //                                                   InsertSyncPoint());
   }
 
   return new_id;
 }
 
-void CommandBufferClientImpl::DestroyImage(int32 id) {
+void CommandBufferClientImpl::DestroyImage(int32_t id) {
   command_buffer_->DestroyImage(id);
 }
 
 int32_t CommandBufferClientImpl::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(mus::MojoGpuMemoryBufferImpl::Create(
       gfx::Size(static_cast<int>(width), static_cast<int>(height)),
@@ skipping 124 matching lines @@
 
   // It is also safe to wait on the same context.
   if (sync_token->namespace_id() == gpu::CommandBufferNamespace::MOJO &&
       sync_token->command_buffer_id() == GetCommandBufferID())
     return true;
 
   return false;
 }
 
 }  // namespace gles2