--- a/dom/base/nsGlobalWindow.h
+++ b/dom/base/nsGlobalWindow.h
@@ -696,17 +696,17 @@ public:
   void GetGamepads(nsTArray<nsRefPtr<mozilla::dom::Gamepad> >& aGamepads);
   already_AddRefed<mozilla::dom::Gamepad> GetGamepad(uint32_t aIndex);
   void SetHasSeenGamepadInput(bool aHasSeen);
   bool HasSeenGamepadInput();
   void SyncGamepadState();
   static PLDHashOperator EnumGamepadsForSync(const uint32_t& aKey,
                                              mozilla::dom::Gamepad* aData,
                                              void* aUserArg);
-  static PLDHashOperator EnumGamepadsForGet(const PRUint32& aKey,
+  static PLDHashOperator EnumGamepadsForGet(const uint32_t& aKey,
                                             mozilla::dom::Gamepad* aData,
                                             void* aUserArg);
 #endif
 
   // Enable/disable updates for gamepad input.
   void EnableGamepadUpdates();
   void DisableGamepadUpdates();
 

--- a/tools/profiler/IOInterposer.cpp
+++ b/tools/profiler/IOInterposer.cpp
@@ -74,17 +74,17 @@ IOInterposer::Init()
   mModules.AppendElement(sqlModule);
   return true;
 }
 
 void
 IOInterposer::Enable(bool aEnable)
 {
   mozilla::MutexAutoLock lock(mMutex);
-  for (PRUint32 i = 0; i < mModules.Length(); ++i ) {
+  for (uint32_t i = 0; i < mModules.Length(); ++i ) {
     mModules[i]->Enable(aEnable);
   }
 }
 
 void
 IOInterposer::Register(IOInterposeObserver::Operation aOp,
                        IOInterposeObserver* aObserver)
 {
@@ -123,31 +123,31 @@ IOInterposer::Deregister(IOInterposeObse
 void
 IOInterposer::Observe(IOInterposeObserver::Operation aOp, double& aDuration,
                       const char* aModuleInfo)
 {
   MOZ_ASSERT(NS_IsMainThread());
   switch (aOp) {
     case IOInterposeObserver::OpRead:
       {
-        for (PRUint32 i = 0; i < mReadObservers.Length(); ++i) {
+        for (uint32_t i = 0; i < mReadObservers.Length(); ++i) {
           mReadObservers[i]->Observe(aOp, aDuration, aModuleInfo);
         }
       }
       break;
     case IOInterposeObserver::OpWrite:
       {
-        for (PRUint32 i = 0; i < mWriteObservers.Length(); ++i) {
+        for (uint32_t i = 0; i < mWriteObservers.Length(); ++i) {
           mWriteObservers[i]->Observe(aOp, aDuration, aModuleInfo);
         }
       }
       break;
     case IOInterposeObserver::OpFSync:
       {
-        for (PRUint32 i = 0; i < mFSyncObservers.Length(); ++i) {
+        for (uint32_t i = 0; i < mFSyncObservers.Length(); ++i) {
           mFSyncObservers[i]->Observe(aOp, aDuration, aModuleInfo);
         }
       }
       break;
     default:
       break;
   }
 }

--- a/tools/profiler/NSPRInterposer.cpp
+++ b/tools/profiler/NSPRInterposer.cpp
@@ -95,31 +95,31 @@ NSPRInterposer::Init(IOInterposeObserver
 }
 
 void
 NSPRInterposer::Enable(bool aEnable)
 {
   mEnabled = aEnable ? 1 : 0;
 }
 
-PRInt32 PR_CALLBACK
-NSPRInterposer::Read(PRFileDesc* aFd, void* aBuf, PRInt32 aAmt)
+int32_t PR_CALLBACK
+NSPRInterposer::Read(PRFileDesc* aFd, void* aBuf, int32_t aAmt)
 {
   // If we don't have valid pointers, something is very wrong.
   NS_ASSERTION(sSingleton, "NSPRInterposer::sSingleton not available!");
   NS_ASSERTION(sSingleton->mOrigReadFn, "mOrigReadFn not available!");
   NS_ASSERTION(sSingleton->mObserver, "NSPRInterposer not initialized!");
 
   NSPRAutoTimer timer(IOInterposeObserver::OpRead);
   return sSingleton->mOrigReadFn(aFd, aBuf, aAmt);
 }
 
 
-PRInt32 PR_CALLBACK
-NSPRInterposer::Write(PRFileDesc* aFd, const void* aBuf, PRInt32 aAmt)
+int32_t PR_CALLBACK
+NSPRInterposer::Write(PRFileDesc* aFd, const void* aBuf, int32_t aAmt)
 {
   // If we don't have valid pointers, something is very wrong.
   NS_ASSERTION(sSingleton, "NSPRInterposer::sSingleton not available!");
   NS_ASSERTION(sSingleton->mOrigWriteFn, "mOrigWriteFn not available!");
   NS_ASSERTION(sSingleton->mObserver, "NSPRInterposer not initialized!");
 
   NSPRAutoTimer timer(IOInterposeObserver::OpWrite);
   return sSingleton->mOrigWriteFn(aFd, aBuf, aAmt);

--- a/tools/profiler/NSPRInterposer.h
+++ b/tools/profiler/NSPRInterposer.h
@@ -39,19 +39,19 @@ public:
   ~NSPRInterposer();
   void Enable(bool aEnable);
 
 private:
   NSPRInterposer();
   bool Init(IOInterposeObserver* aObserver,
             IOInterposeObserver::Operation aOpsToInterpose);
 
-  static PRInt32 PR_CALLBACK Read(PRFileDesc* aFd, void* aBuf, PRInt32 aAmt);
-  static PRInt32 PR_CALLBACK Write(PRFileDesc* aFd, const void* aBuf,
-                                   PRInt32 aAmt);
+  static int32_t PR_CALLBACK Read(PRFileDesc* aFd, void* aBuf, int32_t aAmt);
+  static int32_t PR_CALLBACK Write(PRFileDesc* aFd, const void* aBuf,
+                                   int32_t aAmt);
   static PRStatus PR_CALLBACK FSync(PRFileDesc* aFd);
   static StaticAutoPtr<NSPRInterposer> sSingleton;
 
   friend class NSPRAutoTimer;
 
   IOInterposeObserver*  mObserver;
   PRIOMethods*          mFileIOMethods;
   Atomic<uint32_t,ReleaseAcquire> mEnabled;