Use suffixed {uint,int}{8,16,32,64}_t types.

talk/app/webrtc/statstypes.h

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 232 matching lines @@
     IdBase(StatsType type);  // Only meant for derived classes.
     const StatsType type_;
 
     static const char kSeparator = '_';
   };
 
   typedef rtc::scoped_refptr<IdBase> Id;
 
   struct Value {
     enum Type {
-      kInt, // int.
-      kInt64,  // int64.
-      kFloat,  // float.
-      kString,  // std::string
+      kInt,           // int.
+      kInt64,         // int64_t.
+      kFloat,         // float.
+      kString,        // std::string
       kStaticString,  // const char*.
-      kBool,  // bool.
-      kId,  // Id.
+      kBool,          // bool.
+      kId,            // Id.
     };
 
-    Value(StatsValueName name, int64 value, Type int_type);
+    Value(StatsValueName name, int64_t value, Type int_type);
     Value(StatsValueName name, float f);
     Value(StatsValueName name, const std::string& value);
     Value(StatsValueName name, const char* value);
     Value(StatsValueName name, bool b);
     Value(StatsValueName name, const Id& value);
 
     ~Value();
 
     // TODO(tommi): This compares name as well as value...
     // I think we should only need to compare the value part and
     // move the name part into a hash map.
     bool Equals(const Value& other) const;
 
     // Comparison operators. Return true iff the current instance is of the
     // correct type and holds the same value.  No conversion is performed so
     // a string value of "123" is not equal to an int value of 123 and an int
     // value of 123 is not equal to a float value of 123.0f.
     // One exception to this is that types kInt and kInt64 can be compared and
     // kString and kStaticString too.
     bool operator==(const std::string& value) const;
     bool operator==(const char* value) const;
-    bool operator==(int64 value) const;
+    bool operator==(int64_t value) const;
     bool operator==(bool value) const;
     bool operator==(float value) const;
     bool operator==(const Id& value) const;
 
     // Getters that allow getting the native value directly.
     // The caller must know the type beforehand or else hit a check.
     int int_val() const;
-    int64 int64_val() const;
+    int64_t int64_val() const;
     float float_val() const;
     const char* static_string_val() const;
     const std::string& string_val() const;
     bool bool_val() const;
     const Id& id_val() const;
 
     // Returns the string representation of |name|.
     const char* display_name() const;
 
     // Converts the native value to a string representation of the value.
     std::string ToString() const;
 
     Type type() const { return type_; }
 
     // TODO(tommi): Move |name| and |display_name| out of the Value struct.
     const StatsValueName name;
 
    private:
     const Type type_;
     // TODO(tommi): Use C++ 11 union and make value_ const.
     union InternalType {
       int int_;
-      int64 int64_;
+      int64_t int64_;
       float float_;
       bool bool_;
       std::string* string_;
       const char* static_string_;
       Id* id_;
     } value_;
 
    private:
     RTC_DISALLOW_COPY_AND_ASSIGN(Value);
   };
@@ skipping 22 matching lines @@
   StatsType type() const { return id_->type(); }
   double timestamp() const { return timestamp_; }
   void set_timestamp(double t) { timestamp_ = t; }
   bool empty() const { return values_.empty(); }
   const Values& values() const { return values_; }
 
   const char* TypeToString() const;
 
   void AddString(StatsValueName name, const std::string& value);
   void AddString(StatsValueName name, const char* value);
-  void AddInt64(StatsValueName name, int64 value);
+  void AddInt64(StatsValueName name, int64_t value);
   void AddInt(StatsValueName name, int value);
   void AddFloat(StatsValueName name, float value);
   void AddBoolean(StatsValueName name, bool value);
   void AddId(StatsValueName name, const Id& value);
 
   const Value* FindValue(StatsValueName name) const;
 
  private:
   // The unique identifier for this object.
   // This is used as a key for this report in ordered containers,
@@ skipping 39 matching lines @@
   StatsReport* Find(const StatsReport::Id& id);
 
  private:
   Container list_;
   rtc::ThreadChecker thread_checker_;
 };
 
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_STATSTYPES_H_