Use stdint types everywhere.

src/processor/stackwalker_unittest_utils.h

Index: src/processor/stackwalker_unittest_utils.h
===================================================================
--- a/src/processor/stackwalker_unittest_utils.h
+++ b/src/processor/stackwalker_unittest_utils.h
@@ -50,94 +50,94 @@
 
 class MockMemoryRegion: public google_breakpad::MemoryRegion {
  public:
   MockMemoryRegion(): base_address_(0) { }
 
   // 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);
   }
 
  private:
   // 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;
     ValueType v = 0;
     int start = address - base_address_;
     // The loop condition is odd, but it's correct for size_t.
     for (size_t i = sizeof(ValueType) - 1; i < sizeof(ValueType); i--)
       v = (v << 8) | static_cast<unsigned char>(contents_[start + i]);
     *value = v;
     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_; }
   string debug_identifier() const { return code_file_; }
   string version()          const { return version_; }
   const google_breakpad::CodeModule *Copy() const {
     abort(); // Tests won't use this.
   }
 
  private:
-  u_int64_t base_address_;
-  u_int64_t size_;
+  uint64_t base_address_;
+  uint64_t size_;
   string code_file_;
   string version_;
 };
 
 class MockCodeModules: public google_breakpad::CodeModules {
  public:  
   typedef google_breakpad::CodeModule CodeModule;
   typedef google_breakpad::CodeModules CodeModules;
 
   void Add(const MockCodeModule *module) { 
     modules_.push_back(module);
   }
 
   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;
       if (module->base_address() <= address &&
           address - module->base_address() < module->size())
         return module;
     }
     return NULL;