Switch to standard integer types in ppapi/.

ppapi/proxy/ppapi_command_buffer_proxy.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 "ppapi/proxy/ppapi_command_buffer_proxy.h"
 
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 31 matching lines @@
 
 bool PpapiCommandBufferProxy::Initialize() {
   return true;
 }
 
 gpu::CommandBuffer::State PpapiCommandBufferProxy::GetLastState() {
   ppapi::ProxyLock::AssertAcquiredDebugOnly();
   return last_state_;
 }
 
-int32 PpapiCommandBufferProxy::GetLastToken() {
+int32_t PpapiCommandBufferProxy::GetLastToken() {
   ppapi::ProxyLock::AssertAcquiredDebugOnly();
   TryUpdateState();
   return last_state_.token;
 }
 
-void PpapiCommandBufferProxy::Flush(int32 put_offset) {
+void PpapiCommandBufferProxy::Flush(int32_t put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   OrderingBarrier(put_offset);
   FlushInternal();
 }
 
-void PpapiCommandBufferProxy::OrderingBarrier(int32 put_offset) {
+void PpapiCommandBufferProxy::OrderingBarrier(int32_t put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (flush_info_->flush_pending && flush_info_->resource != resource_) {
     FlushInternal();
   }
 
   flush_info_->flush_pending = true;
   flush_info_->resource = resource_;
   flush_info_->put_offset = put_offset;
   pending_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
-void PpapiCommandBufferProxy::WaitForTokenInRange(int32 start, int32 end) {
+void PpapiCommandBufferProxy::WaitForTokenInRange(int32_t start, int32_t end) {
   TryUpdateState();
   if (!InRange(start, end, last_state_.token) &&
       last_state_.error == gpu::error::kNoError) {
     bool success = false;
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForTokenInRange(
              ppapi::API_ID_PPB_GRAPHICS_3D,
              resource_,
              start,
              end,
              &state,
              &success)))
       UpdateState(state, success);
   }
   DCHECK(InRange(start, end, last_state_.token) ||
          last_state_.error != gpu::error::kNoError);
 }
 
-void PpapiCommandBufferProxy::WaitForGetOffsetInRange(int32 start, int32 end) {
+void PpapiCommandBufferProxy::WaitForGetOffsetInRange(int32_t start,
+                                                      int32_t end) {
   TryUpdateState();
   if (!InRange(start, end, last_state_.get_offset) &&
       last_state_.error == gpu::error::kNoError) {
     bool success = false;
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForGetOffsetInRange(
              ppapi::API_ID_PPB_GRAPHICS_3D,
              resource_,
              start,
              end,
              &state,
              &success)))
       UpdateState(state, success);
   }
   DCHECK(InRange(start, end, last_state_.get_offset) ||
          last_state_.error != gpu::error::kNoError);
 }
 
-void PpapiCommandBufferProxy::SetGetBuffer(int32 transfer_buffer_id) {
+void PpapiCommandBufferProxy::SetGetBuffer(int32_t transfer_buffer_id) {
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_SetGetBuffer(
          ppapi::API_ID_PPB_GRAPHICS_3D, resource_, transfer_buffer_id));
   }
 }
 
 scoped_refptr<gpu::Buffer> PpapiCommandBufferProxy::CreateTransferBuffer(
     size_t size,
-    int32* id) {
+    int32_t* id) {
   *id = -1;
 
   if (last_state_.error != gpu::error::kNoError)
     return NULL;
 
   // Assuming we are in the renderer process, the service is responsible for
   // duplicating the handle. This might not be true for NaCl.
   ppapi::proxy::SerializedHandle handle(
       ppapi::proxy::SerializedHandle::SHARED_MEMORY);
   if (!Send(new PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
@@ skipping 20 matching lines @@
         last_state_.error = gpu::error::kOutOfBounds;
       *id = -1;
       return NULL;
     }
   }
 
   return gpu::MakeBufferFromSharedMemory(std::move(shared_memory),
                                          handle.size());
 }
 
-void PpapiCommandBufferProxy::DestroyTransferBuffer(int32 id) {
+void PpapiCommandBufferProxy::DestroyTransferBuffer(int32_t id) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new PpapiHostMsg_PPBGraphics3D_DestroyTransferBuffer(
       ppapi::API_ID_PPB_GRAPHICS_3D, resource_, id));
 }
 
 void PpapiCommandBufferProxy::SetLock(base::Lock*) {
   NOTIMPLEMENTED();
 }
@@ skipping 34 matching lines @@
 
 bool PpapiCommandBufferProxy::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
   return false;
 }
 
 int32_t PpapiCommandBufferProxy::GetExtraCommandBufferData() const {
   return 0;
 }
 
-uint32 PpapiCommandBufferProxy::InsertSyncPoint() {
-  uint32 sync_point = 0;
+uint32_t PpapiCommandBufferProxy::InsertSyncPoint() {
+  uint32_t sync_point = 0;
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_InsertSyncPoint(
          ppapi::API_ID_PPB_GRAPHICS_3D, resource_, &sync_point));
   }
   return sync_point;
 }
 
-uint32 PpapiCommandBufferProxy::InsertFutureSyncPoint() {
-  uint32 sync_point = 0;
+uint32_t PpapiCommandBufferProxy::InsertFutureSyncPoint() {
+  uint32_t sync_point = 0;
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_InsertFutureSyncPoint(
         ppapi::API_ID_PPB_GRAPHICS_3D, resource_, &sync_point));
   }
   return sync_point;
 }
 
-void PpapiCommandBufferProxy::RetireSyncPoint(uint32 sync_point) {
+void PpapiCommandBufferProxy::RetireSyncPoint(uint32_t sync_point) {
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_RetireSyncPoint(
         ppapi::API_ID_PPB_GRAPHICS_3D, resource_, sync_point));
   }
 }
 
-void PpapiCommandBufferProxy::SignalSyncPoint(uint32 sync_point,
+void PpapiCommandBufferProxy::SignalSyncPoint(uint32_t sync_point,
                                               const base::Closure& callback) {
   NOTREACHED();
 }
 
-void PpapiCommandBufferProxy::SignalQuery(uint32 query,
+void PpapiCommandBufferProxy::SignalQuery(uint32_t query,
                                           const base::Closure& callback) {
   NOTREACHED();
 }
 
 gpu::Capabilities PpapiCommandBufferProxy::GetCapabilities() {
   return capabilities_;
 }
 
-int32 PpapiCommandBufferProxy::CreateImage(ClientBuffer buffer,
-                                           size_t width,
-                                           size_t height,
-                                           unsigned internalformat) {
+int32_t PpapiCommandBufferProxy::CreateImage(ClientBuffer buffer,
+                                             size_t width,
+                                             size_t height,
+                                             unsigned internalformat) {
   NOTREACHED();
   return -1;
 }
 
-void PpapiCommandBufferProxy::DestroyImage(int32 id) {
+void PpapiCommandBufferProxy::DestroyImage(int32_t id) {
   NOTREACHED();
 }
 
-int32 PpapiCommandBufferProxy::CreateGpuMemoryBufferImage(
+int32_t PpapiCommandBufferProxy::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   NOTREACHED();
   return -1;
 }
 
 bool PpapiCommandBufferProxy::Send(IPC::Message* msg) {
   DCHECK(last_state_.error == gpu::error::kNoError);
@@ skipping 50 matching lines @@
   message->set_unblock(true);
   Send(message);
 
   flush_info_->flush_pending = false;
   flush_info_->resource.SetHostResource(0, 0);
   flushed_fence_sync_release_ = pending_fence_sync_release_;
 }
 
 }  // namespace proxy
 }  // namespace ppapi