Switch to standard integer types in components/, part 2 of 4.

components/nacl/loader/nacl_ipc_adapter.h

 // Copyright 2013 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 COMPONENTS_NACL_LOADER_NACL_IPC_ADAPTER_H_
 #define COMPONENTS_NACL_LOADER_NACL_IPC_ADAPTER_H_
 
+#include <stddef.h>
+
 #include <map>
 #include <queue>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/files/scoped_file.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner.h"
+#include "build/build_config.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_platform_file.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/proxy/nacl_message_scanner.h"
 
 struct NaClDesc;
 struct NaClImcTypedMsgHdr;
 struct PP_Size;
 
 namespace IPC {
@@ skipping 23 matching lines @@
 class NaClIPCAdapter : public base::RefCountedThreadSafe<NaClIPCAdapter>,
                        public IPC::Listener {
  public:
   // Chrome's IPC message format varies by platform, NaCl's does not. In
   // particular, the header has some extra fields on Posix platforms. Since
   // NaCl is a Posix environment, it gets that version of the header. This
   // header is duplicated here so we have a cross-platform definition of the
   // header we're exposing to NaCl.
 #pragma pack(push, 4)
   struct NaClMessageHeader : public base::Pickle::Header {
-    int32 routing;
-    uint32 type;
-    uint32 flags;
-    uint16 num_fds;
-    uint16 pad;
+    int32_t routing;
+    uint32_t type;
+    uint32_t flags;
+    uint16_t num_fds;
+    uint16_t pad;
   };
 #pragma pack(pop)
 
   typedef base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)>
       ResolveFileTokenReplyCallback;
 
   typedef base::Callback<void(uint64_t,  // file_token_lo
                               uint64_t,  // file_token_hi
                               ResolveFileTokenReplyCallback)>
       ResolveFileTokenCallback;
@@ skipping 52 matching lines @@
   // Make a NaClDesc that refers to this NaClIPCAdapter. Note that the returned
   // NaClDesc is reference-counted, and a reference is returned.
   NaClDesc* MakeNaClDesc();
 
 #if defined(OS_POSIX)
   base::ScopedFD TakeClientFileDescriptor();
 #endif
 
   // Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
-  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
 
  private:
   friend class base::RefCountedThreadSafe<NaClIPCAdapter>;
 
   class RewrittenMessage;
 
   // This is the data that must only be accessed inside the lock. This struct
   // just separates it so it's easier to see.
   struct LockedData {
@@ skipping 22 matching lines @@
   // by TaskRunner). This struct just separates it so it's easier to see.
   struct IOThreadData {
     IOThreadData();
     ~IOThreadData();
 
     scoped_ptr<IPC::Channel> channel_;
 
     // When we send a synchronous message (from untrusted to trusted), we store
     // its type here, so that later we can associate the reply with its type
     // for scanning.
-    typedef std::map<int, uint32> PendingSyncMsgMap;
+    typedef std::map<int, uint32_t> PendingSyncMsgMap;
     PendingSyncMsgMap pending_sync_msgs_;
   };
 
   ~NaClIPCAdapter() override;
 
   void SaveOpenResourceMessage(const IPC::Message& orig_msg,
                                IPC::PlatformFileForTransit ipc_fd,
                                base::FilePath file_path);
 
   bool RewriteMessage(const IPC::Message& msg, uint32_t type);
@@ skipping 32 matching lines @@
   // To be accessed on the I/O thread (via task runner) only.
   IOThreadData io_thread_data_;
 
   DISALLOW_COPY_AND_ASSIGN(NaClIPCAdapter);
 };
 
 // Export TranslatePepperFileReadWriteOpenFlags for testing.
 int TranslatePepperFileReadWriteOpenFlagsForTesting(int32_t pp_open_flags);
 
 #endif  // COMPONENTS_NACL_LOADER_NACL_IPC_ADAPTER_H_