Switch to standard integer types in sandbox/.

sandbox/win/src/sharedmem_ipc_server.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 <stddef.h>
+#include <stdint.h>
+
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
-#include "sandbox/win/src/sharedmem_ipc_server.h"
-#include "sandbox/win/src/sharedmem_ipc_client.h"
+#include "sandbox/win/src/crosscall_params.h"
+#include "sandbox/win/src/crosscall_server.h"
 #include "sandbox/win/src/sandbox.h"
 #include "sandbox/win/src/sandbox_types.h"
-#include "sandbox/win/src/crosscall_params.h"
-#include "sandbox/win/src/crosscall_server.h"
+#include "sandbox/win/src/sharedmem_ipc_client.h"
+#include "sandbox/win/src/sharedmem_ipc_server.h"
 
 namespace {
 // This handle must not be closed.
 volatile HANDLE g_alive_mutex = NULL;
 }
 
 namespace sandbox {
 
 SharedMemIPCServer::ServerControl::ServerControl() {
 }
@@ skipping 30 matching lines @@
   if (!thread_provider_->UnRegisterWaits(this)) {
     // Better to leak than to crash.
     return;
   }
   STLDeleteElements(&server_contexts_);
 
   if (client_control_)
     ::UnmapViewOfFile(client_control_);
 }
 
-bool SharedMemIPCServer::Init(void* shared_mem, uint32 shared_size,
-                              uint32 channel_size) {
+bool SharedMemIPCServer::Init(void* shared_mem,
+                              uint32_t shared_size,
+                              uint32_t channel_size) {
   // The shared memory needs to be at least as big as a channel.
   if (shared_size < channel_size) {
     return false;
   }
   // The channel size should be aligned.
   if (0 != (channel_size % 32)) {
     return false;
   }
 
   // Calculate how many channels we can fit in the shared memory.
@@ skipping 79 matching lines @@
     }
   }
 }
 
 // Fills up the list of arguments (args and ipc_params) for an IPC call.
 bool GetArgs(CrossCallParamsEx* params, IPCParams* ipc_params,
              void* args[kMaxIpcParams]) {
   if (kMaxIpcParams < params->GetParamsCount())
     return false;
 
-  for (uint32 i = 0; i < params->GetParamsCount(); i++) {
-    uint32 size;
+  for (uint32_t i = 0; i < params->GetParamsCount(); i++) {
+    uint32_t size;
     ArgType type;
     args[i] = params->GetRawParameter(i, &size, &type);
     if (args[i]) {
       ipc_params->args[i] = type;
       switch (type) {
         case WCHAR_TYPE: {
           scoped_ptr<base::string16> data(new base::string16);
           if (!params->GetParameterStr(i, data.get())) {
             args[i] = 0;
             ReleaseArgs(ipc_params, args);
             return false;
           }
           args[i] = data.release();
           break;
         }
         case UINT32_TYPE: {
-          uint32 data;
+          uint32_t data;
           if (!params->GetParameter32(i, &data)) {
             ReleaseArgs(ipc_params, args);
             return false;
           }
           IPCInt ipc_int(data);
           args[i] = ipc_int.AsVoidPtr();
           break;
         }
         case VOIDPTR_TYPE : {
           void* data;
@@ skipping 18 matching lines @@
     }
   }
   return true;
 }
 
 bool SharedMemIPCServer::InvokeCallback(const ServerControl* service_context,
                                         void* ipc_buffer,
                                         CrossCallReturn* call_result) {
   // Set the default error code;
   SetCallError(SBOX_ERROR_INVALID_IPC, call_result);
-  uint32 output_size = 0;
+  uint32_t output_size = 0;
   // Parse, verify and copy the message. The handler operates on a copy
   // of the message so the client cannot play dirty tricks by changing the
   // data in the channel while the IPC is being processed.
   scoped_ptr<CrossCallParamsEx> params(
       CrossCallParamsEx::CreateFromBuffer(ipc_buffer,
                                           service_context->channel_size,
                                           &output_size));
   if (!params.get())
     return false;
 
-  uint32 tag = params->GetTag();
+  uint32_t tag = params->GetTag();
   static_assert(0 == INVALID_TYPE, "incorrect type enum");
   IPCParams ipc_params = {0};
   ipc_params.ipc_tag = tag;
 
   void* args[kMaxIpcParams];
   if (!GetArgs(params.get(), &ipc_params, args))
     return false;
 
   IPCInfo ipc_info = {0};
   ipc_info.ipc_tag = tag;
@@ skipping 172 matching lines @@
   server_pong->Set(::CreateEventW(NULL, FALSE, FALSE, NULL));
   if (!::DuplicateHandle(::GetCurrentProcess(), server_pong->Get(),
                          target_process_, client_pong, kDesiredAccess, FALSE,
                          0)) {
     return false;
   }
   return true;
 }
 
 }  // namespace sandbox