Use stdint types everywhere

R=mark at https://breakpad.appspot.com/535002/

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1121 4c0a9323-5329-0410-9bdc-e9ce6186880e

117 files changed, 1385 insertions, 1379 deletions

diff --git a/src/client/linux/crash_generation/crash_generation_server.cc b/src/client/linux/crash_generation/crash_generation_server.cc
index ff891353..f1e16b1d 100644
--- a/src/client/linux/crash_generation/crash_generation_server.cc
+++ b/src/client/linux/crash_generation/crash_generation_server.cc
@@ -90,7 +90,7 @@ GetInodeForProcPath(ino_t* inode_out, const char* path)
   }
 
   char* endptr;
-  const u_int64_t inode_ul =
+  const uint64_t inode_ul =
       strtoull(buf + sizeof(kSocketLinkPrefix) - 1, &endptr, 10);
   if (*endptr != ']')
     return false;
diff --git a/src/client/linux/handler/exception_handler.cc b/src/client/linux/handler/exception_handler.cc
index e62219d3..55834e01 100644
--- a/src/client/linux/handler/exception_handler.cc
+++ b/src/client/linux/handler/exception_handler.cc
@@ -597,7 +597,7 @@ bool ExceptionHandler::WriteMinidump() {
 }
 
 void ExceptionHandler::AddMappingInfo(const string& name,
-                                      const u_int8_t identifier[sizeof(MDGUID)],
+                                      const uint8_t identifier[sizeof(MDGUID)],
                                       uintptr_t start_address,
                                       size_t mapping_size,
                                       size_t file_offset) {
diff --git a/src/client/linux/handler/exception_handler.h b/src/client/linux/handler/exception_handler.h
index bd510d9e..71554196 100644
--- a/src/client/linux/handler/exception_handler.h
+++ b/src/client/linux/handler/exception_handler.h
@@ -205,7 +205,7 @@ class ExceptionHandler {
   // a custom library loader is used that maps things in a way
   // that the linux dumper can't handle by reading the maps file.
   void AddMappingInfo(const string& name,
-                      const u_int8_t identifier[sizeof(MDGUID)],
+                      const uint8_t identifier[sizeof(MDGUID)],
                       uintptr_t start_address,
                       size_t mapping_size,
                       size_t file_offset);
diff --git a/src/client/linux/handler/exception_handler_unittest.cc b/src/client/linux/handler/exception_handler_unittest.cc
index d7176916..27a7a777 100644
--- a/src/client/linux/handler/exception_handler_unittest.cc
+++ b/src/client/linux/handler/exception_handler_unittest.cc
@@ -423,7 +423,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const int kOffset = kMemorySize / 2;
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
@@ -483,7 +483,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -491,11 +491,11 @@ TEST(ExceptionHandlerTest, InstructionPointerMemory) {
   ASSERT_TRUE(region);
 
   EXPECT_EQ(kMemorySize, region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t prefix_bytes[kOffset];
-  u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
+  uint8_t prefix_bytes[kOffset];
+  uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
   memset(prefix_bytes, 0, sizeof(prefix_bytes));
   memset(suffix_bytes, 0, sizeof(suffix_bytes));
   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
@@ -515,7 +515,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const int kOffset = 0;
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
@@ -575,7 +575,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -583,10 +583,10 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   ASSERT_TRUE(region);
 
   EXPECT_EQ(kMemorySize / 2, region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
+  uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
   memset(suffix_bytes, 0, sizeof(suffix_bytes));
   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
@@ -606,7 +606,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   // Use 4k here because the OS will hand out a single page even
   // if a smaller size is requested, and this test wants to
   // test the upper bound of the memory range.
-  const u_int32_t kMemorySize = 4096;  // bytes
+  const uint32_t kMemorySize = 4096;  // bytes
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
   const int kOffset = kMemorySize - sizeof(instructions);
@@ -665,7 +665,7 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -674,10 +674,10 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
 
   const size_t kPrefixSize = 128;  // bytes
   EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t prefix_bytes[kPrefixSize];
+  uint8_t prefix_bytes[kPrefixSize];
   memset(prefix_bytes, 0, sizeof(prefix_bytes));
   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
   EXPECT_TRUE(memcmp(bytes + kPrefixSize,
@@ -742,9 +742,9 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryNullPointer) {
 TEST(ExceptionHandlerTest, ModuleInfo) {
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
   const char* kMemoryName = "a fake module";
-  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
   };
@@ -998,15 +998,15 @@ TEST(ExceptionHandlerTest, GenerateMultipleDumpsWithPath) {
 
 // Test that an additional memory region can be added to the minidump.
 TEST(ExceptionHandlerTest, AdditionalMemory) {
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
 
   // Get some heap memory.
-  u_int8_t* memory = new u_int8_t[kMemorySize];
+  uint8_t* memory = new uint8_t[kMemorySize];
   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
   // Stick some data into the memory so the contents can be verified.
-  for (u_int32_t i = 0; i < kMemorySize; ++i) {
+  for (uint32_t i = 0; i < kMemorySize; ++i) {
     memory[i] = i % 255;
   }
 
@@ -1042,10 +1042,10 @@ TEST(ExceptionHandlerTest, AdditionalMemory) {
 // Test that a memory region that was previously registered
 // can be unregistered.
 TEST(ExceptionHandlerTest, AdditionalMemoryRemove) {
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
 
   // Get some heap memory.
-  u_int8_t* memory = new u_int8_t[kMemorySize];
+  uint8_t* memory = new uint8_t[kMemorySize];
   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
@@ -1109,7 +1109,7 @@ TEST(ExceptionHandlerTest, WriteMinidumpForChild) {
   // Check that the crashing thread is the main thread of |child|
   MinidumpException* exception = minidump.GetException();
   ASSERT_TRUE(exception);
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(exception->GetThreadID(&thread_id));
   EXPECT_EQ(child, static_cast<int32_t>(thread_id));
 
diff --git a/src/client/linux/minidump_writer/minidump_writer.cc b/src/client/linux/minidump_writer/minidump_writer.cc
index 92632014..600e0a11 100644
--- a/src/client/linux/minidump_writer/minidump_writer.cc
+++ b/src/client/linux/minidump_writer/minidump_writer.cc
@@ -333,7 +333,7 @@ void CPUFillFromThreadInfo(MDRawContextARM* out,
   out->cpsr = 0;
 #if !defined(__ANDROID__)
   out->float_save.fpscr = info.fpregs.fpsr |
-    (static_cast<u_int64_t>(info.fpregs.fpcr) << 32);
+    (static_cast<uint64_t>(info.fpregs.fpcr) << 32);
   // TODO: sort this out, actually collect floating point registers
   my_memset(&out->float_save.regs, 0, sizeof(out->float_save.regs));
   my_memset(&out->float_save.extra, 0, sizeof(out->float_save.extra));
@@ -535,8 +535,8 @@ class MinidumpWriter {
   void PopSeccompStackFrame(RawContextCPU* cpu, const MDRawThread& thread,
                             uint8_t* stack_copy) {
 #if defined(__x86_64)
-    u_int64_t bp = cpu->rbp;
-    u_int64_t top = thread.stack.start_of_memory_range;
+    uint64_t bp = cpu->rbp;
+    uint64_t top = thread.stack.start_of_memory_range;
     for (int i = 4; i--; ) {
       if (bp < top ||
           bp + sizeof(bp) > thread.stack.start_of_memory_range +
@@ -546,7 +546,7 @@ class MinidumpWriter {
       }
       uint64_t old_top = top;
       top = bp;
-      u_int8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
+      uint8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
       my_memcpy(&bp, bp_addr, sizeof(bp));
       if (bp == 0xDEADBEEFDEADBEEFull) {
         struct {
@@ -598,8 +598,8 @@ class MinidumpWriter {
       }
     }
 #elif defined(__i386)
-    u_int32_t bp = cpu->ebp;
-    u_int32_t top = thread.stack.start_of_memory_range;
+    uint32_t bp = cpu->ebp;
+    uint32_t top = thread.stack.start_of_memory_range;
     for (int i = 4; i--; ) {
       if (bp < top ||
           bp + sizeof(bp) > thread.stack.start_of_memory_range +
@@ -609,7 +609,7 @@ class MinidumpWriter {
       }
       uint32_t old_top = top;
       top = bp;
-      u_int8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
+      uint8_t* bp_addr = stack_copy + bp - thread.stack.start_of_memory_range;
       my_memcpy(&bp, bp_addr, sizeof(bp));
       if (bp == 0xDEADBEEFu) {
         struct {
@@ -721,7 +721,7 @@ class MinidumpWriter {
 
         // Copy 256 bytes around crashing instruction pointer to minidump.
         const size_t kIPMemorySize = 256;
-        u_int64_t ip = GetInstructionPointer();
+        uint64_t ip = GetInstructionPointer();
         // Bound it to the upper and lower bounds of the memory map
         // it's contained within. If it's not in mapped memory,
         // don't bother trying to write it.
@@ -921,7 +921,7 @@ class MinidumpWriter {
                      bool member,
                      unsigned int mapping_id,
                      MDRawModule& mod,
-                     const u_int8_t* identifier) {
+                     const uint8_t* identifier) {
     my_memset(&mod, 0, MD_MODULE_SIZE);
 
     mod.base_of_image = mapping.start_addr;
diff --git a/src/client/linux/minidump_writer/minidump_writer.h b/src/client/linux/minidump_writer/minidump_writer.h
index 790ff723..c9e150ae 100644
--- a/src/client/linux/minidump_writer/minidump_writer.h
+++ b/src/client/linux/minidump_writer/minidump_writer.h
@@ -46,7 +46,7 @@ class ExceptionHandler;
 
 struct MappingEntry {
   MappingInfo first;
-  u_int8_t second[sizeof(MDGUID)];
+  uint8_t second[sizeof(MDGUID)];
 };
 
 // A list of <MappingInfo, GUID>
diff --git a/src/client/linux/minidump_writer/minidump_writer_unittest.cc b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
index d884a42b..ace7f350 100644
--- a/src/client/linux/minidump_writer/minidump_writer_unittest.cc
+++ b/src/client/linux/minidump_writer/minidump_writer_unittest.cc
@@ -131,9 +131,9 @@ TEST(MinidumpWriterTest, MappingInfo) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t memory_size = sysconf(_SC_PAGESIZE);
+  const uint32_t memory_size = sysconf(_SC_PAGESIZE);
   const char* kMemoryName = "a fake module";
-  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
   };
@@ -213,7 +213,7 @@ TEST(MinidumpWriterTest, MappingInfo) {
   EXPECT_EQ(kMemoryName, module->code_file());
   EXPECT_EQ(module_identifier, module->debug_identifier());
 
-  u_int32_t len;
+  uint32_t len;
   // These streams are expected to be there
   EXPECT_TRUE(minidump.SeekToStreamType(MD_THREAD_LIST_STREAM, &len));
   EXPECT_TRUE(minidump.SeekToStreamType(MD_MEMORY_LIST_STREAM, &len));
@@ -241,7 +241,7 @@ TEST(MinidumpWriterTest, MappingInfoContained) {
   // data from the minidump afterwards.
   const int32_t memory_size = sysconf(_SC_PAGESIZE);
   const char* kMemoryName = "a fake module";
-  const u_int8_t kModuleGUID[sizeof(MDGUID)] = {
+  const uint8_t kModuleGUID[sizeof(MDGUID)] = {
     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
   };
@@ -435,15 +435,15 @@ TEST(MinidumpWriterTest, AdditionalMemory) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = sysconf(_SC_PAGESIZE);
+  const uint32_t kMemorySize = sysconf(_SC_PAGESIZE);
 
   // Get some heap memory.
-  u_int8_t* memory = new u_int8_t[kMemorySize];
+  uint8_t* memory = new uint8_t[kMemorySize];
   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
   // Stick some data into the memory so the contents can be verified.
-  for (u_int32_t i = 0; i < kMemorySize; ++i) {
+  for (uint32_t i = 0; i < kMemorySize; ++i) {
     memory[i] = i % 255;
   }
 
diff --git a/src/client/mac/handler/minidump_generator.cc b/src/client/mac/handler/minidump_generator.cc
index fac1a60b..85c53ebb 100644
--- a/src/client/mac/handler/minidump_generator.cc
+++ b/src/client/mac/handler/minidump_generator.cc
@@ -410,7 +410,7 @@ bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
   }
 }
 
-u_int64_t MinidumpGenerator::CurrentPCForStack(
+uint64_t MinidumpGenerator::CurrentPCForStack(
     breakpad_thread_state_data_t state) {
   switch (cpu_type_) {
 #ifdef HAS_ARM_SUPPORT
@@ -444,7 +444,7 @@ bool MinidumpGenerator::WriteStackARM(breakpad_thread_state_data_t state,
   return WriteStackFromStartAddress(start_addr, stack_location);
 }
 
-u_int64_t
+uint64_t
 MinidumpGenerator::CurrentPCForStackARM(breakpad_thread_state_data_t state) {
   arm_thread_state_t *machine_state =
       reinterpret_cast<arm_thread_state_t *>(state);
@@ -510,7 +510,7 @@ bool MinidumpGenerator::WriteStackPPC64(breakpad_thread_state_data_t state,
   return WriteStackFromStartAddress(start_addr, stack_location);
 }
 
-u_int64_t
+uint64_t
 MinidumpGenerator::CurrentPCForStackPPC(breakpad_thread_state_data_t state) {
   ppc_thread_state_t *machine_state =
       reinterpret_cast<ppc_thread_state_t *>(state);
@@ -518,7 +518,7 @@ MinidumpGenerator::CurrentPCForStackPPC(breakpad_thread_state_data_t state) {
   return REGISTER_FROM_THREADSTATE(machine_state, srr0);
 }
 
-u_int64_t
+uint64_t
 MinidumpGenerator::CurrentPCForStackPPC64(breakpad_thread_state_data_t state) {
   ppc_thread_state64_t *machine_state =
       reinterpret_cast<ppc_thread_state64_t *>(state);
@@ -672,7 +672,7 @@ bool MinidumpGenerator::WriteStackX86_64(breakpad_thread_state_data_t state,
   return WriteStackFromStartAddress(start_addr, stack_location);
 }
 
-u_int64_t
+uint64_t
 MinidumpGenerator::CurrentPCForStackX86(breakpad_thread_state_data_t state) {
   i386_thread_state_t *machine_state =
       reinterpret_cast<i386_thread_state_t *>(state);
@@ -680,7 +680,7 @@ MinidumpGenerator::CurrentPCForStackX86(breakpad_thread_state_data_t state) {
   return REGISTER_FROM_THREADSTATE(machine_state, eip);
 }
 
-u_int64_t
+uint64_t
 MinidumpGenerator::CurrentPCForStackX86_64(breakpad_thread_state_data_t state) {
   x86_thread_state64_t *machine_state =
       reinterpret_cast<x86_thread_state64_t *>(state);
@@ -764,7 +764,7 @@ bool MinidumpGenerator::WriteContextX86_64(
   // not used in the flags register.  Since the minidump format
   // specifies 32 bits for the flags register, we can truncate safely
   // with no loss.
-  context_ptr->eflags = static_cast<u_int32_t>(REGISTER_FROM_THREADSTATE(machine_state, rflags));
+  context_ptr->eflags = static_cast<uint32_t>(REGISTER_FROM_THREADSTATE(machine_state, rflags));
   AddReg(cs);
   AddReg(fs);
   AddReg(gs);
@@ -899,7 +899,7 @@ bool MinidumpGenerator::WriteMemoryListStream(
       = static_cast<mach_msg_type_number_t>(sizeof(state));
 
     if (GetThreadState(exception_thread_, state, &stateCount)) {
-      u_int64_t ip = CurrentPCForStack(state);
+      uint64_t ip = CurrentPCForStack(state);
       // Bound it to the upper and lower bounds of the region
       // it's contained within. If it's not in a known memory region,
       // don't bother trying to write it.
@@ -1162,7 +1162,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
       return false;
 
     module->base_of_image = image->GetVMAddr() + image->GetVMAddrSlide();
-    module->size_of_image = static_cast<u_int32_t>(image->GetVMSize());
+    module->size_of_image = static_cast<uint32_t>(image->GetVMSize());
     module->module_name_rva = string_location.rva;
 
     // We'll skip the executable module, because they don't have
@@ -1228,7 +1228,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
             return false;
 
           module->base_of_image = seg->vmaddr + slide;
-          module->size_of_image = static_cast<u_int32_t>(seg->vmsize);
+          module->size_of_image = static_cast<uint32_t>(seg->vmsize);
           module->module_name_rva = string_location.rva;
 
           bool in_memory = false;
@@ -1287,7 +1287,7 @@ bool MinidumpGenerator::WriteCVRecord(MDRawModule *module, int cpu_type,
 
   size_t module_name_length = strlen(module_name);
 
-  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
+  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(uint8_t)))
     return false;
 
   if (!cv.CopyIndexAfterObject(0, module_name, module_name_length))
@@ -1388,7 +1388,7 @@ bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
   misc_info_stream->location = info.location();
 
   MDRawMiscInfo *info_ptr = info.get();
-  info_ptr->size_of_info = static_cast<u_int32_t>(sizeof(MDRawMiscInfo));
+  info_ptr->size_of_info = static_cast<uint32_t>(sizeof(MDRawMiscInfo));
   info_ptr->flags1 = MD_MISCINFO_FLAGS1_PROCESS_ID |
     MD_MISCINFO_FLAGS1_PROCESS_TIMES |
     MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO;
@@ -1401,18 +1401,18 @@ bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
   if (getrusage(RUSAGE_SELF, &usage) != -1) {
     // Omit the fractional time since the MDRawMiscInfo only wants seconds
     info_ptr->process_user_time =
-        static_cast<u_int32_t>(usage.ru_utime.tv_sec);
+        static_cast<uint32_t>(usage.ru_utime.tv_sec);
     info_ptr->process_kernel_time =
-        static_cast<u_int32_t>(usage.ru_stime.tv_sec);
+        static_cast<uint32_t>(usage.ru_stime.tv_sec);
   }
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
                  static_cast<int>(info_ptr->process_id) };
-  u_int mibsize = static_cast<u_int>(sizeof(mib) / sizeof(mib[0]));
+  uint mibsize = static_cast<uint>(sizeof(mib) / sizeof(mib[0]));
   struct kinfo_proc proc;
   size_t size = sizeof(proc);
   if (sysctl(mib, mibsize, &proc, &size, NULL, 0) == 0) {
     info_ptr->process_create_time =
-        static_cast<u_int32_t>(proc.kp_proc.p_starttime.tv_sec);
+        static_cast<uint32_t>(proc.kp_proc.p_starttime.tv_sec);
   }
 
   // Speed
@@ -1420,11 +1420,11 @@ bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *misc_info_stream) {
   const uint64_t kOneMillion = 1000 * 1000;
   size = sizeof(speed);
   sysctlbyname("hw.cpufrequency_max", &speed, &size, NULL, 0);
-  info_ptr->processor_max_mhz = static_cast<u_int32_t>(speed / kOneMillion);
-  info_ptr->processor_mhz_limit = static_cast<u_int32_t>(speed / kOneMillion);
+  info_ptr->processor_max_mhz = static_cast<uint32_t>(speed / kOneMillion);
+  info_ptr->processor_mhz_limit = static_cast<uint32_t>(speed / kOneMillion);
   size = sizeof(speed);
   sysctlbyname("hw.cpufrequency", &speed, &size, NULL, 0);
-  info_ptr->processor_current_mhz = static_cast<u_int32_t>(speed / kOneMillion);
+  info_ptr->processor_current_mhz = static_cast<uint32_t>(speed / kOneMillion);
 
   return true;
 }
diff --git a/src/client/mac/handler/minidump_generator.h b/src/client/mac/handler/minidump_generator.h
index ef947841..c79873fa 100644
--- a/src/client/mac/handler/minidump_generator.h
+++ b/src/client/mac/handler/minidump_generator.h
@@ -130,7 +130,7 @@ class MinidumpGenerator {
   bool WriteBreakpadInfoStream(MDRawDirectory *breakpad_info_stream);
 
   // Helpers
-  u_int64_t CurrentPCForStack(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStack(breakpad_thread_state_data_t state);
   bool GetThreadState(thread_act_t target_thread, thread_state_t state,
                       mach_msg_type_number_t *count);
   bool WriteStackFromStartAddress(mach_vm_address_t start_addr,
@@ -151,31 +151,31 @@ class MinidumpGenerator {
                      MDMemoryDescriptor *stack_location);
   bool WriteContextARM(breakpad_thread_state_data_t state,
                        MDLocationDescriptor *register_location);
-  u_int64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStackARM(breakpad_thread_state_data_t state);
 #endif
 #ifdef HAS_PPC_SUPPORT
   bool WriteStackPPC(breakpad_thread_state_data_t state,
                      MDMemoryDescriptor *stack_location);
   bool WriteContextPPC(breakpad_thread_state_data_t state,
                        MDLocationDescriptor *register_location);
-  u_int64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
   bool WriteStackPPC64(breakpad_thread_state_data_t state,
                        MDMemoryDescriptor *stack_location);
   bool WriteContextPPC64(breakpad_thread_state_data_t state,
                        MDLocationDescriptor *register_location);
-  u_int64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
 #endif
 #ifdef HAS_X86_SUPPORT
   bool WriteStackX86(breakpad_thread_state_data_t state,
                        MDMemoryDescriptor *stack_location);
   bool WriteContextX86(breakpad_thread_state_data_t state,
                        MDLocationDescriptor *register_location);
-  u_int64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
   bool WriteStackX86_64(breakpad_thread_state_data_t state,
                         MDMemoryDescriptor *stack_location);
   bool WriteContextX86_64(breakpad_thread_state_data_t state,
                           MDLocationDescriptor *register_location);
-  u_int64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
+  uint64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
 #endif
 
   // disallow copy ctor and operator=
diff --git a/src/client/mac/tests/crash_generation_server_test.cc b/src/client/mac/tests/crash_generation_server_test.cc
index ff8ff78d..0164f4a2 100644
--- a/src/client/mac/tests/crash_generation_server_test.cc
+++ b/src/client/mac/tests/crash_generation_server_test.cc
@@ -318,7 +318,7 @@ const MDCPUArchitecture kExpectedArchitecture =
   MD_CPU_ARCHITECTURE_AMD64
 #endif
   ;
-const u_int32_t kExpectedContext =
+const uint32_t kExpectedContext =
 #if defined(__i386__)
   MD_CONTEXT_AMD64
 #elif defined(__x86_64__)
diff --git a/src/client/mac/tests/exception_handler_test.cc b/src/client/mac/tests/exception_handler_test.cc
index 8325d44e..d108d432 100644
--- a/src/client/mac/tests/exception_handler_test.cc
+++ b/src/client/mac/tests/exception_handler_test.cc
@@ -277,7 +277,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const int kOffset = kMemorySize / 2;
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
@@ -346,7 +346,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -354,11 +354,11 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemory) {
   EXPECT_TRUE(region);
 
   EXPECT_EQ(kMemorySize, region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t prefix_bytes[kOffset];
-  u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
+  uint8_t prefix_bytes[kOffset];
+  uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
   memset(prefix_bytes, 0, sizeof(prefix_bytes));
   memset(suffix_bytes, 0, sizeof(suffix_bytes));
   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
@@ -376,7 +376,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
 
   // These are defined here so the parent can use them to check the
   // data from the minidump afterwards.
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const int kOffset = 0;
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
@@ -445,7 +445,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -453,10 +453,10 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMinBound) {
   EXPECT_TRUE(region);
 
   EXPECT_EQ(kMemorySize / 2, region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
+  uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
   memset(suffix_bytes, 0, sizeof(suffix_bytes));
   EXPECT_TRUE(memcmp(bytes + kOffset, instructions, sizeof(instructions)) == 0);
   EXPECT_TRUE(memcmp(bytes + kOffset + sizeof(instructions),
@@ -475,7 +475,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   // Use 4k here because the OS will hand out a single page even
   // if a smaller size is requested, and this test wants to
   // test the upper bound of the memory range.
-  const u_int32_t kMemorySize = 4096;  // bytes
+  const uint32_t kMemorySize = 4096;  // bytes
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
   const int kOffset = kMemorySize - sizeof(instructions);
@@ -544,7 +544,7 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
   MinidumpContext* context = exception->GetContext();
   ASSERT_TRUE(context);
 
-  u_int64_t instruction_pointer;
+  uint64_t instruction_pointer;
   ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
   MinidumpMemoryRegion* region =
@@ -553,10 +553,10 @@ TEST_F(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) {
 
   const size_t kPrefixSize = 128;  // bytes
   EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
-  const u_int8_t* bytes = region->GetMemory();
+  const uint8_t* bytes = region->GetMemory();
   ASSERT_TRUE(bytes);
 
-  u_int8_t prefix_bytes[kPrefixSize];
+  uint8_t prefix_bytes[kPrefixSize];
   memset(prefix_bytes, 0, sizeof(prefix_bytes));
   EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
   EXPECT_TRUE(memcmp(bytes + kPrefixSize,
diff --git a/src/client/mac/tests/minidump_generator_test.cc b/src/client/mac/tests/minidump_generator_test.cc
index b3f8f0a1..d40c7d98 100644
--- a/src/client/mac/tests/minidump_generator_test.cc
+++ b/src/client/mac/tests/minidump_generator_test.cc
@@ -280,7 +280,7 @@ const MDCPUArchitecture kExpectedArchitecture =
   MD_CPU_ARCHITECTURE_AMD64
 #endif
   ;
-const u_int32_t kExpectedContext =
+const uint32_t kExpectedContext =
 #if defined(__i386__)
   MD_CONTEXT_AMD64
 #elif defined(__x86_64__)
diff --git a/src/client/mac/tests/spawn_child_process.h b/src/client/mac/tests/spawn_child_process.h
index bdd293b1..e52ff6b6 100644
--- a/src/client/mac/tests/spawn_child_process.h
+++ b/src/client/mac/tests/spawn_child_process.h
@@ -65,7 +65,7 @@ const MDCPUArchitecture kNativeArchitecture =
 #endif
   ;
 
-const u_int32_t kNativeContext =
+const uint32_t kNativeContext =
 #if defined(__i386__)
   MD_CONTEXT_X86
 #elif defined(__x86_64__)
diff --git a/src/client/minidump_file_writer.cc b/src/client/minidump_file_writer.cc
index c2674103..1e18d24b 100644
--- a/src/client/minidump_file_writer.cc
+++ b/src/client/minidump_file_writer.cc
@@ -99,11 +99,11 @@ bool MinidumpFileWriter::CopyStringToMDString(const wchar_t *str,
                                               unsigned int length,
                                               TypedMDRVA<MDString> *mdstring) {
   bool result = true;
-  if (sizeof(wchar_t) == sizeof(u_int16_t)) {
+  if (sizeof(wchar_t) == sizeof(uint16_t)) {
     // Shortcut if wchar_t is the same size as MDString's buffer
     result = mdstring->Copy(str, mdstring->get()->length);
   } else {
-    u_int16_t out[2];
+    uint16_t out[2];
     int out_idx = 0;
 
     // Copy the string character by character
@@ -120,7 +120,7 @@ bool MinidumpFileWriter::CopyStringToMDString(const wchar_t *str,
       // zero, but the second one may be zero, depending on the conversion from
       // UTF-32.
       int out_count = out[1] ? 2 : 1;
-      size_t out_size = sizeof(u_int16_t) * out_count;
+      size_t out_size = sizeof(uint16_t) * out_count;
       result = mdstring->CopyIndexAfterObject(out_idx, out, out_size);
       out_idx += out_count;
     }
@@ -132,7 +132,7 @@ bool MinidumpFileWriter::CopyStringToMDString(const char *str,
                                               unsigned int length,
                                               TypedMDRVA<MDString> *mdstring) {
   bool result = true;
-  u_int16_t out[2];
+  uint16_t out[2];
   int out_idx = 0;
 
   // Copy the string character by character
@@ -147,7 +147,7 @@ bool MinidumpFileWriter::CopyStringToMDString(const char *str,
 
     // Append the one or two UTF-16 characters
     int out_count = out[1] ? 2 : 1;
-    size_t out_size = sizeof(u_int16_t) * out_count;
+    size_t out_size = sizeof(uint16_t) * out_count;
     result = mdstring->CopyIndexAfterObject(out_idx, out, out_size);
     out_idx += out_count;
   }
@@ -170,17 +170,17 @@ bool MinidumpFileWriter::WriteStringCore(const CharType *str,
 
   // Allocate the string buffer
   TypedMDRVA<MDString> mdstring(this);
-  if (!mdstring.AllocateObjectAndArray(mdstring_length + 1, sizeof(u_int16_t)))
+  if (!mdstring.AllocateObjectAndArray(mdstring_length + 1, sizeof(uint16_t)))
     return false;
 
   // Set length excluding the NULL and copy the string
   mdstring.get()->length =
-      static_cast<u_int32_t>(mdstring_length * sizeof(u_int16_t));
+      static_cast<uint32_t>(mdstring_length * sizeof(uint16_t));
   bool result = CopyStringToMDString(str, mdstring_length, &mdstring);
 
   // NULL terminate
   if (result) {
-    u_int16_t ch = 0;
+    uint16_t ch = 0;
     result = mdstring.CopyIndexAfterObject(mdstring_length, &ch, sizeof(ch));
 
     if (result)
@@ -211,7 +211,7 @@ bool MinidumpFileWriter::WriteMemory(const void *src, size_t size,
   if (!mem.Copy(src, mem.size()))
     return false;
 
-  output->start_of_memory_range = reinterpret_cast<u_int64_t>(src);
+  output->start_of_memory_range = reinterpret_cast<uint64_t>(src);
   output->memory = mem.location();
 
   return true;
diff --git a/src/client/minidump_file_writer.h b/src/client/minidump_file_writer.h
index 313b250b..538e8545 100644
--- a/src/client/minidump_file_writer.h
+++ b/src/client/minidump_file_writer.h
@@ -172,7 +172,7 @@ class UntypedMDRVA {
 
   // Return size and position
   inline MDLocationDescriptor location() const {
-    MDLocationDescriptor location = { static_cast<u_int32_t>(size_),
+    MDLocationDescriptor location = { static_cast<uint32_t>(size_),
                                       position_ };
     return location;
   }
diff --git a/src/client/solaris/handler/minidump_generator.cc b/src/client/solaris/handler/minidump_generator.cc
index ea046cff..7485025f 100644
--- a/src/client/solaris/handler/minidump_generator.cc
+++ b/src/client/solaris/handler/minidump_generator.cc
@@ -455,7 +455,7 @@ bool WriteCVRecord(MinidumpFileWriter *minidump_writer,
   snprintf(path, sizeof(path), "/proc/self/object/%s", module_name);
 
   size_t module_name_length = strlen(realname);
-  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
+  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(uint8_t)))
     return false;
   if (!cv.CopyIndexAfterObject(0, realname, module_name_length))
     return false;
@@ -522,7 +522,7 @@ bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
   if (!callback_context->minidump_writer->WriteString(realname, 0, &loc))
     return false;
 
-  module.base_of_image = (u_int64_t)module_info.start_addr;
+  module.base_of_image = (uint64_t)module_info.start_addr;
   module.size_of_image = module_info.size;
   module.module_name_rva = loc.rva;
 
diff --git a/src/client/windows/crash_generation/minidump_generator.h b/src/client/windows/crash_generation/minidump_generator.h
index 5f9e4b54..5a1aea0d 100644..100755
--- a/src/client/windows/crash_generation/minidump_generator.h
+++ b/src/client/windows/crash_generation/minidump_generator.h
@@ -32,6 +32,7 @@
 
 #include <windows.h>
 #include <dbghelp.h>
+#include <rpc.h>
 #include <list>
 #include "google_breakpad/common/minidump_format.h"
 
diff --git a/src/client/windows/unittests/exception_handler_death_test.cc b/src/client/windows/unittests/exception_handler_death_test.cc
index 9d6acbc9..c4cb9930 100644
--- a/src/client/windows/unittests/exception_handler_death_test.cc
+++ b/src/client/windows/unittests/exception_handler_death_test.cc
@@ -265,7 +265,7 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemory) {
   testing::DisableExceptionHandlerInScope disable_exception_handler;
 
   // Get some executable memory.
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const int kOffset = kMemorySize / 2;
   // This crashes with SIGILL on x86/x86-64/arm.
   const unsigned char instructions[] = { 0xff, 0xff, 0xff, 0xff };
@@ -314,7 +314,7 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemory) {
     MinidumpContext* context = exception->GetContext();
     ASSERT_TRUE(context);
 
-    u_int64_t instruction_pointer;
+    uint64_t instruction_pointer;
     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
     MinidumpMemoryRegion* region =
@@ -322,11 +322,11 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemory) {
     ASSERT_TRUE(region);
 
     EXPECT_EQ(kMemorySize, region->GetSize());
-    const u_int8_t* bytes = region->GetMemory();
+    const uint8_t* bytes = region->GetMemory();
     ASSERT_TRUE(bytes);
 
-    u_int8_t prefix_bytes[kOffset];
-    u_int8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
+    uint8_t prefix_bytes[kOffset];
+    uint8_t suffix_bytes[kMemorySize - kOffset - sizeof(instructions)];
     memset(prefix_bytes, 0, sizeof(prefix_bytes));
     memset(suffix_bytes, 0, sizeof(suffix_bytes));
     EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
@@ -352,7 +352,7 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMinBound) {
   SYSTEM_INFO sSysInfo;         // Useful information about the system
   GetSystemInfo(&sSysInfo);     // Initialize the structure.
 
-  const u_int32_t kMemorySize = 256;  // bytes
+  const uint32_t kMemorySize = 256;  // bytes
   const DWORD kPageSize = sSysInfo.dwPageSize;
   const int kOffset = 0;
   // This crashes with SIGILL on x86/x86-64/arm.
@@ -407,7 +407,7 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMinBound) {
     MinidumpContext* context = exception->GetContext();
     ASSERT_TRUE(context);
 
-    u_int64_t instruction_pointer;
+    uint64_t instruction_pointer;
     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
     MinidumpMemoryRegion* region =
@@ -415,10 +415,10 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMinBound) {
     ASSERT_TRUE(region);
 
     EXPECT_EQ(kMemorySize / 2, region->GetSize());
-    const u_int8_t* bytes = region->GetMemory();
+    const uint8_t* bytes = region->GetMemory();
     ASSERT_TRUE(bytes);
 
-    u_int8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
+    uint8_t suffix_bytes[kMemorySize / 2 - sizeof(instructions)];
     memset(suffix_bytes, 0, sizeof(suffix_bytes));
     EXPECT_TRUE(memcmp(bytes + kOffset,
                        instructions, sizeof(instructions)) == 0);
@@ -492,7 +492,7 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMaxBound) {
     MinidumpContext* context = exception->GetContext();
     ASSERT_TRUE(context);
 
-    u_int64_t instruction_pointer;
+    uint64_t instruction_pointer;
     ASSERT_TRUE(context->GetInstructionPointer(&instruction_pointer));
 
     MinidumpMemoryRegion* region =
@@ -501,10 +501,10 @@ TEST_F(ExceptionHandlerDeathTest, InstructionPointerMemoryMaxBound) {
 
     const size_t kPrefixSize = 128;  // bytes
     EXPECT_EQ(kPrefixSize + sizeof(instructions), region->GetSize());
-    const u_int8_t* bytes = region->GetMemory();
+    const uint8_t* bytes = region->GetMemory();
     ASSERT_TRUE(bytes);
 
-    u_int8_t prefix_bytes[kPrefixSize];
+    uint8_t prefix_bytes[kPrefixSize];
     memset(prefix_bytes, 0, sizeof(prefix_bytes));
     EXPECT_TRUE(memcmp(bytes, prefix_bytes, sizeof(prefix_bytes)) == 0);
     EXPECT_TRUE(memcmp(bytes + kPrefixSize,
diff --git a/src/client/windows/unittests/exception_handler_test.cc b/src/client/windows/unittests/exception_handler_test.cc
index be9397b8..7b50e301 100644
--- a/src/client/windows/unittests/exception_handler_test.cc
+++ b/src/client/windows/unittests/exception_handler_test.cc
@@ -397,15 +397,15 @@ TEST_F(ExceptionHandlerTest, WriteMinidumpTest) {
 TEST_F(ExceptionHandlerTest, AdditionalMemory) {
   SYSTEM_INFO si;
   GetSystemInfo(&si);
-  const u_int32_t kMemorySize = si.dwPageSize;
+  const uint32_t kMemorySize = si.dwPageSize;
 
   // Get some heap memory.
-  u_int8_t* memory = new u_int8_t[kMemorySize];
+  uint8_t* memory = new uint8_t[kMemorySize];
   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
   // Stick some data into the memory so the contents can be verified.
-  for (u_int32_t i = 0; i < kMemorySize; ++i) {
+  for (uint32_t i = 0; i < kMemorySize; ++i) {
     memory[i] = i % 255;
   }
 
@@ -451,15 +451,15 @@ TEST_F(ExceptionHandlerTest, AdditionalMemory) {
 TEST_F(ExceptionHandlerTest, AdditionalMemoryRemove) {
   SYSTEM_INFO si;
   GetSystemInfo(&si);
-  const u_int32_t kMemorySize = si.dwPageSize;
+  const uint32_t kMemorySize = si.dwPageSize;
 
   // Get some heap memory.
-  u_int8_t* memory = new u_int8_t[kMemorySize];
+  uint8_t* memory = new uint8_t[kMemorySize];
   const uintptr_t kMemoryAddress = reinterpret_cast<uintptr_t>(memory);
   ASSERT_TRUE(memory);
 
   // Stick some data into the memory so the contents can be verified.
-  for (u_int32_t i = 0; i < kMemorySize; ++i) {
+  for (uint32_t i = 0; i < kMemorySize; ++i) {
     memory[i] = i % 255;
   }
 
diff --git a/src/common/dwarf/cfi_assembler.cc b/src/common/dwarf/cfi_assembler.cc
index a6a5aca6..dbc2efae 100644
--- a/src/common/dwarf/cfi_assembler.cc
+++ b/src/common/dwarf/cfi_assembler.cc
@@ -41,10 +41,10 @@ namespace google_breakpad {
 
 using dwarf2reader::DwarfPointerEncoding;
   
-CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor,
+CFISection &CFISection::CIEHeader(uint64_t code_alignment_factor,
                                   int data_alignment_factor,
                                   unsigned return_address_register,
-                                  u_int8_t version,
+                                  uint8_t version,
                                   const string &augmentation,
                                   bool dwarf64) {
   assert(!entry_length_);
@@ -73,8 +73,8 @@ CFISection &CFISection::CIEHeader(u_int64_t code_alignment_factor,
 }
 
 CFISection &CFISection::FDEHeader(Label cie_pointer,
-                                  u_int64_t initial_location,
-                                  u_int64_t address_range,
+                                  uint64_t initial_location,
+                                  uint64_t address_range,
                                   bool dwarf64) {
   assert(!entry_length_);
   entry_length_ = new PendingLength();
@@ -117,7 +117,7 @@ CFISection &CFISection::FinishEntry() {
   return *this;
 }
 
-CFISection &CFISection::EncodedPointer(u_int64_t address,
+CFISection &CFISection::EncodedPointer(uint64_t address,
                                        DwarfPointerEncoding encoding,
                                        const EncodedPointerBases &bases) {
   // Omitted data is extremely easy to emit.
@@ -131,7 +131,7 @@ CFISection &CFISection::EncodedPointer(u_int64_t address,
 
   // Find the base address to which this pointer is relative. The upper
   // nybble of the encoding specifies this.
-  u_int64_t base;
+  uint64_t base;
   switch (encoding & 0xf0) {
     case dwarf2reader::DW_EH_PE_absptr:  base = 0;                  break;
     case dwarf2reader::DW_EH_PE_pcrel:   base = bases.cfi + Size(); break;
@@ -189,10 +189,10 @@ CFISection &CFISection::EncodedPointer(u_int64_t address,
   return *this;
 };
 
-const u_int32_t CFISection::kDwarf64InitialLengthMarker;
-const u_int32_t CFISection::kDwarf32CIEIdentifier;
-const u_int64_t CFISection::kDwarf64CIEIdentifier;
-const u_int32_t CFISection::kEHFrame32CIEIdentifier;
-const u_int64_t CFISection::kEHFrame64CIEIdentifier;
+const uint32_t CFISection::kDwarf64InitialLengthMarker;
+const uint32_t CFISection::kDwarf32CIEIdentifier;
+const uint64_t CFISection::kDwarf64CIEIdentifier;
+const uint32_t CFISection::kEHFrame32CIEIdentifier;
+const uint64_t CFISection::kEHFrame64CIEIdentifier;
 
 } // namespace google_breakpad
diff --git a/src/common/dwarf/cfi_assembler.h b/src/common/dwarf/cfi_assembler.h
index 00ff6f06..227812b5 100644
--- a/src/common/dwarf/cfi_assembler.h
+++ b/src/common/dwarf/cfi_assembler.h
@@ -80,14 +80,14 @@ class CFISection: public Section {
     // The starting address of this CFI section in memory, for
     // DW_EH_PE_pcrel. DW_EH_PE_pcrel pointers may only be used in data
     // that has is loaded into the program's address space.
-    u_int64_t cfi;
+    uint64_t cfi;
 
     // The starting address of this file's .text section, for DW_EH_PE_textrel.
-    u_int64_t text;
+    uint64_t text;
 
     // The starting address of this file's .got or .eh_frame_hdr section,
     // for DW_EH_PE_datarel.
-    u_int64_t data;
+    uint64_t data;
   };
 
   // Create a CFISection whose endianness is ENDIANNESS, and where
@@ -133,10 +133,10 @@ class CFISection: public Section {
   // Before calling this function, you will typically want to use Mark
   // or Here to make a label to pass to FDEHeader that refers to this
   // CIE's position in the section.
-  CFISection &CIEHeader(u_int64_t code_alignment_factor,
+  CFISection &CIEHeader(uint64_t code_alignment_factor,
                         int data_alignment_factor,
                         unsigned return_address_register,
-                        u_int8_t version = 3,
+                        uint8_t version = 3,
                         const string &augmentation = "",
                         bool dwarf64 = false);
 
@@ -151,8 +151,8 @@ class CFISection: public Section {
   // value.) Nor does it support .debug_frame sections longer than
   // 0xffffff00 bytes.
   CFISection &FDEHeader(Label cie_pointer,
-                        u_int64_t initial_location,
-                        u_int64_t address_range,
+                        uint64_t initial_location,
+                        uint64_t address_range,
                         bool dwarf64 = false);
 
   // Note the current position as the end of the last CIE or FDE we
@@ -171,7 +171,7 @@ class CFISection: public Section {
 
   // Append ADDRESS to this section, in the appropriate size and
   // endianness. Return a reference to this section.
-  CFISection &Address(u_int64_t address) {
+  CFISection &Address(uint64_t address) {
     Section::Append(endianness(), address_size_, address);
     return *this;
   }
@@ -189,26 +189,26 @@ class CFISection: public Section {
   // 
   // (C++ doesn't let me use default arguments here, because I want to
   // refer to members of *this in the default argument expression.)
-  CFISection &EncodedPointer(u_int64_t address) {
+  CFISection &EncodedPointer(uint64_t address) {
     return EncodedPointer(address, pointer_encoding_, encoded_pointer_bases_);
   }
-  CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding) {
+  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) {
     return EncodedPointer(address, encoding, encoded_pointer_bases_);
   }
-  CFISection &EncodedPointer(u_int64_t address, DwarfPointerEncoding encoding,
+  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding,
                              const EncodedPointerBases &bases);
 
   // Restate some member functions, to keep chaining working nicely.
   CFISection &Mark(Label *label)   { Section::Mark(label); return *this; }
-  CFISection &D8(u_int8_t v)       { Section::D8(v);       return *this; }
-  CFISection &D16(u_int16_t v)     { Section::D16(v);      return *this; }
+  CFISection &D8(uint8_t v)       { Section::D8(v);       return *this; }
+  CFISection &D16(uint16_t v)     { Section::D16(v);      return *this; }
   CFISection &D16(Label v)         { Section::D16(v);      return *this; }
-  CFISection &D32(u_int32_t v)     { Section::D32(v);      return *this; }
+  CFISection &D32(uint32_t v)     { Section::D32(v);      return *this; }
   CFISection &D32(const Label &v)  { Section::D32(v);      return *this; }
-  CFISection &D64(u_int64_t v)     { Section::D64(v);      return *this; }
+  CFISection &D64(uint64_t v)     { Section::D64(v);      return *this; }
   CFISection &D64(const Label &v)  { Section::D64(v);      return *this; }
   CFISection &LEB128(long long v)  { Section::LEB128(v);   return *this; }
-  CFISection &ULEB128(u_int64_t v) { Section::ULEB128(v);  return *this; }
+  CFISection &ULEB128(uint64_t v) { Section::ULEB128(v);  return *this; }
 
  private:
   // A length value that we've appended to the section, but is not yet
@@ -224,13 +224,13 @@ class CFISection: public Section {
   // If the first four bytes of an "initial length" are this constant, then
   // the data uses the 64-bit DWARF format, and the length itself is the
   // subsequent eight bytes.
-  static const u_int32_t kDwarf64InitialLengthMarker = 0xffffffffU;
+  static const uint32_t kDwarf64InitialLengthMarker = 0xffffffffU;
 
   // The CIE identifier for 32- and 64-bit DWARF CFI and .eh_frame data.
-  static const u_int32_t kDwarf32CIEIdentifier = ~(u_int32_t)0;
-  static const u_int64_t kDwarf64CIEIdentifier = ~(u_int64_t)0;
-  static const u_int32_t kEHFrame32CIEIdentifier = 0;
-  static const u_int64_t kEHFrame64CIEIdentifier = 0;
+  static const uint32_t kDwarf32CIEIdentifier = ~(uint32_t)0;
+  static const uint64_t kDwarf64CIEIdentifier = ~(uint64_t)0;
+  static const uint32_t kEHFrame32CIEIdentifier = 0;
+  static const uint64_t kEHFrame64CIEIdentifier = 0;
 
   // The size of a machine address for the data in this section.
   size_t address_size_;
@@ -261,7 +261,7 @@ class CFISection: public Section {
 
   // If in_fde_ is true, this is its starting address. We use this for
   // emitting DW_EH_PE_funcrel pointers.
-  u_int64_t fde_start_address_;
+  uint64_t fde_start_address_;
 };
 
 }  // namespace google_breakpad
diff --git a/src/common/dwarf/dwarf2reader_cfi_unittest.cc b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
index 7b794361..66c6198b 100644
--- a/src/common/dwarf/dwarf2reader_cfi_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_cfi_unittest.cc
@@ -2326,14 +2326,14 @@ struct ELFSectionHeader {
         alignment(1), entry_size(0) { }
   Label name;
   unsigned int type;
-  u_int64_t flags;
-  u_int64_t address;
+  uint64_t flags;
+  uint64_t address;
   Label file_offset;
   Label file_size;
   unsigned int link;
   unsigned int info;
-  u_int64_t alignment;
-  u_int64_t entry_size;
+  uint64_t alignment;
+  uint64_t entry_size;
 };
 
 void AppendSectionHeader(CFISection *table, const ELFSectionHeader &header) {
diff --git a/src/common/dwarf/dwarf2reader_die_unittest.cc b/src/common/dwarf/dwarf2reader_die_unittest.cc
index f8462a19..4e344369 100644
--- a/src/common/dwarf/dwarf2reader_die_unittest.cc
+++ b/src/common/dwarf/dwarf2reader_die_unittest.cc
@@ -289,7 +289,7 @@ TEST_P(DwarfForms, addr) {
   StartSingleAttributeDIE(GetParam(), dwarf2reader::DW_TAG_compile_unit,
                           dwarf2reader::DW_AT_low_pc,
                           dwarf2reader::DW_FORM_addr);
-  u_int64_t value;
+  uint64_t value;
   if (GetParam().address_size == 4) {
     value = 0xc8e9ffcc;
     info.D32(value);
@@ -372,7 +372,7 @@ TEST_P(DwarfForms, sec_offset) {
   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x1d971689,
                           (DwarfAttribute) 0xa060bfd1,
                           dwarf2reader::DW_FORM_sec_offset);
-  u_int64_t value;
+  uint64_t value;
   if (GetParam().format_size == 4) {
     value = 0xacc9c388;
     info.D32(value);
diff --git a/src/common/dwarf/dwarf2reader_test_common.h b/src/common/dwarf/dwarf2reader_test_common.h
index e46931a4..e91de906 100644
--- a/src/common/dwarf/dwarf2reader_test_common.h
+++ b/src/common/dwarf/dwarf2reader_test_common.h
@@ -97,7 +97,7 @@ class TestCompilationUnit: public google_breakpad::test_assembler::Section {
 
   // The offset of the point in the compilation unit header immediately
   // after the initial length field.
-  u_int64_t post_length_offset_;
+  uint64_t post_length_offset_;
 
   // The length of the compilation unit, not including the initial length field.
   Label length_;
diff --git a/src/common/linux/guid_creator.cc b/src/common/linux/guid_creator.cc
index 426f93a1..bfb308ee 100644
--- a/src/common/linux/guid_creator.cc
+++ b/src/common/linux/guid_creator.cc
@@ -46,14 +46,14 @@
 //
 class GUIDGenerator {
  public:
-  static u_int32_t BytesToUInt32(const u_int8_t bytes[]) {
-    return ((u_int32_t) bytes[0]
-            | ((u_int32_t) bytes[1] << 8)
-            | ((u_int32_t) bytes[2] << 16)
-            | ((u_int32_t) bytes[3] << 24));
+  static uint32_t BytesToUInt32(const uint8_t bytes[]) {
+    return ((uint32_t) bytes[0]
+            | ((uint32_t) bytes[1] << 8)
+            | ((uint32_t) bytes[2] << 16)
+            | ((uint32_t) bytes[3] << 24));
   }
 
-  static void UInt32ToBytes(u_int8_t bytes[], u_int32_t n) {
+  static void UInt32ToBytes(uint8_t bytes[], uint32_t n) {
     bytes[0] = n & 0xff;
     bytes[1] = (n >> 8) & 0xff;
     bytes[2] = (n >> 16) & 0xff;
@@ -63,8 +63,8 @@ class GUIDGenerator {
   static bool CreateGUID(GUID *guid) {
     InitOnce();
     guid->data1 = random();
-    guid->data2 = (u_int16_t)(random());
-    guid->data3 = (u_int16_t)(random());
+    guid->data2 = (uint16_t)(random());
+    guid->data3 = (uint16_t)(random());
     UInt32ToBytes(&guid->data4[0], random());
     UInt32ToBytes(&guid->data4[4], random());
     return true;
diff --git a/src/common/linux/memory_mapped_file.cc b/src/common/linux/memory_mapped_file.cc
index 47b7eb0b..853cce57 100644
--- a/src/common/linux/memory_mapped_file.cc
+++ b/src/common/linux/memory_mapped_file.cc
@@ -97,7 +97,7 @@ bool MemoryMappedFile::Map(const char* path) {
 
 void MemoryMappedFile::Unmap() {
   if (content_.data()) {
-    sys_munmap(const_cast<u_int8_t*>(content_.data()), content_.length());
+    sys_munmap(const_cast<uint8_t*>(content_.data()), content_.length());
     content_.Set(NULL, 0);
   }
 }
diff --git a/src/common/mac/MachIPC.h b/src/common/mac/MachIPC.h
index 52bed590..8df9165b 100644
--- a/src/common/mac/MachIPC.h
+++ b/src/common/mac/MachIPC.h
@@ -164,11 +164,11 @@ class MachMessage {
  public:
 
   // The receiver of the message can retrieve the raw data this way
-  u_int8_t *GetData() {
+  uint8_t *GetData() {
     return GetDataLength() > 0 ? GetDataPacket()->data : NULL;
   }
 
-  u_int32_t GetDataLength() {
+  uint32_t GetDataLength() {
     return EndianU32_LtoN(GetDataPacket()->data_length);
   }
 
@@ -210,7 +210,7 @@ class MachMessage {
   struct MessageDataPacket {
     int32_t      id;          // little-endian
     int32_t      data_length; // little-endian
-    u_int8_t     data[1];     // actual size limited by sizeof(MachMessage)
+    uint8_t      data[1];     // actual size limited by sizeof(MachMessage)
   };
 
   MessageDataPacket* GetDataPacket();
@@ -223,7 +223,7 @@ class MachMessage {
 
   mach_msg_header_t  head;
   mach_msg_body_t    body;
-  u_int8_t           padding[1024]; // descriptors and data may be embedded here
+  uint8_t            padding[1024]; // descriptors and data may be embedded here
 };
 
 //==============================================================================
diff --git a/src/common/memory_range.h b/src/common/memory_range.h
index 86bd08c9..41dd2da6 100644
--- a/src/common/memory_range.h
+++ b/src/common/memory_range.h
@@ -67,7 +67,7 @@ class MemoryRange {
 
   // Sets this memory range to point to |data| and its length to |length|.
   void Set(const void* data, size_t length) {
-    data_ = reinterpret_cast<const u_int8_t*>(data);
+    data_ = reinterpret_cast<const uint8_t*>(data);
     // Always set |length_| to zero if |data_| is NULL.
     length_ = data ? length : 0;
   }
@@ -127,14 +127,14 @@ class MemoryRange {
   }
 
   // Returns a pointer to the beginning of this memory range.
-  const u_int8_t* data() const { return data_; }
+  const uint8_t* data() const { return data_; }
 
   // Returns the length, in bytes, of this memory range.
   size_t length() const { return length_; }
 
  private:
   // Pointer to the beginning of this memory range.
-  const u_int8_t* data_;
+  const uint8_t* data_;
 
   // Length, in bytes, of this memory range.
   size_t length_;
diff --git a/src/common/memory_range_unittest.cc b/src/common/memory_range_unittest.cc
index b13f45ca..f6cf8c8b 100644
--- a/src/common/memory_range_unittest.cc
+++ b/src/common/memory_range_unittest.cc
@@ -37,9 +37,9 @@ using testing::Message;
 
 namespace {
 
-const u_int32_t kBuffer[10] = { 0 };
+const uint32_t kBuffer[10] = { 0 };
 const size_t kBufferSize = sizeof(kBuffer);
-const u_int8_t* kBufferPointer = reinterpret_cast<const u_int8_t*>(kBuffer);
+const uint8_t* kBufferPointer = reinterpret_cast<const uint8_t*>(kBuffer);
 
 // Test vectors for verifying Covers, GetData, and Subrange.
 const struct {
diff --git a/src/common/module.h b/src/common/module.h
index d58e8b78..cecab32f 100644
--- a/src/common/module.h
+++ b/src/common/module.h
@@ -60,7 +60,7 @@ using std::map;
 class Module {
  public:
   // The type of addresses and sizes in a symbol table.
-  typedef u_int64_t Address;
+  typedef uint64_t Address;
   struct File;
   struct Function;
   struct Line;
diff --git a/src/common/solaris/dump_symbols.cc b/src/common/solaris/dump_symbols.cc
index fb040265..168d0b28 100644
--- a/src/common/solaris/dump_symbols.cc
+++ b/src/common/solaris/dump_symbols.cc
@@ -156,7 +156,7 @@ const char *kStrtabName = ".strtab";
 const int demangleLen = 20000;
 
 // Offset to the string table.
-u_int64_t stringOffset = 0;
+uint64_t stringOffset = 0;
 
 // Update the offset to the start of the string index of the next
 // object module for every N_ENDM stabs.
diff --git a/src/common/solaris/guid_creator.cc b/src/common/solaris/guid_creator.cc
index 70940259..c4d58e0a 100644
--- a/src/common/solaris/guid_creator.cc
+++ b/src/common/solaris/guid_creator.cc
@@ -53,10 +53,10 @@ class GUIDGenerator {
 
   bool CreateGUID(GUID *guid) const {
     guid->data1 = random();
-    guid->data2 = (u_int16_t)(random());
-    guid->data3 = (u_int16_t)(random());
-    *reinterpret_cast<u_int32_t*>(&guid->data4[0]) = random();
-    *reinterpret_cast<u_int32_t*>(&guid->data4[4]) = random();
+    guid->data2 = (uint16_t)(random());
+    guid->data3 = (uint16_t)(random());
+    *reinterpret_cast<uint32_t*>(&guid->data4[0]) = random();
+    *reinterpret_cast<uint32_t*>(&guid->data4[4]) = random();
     return true;
   }
 };
@@ -74,8 +74,8 @@ bool GUIDToString(const GUID *guid, char *buf, int buf_len) {
   assert(buf_len > kGUIDStringLength);
   int num = snprintf(buf, buf_len, kGUIDFormatString,
                      guid->data1, guid->data2, guid->data3,
-                     *reinterpret_cast<const u_int32_t *>(&(guid->data4[0])),
-                     *reinterpret_cast<const u_int32_t *>(&(guid->data4[4])));
+                     *reinterpret_cast<const uint32_t *>(&(guid->data4[0])),
+                     *reinterpret_cast<const uint32_t *>(&(guid->data4[4])));
   if (num != kGUIDStringLength)
     return false;
 
diff --git a/src/common/stabs_reader_unittest.cc b/src/common/stabs_reader_unittest.cc
index edcba724..a84da1c4 100644
--- a/src/common/stabs_reader_unittest.cc
+++ b/src/common/stabs_reader_unittest.cc
@@ -565,7 +565,7 @@ TEST_F(Stabs, OnePublicSymbol) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
 
-  const u_int32_t kExpectedAddress = 0x9000;
+  const uint32_t kExpectedAddress = 0x9000;
   const string kExpectedFunctionName("public_function");
   stabs
     .Stab(N_SECT, 1, 0, kExpectedAddress, kExpectedFunctionName);
@@ -584,9 +584,9 @@ TEST_F(Stabs, TwoPublicSymbols) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
 
-  const u_int32_t kExpectedAddress1 = 0xB0B0B0B0;
+  const uint32_t kExpectedAddress1 = 0xB0B0B0B0;
   const string kExpectedFunctionName1("public_function");
-  const u_int32_t kExpectedAddress2 = 0xF0F0F0F0;
+  const uint32_t kExpectedAddress2 = 0xF0F0F0F0;
   const string kExpectedFunctionName2("something else");
   stabs
     .Stab(N_SECT, 1, 0, kExpectedAddress1, kExpectedFunctionName1)
diff --git a/src/common/string_conversion.cc b/src/common/string_conversion.cc
index 444ac817..c4107faf 100644
--- a/src/common/string_conversion.cc
+++ b/src/common/string_conversion.cc
@@ -38,15 +38,15 @@ namespace google_breakpad {
 
 using std::vector;
 
-void UTF8ToUTF16(const char *in, vector<u_int16_t> *out) {
+void UTF8ToUTF16(const char *in, vector<uint16_t> *out) {
   size_t source_length = strlen(in);
   const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
   const UTF8 *source_end_ptr = source_ptr + source_length;
   // Erase the contents and zero fill to the expected size
   out->clear();
   out->insert(out->begin(), source_length, 0);
-  u_int16_t *target_ptr = &(*out)[0];
-  u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t);
+  uint16_t *target_ptr = &(*out)[0];
+  uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t);
   ConversionResult result = ConvertUTF8toUTF16(&source_ptr, source_end_ptr,
                                                &target_ptr, target_end_ptr,
                                                strictConversion);
@@ -55,11 +55,11 @@ void UTF8ToUTF16(const char *in, vector<u_int16_t> *out) {
   out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0);
 }
 
-int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) {
+int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]) {
   const UTF8 *source_ptr = reinterpret_cast<const UTF8 *>(in);
   const UTF8 *source_end_ptr = source_ptr + sizeof(char);
-  u_int16_t *target_ptr = out;
-  u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t);
+  uint16_t *target_ptr = out;
+  uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t);
   out[0] = out[1] = 0;
 
   // Process one character at a time
@@ -82,15 +82,15 @@ int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]) {
   return 0;
 }
 
-void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out) {
+void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out) {
   size_t source_length = wcslen(in);
   const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(in);
   const UTF32 *source_end_ptr = source_ptr + source_length;
   // Erase the contents and zero fill to the expected size
   out->clear();
   out->insert(out->begin(), source_length, 0);
-  u_int16_t *target_ptr = &(*out)[0];
-  u_int16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(u_int16_t);
+  uint16_t *target_ptr = &(*out)[0];
+  uint16_t *target_end_ptr = target_ptr + out->capacity() * sizeof(uint16_t);
   ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
                                                 &target_ptr, target_end_ptr,
                                                 strictConversion);
@@ -99,11 +99,11 @@ void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out) {
   out->resize(result == conversionOK ? target_ptr - &(*out)[0] + 1: 0);
 }
 
-void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) {
+void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]) {
   const UTF32 *source_ptr = reinterpret_cast<const UTF32 *>(&in);
   const UTF32 *source_end_ptr = source_ptr + 1;
-  u_int16_t *target_ptr = out;
-  u_int16_t *target_end_ptr = target_ptr + 2 * sizeof(u_int16_t);
+  uint16_t *target_ptr = out;
+  uint16_t *target_end_ptr = target_ptr + 2 * sizeof(uint16_t);
   out[0] = out[1] = 0;
   ConversionResult result = ConvertUTF32toUTF16(&source_ptr, source_end_ptr,
                                                 &target_ptr, target_end_ptr,
@@ -114,20 +114,20 @@ void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]) {
   }
 }
 
-static inline u_int16_t Swap(u_int16_t value) {
-  return (value >> 8) | static_cast<u_int16_t>(value << 8);
+static inline uint16_t Swap(uint16_t value) {
+  return (value >> 8) | static_cast<uint16_t>(value << 8);
 }
 
-string UTF16ToUTF8(const vector<u_int16_t> &in, bool swap) {
+string UTF16ToUTF8(const vector<uint16_t> &in, bool swap) {
   const UTF16 *source_ptr = &in[0];
-  scoped_ptr<u_int16_t> source_buffer;
+  scoped_ptr<uint16_t> source_buffer;
 
   // If we're to swap, we need to make a local copy and swap each byte pair
   if (swap) {
     int idx = 0;
-    source_buffer.reset(new u_int16_t[in.size()]);
+    source_buffer.reset(new uint16_t[in.size()]);
     UTF16 *source_buffer_ptr = source_buffer.get();
-    for (vector<u_int16_t>::const_iterator it = in.begin();
+    for (vector<uint16_t>::const_iterator it = in.begin();
          it != in.end(); ++it, ++idx)
       source_buffer_ptr[idx] = Swap(*it);
 
diff --git a/src/common/string_conversion.h b/src/common/string_conversion.h
index eeed4d28..b9ba96a2 100644
--- a/src/common/string_conversion.h
+++ b/src/common/string_conversion.h
@@ -44,24 +44,24 @@ using std::vector;
 
 // Convert |in| to UTF-16 into |out|.  Use platform byte ordering.  If the
 // conversion failed, |out| will be zero length.
-void UTF8ToUTF16(const char *in, vector<u_int16_t> *out);
+void UTF8ToUTF16(const char *in, vector<uint16_t> *out);
 
 // Convert at least one character (up to a maximum of |in_length|) from |in|
 // to UTF-16 into |out|.  Return the number of characters consumed from |in|.
 // Any unused characters in |out| will be initialized to 0.  No memory will
 // be allocated by this routine.
-int UTF8ToUTF16Char(const char *in, int in_length, u_int16_t out[2]);
+int UTF8ToUTF16Char(const char *in, int in_length, uint16_t out[2]);
 
 // Convert |in| to UTF-16 into |out|.  Use platform byte ordering.  If the
 // conversion failed, |out| will be zero length.
-void UTF32ToUTF16(const wchar_t *in, vector<u_int16_t> *out);
+void UTF32ToUTF16(const wchar_t *in, vector<uint16_t> *out);
 
 // Convert |in| to UTF-16 into |out|.  Any unused characters in |out| will be
 // initialized to 0.  No memory will be allocated by this routine.
-void UTF32ToUTF16Char(wchar_t in, u_int16_t out[2]);
+void UTF32ToUTF16Char(wchar_t in, uint16_t out[2]);
 
 // Convert |in| to UTF-8.  If |swap| is true, swap bytes before converting.
-string UTF16ToUTF8(const vector<u_int16_t> &in, bool swap);
+string UTF16ToUTF8(const vector<uint16_t> &in, bool swap);
 
 }  // namespace google_breakpad
 
diff --git a/src/common/test_assembler.cc b/src/common/test_assembler.cc
index 7f5dd384..1e783b45 100644
--- a/src/common/test_assembler.cc
+++ b/src/common/test_assembler.cc
@@ -45,7 +45,7 @@ namespace test_assembler {
 using std::back_insert_iterator;
 
 Label::Label() : value_(new Binding()) { }
-Label::Label(u_int64_t value) : value_(new Binding(value)) { }
+Label::Label(uint64_t value) : value_(new Binding(value)) { }
 Label::Label(const Label &label) {
   value_ = label.value_;
   value_->Acquire();
@@ -54,7 +54,7 @@ Label::~Label() {
   if (value_->Release()) delete value_;
 }
 
-Label &Label::operator=(u_int64_t value) {
+Label &Label::operator=(uint64_t value) {
   value_->Set(NULL, value);
   return *this;
 }
@@ -64,13 +64,13 @@ Label &Label::operator=(const Label &label) {
   return *this;
 }
 
-Label Label::operator+(u_int64_t addend) const {
+Label Label::operator+(uint64_t addend) const {
   Label l;
   l.value_->Set(this->value_, addend);
   return l;
 }
 
-Label Label::operator-(u_int64_t subtrahend) const {
+Label Label::operator-(uint64_t subtrahend) const {
   Label l;
   l.value_->Set(this->value_, -subtrahend);
   return l;
@@ -89,31 +89,31 @@ Label Label::operator-(u_int64_t subtrahend) const {
 #define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x)
 #endif
 
-u_int64_t Label::operator-(const Label &label) const {
-  u_int64_t offset;
+uint64_t Label::operator-(const Label &label) const {
+  uint64_t offset;
   ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset));
   return offset;
 }
 
-u_int64_t Label::Value() const {
-  u_int64_t v = 0;
+uint64_t Label::Value() const {
+  uint64_t v = 0;
   ALWAYS_EVALUATE_AND_ASSERT(IsKnownConstant(&v));
   return v;
 };
 
-bool Label::IsKnownConstant(u_int64_t *value_p) const {
+bool Label::IsKnownConstant(uint64_t *value_p) const {
   Binding *base;
-  u_int64_t addend;
+  uint64_t addend;
   value_->Get(&base, &addend);
   if (base != NULL) return false;
   if (value_p) *value_p = addend;
   return true;
 }
 
-bool Label::IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p) const
+bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const
 {
   Binding *label_base, *this_base;
-  u_int64_t label_addend, this_addend;
+  uint64_t label_addend, this_addend;
   label.value_->Get(&label_base, &label_addend);
   value_->Get(&this_base, &this_addend);
   // If this and label are related, Get will find their final
@@ -126,7 +126,7 @@ bool Label::IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p) const
 
 Label::Binding::Binding() : base_(this), addend_(), reference_count_(1) { }
 
-Label::Binding::Binding(u_int64_t addend)
+Label::Binding::Binding(uint64_t addend)
     : base_(NULL), addend_(addend), reference_count_(1) { }
 
 Label::Binding::~Binding() {
@@ -135,7 +135,7 @@ Label::Binding::~Binding() {
     delete base_;
 }
 
-void Label::Binding::Set(Binding *binding, u_int64_t addend) {
+void Label::Binding::Set(Binding *binding, uint64_t addend) {
   if (!base_ && !binding) {
     // We're equating two constants. This could be okay.
     assert(addend_ == addend);
@@ -150,7 +150,7 @@ void Label::Binding::Set(Binding *binding, u_int64_t addend) {
       // another variable (otherwise, it wouldn't be final), this
       // guarantees we won't create cycles here, even for code like this:
       //   l = m, m = n, n = l;
-      u_int64_t binding_addend;
+      uint64_t binding_addend;
       binding->Get(&binding, &binding_addend);
       addend += binding_addend;
     }
@@ -183,14 +183,14 @@ void Label::Binding::Set(Binding *binding, u_int64_t addend) {
   }
 }
 
-void Label::Binding::Get(Binding **base, u_int64_t *addend) {
+void Label::Binding::Get(Binding **base, uint64_t *addend) {
   if (base_ && base_ != this) {
     // Recurse to find the end of our reference chain (the root of our
     // tree), and then rewrite every binding along the chain to refer
     // to it directly, adjusting addends appropriately. (This is why
     // this member function isn't this-const.)
     Binding *final_base;
-    u_int64_t final_addend;
+    uint64_t final_addend;
     base_->Get(&final_base, &final_addend);
     if (final_base) final_base->Acquire();
     if (base_->Release()) delete base_;
@@ -203,7 +203,7 @@ void Label::Binding::Get(Binding **base, u_int64_t *addend) {
 
 template<typename Inserter>
 static inline void InsertEndian(test_assembler::Endianness endianness,
-                                size_t size, u_int64_t number, Inserter dest) {
+                                size_t size, uint64_t number, Inserter dest) {
   assert(size > 0);
   if (endianness == kLittleEndian) {
     for (size_t i = 0; i < size; i++) {
@@ -218,7 +218,7 @@ static inline void InsertEndian(test_assembler::Endianness endianness,
   }
 }
 
-Section &Section::Append(Endianness endianness, size_t size, u_int64_t number) {
+Section &Section::Append(Endianness endianness, size_t size, uint64_t number) {
   InsertEndian(endianness, size, number,
                back_insert_iterator<string>(contents_));
   return *this;
@@ -228,7 +228,7 @@ Section &Section::Append(Endianness endianness, size_t size,
                          const Label &label) {
   // If this label's value is known, there's no reason to waste an
   // entry in references_ on it.
-  u_int64_t value;
+  uint64_t value;
   if (label.IsKnownConstant(&value))
     return Append(endianness, size, value);
 
@@ -246,7 +246,7 @@ Section &Section::Append(Endianness endianness, size_t size,
 #define ENDIANNESS(e) ENDIANNESS_ ## e
 
 #define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits)                      \
-  Section &Section::e ## bits(u_int ## bits ## _t v) {                  \
+  Section &Section::e ## bits(uint ## bits ## _t v) {                  \
     InsertEndian(ENDIANNESS(e), bits / 8, v,                            \
                  back_insert_iterator<string>(contents_));              \
     return *this;                                                       \
@@ -272,7 +272,7 @@ DEFINE_SHORT_APPEND_ENDIAN(B, 32);
 DEFINE_SHORT_APPEND_ENDIAN(B, 64);
 
 #define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits)                        \
-  Section &Section::D ## bits(u_int ## bits ## _t v) {                  \
+  Section &Section::D ## bits(uint ## bits ## _t v) {                  \
     InsertEndian(endianness_, bits / 8, v,                              \
                  back_insert_iterator<string>(contents_));              \
     return *this;                                                       \
@@ -312,7 +312,7 @@ Section &Section::LEB128(long long value) {
   return *this;
 }
 
-Section &Section::ULEB128(u_int64_t value) {
+Section &Section::ULEB128(uint64_t value) {
   while (value > 0x7f) {
     contents_ += (value & 0x7f) | 0x80;
     value = (value >> 7);
@@ -321,7 +321,7 @@ Section &Section::ULEB128(u_int64_t value) {
   return *this;
 }
 
-Section &Section::Align(size_t alignment, u_int8_t pad_byte) {
+Section &Section::Align(size_t alignment, uint8_t pad_byte) {
   // ALIGNMENT must be a power of two.
   assert(((alignment - 1) & alignment) == 0);
   size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1);
@@ -340,7 +340,7 @@ bool Section::GetContents(string *contents) {
   // the section's contents.
   for (size_t i = 0; i < references_.size(); i++) {
     Reference &r = references_[i];
-    u_int64_t value;
+    uint64_t value;
     if (!r.label.IsKnownConstant(&value)) {
       fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset);
       return false;
diff --git a/src/common/test_assembler.h b/src/common/test_assembler.h
index 891cf677..373dbeba 100644
--- a/src/common/test_assembler.h
+++ b/src/common/test_assembler.h
@@ -110,7 +110,7 @@ namespace test_assembler {
 class Label {
  public:
   Label();                      // An undefined label.
-  Label(u_int64_t value);       // A label with a fixed value
+  Label(uint64_t value);       // A label with a fixed value
   Label(const Label &value);    // A label equal to another.
   ~Label();
 
@@ -119,23 +119,23 @@ class Label {
   // Providing this as a cast operator is nifty, but the conversions
   // happen in unexpected places. In particular, ISO C++ says that
   // Label + size_t becomes ambigious, because it can't decide whether
-  // to convert the Label to a u_int64_t and then to a size_t, or use
+  // to convert the Label to a uint64_t and then to a size_t, or use
   // the overloaded operator that returns a new label, even though the
   // former could fail if the label is not yet defined and the latter won't.
-  u_int64_t Value() const;
+  uint64_t Value() const;
 
-  Label &operator=(u_int64_t value);
+  Label &operator=(uint64_t value);
   Label &operator=(const Label &value);
-  Label operator+(u_int64_t addend) const;
-  Label operator-(u_int64_t subtrahend) const;
-  u_int64_t operator-(const Label &subtrahend) const;
+  Label operator+(uint64_t addend) const;
+  Label operator-(uint64_t subtrahend) const;
+  uint64_t operator-(const Label &subtrahend) const;
 
   // We could also provide == and != that work on undefined, but
   // related, labels.
 
   // Return true if this label's value is known. If VALUE_P is given,
   // set *VALUE_P to the known value if returning true.
-  bool IsKnownConstant(u_int64_t *value_p = NULL) const;
+  bool IsKnownConstant(uint64_t *value_p = NULL) const;
 
   // Return true if the offset from LABEL to this label is known. If
   // OFFSET_P is given, set *OFFSET_P to the offset when returning true.
@@ -150,12 +150,12 @@ class Label {
   //   m = l + 10;
   //   l.IsKnownConstant();             // false
   //   m.IsKnownConstant();             // false
-  //   u_int64_t d;                     
+  //   uint64_t d;                     
   //   l.IsKnownOffsetFrom(m, &d);      // true, and sets d to -10.
   //   l-m                              // -10
   //   m-l                              // 10
   //   m.Value()                        // error: m's value is not known
-  bool IsKnownOffsetFrom(const Label &label, u_int64_t *offset_p = NULL) const;
+  bool IsKnownOffsetFrom(const Label &label, uint64_t *offset_p = NULL) const;
 
  private:
   // A label's value, or if that is not yet known, how the value is
@@ -173,7 +173,7 @@ class Label {
   class Binding {
    public:
     Binding();
-    Binding(u_int64_t addend);
+    Binding(uint64_t addend);
     ~Binding();
 
     // Increment our reference count.
@@ -186,7 +186,7 @@ class Label {
     // Update every binding on this binding's chain to point directly
     // to BINDING, or to be a constant, with addends adjusted
     // appropriately.
-    void Set(Binding *binding, u_int64_t value);
+    void Set(Binding *binding, uint64_t value);
 
     // Return what we know about the value of this binding.
     // - If this binding's value is a known constant, set BASE to
@@ -198,7 +198,7 @@ class Label {
     //   value.
     // - If this binding is unconstrained, set BASE to this, and leave
     //   ADDEND unchanged.
-    void Get(Binding **base, u_int64_t *addend);
+    void Get(Binding **base, uint64_t *addend);
 
    private:
     // There are three cases:
@@ -221,7 +221,7 @@ class Label {
     // binding on the chain to point directly to the final value,
     // adjusting addends as appropriate.
     Binding *base_;
-    u_int64_t addend_;
+    uint64_t addend_;
 
     // The number of Labels and Bindings pointing to this binding.
     // (When a binding points to itself, indicating a completely
@@ -233,7 +233,7 @@ class Label {
   Binding *value_;
 };
 
-inline Label operator+(u_int64_t a, const Label &l) { return l + a; }
+inline Label operator+(uint64_t a, const Label &l) { return l + a; }
 // Note that int-Label isn't defined, as negating a Label is not an
 // operation we support.
 
@@ -288,7 +288,7 @@ class Section {
 
   // Append the SIZE bytes at DATA or the contents of STRING to the
   // end of this section. Return a reference to this section.
-  Section &Append(const u_int8_t *data, size_t size) {
+  Section &Append(const uint8_t *data, size_t size) {
     contents_.append(reinterpret_cast<const char *>(data), size);
     return *this;
   };
@@ -299,7 +299,7 @@ class Section {
 
   // Append SIZE copies of BYTE to the end of this section. Return a
   // reference to this section.
-  Section &Append(size_t size, u_int8_t byte) {
+  Section &Append(size_t size, uint8_t byte) {
     contents_.append(size, (char) byte);
     return *this;
   }
@@ -307,7 +307,7 @@ class Section {
   // Append NUMBER to this section. ENDIANNESS is the endianness to
   // use to write the number. SIZE is the length of the number in
   // bytes. Return a reference to this section.
-  Section &Append(Endianness endianness, size_t size, u_int64_t number);
+  Section &Append(Endianness endianness, size_t size, uint64_t number);
   Section &Append(Endianness endianness, size_t size, const Label &label);
 
   // Append SECTION to the end of this section. The labels SECTION
@@ -352,12 +352,12 @@ class Section {
   // the compiler will properly sign-extend a signed value before
   // passing it to the function, at which point the function's
   // behavior is the same either way.
-  Section &L8(u_int8_t value) { contents_ += value; return *this; }
-  Section &B8(u_int8_t value) { contents_ += value; return *this; }
-  Section &D8(u_int8_t value) { contents_ += value; return *this; }
-  Section &L16(u_int16_t), &L32(u_int32_t), &L64(u_int64_t),
-          &B16(u_int16_t), &B32(u_int32_t), &B64(u_int64_t),
-          &D16(u_int16_t), &D32(u_int32_t), &D64(u_int64_t);
+  Section &L8(uint8_t value) { contents_ += value; return *this; }
+  Section &B8(uint8_t value) { contents_ += value; return *this; }
+  Section &D8(uint8_t value) { contents_ += value; return *this; }
+  Section &L16(uint16_t), &L32(uint32_t), &L64(uint64_t),
+          &B16(uint16_t), &B32(uint32_t), &B64(uint64_t),
+          &D16(uint16_t), &D32(uint32_t), &D64(uint64_t);
   Section &L8(const Label &label),  &L16(const Label &label),
           &L32(const Label &label), &L64(const Label &label),
           &B8(const Label &label),  &B16(const Label &label),
@@ -399,13 +399,13 @@ class Section {
   //
   // Note that VALUE cannot be a Label (we would have to implement
   // relaxation).
-  Section &ULEB128(u_int64_t value);
+  Section &ULEB128(uint64_t value);
 
   // Jump to the next location aligned on an ALIGNMENT-byte boundary,
   // relative to the start of the section. Fill the gap with PAD_BYTE.
   // ALIGNMENT must be a power of two. Return a reference to this
   // section.
-  Section &Align(size_t alignment, u_int8_t pad_byte = 0);
+  Section &Align(size_t alignment, uint8_t pad_byte = 0);
 
   // Clear the contents of this section.
   void Clear();
diff --git a/src/common/test_assembler_unittest.cc b/src/common/test_assembler_unittest.cc
index d4e95eff..94b5a5ce 100644
--- a/src/common/test_assembler_unittest.cc
+++ b/src/common/test_assembler_unittest.cc
@@ -60,7 +60,7 @@ TEST(ConstructLabelDeathTest, Undefined) {
 
 TEST(ConstructLabel, Constant) {
   Label l(0x060b9f974eaf301eULL);
-  u_int64_t v;
+  uint64_t v;
   EXPECT_TRUE(l.IsKnownConstant(&v));
   EXPECT_EQ(v, 0x060b9f974eaf301eULL);
   EXPECT_EQ(l.Value(), 0x060b9f974eaf301eULL);
@@ -69,7 +69,7 @@ TEST(ConstructLabel, Constant) {
 TEST(ConstructLabel, Copy) {
   Label l;
   Label m(l);
-  u_int64_t v;
+  uint64_t v;
   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &v));
   EXPECT_EQ(0U, v);
 }
@@ -82,7 +82,7 @@ TEST(Assignment, UnconstrainedToUnconstrained) {
   l = m;
   EXPECT_EQ(0U, l-m);
   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
   EXPECT_EQ(0U, d);
   EXPECT_FALSE(l.IsKnownConstant());
@@ -94,7 +94,7 @@ TEST(Assignment, UnconstrainedToRelated) {
   l = m;
   EXPECT_EQ(0U, l-m);
   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
   EXPECT_EQ(0U, d);
   EXPECT_FALSE(l.IsKnownConstant());
@@ -106,7 +106,7 @@ TEST(Assignment, UnconstrainedToKnown) {
   l = m;
   EXPECT_EQ(0U, l-m);
   EXPECT_TRUE(l.IsKnownOffsetFrom(m));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(l.IsKnownOffsetFrom(m, &d));
   EXPECT_EQ(0U, d);
   EXPECT_TRUE(m.IsKnownConstant());
@@ -119,7 +119,7 @@ TEST(Assignment, RelatedToUnconstrained) {
   l = m;
   EXPECT_EQ(0U, l-n);
   EXPECT_TRUE(l.IsKnownOffsetFrom(n));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(l.IsKnownOffsetFrom(n, &d));
   EXPECT_EQ(0U, d);
   EXPECT_FALSE(l.IsKnownConstant());
@@ -132,7 +132,7 @@ TEST(Assignment, RelatedToRelated) {
   l = m;
   EXPECT_EQ(0U, n-o);
   EXPECT_TRUE(n.IsKnownOffsetFrom(o));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(n.IsKnownOffsetFrom(o, &d));
   EXPECT_EQ(0U, d);
   EXPECT_FALSE(l.IsKnownConstant());
@@ -234,7 +234,7 @@ TEST(Addition, LabelConstant) {
   Label l, m;
   m = l + 0x5248d93e8bbe9497ULL;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(0x5248d93e8bbe9497ULL, d);
   EXPECT_FALSE(m.IsKnownConstant());
@@ -244,7 +244,7 @@ TEST(Addition, ConstantLabel) {
   Label l, m;
   m = 0xf51e94e00d6e3c84ULL + l;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(0xf51e94e00d6e3c84ULL, d);
   EXPECT_FALSE(m.IsKnownConstant());
@@ -255,7 +255,7 @@ TEST(Addition, KnownLabelConstant) {
   l = 0x16286307042ce0d8ULL;
   m = l + 0x3fdddd91306719d7ULL;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(0x3fdddd91306719d7ULL, d);
   EXPECT_TRUE(m.IsKnownConstant());
@@ -267,7 +267,7 @@ TEST(Addition, ConstantKnownLabel) {
   l = 0x50f62d0cdd1031deULL;
   m = 0x1b13462d8577c538ULL + l;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(0x1b13462d8577c538ULL, d);
   EXPECT_TRUE(m.IsKnownConstant());
@@ -278,7 +278,7 @@ TEST(Subtraction, LabelConstant) {
   Label l, m;
   m = l - 0x0620884d21d3138eULL;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(-0x0620884d21d3138eULL, d);
   EXPECT_FALSE(m.IsKnownConstant());
@@ -289,7 +289,7 @@ TEST(Subtraction, KnownLabelConstant) {
   l = 0x6237fbaf9ef7929eULL;
   m = l - 0x317730995d2ab6eeULL;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l));
-  u_int64_t d;
+  uint64_t d;
   EXPECT_TRUE(m.IsKnownOffsetFrom(l, &d));
   EXPECT_EQ(-0x317730995d2ab6eeULL, d);
   EXPECT_TRUE(m.IsKnownConstant());
@@ -475,10 +475,10 @@ TEST(LabelChain, AssignEndRelationBeforeForward) {
   b = a + 0x1;
   c = b + 0x10;
   d = c + 0x100;
-  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
-  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
-  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
-  EXPECT_EQ(-(u_int64_t)0U,     d-x);
+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
+  EXPECT_EQ(-(uint64_t)0U,     d-x);
 }
 
 TEST(LabelChain, AssignEndRelationBeforeBackward) {
@@ -488,10 +488,10 @@ TEST(LabelChain, AssignEndRelationBeforeBackward) {
   d = c + 0x100;
   c = b + 0x10;
   b = a + 0x1;
-  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
-  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
-  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
-  EXPECT_EQ(-(u_int64_t)0U,     d-x);
+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
+  EXPECT_EQ(-(uint64_t)0U,     d-x);
 }
 
 TEST(LabelChain, AssignEndRelationAfterForward) {
@@ -501,10 +501,10 @@ TEST(LabelChain, AssignEndRelationAfterForward) {
   c = b + 0x10;
   d = c + 0x100;
   x = d;
-  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
-  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
-  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
-  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
 }
 
 TEST(LabelChain, AssignEndRelationAfterBackward) {
@@ -514,10 +514,10 @@ TEST(LabelChain, AssignEndRelationAfterBackward) {
   c = b + 0x10;
   b = a + 0x1;
   x = d;
-  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
-  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
-  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
-  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
 }
 
 TEST(LabelChain, AssignEndValueBeforeForward) {
@@ -623,10 +623,10 @@ TEST(LabelChain, ConstructEndRelationAfterForward) {
   Label c(b + 0x10);
   Label d(c + 0x100);
   x = d;
-  EXPECT_EQ(-(u_int64_t)0x111U, a-x);
-  EXPECT_EQ(-(u_int64_t)0x110U, b-x);
-  EXPECT_EQ(-(u_int64_t)0x100U, c-x);
-  EXPECT_EQ(-(u_int64_t)0x000U, d-x);
+  EXPECT_EQ(-(uint64_t)0x111U, a-x);
+  EXPECT_EQ(-(uint64_t)0x110U, b-x);
+  EXPECT_EQ(-(uint64_t)0x100U, c-x);
+  EXPECT_EQ(-(uint64_t)0x000U, d-x);
 }
 
 TEST(LabelChain, ConstructEndValueAfterForward) {
@@ -732,11 +732,11 @@ class SectionFixture {
  public:
   Section section;
   string contents;
-  static const u_int8_t data[];
+  static const uint8_t data[];
   static const size_t data_size;
 };
 
-const u_int8_t SectionFixture::data[] = {
+const uint8_t SectionFixture::data[] = {
   0x87, 0x4f, 0x43, 0x67, 0x30, 0xd0, 0xd4, 0x0e
 };
 
@@ -753,7 +753,7 @@ const u_int8_t SectionFixture::data[] = {
 #define ASSERT_BYTES(s, b)                                              \
   do                                                                    \
     {                                                                   \
-      static const u_int8_t expected_bytes[] = b;                       \
+      static const uint8_t expected_bytes[] = b;                       \
       ASSERT_EQ(sizeof(expected_bytes), s.size());                      \
       ASSERT_TRUE(memcmp(s.data(), (const char *) expected_bytes,       \
                          sizeof(expected_bytes)) == 0);                 \
@@ -1361,7 +1361,7 @@ TEST_F(Append, Variety) {
   ASSERT_EQ(8 * 18U, section.Size());
   ASSERT_TRUE(section.GetContents(&contents));
 
-  static const u_int8_t expected[] = {
+  static const uint8_t expected[] = {
     0x35,    0xa6, 0x6b, 0x28, 0xf7, 0xa8, 0x99, 0xa1, 0x61,
     0x8b,    0x39, 0x44, 0x8f, 0x44, 0x40, 0x65, 0xa5, 0x0e,
     0xc9, 0x1c,    0x5e, 0x87, 0xbf, 0xa4, 0x28, 0xb9, 0xf4,
diff --git a/src/google_breakpad/common/breakpad_types.h b/src/google_breakpad/common/breakpad_types.h
index 926b47f2..a6545be5 100644
--- a/src/google_breakpad/common/breakpad_types.h
+++ b/src/google_breakpad/common/breakpad_types.h
@@ -31,7 +31,7 @@
  *
  * (This is C99 source, please don't corrupt it with C++.)
  *
- * This file ensures that types u_intN_t are defined for N = 8, 16, 32, and
+ * This file ensures that types uintN_t are defined for N = 8, 16, 32, and
  * 64.  Types of precise widths are crucial to the task of writing data
  * structures on one platform and reading them on another.
  *
@@ -42,36 +42,38 @@
 
 #ifndef _WIN32
 
-#include <sys/types.h>
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif  /* __STDC_FORMAT_MACROS */
 #include <inttypes.h>
 
-#if defined(__SUNPRO_CC) || (defined(__GNUC__) && defined(__sun__))
-typedef uint8_t u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
-#endif
-
 #else  /* !_WIN32 */
 
+#if _MSC_VER >= 1600
+#include <stdint.h>
+#elif defined(BREAKPAD_CUSTOM_STDINT_H)
+/* Visual C++ Pre-2010 did not ship a stdint.h, so allow
+ * consumers of this library to provide their own because
+ * there are often subtle type incompatibilities.
+ */
+#include BREAKPAD_CUSTOM_STDINT_H
+#else
 #include <WTypes.h>
 
-typedef unsigned __int8  u_int8_t;
-typedef unsigned __int16 u_int16_t;
-typedef unsigned __int32 u_int32_t;
-typedef unsigned __int64 u_int64_t;
+typedef unsigned __int8  uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+#endif
 
 #endif  /* !_WIN32 */
 
 typedef struct {
-  u_int64_t high;
-  u_int64_t low;
-} u_int128_t;
+  uint64_t high;
+  uint64_t low;
+} uint128_struct;
 
-typedef u_int64_t breakpad_time_t;
+typedef uint64_t breakpad_time_t;
 
 /* Try to get PRIx64 from inttypes.h, but if it's not defined, fall back to
  * llx, which is the format string for "long long" - this is a 64-bit
diff --git a/src/google_breakpad/common/minidump_cpu_amd64.h b/src/google_breakpad/common/minidump_cpu_amd64.h
index fa6a9961..4256706d 100644
--- a/src/google_breakpad/common/minidump_cpu_amd64.h
+++ b/src/google_breakpad/common/minidump_cpu_amd64.h
@@ -67,7 +67,7 @@
  * equivalent types and values in the Windows Platform SDK are given in
  * comments.
  *
- * Author: Mark Mentovai 
+ * Author: Mark Mentovai
  * Change to split into its own file: Neal Sidhwaney */
 
 #ifndef GOOGLE_BREAKPAD_COMMON_MINIDUMP_CPU_AMD64_H__
@@ -79,22 +79,22 @@
  */
 
 typedef struct {
-  u_int16_t  control_word;
-  u_int16_t  status_word;
-  u_int8_t   tag_word;
-  u_int8_t   reserved1;
-  u_int16_t  error_opcode;
-  u_int32_t  error_offset;
-  u_int16_t  error_selector;
-  u_int16_t  reserved2;
-  u_int32_t  data_offset;
-  u_int16_t  data_selector;
-  u_int16_t  reserved3;
-  u_int32_t  mx_csr;
-  u_int32_t  mx_csr_mask;
-  u_int128_t float_registers[8];
-  u_int128_t xmm_registers[16];
-  u_int8_t   reserved4[96];
+  uint16_t       control_word;
+  uint16_t       status_word;
+  uint8_t        tag_word;
+  uint8_t        reserved1;
+  uint16_t       error_opcode;
+  uint32_t       error_offset;
+  uint16_t       error_selector;
+  uint16_t       reserved2;
+  uint32_t       data_offset;
+  uint16_t       data_selector;
+  uint16_t       reserved3;
+  uint32_t       mx_csr;
+  uint32_t       mx_csr_mask;
+  uint128_struct float_registers[8];
+  uint128_struct xmm_registers[16];
+  uint8_t        reserved4[96];
 } MDXmmSaveArea32AMD64;  /* XMM_SAVE_AREA32 */
 
 #define MD_CONTEXT_AMD64_VR_COUNT 26
@@ -103,63 +103,63 @@ typedef struct {
   /*
    * Register parameter home addresses.
    */
-  u_int64_t  p1_home;
-  u_int64_t  p2_home;
-  u_int64_t  p3_home;
-  u_int64_t  p4_home;
-  u_int64_t  p5_home;
-  u_int64_t  p6_home;
+  uint64_t  p1_home;
+  uint64_t  p2_home;
+  uint64_t  p3_home;
+  uint64_t  p4_home;
+  uint64_t  p5_home;
+  uint64_t  p6_home;
 
   /* The next field determines the layout of the structure, and which parts
    * of it are populated */
-  u_int32_t  context_flags;
-  u_int32_t  mx_csr;
+  uint32_t  context_flags;
+  uint32_t  mx_csr;
 
   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
-  u_int16_t  cs;
+  uint16_t  cs;
 
   /* The next 4 registers are included with MD_CONTEXT_AMD64_SEGMENTS */
-  u_int16_t  ds;
-  u_int16_t  es;
-  u_int16_t  fs;
-  u_int16_t  gs;
+  uint16_t  ds;
+  uint16_t  es;
+  uint16_t  fs;
+  uint16_t  gs;
 
   /* The next 2 registers are included with MD_CONTEXT_AMD64_CONTROL */
-  u_int16_t  ss;
-  u_int32_t  eflags;
-  
+  uint16_t  ss;
+  uint32_t  eflags;
+
   /* The next 6 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */
-  u_int64_t  dr0;
-  u_int64_t  dr1;
-  u_int64_t  dr2;
-  u_int64_t  dr3;
-  u_int64_t  dr6;
-  u_int64_t  dr7;
+  uint64_t  dr0;
+  uint64_t  dr1;
+  uint64_t  dr2;
+  uint64_t  dr3;
+  uint64_t  dr6;
+  uint64_t  dr7;
 
   /* The next 4 registers are included with MD_CONTEXT_AMD64_INTEGER */
-  u_int64_t  rax;
-  u_int64_t  rcx;
-  u_int64_t  rdx;
-  u_int64_t  rbx;
+  uint64_t  rax;
+  uint64_t  rcx;
+  uint64_t  rdx;
+  uint64_t  rbx;
 
   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
-  u_int64_t  rsp;
+  uint64_t  rsp;
 
   /* The next 11 registers are included with MD_CONTEXT_AMD64_INTEGER */
-  u_int64_t  rbp;
-  u_int64_t  rsi;
-  u_int64_t  rdi;
-  u_int64_t  r8;
-  u_int64_t  r9;
-  u_int64_t  r10;
-  u_int64_t  r11;
-  u_int64_t  r12;
-  u_int64_t  r13;
-  u_int64_t  r14;
-  u_int64_t  r15;
+  uint64_t  rbp;
+  uint64_t  rsi;
+  uint64_t  rdi;
+  uint64_t  r8;
+  uint64_t  r9;
+  uint64_t  r10;
+  uint64_t  r11;
+  uint64_t  r12;
+  uint64_t  r13;
+  uint64_t  r14;
+  uint64_t  r15;
 
   /* The next register is included with MD_CONTEXT_AMD64_CONTROL */
-  u_int64_t  rip;
+  uint64_t  rip;
 
   /* The next set of registers are included with
    * MD_CONTEXT_AMD64_FLOATING_POINT
@@ -167,37 +167,37 @@ typedef struct {
   union {
     MDXmmSaveArea32AMD64 flt_save;
     struct {
-      u_int128_t header[2];
-      u_int128_t legacy[8];
-      u_int128_t xmm0;
-      u_int128_t xmm1;
-      u_int128_t xmm2;
-      u_int128_t xmm3;
-      u_int128_t xmm4;
-      u_int128_t xmm5;
-      u_int128_t xmm6;
-      u_int128_t xmm7;
-      u_int128_t xmm8;
-      u_int128_t xmm9;
-      u_int128_t xmm10;
-      u_int128_t xmm11;
-      u_int128_t xmm12;
-      u_int128_t xmm13;
-      u_int128_t xmm14;
-      u_int128_t xmm15;
+      uint128_struct header[2];
+      uint128_struct legacy[8];
+      uint128_struct xmm0;
+      uint128_struct xmm1;
+      uint128_struct xmm2;
+      uint128_struct xmm3;
+      uint128_struct xmm4;
+      uint128_struct xmm5;
+      uint128_struct xmm6;
+      uint128_struct xmm7;
+      uint128_struct xmm8;
+      uint128_struct xmm9;
+      uint128_struct xmm10;
+      uint128_struct xmm11;
+      uint128_struct xmm12;
+      uint128_struct xmm13;
+      uint128_struct xmm14;
+      uint128_struct xmm15;
     } sse_registers;
   };
 
-  u_int128_t vector_register[MD_CONTEXT_AMD64_VR_COUNT];
-  u_int64_t  vector_control;
+  uint128_struct vector_register[MD_CONTEXT_AMD64_VR_COUNT];
+  uint64_t       vector_control;
 
   /* The next 5 registers are included with MD_CONTEXT_AMD64_DEBUG_REGISTERS */
-  u_int64_t debug_control;
-  u_int64_t last_branch_to_rip;
-  u_int64_t last_branch_from_rip;
-  u_int64_t last_exception_to_rip;
-  u_int64_t last_exception_from_rip;
-  
+  uint64_t debug_control;
+  uint64_t last_branch_to_rip;
+  uint64_t last_branch_from_rip;
+  uint64_t last_exception_to_rip;
+  uint64_t last_exception_from_rip;
+
 } MDRawContextAMD64;  /* CONTEXT */
 
 /* For (MDRawContextAMD64).context_flags.  These values indicate the type of
diff --git a/src/google_breakpad/common/minidump_cpu_arm.h b/src/google_breakpad/common/minidump_cpu_arm.h
index dd071293..6a711383 100644
--- a/src/google_breakpad/common/minidump_cpu_arm.h
+++ b/src/google_breakpad/common/minidump_cpu_arm.h
@@ -77,13 +77,13 @@
  * are not exactly minidumps.
  */
 typedef struct {
-  u_int64_t	fpscr;      /* FPU status register */
+  uint64_t      fpscr;      /* FPU status register */
 
   /* 32 64-bit floating point registers, d0 .. d31. */
-  u_int64_t	regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT];
+  uint64_t      regs[MD_FLOATINGSAVEAREA_ARM_FPR_COUNT];
 
   /* Miscellaneous control words */
-  u_int32_t     extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT];
+  uint32_t     extra[MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT];
 } MDFloatingSaveAreaARM;
 
 #define MD_CONTEXT_ARM_GPR_COUNT 16
@@ -92,7 +92,7 @@ typedef struct {
   /* The next field determines the layout of the structure, and which parts
    * of it are populated
    */
-  u_int32_t	context_flags;
+  uint32_t      context_flags;
 
   /* 16 32-bit integer registers, r0 .. r15
    * Note the following fixed uses:
@@ -100,7 +100,7 @@ typedef struct {
    *   r14 is the link register
    *   r15 is the program counter
    */
-  u_int32_t     iregs[MD_CONTEXT_ARM_GPR_COUNT];
+  uint32_t     iregs[MD_CONTEXT_ARM_GPR_COUNT];
 
   /* CPSR (flags, basically): 32 bits:
         bit 31 - N (negative)
@@ -109,14 +109,14 @@ typedef struct {
         bit 28 - V (overflow)
         bit 27 - Q (saturation flag, sticky)
      All other fields -- ignore */
-  u_int32_t    cpsr;
+  uint32_t    cpsr;
 
   /* The next field is included with MD_CONTEXT_ARM_FLOATING_POINT */
   MDFloatingSaveAreaARM float_save;
 
 } MDRawContextARM;
 
-/* Indices into iregs for registers with a dedicated or conventional 
+/* Indices into iregs for registers with a dedicated or conventional
  * purpose.
  */
 enum MDARMRegisterNumbers {
diff --git a/src/google_breakpad/common/minidump_cpu_ppc.h b/src/google_breakpad/common/minidump_cpu_ppc.h
index 038e921a..02ac3220 100644
--- a/src/google_breakpad/common/minidump_cpu_ppc.h
+++ b/src/google_breakpad/common/minidump_cpu_ppc.h
@@ -81,11 +81,11 @@
 #define MD_FLOATINGSAVEAREA_PPC_FPR_COUNT 32
 
 typedef struct {
-  /* fpregs is a double[32] in mach/ppc/_types.h, but a u_int64_t is used
+  /* fpregs is a double[32] in mach/ppc/_types.h, but a uint64_t is used
    * here for precise sizing. */
-  u_int64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT];
-  u_int32_t fpscr_pad;
-  u_int32_t fpscr;      /* Status/control */
+  uint64_t fpregs[MD_FLOATINGSAVEAREA_PPC_FPR_COUNT];
+  uint32_t fpscr_pad;
+  uint32_t fpscr;      /* Status/control */
 } MDFloatingSaveAreaPPC;  /* Based on ppc_float_state */
 
 
@@ -94,11 +94,11 @@ typedef struct {
 typedef struct {
   /* Vector registers (including vscr) are 128 bits, but mach/ppc/_types.h
    * exposes them as four 32-bit quantities. */
-  u_int128_t save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT];
-  u_int128_t save_vscr;  /* Status/control */
-  u_int32_t  save_pad5[4];
-  u_int32_t  save_vrvalid;  /* Identifies which vector registers are saved */
-  u_int32_t  save_pad6[7];
+  uint128_struct save_vr[MD_VECTORSAVEAREA_PPC_VR_COUNT];
+  uint128_struct save_vscr;  /* Status/control */
+  uint32_t       save_pad5[4];
+  uint32_t       save_vrvalid;  /* Indicates which vector registers are saved */
+  uint32_t       save_pad6[7];
 } MDVectorSaveAreaPPC;  /* ppc_vector_state */
 
 
@@ -117,21 +117,21 @@ typedef struct {
   /* context_flags is not present in ppc_thread_state, but it aids
    * identification of MDRawContextPPC among other raw context types,
    * and it guarantees alignment when we get to float_save. */
-  u_int32_t             context_flags;
+  uint32_t              context_flags;
 
-  u_int32_t             srr0;    /* Machine status save/restore: stores pc
+  uint32_t              srr0;    /* Machine status save/restore: stores pc
                                   * (instruction) */
-  u_int32_t             srr1;    /* Machine status save/restore: stores msr
+  uint32_t              srr1;    /* Machine status save/restore: stores msr
                                   * (ps, program/machine state) */
   /* ppc_thread_state contains 32 fields, r0 .. r31.  Here, an array is
    * used for brevity. */
-  u_int32_t             gpr[MD_CONTEXT_PPC_GPR_COUNT];
-  u_int32_t             cr;      /* Condition */
-  u_int32_t             xer;     /* Integer (fiXed-point) exception */
-  u_int32_t             lr;      /* Link */
-  u_int32_t             ctr;     /* Count */
-  u_int32_t             mq;      /* Multiply/Quotient (PPC 601, POWER only) */
-  u_int32_t             vrsave;  /* Vector save */
+  uint32_t              gpr[MD_CONTEXT_PPC_GPR_COUNT];
+  uint32_t              cr;      /* Condition */
+  uint32_t              xer;     /* Integer (fiXed-point) exception */
+  uint32_t              lr;      /* Link */
+  uint32_t              ctr;     /* Count */
+  uint32_t              mq;      /* Multiply/Quotient (PPC 601, POWER only) */
+  uint32_t              vrsave;  /* Vector save */
 
   /* float_save and vector_save aren't present in ppc_thread_state, but
    * are represented in separate structures that still define a thread's
diff --git a/src/google_breakpad/common/minidump_cpu_ppc64.h b/src/google_breakpad/common/minidump_cpu_ppc64.h
index a788e5d1..da4f8723 100644
--- a/src/google_breakpad/common/minidump_cpu_ppc64.h
+++ b/src/google_breakpad/common/minidump_cpu_ppc64.h
@@ -90,20 +90,20 @@ typedef struct {
   /* context_flags is not present in ppc_thread_state, but it aids
    * identification of MDRawContextPPC among other raw context types,
    * and it guarantees alignment when we get to float_save. */
-  u_int64_t             context_flags;
+  uint64_t              context_flags;
 
-  u_int64_t             srr0;    /* Machine status save/restore: stores pc
+  uint64_t              srr0;    /* Machine status save/restore: stores pc
                                   * (instruction) */
-  u_int64_t             srr1;    /* Machine status save/restore: stores msr
+  uint64_t              srr1;    /* Machine status save/restore: stores msr
                                   * (ps, program/machine state) */
   /* ppc_thread_state contains 32 fields, r0 .. r31.  Here, an array is
    * used for brevity. */
-  u_int64_t             gpr[MD_CONTEXT_PPC64_GPR_COUNT];
-  u_int64_t             cr;      /* Condition */
-  u_int64_t             xer;     /* Integer (fiXed-point) exception */
-  u_int64_t             lr;      /* Link */
-  u_int64_t             ctr;     /* Count */
-  u_int64_t             vrsave;  /* Vector save */
+  uint64_t              gpr[MD_CONTEXT_PPC64_GPR_COUNT];
+  uint64_t              cr;      /* Condition */
+  uint64_t              xer;     /* Integer (fiXed-point) exception */
+  uint64_t              lr;      /* Link */
+  uint64_t              ctr;     /* Count */
+  uint64_t              vrsave;  /* Vector save */
 
   /* float_save and vector_save aren't present in ppc_thread_state, but
    * are represented in separate structures that still define a thread's
diff --git a/src/google_breakpad/common/minidump_cpu_sparc.h b/src/google_breakpad/common/minidump_cpu_sparc.h
index ee95b64e..ddc4c759 100644
--- a/src/google_breakpad/common/minidump_cpu_sparc.h
+++ b/src/google_breakpad/common/minidump_cpu_sparc.h
@@ -82,10 +82,10 @@
 typedef struct {
 
   /* FPU floating point regs */
-  u_int64_t	regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT];
+  uint64_t      regs[MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT];
 
-  u_int64_t	filler;
-  u_int64_t	fsr;        /* FPU status register */
+  uint64_t      filler;
+  uint64_t      fsr;        /* FPU status register */
 } MDFloatingSaveAreaSPARC;  /* FLOATING_SAVE_AREA */
 
 #define MD_CONTEXT_SPARC_GPR_COUNT 32
@@ -94,8 +94,8 @@ typedef struct {
   /* The next field determines the layout of the structure, and which parts
    * of it are populated
    */
-  u_int32_t	context_flags;
-  u_int32_t	flag_pad;
+  uint32_t      context_flags;
+  uint32_t      flag_pad;
   /*
    * General register access (SPARC).
    * Don't confuse definitions here with definitions in <sys/regset.h>.
@@ -110,28 +110,28 @@ typedef struct {
    * g_r[16-23] local registers(l0-l7)
    * g_r[24-31] in registers(i0-i7)
    */
-  u_int64_t     g_r[MD_CONTEXT_SPARC_GPR_COUNT];
+  uint64_t     g_r[MD_CONTEXT_SPARC_GPR_COUNT];
 
   /* several control registers */
 
   /* Processor State register(PSR) for SPARC V7/V8
    * Condition Code register (CCR) for SPARC V9
    */
-  u_int64_t     ccr;
+  uint64_t     ccr;
 
-  u_int64_t     pc;     /* Program Counter register (PC) */
-  u_int64_t     npc;    /* Next Program Counter register (nPC) */
-  u_int64_t     y;      /* Y register (Y) */
+  uint64_t     pc;     /* Program Counter register (PC) */
+  uint64_t     npc;    /* Next Program Counter register (nPC) */
+  uint64_t     y;      /* Y register (Y) */
 
   /* Address Space Identifier register (ASI) for SPARC V9
    * WIM for SPARC V7/V8
    */
-  u_int64_t     asi;
+  uint64_t     asi;
 
   /* Floating-Point Registers State register (FPRS) for SPARC V9
    * TBR for for SPARC V7/V8
    */
-  u_int64_t     fprs;
+  uint64_t     fprs;
 
   /* The next field is included with MD_CONTEXT_SPARC_FLOATING_POINT */
   MDFloatingSaveAreaSPARC float_save;
diff --git a/src/google_breakpad/common/minidump_cpu_x86.h b/src/google_breakpad/common/minidump_cpu_x86.h
index 32aff8a7..e09cb7cb 100644
--- a/src/google_breakpad/common/minidump_cpu_x86.h
+++ b/src/google_breakpad/common/minidump_cpu_x86.h
@@ -76,18 +76,18 @@
      /* SIZE_OF_80387_REGISTERS */
 
 typedef struct {
-  u_int32_t control_word;
-  u_int32_t status_word;
-  u_int32_t tag_word;
-  u_int32_t error_offset;
-  u_int32_t error_selector;
-  u_int32_t data_offset;
-  u_int32_t data_selector;
+  uint32_t control_word;
+  uint32_t status_word;
+  uint32_t tag_word;
+  uint32_t error_offset;
+  uint32_t error_selector;
+  uint32_t data_offset;
+  uint32_t data_selector;
 
   /* register_area contains eight 80-bit (x87 "long double") quantities for
    * floating-point registers %st0 (%mm0) through %st7 (%mm7). */
-  u_int8_t  register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE];
-  u_int32_t cr0_npx_state;
+  uint8_t  register_area[MD_FLOATINGSAVEAREA_X86_REGISTERAREA_SIZE];
+  uint32_t cr0_npx_state;
 } MDFloatingSaveAreaX86;  /* FLOATING_SAVE_AREA */
 
 
@@ -97,46 +97,46 @@ typedef struct {
 typedef struct {
   /* The next field determines the layout of the structure, and which parts
    * of it are populated */
-  u_int32_t             context_flags;
+  uint32_t             context_flags;
 
   /* The next 6 registers are included with MD_CONTEXT_X86_DEBUG_REGISTERS */
-  u_int32_t             dr0;
-  u_int32_t             dr1;
-  u_int32_t             dr2;
-  u_int32_t             dr3;
-  u_int32_t             dr6;
-  u_int32_t             dr7;
+  uint32_t             dr0;
+  uint32_t             dr1;
+  uint32_t             dr2;
+  uint32_t             dr3;
+  uint32_t             dr6;
+  uint32_t             dr7;
 
   /* The next field is included with MD_CONTEXT_X86_FLOATING_POINT */
   MDFloatingSaveAreaX86 float_save;
 
   /* The next 4 registers are included with MD_CONTEXT_X86_SEGMENTS */
-  u_int32_t             gs; 
-  u_int32_t             fs;
-  u_int32_t             es;
-  u_int32_t             ds;
+  uint32_t             gs; 
+  uint32_t             fs;
+  uint32_t             es;
+  uint32_t             ds;
   /* The next 6 registers are included with MD_CONTEXT_X86_INTEGER */
-  u_int32_t             edi;
-  u_int32_t             esi;
-  u_int32_t             ebx;
-  u_int32_t             edx;
-  u_int32_t             ecx;
-  u_int32_t             eax;
+  uint32_t             edi;
+  uint32_t             esi;
+  uint32_t             ebx;
+  uint32_t             edx;
+  uint32_t             ecx;
+  uint32_t             eax;
 
   /* The next 6 registers are included with MD_CONTEXT_X86_CONTROL */
-  u_int32_t             ebp;
-  u_int32_t             eip;
-  u_int32_t             cs;      /* WinNT.h says "must be sanitized" */
-  u_int32_t             eflags;  /* WinNT.h says "must be sanitized" */
-  u_int32_t             esp;
-  u_int32_t             ss;
+  uint32_t             ebp;
+  uint32_t             eip;
+  uint32_t             cs;      /* WinNT.h says "must be sanitized" */
+  uint32_t             eflags;  /* WinNT.h says "must be sanitized" */
+  uint32_t             esp;
+  uint32_t             ss;
 
   /* The next field is included with MD_CONTEXT_X86_EXTENDED_REGISTERS.
    * It contains vector (MMX/SSE) registers.  It it laid out in the
    * format used by the fxsave and fsrstor instructions, so it includes
    * a copy of the x87 floating-point registers as well.  See FXSAVE in
    * "Intel Architecture Software Developer's Manual, Volume 2." */
-  u_int8_t              extended_registers[
+  uint8_t              extended_registers[
                          MD_CONTEXT_X86_EXTENDED_REGISTERS_SIZE];
 } MDRawContextX86;  /* CONTEXT */
 
diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h
index 28a81d41..af8cab0a 100644
--- a/src/google_breakpad/common/minidump_format.h
+++ b/src/google_breakpad/common/minidump_format.h
@@ -79,10 +79,10 @@
  */
 
 typedef struct {
-  u_int32_t data1;
-  u_int16_t data2;
-  u_int16_t data3;
-  u_int8_t  data4[8];
+  uint32_t data1;
+  uint16_t data2;
+  uint16_t data3;
+  uint8_t  data4[8];
 } MDGUID;  /* GUID */
 
 
@@ -110,7 +110,7 @@ typedef struct {
  * structure should never be allocated directly.  The actual structure type
  * can be determined by examining the context_flags field. */
 typedef struct {
-  u_int32_t context_flags;
+  uint32_t context_flags;
 } MDRawContextBase;
 
 #include "minidump_cpu_amd64.h"
@@ -126,19 +126,19 @@ typedef struct {
 
 
 typedef struct {
-  u_int32_t signature;
-  u_int32_t struct_version;
-  u_int32_t file_version_hi;
-  u_int32_t file_version_lo;
-  u_int32_t product_version_hi;
-  u_int32_t product_version_lo;
-  u_int32_t file_flags_mask;    /* Identifies valid bits in fileFlags */
-  u_int32_t file_flags;
-  u_int32_t file_os;
-  u_int32_t file_type;
-  u_int32_t file_subtype;
-  u_int32_t file_date_hi;
-  u_int32_t file_date_lo;
+  uint32_t signature;
+  uint32_t struct_version;
+  uint32_t file_version_hi;
+  uint32_t file_version_lo;
+  uint32_t product_version_hi;
+  uint32_t product_version_lo;
+  uint32_t file_flags_mask;    /* Identifies valid bits in fileFlags */
+  uint32_t file_flags;
+  uint32_t file_os;
+  uint32_t file_type;
+  uint32_t file_subtype;
+  uint32_t file_date_hi;
+  uint32_t file_date_lo;
 } MDVSFixedFileInfo;  /* VS_FIXEDFILEINFO */
 
 /* For (MDVSFixedFileInfo).signature */
@@ -231,10 +231,10 @@ typedef struct {
 
 /* An MDRVA is an offset into the minidump file.  The beginning of the
  * MDRawHeader is at offset 0. */
-typedef u_int32_t MDRVA;  /* RVA */
+typedef uint32_t MDRVA;  /* RVA */
 
 typedef struct {
-  u_int32_t data_size;
+  uint32_t  data_size;
   MDRVA     rva;
 } MDLocationDescriptor;  /* MINIDUMP_LOCATION_DESCRIPTOR */
 
@@ -242,22 +242,22 @@ typedef struct {
 typedef struct {
   /* The base address of the memory range on the host that produced the
    * minidump. */
-  u_int64_t            start_of_memory_range;
+  uint64_t             start_of_memory_range;
 
   MDLocationDescriptor memory;
 } MDMemoryDescriptor;  /* MINIDUMP_MEMORY_DESCRIPTOR */
 
 
 typedef struct {
-  u_int32_t signature;
-  u_int32_t version;
-  u_int32_t stream_count;
+  uint32_t  signature;
+  uint32_t  version;
+  uint32_t  stream_count;
   MDRVA     stream_directory_rva;  /* A |stream_count|-sized array of
                                     * MDRawDirectory structures. */
-  u_int32_t checksum;              /* Can be 0.  In fact, that's all that's
+  uint32_t  checksum;              /* Can be 0.  In fact, that's all that's
                                     * been found in minidump files. */
-  u_int32_t time_date_stamp;       /* time_t */
-  u_int64_t flags;
+  uint32_t  time_date_stamp;       /* time_t */
+  uint64_t  flags;
 } MDRawHeader;  /* MINIDUMP_HEADER */
 
 /* For (MDRawHeader).signature and (MDRawHeader).version.  Note that only the
@@ -302,7 +302,7 @@ typedef enum {
 
 
 typedef struct {
-  u_int32_t            stream_type;
+  uint32_t             stream_type;
   MDLocationDescriptor location;
 } MDRawDirectory;  /* MINIDUMP_DIRECTORY */
 
@@ -346,27 +346,27 @@ typedef enum {
 
 
 typedef struct {
-  u_int32_t length;     /* Length of buffer in bytes (not characters),
+  uint32_t length;     /* Length of buffer in bytes (not characters),
                          * excluding 0-terminator */
-  u_int16_t buffer[1];  /* UTF-16-encoded, 0-terminated */
+  uint16_t buffer[1];  /* UTF-16-encoded, 0-terminated */
 } MDString;  /* MINIDUMP_STRING */
 
 static const size_t MDString_minsize = offsetof(MDString, buffer[0]);
 
 
 typedef struct {
-  u_int32_t            thread_id;
-  u_int32_t            suspend_count;
-  u_int32_t            priority_class;
-  u_int32_t            priority;
-  u_int64_t            teb;             /* Thread environment block */
+  uint32_t             thread_id;
+  uint32_t             suspend_count;
+  uint32_t             priority_class;
+  uint32_t             priority;
+  uint64_t             teb;             /* Thread environment block */
   MDMemoryDescriptor   stack;
   MDLocationDescriptor thread_context;  /* MDRawContext[CPU] */
 } MDRawThread;  /* MINIDUMP_THREAD */
 
 
 typedef struct {
-  u_int32_t   number_of_threads;
+  uint32_t    number_of_threads;
   MDRawThread threads[1];
 } MDRawThreadList;  /* MINIDUMP_THREAD_LIST */
 
@@ -375,10 +375,10 @@ static const size_t MDRawThreadList_minsize = offsetof(MDRawThreadList,
 
 
 typedef struct {
-  u_int64_t            base_of_image;
-  u_int32_t            size_of_image;
-  u_int32_t            checksum;         /* 0 if unknown */
-  u_int32_t            time_date_stamp;  /* time_t */
+  uint64_t             base_of_image;
+  uint32_t             size_of_image;
+  uint32_t             checksum;         /* 0 if unknown */
+  uint32_t             time_date_stamp;  /* time_t */
   MDRVA                module_name_rva;  /* MDString, pathname or filename */
   MDVSFixedFileInfo    version_info;
 
@@ -402,8 +402,8 @@ typedef struct {
    * As a workaround, reserved0 and reserved1 are instead defined here as
    * four 32-bit quantities.  This should be harmless, as there are
    * currently no known uses for these fields. */
-  u_int32_t            reserved0[2];
-  u_int32_t            reserved1[2];
+  uint32_t             reserved0[2];
+  uint32_t             reserved1[2];
 } MDRawModule;  /* MINIDUMP_MODULE */
 
 /* The inclusion of a 64-bit type in MINIDUMP_MODULE forces the struct to
@@ -419,15 +419,15 @@ typedef struct {
  * MDCVInfoPDB70 is the expected structure type with recent toolchains. */
 
 typedef struct {
-  u_int32_t signature;
-  u_int32_t offset;     /* Offset to debug data (expect 0 in minidump) */
+  uint32_t signature;
+  uint32_t offset;     /* Offset to debug data (expect 0 in minidump) */
 } MDCVHeader;
 
 typedef struct {
   MDCVHeader cv_header;
-  u_int32_t  signature;         /* time_t debug information created */
-  u_int32_t  age;               /* revision of PDB file */
-  u_int8_t   pdb_file_name[1];  /* Pathname or filename of PDB file */
+  uint32_t   signature;         /* time_t debug information created */
+  uint32_t   age;               /* revision of PDB file */
+  uint8_t    pdb_file_name[1];  /* Pathname or filename of PDB file */
 } MDCVInfoPDB20;
 
 static const size_t MDCVInfoPDB20_minsize = offsetof(MDCVInfoPDB20,
@@ -436,10 +436,10 @@ static const size_t MDCVInfoPDB20_minsize = offsetof(MDCVInfoPDB20,
 #define MD_CVINFOPDB20_SIGNATURE 0x3031424e  /* cvHeader.signature = '01BN' */
 
 typedef struct {
-  u_int32_t cv_signature;
+  uint32_t  cv_signature;
   MDGUID    signature;         /* GUID, identifies PDB file */
-  u_int32_t age;               /* Identifies incremental changes to PDB file */
-  u_int8_t  pdb_file_name[1];  /* Pathname or filename of PDB file,
+  uint32_t  age;               /* Identifies incremental changes to PDB file */
+  uint8_t   pdb_file_name[1];  /* Pathname or filename of PDB file,
                                 * 0-terminated 8-bit character data (UTF-8?) */
 } MDCVInfoPDB70;
 
@@ -449,12 +449,12 @@ static const size_t MDCVInfoPDB70_minsize = offsetof(MDCVInfoPDB70,
 #define MD_CVINFOPDB70_SIGNATURE 0x53445352  /* cvSignature = 'SDSR' */
 
 typedef struct {
-  u_int32_t data1[2];
-  u_int32_t data2;
-  u_int32_t data3;
-  u_int32_t data4;
-  u_int32_t data5[3];
-  u_int8_t extra[2];
+  uint32_t data1[2];
+  uint32_t data2;
+  uint32_t data3;
+  uint32_t data4;
+  uint32_t data5[3];
+  uint8_t  extra[2];
 } MDCVInfoELF;
 
 /* In addition to the two CodeView record formats above, used for linking
@@ -479,12 +479,12 @@ typedef struct {
  * obsolete with modules built by recent toolchains. */
 
 typedef struct {
-  u_int32_t data_type;    /* IMAGE_DEBUG_TYPE_*, not defined here because
+  uint32_t  data_type;    /* IMAGE_DEBUG_TYPE_*, not defined here because
                            * this debug record type is mostly obsolete. */
-  u_int32_t length;       /* Length of entire MDImageDebugMisc structure */
-  u_int8_t  unicode;      /* True if data is multibyte */
-  u_int8_t  reserved[3];
-  u_int8_t  data[1];
+  uint32_t  length;       /* Length of entire MDImageDebugMisc structure */
+  uint8_t   unicode;      /* True if data is multibyte */
+  uint8_t   reserved[3];
+  uint8_t   data[1];
 } MDImageDebugMisc;  /* IMAGE_DEBUG_MISC */
 
 static const size_t MDImageDebugMisc_minsize = offsetof(MDImageDebugMisc,
@@ -492,7 +492,7 @@ static const size_t MDImageDebugMisc_minsize = offsetof(MDImageDebugMisc,
 
 
 typedef struct {
-  u_int32_t   number_of_modules;
+  uint32_t    number_of_modules;
   MDRawModule modules[1];
 } MDRawModuleList;  /* MINIDUMP_MODULE_LIST */
 
@@ -501,7 +501,7 @@ static const size_t MDRawModuleList_minsize = offsetof(MDRawModuleList,
 
 
 typedef struct {
-  u_int32_t          number_of_memory_ranges;
+  uint32_t           number_of_memory_ranges;
   MDMemoryDescriptor memory_ranges[1];
 } MDRawMemoryList;  /* MINIDUMP_MEMORY_LIST */
 
@@ -512,21 +512,21 @@ static const size_t MDRawMemoryList_minsize = offsetof(MDRawMemoryList,
 #define MD_EXCEPTION_MAXIMUM_PARAMETERS 15
 
 typedef struct {
-  u_int32_t exception_code;     /* Windows: MDExceptionCodeWin,
+  uint32_t  exception_code;     /* Windows: MDExceptionCodeWin,
                                  * Mac OS X: MDExceptionMac,
                                  * Linux: MDExceptionCodeLinux. */
-  u_int32_t exception_flags;    /* Windows: 1 if noncontinuable,
+  uint32_t  exception_flags;    /* Windows: 1 if noncontinuable,
                                    Mac OS X: MDExceptionCodeMac. */
-  u_int64_t exception_record;   /* Address (in the minidump-producing host's
+  uint64_t  exception_record;   /* Address (in the minidump-producing host's
                                  * memory) of another MDException, for
                                  * nested exceptions. */
-  u_int64_t exception_address;  /* The address that caused the exception.
+  uint64_t  exception_address;  /* The address that caused the exception.
                                  * Mac OS X: exception subcode (which is
                                  *           typically the address). */
-  u_int32_t number_parameters;  /* Number of valid elements in
+  uint32_t  number_parameters;  /* Number of valid elements in
                                  * exception_information. */
-  u_int32_t __align;
-  u_int64_t exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS];
+  uint32_t  __align;
+  uint64_t  exception_information[MD_EXCEPTION_MAXIMUM_PARAMETERS];
 } MDException;  /* MINIDUMP_EXCEPTION */
 
 #include "minidump_exception_win32.h"
@@ -535,10 +535,10 @@ typedef struct {
 #include "minidump_exception_solaris.h"
 
 typedef struct {
-  u_int32_t            thread_id;         /* Thread in which the exception
+  uint32_t             thread_id;         /* Thread in which the exception
                                            * occurred.  Corresponds to
                                            * (MDRawThread).thread_id. */
-  u_int32_t            __align;
+  uint32_t             __align;
   MDException          exception_record;
   MDLocationDescriptor thread_context;    /* MDRawContext[CPU] */
 } MDRawExceptionStream;  /* MINIDUMP_EXCEPTION_STREAM */
@@ -546,13 +546,13 @@ typedef struct {
 
 typedef union {
   struct {
-    u_int32_t vendor_id[3];               /* cpuid 0: ebx, edx, ecx */
-    u_int32_t version_information;        /* cpuid 1: eax */
-    u_int32_t feature_information;        /* cpuid 1: edx */
-    u_int32_t amd_extended_cpu_features;  /* cpuid 0x80000001, ebx */
+    uint32_t vendor_id[3];               /* cpuid 0: ebx, edx, ecx */
+    uint32_t version_information;        /* cpuid 1: eax */
+    uint32_t feature_information;        /* cpuid 1: edx */
+    uint32_t amd_extended_cpu_features;  /* cpuid 0x80000001, ebx */
   } x86_cpu_info;
   struct {
-    u_int64_t processor_features[2];
+    uint64_t processor_features[2];
   } other_cpu_info;
 } MDCPUInformation;  /* CPU_INFORMATION */
 
@@ -560,20 +560,20 @@ typedef union {
 typedef struct {
   /* The next 3 fields and numberOfProcessors are from the SYSTEM_INFO
    * structure as returned by GetSystemInfo */
-  u_int16_t        processor_architecture;
-  u_int16_t        processor_level;         /* x86: 5 = 586, 6 = 686, ... */
-  u_int16_t        processor_revision;      /* x86: 0xMMSS, where MM=model,
+  uint16_t         processor_architecture;
+  uint16_t         processor_level;         /* x86: 5 = 586, 6 = 686, ... */
+  uint16_t         processor_revision;      /* x86: 0xMMSS, where MM=model,
                                              *      SS=stepping */
 
-  u_int8_t         number_of_processors;
-  u_int8_t         product_type;            /* Windows: VER_NT_* from WinNT.h */
+  uint8_t          number_of_processors;
+  uint8_t          product_type;            /* Windows: VER_NT_* from WinNT.h */
 
   /* The next 5 fields are from the OSVERSIONINFO structure as returned
    * by GetVersionEx */
-  u_int32_t        major_version;
-  u_int32_t        minor_version;
-  u_int32_t        build_number;
-  u_int32_t        platform_id;
+  uint32_t         major_version;
+  uint32_t         minor_version;
+  uint32_t         build_number;
+  uint32_t         platform_id;
   MDRVA            csd_version_rva;  /* MDString further identifying the
                                       * host OS.
                                       * Windows: name of the installed OS
@@ -582,8 +582,8 @@ typedef struct {
                                       *           (sw_vers -buildVersion).
                                       * Linux: uname -srvmo */
 
-  u_int16_t        suite_mask;       /* Windows: VER_SUITE_* from WinNT.h */
-  u_int16_t        reserved2;
+  uint16_t         suite_mask;       /* Windows: VER_SUITE_* from WinNT.h */
+  uint16_t         reserved2;
 
   MDCPUInformation cpu;
 } MDRawSystemInfo;  /* MINIDUMP_SYSTEM_INFO */
@@ -627,29 +627,29 @@ typedef enum {
 
 
 typedef struct {
-  u_int32_t size_of_info;  /* Length of entire MDRawMiscInfo structure. */
-  u_int32_t flags1;
+  uint32_t size_of_info;  /* Length of entire MDRawMiscInfo structure. */
+  uint32_t flags1;
 
   /* The next field is only valid if flags1 contains
    * MD_MISCINFO_FLAGS1_PROCESS_ID. */
-  u_int32_t process_id;
+  uint32_t process_id;
 
   /* The next 3 fields are only valid if flags1 contains
    * MD_MISCINFO_FLAGS1_PROCESS_TIMES. */
-  u_int32_t process_create_time;  /* time_t process started */
-  u_int32_t process_user_time;    /* seconds of user CPU time */
-  u_int32_t process_kernel_time;  /* seconds of kernel CPU time */
+  uint32_t process_create_time;  /* time_t process started */
+  uint32_t process_user_time;    /* seconds of user CPU time */
+  uint32_t process_kernel_time;  /* seconds of kernel CPU time */
 
   /* The following fields are not present in MINIDUMP_MISC_INFO but are
    * in MINIDUMP_MISC_INFO_2.  When this struct is populated, these values
    * may not be set.  Use flags1 or sizeOfInfo to determine whether these
    * values are present.  These are only valid when flags1 contains
    * MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO. */
-  u_int32_t processor_max_mhz;
-  u_int32_t processor_current_mhz;
-  u_int32_t processor_mhz_limit;
-  u_int32_t processor_max_idle_state;
-  u_int32_t processor_current_idle_state;
+  uint32_t processor_max_mhz;
+  uint32_t processor_current_mhz;
+  uint32_t processor_mhz_limit;
+  uint32_t processor_max_idle_state;
+  uint32_t processor_current_idle_state;
 } MDRawMiscInfo;  /* MINIDUMP_MISC_INFO, MINIDUMP_MISC_INFO2 */
 
 #define MD_MISCINFO_SIZE 24
@@ -666,7 +666,7 @@ typedef enum {
       /* MINIDUMP_MISC1_PROCESSOR_POWER_INFO */
 } MDMiscInfoFlags1;
 
-/* 
+/*
  * Around DbgHelp version 6.0, the style of new LIST structures changed
  * from including an array of length 1 at the end of the struct to
  * represent the variable-length data to including explicit
@@ -677,24 +677,24 @@ typedef enum {
  */
 
 typedef struct {
-  u_int32_t size_of_header;    /* sizeof(MDRawMemoryInfoList) */
-  u_int32_t size_of_entry;     /* sizeof(MDRawMemoryInfo) */
-  u_int64_t number_of_entries;
+  uint32_t size_of_header;    /* sizeof(MDRawMemoryInfoList) */
+  uint32_t size_of_entry;     /* sizeof(MDRawMemoryInfo) */
+  uint64_t number_of_entries;
 } MDRawMemoryInfoList;  /* MINIDUMP_MEMORY_INFO_LIST */
 
 typedef struct {
-  u_int64_t base_address;           /* Base address of a region of pages */
-  u_int64_t allocation_base;        /* Base address of a range of pages
+  uint64_t  base_address;           /* Base address of a region of pages */
+  uint64_t  allocation_base;        /* Base address of a range of pages
                                      * within this region. */
-  u_int32_t allocation_protection;  /* Memory protection when this region
+  uint32_t  allocation_protection;  /* Memory protection when this region
                                      * was originally allocated:
                                      * MDMemoryProtection */
-  u_int32_t __alignment1;
-  u_int64_t region_size;
-  u_int32_t state;                  /* MDMemoryState */
-  u_int32_t protection;             /* MDMemoryProtection */
-  u_int32_t type;                   /* MDMemoryType */
-  u_int32_t __alignment2;
+  uint32_t  __alignment1;
+  uint64_t  region_size;
+  uint32_t  state;                  /* MDMemoryState */
+  uint32_t  protection;             /* MDMemoryProtection */
+  uint32_t  type;                   /* MDMemoryType */
+  uint32_t  __alignment2;
 } MDRawMemoryInfo;  /* MINIDUMP_MEMORY_INFO */
 
 /* For (MDRawMemoryInfo).state */
@@ -721,7 +721,7 @@ typedef enum {
 } MDMemoryProtection;
 
 /* Used to mask the mutually exclusive options from the combinable flags. */
-const u_int32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF;
+const uint32_t MD_MEMORY_PROTECTION_ACCESS_MASK = 0xFF;
 
 /* For (MDRawMemoryInfo).type */
 typedef enum {
@@ -738,7 +738,7 @@ typedef enum {
 typedef struct {
   /* validity is a bitmask with values from MDBreakpadInfoValidity, indicating
    * which of the other fields in the structure are valid. */
-  u_int32_t validity;
+  uint32_t validity;
 
   /* Thread ID of the handler thread.  dump_thread_id should correspond to
    * the thread_id of an MDRawThread in the minidump's MDRawThreadList if
@@ -746,7 +746,7 @@ typedef struct {
    * the MDRawThreadList does not contain a dedicated thread used to produce
    * the minidump, this field should be set to 0 and the validity field
    * must not contain MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID. */
-  u_int32_t dump_thread_id;
+  uint32_t dump_thread_id;
 
   /* Thread ID of the thread that requested the minidump be produced.  As
    * with dump_thread_id, requesting_thread_id should correspond to the
@@ -759,7 +759,7 @@ typedef struct {
    * other than a thread in the MDRawThreadList, this field should be set
    * to 0 and the validity field must not contain
    * MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID. */
-  u_int32_t requesting_thread_id;
+  uint32_t requesting_thread_id;
 } MDRawBreakpadInfo;
 
 /* For (MDRawBreakpadInfo).validity: */
@@ -777,11 +777,11 @@ typedef struct {
    * written to a file.
    * Fixed-length strings are used because MiniDumpWriteDump doesn't offer
    * a way for user streams to point to arbitrary RVAs for strings. */
-  u_int16_t expression[128];  /* Assertion that failed... */
-  u_int16_t function[128];    /* ...within this function... */
-  u_int16_t file[128];        /* ...in this file... */
-  u_int32_t line;             /* ...at this line. */
-  u_int32_t type;
+  uint16_t expression[128];  /* Assertion that failed... */
+  uint16_t function[128];    /* ...within this function... */
+  uint16_t file[128];        /* ...in this file... */
+  uint32_t line;             /* ...at this line. */
+  uint32_t type;
 } MDRawAssertionInfo;
 
 /* For (MDRawAssertionInfo).type: */
@@ -806,9 +806,9 @@ typedef struct {
 } MDRawLinkMap;
 
 typedef struct {
-  u_int32_t version;
+  uint32_t  version;
   MDRVA     map;
-  u_int32_t dso_count;
+  uint32_t  dso_count;
   void*     brk;
   void*     ldbase;
   void*     dynamic;
diff --git a/src/google_breakpad/processor/code_module.h b/src/google_breakpad/processor/code_module.h
index 24b88fba..4e892824 100644
--- a/src/google_breakpad/processor/code_module.h
+++ b/src/google_breakpad/processor/code_module.h
@@ -47,11 +47,11 @@ class CodeModule {
   virtual ~CodeModule() {}
 
   // The base address of this code module as it was loaded by the process.
-  // (u_int64_t)-1 on error.
-  virtual u_int64_t base_address() const = 0;
+  // (uint64_t)-1 on error.
+  virtual uint64_t base_address() const = 0;
 
   // The size of the code module.  0 on error.
-  virtual u_int64_t size() const = 0;
+  virtual uint64_t size() const = 0;
 
   // The path or file name that the code module was loaded from.  Empty on
   // error.
diff --git a/src/google_breakpad/processor/code_modules.h b/src/google_breakpad/processor/code_modules.h
index 29c55d4e..a38579af 100644
--- a/src/google_breakpad/processor/code_modules.h
+++ b/src/google_breakpad/processor/code_modules.h
@@ -53,7 +53,7 @@ class CodeModules {
   // address, returns NULL.  Ownership of the returned CodeModule is retained
   // by the CodeModules object; pointers returned by this method are valid for
   // comparison with pointers returned by the other Get methods.
-  virtual const CodeModule* GetModuleForAddress(u_int64_t address) const = 0;
+  virtual const CodeModule* GetModuleForAddress(uint64_t address) const = 0;
 
   // Returns the module corresponding to the main executable.  If there is
   // no main executable, returns NULL.  Ownership of the returned CodeModule
diff --git a/src/google_breakpad/processor/exploitability.h b/src/google_breakpad/processor/exploitability.h
index 225206d7..67255a3a 100644
--- a/src/google_breakpad/processor/exploitability.h
+++ b/src/google_breakpad/processor/exploitability.h
@@ -54,7 +54,7 @@ class Exploitability {
                                                    ProcessState *process_state);
 
   ExploitabilityRating CheckExploitability();
-  bool AddressIsAscii(u_int64_t);
+  bool AddressIsAscii(uint64_t);
 
  protected:
   Exploitability(Minidump *dump,
diff --git a/src/google_breakpad/processor/memory_region.h b/src/google_breakpad/processor/memory_region.h
index 15e23ddc..bd9755f5 100644
--- a/src/google_breakpad/processor/memory_region.h
+++ b/src/google_breakpad/processor/memory_region.h
@@ -50,10 +50,10 @@ class MemoryRegion {
   virtual ~MemoryRegion() {}
 
   // The base address of this memory region.
-  virtual u_int64_t GetBase() const = 0;
+  virtual uint64_t GetBase() const = 0;
 
   // The size of this memory region.
-  virtual u_int32_t GetSize() const = 0;
+  virtual uint32_t GetSize() const = 0;
 
   // Access to data of various sizes within the memory region.  address
   // is a pointer to read, and it must lie within the memory region as
@@ -63,10 +63,10 @@ class MemoryRegion {
   // program.  Returns true on success.  Fails and returns false if address
   // is out of the region's bounds (after considering the width of value),
   // or for other types of errors.
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int8_t*  value) const =0;
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const =0;
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const =0;
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const =0;
+  virtual bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) const = 0;
+  virtual bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const = 0;
+  virtual bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const = 0;
+  virtual bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const = 0;
 };
 
 
diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h
index 0fe78443..18097714 100644
--- a/src/google_breakpad/processor/minidump.h
+++ b/src/google_breakpad/processor/minidump.h
@@ -154,7 +154,7 @@ class MinidumpStream : public MinidumpObject {
   // the MDRawDirectory record or other identifying record.  A class
   // that implements MinidumpStream can compare expected_size to a
   // known size as an integrity check.
-  virtual bool Read(u_int32_t expected_size) = 0;
+  virtual bool Read(uint32_t expected_size) = 0;
 };
 
 
@@ -176,11 +176,11 @@ class MinidumpContext : public MinidumpStream {
   // identifying the CPU type that the context was collected from.  The
   // returned value will identify the CPU only, and will have any other
   // MD_CONTEXT_* bits masked out.  Returns 0 on failure.
-  u_int32_t GetContextCPU() const;
+  uint32_t GetContextCPU() const;
 
   // A convenience method to get the instruction pointer out of the
   // MDRawContext, since it varies per-CPU architecture.
-  bool GetInstructionPointer(u_int64_t* ip) const;
+  bool GetInstructionPointer(uint64_t* ip) const;
 
   // Returns raw CPU-specific context data for the named CPU type.  If the
   // context data does not match the CPU type or does not exist, returns
@@ -210,13 +210,13 @@ class MinidumpContext : public MinidumpStream {
   } context_;
 
   // Store this separately because of the weirdo AMD64 context
-  u_int32_t context_flags_;
+  uint32_t context_flags_;
 
  private:
   friend class MinidumpThread;
   friend class MinidumpException;
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   // Free the CPU-specific context structure.
   void FreeContext();
@@ -226,7 +226,7 @@ class MinidumpContext : public MinidumpStream {
   // CPU type in context_cpu_type.  Returns false if the CPU type does not
   // match.  Returns true if the CPU type matches or if the minidump does
   // not contain a system info stream.
-  bool CheckAgainstSystemInfo(u_int32_t context_cpu_type);
+  bool CheckAgainstSystemInfo(uint32_t context_cpu_type);
 };
 
 
@@ -243,28 +243,28 @@ class MinidumpMemoryRegion : public MinidumpObject,
  public:
   virtual ~MinidumpMemoryRegion();
 
-  static void set_max_bytes(u_int32_t max_bytes) { max_bytes_ = max_bytes; }
-  static u_int32_t max_bytes() { return max_bytes_; }
+  static void set_max_bytes(uint32_t max_bytes) { max_bytes_ = max_bytes; }
+  static uint32_t max_bytes() { return max_bytes_; }
 
   // Returns a pointer to the base of the memory region.  Returns the
   // cached value if available, otherwise, reads the minidump file and
   // caches the memory region.
-  const u_int8_t* GetMemory() const;
+  const uint8_t* GetMemory() const;
 
   // The address of the base of the memory region.
-  u_int64_t GetBase() const;
+  uint64_t GetBase() const;
 
   // The size, in bytes, of the memory region.
-  u_int32_t GetSize() const;
+  uint32_t GetSize() const;
 
   // Frees the cached memory region, if cached.
   void FreeMemory();
 
   // Obtains the value of memory at the pointer specified by address.
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t*  value) const;
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) const;
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) const;
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) const;
+  bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) const;
+  bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const;
+  bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const;
+  bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const;
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -281,19 +281,19 @@ class MinidumpMemoryRegion : public MinidumpObject,
   void SetDescriptor(MDMemoryDescriptor* descriptor);
 
   // Implementation for GetMemoryAtAddress
-  template<typename T> bool GetMemoryAtAddressInternal(u_int64_t address,
+  template<typename T> bool GetMemoryAtAddressInternal(uint64_t address,
                                                        T*        value) const;
 
   // The largest memory region that will be read from a minidump.  The
   // default is 1MB.
-  static u_int32_t max_bytes_;
+  static uint32_t max_bytes_;
 
   // Base address and size of the memory region, and its position in the
   // minidump file.
   MDMemoryDescriptor* descriptor_;
 
   // Cached memory.
-  mutable vector<u_int8_t>* memory_;
+  mutable vector<uint8_t>* memory_;
 };
 
 
@@ -319,7 +319,7 @@ class MinidumpThread : public MinidumpObject {
   // so a special getter is provided to retrieve this data from the
   // MDRawThread structure.  Returns false if the thread ID cannot be
   // determined.
-  virtual bool GetThreadID(u_int32_t *thread_id) const;
+  virtual bool GetThreadID(uint32_t *thread_id) const;
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -348,10 +348,10 @@ class MinidumpThreadList : public MinidumpStream {
  public:
   virtual ~MinidumpThreadList();
 
-  static void set_max_threads(u_int32_t max_threads) {
+  static void set_max_threads(uint32_t max_threads) {
     max_threads_ = max_threads;
   }
-  static u_int32_t max_threads() { return max_threads_; }
+  static uint32_t max_threads() { return max_threads_; }
 
   virtual unsigned int thread_count() const {
     return valid_ ? thread_count_ : 0;
@@ -361,7 +361,7 @@ class MinidumpThreadList : public MinidumpStream {
   virtual MinidumpThread* GetThreadAtIndex(unsigned int index) const;
 
   // Random access to threads.
-  MinidumpThread* GetThreadByID(u_int32_t thread_id);
+  MinidumpThread* GetThreadByID(uint32_t thread_id);
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -372,23 +372,23 @@ class MinidumpThreadList : public MinidumpStream {
  private:
   friend class Minidump;
 
-  typedef map<u_int32_t, MinidumpThread*> IDToThreadMap;
+  typedef map<uint32_t, MinidumpThread*> IDToThreadMap;
   typedef vector<MinidumpThread> MinidumpThreads;
 
-  static const u_int32_t kStreamType = MD_THREAD_LIST_STREAM;
+  static const uint32_t kStreamType = MD_THREAD_LIST_STREAM;
 
-  bool Read(u_int32_t aExpectedSize);
+  bool Read(uint32_t aExpectedSize);
 
   // The largest number of threads that will be read from a minidump.  The
   // default is 256.
-  static u_int32_t max_threads_;
+  static uint32_t max_threads_;
 
   // Access to threads using the thread ID as the key.
   IDToThreadMap    id_to_thread_map_;
 
   // The list of threads.
   MinidumpThreads* threads_;
-  u_int32_t        thread_count_;
+  uint32_t        thread_count_;
 };
 
 
@@ -401,23 +401,23 @@ class MinidumpModule : public MinidumpObject,
  public:
   virtual ~MinidumpModule();
 
-  static void set_max_cv_bytes(u_int32_t max_cv_bytes) {
+  static void set_max_cv_bytes(uint32_t max_cv_bytes) {
     max_cv_bytes_ = max_cv_bytes;
   }
-  static u_int32_t max_cv_bytes() { return max_cv_bytes_; }
+  static uint32_t max_cv_bytes() { return max_cv_bytes_; }
 
-  static void set_max_misc_bytes(u_int32_t max_misc_bytes) {
+  static void set_max_misc_bytes(uint32_t max_misc_bytes) {
     max_misc_bytes_ = max_misc_bytes;
   }
-  static u_int32_t max_misc_bytes() { return max_misc_bytes_; }
+  static uint32_t max_misc_bytes() { return max_misc_bytes_; }
 
   const MDRawModule* module() const { return valid_ ? &module_ : NULL; }
 
   // CodeModule implementation
-  virtual u_int64_t base_address() const {
-    return valid_ ? module_.base_of_image : static_cast<u_int64_t>(-1);
+  virtual uint64_t base_address() const {
+    return valid_ ? module_.base_of_image : static_cast<uint64_t>(-1);
   }
-  virtual u_int64_t size() const { return valid_ ? module_.size_of_image : 0; }
+  virtual uint64_t size() const { return valid_ ? module_.size_of_image : 0; }
   virtual string code_file() const;
   virtual string code_identifier() const;
   virtual string debug_file() const;
@@ -426,7 +426,7 @@ class MinidumpModule : public MinidumpObject,
   virtual const CodeModule* Copy() const;
 
   // The CodeView record, which contains information to locate the module's
-  // debugging information (pdb).  This is returned as u_int8_t* because
+  // debugging information (pdb).  This is returned as uint8_t* because
   // the data can be of types MDCVInfoPDB20* or MDCVInfoPDB70*, or it may be
   // of a type unknown to Breakpad, in which case the raw data will still be
   // returned but no byte-swapping will have been performed.  Check the
@@ -435,14 +435,14 @@ class MinidumpModule : public MinidumpObject,
   // MDCVInfoPDB70 by default.  Returns a pointer to the CodeView record on
   // success, and NULL on failure.  On success, the optional |size| argument
   // is set to the size of the CodeView record.
-  const u_int8_t* GetCVRecord(u_int32_t* size);
+  const uint8_t* GetCVRecord(uint32_t* size);
 
   // The miscellaneous debug record, which is obsolete.  Current toolchains
   // do not generate this type of debugging information (dbg), and this
   // field is not expected to be present.  Returns a pointer to the debugging
   // record on success, and NULL on failure.  On success, the optional |size|
   // argument is set to the size of the debugging record.
-  const MDImageDebugMisc* GetMiscRecord(u_int32_t* size);
+  const MDImageDebugMisc* GetMiscRecord(uint32_t* size);
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -469,8 +469,8 @@ class MinidumpModule : public MinidumpObject,
   // The largest number of bytes that will be read from a minidump for a
   // CodeView record or miscellaneous debugging record, respectively.  The
   // default for each is 1024.
-  static u_int32_t max_cv_bytes_;
-  static u_int32_t max_misc_bytes_;
+  static uint32_t max_cv_bytes_;
+  static uint32_t max_misc_bytes_;
 
   // True after a successful Read.  This is different from valid_, which is
   // not set true until ReadAuxiliaryData also completes successfully.
@@ -490,20 +490,20 @@ class MinidumpModule : public MinidumpObject,
   const string*     name_;
 
   // Cached CodeView record - this is MDCVInfoPDB20 or (likely)
-  // MDCVInfoPDB70, or possibly something else entirely.  Stored as a u_int8_t
+  // MDCVInfoPDB70, or possibly something else entirely.  Stored as a uint8_t
   // because the structure contains a variable-sized string and its exact
   // size cannot be known until it is processed.
-  vector<u_int8_t>* cv_record_;
+  vector<uint8_t>* cv_record_;
 
   // If cv_record_ is present, cv_record_signature_ contains a copy of the
   // CodeView record's first four bytes, for ease of determinining the
   // type of structure that cv_record_ contains.
-  u_int32_t cv_record_signature_;
+  uint32_t cv_record_signature_;
 
-  // Cached MDImageDebugMisc (usually not present), stored as u_int8_t
+  // Cached MDImageDebugMisc (usually not present), stored as uint8_t
   // because the structure contains a variable-sized string and its exact
   // size cannot be known until it is processed.
-  vector<u_int8_t>* misc_record_;
+  vector<uint8_t>* misc_record_;
 };
 
 
@@ -516,16 +516,16 @@ class MinidumpModuleList : public MinidumpStream,
  public:
   virtual ~MinidumpModuleList();
 
-  static void set_max_modules(u_int32_t max_modules) {
+  static void set_max_modules(uint32_t max_modules) {
     max_modules_ = max_modules;
   }
-  static u_int32_t max_modules() { return max_modules_; }
+  static uint32_t max_modules() { return max_modules_; }
 
   // CodeModules implementation.
   virtual unsigned int module_count() const {
     return valid_ ? module_count_ : 0;
   }
-  virtual const MinidumpModule* GetModuleForAddress(u_int64_t address) const;
+  virtual const MinidumpModule* GetModuleForAddress(uint64_t address) const;
   virtual const MinidumpModule* GetMainModule() const;
   virtual const MinidumpModule* GetModuleAtSequence(
       unsigned int sequence) const;
@@ -543,19 +543,19 @@ class MinidumpModuleList : public MinidumpStream,
 
   typedef vector<MinidumpModule> MinidumpModules;
 
-  static const u_int32_t kStreamType = MD_MODULE_LIST_STREAM;
+  static const uint32_t kStreamType = MD_MODULE_LIST_STREAM;
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   // The largest number of modules that will be read from a minidump.  The
   // default is 1024.
-  static u_int32_t max_modules_;
+  static uint32_t max_modules_;
 
   // Access to modules using addresses as the key.
-  RangeMap<u_int64_t, unsigned int> *range_map_;
+  RangeMap<uint64_t, unsigned int> *range_map_;
 
   MinidumpModules *modules_;
-  u_int32_t module_count_;
+  uint32_t module_count_;
 };
 
 
@@ -572,10 +572,10 @@ class MinidumpMemoryList : public MinidumpStream {
  public:
   virtual ~MinidumpMemoryList();
 
-  static void set_max_regions(u_int32_t max_regions) {
+  static void set_max_regions(uint32_t max_regions) {
     max_regions_ = max_regions;
   }
-  static u_int32_t max_regions() { return max_regions_; }
+  static uint32_t max_regions() { return max_regions_; }
 
   unsigned int region_count() const { return valid_ ? region_count_ : 0; }
 
@@ -584,7 +584,7 @@ class MinidumpMemoryList : public MinidumpStream {
 
   // Random access to memory regions.  Returns the region encompassing
   // the address identified by address.
-  MinidumpMemoryRegion* GetMemoryRegionForAddress(u_int64_t address);
+  MinidumpMemoryRegion* GetMemoryRegionForAddress(uint64_t address);
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -595,18 +595,18 @@ class MinidumpMemoryList : public MinidumpStream {
   typedef vector<MDMemoryDescriptor>   MemoryDescriptors;
   typedef vector<MinidumpMemoryRegion> MemoryRegions;
 
-  static const u_int32_t kStreamType = MD_MEMORY_LIST_STREAM;
+  static const uint32_t kStreamType = MD_MEMORY_LIST_STREAM;
 
   explicit MinidumpMemoryList(Minidump* minidump);
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   // The largest number of memory regions that will be read from a minidump.
   // The default is 256.
-  static u_int32_t max_regions_;
+  static uint32_t max_regions_;
 
   // Access to memory regions using addresses as the key.
-  RangeMap<u_int64_t, unsigned int> *range_map_;
+  RangeMap<uint64_t, unsigned int> *range_map_;
 
   // The list of descriptors.  This is maintained separately from the list
   // of regions, because MemoryRegion doesn't own its MemoryDescriptor, it
@@ -616,7 +616,7 @@ class MinidumpMemoryList : public MinidumpStream {
 
   // The list of regions.
   MemoryRegions *regions_;
-  u_int32_t region_count_;
+  uint32_t region_count_;
 };
 
 
@@ -638,7 +638,7 @@ class MinidumpException : public MinidumpStream {
   // so a special getter is provided to retrieve this data from the
   // MDRawExceptionStream structure.  Returns false if the thread ID cannot
   // be determined.
-  bool GetThreadID(u_int32_t *thread_id) const;
+  bool GetThreadID(uint32_t *thread_id) const;
 
   MinidumpContext* GetContext();
 
@@ -648,11 +648,11 @@ class MinidumpException : public MinidumpStream {
  private:
   friend class Minidump;
 
-  static const u_int32_t kStreamType = MD_EXCEPTION_STREAM;
+  static const uint32_t kStreamType = MD_EXCEPTION_STREAM;
 
   explicit MinidumpException(Minidump* minidump);
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   MDRawExceptionStream exception_;
   MinidumpContext*     context_;
@@ -686,11 +686,11 @@ class MinidumpAssertion : public MinidumpStream {
  private:
   friend class Minidump;
 
-  static const u_int32_t kStreamType = MD_ASSERTION_INFO_STREAM;
+  static const uint32_t kStreamType = MD_ASSERTION_INFO_STREAM;
 
   explicit MinidumpAssertion(Minidump* minidump);
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   MDRawAssertionInfo assertion_;
   string expression_;
@@ -743,9 +743,9 @@ class MinidumpSystemInfo : public MinidumpStream {
  private:
   friend class Minidump;
 
-  static const u_int32_t kStreamType = MD_SYSTEM_INFO_STREAM;
+  static const uint32_t kStreamType = MD_SYSTEM_INFO_STREAM;
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   // A string identifying the CPU vendor, if known.
   const string* cpu_vendor_;
@@ -767,11 +767,11 @@ class MinidumpMiscInfo : public MinidumpStream {
  private:
   friend class Minidump;
 
-  static const u_int32_t kStreamType = MD_MISC_INFO_STREAM;
+  static const uint32_t kStreamType = MD_MISC_INFO_STREAM;
 
   explicit MinidumpMiscInfo(Minidump* minidump_);
 
-  bool Read(u_int32_t expected_size_);
+  bool Read(uint32_t expected_size_);
 
   MDRawMiscInfo misc_info_;
 };
@@ -790,8 +790,8 @@ class MinidumpBreakpadInfo : public MinidumpStream {
   // treatment, so special getters are provided to retrieve this data from
   // the MDRawBreakpadInfo structure.  The getters return false if the thread
   // IDs cannot be determined.
-  bool GetDumpThreadID(u_int32_t *thread_id) const;
-  bool GetRequestingThreadID(u_int32_t *thread_id) const;
+  bool GetDumpThreadID(uint32_t *thread_id) const;
+  bool GetRequestingThreadID(uint32_t *thread_id) const;
 
   // Print a human-readable representation of the object to stdout.
   void Print();
@@ -799,11 +799,11 @@ class MinidumpBreakpadInfo : public MinidumpStream {
  private:
   friend class Minidump;
 
-  static const u_int32_t kStreamType = MD_BREAKPAD_INFO_STREAM;
+  static const uint32_t kStreamType = MD_BREAKPAD_INFO_STREAM;
 
   explicit MinidumpBreakpadInfo(Minidump* minidump_);
 
-  bool Read(u_int32_t expected_size_);
+  bool Read(uint32_t expected_size_);
 
   MDRawBreakpadInfo breakpad_info_;
 };
@@ -816,10 +816,10 @@ class MinidumpMemoryInfo : public MinidumpObject {
   const MDRawMemoryInfo* info() const { return valid_ ? &memory_info_ : NULL; }
 
   // The address of the base of the memory region.
-  u_int64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; }
+  uint64_t GetBase() const { return valid_ ? memory_info_.base_address : 0; }
 
   // The size, in bytes, of the memory region.
-  u_int32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; }
+  uint32_t GetSize() const { return valid_ ? memory_info_.region_size : 0; }
 
   // Return true if the memory protection allows execution.
   bool IsExecutable() const;
@@ -854,7 +854,7 @@ class MinidumpMemoryInfoList : public MinidumpStream {
 
   unsigned int info_count() const { return valid_ ? info_count_ : 0; }
 
-  const MinidumpMemoryInfo* GetMemoryInfoForAddress(u_int64_t address) const;
+  const MinidumpMemoryInfo* GetMemoryInfoForAddress(uint64_t address) const;
   const MinidumpMemoryInfo* GetMemoryInfoAtIndex(unsigned int index) const;
 
   // Print a human-readable representation of the object to stdout.
@@ -865,17 +865,17 @@ class MinidumpMemoryInfoList : public MinidumpStream {
 
   typedef vector<MinidumpMemoryInfo> MinidumpMemoryInfos;
 
-  static const u_int32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM;
+  static const uint32_t kStreamType = MD_MEMORY_INFO_LIST_STREAM;
 
   explicit MinidumpMemoryInfoList(Minidump* minidump);
 
-  bool Read(u_int32_t expected_size);
+  bool Read(uint32_t expected_size);
 
   // Access to memory info using addresses as the key.
-  RangeMap<u_int64_t, unsigned int> *range_map_;
+  RangeMap<uint64_t, unsigned int> *range_map_;
 
   MinidumpMemoryInfos* infos_;
-  u_int32_t info_count_;
+  uint32_t info_count_;
 };
 
 
@@ -896,15 +896,15 @@ class Minidump {
   virtual string path() const {
     return path_;
   }
-  static void set_max_streams(u_int32_t max_streams) {
+  static void set_max_streams(uint32_t max_streams) {
     max_streams_ = max_streams;
   }
-  static u_int32_t max_streams() { return max_streams_; }
+  static uint32_t max_streams() { return max_streams_; }
 
-  static void set_max_string_length(u_int32_t max_string_length) {
+  static void set_max_string_length(uint32_t max_string_length) {
     max_string_length_ = max_string_length;
   }
-  static u_int32_t max_string_length() { return max_string_length_; }
+  static uint32_t max_string_length() { return max_string_length_; }
 
   virtual const MDRawHeader* header() const { return valid_ ? &header_ : NULL; }
 
@@ -916,7 +916,7 @@ class Minidump {
   // Returns true if the current position in the stream was not changed.
   // Returns false when the current location in the stream was changed and the
   // attempt to restore the original position failed.
-  bool GetContextCPUFlagsFromSystemInfo(u_int32_t* context_cpu_flags);
+  bool GetContextCPUFlagsFromSystemInfo(uint32_t* context_cpu_flags);
 
   // Reads the minidump file's header and top-level stream directory.
   // The minidump is expected to be positioned at the beginning of the
@@ -980,7 +980,7 @@ class Minidump {
   // possibility, and consider using GetDirectoryEntryAtIndex (possibly
   // with GetDirectoryEntryCount) if expecting multiple streams of the same
   // type in a single minidump file.
-  bool SeekToStreamType(u_int32_t stream_type, u_int32_t* stream_length);
+  bool SeekToStreamType(uint32_t stream_type, uint32_t* stream_length);
 
   bool swap() const { return valid_ ? swap_ : false; }
 
@@ -1003,7 +1003,7 @@ class Minidump {
   };
 
   typedef vector<MDRawDirectory> MinidumpDirectoryEntries;
-  typedef map<u_int32_t, MinidumpStreamInfo> MinidumpStreamMap;
+  typedef map<uint32_t, MinidumpStreamInfo> MinidumpStreamMap;
 
   template<typename T> T* GetStream(T** stream);
 
@@ -1013,7 +1013,7 @@ class Minidump {
   // The largest number of top-level streams that will be read from a minidump.
   // Note that streams are only read (and only consume memory) as needed,
   // when directed by the caller.  The default is 128.
-  static u_int32_t max_streams_;
+  static uint32_t max_streams_;
 
   // The maximum length of a UTF-16 string that will be read from a minidump
   // in 16-bit words.  The default is 1024.  UTF-16 strings are converted
diff --git a/src/google_breakpad/processor/minidump_processor.h b/src/google_breakpad/processor/minidump_processor.h
index 0e10f40b..33cd0206 100644
--- a/src/google_breakpad/processor/minidump_processor.h
+++ b/src/google_breakpad/processor/minidump_processor.h
@@ -131,7 +131,7 @@ class MinidumpProcessor {
   // address when the crash was caused by problems such as illegal
   // instructions or divisions by zero, or a data address when the crash
   // was caused by a memory access violation.
-  static string GetCrashReason(Minidump* dump, u_int64_t* address);
+  static string GetCrashReason(Minidump* dump, uint64_t* address);
 
   // This function returns true if the passed-in error code is
   // something unrecoverable(i.e. retry should not happen).  For
diff --git a/src/google_breakpad/processor/process_state.h b/src/google_breakpad/processor/process_state.h
index 8d71457b..780cb548 100644
--- a/src/google_breakpad/processor/process_state.h
+++ b/src/google_breakpad/processor/process_state.h
@@ -94,10 +94,10 @@ class ProcessState {
   void Clear();
 
   // Accessors.  See the data declarations below.
-  u_int32_t time_date_stamp() const { return time_date_stamp_; }
+  uint32_t time_date_stamp() const { return time_date_stamp_; }
   bool crashed() const { return crashed_; }
   string crash_reason() const { return crash_reason_; }
-  u_int64_t crash_address() const { return crash_address_; }
+  uint64_t crash_address() const { return crash_address_; }
   string assertion() const { return assertion_; }
   int requesting_thread() const { return requesting_thread_; }
   const vector<CallStack*>* threads() const { return &threads_; }
@@ -113,7 +113,7 @@ class ProcessState {
   friend class MinidumpProcessor;
 
   // The time-date stamp of the minidump (time_t format)
-  u_int32_t time_date_stamp_;
+  uint32_t time_date_stamp_;
 
   // True if the process crashed, false if the dump was produced outside
   // of an exception handler.
@@ -129,7 +129,7 @@ class ProcessState {
   // the memory address that caused the crash.  For data access errors,
   // this will be the data address that caused the fault.  For code errors,
   // this will be the address of the instruction that caused the fault.
-  u_int64_t crash_address_;
+  uint64_t crash_address_;
 
   // If there was an assertion that was hit, a textual representation
   // of that assertion, possibly including the file and line at which
diff --git a/src/google_breakpad/processor/source_line_resolver_interface.h b/src/google_breakpad/processor/source_line_resolver_interface.h
index 4e9dd4b7..7b69b0d3 100644
--- a/src/google_breakpad/processor/source_line_resolver_interface.h
+++ b/src/google_breakpad/processor/source_line_resolver_interface.h
@@ -48,7 +48,7 @@ class CFIFrameInfo;
 
 class SourceLineResolverInterface {
  public:
-  typedef u_int64_t MemAddr;
+  typedef uint64_t MemAddr;
 
   virtual ~SourceLineResolverInterface() {}
 
diff --git a/src/google_breakpad/processor/stack_frame.h b/src/google_breakpad/processor/stack_frame.h
index e8803804..23e69bb4 100644
--- a/src/google_breakpad/processor/stack_frame.h
+++ b/src/google_breakpad/processor/stack_frame.h
@@ -85,7 +85,7 @@ struct StackFrame {
 
   // Return the actual return address, as saved on the stack or in a
   // register. See the comments for 'instruction', below, for details.
-  virtual u_int64_t ReturnAddress() const { return instruction; }
+  virtual uint64_t ReturnAddress() const { return instruction; }
 
   // The program counter location as an absolute virtual address.
   //
@@ -108,7 +108,7 @@ struct StackFrame {
   // a register is fine for looking up the point of the call. On others, it
   // requires adjustment. ReturnAddress returns the address as saved by the
   // machine.
-  u_int64_t instruction;
+  uint64_t instruction;
 
   // The module in which the instruction resides.
   const CodeModule *module;
@@ -118,7 +118,7 @@ struct StackFrame {
 
   // The start address of the function, may be omitted if debug symbols
   // are not available.
-  u_int64_t function_base;
+  uint64_t function_base;
 
   // The source file name, may be omitted if debug symbols are not available.
   string source_file_name;
@@ -129,7 +129,7 @@ struct StackFrame {
 
   // The start address of the source line, may be omitted if debug symbols
   // are not available.
-  u_int64_t source_line_base;
+  uint64_t source_line_base;
 
   // Amount of trust the stack walker has in the instruction pointer
   // of this frame.
diff --git a/src/google_breakpad/processor/stack_frame_cpu.h b/src/google_breakpad/processor/stack_frame_cpu.h
index 34171f37..a9cf99b7 100644
--- a/src/google_breakpad/processor/stack_frame_cpu.h
+++ b/src/google_breakpad/processor/stack_frame_cpu.h
@@ -78,7 +78,7 @@ struct StackFrameX86 : public StackFrame {
   ~StackFrameX86();
 
   // Overriden to return the return address as saved on the stack.
-  virtual u_int64_t ReturnAddress() const;
+  virtual uint64_t ReturnAddress() const;
 
   // Register state.  This is only fully valid for the topmost frame in a
   // stack.  In other frames, the values of nonvolatile registers may be
@@ -151,7 +151,7 @@ struct StackFrameAMD64 : public StackFrame {
   StackFrameAMD64() : context(), context_validity(CONTEXT_VALID_NONE) {}
 
   // Overriden to return the return address as saved on the stack.
-  virtual u_int64_t ReturnAddress() const;
+  virtual uint64_t ReturnAddress() const;
 
   // Register state. This is only fully valid for the topmost frame in a
   // stack. In other frames, which registers are present depends on what
diff --git a/src/google_breakpad/processor/stackwalker.h b/src/google_breakpad/processor/stackwalker.h
index 401c2f62..9e678e3c 100644
--- a/src/google_breakpad/processor/stackwalker.h
+++ b/src/google_breakpad/processor/stackwalker.h
@@ -78,8 +78,8 @@ class Stackwalker {
      const CodeModules* modules,
      StackFrameSymbolizer* resolver_helper);
 
-  static void set_max_frames(u_int32_t max_frames) { max_frames_ = max_frames; }
-  static u_int32_t max_frames() { return max_frames_; }
+  static void set_max_frames(uint32_t max_frames) { max_frames_ = max_frames; }
+  static uint32_t max_frames() { return max_frames_; }
 
  protected:
   // system_info identifies the operating system, NULL or empty if unknown.
@@ -104,7 +104,7 @@ class Stackwalker {
   // * This address is within a loaded module for which we have symbols,
   //   and falls inside a function in that module.
   // Returns false otherwise.
-  bool InstructionAddressSeemsValid(u_int64_t address);
+  bool InstructionAddressSeemsValid(uint64_t address);
 
   // The default number of words to search through on the stack
   // for a return address.
@@ -185,7 +185,7 @@ class Stackwalker {
 
   // The maximum number of frames Stackwalker will walk through.
   // This defaults to 1024 to prevent infinite loops.
-  static u_int32_t max_frames_;
+  static uint32_t max_frames_;
 };
 
 }  // namespace google_breakpad
diff --git a/src/processor/basic_code_module.h b/src/processor/basic_code_module.h
index 635c09a2..3fe782bb 100644
--- a/src/processor/basic_code_module.h
+++ b/src/processor/basic_code_module.h
@@ -63,7 +63,7 @@ class BasicCodeModule : public CodeModule {
         debug_identifier_(that->debug_identifier()),
         version_(that->version()) {}
 
-  BasicCodeModule(u_int64_t base_address, u_int64_t size,
+  BasicCodeModule(uint64_t base_address, uint64_t size,
 		  const string &code_file,
 		  const string &code_identifier,
 		  const string &debug_file,
@@ -81,8 +81,8 @@ class BasicCodeModule : public CodeModule {
 
   // See code_module.h for descriptions of these methods and the associated
   // members.
-  virtual u_int64_t base_address() const { return base_address_; }
-  virtual u_int64_t size() const { return size_; }
+  virtual uint64_t base_address() const { return base_address_; }
+  virtual uint64_t size() const { return size_; }
   virtual string code_file() const { return code_file_; }
   virtual string code_identifier() const { return code_identifier_; }
   virtual string debug_file() const { return debug_file_; }
@@ -91,8 +91,8 @@ class BasicCodeModule : public CodeModule {
   virtual const CodeModule* Copy() const { return new BasicCodeModule(this); }
 
  private:
-  u_int64_t base_address_;
-  u_int64_t size_;
+  uint64_t base_address_;
+  uint64_t size_;
   string code_file_;
   string code_identifier_;
   string debug_file_;
diff --git a/src/processor/basic_code_modules.cc b/src/processor/basic_code_modules.cc
index 63da8995..71874bed 100644
--- a/src/processor/basic_code_modules.cc
+++ b/src/processor/basic_code_modules.cc
@@ -47,7 +47,7 @@ namespace google_breakpad {
 
 BasicCodeModules::BasicCodeModules(const CodeModules *that)
     : main_address_(0),
-      map_(new RangeMap<u_int64_t, linked_ptr<const CodeModule> >()) {
+      map_(new RangeMap<uint64_t, linked_ptr<const CodeModule> >()) {
   BPLOG_IF(ERROR, !that) << "BasicCodeModules::BasicCodeModules requires "
                             "|that|";
   assert(that);
@@ -82,7 +82,7 @@ unsigned int BasicCodeModules::module_count() const {
 }
 
 const CodeModule* BasicCodeModules::GetModuleForAddress(
-    u_int64_t address) const {
+    uint64_t address) const {
   linked_ptr<const CodeModule> module;
   if (!map_->RetrieveRange(address, &module, NULL, NULL)) {
     BPLOG(INFO) << "No module at " << HexString(address);
diff --git a/src/processor/basic_code_modules.h b/src/processor/basic_code_modules.h
index df87fc49..d302287e 100644
--- a/src/processor/basic_code_modules.h
+++ b/src/processor/basic_code_modules.h
@@ -61,7 +61,7 @@ class BasicCodeModules : public CodeModules {
 
   // See code_modules.h for descriptions of these methods.
   virtual unsigned int module_count() const;
-  virtual const CodeModule* GetModuleForAddress(u_int64_t address) const;
+  virtual const CodeModule* GetModuleForAddress(uint64_t address) const;
   virtual const CodeModule* GetMainModule() const;
   virtual const CodeModule* GetModuleAtSequence(unsigned int sequence) const;
   virtual const CodeModule* GetModuleAtIndex(unsigned int index) const;
@@ -69,11 +69,11 @@ class BasicCodeModules : public CodeModules {
 
  private:
   // The base address of the main module.
-  u_int64_t main_address_;
+  uint64_t main_address_;
 
   // The map used to contain each CodeModule, keyed by each CodeModule's
   // address range.
-  RangeMap<u_int64_t, linked_ptr<const CodeModule> > *map_;
+  RangeMap<uint64_t, linked_ptr<const CodeModule> > *map_;
 
   // Disallow copy constructor and assignment operator.
   BasicCodeModules(const BasicCodeModules &that);
diff --git a/src/processor/basic_source_line_resolver.cc b/src/processor/basic_source_line_resolver.cc
index a0ce8e6d..2a93ee36 100644
--- a/src/processor/basic_source_line_resolver.cc
+++ b/src/processor/basic_source_line_resolver.cc
@@ -299,8 +299,8 @@ BasicSourceLineResolver::Module::ParseFunction(char *function_line) {
     return NULL;
   }
 
-  u_int64_t address    = strtoull(tokens[0], NULL, 16);
-  u_int64_t size       = strtoull(tokens[1], NULL, 16);
+  uint64_t address     = strtoull(tokens[0], NULL, 16);
+  uint64_t size        = strtoull(tokens[1], NULL, 16);
   int stack_param_size = strtoull(tokens[2], NULL, 16);
   char *name           = tokens[3];
 
@@ -315,8 +315,8 @@ BasicSourceLineResolver::Line* BasicSourceLineResolver::Module::ParseLine(
     return NULL;
   }
 
-  u_int64_t address = strtoull(tokens[0], NULL, 16);
-  u_int64_t size    = strtoull(tokens[1], NULL, 16);
+  uint64_t address  = strtoull(tokens[0], NULL, 16);
+  uint64_t size     = strtoull(tokens[1], NULL, 16);
   int line_number   = atoi(tokens[2]);
   int source_file   = atoi(tokens[3]);
   if (line_number <= 0) {
@@ -337,7 +337,7 @@ bool BasicSourceLineResolver::Module::ParsePublicSymbol(char *public_line) {
     return false;
   }
 
-  u_int64_t address    = strtoull(tokens[0], NULL, 16);
+  uint64_t address     = strtoull(tokens[0], NULL, 16);
   int stack_param_size = strtoull(tokens[1], NULL, 16);
   char *name           = tokens[2];
 
@@ -372,7 +372,7 @@ bool BasicSourceLineResolver::Module::ParseStackInfo(char *stack_info_line) {
   // MSVC stack frame info.
   if (strcmp(platform, "WIN") == 0) {
     int type = 0;
-    u_int64_t rva, code_size;
+    uint64_t rva, code_size;
     linked_ptr<WindowsFrameInfo>
       stack_frame_info(WindowsFrameInfo::ParseFromString(stack_info_line,
                                                          type,
diff --git a/src/processor/basic_source_line_resolver_unittest.cc b/src/processor/basic_source_line_resolver_unittest.cc
index 6e3c164c..8525e9e4 100644
--- a/src/processor/basic_source_line_resolver_unittest.cc
+++ b/src/processor/basic_source_line_resolver_unittest.cc
@@ -59,8 +59,8 @@ class TestCodeModule : public CodeModule {
   TestCodeModule(string code_file) : code_file_(code_file) {}
   virtual ~TestCodeModule() {}
 
-  virtual u_int64_t base_address() const { return 0; }
-  virtual u_int64_t size() const { return 0xb000; }
+  virtual uint64_t base_address() const { return 0; }
+  virtual uint64_t size() const { return 0xb000; }
   virtual string code_file() const { return code_file_; }
   virtual string code_identifier() const { return ""; }
   virtual string debug_file() const { return ""; }
@@ -76,17 +76,17 @@ class TestCodeModule : public CodeModule {
 
 // A mock memory region object, for use by the STACK CFI tests.
 class MockMemoryRegion: public MemoryRegion {
-  u_int64_t GetBase() const { return 0x10000; }
-  u_int32_t GetSize() const { return 0x01000; }
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
+  uint64_t GetBase() const { return 0x10000; }
+  uint32_t GetSize() const { return 0x01000; }
+  bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
     *value = address & 0xff;
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
     *value = address & 0xffff;
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
     switch (address) {
       case 0x10008: *value = 0x98ecadc3; break; // saved %ebx
       case 0x1000c: *value = 0x878f7524; break; // saved %esi
@@ -97,7 +97,7 @@ class MockMemoryRegion: public MemoryRegion {
     }
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
     *value = address;
     return true;
   }
@@ -109,9 +109,9 @@ class MockMemoryRegion: public MemoryRegion {
 // ".cfa".
 static bool VerifyRegisters(
     const char *file, int line,
-    const CFIFrameInfo::RegisterValueMap<u_int32_t> &expected,
-    const CFIFrameInfo::RegisterValueMap<u_int32_t> &actual) {
-  CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator a;
+    const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
+    const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
+  CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
   a = actual.find(".cfa");
   if (a == actual.end())
     return false;
@@ -119,7 +119,7 @@ static bool VerifyRegisters(
   if (a == actual.end())
     return false;
   for (a = actual.begin(); a != actual.end(); a++) {
-    CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator e =
+    CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e =
       expected.find(a->first);
     if (e == expected.end()) {
       fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n",
@@ -252,9 +252,9 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_FALSE(cfi_frame_info.get());
 
-  CFIFrameInfo::RegisterValueMap<u_int32_t> current_registers;
-  CFIFrameInfo::RegisterValueMap<u_int32_t> caller_registers;
-  CFIFrameInfo::RegisterValueMap<u_int32_t> expected_caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> current_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers;
   MockMemoryRegion memory;
 
   // Regardless of which instruction evaluation takes place at, it
@@ -277,7 +277,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
                               expected_caller_registers, caller_registers));
@@ -287,7 +287,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
                               expected_caller_registers, caller_registers));
@@ -297,7 +297,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -307,7 +307,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -317,7 +317,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -327,7 +327,7 @@ TEST_F(TestBasicSourceLineResolver, TestLoadAndResolve)
   cfi_frame_info.reset(resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
diff --git a/src/processor/binarystream.cc b/src/processor/binarystream.cc
index 9ed3b702..bf92225b 100644
--- a/src/processor/binarystream.cc
+++ b/src/processor/binarystream.cc
@@ -40,7 +40,7 @@ namespace google_breakpad {
 using std::vector;
 
 binarystream &binarystream::operator>>(string &str) {
-  u_int16_t length;
+  uint16_t length;
   *this >> length;
   if (eof())
     return *this;
@@ -55,68 +55,68 @@ binarystream &binarystream::operator>>(string &str) {
   return *this;
 }
 
-binarystream &binarystream::operator>>(u_int8_t &u8) {
+binarystream &binarystream::operator>>(uint8_t &u8) {
   stream_.read((char *)&u8, 1);
   return *this;
 }
 
-binarystream &binarystream::operator>>(u_int16_t &u16) {
-  u_int16_t temp;
+binarystream &binarystream::operator>>(uint16_t &u16) {
+  uint16_t temp;
   stream_.read((char *)&temp, 2);
   if (!eof())
     u16 = ntohs(temp);
   return *this;
 }
 
-binarystream &binarystream::operator>>(u_int32_t &u32) {
-  u_int32_t temp;
+binarystream &binarystream::operator>>(uint32_t &u32) {
+  uint32_t temp;
   stream_.read((char *)&temp, 4);
   if (!eof())
     u32 = ntohl(temp);
   return *this;
 }
 
-binarystream &binarystream::operator>>(u_int64_t &u64) {
-  u_int32_t lower, upper;
+binarystream &binarystream::operator>>(uint64_t &u64) {
+  uint32_t lower, upper;
   *this >> lower >> upper;
   if (!eof())
-    u64 = static_cast<u_int64_t>(lower) | (static_cast<u_int64_t>(upper) << 32);
+    u64 = static_cast<uint64_t>(lower) | (static_cast<uint64_t>(upper) << 32);
   return *this;
 }
 
 binarystream &binarystream::operator<<(const string &str) {
   if (str.length() > USHRT_MAX) {
     // truncate to 16-bit length
-    *this << static_cast<u_int16_t>(USHRT_MAX);
+    *this << static_cast<uint16_t>(USHRT_MAX);
     stream_.write(str.c_str(), USHRT_MAX);
   } else {
-    *this << (u_int16_t)(str.length() & 0xFFFF);
+    *this << (uint16_t)(str.length() & 0xFFFF);
     stream_.write(str.c_str(), str.length());
   }
   return *this;
 }
 
-binarystream &binarystream::operator<<(u_int8_t u8) {
+binarystream &binarystream::operator<<(uint8_t u8) {
   stream_.write((const char*)&u8, 1);
   return *this;
 }
 
-binarystream &binarystream::operator<<(u_int16_t u16) {
+binarystream &binarystream::operator<<(uint16_t u16) {
   u16 = htons(u16);
   stream_.write((const char*)&u16, 2);
   return *this;
 }
 
-binarystream &binarystream::operator<<(u_int32_t u32) {
+binarystream &binarystream::operator<<(uint32_t u32) {
   u32 = htonl(u32);
   stream_.write((const char*)&u32, 4);
   return *this;
 }
 
-binarystream &binarystream::operator<<(u_int64_t u64) {
+binarystream &binarystream::operator<<(uint64_t u64) {
   // write 64-bit ints as two 32-bit ints, so we can byte-swap them easily
-  u_int32_t lower = static_cast<u_int32_t>(u64 & 0xFFFFFFFF);
-  u_int32_t upper = static_cast<u_int32_t>(u64 >> 32);
+  uint32_t lower = static_cast<uint32_t>(u64 & 0xFFFFFFFF);
+  uint32_t upper = static_cast<uint32_t>(u64 >> 32);
   *this << lower << upper;
   return *this;
 }
diff --git a/src/processor/binarystream.h b/src/processor/binarystream.h
index 04657150..172e09b9 100644
--- a/src/processor/binarystream.h
+++ b/src/processor/binarystream.h
@@ -56,17 +56,17 @@ class binarystream {
     : stream_(string(str, size), which) {}
 
   binarystream &operator>>(string &str);
-  binarystream &operator>>(u_int8_t &u8);
-  binarystream &operator>>(u_int16_t &u16);
-  binarystream &operator>>(u_int32_t &u32);
-  binarystream &operator>>(u_int64_t &u64);
+  binarystream &operator>>(uint8_t &u8);
+  binarystream &operator>>(uint16_t &u16);
+  binarystream &operator>>(uint32_t &u32);
+  binarystream &operator>>(uint64_t &u64);
 
   // Note: strings are truncated at 65535 characters
   binarystream &operator<<(const string &str);
-  binarystream &operator<<(u_int8_t u8);
-  binarystream &operator<<(u_int16_t u16);
-  binarystream &operator<<(u_int32_t u32);
-  binarystream &operator<<(u_int64_t u64);
+  binarystream &operator<<(uint8_t u8);
+  binarystream &operator<<(uint16_t u16);
+  binarystream &operator<<(uint32_t u32);
+  binarystream &operator<<(uint64_t u64);
 
   // Forward a few methods directly from the stream object
   bool eof() const { return stream_.eof(); }
diff --git a/src/processor/binarystream_unittest.cc b/src/processor/binarystream_unittest.cc
index 8a3daa37..bf020edb 100644
--- a/src/processor/binarystream_unittest.cc
+++ b/src/processor/binarystream_unittest.cc
@@ -47,14 +47,14 @@ protected:
 };
  
 TEST_F(BinaryStreamBasicTest, ReadU8) {
-  u_int8_t u8 = 0;
+  uint8_t u8 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u8;
   ASSERT_TRUE(stream.eof());
   EXPECT_EQ(0U, u8);
   stream.rewind();
   stream.clear();
-  stream << (u_int8_t)1;
+  stream << (uint8_t)1;
   ASSERT_FALSE(stream.eof());
   stream >> u8;
   EXPECT_EQ(1, u8);
@@ -62,14 +62,14 @@ TEST_F(BinaryStreamBasicTest, ReadU8) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadU16) {
-  u_int16_t u16 = 0;
+  uint16_t u16 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u16;
   ASSERT_TRUE(stream.eof());
   EXPECT_EQ(0U, u16);
   stream.rewind();
   stream.clear();
-  stream << (u_int16_t)1;
+  stream << (uint16_t)1;
   ASSERT_FALSE(stream.eof());
   stream >> u16;
   EXPECT_EQ(1, u16);
@@ -77,14 +77,14 @@ TEST_F(BinaryStreamBasicTest, ReadU16) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadU32) {
-  u_int32_t u32 = 0;
+  uint32_t u32 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u32;
   ASSERT_TRUE(stream.eof());
   EXPECT_EQ(0U, u32);
   stream.rewind();
   stream.clear();
-  stream << (u_int32_t)1;
+  stream << (uint32_t)1;
   ASSERT_FALSE(stream.eof());
   stream >> u32;
   EXPECT_EQ(1U, u32);
@@ -92,14 +92,14 @@ TEST_F(BinaryStreamBasicTest, ReadU32) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadU64) {
-  u_int64_t u64 = 0;
+  uint64_t u64 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u64;
   ASSERT_TRUE(stream.eof());
   EXPECT_EQ(0U, u64);
   stream.rewind();
   stream.clear();
-  stream << (u_int64_t)1;
+  stream << (uint64_t)1;
   ASSERT_FALSE(stream.eof());
   stream >> u64;
   EXPECT_EQ(1U, u64);
@@ -137,8 +137,8 @@ TEST_F(BinaryStreamBasicTest, ReadEmptyString) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadMultiU8) {
-  const u_int8_t ea = 0, eb = 100, ec = 200, ed = 0xFF;
-  u_int8_t a, b, c, d, e;
+  const uint8_t ea = 0, eb = 100, ec = 200, ed = 0xFF;
+  uint8_t a, b, c, d, e;
   stream << ea << eb << ec << ed;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
@@ -167,8 +167,8 @@ TEST_F(BinaryStreamBasicTest, ReadMultiU8) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadMultiU16) {
-  const u_int16_t ea = 0, eb = 0x100, ec = 0x8000, ed = 0xFFFF;
-  u_int16_t a, b, c, d, e;
+  const uint16_t ea = 0, eb = 0x100, ec = 0x8000, ed = 0xFFFF;
+  uint16_t a, b, c, d, e;
   stream << ea << eb << ec << ed;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
@@ -197,8 +197,8 @@ TEST_F(BinaryStreamBasicTest, ReadMultiU16) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadMultiU32) {
-  const u_int32_t ea = 0, eb = 0x10000, ec = 0x8000000, ed = 0xFFFFFFFF;
-  u_int32_t a, b, c, d, e;
+  const uint32_t ea = 0, eb = 0x10000, ec = 0x8000000, ed = 0xFFFFFFFF;
+  uint32_t a, b, c, d, e;
   stream << ea << eb << ec << ed;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
@@ -227,9 +227,9 @@ TEST_F(BinaryStreamBasicTest, ReadMultiU32) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadMultiU64) {
-  const u_int64_t ea = 0, eb = 0x10000, ec = 0x100000000ULL,
+  const uint64_t ea = 0, eb = 0x10000, ec = 0x100000000ULL,
     ed = 0xFFFFFFFFFFFFFFFFULL;
-  u_int64_t a, b, c, d, e;
+  uint64_t a, b, c, d, e;
   stream << ea << eb << ec << ed;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
@@ -258,15 +258,15 @@ TEST_F(BinaryStreamBasicTest, ReadMultiU64) {
 }
 
 TEST_F(BinaryStreamBasicTest, ReadMixed) {
-  const u_int8_t e8 = 0x10;
-  const u_int16_t e16 = 0x2020;
-  const u_int32_t e32 = 0x30303030;
-  const u_int64_t e64 = 0x4040404040404040ULL;
+  const uint8_t e8 = 0x10;
+  const uint16_t e16 = 0x2020;
+  const uint32_t e32 = 0x30303030;
+  const uint64_t e64 = 0x4040404040404040ULL;
   const string es = "test";
-  u_int8_t u8 = 0;
-  u_int16_t u16 = 0;
-  u_int32_t u32 = 0;
-  u_int64_t u64 = 0;
+  uint8_t u8 = 0;
+  uint16_t u16 = 0;
+  uint32_t u32 = 0;
+  uint64_t u64 = 0;
   string s("test");
   stream << e8 << e16 << e32 << e64 << es;
   stream >> u8 >> u16 >> u32 >> u64 >> s;
@@ -280,7 +280,7 @@ TEST_F(BinaryStreamBasicTest, ReadMixed) {
 
 TEST_F(BinaryStreamBasicTest, ReadStringMissing) {
   // ensure that reading a string where only the length is present fails
-  u_int16_t u16 = 8;
+  uint16_t u16 = 8;
   stream << u16;
   stream.rewind();
   string s("");
@@ -291,9 +291,9 @@ TEST_F(BinaryStreamBasicTest, ReadStringMissing) {
 
 TEST_F(BinaryStreamBasicTest, ReadStringTruncated) {
   // ensure that reading a string where not all the data is present fails
-  u_int16_t u16 = 8;
+  uint16_t u16 = 8;
   stream << u16;
-  stream << (u_int8_t)'t' << (u_int8_t)'e' << (u_int8_t)'s' << (u_int8_t)'t';
+  stream << (uint8_t)'t' << (uint8_t)'e' << (uint8_t)'s' << (uint8_t)'t';
   stream.rewind();
   string s("");
   stream >> s;
@@ -303,7 +303,7 @@ TEST_F(BinaryStreamBasicTest, ReadStringTruncated) {
 
 TEST_F(BinaryStreamBasicTest, StreamByteLength) {
   // Test that the stream buffer contains the right amount of data
-  stream << (u_int8_t)0 << (u_int16_t)1 << (u_int32_t)2 << (u_int64_t)3
+  stream << (uint8_t)0 << (uint16_t)1 << (uint32_t)2 << (uint64_t)3
          << string("test");
   string s = stream.str();
   EXPECT_EQ(21U, s.length());
@@ -313,8 +313,8 @@ TEST_F(BinaryStreamBasicTest, AppendStreamResultsByteLength) {
   // Test that appending the str() results from two streams
   // gives the right byte length
   binarystream stream2;
-  stream << (u_int8_t)0 << (u_int16_t)1;
-  stream2 << (u_int32_t)0 << (u_int64_t)2
+  stream << (uint8_t)0 << (uint16_t)1;
+  stream2 << (uint32_t)0 << (uint64_t)2
           << string("test");
   string s = stream.str();
   string s2 = stream2.str();
@@ -344,12 +344,12 @@ protected:
   binarystream stream;
 
   void SetUp() {
-    stream << (u_int8_t)1;
+    stream << (uint8_t)1;
   }
 };
 
 TEST_F(BinaryStreamU8Test, ReadU16) {
-  u_int16_t u16 = 0;
+  uint16_t u16 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u16;
   ASSERT_TRUE(stream.eof());
@@ -357,7 +357,7 @@ TEST_F(BinaryStreamU8Test, ReadU16) {
 }
 
 TEST_F(BinaryStreamU8Test, ReadU32) {
-  u_int32_t u32 = 0;
+  uint32_t u32 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u32;
   ASSERT_TRUE(stream.eof());
@@ -365,7 +365,7 @@ TEST_F(BinaryStreamU8Test, ReadU32) {
 }
 
 TEST_F(BinaryStreamU8Test, ReadU64) {
-  u_int64_t u64 = 0;
+  uint64_t u64 = 0;
   ASSERT_FALSE(stream.eof());
   stream >> u64;
   ASSERT_TRUE(stream.eof());
@@ -384,7 +384,7 @@ TEST_F(BinaryStreamU8Test, ReadString) {
 TEST(BinaryStreamTest, InitWithData) {
   const char *data = "abcd";
   binarystream stream(data);
-  u_int8_t a, b, c, d;
+  uint8_t a, b, c, d;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
   EXPECT_EQ('a', a);
@@ -396,7 +396,7 @@ TEST(BinaryStreamTest, InitWithData) {
 TEST(BinaryStreamTest, InitWithDataLeadingNull) {
   const char *data = "\0abcd";
   binarystream stream(data, 5);
-  u_int8_t z, a, b, c, d;
+  uint8_t z, a, b, c, d;
   stream >> z >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
   EXPECT_EQ(0U, z);
@@ -415,7 +415,7 @@ TEST(BinaryStreamTest, InitWithDataVector) {
   data.push_back('e');
   data.resize(4);
   binarystream stream(&data[0], data.size());
-  u_int8_t a, b, c, d;
+  uint8_t a, b, c, d;
   stream >> a >> b >> c >> d;
   ASSERT_FALSE(stream.eof());
   EXPECT_EQ('a', a);
diff --git a/src/processor/cfi_frame_info.cc b/src/processor/cfi_frame_info.cc
index d8394619..881a2a7a 100644
--- a/src/processor/cfi_frame_info.cc
+++ b/src/processor/cfi_frame_info.cc
@@ -88,14 +88,14 @@ bool CFIFrameInfo::FindCallerRegs(const RegisterValueMap<V> &registers,
 }
 
 // Explicit instantiations for 32-bit and 64-bit architectures.
-template bool CFIFrameInfo::FindCallerRegs<u_int32_t>(
-    const RegisterValueMap<u_int32_t> &registers,
+template bool CFIFrameInfo::FindCallerRegs<uint32_t>(
+    const RegisterValueMap<uint32_t> &registers,
     const MemoryRegion &memory,
-    RegisterValueMap<u_int32_t> *caller_registers) const;
-template bool CFIFrameInfo::FindCallerRegs<u_int64_t>(
-    const RegisterValueMap<u_int64_t> &registers,
+    RegisterValueMap<uint32_t> *caller_registers) const;
+template bool CFIFrameInfo::FindCallerRegs<uint64_t>(
+    const RegisterValueMap<uint64_t> &registers,
     const MemoryRegion &memory,
-    RegisterValueMap<u_int64_t> *caller_registers) const;
+    RegisterValueMap<uint64_t> *caller_registers) const;
 
 string CFIFrameInfo::Serialize() const {
   std::ostringstream stream;
diff --git a/src/processor/cfi_frame_info.h b/src/processor/cfi_frame_info.h
index 4bbbd1ef..bba2978e 100644
--- a/src/processor/cfi_frame_info.h
+++ b/src/processor/cfi_frame_info.h
@@ -80,8 +80,8 @@ class CFIFrameInfo {
 
   // Compute the values of the calling frame's registers, according to
   // this rule set. Use ValueType in expression evaluation; this
-  // should be u_int32_t on machines with 32-bit addresses, or
-  // u_int64_t on machines with 64-bit addresses.
+  // should be uint32_t on machines with 32-bit addresses, or
+  // uint64_t on machines with 64-bit addresses.
   //
   // Return true on success, false otherwise.
   //
@@ -204,7 +204,7 @@ class CFIFrameInfoParseHandler: public CFIRuleParser::Handler {
 // up in a class should allow the walkers to share code.
 //
 // RegisterType should be the type of this architecture's registers, either
-// u_int32_t or u_int64_t. RawContextType should be the raw context
+// uint32_t or uint64_t. RawContextType should be the raw context
 // structure type for this architecture.
 template <typename RegisterType, class RawContextType>
 class SimpleCFIWalker {
diff --git a/src/processor/cfi_frame_info_unittest.cc b/src/processor/cfi_frame_info_unittest.cc
index cd48e16d..eabce113 100644
--- a/src/processor/cfi_frame_info_unittest.cc
+++ b/src/processor/cfi_frame_info_unittest.cc
@@ -54,12 +54,12 @@ using testing::Test;
 
 class MockMemoryRegion: public MemoryRegion {
  public:
-  MOCK_CONST_METHOD0(GetBase, u_int64_t());
-  MOCK_CONST_METHOD0(GetSize, u_int32_t());
-  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int8_t *));
-  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int16_t *));
-  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int32_t *));
-  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(u_int64_t, u_int64_t *));
+  MOCK_CONST_METHOD0(GetBase, uint64_t());
+  MOCK_CONST_METHOD0(GetSize, uint32_t());
+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint8_t *));
+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint16_t *));
+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint32_t *));
+  MOCK_CONST_METHOD2(GetMemoryAtAddress, bool(uint64_t, uint64_t *));
 };
 
 // Handy definitions for all tests.
@@ -69,15 +69,15 @@ struct CFIFixture {
   void ExpectNoMemoryReferences() {
     EXPECT_CALL(memory, GetBase()).Times(0);
     EXPECT_CALL(memory, GetSize()).Times(0);
-    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int8_t *>())).Times(0);
-    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int16_t *>())).Times(0);
-    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int32_t *>())).Times(0);
-    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<u_int64_t *>())).Times(0);
+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint8_t *>())).Times(0);
+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint16_t *>())).Times(0);
+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint32_t *>())).Times(0);
+    EXPECT_CALL(memory, GetMemoryAtAddress(_, A<uint64_t *>())).Times(0);
   }
 
   CFIFrameInfo cfi;
   MockMemoryRegion memory;
-  CFIFrameInfo::RegisterValueMap<u_int64_t> registers, caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint64_t> registers, caller_registers;
 };
 
 class Simple: public CFIFixture, public Test { };
@@ -87,7 +87,7 @@ TEST_F(Simple, NoCFA) {
   ExpectNoMemoryReferences();
 
   cfi.SetRARule("0");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
   ASSERT_EQ(".ra: 0", cfi.Serialize());
 }
@@ -97,7 +97,7 @@ TEST_F(Simple, NoRA) {
   ExpectNoMemoryReferences();
 
   cfi.SetCFARule("0");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
   ASSERT_EQ(".cfa: 0", cfi.Serialize());
 }
@@ -107,7 +107,7 @@ TEST_F(Simple, SetCFAAndRARule) {
 
   cfi.SetCFARule("330903416631436410");
   cfi.SetRARule("5870666104170902211");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(2U, caller_registers.size());
   ASSERT_EQ(330903416631436410ULL, caller_registers[".cfa"]);
@@ -126,7 +126,7 @@ TEST_F(Simple, SetManyRules) {
   cfi.SetRegisterRule("vodkathumbscrewingly", "24076308 .cfa +");
   cfi.SetRegisterRule("pubvexingfjordschmaltzy", ".cfa 29801007 -");
   cfi.SetRegisterRule("uncopyrightables", "92642917 .cfa /");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(6U, caller_registers.size());
   ASSERT_EQ(7664691U,           caller_registers[".cfa"]);
@@ -150,7 +150,7 @@ TEST_F(Simple, RulesOverride) {
   cfi.SetCFARule("330903416631436410");
   cfi.SetRARule("5870666104170902211");
   cfi.SetCFARule("2828089117179001");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(2U, caller_registers.size());
   ASSERT_EQ(2828089117179001ULL, caller_registers[".cfa"]);
@@ -167,7 +167,7 @@ TEST_F(Scope, CFALacksCFA) {
 
   cfi.SetCFARule(".cfa");
   cfi.SetRARule("0");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
 }
 
@@ -177,7 +177,7 @@ TEST_F(Scope, CFALacksRA) {
 
   cfi.SetCFARule(".ra");
   cfi.SetRARule("0");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
 }
 
@@ -190,7 +190,7 @@ TEST_F(Scope, CFASeesCurrentRegs) {
   registers[".ornithorhynchus"] = 0x5e0bf850bafce9d2ULL;
   cfi.SetCFARule(".baraminology .ornithorhynchus +");
   cfi.SetRARule("0");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(2U, caller_registers.size());
   ASSERT_EQ(0x06a7bc63e4f13893ULL + 0x5e0bf850bafce9d2ULL,
@@ -203,7 +203,7 @@ TEST_F(Scope, RASeesCFA) {
 
   cfi.SetCFARule("48364076");
   cfi.SetRARule(".cfa");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(2U, caller_registers.size());
   ASSERT_EQ(48364076U, caller_registers[".ra"]);
@@ -215,7 +215,7 @@ TEST_F(Scope, RALacksRA) {
 
   cfi.SetCFARule("0");
   cfi.SetRARule(".ra");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
 }
 
@@ -227,7 +227,7 @@ TEST_F(Scope, RASeesCurrentRegs) {
   registers["noachian"] = 0x54dc4a5d8e5eb503ULL;
   cfi.SetCFARule("10359370");
   cfi.SetRARule("noachian");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(2U, caller_registers.size());
   ASSERT_EQ(0x54dc4a5d8e5eb503ULL, caller_registers[".ra"]);
@@ -240,7 +240,7 @@ TEST_F(Scope, RegistersSeeCFA) {
   cfi.SetCFARule("6515179");
   cfi.SetRARule(".cfa");
   cfi.SetRegisterRule("rogerian", ".cfa");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(3U, caller_registers.size());
   ASSERT_EQ(6515179U, caller_registers["rogerian"]);
@@ -253,7 +253,7 @@ TEST_F(Scope, RegsLackRA) {
   cfi.SetCFARule("42740329");
   cfi.SetRARule("27045204");
   cfi.SetRegisterRule("$r1", ".ra");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
 }
 
@@ -267,7 +267,7 @@ TEST_F(Scope, RegsSeeRegs) {
   cfi.SetRARule("30503835");
   cfi.SetRegisterRule("$r1", "$r1 42175211 = $r2");
   cfi.SetRegisterRule("$r2", "$r2 21357221 = $r1");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(4U, caller_registers.size());
   ASSERT_EQ(0xd27d9e742b8df6d0ULL, caller_registers["$r1"]);
@@ -280,12 +280,12 @@ TEST_F(Scope, SeparateTempsRA) {
 
   cfi.SetCFARule("$temp1 76569129 = $temp1");
   cfi.SetRARule("0");
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
 
   cfi.SetCFARule("$temp1 76569129 = $temp1");
   cfi.SetRARule("$temp1");
-  ASSERT_FALSE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_FALSE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                              &caller_registers));
 }
 
@@ -427,7 +427,7 @@ TEST_F(ParseHandler, CFARARule) {
   handler.RARule("reg-for-ra");
   registers["reg-for-cfa"] = 0x268a9a4a3821a797ULL;
   registers["reg-for-ra"] = 0x6301b475b8b91c02ULL;
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(0x268a9a4a3821a797ULL, caller_registers[".cfa"]);
   ASSERT_EQ(0x6301b475b8b91c02ULL, caller_registers[".ra"]);
@@ -442,7 +442,7 @@ TEST_F(ParseHandler, RegisterRules) {
   registers["reg-for-ra"] = 0x6301b475b8b91c02ULL;
   registers["reg-for-reg1"] = 0x06cde8e2ff062481ULL;
   registers["reg-for-reg2"] = 0xff0c4f76403173e2ULL;
-  ASSERT_TRUE(cfi.FindCallerRegs<u_int64_t>(registers, memory,
+  ASSERT_TRUE(cfi.FindCallerRegs<uint64_t>(registers, memory,
                                             &caller_registers));
   ASSERT_EQ(0x268a9a4a3821a797ULL, caller_registers[".cfa"]);
   ASSERT_EQ(0x6301b475b8b91c02ULL, caller_registers[".ra"]);
@@ -452,7 +452,7 @@ TEST_F(ParseHandler, RegisterRules) {
 
 struct SimpleCFIWalkerFixture {
   struct RawContext {
-    u_int64_t r0, r1, r2, r3, r4, sp, pc;
+    uint64_t r0, r1, r2, r3, r4, sp, pc;
   };
   enum Validity {
     R0_VALID = 0x01,
@@ -463,7 +463,7 @@ struct SimpleCFIWalkerFixture {
     SP_VALID = 0x20,
     PC_VALID = 0x40
   };
-  typedef SimpleCFIWalker<u_int64_t, RawContext> CFIWalker;
+  typedef SimpleCFIWalker<uint64_t, RawContext> CFIWalker;
 
   SimpleCFIWalkerFixture()
       : walker(register_map,
@@ -504,16 +504,16 @@ TEST_F(SimpleWalker, Walk) {
   // r4 is not recoverable, even though it is a callee-saves register.
   //    Some earlier frame's unwinder must have failed to recover it.
 
-  u_int64_t stack_top = 0x83254944b20d5512ULL;
+  uint64_t stack_top = 0x83254944b20d5512ULL;
 
   // Saved r0.
   EXPECT_CALL(memory,
-              GetMemoryAtAddress(stack_top, A<u_int64_t *>()))
+              GetMemoryAtAddress(stack_top, A<uint64_t *>()))
       .WillRepeatedly(DoAll(SetArgumentPointee<1>(0xdc1975eba8602302ULL),
                             Return(true)));
   // Saved return address.
   EXPECT_CALL(memory,
-              GetMemoryAtAddress(stack_top + 16, A<u_int64_t *>()))
+              GetMemoryAtAddress(stack_top + 16, A<uint64_t *>()))
       .WillRepeatedly(DoAll(SetArgumentPointee<1>(0xba5ad6d9acce28deULL),
                             Return(true)));
 
diff --git a/src/processor/disassembler_x86.cc b/src/processor/disassembler_x86.cc
index 45a235db..9eba848d 100644
--- a/src/processor/disassembler_x86.cc
+++ b/src/processor/disassembler_x86.cc
@@ -31,9 +31,9 @@
 
 namespace google_breakpad {
 
-DisassemblerX86::DisassemblerX86(const u_int8_t *bytecode,
-                                 u_int32_t size,
-                                 u_int32_t virtual_address) :
+DisassemblerX86::DisassemblerX86(const uint8_t *bytecode,
+                                 uint32_t size,
+                                 uint32_t virtual_address) :
                                      bytecode_(bytecode),
                                      size_(size),
                                      virtual_address_(virtual_address),
@@ -54,7 +54,7 @@ DisassemblerX86::~DisassemblerX86() {
   libdis::x86_cleanup();
 }
 
-u_int32_t DisassemblerX86::NextInstruction() {
+uint32_t DisassemblerX86::NextInstruction() {
   if (instr_valid_)
     libdis::x86_oplist_free(&current_instr_);
 
@@ -62,7 +62,7 @@ u_int32_t DisassemblerX86::NextInstruction() {
     instr_valid_ = false;
     return 0;
   }
-  u_int32_t instr_size = 0;
+  uint32_t instr_size = 0;
   instr_size = libdis::x86_disasm((unsigned char *)bytecode_, size_,
                           virtual_address_, current_byte_offset_,
                           &current_instr_);
diff --git a/src/processor/disassembler_x86.h b/src/processor/disassembler_x86.h
index 3bdd558f..71069410 100644
--- a/src/processor/disassembler_x86.h
+++ b/src/processor/disassembler_x86.h
@@ -37,6 +37,7 @@
 #define GOOGLE_BREAKPAD_PROCESSOR_DISASSEMBLER_X86_H_
 
 #include <stddef.h>
+#include <sys/types.h>
 
 #include "google_breakpad/common/breakpad_types.h"
 
@@ -62,7 +63,7 @@ class DisassemblerX86 {
     // TODO(cdn): Modify this class to take a MemoryRegion instead of just
     // a raw buffer. This will make it easier to use this on arbitrary
     // minidumps without first copying out the code segment.
-    DisassemblerX86(const u_int8_t *bytecode, u_int32_t, u_int32_t);
+    DisassemblerX86(const uint8_t *bytecode, uint32_t, uint32_t);
     ~DisassemblerX86();
 
     // This walks to the next instruction in the memory region and
@@ -70,7 +71,7 @@ class DisassemblerX86 {
     // including any registers marked as bad through setBadRead()
     // or setBadWrite(). This method can be called in a loop to
     // disassemble until the end of a region.
-    u_int32_t NextInstruction();
+    uint32_t NextInstruction();
 
     // Indicates whether the current disassembled instruction was valid.
     bool currentInstructionValid() { return instr_valid_; }
@@ -90,7 +91,7 @@ class DisassemblerX86 {
     bool endOfBlock() { return end_of_block_; }
 
     // The flags set so far for the disassembly.
-    u_int16_t flags() { return flags_; }
+    uint16_t flags() { return flags_; }
 
     // This sets an indicator that the register used to determine
     // src or dest for the current instruction is tainted. These can
@@ -101,11 +102,11 @@ class DisassemblerX86 {
     bool setBadWrite();
 
   protected:
-    const u_int8_t *bytecode_;
-    u_int32_t size_;
-    u_int32_t virtual_address_;
-    u_int32_t current_byte_offset_;
-    u_int32_t current_inst_offset_;
+    const uint8_t *bytecode_;
+    uint32_t size_;
+    uint32_t virtual_address_;
+    uint32_t current_byte_offset_;
+    uint32_t current_inst_offset_;
 
     bool instr_valid_;
     libdis::x86_insn_t current_instr_;
@@ -118,7 +119,7 @@ class DisassemblerX86 {
     bool pushed_bad_value_;
     bool end_of_block_;
 
-    u_int16_t flags_;
+    uint16_t flags_;
 };
 
 }  // namespace google_breakpad
diff --git a/src/processor/exploitability.cc b/src/processor/exploitability.cc
index 16807a3c..5355b7d1 100644
--- a/src/processor/exploitability.cc
+++ b/src/processor/exploitability.cc
@@ -92,9 +92,9 @@ Exploitability *Exploitability::ExploitabilityForPlatform(
   return platform_exploitability;
 }
 
-bool Exploitability::AddressIsAscii(u_int64_t address) {
+bool Exploitability::AddressIsAscii(uint64_t address) {
   for (int i = 0; i < 8; i++) {
-    u_int8_t byte = (address >> (8*i)) & 0xff;
+    uint8_t byte = (address >> (8*i)) & 0xff;
     if ((byte >= ' ' && byte <= '~') || byte == 0)
       continue;
     return false;
diff --git a/src/processor/exploitability_win.cc b/src/processor/exploitability_win.cc
index e0798452..e20fbdda 100644
--- a/src/processor/exploitability_win.cc
+++ b/src/processor/exploitability_win.cc
@@ -50,8 +50,8 @@ namespace google_breakpad {
 
 // The cutoff that we use to judge if and address is likely an offset
 // from various interesting addresses.
-static const u_int64_t kProbableNullOffset = 4096;
-static const u_int64_t kProbableStackOffset = 8192;
+static const uint64_t kProbableNullOffset = 4096;
+static const uint64_t kProbableStackOffset = 8192;
 
 // The various cutoffs for the different ratings.
 static const size_t kHighCutoff        = 100;
@@ -98,14 +98,14 @@ ExploitabilityRating ExploitabilityWin::CheckPlatformExploitability() {
     BPLOG(INFO) << "Minidump memory segments not available.";
     memory_available = false;
   }
-  u_int64_t address = process_state_->crash_address();
-  u_int32_t exception_code = raw_exception->exception_record.exception_code;
+  uint64_t address = process_state_->crash_address();
+  uint32_t exception_code = raw_exception->exception_record.exception_code;
 
-  u_int32_t exploitability_weight = 0;
+  uint32_t exploitability_weight = 0;
 
-  u_int64_t stack_ptr = 0;
-  u_int64_t instruction_ptr = 0;
-  u_int64_t this_ptr = 0;
+  uint64_t stack_ptr = 0;
+  uint64_t instruction_ptr = 0;
+  uint64_t this_ptr = 0;
 
   switch (context->GetContextCPU()) {
     case MD_CONTEXT_X86:
@@ -211,14 +211,14 @@ ExploitabilityRating ExploitabilityWin::CheckPlatformExploitability() {
             context->GetContextCPU() == MD_CONTEXT_X86 &&
             (bad_read || bad_write)) {
           // Perform checks related to memory around instruction pointer.
-          u_int32_t memory_offset =
+          uint32_t memory_offset =
               instruction_ptr - instruction_region->GetBase();
-          u_int32_t available_memory =
+          uint32_t available_memory =
               instruction_region->GetSize() - memory_offset;
           available_memory = available_memory > kDisassembleBytesBeyondPC ?
               kDisassembleBytesBeyondPC : available_memory;
           if (available_memory) {
-            const u_int8_t *raw_memory =
+            const uint8_t *raw_memory =
                 instruction_region->GetMemory() + memory_offset;
             DisassemblerX86 disassembler(raw_memory,
                                          available_memory,
diff --git a/src/processor/fast_source_line_resolver.cc b/src/processor/fast_source_line_resolver.cc
index 29a8f091..86073d2d 100644
--- a/src/processor/fast_source_line_resolver.cc
+++ b/src/processor/fast_source_line_resolver.cc
@@ -116,15 +116,15 @@ WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char *raw) {
   // The first 8 bytes of int data are unused.
   // They correspond to "StackInfoTypes type_;" and "int valid;"
   // data member of WFI.
-  const u_int32_t *para_uint32 = reinterpret_cast<const u_int32_t*>(
+  const uint32_t *para_uint32 = reinterpret_cast<const uint32_t*>(
       raw + 2 * sizeof(int32_t));
 
-  u_int32_t prolog_size = para_uint32[0];;
-  u_int32_t epilog_size = para_uint32[1];
-  u_int32_t parameter_size = para_uint32[2];
-  u_int32_t saved_register_size = para_uint32[3];
-  u_int32_t local_size = para_uint32[4];
-  u_int32_t max_stack_size = para_uint32[5];
+  uint32_t prolog_size = para_uint32[0];;
+  uint32_t epilog_size = para_uint32[1];
+  uint32_t parameter_size = para_uint32[2];
+  uint32_t saved_register_size = para_uint32[3];
+  uint32_t local_size = para_uint32[4];
+  uint32_t max_stack_size = para_uint32[5];
   const char *boolean = reinterpret_cast<const char*>(para_uint32 + 6);
   bool allocates_base_pointer = (*boolean != 0);
   string program_string = boolean + 1;
@@ -146,7 +146,7 @@ WindowsFrameInfo FastSourceLineResolver::CopyWFI(const char *raw) {
 bool FastSourceLineResolver::Module::LoadMapFromMemory(char *mem_buffer) {
   if (!mem_buffer) return false;
 
-  const u_int32_t *map_sizes = reinterpret_cast<const u_int32_t*>(mem_buffer);
+  const uint32_t *map_sizes = reinterpret_cast<const uint32_t*>(mem_buffer);
 
   unsigned int header_size = kNumberMaps_ * sizeof(unsigned int);
 
diff --git a/src/processor/fast_source_line_resolver_unittest.cc b/src/processor/fast_source_line_resolver_unittest.cc
index c982c541..26982bfc 100644
--- a/src/processor/fast_source_line_resolver_unittest.cc
+++ b/src/processor/fast_source_line_resolver_unittest.cc
@@ -71,8 +71,8 @@ class TestCodeModule : public CodeModule {
   explicit TestCodeModule(string code_file) : code_file_(code_file) {}
   virtual ~TestCodeModule() {}
 
-  virtual u_int64_t base_address() const { return 0; }
-  virtual u_int64_t size() const { return 0xb000; }
+  virtual uint64_t base_address() const { return 0; }
+  virtual uint64_t size() const { return 0xb000; }
   virtual string code_file() const { return code_file_; }
   virtual string code_identifier() const { return ""; }
   virtual string debug_file() const { return ""; }
@@ -88,17 +88,17 @@ class TestCodeModule : public CodeModule {
 
 // A mock memory region object, for use by the STACK CFI tests.
 class MockMemoryRegion: public MemoryRegion {
-  u_int64_t GetBase() const { return 0x10000; }
-  u_int32_t GetSize() const { return 0x01000; }
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t *value) const {
+  uint64_t GetBase() const { return 0x10000; }
+  uint32_t GetSize() const { return 0x01000; }
+  bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
     *value = address & 0xff;
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
     *value = address & 0xffff;
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
     switch (address) {
       case 0x10008: *value = 0x98ecadc3; break;  // saved %ebx
       case 0x1000c: *value = 0x878f7524; break;  // saved %esi
@@ -109,7 +109,7 @@ class MockMemoryRegion: public MemoryRegion {
     }
     return true;
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
     *value = address;
     return true;
   }
@@ -121,9 +121,9 @@ class MockMemoryRegion: public MemoryRegion {
 // ".cfa".
 static bool VerifyRegisters(
     const char *file, int line,
-    const CFIFrameInfo::RegisterValueMap<u_int32_t> &expected,
-    const CFIFrameInfo::RegisterValueMap<u_int32_t> &actual) {
-  CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator a;
+    const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
+    const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
+  CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
   a = actual.find(".cfa");
   if (a == actual.end())
     return false;
@@ -131,7 +131,7 @@ static bool VerifyRegisters(
   if (a == actual.end())
     return false;
   for (a = actual.begin(); a != actual.end(); a++) {
-    CFIFrameInfo::RegisterValueMap<u_int32_t>::const_iterator e =
+    CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e =
       expected.find(a->first);
     if (e == expected.end()) {
       fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n",
@@ -280,9 +280,9 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_FALSE(cfi_frame_info.get());
 
-  CFIFrameInfo::RegisterValueMap<u_int32_t> current_registers;
-  CFIFrameInfo::RegisterValueMap<u_int32_t> caller_registers;
-  CFIFrameInfo::RegisterValueMap<u_int32_t> expected_caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> current_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers;
   MockMemoryRegion memory;
 
   // Regardless of which instruction evaluation takes place at, it
@@ -305,7 +305,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
                               expected_caller_registers, caller_registers));
@@ -315,7 +315,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
                               expected_caller_registers, caller_registers));
@@ -325,7 +325,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -335,7 +335,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -345,7 +345,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
@@ -355,7 +355,7 @@ TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
   ASSERT_TRUE(cfi_frame_info.get());
   ASSERT_TRUE(cfi_frame_info.get()
-              ->FindCallerRegs<u_int32_t>(current_registers, memory,
+              ->FindCallerRegs<uint32_t>(current_registers, memory,
                                           &caller_registers));
   VerifyRegisters(__FILE__, __LINE__,
                   expected_caller_registers, caller_registers);
diff --git a/src/processor/logging.cc b/src/processor/logging.cc
index a6e15cae..8bb95a69 100644
--- a/src/processor/logging.cc
+++ b/src/processor/logging.cc
@@ -83,13 +83,13 @@ LogStream::~LogStream() {
   stream_ << std::endl;
 }
 
-string HexString(u_int32_t number) {
+string HexString(uint32_t number) {
   char buffer[11];
   snprintf(buffer, sizeof(buffer), "0x%x", number);
   return string(buffer);
 }
 
-string HexString(u_int64_t number) {
+string HexString(uint64_t number) {
   char buffer[19];
   snprintf(buffer, sizeof(buffer), "0x%" PRIx64, number);
   return string(buffer);
diff --git a/src/processor/logging.h b/src/processor/logging.h
index 6a964f6e..4925e67f 100644
--- a/src/processor/logging.h
+++ b/src/processor/logging.h
@@ -119,8 +119,8 @@ class LogMessageVoidify {
 };
 
 // Returns number formatted as a hexadecimal string, such as "0x7b".
-string HexString(u_int32_t number);
-string HexString(u_int64_t number);
+string HexString(uint32_t number);
+string HexString(uint64_t number);
 string HexString(int number);
 
 // Returns the error code as set in the global errno variable, and sets
diff --git a/src/processor/map_serializers-inl.h b/src/processor/map_serializers-inl.h
index d68e8b9f..61c7bbd7 100644
--- a/src/processor/map_serializers-inl.h
+++ b/src/processor/map_serializers-inl.h
@@ -55,7 +55,7 @@ template<typename Key, typename Value>
 size_t StdMapSerializer<Key, Value>::SizeOf(
     const std::map<Key, Value> &m) const {
   size_t size = 0;
-  size_t header_size = (1 + m.size()) * sizeof(u_int32_t);
+  size_t header_size = (1 + m.size()) * sizeof(uint32_t);
   size += header_size;
 
   typename std::map<Key, Value>::const_iterator iter;
@@ -77,10 +77,10 @@ char *StdMapSerializer<Key, Value>::Write(const std::map<Key, Value> &m,
 
   // Write header:
   // Number of nodes.
-  dest = SimpleSerializer<u_int32_t>::Write(m.size(), dest);
+  dest = SimpleSerializer<uint32_t>::Write(m.size(), dest);
   // Nodes offsets.
-  u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
-  dest += sizeof(u_int32_t) * m.size();
+  uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+  dest += sizeof(uint32_t) * m.size();
 
   char *key_address = dest;
   dest += sizeof(Key) * m.size();
@@ -89,7 +89,7 @@ char *StdMapSerializer<Key, Value>::Write(const std::map<Key, Value> &m,
   typename std::map<Key, Value>::const_iterator iter;
   int index = 0;
   for (iter = m.begin(); iter != m.end(); ++iter, ++index) {
-    offsets[index] = static_cast<u_int32_t>(dest - start_address);
+    offsets[index] = static_cast<uint32_t>(dest - start_address);
     key_address = key_serializer_.Write(iter->first, key_address);
     dest = value_serializer_.Write(iter->second, dest);
   }
@@ -119,7 +119,7 @@ template<typename Address, typename Entry>
 size_t RangeMapSerializer<Address, Entry>::SizeOf(
     const RangeMap<Address, Entry> &m) const {
   size_t size = 0;
-  size_t header_size = (1 + m.map_.size()) * sizeof(u_int32_t);
+  size_t header_size = (1 + m.map_.size()) * sizeof(uint32_t);
   size += header_size;
 
   typename std::map<Address, Range>::const_iterator iter;
@@ -145,10 +145,10 @@ char *RangeMapSerializer<Address, Entry>::Write(
 
   // Write header:
   // Number of nodes.
-  dest = SimpleSerializer<u_int32_t>::Write(m.map_.size(), dest);
+  dest = SimpleSerializer<uint32_t>::Write(m.map_.size(), dest);
   // Nodes offsets.
-  u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
-  dest += sizeof(u_int32_t) * m.map_.size();
+  uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+  dest += sizeof(uint32_t) * m.map_.size();
 
   char *key_address = dest;
   dest += sizeof(Address) * m.map_.size();
@@ -157,7 +157,7 @@ char *RangeMapSerializer<Address, Entry>::Write(
   typename std::map<Address, Range>::const_iterator iter;
   int index = 0;
   for (iter = m.map_.begin(); iter != m.map_.end(); ++iter, ++index) {
-    offsets[index] = static_cast<u_int32_t>(dest - start_address);
+    offsets[index] = static_cast<uint32_t>(dest - start_address);
     key_address = address_serializer_.Write(iter->first, key_address);
     dest = address_serializer_.Write(iter->second.base(), dest);
     dest = entry_serializer_.Write(iter->second.entry(), dest);
@@ -192,12 +192,12 @@ size_t ContainedRangeMapSerializer<AddrType, EntryType>::SizeOf(
   size_t size = 0;
   size_t header_size = addr_serializer_.SizeOf(m->base_)
                        + entry_serializer_.SizeOf(m->entry_)
-                       + sizeof(u_int32_t);
+                       + sizeof(uint32_t);
   size += header_size;
   // In case m.map_ == NULL, we treat it as an empty map:
-  size += sizeof(u_int32_t);
+  size += sizeof(uint32_t);
   if (m->map_) {
-    size += m->map_->size() * sizeof(u_int32_t);
+    size += m->map_->size() * sizeof(uint32_t);
     typename Map::const_iterator iter;
     for (iter = m->map_->begin(); iter != m->map_->end(); ++iter) {
       size += addr_serializer_.SizeOf(iter->first);
@@ -216,18 +216,18 @@ char *ContainedRangeMapSerializer<AddrType, EntryType>::Write(
     return NULL;
   }
   dest = addr_serializer_.Write(m->base_, dest);
-  dest = SimpleSerializer<u_int32_t>::Write(entry_serializer_.SizeOf(m->entry_),
+  dest = SimpleSerializer<uint32_t>::Write(entry_serializer_.SizeOf(m->entry_),
                                             dest);
   dest = entry_serializer_.Write(m->entry_, dest);
 
   // Write map<<AddrType, ContainedRangeMap*>:
   char *map_address = dest;
   if (m->map_ == NULL) {
-    dest = SimpleSerializer<u_int32_t>::Write(0, dest);
+    dest = SimpleSerializer<uint32_t>::Write(0, dest);
   } else {
-    dest = SimpleSerializer<u_int32_t>::Write(m->map_->size(), dest);
-    u_int32_t *offsets = reinterpret_cast<u_int32_t*>(dest);
-    dest += sizeof(u_int32_t) * m->map_->size();
+    dest = SimpleSerializer<uint32_t>::Write(m->map_->size(), dest);
+    uint32_t *offsets = reinterpret_cast<uint32_t*>(dest);
+    dest += sizeof(uint32_t) * m->map_->size();
 
     char *key_address = dest;
     dest += sizeof(AddrType) * m->map_->size();
@@ -236,7 +236,7 @@ char *ContainedRangeMapSerializer<AddrType, EntryType>::Write(
     typename Map::const_iterator iter;
     int index = 0;
     for (iter = m->map_->begin(); iter != m->map_->end(); ++iter, ++index) {
-      offsets[index] = static_cast<u_int32_t>(dest - map_address);
+      offsets[index] = static_cast<uint32_t>(dest - map_address);
       key_address = addr_serializer_.Write(iter->first, key_address);
       // Recursively write.
       dest = Write(iter->second, dest);
diff --git a/src/processor/map_serializers_unittest.cc b/src/processor/map_serializers_unittest.cc
index abaef976..95d03d01 100644
--- a/src/processor/map_serializers_unittest.cc
+++ b/src/processor/map_serializers_unittest.cc
@@ -64,13 +64,13 @@ class TestStdMapSerializer : public ::testing::Test {
 
   std::map<AddrType, EntryType> std_map_;
   google_breakpad::StdMapSerializer<AddrType, EntryType> serializer_;
-  u_int32_t serialized_size_;
+  uint32_t serialized_size_;
   char *serialized_data_;
 };
 
 TEST_F(TestStdMapSerializer, EmptyMapTestCase) {
   const int32_t correct_data[] = { 0 };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   // std_map_ is empty.
   serialized_data_ = serializer_.Serialize(std_map_, &serialized_size_);
@@ -90,7 +90,7 @@ TEST_F(TestStdMapSerializer, MapWithTwoElementsTestCase) {
       // Values
       2, 6
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   std_map_.insert(std::make_pair(1, 2));
   std_map_.insert(std::make_pair(3, 6));
@@ -112,7 +112,7 @@ TEST_F(TestStdMapSerializer, MapWithFiveElementsTestCase) {
       // Values
       11, 12, 13, 14, 15
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   for (int i = 1; i < 6; ++i)
     std_map_.insert(std::make_pair(i, 10 + i));
@@ -136,13 +136,13 @@ class TestAddressMapSerializer : public ::testing::Test {
 
   google_breakpad::AddressMap<AddrType, EntryType> address_map_;
   google_breakpad::AddressMapSerializer<AddrType, EntryType> serializer_;
-  u_int32_t serialized_size_;
+  uint32_t serialized_size_;
   char *serialized_data_;
 };
 
 TEST_F(TestAddressMapSerializer, EmptyMapTestCase) {
   const int32_t correct_data[] = { 0 };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   // std_map_ is empty.
   serialized_data_ = serializer_.Serialize(address_map_, &serialized_size_);
@@ -162,7 +162,7 @@ TEST_F(TestAddressMapSerializer, MapWithTwoElementsTestCase) {
       // Values
       2, 6
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   address_map_.Store(1, 2);
   address_map_.Store(3, 6);
@@ -184,7 +184,7 @@ TEST_F(TestAddressMapSerializer, MapWithFourElementsTestCase) {
       // Values
       2, 3, 5, 8
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   address_map_.Store(-6, 2);
   address_map_.Store(-4, 3);
@@ -211,13 +211,13 @@ class TestRangeMapSerializer : public ::testing::Test {
 
   google_breakpad::RangeMap<AddrType, EntryType> range_map_;
   google_breakpad::RangeMapSerializer<AddrType, EntryType> serializer_;
-  u_int32_t serialized_size_;
+  uint32_t serialized_size_;
   char *serialized_data_;
 };
 
 TEST_F(TestRangeMapSerializer, EmptyMapTestCase) {
   const int32_t correct_data[] = { 0 };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   // range_map_ is empty.
   serialized_data_ = serializer_.Serialize(range_map_, &serialized_size_);
@@ -237,7 +237,7 @@ TEST_F(TestRangeMapSerializer, MapWithOneRangeTestCase) {
       // Values: (low address, entry) pairs
       1, 6
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   range_map_.StoreRange(1, 10, 6);
 
@@ -258,7 +258,7 @@ TEST_F(TestRangeMapSerializer, MapWithThreeRangesTestCase) {
       // Values: (low address, entry) pairs
       2, 1,  6, 2,  10, 3
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   ASSERT_TRUE(range_map_.StoreRange(2, 4, 1));
   ASSERT_TRUE(range_map_.StoreRange(6, 4, 2));
@@ -284,7 +284,7 @@ class TestContainedRangeMapSerializer : public ::testing::Test {
 
   google_breakpad::ContainedRangeMap<AddrType, EntryType> crm_map_;
   google_breakpad::ContainedRangeMapSerializer<AddrType, EntryType> serializer_;
-  u_int32_t serialized_size_;
+  uint32_t serialized_size_;
   char *serialized_data_;
 };
 
@@ -295,7 +295,7 @@ TEST_F(TestContainedRangeMapSerializer, EmptyMapTestCase) {
       0,  // entry stored at root
       0   // empty map stored at root
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   // crm_map_ is empty.
   serialized_data_ = serializer_.Serialize(&crm_map_, &serialized_size_);
@@ -319,7 +319,7 @@ TEST_F(TestContainedRangeMapSerializer, MapWithOneRangeTestCase) {
       -1, // entry stored in child CRM
       0   // empty sub-map stored in child CRM
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   crm_map_.StoreRange(3, 7, -1);
 
@@ -361,7 +361,7 @@ TEST_F(TestContainedRangeMapSerializer, MapWithTwoLevelsTestCase) {
         // grandchild3: base, entry_size, entry, empty_map
         16, 4, -1, 0
   };
-  u_int32_t correct_size = sizeof(correct_data);
+  uint32_t correct_size = sizeof(correct_data);
 
   // Store child1.
   ASSERT_TRUE(crm_map_.StoreRange(2, 7, -1));
diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc
index d033a0b6..e18a1675 100644..100755
--- a/src/processor/minidump.cc
+++ b/src/processor/minidump.cc
@@ -43,7 +43,9 @@
 
 #ifdef _WIN32
 #include <io.h>
+#if _MSC_VER < 1600
 typedef SSIZE_T ssize_t;
+#endif
 #define PRIx64 "llx"
 #define PRIx32 "lx"
 #define snprintf _snprintf
@@ -86,9 +88,9 @@ using std::vector;
 
 // Swapping an 8-bit quantity is a no-op.  This function is only provided
 // to account for certain templatized operations that require swapping for
-// wider types but handle u_int8_t too
+// wider types but handle uint8_t too
 // (MinidumpMemoryRegion::GetMemoryAtAddressInternal).
-static inline void Swap(u_int8_t* value) {
+static inline void Swap(uint8_t* value) {
 }
 
 
@@ -99,13 +101,13 @@ static inline void Swap(u_int8_t* value) {
 // The furthest left shift never needs to be ANDed bitmask.
 
 
-static inline void Swap(u_int16_t* value) {
+static inline void Swap(uint16_t* value) {
   *value = (*value >> 8) |
            (*value << 8);
 }
 
 
-static inline void Swap(u_int32_t* value) {
+static inline void Swap(uint32_t* value) {
   *value =  (*value >> 24) |
            ((*value >> 8)  & 0x0000ff00) |
            ((*value << 8)  & 0x00ff0000) |
@@ -113,11 +115,11 @@ static inline void Swap(u_int32_t* value) {
 }
 
 
-static inline void Swap(u_int64_t* value) {
-  u_int32_t* value32 = reinterpret_cast<u_int32_t*>(value);
+static inline void Swap(uint64_t* value) {
+  uint32_t* value32 = reinterpret_cast<uint32_t*>(value);
   Swap(&value32[0]);
   Swap(&value32[1]);
-  u_int32_t temp = value32[0];
+  uint32_t temp = value32[0];
   value32[0] = value32[1];
   value32[1] = temp;
 }
@@ -125,11 +127,11 @@ static inline void Swap(u_int64_t* value) {
 
 // Given a pointer to a 128-bit int in the minidump data, set the "low"
 // and "high" fields appropriately.
-static void Normalize128(u_int128_t* value, bool is_big_endian) {
+static void Normalize128(uint128_struct* value, bool is_big_endian) {
   // The struct format is [high, low], so if the format is big-endian,
   // the most significant bytes will already be in the high field.
   if (!is_big_endian) {
-    u_int64_t temp = value->low;
+    uint64_t temp = value->low;
     value->low = value->high;
     value->high = temp;
   }
@@ -137,7 +139,7 @@ static void Normalize128(u_int128_t* value, bool is_big_endian) {
 
 // This just swaps each int64 half of the 128-bit value.
 // The value should also be normalized by calling Normalize128().
-static void Swap(u_int128_t* value) {
+static void Swap(uint128_struct* value) {
   Swap(&value->low);
   Swap(&value->high);
 }
@@ -177,7 +179,7 @@ static inline void Swap(MDGUID* guid) {
 // parameter, a converter that uses iconv would also need to take the host
 // CPU's endianness into consideration.  It doesn't seems worth the trouble
 // of making it a dependency when we don't care about anything but UTF-16.
-static string* UTF16ToUTF8(const vector<u_int16_t>& in,
+static string* UTF16ToUTF8(const vector<uint16_t>& in,
                            bool                     swap) {
   scoped_ptr<string> out(new string());
 
@@ -186,16 +188,16 @@ static string* UTF16ToUTF8(const vector<u_int16_t>& in,
   // If the UTF-8 representation is longer, the string will grow dynamically.
   out->reserve(in.size());
 
-  for (vector<u_int16_t>::const_iterator iterator = in.begin();
+  for (vector<uint16_t>::const_iterator iterator = in.begin();
        iterator != in.end();
        ++iterator) {
     // Get a 16-bit value from the input
-    u_int16_t in_word = *iterator;
+    uint16_t in_word = *iterator;
     if (swap)
       Swap(&in_word);
 
     // Convert the input value (in_word) into a Unicode code point (unichar).
-    u_int32_t unichar;
+    uint32_t unichar;
     if (in_word >= 0xdc00 && in_word <= 0xdcff) {
       BPLOG(ERROR) << "UTF16ToUTF8 found low surrogate " <<
                       HexString(in_word) << " without high";
@@ -208,7 +210,7 @@ static string* UTF16ToUTF8(const vector<u_int16_t>& in,
                         HexString(in_word) << " at end of string";
         return NULL;
       }
-      u_int32_t high_word = in_word;
+      uint32_t high_word = in_word;
       in_word = *iterator;
       if (in_word < 0xdc00 || in_word > 0xdcff) {
         BPLOG(ERROR) << "UTF16ToUTF8 found high surrogate " <<
@@ -251,7 +253,7 @@ static string* UTF16ToUTF8(const vector<u_int16_t>& in,
 
 // Return the smaller of the number of code units in the UTF-16 string,
 // not including the terminating null word, or maxlen.
-static size_t UTF16codeunits(const u_int16_t *string, size_t maxlen) {
+static size_t UTF16codeunits(const uint16_t *string, size_t maxlen) {
   size_t count = 0;
   while (count < maxlen && string[count] != 0)
     count++;
@@ -297,7 +299,7 @@ MinidumpContext::~MinidumpContext() {
 }
 
 
-bool MinidumpContext::Read(u_int32_t expected_size) {
+bool MinidumpContext::Read(uint32_t expected_size) {
   valid_ = false;
 
   FreeContext();
@@ -318,7 +320,7 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
     if (minidump_->swap())
       Swap(&context_amd64->context_flags);
 
-    u_int32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK;
+    uint32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK;
     if (cpu_type == 0) {
       if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
         context_amd64->context_flags |= cpu_type;
@@ -410,7 +412,7 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
     context_.amd64 = context_amd64.release();
   }
   else {
-    u_int32_t context_flags;
+    uint32_t context_flags;
     if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) {
       BPLOG(ERROR) << "MinidumpContext could not read context flags";
       return false;
@@ -418,7 +420,7 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
     if (minidump_->swap())
       Swap(&context_flags);
 
-    u_int32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
+    uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
     if (cpu_type == 0) {
       // Unfortunately the flag for MD_CONTEXT_ARM that was taken
       // from a Windows CE SDK header conflicts in practice with
@@ -460,8 +462,8 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
         context_x86->context_flags = context_flags;
 
         size_t flags_size = sizeof(context_x86->context_flags);
-        u_int8_t* context_after_flags =
-          reinterpret_cast<u_int8_t*>(context_x86.get()) + flags_size;
+        uint8_t* context_after_flags =
+          reinterpret_cast<uint8_t*>(context_x86.get()) + flags_size;
         if (!minidump_->ReadBytes(context_after_flags,
                                   sizeof(MDRawContextX86) - flags_size)) {
           BPLOG(ERROR) << "MinidumpContext could not read x86 context";
@@ -533,8 +535,8 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
         context_ppc->context_flags = context_flags;
 
         size_t flags_size = sizeof(context_ppc->context_flags);
-        u_int8_t* context_after_flags =
-          reinterpret_cast<u_int8_t*>(context_ppc.get()) + flags_size;
+        uint8_t* context_after_flags =
+          reinterpret_cast<uint8_t*>(context_ppc.get()) + flags_size;
         if (!minidump_->ReadBytes(context_after_flags,
                                   sizeof(MDRawContextPPC) - flags_size)) {
           BPLOG(ERROR) << "MinidumpContext could not read ppc context";
@@ -609,8 +611,8 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
         context_sparc->context_flags = context_flags;
 
         size_t flags_size = sizeof(context_sparc->context_flags);
-        u_int8_t* context_after_flags =
-            reinterpret_cast<u_int8_t*>(context_sparc.get()) + flags_size;
+        uint8_t* context_after_flags =
+            reinterpret_cast<uint8_t*>(context_sparc.get()) + flags_size;
         if (!minidump_->ReadBytes(context_after_flags,
                                   sizeof(MDRawContextSPARC) - flags_size)) {
           BPLOG(ERROR) << "MinidumpContext could not read sparc context";
@@ -665,8 +667,8 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
         context_arm->context_flags = context_flags;
 
         size_t flags_size = sizeof(context_arm->context_flags);
-        u_int8_t* context_after_flags =
-            reinterpret_cast<u_int8_t*>(context_arm.get()) + flags_size;
+        uint8_t* context_after_flags =
+            reinterpret_cast<uint8_t*>(context_arm.get()) + flags_size;
         if (!minidump_->ReadBytes(context_after_flags,
                                   sizeof(MDRawContextARM) - flags_size)) {
           BPLOG(ERROR) << "MinidumpContext could not read arm context";
@@ -722,7 +724,7 @@ bool MinidumpContext::Read(u_int32_t expected_size) {
 }
 
 
-u_int32_t MinidumpContext::GetContextCPU() const {
+uint32_t MinidumpContext::GetContextCPU() const {
   if (!valid_) {
     // Don't log a message, GetContextCPU can be legitimately called with
     // valid_ false by FreeContext, which is called by Read.
@@ -732,7 +734,7 @@ u_int32_t MinidumpContext::GetContextCPU() const {
   return context_flags_ & MD_CONTEXT_CPU_MASK;
 }
 
-bool MinidumpContext::GetInstructionPointer(u_int64_t* ip) const {
+bool MinidumpContext::GetInstructionPointer(uint64_t* ip) const {
   BPLOG_IF(ERROR, !ip) << "MinidumpContext::GetInstructionPointer "
                           "requires |ip|";
   assert(ip);
@@ -848,7 +850,7 @@ void MinidumpContext::FreeContext() {
 }
 
 
-bool MinidumpContext::CheckAgainstSystemInfo(u_int32_t context_cpu_type) {
+bool MinidumpContext::CheckAgainstSystemInfo(uint32_t context_cpu_type) {
   // It's OK if the minidump doesn't contain an MD_SYSTEM_INFO_STREAM,
   // as this function just implements a sanity check.
   MinidumpSystemInfo* system_info = minidump_->GetSystemInfo();
@@ -1147,7 +1149,7 @@ void MinidumpContext::Print() {
 //
 
 
-u_int32_t MinidumpMemoryRegion::max_bytes_ = 1024 * 1024;  // 1MB
+uint32_t MinidumpMemoryRegion::max_bytes_ = 1024 * 1024;  // 1MB
 
 
 MinidumpMemoryRegion::MinidumpMemoryRegion(Minidump* minidump)
@@ -1166,12 +1168,12 @@ void MinidumpMemoryRegion::SetDescriptor(MDMemoryDescriptor* descriptor) {
   descriptor_ = descriptor;
   valid_ = descriptor &&
            descriptor_->memory.data_size <=
-               numeric_limits<u_int64_t>::max() -
+               numeric_limits<uint64_t>::max() -
                descriptor_->start_of_memory_range;
 }
 
 
-const u_int8_t* MinidumpMemoryRegion::GetMemory() const {
+const uint8_t* MinidumpMemoryRegion::GetMemory() const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetMemory";
     return NULL;
@@ -1195,8 +1197,8 @@ const u_int8_t* MinidumpMemoryRegion::GetMemory() const {
       return NULL;
     }
 
-    scoped_ptr< vector<u_int8_t> > memory(
-        new vector<u_int8_t>(descriptor_->memory.data_size));
+    scoped_ptr< vector<uint8_t> > memory(
+        new vector<uint8_t>(descriptor_->memory.data_size));
 
     if (!minidump_->ReadBytes(&(*memory)[0], descriptor_->memory.data_size)) {
       BPLOG(ERROR) << "MinidumpMemoryRegion could not read memory region";
@@ -1210,17 +1212,17 @@ const u_int8_t* MinidumpMemoryRegion::GetMemory() const {
 }
 
 
-u_int64_t MinidumpMemoryRegion::GetBase() const {
+uint64_t MinidumpMemoryRegion::GetBase() const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetBase";
-    return static_cast<u_int64_t>(-1);
+    return static_cast<uint64_t>(-1);
   }
 
   return descriptor_->start_of_memory_range;
 }
 
 
-u_int32_t MinidumpMemoryRegion::GetSize() const {
+uint32_t MinidumpMemoryRegion::GetSize() const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetSize";
     return 0;
@@ -1237,7 +1239,7 @@ void MinidumpMemoryRegion::FreeMemory() {
 
 
 template<typename T>
-bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address,
+bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(uint64_t address,
                                                       T*        value) const {
   BPLOG_IF(ERROR, !value) << "MinidumpMemoryRegion::GetMemoryAtAddressInternal "
                              "requires |value|";
@@ -1252,7 +1254,7 @@ bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address,
 
   // Common failure case
   if (address < descriptor_->start_of_memory_range ||
-      sizeof(T) > numeric_limits<u_int64_t>::max() - address ||
+      sizeof(T) > numeric_limits<uint64_t>::max() - address ||
       address + sizeof(T) > descriptor_->start_of_memory_range +
                             descriptor_->memory.data_size) {
     BPLOG(INFO) << "MinidumpMemoryRegion request out of range: " <<
@@ -1262,7 +1264,7 @@ bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address,
     return false;
   }
 
-  const u_int8_t* memory = GetMemory();
+  const uint8_t* memory = GetMemory();
   if (!memory) {
     // GetMemory already logged a perfectly good message.
     return false;
@@ -1280,26 +1282,26 @@ bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(u_int64_t address,
 }
 
 
-bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
-                                              u_int8_t*  value) const {
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
+                                              uint8_t*  value) const {
   return GetMemoryAtAddressInternal(address, value);
 }
 
 
-bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
-                                              u_int16_t* value) const {
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
+                                              uint16_t* value) const {
   return GetMemoryAtAddressInternal(address, value);
 }
 
 
-bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
-                                              u_int32_t* value) const {
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
+                                              uint32_t* value) const {
   return GetMemoryAtAddressInternal(address, value);
 }
 
 
-bool MinidumpMemoryRegion::GetMemoryAtAddress(u_int64_t  address,
-                                              u_int64_t* value) const {
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t  address,
+                                              uint64_t* value) const {
   return GetMemoryAtAddressInternal(address, value);
 }
 
@@ -1310,7 +1312,7 @@ void MinidumpMemoryRegion::Print() {
     return;
   }
 
-  const u_int8_t* memory = GetMemory();
+  const uint8_t* memory = GetMemory();
   if (memory) {
     printf("0x");
     for (unsigned int byte_index = 0;
@@ -1370,7 +1372,7 @@ bool MinidumpThread::Read() {
 
   // Check for base + size overflow or undersize.
   if (thread_.stack.memory.data_size == 0 ||
-      thread_.stack.memory.data_size > numeric_limits<u_int64_t>::max() -
+      thread_.stack.memory.data_size > numeric_limits<uint64_t>::max() -
                                        thread_.stack.start_of_memory_range) {
     // This is ok, but log an error anyway.
     BPLOG(ERROR) << "MinidumpThread has a memory region problem, " <<
@@ -1422,7 +1424,7 @@ MinidumpContext* MinidumpThread::GetContext() {
 }
 
 
-bool MinidumpThread::GetThreadID(u_int32_t *thread_id) const {
+bool MinidumpThread::GetThreadID(uint32_t *thread_id) const {
   BPLOG_IF(ERROR, !thread_id) << "MinidumpThread::GetThreadID requires "
                                  "|thread_id|";
   assert(thread_id);
@@ -1485,7 +1487,7 @@ void MinidumpThread::Print() {
 //
 
 
-u_int32_t MinidumpThreadList::max_threads_ = 4096;
+uint32_t MinidumpThreadList::max_threads_ = 4096;
 
 
 MinidumpThreadList::MinidumpThreadList(Minidump* minidump)
@@ -1501,7 +1503,7 @@ MinidumpThreadList::~MinidumpThreadList() {
 }
 
 
-bool MinidumpThreadList::Read(u_int32_t expected_size) {
+bool MinidumpThreadList::Read(uint32_t expected_size) {
   // Invalidate cached data.
   id_to_thread_map_.clear();
   delete threads_;
@@ -1510,7 +1512,7 @@ bool MinidumpThreadList::Read(u_int32_t expected_size) {
 
   valid_ = false;
 
-  u_int32_t thread_count;
+  uint32_t thread_count;
   if (expected_size < sizeof(thread_count)) {
     BPLOG(ERROR) << "MinidumpThreadList count size mismatch, " <<
                     expected_size << " < " << sizeof(thread_count);
@@ -1524,7 +1526,7 @@ bool MinidumpThreadList::Read(u_int32_t expected_size) {
   if (minidump_->swap())
     Swap(&thread_count);
 
-  if (thread_count > numeric_limits<u_int32_t>::max() / sizeof(MDRawThread)) {
+  if (thread_count > numeric_limits<uint32_t>::max() / sizeof(MDRawThread)) {
     BPLOG(ERROR) << "MinidumpThreadList thread count " << thread_count <<
                     " would cause multiplication overflow";
     return false;
@@ -1535,7 +1537,7 @@ bool MinidumpThreadList::Read(u_int32_t expected_size) {
     // may be padded with 4 bytes on 64bit ABIs for alignment
     if (expected_size == sizeof(thread_count) + 4 +
                          thread_count * sizeof(MDRawThread)) {
-      u_int32_t useless;
+      uint32_t useless;
       if (!minidump_->ReadBytes(&useless, 4)) {
         BPLOG(ERROR) << "MinidumpThreadList cannot read threadlist padded bytes";
         return false;
@@ -1571,7 +1573,7 @@ bool MinidumpThreadList::Read(u_int32_t expected_size) {
         return false;
       }
 
-      u_int32_t thread_id;
+      uint32_t thread_id;
       if (!thread->GetThreadID(&thread_id)) {
         BPLOG(ERROR) << "MinidumpThreadList cannot get thread ID for thread " <<
                         thread_index << "/" << thread_count;
@@ -1615,7 +1617,7 @@ MinidumpThread* MinidumpThreadList::GetThreadAtIndex(unsigned int index)
 }
 
 
-MinidumpThread* MinidumpThreadList::GetThreadByID(u_int32_t thread_id) {
+MinidumpThread* MinidumpThreadList::GetThreadByID(uint32_t thread_id) {
   // Don't check valid_.  Read calls this method before everything is
   // validated.  It is safe to not check valid_ here.
   return id_to_thread_map_[thread_id];
@@ -1647,8 +1649,8 @@ void MinidumpThreadList::Print() {
 //
 
 
-u_int32_t MinidumpModule::max_cv_bytes_ = 32768;
-u_int32_t MinidumpModule::max_misc_bytes_ = 32768;
+uint32_t MinidumpModule::max_cv_bytes_ = 32768;
+uint32_t MinidumpModule::max_misc_bytes_ = 32768;
 
 
 MinidumpModule::MinidumpModule(Minidump* minidump)
@@ -1717,7 +1719,7 @@ bool MinidumpModule::Read() {
   // Check for base + size overflow or undersize.
   if (module_.size_of_image == 0 ||
       module_.size_of_image >
-          numeric_limits<u_int64_t>::max() - module_.base_of_image) {
+          numeric_limits<uint64_t>::max() - module_.base_of_image) {
     BPLOG(ERROR) << "MinidumpModule has a module problem, " <<
                     HexString(module_.base_of_image) << "+" <<
                     HexString(module_.size_of_image);
@@ -1892,9 +1894,9 @@ string MinidumpModule::debug_file() const {
         if (bytes % 2 == 0) {
           unsigned int utf16_words = bytes / 2;
 
-          // UTF16ToUTF8 expects a vector<u_int16_t>, so create a temporary one
+          // UTF16ToUTF8 expects a vector<uint16_t>, so create a temporary one
           // and copy the UTF-16 data into it.
-          vector<u_int16_t> string_utf16(utf16_words);
+          vector<uint16_t> string_utf16(utf16_words);
           if (utf16_words)
             memcpy(&string_utf16[0], &misc_record->data, bytes);
 
@@ -2021,7 +2023,7 @@ const CodeModule* MinidumpModule::Copy() const {
 }
 
 
-const u_int8_t* MinidumpModule::GetCVRecord(u_int32_t* size) {
+const uint8_t* MinidumpModule::GetCVRecord(uint32_t* size) {
   if (!module_valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModule for GetCVRecord";
     return NULL;
@@ -2047,21 +2049,21 @@ const u_int8_t* MinidumpModule::GetCVRecord(u_int32_t* size) {
     }
 
     // Allocating something that will be accessed as MDCVInfoPDB70 or
-    // MDCVInfoPDB20 but is allocated as u_int8_t[] can cause alignment
+    // MDCVInfoPDB20 but is allocated as uint8_t[] can cause alignment
     // problems.  x86 and ppc are able to cope, though.  This allocation
     // style is needed because the MDCVInfoPDB70 or MDCVInfoPDB20 are
     // variable-sized due to their pdb_file_name fields; these structures
     // are not MDCVInfoPDB70_minsize or MDCVInfoPDB20_minsize and treating
     // them as such would result in incomplete structures or overruns.
-    scoped_ptr< vector<u_int8_t> > cv_record(
-        new vector<u_int8_t>(module_.cv_record.data_size));
+    scoped_ptr< vector<uint8_t> > cv_record(
+        new vector<uint8_t>(module_.cv_record.data_size));
 
     if (!minidump_->ReadBytes(&(*cv_record)[0], module_.cv_record.data_size)) {
       BPLOG(ERROR) << "MinidumpModule could not read CodeView record";
       return NULL;
     }
 
-    u_int32_t signature = MD_CVINFOUNKNOWN_SIGNATURE;
+    uint32_t signature = MD_CVINFOUNKNOWN_SIGNATURE;
     if (module_.cv_record.data_size > sizeof(signature)) {
       MDCVInfoPDB70* cv_record_signature =
           reinterpret_cast<MDCVInfoPDB70*>(&(*cv_record)[0]);
@@ -2131,7 +2133,7 @@ const u_int8_t* MinidumpModule::GetCVRecord(u_int32_t* size) {
     // although byte-swapping can't be done.
 
     // Store the vector type because that's how storage was allocated, but
-    // return it casted to u_int8_t*.
+    // return it casted to uint8_t*.
     cv_record_ = cv_record.release();
     cv_record_signature_ = signature;
   }
@@ -2143,7 +2145,7 @@ const u_int8_t* MinidumpModule::GetCVRecord(u_int32_t* size) {
 }
 
 
-const MDImageDebugMisc* MinidumpModule::GetMiscRecord(u_int32_t* size) {
+const MDImageDebugMisc* MinidumpModule::GetMiscRecord(uint32_t* size) {
   if (!module_valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModule for GetMiscRecord";
     return NULL;
@@ -2175,13 +2177,13 @@ const MDImageDebugMisc* MinidumpModule::GetMiscRecord(u_int32_t* size) {
     }
 
     // Allocating something that will be accessed as MDImageDebugMisc but
-    // is allocated as u_int8_t[] can cause alignment problems.  x86 and
+    // is allocated as uint8_t[] can cause alignment problems.  x86 and
     // ppc are able to cope, though.  This allocation style is needed
     // because the MDImageDebugMisc is variable-sized due to its data field;
     // this structure is not MDImageDebugMisc_minsize and treating it as such
     // would result in an incomplete structure or an overrun.
-    scoped_ptr< vector<u_int8_t> > misc_record_mem(
-        new vector<u_int8_t>(module_.misc_record.data_size));
+    scoped_ptr< vector<uint8_t> > misc_record_mem(
+        new vector<uint8_t>(module_.misc_record.data_size));
     MDImageDebugMisc* misc_record =
         reinterpret_cast<MDImageDebugMisc*>(&(*misc_record_mem)[0]);
 
@@ -2200,7 +2202,7 @@ const MDImageDebugMisc* MinidumpModule::GetMiscRecord(u_int32_t* size) {
       if (misc_record->unicode) {
         // There is a potential alignment problem, but shouldn't be a problem
         // in practice due to the layout of MDImageDebugMisc.
-        u_int16_t* data16 = reinterpret_cast<u_int16_t*>(&(misc_record->data));
+        uint16_t* data16 = reinterpret_cast<uint16_t*>(&(misc_record->data));
         unsigned int dataBytes = module_.misc_record.data_size -
                                  MDImageDebugMisc_minsize;
         unsigned int dataLength = dataBytes / 2;
@@ -2284,8 +2286,8 @@ void MinidumpModule::Print() {
   printf("  (code_identifier)               = \"%s\"\n",
          code_identifier().c_str());
 
-  u_int32_t cv_record_size;
-  const u_int8_t *cv_record = GetCVRecord(&cv_record_size);
+  uint32_t cv_record_size;
+  const uint8_t *cv_record = GetCVRecord(&cv_record_size);
   if (cv_record) {
     if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
       const MDCVInfoPDB70* cv_record_70 =
@@ -2370,12 +2372,12 @@ void MinidumpModule::Print() {
 //
 
 
-u_int32_t MinidumpModuleList::max_modules_ = 1024;
+uint32_t MinidumpModuleList::max_modules_ = 1024;
 
 
 MinidumpModuleList::MinidumpModuleList(Minidump* minidump)
     : MinidumpStream(minidump),
-      range_map_(new RangeMap<u_int64_t, unsigned int>()),
+      range_map_(new RangeMap<uint64_t, unsigned int>()),
       modules_(NULL),
       module_count_(0) {
 }
@@ -2387,7 +2389,7 @@ MinidumpModuleList::~MinidumpModuleList() {
 }
 
 
-bool MinidumpModuleList::Read(u_int32_t expected_size) {
+bool MinidumpModuleList::Read(uint32_t expected_size) {
   // Invalidate cached data.
   range_map_->Clear();
   delete modules_;
@@ -2396,7 +2398,7 @@ bool MinidumpModuleList::Read(u_int32_t expected_size) {
 
   valid_ = false;
 
-  u_int32_t module_count;
+  uint32_t module_count;
   if (expected_size < sizeof(module_count)) {
     BPLOG(ERROR) << "MinidumpModuleList count size mismatch, " <<
                     expected_size << " < " << sizeof(module_count);
@@ -2410,7 +2412,7 @@ bool MinidumpModuleList::Read(u_int32_t expected_size) {
   if (minidump_->swap())
     Swap(&module_count);
 
-  if (module_count > numeric_limits<u_int32_t>::max() / MD_MODULE_SIZE) {
+  if (module_count > numeric_limits<uint32_t>::max() / MD_MODULE_SIZE) {
     BPLOG(ERROR) << "MinidumpModuleList module count " << module_count <<
                     " would cause multiplication overflow";
     return false;
@@ -2421,7 +2423,7 @@ bool MinidumpModuleList::Read(u_int32_t expected_size) {
     // may be padded with 4 bytes on 64bit ABIs for alignment
     if (expected_size == sizeof(module_count) + 4 +
                          module_count * MD_MODULE_SIZE) {
-      u_int32_t useless;
+      uint32_t useless;
       if (!minidump_->ReadBytes(&useless, 4)) {
         BPLOG(ERROR) << "MinidumpModuleList cannot read modulelist padded bytes";
         return false;
@@ -2482,9 +2484,9 @@ bool MinidumpModuleList::Read(u_int32_t expected_size) {
       // It is safe to use module->code_file() after successfully calling
       // module->ReadAuxiliaryData or noting that the module is valid.
 
-      u_int64_t base_address = module->base_address();
-      u_int64_t module_size = module->size();
-      if (base_address == static_cast<u_int64_t>(-1)) {
+      uint64_t base_address = module->base_address();
+      uint64_t module_size = module->size();
+      if (base_address == static_cast<uint64_t>(-1)) {
         BPLOG(ERROR) << "MinidumpModuleList found bad base address "
                         "for module " << module_index << "/" << module_count <<
                         ", " << module->code_file();
@@ -2512,7 +2514,7 @@ bool MinidumpModuleList::Read(u_int32_t expected_size) {
 
 
 const MinidumpModule* MinidumpModuleList::GetModuleForAddress(
-    u_int64_t address) const {
+    uint64_t address) const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModuleList for GetModuleForAddress";
     return NULL;
@@ -2611,12 +2613,12 @@ void MinidumpModuleList::Print() {
 //
 
 
-u_int32_t MinidumpMemoryList::max_regions_ = 4096;
+uint32_t MinidumpMemoryList::max_regions_ = 4096;
 
 
 MinidumpMemoryList::MinidumpMemoryList(Minidump* minidump)
     : MinidumpStream(minidump),
-      range_map_(new RangeMap<u_int64_t, unsigned int>()),
+      range_map_(new RangeMap<uint64_t, unsigned int>()),
       descriptors_(NULL),
       regions_(NULL),
       region_count_(0) {
@@ -2630,7 +2632,7 @@ MinidumpMemoryList::~MinidumpMemoryList() {
 }
 
 
-bool MinidumpMemoryList::Read(u_int32_t expected_size) {
+bool MinidumpMemoryList::Read(uint32_t expected_size) {
   // Invalidate cached data.
   delete descriptors_;
   descriptors_ = NULL;
@@ -2641,7 +2643,7 @@ bool MinidumpMemoryList::Read(u_int32_t expected_size) {
 
   valid_ = false;
 
-  u_int32_t region_count;
+  uint32_t region_count;
   if (expected_size < sizeof(region_count)) {
     BPLOG(ERROR) << "MinidumpMemoryList count size mismatch, " <<
                     expected_size << " < " << sizeof(region_count);
@@ -2656,7 +2658,7 @@ bool MinidumpMemoryList::Read(u_int32_t expected_size) {
     Swap(&region_count);
 
   if (region_count >
-          numeric_limits<u_int32_t>::max() / sizeof(MDMemoryDescriptor)) {
+          numeric_limits<uint32_t>::max() / sizeof(MDMemoryDescriptor)) {
     BPLOG(ERROR) << "MinidumpMemoryList region count " << region_count <<
                     " would cause multiplication overflow";
     return false;
@@ -2667,7 +2669,7 @@ bool MinidumpMemoryList::Read(u_int32_t expected_size) {
     // may be padded with 4 bytes on 64bit ABIs for alignment
     if (expected_size == sizeof(region_count) + 4 +
                          region_count * sizeof(MDMemoryDescriptor)) {
-      u_int32_t useless;
+      uint32_t useless;
       if (!minidump_->ReadBytes(&useless, 4)) {
         BPLOG(ERROR) << "MinidumpMemoryList cannot read memorylist padded bytes";
         return false;
@@ -2709,12 +2711,12 @@ bool MinidumpMemoryList::Read(u_int32_t expected_size) {
       if (minidump_->swap())
         Swap(descriptor);
 
-      u_int64_t base_address = descriptor->start_of_memory_range;
-      u_int32_t region_size = descriptor->memory.data_size;
+      uint64_t base_address = descriptor->start_of_memory_range;
+      uint32_t region_size = descriptor->memory.data_size;
 
       // Check for base + size overflow or undersize.
       if (region_size == 0 ||
-          region_size > numeric_limits<u_int64_t>::max() - base_address) {
+          region_size > numeric_limits<uint64_t>::max() - base_address) {
         BPLOG(ERROR) << "MinidumpMemoryList has a memory region problem, " <<
                         " region " << region_index << "/" << region_count <<
                         ", " << HexString(base_address) << "+" <<
@@ -2762,7 +2764,7 @@ MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionAtIndex(
 
 
 MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionForAddress(
-    u_int64_t address) {
+    uint64_t address) {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryList for GetMemoryRegionForAddress";
     return NULL;
@@ -2828,7 +2830,7 @@ MinidumpException::~MinidumpException() {
 }
 
 
-bool MinidumpException::Read(u_int32_t expected_size) {
+bool MinidumpException::Read(uint32_t expected_size) {
   // Invalidate cached data.
   delete context_;
   context_ = NULL;
@@ -2870,7 +2872,7 @@ bool MinidumpException::Read(u_int32_t expected_size) {
 }
 
 
-bool MinidumpException::GetThreadID(u_int32_t *thread_id) const {
+bool MinidumpException::GetThreadID(uint32_t *thread_id) const {
   BPLOG_IF(ERROR, !thread_id) << "MinidumpException::GetThreadID requires "
                                  "|thread_id|";
   assert(thread_id);
@@ -2972,7 +2974,7 @@ MinidumpAssertion::~MinidumpAssertion() {
 }
 
 
-bool MinidumpAssertion::Read(u_int32_t expected_size) {
+bool MinidumpAssertion::Read(uint32_t expected_size) {
   // Invalidate cached data.
   valid_ = false;
 
@@ -2993,11 +2995,11 @@ bool MinidumpAssertion::Read(u_int32_t expected_size) {
   // Since we don't have an explicit byte length for each string,
   // we use UTF16codeunits to calculate word length, then derive byte
   // length from that.
-  u_int32_t word_length = UTF16codeunits(assertion_.expression,
+  uint32_t word_length = UTF16codeunits(assertion_.expression,
                                          sizeof(assertion_.expression));
   if (word_length > 0) {
-    u_int32_t byte_length = word_length * 2;
-    vector<u_int16_t> expression_utf16(word_length);
+    uint32_t byte_length = word_length * 2;
+    vector<uint16_t> expression_utf16(word_length);
     memcpy(&expression_utf16[0], &assertion_.expression[0], byte_length);
 
     scoped_ptr<string> new_expression(UTF16ToUTF8(expression_utf16,
@@ -3010,8 +3012,8 @@ bool MinidumpAssertion::Read(u_int32_t expected_size) {
   word_length = UTF16codeunits(assertion_.function,
                                sizeof(assertion_.function));
   if (word_length) {
-    u_int32_t byte_length = word_length * 2;
-    vector<u_int16_t> function_utf16(word_length);
+    uint32_t byte_length = word_length * 2;
+    vector<uint16_t> function_utf16(word_length);
     memcpy(&function_utf16[0], &assertion_.function[0], byte_length);
     scoped_ptr<string> new_function(UTF16ToUTF8(function_utf16,
                                                 minidump_->swap()));
@@ -3023,8 +3025,8 @@ bool MinidumpAssertion::Read(u_int32_t expected_size) {
   word_length = UTF16codeunits(assertion_.file,
                                sizeof(assertion_.file));
   if (word_length > 0) {
-    u_int32_t byte_length = word_length * 2;
-    vector<u_int16_t> file_utf16(word_length);
+    uint32_t byte_length = word_length * 2;
+    vector<uint16_t> file_utf16(word_length);
     memcpy(&file_utf16[0], &assertion_.file[0], byte_length);
     scoped_ptr<string> new_file(UTF16ToUTF8(file_utf16,
                                             minidump_->swap()));
@@ -3080,7 +3082,7 @@ MinidumpSystemInfo::~MinidumpSystemInfo() {
 }
 
 
-bool MinidumpSystemInfo::Read(u_int32_t expected_size) {
+bool MinidumpSystemInfo::Read(uint32_t expected_size) {
   // Invalidate cached data.
   delete csd_version_;
   csd_version_ = NULL;
@@ -3332,7 +3334,7 @@ MinidumpMiscInfo::MinidumpMiscInfo(Minidump* minidump)
 }
 
 
-bool MinidumpMiscInfo::Read(u_int32_t expected_size) {
+bool MinidumpMiscInfo::Read(uint32_t expected_size) {
   valid_ = false;
 
   if (expected_size != MD_MISCINFO_SIZE &&
@@ -3418,7 +3420,7 @@ MinidumpBreakpadInfo::MinidumpBreakpadInfo(Minidump* minidump)
 }
 
 
-bool MinidumpBreakpadInfo::Read(u_int32_t expected_size) {
+bool MinidumpBreakpadInfo::Read(uint32_t expected_size) {
   valid_ = false;
 
   if (expected_size != sizeof(breakpad_info_)) {
@@ -3443,7 +3445,7 @@ bool MinidumpBreakpadInfo::Read(u_int32_t expected_size) {
 }
 
 
-bool MinidumpBreakpadInfo::GetDumpThreadID(u_int32_t *thread_id) const {
+bool MinidumpBreakpadInfo::GetDumpThreadID(uint32_t *thread_id) const {
   BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetDumpThreadID "
                                  "requires |thread_id|";
   assert(thread_id);
@@ -3464,7 +3466,7 @@ bool MinidumpBreakpadInfo::GetDumpThreadID(u_int32_t *thread_id) const {
 }
 
 
-bool MinidumpBreakpadInfo::GetRequestingThreadID(u_int32_t *thread_id)
+bool MinidumpBreakpadInfo::GetRequestingThreadID(uint32_t *thread_id)
     const {
   BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetRequestingThreadID "
                                  "requires |thread_id|";
@@ -3525,7 +3527,7 @@ MinidumpMemoryInfo::MinidumpMemoryInfo(Minidump* minidump)
 
 
 bool MinidumpMemoryInfo::IsExecutable() const {
-  u_int32_t protection =
+  uint32_t protection =
       memory_info_.protection & MD_MEMORY_PROTECTION_ACCESS_MASK;
   return protection == MD_MEMORY_PROTECT_EXECUTE ||
       protection == MD_MEMORY_PROTECT_EXECUTE_READ ||
@@ -3534,7 +3536,7 @@ bool MinidumpMemoryInfo::IsExecutable() const {
 
 
 bool MinidumpMemoryInfo::IsWritable() const {
-  u_int32_t protection =
+  uint32_t protection =
       memory_info_.protection & MD_MEMORY_PROTECTION_ACCESS_MASK;
   return protection == MD_MEMORY_PROTECT_READWRITE ||
     protection == MD_MEMORY_PROTECT_WRITECOPY ||
@@ -3563,7 +3565,7 @@ bool MinidumpMemoryInfo::Read() {
 
   // Check for base + size overflow or undersize.
   if (memory_info_.region_size == 0 ||
-      memory_info_.region_size > numeric_limits<u_int64_t>::max() -
+      memory_info_.region_size > numeric_limits<uint64_t>::max() -
                                      memory_info_.base_address) {
     BPLOG(ERROR) << "MinidumpMemoryInfo has a memory region problem, " <<
                     HexString(memory_info_.base_address) << "+" <<
@@ -3603,7 +3605,7 @@ void MinidumpMemoryInfo::Print() {
 
 MinidumpMemoryInfoList::MinidumpMemoryInfoList(Minidump* minidump)
     : MinidumpStream(minidump),
-      range_map_(new RangeMap<u_int64_t, unsigned int>()),
+      range_map_(new RangeMap<uint64_t, unsigned int>()),
       infos_(NULL),
       info_count_(0) {
 }
@@ -3615,7 +3617,7 @@ MinidumpMemoryInfoList::~MinidumpMemoryInfoList() {
 }
 
 
-bool MinidumpMemoryInfoList::Read(u_int32_t expected_size) {
+bool MinidumpMemoryInfoList::Read(uint32_t expected_size) {
   // Invalidate cached data.
   delete infos_;
   infos_ = NULL;
@@ -3660,7 +3662,7 @@ bool MinidumpMemoryInfoList::Read(u_int32_t expected_size) {
   }
 
   if (header.number_of_entries >
-          numeric_limits<u_int32_t>::max() / sizeof(MDRawMemoryInfo)) {
+          numeric_limits<uint32_t>::max() / sizeof(MDRawMemoryInfo)) {
     BPLOG(ERROR) << "MinidumpMemoryInfoList info count " <<
                     header.number_of_entries <<
                     " would cause multiplication overflow";
@@ -3692,8 +3694,8 @@ bool MinidumpMemoryInfoList::Read(u_int32_t expected_size) {
         return false;
       }
 
-      u_int64_t base_address = info->GetBase();
-      u_int32_t region_size = info->GetSize();
+      uint64_t base_address = info->GetBase();
+      uint32_t region_size = info->GetSize();
 
       if (!range_map_->StoreRange(base_address, region_size, index)) {
         BPLOG(ERROR) << "MinidumpMemoryInfoList could not store"
@@ -3733,7 +3735,7 @@ const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoAtIndex(
 
 
 const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoForAddress(
-    u_int64_t address) const {
+    uint64_t address) const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryInfoList for"
                     " GetMemoryInfoForAddress";
@@ -3776,7 +3778,7 @@ void MinidumpMemoryInfoList::Print() {
 //
 
 
-u_int32_t Minidump::max_streams_ = 128;
+uint32_t Minidump::max_streams_ = 128;
 unsigned int Minidump::max_string_length_ = 1024;
 
 
@@ -3834,7 +3836,7 @@ bool Minidump::Open() {
   return true;
 }
 
-bool Minidump::GetContextCPUFlagsFromSystemInfo(u_int32_t *context_cpu_flags) {
+bool Minidump::GetContextCPUFlagsFromSystemInfo(uint32_t *context_cpu_flags) {
   // Initialize output parameters
   *context_cpu_flags = 0;
 
@@ -3924,7 +3926,7 @@ bool Minidump::Read() {
     // classes don't know or need to know what CPU (or endianness) the
     // minidump was produced on in order to parse it.  Use the signature as
     // a byte order marker.
-    u_int32_t signature_swapped = header_.signature;
+    uint32_t signature_swapped = header_.signature;
     Swap(&signature_swapped);
     if (signature_swapped != MD_HEADER_SIGNATURE) {
       // This isn't a minidump or a byte-swapped minidump.
@@ -4128,7 +4130,7 @@ void Minidump::Print() {
   for (MinidumpStreamMap::const_iterator iterator = stream_map_->begin();
        iterator != stream_map_->end();
        ++iterator) {
-    u_int32_t stream_type = iterator->first;
+    uint32_t stream_type = iterator->first;
     MinidumpStreamInfo info = iterator->second;
     printf("  stream type 0x%x at index %d\n", stream_type, info.stream_index);
   }
@@ -4210,7 +4212,7 @@ string* Minidump::ReadString(off_t offset) {
     return NULL;
   }
 
-  u_int32_t bytes;
+  uint32_t bytes;
   if (!ReadBytes(&bytes, sizeof(bytes))) {
     BPLOG(ERROR) << "ReadString could not read string size at offset " <<
                     offset;
@@ -4233,7 +4235,7 @@ string* Minidump::ReadString(off_t offset) {
     return NULL;
   }
 
-  vector<u_int16_t> string_utf16(utf16_words);
+  vector<uint16_t> string_utf16(utf16_words);
 
   if (utf16_words) {
     if (!ReadBytes(&string_utf16[0], bytes)) {
@@ -4247,8 +4249,8 @@ string* Minidump::ReadString(off_t offset) {
 }
 
 
-bool Minidump::SeekToStreamType(u_int32_t  stream_type,
-                                u_int32_t* stream_length) {
+bool Minidump::SeekToStreamType(uint32_t  stream_type,
+                                uint32_t* stream_length) {
   BPLOG_IF(ERROR, !stream_length) << "Minidump::SeekToStreamType requires "
                                      "|stream_length|";
   assert(stream_length);
@@ -4292,7 +4294,7 @@ T* Minidump::GetStream(T** stream) {
   // stream is a garbage parameter that's present only to account for C++'s
   // inability to overload a method based solely on its return type.
 
-  const u_int32_t stream_type = T::kStreamType;
+  const uint32_t stream_type = T::kStreamType;
 
   BPLOG_IF(ERROR, !stream) << "Minidump::GetStream type " << stream_type <<
                               " requires |stream|";
@@ -4321,7 +4323,7 @@ T* Minidump::GetStream(T** stream) {
     return *stream;
   }
 
-  u_int32_t stream_length;
+  uint32_t stream_length;
   if (!SeekToStreamType(stream_type, &stream_length)) {
     BPLOG(ERROR) << "GetStream could not seek to stream type " << stream_type;
     return NULL;
diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc
index f14aee85..343f0442 100644
--- a/src/processor/minidump_dump.cc
+++ b/src/processor/minidump_dump.cc
@@ -53,10 +53,10 @@ using google_breakpad::MinidumpMiscInfo;
 using google_breakpad::MinidumpBreakpadInfo;
 
 static void DumpRawStream(Minidump *minidump,
-                          u_int32_t stream_type,
+                          uint32_t stream_type,
                           const char *stream_name,
                           int *errors) {
-  u_int32_t length = 0;
+  uint32_t length = 0;
   if (!minidump->SeekToStreamType(stream_type, &length)) {
     return;
   }
@@ -78,7 +78,7 @@ static void DumpRawStream(Minidump *minidump,
     size_t remaining = length - current_offset;
     // Printf requires an int and direct casting from size_t results
     // in compatibility warnings.
-    u_int32_t int_remaining = remaining;
+    uint32_t int_remaining = remaining;
     printf("%.*s", int_remaining, &contents[current_offset]);
     char *next_null = reinterpret_cast<char *>(
         memchr(&contents[current_offset], 0, remaining));
diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc
index 14615ee9..059d8849 100644
--- a/src/processor/minidump_processor.cc
+++ b/src/processor/minidump_processor.cc
@@ -87,9 +87,9 @@ ProcessResult MinidumpProcessor::Process(
   bool has_cpu_info = GetCPUInfo(dump, &process_state->system_info_);
   bool has_os_info = GetOSInfo(dump, &process_state->system_info_);
 
-  u_int32_t dump_thread_id = 0;
+  uint32_t dump_thread_id = 0;
   bool has_dump_thread = false;
-  u_int32_t requesting_thread_id = 0;
+  uint32_t requesting_thread_id = 0;
   bool has_requesting_thread = false;
 
   MinidumpBreakpadInfo *breakpad_info = dump->GetBreakpadInfo();
@@ -156,7 +156,7 @@ ProcessResult MinidumpProcessor::Process(
       return PROCESS_ERROR_GETTING_THREAD;
     }
 
-    u_int32_t thread_id;
+    uint32_t thread_id;
     if (!thread->GetThreadID(&thread_id)) {
       BPLOG(ERROR) << "Could not get thread ID for " << thread_string;
       return PROCESS_ERROR_GETTING_THREAD_ID;
@@ -450,7 +450,7 @@ bool MinidumpProcessor::GetOSInfo(Minidump *dump, SystemInfo *info) {
 }
 
 // static
-string MinidumpProcessor::GetCrashReason(Minidump *dump, u_int64_t *address) {
+string MinidumpProcessor::GetCrashReason(Minidump *dump, uint64_t *address) {
   MinidumpException *exception = dump->GetException();
   if (!exception)
     return "";
@@ -467,8 +467,8 @@ string MinidumpProcessor::GetCrashReason(Minidump *dump, u_int64_t *address) {
   // map the codes to a string (because there's no system info, or because
   // it's an unrecognized platform, or because it's an unrecognized code.)
   char reason_string[24];
-  u_int32_t exception_code = raw_exception->exception_record.exception_code;
-  u_int32_t exception_flags = raw_exception->exception_record.exception_flags;
+  uint32_t exception_code = raw_exception->exception_record.exception_code;
+  uint32_t exception_flags = raw_exception->exception_record.exception_flags;
   snprintf(reason_string, sizeof(reason_string), "0x%08x / 0x%08x",
            exception_code, exception_flags);
   string reason = reason_string;
diff --git a/src/processor/minidump_processor_unittest.cc b/src/processor/minidump_processor_unittest.cc
index 999637d3..562c0f93 100644
--- a/src/processor/minidump_processor_unittest.cc
+++ b/src/processor/minidump_processor_unittest.cc
@@ -84,7 +84,7 @@ class MockMinidumpThread : public MinidumpThread {
  public:
   MockMinidumpThread() : MinidumpThread(NULL) {}
 
-  MOCK_CONST_METHOD1(GetThreadID, bool(u_int32_t*));
+  MOCK_CONST_METHOD1(GetThreadID, bool(uint32_t*));
   MOCK_METHOD0(GetContext, MinidumpContext*());
   MOCK_METHOD0(GetMemory, MinidumpMemoryRegion*());
 };
@@ -93,24 +93,24 @@ class MockMinidumpThread : public MinidumpThread {
 // MinidumpMemoryRegion.
 class MockMinidumpMemoryRegion : public MinidumpMemoryRegion {
  public:
-  MockMinidumpMemoryRegion(u_int64_t base, const string& contents) :
+  MockMinidumpMemoryRegion(uint64_t base, const string& contents) :
       MinidumpMemoryRegion(NULL) {
     region_.Init(base, contents);
   }
 
-  u_int64_t GetBase() const { return region_.GetBase(); }
-  u_int32_t GetSize() const { return region_.GetSize(); }
+  uint64_t GetBase() const { return region_.GetBase(); }
+  uint32_t GetSize() const { return region_.GetSize(); }
 
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t  *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint8_t  *value) const {
     return region_.GetMemoryAtAddress(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
     return region_.GetMemoryAtAddress(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
     return region_.GetMemoryAtAddress(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
     return region_.GetMemoryAtAddress(address, value);
   }
 
@@ -475,7 +475,7 @@ TEST_F(MinidumpProcessorTest, TestThreadMissingMemory) {
   memset(&no_memory_thread_raw_context, 0,
          sizeof(no_memory_thread_raw_context));
   no_memory_thread_raw_context.context_flags = MD_CONTEXT_X86_FULL;
-  const u_int32_t kExpectedEIP = 0xabcd1234;
+  const uint32_t kExpectedEIP = 0xabcd1234;
   no_memory_thread_raw_context.eip = kExpectedEIP;
   TestMinidumpContext no_memory_thread_context(no_memory_thread_raw_context);
   EXPECT_CALL(no_memory_thread, GetContext()).
diff --git a/src/processor/minidump_stackwalk.cc b/src/processor/minidump_stackwalk.cc
index 3f7df0cf..7b930e46 100644
--- a/src/processor/minidump_stackwalk.cc
+++ b/src/processor/minidump_stackwalk.cc
@@ -84,7 +84,7 @@ static const char kOutputSeparator = '|';
 // of registers is completely printed, regardless of the number of calls
 // to PrintRegister.
 static const int kMaxWidth = 80;  // optimize for an 80-column terminal
-static int PrintRegister(const char *name, u_int32_t value, int start_col) {
+static int PrintRegister(const char *name, uint32_t value, int start_col) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer), " %5s = 0x%08x", name, value);
 
@@ -98,7 +98,7 @@ static int PrintRegister(const char *name, u_int32_t value, int start_col) {
 }
 
 // PrintRegister64 does the same thing, but for 64-bit registers.
-static int PrintRegister64(const char *name, u_int64_t value, int start_col) {
+static int PrintRegister64(const char *name, uint64_t value, int start_col) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer), " %5s = 0x%016" PRIx64 , name, value);
 
@@ -144,7 +144,7 @@ static void PrintStack(const CallStack *stack, const string &cpu) {
     const StackFrame *frame = stack->frames()->at(frame_index);
     printf("%2d  ", frame_index);
 
-    u_int64_t instruction_address = frame->ReturnAddress();
+    uint64_t instruction_address = frame->ReturnAddress();
 
     if (frame->module) {
       printf("%s", PathnameStripper::File(frame->module->code_file()).c_str());
@@ -288,7 +288,7 @@ static void PrintStackMachineReadable(int thread_num, const CallStack *stack) {
     printf("%d%c%d%c", thread_num, kOutputSeparator, frame_index,
            kOutputSeparator);
 
-    u_int64_t instruction_address = frame->ReturnAddress();
+    uint64_t instruction_address = frame->ReturnAddress();
 
     if (frame->module) {
       assert(!frame->module->code_file().empty());
@@ -340,7 +340,7 @@ static void PrintModules(const CodeModules *modules) {
   printf("\n");
   printf("Loaded modules:\n");
 
-  u_int64_t main_address = 0;
+  uint64_t main_address = 0;
   const CodeModule *main_module = modules->GetMainModule();
   if (main_module) {
     main_address = main_module->base_address();
@@ -351,7 +351,7 @@ static void PrintModules(const CodeModules *modules) {
        module_sequence < module_count;
        ++module_sequence) {
     const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
-    u_int64_t base_address = module->base_address();
+    uint64_t base_address = module->base_address();
     printf("0x%08" PRIx64 " - 0x%08" PRIx64 "  %s  %s%s\n",
            base_address, base_address + module->size() - 1,
            PathnameStripper::File(module->code_file()).c_str(),
@@ -370,7 +370,7 @@ static void PrintModulesMachineReadable(const CodeModules *modules) {
   if (!modules)
     return;
 
-  u_int64_t main_address = 0;
+  uint64_t main_address = 0;
   const CodeModule *main_module = modules->GetMainModule();
   if (main_module) {
     main_address = main_module->base_address();
@@ -381,7 +381,7 @@ static void PrintModulesMachineReadable(const CodeModules *modules) {
        module_sequence < module_count;
        ++module_sequence) {
     const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
-    u_int64_t base_address = module->base_address();
+    uint64_t base_address = module->base_address();
     printf("Module%c%s%c%s%c%s%c%s%c0x%08" PRIx64 "%c0x%08" PRIx64 "%c%d\n",
            kOutputSeparator,
            StripSeparator(PathnameStripper::File(module->code_file())).c_str(),
diff --git a/src/processor/minidump_unittest.cc b/src/processor/minidump_unittest.cc
index f94c3eb3..d16bbc62 100644
--- a/src/processor/minidump_unittest.cc
+++ b/src/processor/minidump_unittest.cc
@@ -89,7 +89,7 @@ TEST_F(MinidumpTest, TestMinidumpFromFile) {
   ASSERT_TRUE(minidump.Read());
   const MDRawHeader* header = minidump.header();
   ASSERT_NE(header, (MDRawHeader*)NULL);
-  ASSERT_EQ(header->signature, u_int32_t(MD_HEADER_SIGNATURE));
+  ASSERT_EQ(header->signature, uint32_t(MD_HEADER_SIGNATURE));
   //TODO: add more checks here
 }
 
@@ -115,7 +115,7 @@ TEST_F(MinidumpTest, TestMinidumpFromStream) {
   ASSERT_TRUE(minidump.Read());
   const MDRawHeader* header = minidump.header();
   ASSERT_NE(header, (MDRawHeader*)NULL);
-  ASSERT_EQ(header->signature, u_int32_t(MD_HEADER_SIGNATURE));
+  ASSERT_EQ(header->signature, uint32_t(MD_HEADER_SIGNATURE));
   //TODO: add more checks here
 }
 
@@ -159,7 +159,7 @@ TEST(Dump, OneStream) {
   ASSERT_TRUE(dir != NULL);
   EXPECT_EQ(0xfbb7fa2bU, dir->stream_type);
 
-  u_int32_t stream_length;
+  uint32_t stream_length;
   ASSERT_TRUE(minidump.SeekToStreamType(0xfbb7fa2bU, &stream_length));
   ASSERT_EQ(15U, stream_length);
   char stream_contents[15];
@@ -193,7 +193,7 @@ TEST(Dump, OneMemory) {
 
   const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
   ASSERT_TRUE(dir != NULL);
-  EXPECT_EQ((u_int32_t) MD_MEMORY_LIST_STREAM, dir->stream_type);
+  EXPECT_EQ((uint32_t) MD_MEMORY_LIST_STREAM, dir->stream_type);
 
   MinidumpMemoryList *memory_list = minidump.GetMemoryList();
   ASSERT_TRUE(memory_list != NULL);
@@ -202,7 +202,7 @@ TEST(Dump, OneMemory) {
   MinidumpMemoryRegion *region1 = memory_list->GetMemoryRegionAtIndex(0);
   ASSERT_EQ(0x309d68010bd21b2cULL, region1->GetBase());
   ASSERT_EQ(15U, region1->GetSize());
-  const u_int8_t *region1_bytes = region1->GetMemory();
+  const uint8_t *region1_bytes = region1->GetMemory();
   ASSERT_TRUE(memcmp("memory contents", region1_bytes, 15) == 0);
 }
 
@@ -213,7 +213,7 @@ TEST(Dump, OneThread) {
   stack.Append("stack for thread");
 
   MDRawContextX86 raw_context;
-  const u_int32_t kExpectedEIP = 0x6913f540;
+  const uint32_t kExpectedEIP = 0x6913f540;
   raw_context.context_flags = MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL;
   raw_context.edi = 0x3ecba80d;
   raw_context.esi = 0x382583b9;
@@ -252,7 +252,7 @@ TEST(Dump, OneThread) {
   MinidumpMemoryRegion *md_region = md_memory_list->GetMemoryRegionAtIndex(0);
   ASSERT_EQ(0x2326a0faU, md_region->GetBase());
   ASSERT_EQ(16U, md_region->GetSize());
-  const u_int8_t *region_bytes = md_region->GetMemory();
+  const uint8_t *region_bytes = md_region->GetMemory();
   ASSERT_TRUE(memcmp("stack for thread", region_bytes, 16) == 0);
 
   MinidumpThreadList *thread_list = minidump.GetThreadList();
@@ -261,27 +261,27 @@ TEST(Dump, OneThread) {
 
   MinidumpThread *md_thread = thread_list->GetThreadAtIndex(0);
   ASSERT_TRUE(md_thread != NULL);
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_thread->GetThreadID(&thread_id));
   ASSERT_EQ(0xa898f11bU, thread_id);
   MinidumpMemoryRegion *md_stack = md_thread->GetMemory();
   ASSERT_TRUE(md_stack != NULL);
   ASSERT_EQ(0x2326a0faU, md_stack->GetBase());
   ASSERT_EQ(16U, md_stack->GetSize());
-  const u_int8_t *md_stack_bytes = md_stack->GetMemory();
+  const uint8_t *md_stack_bytes = md_stack->GetMemory();
   ASSERT_TRUE(memcmp("stack for thread", md_stack_bytes, 16) == 0);
 
   MinidumpContext *md_context = md_thread->GetContext();
   ASSERT_TRUE(md_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
 
-  u_int64_t eip;
+  uint64_t eip;
   ASSERT_TRUE(md_context->GetInstructionPointer(&eip));
   EXPECT_EQ(kExpectedEIP, eip);
 
   const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
   ASSERT_TRUE(md_raw_context != NULL);
-  ASSERT_EQ((u_int32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
+  ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
             (md_raw_context->context_flags
              & (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL)));
   EXPECT_EQ(0x3ecba80dU, raw_context.edi);
@@ -332,7 +332,7 @@ TEST(Dump, ThreadMissingMemory) {
   MinidumpThread* md_thread = thread_list->GetThreadAtIndex(0);
   ASSERT_TRUE(md_thread != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_thread->GetThreadID(&thread_id));
   ASSERT_EQ(0xa898f11bU, thread_id);
 
@@ -375,7 +375,7 @@ TEST(Dump, ThreadMissingContext) {
   MinidumpThread* md_thread = thread_list->GetThreadAtIndex(0);
   ASSERT_TRUE(md_thread != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_thread->GetThreadID(&thread_id));
   ASSERT_EQ(0xa898f11bU, thread_id);
   MinidumpMemoryRegion* md_stack = md_thread->GetMemory();
@@ -424,7 +424,7 @@ TEST(Dump, OneModule) {
 
   const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
   ASSERT_TRUE(dir != NULL);
-  EXPECT_EQ((u_int32_t) MD_MODULE_LIST_STREAM, dir->stream_type);
+  EXPECT_EQ((uint32_t) MD_MODULE_LIST_STREAM, dir->stream_type);
 
   MinidumpModuleList *md_module_list = minidump.GetModuleList();
   ASSERT_TRUE(md_module_list != NULL);
@@ -462,7 +462,7 @@ TEST(Dump, OneSystemInfo) {
 
   const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
   ASSERT_TRUE(dir != NULL);
-  EXPECT_EQ((u_int32_t) MD_SYSTEM_INFO_STREAM, dir->stream_type);
+  EXPECT_EQ((uint32_t) MD_SYSTEM_INFO_STREAM, dir->stream_type);
 
   MinidumpSystemInfo *md_system_info = minidump.GetSystemInfo();
   ASSERT_TRUE(md_system_info != NULL);
@@ -576,7 +576,7 @@ TEST(Dump, BigDump) {
   MinidumpThreadList *thread_list = minidump.GetThreadList();
   ASSERT_TRUE(thread_list != NULL);
   ASSERT_EQ(5U, thread_list->thread_count());
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(thread_list->GetThreadAtIndex(0)->GetThreadID(&thread_id));
   ASSERT_EQ(0xbbef4432U, thread_id);
   ASSERT_EQ(0x70b9ebfcU,
@@ -634,15 +634,15 @@ TEST(Dump, OneMemoryInfo) {
   Stream stream(dump, MD_MEMORY_INFO_LIST_STREAM);
 
   // Add the MDRawMemoryInfoList header.
-  const u_int64_t kNumberOfEntries = 1;
+  const uint64_t kNumberOfEntries = 1;
   stream.D32(sizeof(MDRawMemoryInfoList))  // size_of_header
         .D32(sizeof(MDRawMemoryInfo))      // size_of_entry
         .D64(kNumberOfEntries);            // number_of_entries
 
   
   // Now add a MDRawMemoryInfo entry.
-  const u_int64_t kBaseAddress = 0x1000;
-  const u_int64_t kRegionSize = 0x2000;
+  const uint64_t kBaseAddress = 0x1000;
+  const uint64_t kRegionSize = 0x2000;
   stream.D64(kBaseAddress)                         // base_address
         .D64(kBaseAddress)                         // allocation_base
         .D32(MD_MEMORY_PROTECT_EXECUTE_READWRITE)  // allocation_protection
@@ -665,7 +665,7 @@ TEST(Dump, OneMemoryInfo) {
 
   const MDRawDirectory *dir = minidump.GetDirectoryEntryAtIndex(0);
   ASSERT_TRUE(dir != NULL);
-  EXPECT_EQ((u_int32_t) MD_MEMORY_INFO_LIST_STREAM, dir->stream_type);
+  EXPECT_EQ((uint32_t) MD_MEMORY_INFO_LIST_STREAM, dir->stream_type);
 
   MinidumpMemoryInfoList *info_list = minidump.GetMemoryInfoList();
   ASSERT_TRUE(info_list != NULL);
@@ -724,7 +724,7 @@ TEST(Dump, OneExceptionX86) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -737,10 +737,10 @@ TEST(Dump, OneExceptionX86) {
 
   MinidumpContext *md_context = md_exception->GetContext();
   ASSERT_TRUE(md_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
   const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
   ASSERT_TRUE(md_raw_context != NULL);
-  ASSERT_EQ((u_int32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
+  ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
             (md_raw_context->context_flags
              & (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL)));
   EXPECT_EQ(0x3ecba80dU, raw_context.edi);
@@ -798,7 +798,7 @@ TEST(Dump, OneExceptionX86XState) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -811,10 +811,10 @@ TEST(Dump, OneExceptionX86XState) {
 
   MinidumpContext *md_context = md_exception->GetContext();
   ASSERT_TRUE(md_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
   const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
   ASSERT_TRUE(md_raw_context != NULL);
-  ASSERT_EQ((u_int32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
+  ASSERT_EQ((uint32_t) (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL),
             (md_raw_context->context_flags
              & (MD_CONTEXT_X86_INTEGER | MD_CONTEXT_X86_CONTROL)));
   EXPECT_EQ(0x3ecba80dU, raw_context.edi);
@@ -883,7 +883,7 @@ TEST(Dump, OneExceptionX86NoCPUFlags) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -897,14 +897,14 @@ TEST(Dump, OneExceptionX86NoCPUFlags) {
   MinidumpContext *md_context = md_exception->GetContext();
   ASSERT_TRUE(md_context != NULL);
 
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_X86, md_context->GetContextCPU());
   const MDRawContextX86 *md_raw_context = md_context->GetContextX86();
   ASSERT_TRUE(md_raw_context != NULL);
 
   // Even though the CPU flags were missing from the context_flags, the
   // GetContext call above is expected to load the missing CPU flags from the
   // system info stream and set the CPU type bits in context_flags.
-  ASSERT_EQ((u_int32_t) (MD_CONTEXT_X86), md_raw_context->context_flags);
+  ASSERT_EQ((uint32_t) (MD_CONTEXT_X86), md_raw_context->context_flags);
 
   EXPECT_EQ(0x3ecba80dU, raw_context.edi);
   EXPECT_EQ(0x382583b9U, raw_context.esi);
@@ -965,7 +965,7 @@ TEST(Dump, OneExceptionX86NoCPUFlagsNoSystemInfo) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -1028,7 +1028,7 @@ TEST(Dump, OneExceptionARM) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -1041,10 +1041,10 @@ TEST(Dump, OneExceptionARM) {
 
   MinidumpContext *md_context = md_exception->GetContext();
   ASSERT_TRUE(md_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
   const MDRawContextARM *md_raw_context = md_context->GetContextARM();
   ASSERT_TRUE(md_raw_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_ARM_INTEGER,
+  ASSERT_EQ((uint32_t) MD_CONTEXT_ARM_INTEGER,
             (md_raw_context->context_flags
              & MD_CONTEXT_ARM_INTEGER));
   EXPECT_EQ(0x3ecba80dU, raw_context.iregs[0]);
@@ -1112,7 +1112,7 @@ TEST(Dump, OneExceptionARMOldFlags) {
   MinidumpException *md_exception = minidump.GetException();
   ASSERT_TRUE(md_exception != NULL);
 
-  u_int32_t thread_id;
+  uint32_t thread_id;
   ASSERT_TRUE(md_exception->GetThreadID(&thread_id));
   ASSERT_EQ(0x1234abcdU, thread_id);
 
@@ -1125,10 +1125,10 @@ TEST(Dump, OneExceptionARMOldFlags) {
 
   MinidumpContext *md_context = md_exception->GetContext();
   ASSERT_TRUE(md_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
+  ASSERT_EQ((uint32_t) MD_CONTEXT_ARM, md_context->GetContextCPU());
   const MDRawContextARM *md_raw_context = md_context->GetContextARM();
   ASSERT_TRUE(md_raw_context != NULL);
-  ASSERT_EQ((u_int32_t) MD_CONTEXT_ARM_INTEGER,
+  ASSERT_EQ((uint32_t) MD_CONTEXT_ARM_INTEGER,
             (md_raw_context->context_flags
              & MD_CONTEXT_ARM_INTEGER));
   EXPECT_EQ(0x3ecba80dU, raw_context.iregs[0]);
diff --git a/src/processor/module_serializer.cc b/src/processor/module_serializer.cc
index 5c5ff77c..cf64a7ef 100644
--- a/src/processor/module_serializer.cc
+++ b/src/processor/module_serializer.cc
@@ -65,7 +65,7 @@ size_t ModuleSerializer::SizeOf(const BasicSourceLineResolver::Module &module) {
      module.cfi_delta_rules_);
 
   // Header size.
-  total_size_alloc_ = kNumberMaps_ * sizeof(u_int32_t);
+  total_size_alloc_ = kNumberMaps_ * sizeof(uint32_t);
 
   for (int i = 0; i < kNumberMaps_; ++i)
    total_size_alloc_ += map_sizes_[i];
@@ -79,8 +79,8 @@ size_t ModuleSerializer::SizeOf(const BasicSourceLineResolver::Module &module) {
 char *ModuleSerializer::Write(const BasicSourceLineResolver::Module &module,
                               char *dest) {
   // Write header.
-  memcpy(dest, map_sizes_, kNumberMaps_ * sizeof(u_int32_t));
-  dest += kNumberMaps_ * sizeof(u_int32_t);
+  memcpy(dest, map_sizes_, kNumberMaps_ * sizeof(uint32_t));
+  dest += kNumberMaps_ * sizeof(uint32_t);
   // Write each map.
   dest = files_serializer_.Write(module.files_, dest);
   dest = functions_serializer_.Write(module.functions_, dest);
diff --git a/src/processor/module_serializer.h b/src/processor/module_serializer.h
index 91e913b4..effb0091 100644
--- a/src/processor/module_serializer.h
+++ b/src/processor/module_serializer.h
@@ -110,7 +110,7 @@ class ModuleSerializer {
       FastSourceLineResolver::Module::kNumberMaps_;
 
   // Memory sizes required to serialize map components in Module.
-  u_int32_t map_sizes_[kNumberMaps_];
+  uint32_t map_sizes_[kNumberMaps_];
 
   // Serializers for each individual map component in Module class.
   StdMapSerializer<int, string> files_serializer_;
diff --git a/src/processor/postfix_evaluator_unittest.cc b/src/processor/postfix_evaluator_unittest.cc
index 00c8fd83..516be518 100644
--- a/src/processor/postfix_evaluator_unittest.cc
+++ b/src/processor/postfix_evaluator_unittest.cc
@@ -57,21 +57,21 @@ using google_breakpad::PostfixEvaluator;
 // the value.
 class FakeMemoryRegion : public MemoryRegion {
  public:
-  virtual u_int64_t GetBase() const { return 0; }
-  virtual u_int32_t GetSize() const { return 0; }
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int8_t  *value) const {
+  virtual uint64_t GetBase() const { return 0; }
+  virtual uint32_t GetSize() const { return 0; }
+  virtual bool GetMemoryAtAddress(uint64_t address, uint8_t  *value) const {
     *value = address + 1;
     return true;
   }
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
+  virtual bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
     *value = address + 1;
     return true;
   }
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
+  virtual bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
     *value = address + 1;
     return true;
   }
-  virtual bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
+  virtual bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
     *value = address + 1;
     return true;
   }
diff --git a/src/processor/simple_serializer-inl.h b/src/processor/simple_serializer-inl.h
index 1faf5ef5..6e5fe5d1 100644
--- a/src/processor/simple_serializer-inl.h
+++ b/src/processor/simple_serializer-inl.h
@@ -134,12 +134,12 @@ class SimpleSerializer<WindowsFrameInfo> {
     unsigned int size = 0;
     size += sizeof(int32_t);  // wfi.type_
     size += SimpleSerializer<int32_t>::SizeOf(wfi.valid);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.prolog_size);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.epilog_size);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.parameter_size);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.saved_register_size);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.local_size);
-    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.max_stack_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.prolog_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.epilog_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.parameter_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.saved_register_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.local_size);
+    size += SimpleSerializer<uint32_t>::SizeOf(wfi.max_stack_size);
     size += SimpleSerializer<bool>::SizeOf(wfi.allocates_base_pointer);
     size += SimpleSerializer<string>::SizeOf(wfi.program_string);
     return size;
@@ -148,12 +148,12 @@ class SimpleSerializer<WindowsFrameInfo> {
     dest = SimpleSerializer<int32_t>::Write(
         static_cast<const int32_t>(wfi.type_), dest);
     dest = SimpleSerializer<int32_t>::Write(wfi.valid, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.prolog_size, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.epilog_size, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.parameter_size, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.saved_register_size, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.local_size, dest);
-    dest = SimpleSerializer<u_int32_t>::Write(wfi.max_stack_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.prolog_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.epilog_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.parameter_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.saved_register_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.local_size, dest);
+    dest = SimpleSerializer<uint32_t>::Write(wfi.max_stack_size, dest);
     dest = SimpleSerializer<bool>::Write(wfi.allocates_base_pointer, dest);
     return SimpleSerializer<string>::Write(wfi.program_string, dest);
   }
diff --git a/src/processor/simple_serializer.h b/src/processor/simple_serializer.h
index a1ca4f30..275f51ce 100644
--- a/src/processor/simple_serializer.h
+++ b/src/processor/simple_serializer.h
@@ -38,11 +38,11 @@
 #ifndef PROCESSOR_SIMPLE_SERIALIZER_H__
 #define PROCESSOR_SIMPLE_SERIALIZER_H__
 
-#include <sys/types.h>
+#include "google_breakpad/common/breakpad_types.h"
 
 namespace google_breakpad {
 
-typedef u_int64_t MemAddr;
+typedef uint64_t MemAddr;
 
 // Default implementation of SimpleSerializer template.
 // Specializations are defined in "simple_serializer-inl.h".
diff --git a/src/processor/stackwalker.cc b/src/processor/stackwalker.cc
index 58289425..c1b290e6 100644
--- a/src/processor/stackwalker.cc
+++ b/src/processor/stackwalker.cc
@@ -56,7 +56,7 @@
 namespace google_breakpad {
 
 const int Stackwalker::kRASearchWords = 30;
-u_int32_t Stackwalker::max_frames_ = 1024;
+uint32_t Stackwalker::max_frames_ = 1024;
 
 Stackwalker::Stackwalker(const SystemInfo* system_info,
                          MemoryRegion* memory,
@@ -125,7 +125,7 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
 
   Stackwalker* cpu_stackwalker = NULL;
 
-  u_int32_t cpu = context->GetContextCPU();
+  uint32_t cpu = context->GetContextCPU();
   switch (cpu) {
     case MD_CONTEXT_X86:
       cpu_stackwalker = new StackwalkerX86(system_info,
@@ -168,7 +168,7 @@ Stackwalker* Stackwalker::StackwalkerForCPU(
   return cpu_stackwalker;
 }
 
-bool Stackwalker::InstructionAddressSeemsValid(u_int64_t address) {
+bool Stackwalker::InstructionAddressSeemsValid(uint64_t address) {
   StackFrame frame;
   frame.instruction = address;
   StackFrameSymbolizer::SymbolizerResult symbolizer_result =
diff --git a/src/processor/stackwalker_amd64.cc b/src/processor/stackwalker_amd64.cc
index 3aa7c736..656af183 100644
--- a/src/processor/stackwalker_amd64.cc
+++ b/src/processor/stackwalker_amd64.cc
@@ -101,7 +101,7 @@ StackwalkerAMD64::StackwalkerAMD64(const SystemInfo* system_info,
                   (sizeof(cfi_register_map_) / sizeof(cfi_register_map_[0]))) {
 }
 
-u_int64_t StackFrameAMD64::ReturnAddress() const
+uint64_t StackFrameAMD64::ReturnAddress() const
 {
   assert(context_validity & StackFrameAMD64::CONTEXT_VALID_RIP);
   return context.rip;   
@@ -150,8 +150,8 @@ StackFrameAMD64* StackwalkerAMD64::GetCallerByCFIFrameInfo(
 StackFrameAMD64* StackwalkerAMD64::GetCallerByStackScan(
     const vector<StackFrame*> &frames) {
   StackFrameAMD64* last_frame = static_cast<StackFrameAMD64*>(frames.back());
-  u_int64_t last_rsp = last_frame->context.rsp;
-  u_int64_t caller_rip_address, caller_rip;
+  uint64_t last_rsp = last_frame->context.rsp;
+  uint64_t caller_rip_address, caller_rip;
 
   if (!ScanForReturnAddress(last_rsp, &caller_rip_address, &caller_rip)) {
     // No plausible return address was found.
@@ -179,7 +179,7 @@ StackFrameAMD64* StackwalkerAMD64::GetCallerByStackScan(
     // pointing to the first word below the alleged return address, presume
     // that the caller's %rbp is saved there.
     if (caller_rip_address - 8 == last_frame->context.rbp) {
-      u_int64_t caller_rbp = 0;
+      uint64_t caller_rbp = 0;
       if (memory_->GetMemoryAtAddress(last_frame->context.rbp, &caller_rbp) &&
           caller_rbp > caller_rip_address) {
         frame->context.rbp = caller_rbp;
diff --git a/src/processor/stackwalker_amd64.h b/src/processor/stackwalker_amd64.h
index 3e41c123..3f1eaf77 100644
--- a/src/processor/stackwalker_amd64.h
+++ b/src/processor/stackwalker_amd64.h
@@ -64,7 +64,7 @@ class StackwalkerAMD64 : public Stackwalker {
 
  private:
   // A STACK CFI-driven frame walker for the AMD64
-  typedef SimpleCFIWalker<u_int64_t, MDRawContextAMD64> CFIWalker;
+  typedef SimpleCFIWalker<uint64_t, MDRawContextAMD64> CFIWalker;
 
   // Implementation of Stackwalker, using amd64 context (stack pointer in %rsp,
   // stack base in %rbp) and stack conventions (saved stack pointer at 0(%rbp))
diff --git a/src/processor/stackwalker_amd64_unittest.cc b/src/processor/stackwalker_amd64_unittest.cc
index 2d679abb..a726e8ac 100644
--- a/src/processor/stackwalker_amd64_unittest.cc
+++ b/src/processor/stackwalker_amd64_unittest.cc
@@ -109,9 +109,9 @@ class StackwalkerAMD64Fixture {
 
   // Fill RAW_CONTEXT with pseudo-random data, for round-trip checking.
   void BrandContext(MDRawContextAMD64 *raw_context) {
-    u_int8_t x = 173;
+    uint8_t x = 173;
     for (size_t i = 0; i < sizeof(*raw_context); i++)
-      reinterpret_cast<u_int8_t *>(raw_context)[i] = (x += 17);
+      reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
   }
 
   SystemInfo system_info;
@@ -199,8 +199,8 @@ TEST_F(GetCallerFrame, ScanWithoutSymbols) {
   // Force scanning through three frames to ensure that the
   // stack pointer is set properly in scan-recovered frames.
   stack_section.start() = 0x8000000080000000ULL;
-  u_int64_t return_address1 = 0x50000000b0000100ULL;
-  u_int64_t return_address2 = 0x50000000b0000900ULL;
+  uint64_t return_address1 = 0x50000000b0000100ULL;
+  uint64_t return_address2 = 0x50000000b0000900ULL;
   Label frame1_sp, frame2_sp, frame1_rbp;
   stack_section
     // frame 0
@@ -270,7 +270,7 @@ TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
   // it is only considered a valid return address if it
   // lies within a function's bounds.
   stack_section.start() = 0x8000000080000000ULL;
-  u_int64_t return_address = 0x50000000b0000110ULL;
+  uint64_t return_address = 0x50000000b0000110ULL;
   Label frame1_sp, frame1_rbp;
 
   stack_section
@@ -333,7 +333,7 @@ TEST_F(GetCallerFrame, CallerPushedRBP) {
   // %rbp directly below the return address, assume that it is indeed the
   // next frame's %rbp.
   stack_section.start() = 0x8000000080000000ULL;
-  u_int64_t return_address = 0x50000000b0000110ULL;
+  uint64_t return_address = 0x50000000b0000110ULL;
   Label frame0_rbp, frame1_sp, frame1_rbp;
 
   stack_section
diff --git a/src/processor/stackwalker_arm.cc b/src/processor/stackwalker_arm.cc
index 05df3d19..a736061b 100644
--- a/src/processor/stackwalker_arm.cc
+++ b/src/processor/stackwalker_arm.cc
@@ -90,13 +90,13 @@ StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
   };
 
   // Populate a dictionary with the valid register values in last_frame.
-  CFIFrameInfo::RegisterValueMap<u_int32_t> callee_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> callee_registers;
   for (int i = 0; register_names[i]; i++)
     if (last_frame->context_validity & StackFrameARM::RegisterValidFlag(i))
       callee_registers[register_names[i]] = last_frame->context.iregs[i];
 
   // Use the STACK CFI data to recover the caller's register values.
-  CFIFrameInfo::RegisterValueMap<u_int32_t> caller_registers;
+  CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
   if (!cfi_frame_info->FindCallerRegs(callee_registers, *memory_,
                                       &caller_registers))
     return NULL;
@@ -104,7 +104,7 @@ StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
   // Construct a new stack frame given the values the CFI recovered.
   scoped_ptr<StackFrameARM> frame(new StackFrameARM());
   for (int i = 0; register_names[i]; i++) {
-    CFIFrameInfo::RegisterValueMap<u_int32_t>::iterator entry =
+    CFIFrameInfo::RegisterValueMap<uint32_t>::iterator entry =
       caller_registers.find(register_names[i]);
     if (entry != caller_registers.end()) {
       // We recovered the value of this register; fill the context with the
@@ -123,7 +123,7 @@ StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
   }
   // If the CFI doesn't recover the PC explicitly, then use .ra.
   if (!(frame->context_validity & StackFrameARM::CONTEXT_VALID_PC)) {
-    CFIFrameInfo::RegisterValueMap<u_int32_t>::iterator entry =
+    CFIFrameInfo::RegisterValueMap<uint32_t>::iterator entry =
       caller_registers.find(".ra");
     if (entry != caller_registers.end()) {
       if (fp_register_ == -1) {
@@ -142,7 +142,7 @@ StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
   }
   // If the CFI doesn't recover the SP explicitly, then use .cfa.
   if (!(frame->context_validity & StackFrameARM::CONTEXT_VALID_SP)) {
-    CFIFrameInfo::RegisterValueMap<u_int32_t>::iterator entry =
+    CFIFrameInfo::RegisterValueMap<uint32_t>::iterator entry =
       caller_registers.find(".cfa");
     if (entry != caller_registers.end()) {
       frame->context_validity |= StackFrameARM::CONTEXT_VALID_SP;
@@ -163,8 +163,8 @@ StackFrameARM* StackwalkerARM::GetCallerByCFIFrameInfo(
 StackFrameARM* StackwalkerARM::GetCallerByStackScan(
     const vector<StackFrame*> &frames) {
   StackFrameARM* last_frame = static_cast<StackFrameARM*>(frames.back());
-  u_int32_t last_sp = last_frame->context.iregs[MD_CONTEXT_ARM_REG_SP];
-  u_int32_t caller_sp, caller_pc;
+  uint32_t last_sp = last_frame->context.iregs[MD_CONTEXT_ARM_REG_SP];
+  uint32_t caller_sp, caller_pc;
 
   // When searching for the caller of the context frame,
   // allow the scanner to look farther down the stack.
@@ -206,23 +206,23 @@ StackFrameARM* StackwalkerARM::GetCallerByFramePointer(
     return NULL;
   }
 
-  u_int32_t last_fp = last_frame->context.iregs[fp_register_];
+  uint32_t last_fp = last_frame->context.iregs[fp_register_];
 
-  u_int32_t caller_fp = 0;
+  uint32_t caller_fp = 0;
   if (last_fp && !memory_->GetMemoryAtAddress(last_fp, &caller_fp)) {
     BPLOG(ERROR) << "Unable to read caller_fp from last_fp: 0x"
                  << std::hex << last_fp;
     return NULL;
   }
 
-  u_int32_t caller_lr = 0;
+  uint32_t caller_lr = 0;
   if (last_fp && !memory_->GetMemoryAtAddress(last_fp + 4, &caller_lr)) {
     BPLOG(ERROR) << "Unable to read caller_lr from last_fp + 4: 0x"
                  << std::hex << (last_fp + 4);
     return NULL;
   }
 
-  u_int32_t caller_sp = last_fp ? last_fp + 8 :
+  uint32_t caller_sp = last_fp ? last_fp + 8 :
       last_frame->context.iregs[MD_CONTEXT_ARM_REG_SP];
 
   // Create a new stack frame (ownership will be transferred to the caller)
diff --git a/src/processor/stackwalker_arm_unittest.cc b/src/processor/stackwalker_arm_unittest.cc
index a86729fd..f1d18bb7 100644
--- a/src/processor/stackwalker_arm_unittest.cc
+++ b/src/processor/stackwalker_arm_unittest.cc
@@ -111,9 +111,9 @@ class StackwalkerARMFixture {
 
   // Fill RAW_CONTEXT with pseudo-random data, for round-trip checking.
   void BrandContext(MDRawContextARM *raw_context) {
-    u_int8_t x = 173;
+    uint8_t x = 173;
     for (size_t i = 0; i < sizeof(*raw_context); i++)
-      reinterpret_cast<u_int8_t *>(raw_context)[i] = (x += 17);
+      reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
   }
 
   SystemInfo system_info;
@@ -190,8 +190,8 @@ TEST_F(GetCallerFrame, ScanWithoutSymbols) {
   // Force scanning through three frames to ensure that the
   // stack pointer is set properly in scan-recovered frames.
   stack_section.start() = 0x80000000;
-  u_int32_t return_address1 = 0x50000100;
-  u_int32_t return_address2 = 0x50000900;
+  uint32_t return_address1 = 0x50000100;
+  uint32_t return_address2 = 0x50000900;
   Label frame1_sp, frame2_sp;
   stack_section
     // frame 0
@@ -252,7 +252,7 @@ TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
   // it is only considered a valid return address if it
   // lies within a function's bounds.
   stack_section.start() = 0x80000000;
-  u_int32_t return_address = 0x50000200;
+  uint32_t return_address = 0x50000200;
   Label frame1_sp;
 
   stack_section
@@ -310,8 +310,8 @@ TEST_F(GetCallerFrame, ScanFirstFrame) {
   // If the stackwalker resorts to stack scanning, it will scan much
   // farther to find the caller of the context frame.
   stack_section.start() = 0x80000000;
-  u_int32_t return_address1 = 0x50000100;
-  u_int32_t return_address2 = 0x50000900;
+  uint32_t return_address1 = 0x50000100;
+  uint32_t return_address2 = 0x50000900;
   Label frame1_sp, frame2_sp;
   stack_section
     // frame 0
@@ -674,8 +674,8 @@ class GetFramesByFramePointer: public StackwalkerARMFixtureIOS, public Test { };
 
 TEST_F(GetFramesByFramePointer, OnlyFramePointer) {
   stack_section.start() = 0x80000000;
-  u_int32_t return_address1 = 0x50000100;
-  u_int32_t return_address2 = 0x50000900;
+  uint32_t return_address1 = 0x50000100;
+  uint32_t return_address2 = 0x50000900;
   Label frame1_sp, frame2_sp;
   Label frame1_fp, frame2_fp;
   stack_section
@@ -764,8 +764,8 @@ TEST_F(GetFramesByFramePointer, FramePointerAndCFI) {
                   );
 
   stack_section.start() = 0x80000000;
-  u_int32_t return_address1 = 0x40004010;
-  u_int32_t return_address2 = 0x50000900;
+  uint32_t return_address1 = 0x40004010;
+  uint32_t return_address2 = 0x50000900;
   Label frame1_sp, frame2_sp;
   Label frame1_fp, frame2_fp;
   stack_section
diff --git a/src/processor/stackwalker_ppc.cc b/src/processor/stackwalker_ppc.cc
index 40bec8de..29015dff 100644
--- a/src/processor/stackwalker_ppc.cc
+++ b/src/processor/stackwalker_ppc.cc
@@ -102,7 +102,7 @@ StackFrame* StackwalkerPPC::GetCallerFrame(const CallStack* stack) {
   // A caller frame must reside higher in memory than its callee frames.
   // Anything else is an error, or an indication that we've reached the
   // end of the stack.
-  u_int32_t stack_pointer;
+  uint32_t stack_pointer;
   if (!memory_->GetMemoryAtAddress(last_frame->context.gpr[1],
                                    &stack_pointer) ||
       stack_pointer <= last_frame->context.gpr[1]) {
@@ -114,7 +114,7 @@ StackFrame* StackwalkerPPC::GetCallerFrame(const CallStack* stack) {
   // documentation on this, but 0 or 1 would be bogus return addresses,
   // so check for them here and return false (end of stack) when they're
   // hit to avoid having a phantom frame.
-  u_int32_t instruction;
+  uint32_t instruction;
   if (!memory_->GetMemoryAtAddress(stack_pointer + 8, &instruction) ||
       instruction <= 1) {
     return NULL;
diff --git a/src/processor/stackwalker_selftest.cc b/src/processor/stackwalker_selftest.cc
index 8c343eb9..99644d7a 100644
--- a/src/processor/stackwalker_selftest.cc
+++ b/src/processor/stackwalker_selftest.cc
@@ -100,20 +100,20 @@ using google_breakpad::StackwalkerSPARC;
 // process' memory space by pointer.
 class SelfMemoryRegion : public MemoryRegion {
  public:
-  virtual u_int64_t GetBase() { return 0; }
-  virtual u_int32_t GetSize() { return 0xffffffff; }
+  virtual uint64_t GetBase() { return 0; }
+  virtual uint32_t GetSize() { return 0xffffffff; }
 
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t*  value) {
+  bool GetMemoryAtAddress(uint64_t address, uint8_t*  value) {
       return GetMemoryAtAddressInternal(address, value); }
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t* value) {
+  bool GetMemoryAtAddress(uint64_t address, uint16_t* value) {
       return GetMemoryAtAddressInternal(address, value); }
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t* value) {
+  bool GetMemoryAtAddress(uint64_t address, uint32_t* value) {
       return GetMemoryAtAddressInternal(address, value); }
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t* value) {
+  bool GetMemoryAtAddress(uint64_t address, uint64_t* value) {
       return GetMemoryAtAddressInternal(address, value); }
 
  private:
-  template<typename T> bool GetMemoryAtAddressInternal(u_int64_t address,
+  template<typename T> bool GetMemoryAtAddressInternal(uint64_t address,
                                                        T*        value) {
     // Without knowing what addresses are actually mapped, just assume that
     // everything low is not mapped.  This helps the stackwalker catch the
@@ -123,7 +123,7 @@ class SelfMemoryRegion : public MemoryRegion {
     if (address < 0x100)
       return false;
 
-    u_int8_t* memory = 0;
+    uint8_t* memory = 0;
     *value = *reinterpret_cast<const T*>(&memory[address]);
     return true;
   }
@@ -142,9 +142,9 @@ class SelfMemoryRegion : public MemoryRegion {
 // on the stack (provided frame pointers are not being omitted.)  Because
 // this function depends on the compiler-generated preamble, inlining is
 // disabled.
-static u_int32_t GetEBP() __attribute__((noinline));
-static u_int32_t GetEBP() {
-  u_int32_t ebp;
+static uint32_t GetEBP() __attribute__((noinline));
+static uint32_t GetEBP() {
+  uint32_t ebp;
   __asm__ __volatile__(
     "movl (%%ebp), %0"
     : "=a" (ebp)
@@ -158,9 +158,9 @@ static u_int32_t GetEBP() {
 // The CALL instruction places a 4-byte return address on the stack above
 // the caller's %esp, and this function's prolog will save the caller's %ebp
 // on the stack as well, for another 4 bytes, before storing %esp in %ebp.
-static u_int32_t GetESP() __attribute__((noinline));
-static u_int32_t GetESP() {
-  u_int32_t ebp;
+static uint32_t GetESP() __attribute__((noinline));
+static uint32_t GetESP() {
+  uint32_t ebp;
   __asm__ __volatile__(
     "movl %%ebp, %0"
     : "=a" (ebp)
@@ -179,9 +179,9 @@ static u_int32_t GetESP() {
 // because GetEBP and stackwalking necessarily depends on access to frame
 // pointers.  Because this function depends on a call instruction and the
 // compiler-generated preamble, inlining is disabled.
-static u_int32_t GetEIP() __attribute__((noinline));
-static u_int32_t GetEIP() {
-  u_int32_t eip;
+static uint32_t GetEIP() __attribute__((noinline));
+static uint32_t GetEIP() {
+  uint32_t eip;
   __asm__ __volatile__(
     "movl 4(%%ebp), %0"
     : "=a" (eip)
@@ -199,9 +199,9 @@ static u_int32_t GetEIP() {
 // pointer.  Dereference %r1 to obtain the caller's stack pointer, which the
 // compiler-generated prolog stored on the stack.  Because this function
 // depends on the compiler-generated prolog, inlining is disabled.
-static u_int32_t GetSP() __attribute__((noinline));
-static u_int32_t GetSP() {
-  u_int32_t sp;
+static uint32_t GetSP() __attribute__((noinline));
+static uint32_t GetSP() {
+  uint32_t sp;
   __asm__ __volatile__(
     "lwz %0, 0(r1)"
     : "=r" (sp)
@@ -215,9 +215,9 @@ static u_int32_t GetSP() {
 // link register, where it was placed by the branch instruction that called
 // GetPC.  Because this function depends on the caller's use of a branch
 // instruction, inlining is disabled.
-static u_int32_t GetPC() __attribute__((noinline));
-static u_int32_t GetPC() {
-  u_int32_t lr;
+static uint32_t GetPC() __attribute__((noinline));
+static uint32_t GetPC() {
+  uint32_t lr;
   __asm__ __volatile__(
     "mflr %0"
     : "=r" (lr)
@@ -236,9 +236,9 @@ static u_int32_t GetPC() {
 // pointer, which the compiler-generated prolog stored on the stack.
 // Because this function depends on the compiler-generated prolog, inlining
 // is disabled.
-static u_int32_t GetSP() __attribute__((noinline));
-static u_int32_t GetSP() {
-  u_int32_t sp;
+static uint32_t GetSP() __attribute__((noinline));
+static uint32_t GetSP() {
+  uint32_t sp;
   __asm__ __volatile__(
     "mov %%fp, %0"
     : "=r" (sp)
@@ -253,9 +253,9 @@ static u_int32_t GetSP() {
 // on the stack (provided frame pointers are not being omitted.)  Because
 // this function depends on the compiler-generated preamble, inlining is
 // disabled.
-static u_int32_t GetFP() __attribute__((noinline));
-static u_int32_t GetFP() {
-  u_int32_t fp;
+static uint32_t GetFP() __attribute__((noinline));
+static uint32_t GetFP() {
+  uint32_t fp;
   __asm__ __volatile__(
     "ld [%%fp+56], %0"
     : "=r" (fp)
@@ -268,9 +268,9 @@ static u_int32_t GetFP() {
 // link register, where it was placed by the branch instruction that called
 // GetPC.  Because this function depends on the caller's use of a branch
 // instruction, inlining is disabled.
-static u_int32_t GetPC() __attribute__((noinline));
-static u_int32_t GetPC() {
-  u_int32_t pc;
+static uint32_t GetPC() __attribute__((noinline));
+static uint32_t GetPC() {
+  uint32_t pc;
   __asm__ __volatile__(
     "mov %%i7, %0"
     : "=r" (pc)
@@ -284,15 +284,15 @@ static u_int32_t GetPC() {
 
 #if defined(__i386__)
 extern "C" {
-extern u_int32_t GetEIP();
-extern u_int32_t GetEBP();
-extern u_int32_t GetESP();
+extern uint32_t GetEIP();
+extern uint32_t GetEBP();
+extern uint32_t GetESP();
 }
 #elif defined(__sparc__)
 extern "C" {
-extern u_int32_t GetPC();
-extern u_int32_t GetFP();
-extern u_int32_t GetSP();
+extern uint32_t GetPC();
+extern uint32_t GetFP();
+extern uint32_t GetSP();
 }
 #endif // __i386__ || __sparc__
 
diff --git a/src/processor/stackwalker_sparc.cc b/src/processor/stackwalker_sparc.cc
index d1d5d236..7c3c5200 100644
--- a/src/processor/stackwalker_sparc.cc
+++ b/src/processor/stackwalker_sparc.cc
@@ -93,18 +93,18 @@ StackFrame* StackwalkerSPARC::GetCallerFrame(const CallStack* stack) {
   // A caller frame must reside higher in memory than its callee frames.
   // Anything else is an error, or an indication that we've reached the
   // end of the stack.
-  u_int64_t stack_pointer = last_frame->context.g_r[30];
+  uint64_t stack_pointer = last_frame->context.g_r[30];
   if (stack_pointer <= last_frame->context.g_r[14]) {
     return NULL;
   }
 
-  u_int32_t instruction;
+  uint32_t instruction;
   if (!memory_->GetMemoryAtAddress(stack_pointer + 60,
                      &instruction) || instruction <= 1) {
     return NULL;
   }
 
-  u_int32_t stack_base;
+  uint32_t stack_base;
   if (!memory_->GetMemoryAtAddress(stack_pointer + 56,
                      &stack_base) || stack_base <= 1) {
     return NULL;
diff --git a/src/processor/stackwalker_unittest_utils.h b/src/processor/stackwalker_unittest_utils.h
index 5257f816..07638661 100644
--- a/src/processor/stackwalker_unittest_utils.h
+++ b/src/processor/stackwalker_unittest_utils.h
@@ -55,24 +55,24 @@ class MockMemoryRegion: public google_breakpad::MemoryRegion {
   // Set this region's address and contents. If we have placed an
   // instance of this class in a test fixture class, individual tests
   // can use this to provide the region's contents.
-  void Init(u_int64_t base_address, const string &contents) {
+  void Init(uint64_t base_address, const string &contents) {
     base_address_ = base_address;
     contents_ = contents;
   }
 
-  u_int64_t GetBase() const { return base_address_; }
-  u_int32_t GetSize() const { return contents_.size(); }
+  uint64_t GetBase() const { return base_address_; }
+  uint32_t GetSize() const { return contents_.size(); }
 
-  bool GetMemoryAtAddress(u_int64_t address, u_int8_t  *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint8_t  *value) const {
     return GetMemoryLittleEndian(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int16_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
     return GetMemoryLittleEndian(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int32_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
     return GetMemoryLittleEndian(address, value);
   }
-  bool GetMemoryAtAddress(u_int64_t address, u_int64_t *value) const {
+  bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
     return GetMemoryLittleEndian(address, value);
   }
 
@@ -80,7 +80,7 @@ class MockMemoryRegion: public google_breakpad::MemoryRegion {
   // Fetch a little-endian value from ADDRESS in contents_ whose size
   // is BYTES, and store it in *VALUE. Return true on success.
   template<typename ValueType>
-  bool GetMemoryLittleEndian(u_int64_t address, ValueType *value) const {
+  bool GetMemoryLittleEndian(uint64_t address, ValueType *value) const {
     if (address < base_address_ ||
         address - base_address_ + sizeof(ValueType) > contents_.size())
       return false;
@@ -93,18 +93,18 @@ class MockMemoryRegion: public google_breakpad::MemoryRegion {
     return true;
   }
 
-  u_int64_t base_address_;
+  uint64_t base_address_;
   string contents_;
 };
 
 class MockCodeModule: public google_breakpad::CodeModule {
  public:
-  MockCodeModule(u_int64_t base_address, u_int64_t size,
+  MockCodeModule(uint64_t base_address, uint64_t size,
                  const string &code_file, const string &version)
       : base_address_(base_address), size_(size), code_file_(code_file) { }
 
-  u_int64_t base_address()       const { return base_address_; }
-  u_int64_t size()               const { return size_; }
+  uint64_t base_address()       const { return base_address_; }
+  uint64_t size()               const { return size_; }
   string code_file()        const { return code_file_; }
   string code_identifier()  const { return code_file_; }
   string debug_file()       const { return code_file_; }
@@ -115,8 +115,8 @@ class MockCodeModule: public google_breakpad::CodeModule {
   }
 
  private:
-  u_int64_t base_address_;
-  u_int64_t size_;
+  uint64_t base_address_;
+  uint64_t size_;
   string code_file_;
   string version_;
 };
@@ -132,7 +132,7 @@ class MockCodeModules: public google_breakpad::CodeModules {
 
   unsigned int module_count() const { return modules_.size(); }
 
-  const CodeModule *GetModuleForAddress(u_int64_t address) const {
+  const CodeModule *GetModuleForAddress(uint64_t address) const {
     for (ModuleVector::const_iterator i = modules_.begin();
          i != modules_.end(); i++) {
       const MockCodeModule *module = *i;
diff --git a/src/processor/stackwalker_x86.cc b/src/processor/stackwalker_x86.cc
index 19fc2a11..f4de1a40 100644
--- a/src/processor/stackwalker_x86.cc
+++ b/src/processor/stackwalker_x86.cc
@@ -106,7 +106,7 @@ StackFrameX86::~StackFrameX86() {
   cfi_frame_info = NULL;
 }
 
-u_int64_t StackFrameX86::ReturnAddress() const
+uint64_t StackFrameX86::ReturnAddress() const
 {
   assert(context_validity & StackFrameX86::CONTEXT_VALID_EIP);
   return context.eip;   
@@ -179,7 +179,7 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
   // are unknown, 0 is also used in that case.  When that happens, it should
   // be possible to walk to the next frame without reference to %esp.
 
-  u_int32_t last_frame_callee_parameter_size = 0;
+  uint32_t last_frame_callee_parameter_size = 0;
   int frames_already_walked = frames.size();
   if (frames_already_walked >= 2) {
     const StackFrameX86* last_frame_callee
@@ -197,7 +197,7 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
   // Set up the dictionary for the PostfixEvaluator.  %ebp and %esp are used
   // in each program string, and their previous values are known, so set them
   // here.
-  PostfixEvaluator<u_int32_t>::DictionaryType dictionary;
+  PostfixEvaluator<uint32_t>::DictionaryType dictionary;
   // Provide the current register values.
   dictionary["$ebp"] = last_frame->context.ebp;
   dictionary["$esp"] = last_frame->context.esp;
@@ -210,13 +210,13 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
   dictionary[".cbSavedRegs"] = last_frame_info->saved_register_size;
   dictionary[".cbLocals"] = last_frame_info->local_size;
 
-  u_int32_t raSearchStart = last_frame->context.esp +
+  uint32_t raSearchStart = last_frame->context.esp +
                             last_frame_callee_parameter_size +
                             last_frame_info->local_size +
                             last_frame_info->saved_register_size;
 
-  u_int32_t raSearchStartOld = raSearchStart;
-  u_int32_t found = 0;  // dummy value
+  uint32_t raSearchStartOld = raSearchStart;
+  uint32_t found = 0;  // dummy value
   // Scan up to three words above the calculated search value, in case
   // the stack was aligned to a quadword boundary.
   if (ScanForReturnAddress(raSearchStart, &raSearchStart, &found, 3) &&
@@ -326,9 +326,9 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
 
   // Now crank it out, making sure that the program string set at least the
   // two required variables.
-  PostfixEvaluator<u_int32_t> evaluator =
-      PostfixEvaluator<u_int32_t>(&dictionary, memory_);
-  PostfixEvaluator<u_int32_t>::DictionaryValidityType dictionary_validity;
+  PostfixEvaluator<uint32_t> evaluator =
+      PostfixEvaluator<uint32_t>(&dictionary, memory_);
+  PostfixEvaluator<uint32_t>::DictionaryValidityType dictionary_validity;
   if (!evaluator.Evaluate(program_string, &dictionary_validity) ||
       dictionary_validity.find("$eip") == dictionary_validity.end() ||
       dictionary_validity.find("$esp") == dictionary_validity.end()) {
@@ -338,8 +338,8 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
     // address. This can happen if the stack is in a module for which
     // we don't have symbols, and that module is compiled without a
     // frame pointer.
-    u_int32_t location_start = last_frame->context.esp;
-    u_int32_t location, eip;
+    uint32_t location_start = last_frame->context.esp;
+    uint32_t location, eip;
     if (!ScanForReturnAddress(location_start, &location, &eip)) {
       // if we can't find an instruction pointer even with stack scanning,
       // give up.
@@ -376,12 +376,12 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
     // ability, older OSes (pre-XP SP2) and CPUs (pre-P4) don't enforce
     // an independent execute privilege on memory pages.
 
-    u_int32_t eip = dictionary["$eip"];
+    uint32_t eip = dictionary["$eip"];
     if (modules_ && !modules_->GetModuleForAddress(eip)) {
       // The instruction pointer at .raSearchStart was invalid, so start
       // looking one 32-bit word above that location.
-      u_int32_t location_start = dictionary[".raSearchStart"] + 4;
-      u_int32_t location;
+      uint32_t location_start = dictionary[".raSearchStart"] + 4;
+      uint32_t location;
       if (ScanForReturnAddress(location_start, &location, &eip)) {
         // This is a better return address that what program string
         // evaluation found.  Use it, and set %esp to the location above the
@@ -401,7 +401,7 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
       // stack.  The scan is performed from the highest possible address to
       // the lowest, because the expectation is that the function's prolog
       // would have saved %ebp early.
-      u_int32_t ebp = dictionary["$ebp"];
+      uint32_t ebp = dictionary["$ebp"];
 
       // When a scan for return address is used, it is possible to skip one or
       // more frames (when return address is not in a known module).  One
@@ -410,13 +410,13 @@ StackFrameX86* StackwalkerX86::GetCallerByWindowsFrameInfo(
       bool has_skipped_frames =
         (trust != StackFrame::FRAME_TRUST_CFI && ebp <= raSearchStart + offset);
 
-      u_int32_t value;  // throwaway variable to check pointer validity
+      uint32_t value;  // throwaway variable to check pointer validity
       if (has_skipped_frames || !memory_->GetMemoryAtAddress(ebp, &value)) {
         int fp_search_bytes = last_frame_info->saved_register_size + offset;
-        u_int32_t location_end = last_frame->context.esp +
+        uint32_t location_end = last_frame->context.esp +
                                  last_frame_callee_parameter_size;
 
-        for (u_int32_t location = location_end + fp_search_bytes;
+        for (uint32_t location = location_end + fp_search_bytes;
              location >= location_end;
              location -= 4) {
           if (!memory_->GetMemoryAtAddress(location, &ebp))
@@ -493,8 +493,8 @@ StackFrameX86* StackwalkerX86::GetCallerByEBPAtBase(
     const vector<StackFrame*> &frames) {
   StackFrame::FrameTrust trust;
   StackFrameX86* last_frame = static_cast<StackFrameX86*>(frames.back());
-  u_int32_t last_esp = last_frame->context.esp;
-  u_int32_t last_ebp = last_frame->context.ebp;
+  uint32_t last_esp = last_frame->context.esp;
+  uint32_t last_ebp = last_frame->context.ebp;
 
   // Assume that the standard %ebp-using x86 calling convention is in
   // use.
@@ -519,7 +519,7 @@ StackFrameX86* StackwalkerX86::GetCallerByEBPAtBase(
   // %esp_new = %ebp_old + 8
   // %ebp_new = *(%ebp_old)
 
-  u_int32_t caller_eip, caller_esp, caller_ebp;
+  uint32_t caller_eip, caller_esp, caller_ebp;
 
   if (memory_->GetMemoryAtAddress(last_ebp + 4, &caller_eip) &&
       memory_->GetMemoryAtAddress(last_ebp, &caller_ebp)) {
diff --git a/src/processor/stackwalker_x86.h b/src/processor/stackwalker_x86.h
index 410a473d..45e9709b 100644
--- a/src/processor/stackwalker_x86.h
+++ b/src/processor/stackwalker_x86.h
@@ -67,7 +67,7 @@ class StackwalkerX86 : public Stackwalker {
 
  private:
   // A STACK CFI-driven frame walker for the X86.
-  typedef SimpleCFIWalker<u_int32_t, MDRawContextX86> CFIWalker;
+  typedef SimpleCFIWalker<uint32_t, MDRawContextX86> CFIWalker;
 
   // Implementation of Stackwalker, using x86 context (%ebp, %esp, %eip) and
   // stack conventions (saved %ebp at [%ebp], saved %eip at 4[%ebp], or
diff --git a/src/processor/stackwalker_x86_unittest.cc b/src/processor/stackwalker_x86_unittest.cc
index 25801a2a..841ad0d8 100644
--- a/src/processor/stackwalker_x86_unittest.cc
+++ b/src/processor/stackwalker_x86_unittest.cc
@@ -118,9 +118,9 @@ class StackwalkerX86Fixture {
 
   // Fill RAW_CONTEXT with pseudo-random data, for round-trip checking.
   void BrandContext(MDRawContextX86 *raw_context) {
-    u_int8_t x = 173;
+    uint8_t x = 173;
     for (size_t i = 0; i < sizeof(*raw_context); i++)
-      reinterpret_cast<u_int8_t *>(raw_context)[i] = (x += 17);
+      reinterpret_cast<uint8_t *>(raw_context)[i] = (x += 17);
   }
   
   SystemInfo system_info;
diff --git a/src/processor/static_contained_range_map-inl.h b/src/processor/static_contained_range_map-inl.h
index 46f9bbb5..777c7621 100644
--- a/src/processor/static_contained_range_map-inl.h
+++ b/src/processor/static_contained_range_map-inl.h
@@ -46,7 +46,7 @@ template<typename AddressType, typename EntryType>
 StaticContainedRangeMap<AddressType, EntryType>::StaticContainedRangeMap(
     const char *base)
     : base_(*(reinterpret_cast<const AddressType*>(base))),
-      entry_size_(*(reinterpret_cast<const u_int32_t*>(base + sizeof(base_)))),
+      entry_size_(*(reinterpret_cast<const uint32_t*>(base + sizeof(base_)))),
       entry_ptr_(reinterpret_cast<const EntryType *>(
           base + sizeof(base_) + sizeof(entry_size_))),
       map_(base + sizeof(base_) + sizeof(entry_size_) + entry_size_) {
diff --git a/src/processor/static_contained_range_map.h b/src/processor/static_contained_range_map.h
index 4d26e63f..6a9b8b7b 100644
--- a/src/processor/static_contained_range_map.h
+++ b/src/processor/static_contained_range_map.h
@@ -81,7 +81,7 @@ class StaticContainedRangeMap {
   // actually contain an entry, so its entry_ field is meaningless.  For
   // this reason, the entry_ field should only be accessed on child
   // ContainedRangeMap objects, and never on |this|.
-  u_int32_t entry_size_;
+  uint32_t entry_size_;
   const EntryType *entry_ptr_;
 
   // The map containing child ranges, keyed by each child range's high
diff --git a/src/processor/static_map-inl.h b/src/processor/static_map-inl.h
index 7727052f..e6aac6ab 100644
--- a/src/processor/static_map-inl.h
+++ b/src/processor/static_map-inl.h
@@ -47,13 +47,13 @@ StaticMap<Key, Value, Compare>::StaticMap(const char* raw_data)
     : raw_data_(raw_data),
       compare_() {
   // First 4 Bytes store the number of nodes.
-  num_nodes_ = *(reinterpret_cast<const u_int32_t*>(raw_data_));
+  num_nodes_ = *(reinterpret_cast<const uint32_t*>(raw_data_));
 
-  offsets_ = reinterpret_cast<const u_int32_t*>(
+  offsets_ = reinterpret_cast<const uint32_t*>(
       raw_data_ + sizeof(num_nodes_));
 
   keys_ = reinterpret_cast<const Key*>(
-      raw_data_ + (1 + num_nodes_) * sizeof(u_int32_t));
+      raw_data_ + (1 + num_nodes_) * sizeof(uint32_t));
 }
 
 // find(), lower_bound() and upper_bound() implement binary search algorithm.
@@ -132,14 +132,14 @@ bool StaticMap<Key, Value, Compare>::ValidateInMemoryStructure() const {
 
   int node_index = 0;
   if (num_nodes_) {
-    u_int64_t first_offset = sizeof(int32_t) * (num_nodes_ + 1)
+    uint64_t first_offset = sizeof(int32_t) * (num_nodes_ + 1)
                            + sizeof(Key) * num_nodes_;
     // Num_nodes_ is too large.
     if (first_offset > 0xffffffffUL) {
       BPLOG(INFO) << "StaticMap check failed: size exceeds limit";
       return false;
     }
-    if (offsets_[node_index] != static_cast<u_int32_t>(first_offset)) {
+    if (offsets_[node_index] != static_cast<uint32_t>(first_offset)) {
       BPLOG(INFO) << "StaticMap check failed: first node offset is incorrect";
       return false;
     }
diff --git a/src/processor/static_map.h b/src/processor/static_map.h
index 15a5573b..9723ab2a 100644
--- a/src/processor/static_map.h
+++ b/src/processor/static_map.h
@@ -131,7 +131,7 @@ class StaticMap {
   // Array of offset addresses for stored values.
   // For example:
   // address_of_i-th_node_value = raw_data_ + offsets_[i]
-  const u_int32_t* offsets_;
+  const uint32_t* offsets_;
 
   // keys_[i] = key of i_th node
   const Key* keys_;
diff --git a/src/processor/static_map_iterator-inl.h b/src/processor/static_map_iterator-inl.h
index 325046c3..7a7db5ad 100644
--- a/src/processor/static_map_iterator-inl.h
+++ b/src/processor/static_map_iterator-inl.h
@@ -48,7 +48,7 @@ StaticMapIterator<Key, Value, Compare>::StaticMapIterator(const char* base,
   // See static_map.h for documentation on
   // bytes format of serialized StaticMap data.
   num_nodes_ = *(reinterpret_cast<const int32_t*>(base_));
-  offsets_ = reinterpret_cast<const u_int32_t*>(base_ + sizeof(num_nodes_));
+  offsets_ = reinterpret_cast<const uint32_t*>(base_ + sizeof(num_nodes_));
   keys_ = reinterpret_cast<const Key*>(
       base_ + (1 + num_nodes_) * sizeof(num_nodes_));
 }
diff --git a/src/processor/static_map_iterator.h b/src/processor/static_map_iterator.h
index 8127667b..1af8fff4 100644
--- a/src/processor/static_map_iterator.h
+++ b/src/processor/static_map_iterator.h
@@ -39,7 +39,7 @@
 #ifndef PROCESSOR_STATIC_MAP_ITERATOR_H__
 #define PROCESSOR_STATIC_MAP_ITERATOR_H__
 
-#include <sys/types.h>
+#include "google_breakpad/common/breakpad_types.h"
 
 namespace google_breakpad {
 
@@ -101,7 +101,7 @@ class StaticMapIterator {
   // offsets_ is an array of offset addresses of mapped values.
   // For example:
   // address_of_i-th_node_value = base_ + offsets_[i]
-  const u_int32_t* offsets_;
+  const uint32_t* offsets_;
 
   // keys_[i] = key of i_th node.
   const Key* keys_;
diff --git a/src/processor/static_map_unittest.cc b/src/processor/static_map_unittest.cc
index eb1e1354..97b1e61a 100644
--- a/src/processor/static_map_unittest.cc
+++ b/src/processor/static_map_unittest.cc
@@ -49,7 +49,7 @@ class SimpleMapSerializer {
   static char* Serialize(const std::map<Key, Value> &stdmap,
                    unsigned int* size = NULL) {
     unsigned int size_per_node =
-        sizeof(u_int32_t) + sizeof(Key) + sizeof(Value);
+        sizeof(uint32_t) + sizeof(Key) + sizeof(Value);
     unsigned int memsize = sizeof(int32_t) + size_per_node * stdmap.size();
     if (size) *size = memsize;
 
@@ -58,12 +58,12 @@ class SimpleMapSerializer {
     char* address = mem;
 
     // Writer the number of nodes:
-    new (address) u_int32_t(static_cast<u_int32_t>(stdmap.size()));
-    address += sizeof(u_int32_t);
+    new (address) uint32_t(static_cast<uint32_t>(stdmap.size()));
+    address += sizeof(uint32_t);
 
     // Nodes' offset:
-    u_int32_t* offsets = reinterpret_cast<u_int32_t*>(address);
-    address += sizeof(u_int32_t) * stdmap.size();
+    uint32_t* offsets = reinterpret_cast<uint32_t*>(address);
+    address += sizeof(uint32_t) * stdmap.size();
 
     // Keys:
     Key* keys = reinterpret_cast<Key*>(address);
@@ -95,16 +95,16 @@ class TestInvalidMap : public ::testing::Test {
 };
 
 TEST_F(TestInvalidMap, TestNegativeNumberNodes) {
-  memset(data, 0xff, sizeof(u_int32_t));  // Set the number of nodes = -1
+  memset(data, 0xff, sizeof(uint32_t));  // Set the number of nodes = -1
   test_map = TestMap(data);
   ASSERT_FALSE(test_map.ValidateInMemoryStructure());
 }
 
 TEST_F(TestInvalidMap, TestWrongOffsets) {
-  u_int32_t* header = reinterpret_cast<u_int32_t*>(data);
-  const u_int32_t kNumNodes = 2;
-  const u_int32_t kHeaderOffset =
-        sizeof(u_int32_t) + kNumNodes * (sizeof(u_int32_t) + sizeof(KeyType));
+  uint32_t* header = reinterpret_cast<uint32_t*>(data);
+  const uint32_t kNumNodes = 2;
+  const uint32_t kHeaderOffset =
+        sizeof(uint32_t) + kNumNodes * (sizeof(uint32_t) + sizeof(KeyType));
 
   header[0] = kNumNodes;
   header[1] = kHeaderOffset + 3;   // Wrong offset for first node
@@ -118,16 +118,16 @@ TEST_F(TestInvalidMap, TestWrongOffsets) {
 }
 
 TEST_F(TestInvalidMap, TestUnSortedKeys) {
-  u_int32_t* header = reinterpret_cast<u_int32_t*>(data);
-  const u_int32_t kNumNodes = 2;
-  const u_int32_t kHeaderOffset =
-      sizeof(u_int32_t) + kNumNodes * (sizeof(u_int32_t) + sizeof(KeyType));
+  uint32_t* header = reinterpret_cast<uint32_t*>(data);
+  const uint32_t kNumNodes = 2;
+  const uint32_t kHeaderOffset =
+      sizeof(uint32_t) + kNumNodes * (sizeof(uint32_t) + sizeof(KeyType));
   header[0] = kNumNodes;
   header[1] = kHeaderOffset;
   header[2] = kHeaderOffset + sizeof(ValueType);
 
   KeyType* keys = reinterpret_cast<KeyType*>(
-      data + (kNumNodes + 1) * sizeof(u_int32_t));
+      data + (kNumNodes + 1) * sizeof(uint32_t));
   // Set keys in non-increasing order.
   keys[0] = 10;
   keys[1] = 7;
@@ -171,10 +171,10 @@ class TestValidMap : public ::testing::Test {
 
     // Set correct size of memory allocation for each test case.
     unsigned int size_per_node =
-        sizeof(u_int32_t) + sizeof(KeyType) + sizeof(ValueType);
+        sizeof(uint32_t) + sizeof(KeyType) + sizeof(ValueType);
     for (testcase = 0; testcase < kNumberTestCases; ++testcase) {
       correct_size[testcase] =
-          sizeof(u_int32_t) + std_map[testcase].size() * size_per_node;
+          sizeof(uint32_t) + std_map[testcase].size() * size_per_node;
     }
   }
 
diff --git a/src/processor/synth_minidump.cc b/src/processor/synth_minidump.cc
index 0b623647..377368ac 100644
--- a/src/processor/synth_minidump.cc
+++ b/src/processor/synth_minidump.cc
@@ -193,9 +193,9 @@ Context::Context(const Dump &dump, const MDRawContextARM &context)
 }
 
 Thread::Thread(const Dump &dump,
-               u_int32_t thread_id, const Memory &stack, const Context &context,
-               u_int32_t suspend_count, u_int32_t priority_class,
-               u_int32_t priority, u_int64_t teb) : Section(dump) {
+               uint32_t thread_id, const Memory &stack, const Context &context,
+               uint32_t suspend_count, uint32_t priority_class,
+               uint32_t priority, uint64_t teb) : Section(dump) {
   D32(thread_id);
   D32(suspend_count);
   D32(priority_class);
@@ -207,11 +207,11 @@ Thread::Thread(const Dump &dump,
 }
 
 Module::Module(const Dump &dump,
-               u_int64_t base_of_image,
-               u_int32_t size_of_image,
+               uint64_t base_of_image,
+               uint32_t size_of_image,
                const String &name,
-               u_int32_t time_date_stamp,
-               u_int32_t checksum,
+               uint32_t time_date_stamp,
+               uint32_t checksum,
                const MDVSFixedFileInfo &version_info,
                const Section *cv_record,
                const Section *misc_record) : Section(dump) {
@@ -257,10 +257,10 @@ const MDVSFixedFileInfo Module::stock_version_info = {
 
 Exception::Exception(const Dump &dump,
                      const Context &context,
-                     u_int32_t thread_id,
-                     u_int32_t exception_code,
-                     u_int32_t exception_flags,
-                     u_int64_t exception_address)
+                     uint32_t thread_id,
+                     uint32_t exception_code,
+                     uint32_t exception_flags,
+                     uint64_t exception_address)
   : Stream(dump, MD_EXCEPTION_STREAM) {
   D32(thread_id);
   D32(0);  // __align
@@ -276,10 +276,10 @@ Exception::Exception(const Dump &dump,
   assert(Size() == sizeof(MDRawExceptionStream));
 }
 
-Dump::Dump(u_int64_t flags,
+Dump::Dump(uint64_t flags,
            Endianness endianness,
-           u_int32_t version,
-           u_int32_t date_time_stamp)
+           uint32_t version,
+           uint32_t date_time_stamp)
     : test_assembler::Section(endianness),
       file_start_(0),
       stream_directory_(*this),
diff --git a/src/processor/synth_minidump.h b/src/processor/synth_minidump.h
index 17dbc480..fbc1e29b 100644
--- a/src/processor/synth_minidump.h
+++ b/src/processor/synth_minidump.h
@@ -166,14 +166,14 @@ class Stream: public Section {
  public:
   // Create a stream of type TYPE.  You can append whatever contents
   // you like to this stream using the test_assembler::Section methods.
-  Stream(const Dump &dump, u_int32_t type) : Section(dump), type_(type) { }
+  Stream(const Dump &dump, uint32_t type) : Section(dump), type_(type) { }
 
   // Append an MDRawDirectory referring to this stream to SECTION.
   void CiteStreamIn(test_assembler::Section *section) const;
 
  private:
   // The type of this stream.
-  u_int32_t type_;
+  uint32_t type_;
 };
 
 class SystemInfo: public Stream {
@@ -211,7 +211,7 @@ class String: public Section {
 // to memory addresses.
 class Memory: public Section {
  public:
-  Memory(const Dump &dump, u_int64_t address)
+  Memory(const Dump &dump, uint64_t address)
       : Section(dump), address_(address) { start() = address; }
 
   // Append an MDMemoryDescriptor referring to this memory range to SECTION.
@@ -220,7 +220,7 @@ class Memory: public Section {
  private:
   // The process address from which these memory contents were taken.
   // Shouldn't this be a Label?
-  u_int64_t address_;
+  uint64_t address_;
 };
 
 class Context: public Section {
@@ -238,13 +238,13 @@ class Thread: public Section {
   // Create a thread belonging to DUMP with the given values, citing
   // STACK and CONTEXT (which you must Add to the dump separately).
   Thread(const Dump &dump,
-         u_int32_t thread_id,
+         uint32_t thread_id,
          const Memory &stack,
          const Context &context,
-         u_int32_t suspend_count = 0,
-         u_int32_t priority_class = 0,
-         u_int32_t priority = 0,
-         u_int64_t teb = 0);
+         uint32_t suspend_count = 0,
+         uint32_t priority_class = 0,
+         uint32_t priority = 0,
+         uint64_t teb = 0);
 };
 
 class Module: public Section {
@@ -253,11 +253,11 @@ class Module: public Section {
   // MISC_RECORD can be NULL, in which case the corresponding location
   // descriptior in the minidump will have a length of zero.
   Module(const Dump &dump,
-         u_int64_t base_of_image,
-         u_int32_t size_of_image,
+         uint64_t base_of_image,
+         uint32_t size_of_image,
          const String &name,
-         u_int32_t time_date_stamp = 1262805309,
-         u_int32_t checksum = 0,
+         uint32_t time_date_stamp = 1262805309,
+         uint32_t checksum = 0,
          const MDVSFixedFileInfo &version_info = Module::stock_version_info,
          const Section *cv_record = NULL,
          const Section *misc_record = NULL);
@@ -273,10 +273,10 @@ class Exception : public Stream {
 public:
   Exception(const Dump &dump,
             const Context &context,
-            u_int32_t thread_id = 0,
-            u_int32_t exception_code = 0,
-            u_int32_t exception_flags = 0,
-            u_int64_t exception_address = 0);
+            uint32_t thread_id = 0,
+            uint32_t exception_code = 0,
+            uint32_t exception_flags = 0,
+            uint64_t exception_address = 0);
 };
 
 // A list of entries starting with a 32-bit count, like a memory list
@@ -284,7 +284,7 @@ public:
 template<typename Element>
 class List: public Stream {
  public:
-  List(const Dump &dump, u_int32_t type) : Stream(dump, type), count_(0) {
+  List(const Dump &dump, uint32_t type) : Stream(dump, type), count_(0) {
     D32(count_label_);
   }
 
@@ -317,10 +317,10 @@ class Dump: public test_assembler::Section {
   // header uses the given values. ENDIANNESS determines the
   // endianness of the signature; we set this section's default
   // endianness by this.
-  Dump(u_int64_t flags,
+  Dump(uint64_t flags,
        Endianness endianness = kLittleEndian,
-       u_int32_t version = MD_HEADER_VERSION,
-       u_int32_t date_time_stamp = 1262805309);
+       uint32_t version = MD_HEADER_VERSION,
+       uint32_t date_time_stamp = 1262805309);
 
   // The following functions call OBJECT->Finish(), and append the
   // contents of OBJECT to this minidump. They also record OBJECT in
diff --git a/src/processor/synth_minidump_unittest.cc b/src/processor/synth_minidump_unittest.cc
index b5cf9557..8835b449 100644
--- a/src/processor/synth_minidump_unittest.cc
+++ b/src/processor/synth_minidump_unittest.cc
@@ -175,7 +175,7 @@ TEST(Thread, Simple) {
       0xeb2de4be3f29e3e9ULL); // thread environment block
   string contents;
   ASSERT_TRUE(thread.GetContents(&contents));
-  static const u_int8_t expected_bytes[] = {
+  static const uint8_t expected_bytes[] = {
     0x60, 0xc3, 0x7e, 0x3d, // thread id
     0x4d, 0xf4, 0x93, 0x35, // suspend count
     0x82, 0x2b, 0x35, 0xab, // priority class
@@ -203,7 +203,7 @@ TEST(Exception, Simple) {
                       0x0919a9b9c9d9e9f9ULL); // exception address
   string contents;
   ASSERT_TRUE(exception.GetContents(&contents));
-  static const u_int8_t expected_bytes[] = {
+  static const uint8_t expected_bytes[] = {
     0xcd, 0xab, 0x34, 0x12, // thread id
     0x00, 0x00, 0x00, 0x00, // __align
     0x21, 0x43, 0xba, 0xdc, // exception code
diff --git a/src/processor/synth_minidump_unittest_data.h b/src/processor/synth_minidump_unittest_data.h
index be3bd701..3403372e 100644
--- a/src/processor/synth_minidump_unittest_data.h
+++ b/src/processor/synth_minidump_unittest_data.h
@@ -130,7 +130,7 @@ static const MDRawContextX86 x86_raw_context = {
   }
 };
 
-static const u_int8_t x86_expected_contents[] = {
+static const uint8_t x86_expected_contents[] = {
   0x1b, 0xd7, 0xd5, 0xde,
   0x2e, 0x43, 0xdb, 0x9f,
   0x1a, 0xa8, 0xb7, 0x26,
@@ -320,7 +320,7 @@ static const MDRawContextARM arm_raw_context = {
   }
 };
 
-static const u_int8_t arm_expected_contents[] = {
+static const uint8_t arm_expected_contents[] = {
   0x6a, 0x9e, 0x1b, 0x59,
   0xde, 0x94, 0x15, 0xa2,
   0x25, 0x8a, 0x0d, 0x82,
diff --git a/src/processor/windows_frame_info.h b/src/processor/windows_frame_info.h
index 8af4b3f3..46e7bca0 100644
--- a/src/processor/windows_frame_info.h
+++ b/src/processor/windows_frame_info.h
@@ -85,12 +85,12 @@ struct WindowsFrameInfo {
                      program_string() {}
 
   WindowsFrameInfo(StackInfoTypes type,
-                 u_int32_t set_prolog_size,
-                 u_int32_t set_epilog_size,
-                 u_int32_t set_parameter_size,
-                 u_int32_t set_saved_register_size,
-                 u_int32_t set_local_size,
-                 u_int32_t set_max_stack_size,
+                 uint32_t set_prolog_size,
+                 uint32_t set_epilog_size,
+                 uint32_t set_parameter_size,
+                 uint32_t set_saved_register_size,
+                 uint32_t set_local_size,
+                 uint32_t set_max_stack_size,
                  int set_allocates_base_pointer,
                  const string set_program_string)
       : type_(type),
@@ -110,9 +110,9 @@ struct WindowsFrameInfo {
   // but not the StackFrameInfo structure, so return them as outparams.
   static WindowsFrameInfo *ParseFromString(const string string,
                                            int &type,
-                                           u_int64_t &rva,
-                                           u_int64_t &code_size) {
-    // The format of a STACK WIN record is documented at: 
+                                           uint64_t &rva,
+                                           uint64_t &code_size) {
+    // The format of a STACK WIN record is documented at:
     //
     // http://code.google.com/p/google-breakpad/wiki/SymbolFiles
 
@@ -128,12 +128,12 @@ struct WindowsFrameInfo {
 
     rva                           = strtoull(tokens[1],  NULL, 16);
     code_size                     = strtoull(tokens[2],  NULL, 16);
-    u_int32_t prolog_size         =  strtoul(tokens[3],  NULL, 16);
-    u_int32_t epilog_size         =  strtoul(tokens[4],  NULL, 16);
-    u_int32_t parameter_size      =  strtoul(tokens[5],  NULL, 16);
-    u_int32_t saved_register_size =  strtoul(tokens[6],  NULL, 16);
-    u_int32_t local_size          =  strtoul(tokens[7],  NULL, 16);
-    u_int32_t max_stack_size      =  strtoul(tokens[8],  NULL, 16);
+    uint32_t prolog_size          =  strtoul(tokens[3],  NULL, 16);
+    uint32_t epilog_size          =  strtoul(tokens[4],  NULL, 16);
+    uint32_t parameter_size       =  strtoul(tokens[5],  NULL, 16);
+    uint32_t saved_register_size  =  strtoul(tokens[6],  NULL, 16);
+    uint32_t local_size           =  strtoul(tokens[7],  NULL, 16);
+    uint32_t max_stack_size       =  strtoul(tokens[8],  NULL, 16);
     int has_program_string        =  strtoul(tokens[9], NULL, 16);
 
     const char *program_string = "";
@@ -186,12 +186,12 @@ struct WindowsFrameInfo {
   int valid;
 
   // These values come from IDiaFrameData.
-  u_int32_t prolog_size;
-  u_int32_t epilog_size;
-  u_int32_t parameter_size;
-  u_int32_t saved_register_size;
-  u_int32_t local_size;
-  u_int32_t max_stack_size;
+  uint32_t prolog_size;
+  uint32_t epilog_size;
+  uint32_t parameter_size;
+  uint32_t saved_register_size;
+  uint32_t local_size;
+  uint32_t max_stack_size;
 
   // Only one of allocates_base_pointer or program_string will be valid.
   // If program_string is empty, use allocates_base_pointer.
diff --git a/src/tools/linux/md2core/minidump-2-core.cc b/src/tools/linux/md2core/minidump-2-core.cc
index 289bb980..93c46aab 100644
--- a/src/tools/linux/md2core/minidump-2-core.cc
+++ b/src/tools/linux/md2core/minidump-2-core.cc
@@ -500,9 +500,9 @@ ParseMaps(CrashedProcess* crashinfo, const MinidumpMemoryRange& range) {
     fputs("MD_LINUX_MAPS:\n", stderr);
     fwrite(range.data(), range.length(), 1, stderr);
   }
-  for (const u_int8_t* ptr = range.data();
+  for (const uint8_t* ptr = range.data();
        ptr < range.data() + range.length();) {
-    const u_int8_t* eol = (u_int8_t*)memchr(ptr, '\n',
+    const uint8_t* eol = (uint8_t*)memchr(ptr, '\n',
                                        range.data() + range.length() - ptr);
     std::string line((const char*)ptr,
                      eol ? eol - ptr : range.data() + range.length() - ptr);
diff --git a/src/tools/linux/md2core/minidump_memory_range.h b/src/tools/linux/md2core/minidump_memory_range.h
index b0d8255f..a793e2cf 100644
--- a/src/tools/linux/md2core/minidump_memory_range.h
+++ b/src/tools/linux/md2core/minidump_memory_range.h
@@ -75,8 +75,8 @@ class MinidumpMemoryRange : public MemoryRange {
     std::string str;
     const MDString* md_str = GetData<MDString>(sub_offset);
     if (md_str) {
-      const u_int16_t* buffer = &md_str->buffer[0];
-      for (u_int32_t i = 0; i < md_str->length && buffer[i]; ++i) {
+      const uint16_t* buffer = &md_str->buffer[0];
+      for (uint32_t i = 0; i < md_str->length && buffer[i]; ++i) {
         str.push_back(buffer[i]);
       }
     }
diff --git a/src/tools/linux/md2core/minidump_memory_range_unittest.cc b/src/tools/linux/md2core/minidump_memory_range_unittest.cc
index f4994fe6..fe4ded83 100644
--- a/src/tools/linux/md2core/minidump_memory_range_unittest.cc
+++ b/src/tools/linux/md2core/minidump_memory_range_unittest.cc
@@ -38,9 +38,9 @@ using testing::Message;
 
 namespace {
 
-const u_int32_t kBuffer[10] = { 0 };
+const uint32_t kBuffer[10] = { 0 };
 const size_t kBufferSize = sizeof(kBuffer);
-const u_int8_t* kBufferPointer = reinterpret_cast<const u_int8_t*>(kBuffer);
+const uint8_t* kBufferPointer = reinterpret_cast<const uint8_t*>(kBuffer);
 
 // Test vectors for verifying Covers, GetData, and Subrange.
 const struct {
@@ -222,7 +222,7 @@ TEST(MinidumpMemoryRangeTest, GetArrayElmentWithTemplateType) {
 }
 
 TEST(MinidumpMemoryRangeTest, GetAsciiMDString) {
-  u_int8_t buffer[100] = { 0 };
+  uint8_t buffer[100] = { 0 };
 
   MDString* md_str = reinterpret_cast<MDString*>(buffer);
   md_str->length = 4;
@@ -233,7 +233,7 @@ TEST(MinidumpMemoryRangeTest, GetAsciiMDString) {
   md_str->buffer[4] = '\0';
 
   size_t str2_offset =
-      sizeof(MDString) + (md_str->length + 1) * sizeof(u_int16_t);
+      sizeof(MDString) + (md_str->length + 1) * sizeof(uint16_t);
 
   md_str = reinterpret_cast<MDString*>(buffer + str2_offset);
   md_str->length = 9;  // Test length larger than actual string