Switch to standard integer types in sandbox/.

sandbox/win/src/sharedmem_ipc_server.h

 // 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.
 
 #ifndef SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_
 #define SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_
 
+#include <stdint.h>
+
 #include <list>
 
-#include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/win/scoped_handle.h"
 #include "sandbox/win/src/crosscall_params.h"
 #include "sandbox/win/src/crosscall_server.h"
 #include "sandbox/win/src/sharedmem_ipc_client.h"
 
 // IPC transport implementation that uses shared memory.
 // This is the server side
 //
 // The server side has knowledge about the layout of the shared memory
 // and the state transitions. Both are explained in sharedmem_ipc_client.h
@@ skipping 24 matching lines @@
   // target_process_id: process id of the target process.
   // thread_provider: a thread provider object.
   // dispatcher: an object that can service IPC calls.
   SharedMemIPCServer(HANDLE target_process, DWORD target_process_id,
                      ThreadProvider* thread_provider, Dispatcher* dispatcher);
 
   ~SharedMemIPCServer();
 
   // Initializes the server structures, shared memory structures and
   // creates the kernels events used to signal the IPC.
-  bool Init(void* shared_mem, uint32 shared_size, uint32 channel_size);
+  bool Init(void* shared_mem, uint32_t shared_size, uint32_t channel_size);
 
  private:
   // Allow tests to be marked DISABLED_. Note that FLAKY_ and FAILS_ prefixes
   // do not work with sandbox tests.
   FRIEND_TEST_ALL_PREFIXES(IPCTest, SharedMemServerTests);
   // When an event fires (IPC request). A thread from the ThreadProvider
   // will call this function. The context parameter should be the same as
   // provided when ThreadProvider::RegisterWait was called.
   static void __stdcall ThreadPingEventReady(void* context,
                                              unsigned char);
@@ skipping 11 matching lines @@
   // call or about threading issues.
   struct ServerControl {
     ServerControl();
     ~ServerControl();
 
     // This channel server ping event.
     base::win::ScopedHandle ping_event;
     // This channel server pong event.
     base::win::ScopedHandle pong_event;
     // The size of this channel.
-    uint32 channel_size;
+    uint32_t channel_size;
     // The pointer to the actual channel data.
     char* channel_buffer;
     // The pointer to the base of the shared memory.
     char* shared_base;
     // A pointer to this channel's client-side control structure this structure
     // lives in the shared memory.
     ChannelControl* channel;
     // the IPC dispatcher associated with this channel.
     Dispatcher* dispatcher;
     // The target process information associated with this channel.
@@ skipping 24 matching lines @@
 
   // The dispatcher handles 'ready' IPC calls.
   Dispatcher* call_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemIPCServer);
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_SRC_SHAREDMEM_IPC_SERVER_H_