Switch to standard integer types in ppapi/.

ppapi/proxy/ppb_graphics_3d_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/ppb_graphics_3d_proxy.h"
 
 #include "base/numerics/safe_conversions.h"
+#include "build/build_config.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_command_buffer_proxy.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::ResourceCreationAPI;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
-const int32 kCommandBufferSize = 1024 * 1024;
-const int32 kTransferBufferSize = 1024 * 1024;
+const int32_t kCommandBufferSize = 1024 * 1024;
+const int32_t kTransferBufferSize = 1024 * 1024;
 
 #if !defined(OS_NACL)
 base::SharedMemoryHandle TransportSHMHandle(
     Dispatcher* dispatcher,
     const base::SharedMemoryHandle& handle) {
   // Don't close the handle, it doesn't belong to us.
   return dispatcher->ShareSharedMemoryHandleWithRemote(handle);
 }
 #endif  // !defined(OS_NACL)
 
@@ skipping 73 matching lines @@
 }
 
 gpu::CommandBuffer* Graphics3D::GetCommandBuffer() {
   return command_buffer_.get();
 }
 
 gpu::GpuControl* Graphics3D::GetGpuControl() {
   return command_buffer_.get();
 }
 
-int32 Graphics3D::DoSwapBuffers() {
+int32_t Graphics3D::DoSwapBuffers() {
   gles2_impl()->SwapBuffers();
   IPC::Message* msg = new PpapiHostMsg_PPBGraphics3D_SwapBuffers(
       API_ID_PPB_GRAPHICS_3D, host_resource());
   msg->set_unblock(true);
   PluginDispatcher::GetForResource(this)->Send(msg);
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 PPB_Graphics3D_Proxy::PPB_Graphics3D_Proxy(Dispatcher* dispatcher)
@@ skipping 86 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBGraphics3D_SwapBuffersACK,
                         OnMsgSwapBuffersACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
 
   IPC_END_MESSAGE_MAP()
   // FIXME(brettw) handle bad messages!
   return handled;
 }
 
 #if !defined(OS_NACL)
-void PPB_Graphics3D_Proxy::OnMsgCreate(
-    PP_Instance instance,
-    HostResource share_context,
-    const std::vector<int32_t>& attribs,
-    HostResource* result,
-    gpu::Capabilities* capabilities,
-    SerializedHandle* shared_state,
-    uint64* command_buffer_id) {
+void PPB_Graphics3D_Proxy::OnMsgCreate(PP_Instance instance,
+                                       HostResource share_context,
+                                       const std::vector<int32_t>& attribs,
+                                       HostResource* result,
+                                       gpu::Capabilities* capabilities,
+                                       SerializedHandle* shared_state,
+                                       uint64_t* command_buffer_id) {
   shared_state->set_null_shmem();
   if (attribs.empty() ||
       attribs.back() != PP_GRAPHICS3DATTRIB_NONE ||
       !(attribs.size() & 1))
     return;  // Bad message.
 
   thunk::EnterResourceCreation enter(instance);
 
   if (!enter.succeeded())
     return;
 
   base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle();
   result->SetHostResource(
       instance,
       enter.functions()->CreateGraphics3DRaw(instance,
                                              share_context.host_resource(),
                                              &attribs.front(),
                                              capabilities,
                                              &handle,
                                              command_buffer_id));
   if (!result->is_null()) {
     shared_state->set_shmem(TransportSHMHandle(dispatcher(), handle),
                             sizeof(gpu::CommandBuffer::State));
   }
 }
 
-void PPB_Graphics3D_Proxy::OnMsgSetGetBuffer(
-    const HostResource& context,
-    int32 transfer_buffer_id) {
+void PPB_Graphics3D_Proxy::OnMsgSetGetBuffer(const HostResource& context,
+                                             int32_t transfer_buffer_id) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->SetGetBuffer(transfer_buffer_id);
 }
 
 void PPB_Graphics3D_Proxy::OnMsgWaitForTokenInRange(
     const HostResource& context,
-    int32 start,
-    int32 end,
+    int32_t start,
+    int32_t end,
     gpu::CommandBuffer::State* state,
     bool* success) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.failed()) {
     *success = false;
     return;
   }
   *state = enter.object()->WaitForTokenInRange(start, end);
   *success = true;
 }
 
 void PPB_Graphics3D_Proxy::OnMsgWaitForGetOffsetInRange(
     const HostResource& context,
-    int32 start,
-    int32 end,
+    int32_t start,
+    int32_t end,
     gpu::CommandBuffer::State* state,
     bool* success) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.failed()) {
     *success = false;
     return;
   }
   *state = enter.object()->WaitForGetOffsetInRange(start, end);
   *success = true;
 }
 
 void PPB_Graphics3D_Proxy::OnMsgAsyncFlush(const HostResource& context,
-                                           int32 put_offset) {
+                                           int32_t put_offset) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->Flush(put_offset);
 }
 
 void PPB_Graphics3D_Proxy::OnMsgCreateTransferBuffer(
     const HostResource& context,
-    uint32 size,
-    int32* id,
+    uint32_t size,
+    int32_t* id,
     SerializedHandle* transfer_buffer) {
   transfer_buffer->set_null_shmem();
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded()) {
     scoped_refptr<gpu::Buffer> buffer =
         enter.object()->CreateTransferBuffer(size, id);
     if (!buffer.get())
       return;
     gpu::SharedMemoryBufferBacking* backing =
         static_cast<gpu::SharedMemoryBufferBacking*>(buffer->backing());
     DCHECK(backing && backing->shared_memory());
     transfer_buffer->set_shmem(
         TransportSHMHandle(dispatcher(), backing->shared_memory()->handle()),
         base::checked_cast<uint32_t>(buffer->size()));
   } else {
     *id = -1;
   }
 }
 
 void PPB_Graphics3D_Proxy::OnMsgDestroyTransferBuffer(
     const HostResource& context,
-    int32 id) {
+    int32_t id) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->DestroyTransferBuffer(id);
 }
 
 void PPB_Graphics3D_Proxy::OnMsgSwapBuffers(const HostResource& context) {
   EnterHostFromHostResourceForceCallback<PPB_Graphics3D_API> enter(
       context, callback_factory_,
       &PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin, context);
   if (enter.succeeded())
     enter.SetResult(enter.object()->SwapBuffers(enter.callback()));
 }
 
 void PPB_Graphics3D_Proxy::OnMsgInsertSyncPoint(const HostResource& context,
-                                                uint32* sync_point) {
+                                                uint32_t* sync_point) {
   *sync_point = 0;
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     *sync_point = enter.object()->InsertSyncPoint();
 }
 
 void PPB_Graphics3D_Proxy::OnMsgInsertFutureSyncPoint(
     const HostResource& context,
-    uint32* sync_point) {
+    uint32_t* sync_point) {
   *sync_point = 0;
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     *sync_point = enter.object()->InsertFutureSyncPoint();
 }
 
 void PPB_Graphics3D_Proxy::OnMsgRetireSyncPoint(const HostResource& context,
-                                                uint32 sync_point) {
+                                                uint32_t sync_point) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.succeeded())
     enter.object()->RetireSyncPoint(sync_point);
 }
 #endif  // !defined(OS_NACL)
 
 void PPB_Graphics3D_Proxy::OnMsgSwapBuffersACK(const HostResource& resource,
                                               int32_t pp_error) {
   EnterPluginFromHostResource<PPB_Graphics3D_API> enter(resource);
   if (enter.succeeded())
     static_cast<Graphics3D*>(enter.object())->SwapBuffersACK(pp_error);
 }
 
 #if !defined(OS_NACL)
 void PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin(
     int32_t result,
     const HostResource& context) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics3D_SwapBuffersACK(
       API_ID_PPB_GRAPHICS_3D, context, result));
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi