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

talk/app/webrtc/webrtcsdp.cc

 /*
  * libjingle
  * Copyright 2011 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 213 matching lines @@
 // types.
 const int kWildcardPayloadType = -1;
 
 struct SsrcInfo {
   SsrcInfo()
       : msid_identifier(kDefaultMsid),
         // TODO(ronghuawu): What should we do if the appdata doesn't appear?
         // Create random string (which will be used as track label later)?
         msid_appdata(rtc::CreateRandomString(8)) {
   }
-  uint32 ssrc_id;
+  uint32_t ssrc_id;
   std::string cname;
   std::string msid_identifier;
   std::string msid_appdata;
 
   // For backward compatibility.
   // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
   std::string label;
   std::string mslabel;
 };
 typedef std::vector<SsrcInfo> SsrcInfoVec;
@@ skipping 273 matching lines @@
     return false;
 
   return true;
 }
 
 static bool HasAttribute(const std::string& line,
                          const std::string& attribute) {
   return (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0);
 }
 
-static bool AddSsrcLine(uint32 ssrc_id, const std::string& attribute,
-                        const std::string& value, std::string* message) {
+static bool AddSsrcLine(uint32_t ssrc_id,
+                        const std::string& attribute,
+                        const std::string& value,
+                        std::string* message) {
   // RFC 5576
   // a=ssrc:<ssrc-id> <attribute>:<value>
   std::ostringstream os;
   InitAttrLine(kAttributeSsrc, &os);
   os << kSdpDelimiterColon << ssrc_id << kSdpDelimiterSpace
      << attribute << kSdpDelimiterColon << value;
   return AddLine(os.str(), message);
 }
 
 // Get value only from <attribute>:<value>.
@@ skipping 457 matching lines @@
       (fields[6] != kAttributeCandidateTyp)) {
     return ParseFailedExpectMinFieldNum(first_line, expected_min_fields, error);
   }
   const std::string& foundation = fields[0];
 
   int component_id = 0;
   if (!GetValueFromString(first_line, fields[1], &component_id, error)) {
     return false;
   }
   const std::string& transport = fields[2];
-  uint32 priority = 0;
+  uint32_t priority = 0;
   if (!GetValueFromString(first_line, fields[3], &priority, error)) {
     return false;
   }
   const std::string& connection_address = fields[4];
   int port = 0;
   if (!GetValueFromString(first_line, fields[5], &port, error)) {
     return false;
   }
   SocketAddress address(connection_address, port);
 
@@ skipping 53 matching lines @@
     }
   }
 
   // Extension
   // Empty string as the candidate username and password.
   // Will be updated later with the ice-ufrag and ice-pwd.
   // TODO: Remove the username/password extension, which is currently
   // kept for backwards compatibility.
   std::string username;
   std::string password;
-  uint32 generation = 0;
+  uint32_t generation = 0;
   for (size_t i = current_position; i + 1 < fields.size(); ++i) {
     // RFC 5245
     // *(SP extension-att-name SP extension-att-value)
     if (fields[i] == kAttributeCandidateGeneration) {
       if (!GetValueFromString(first_line, fields[++i], &generation, error)) {
         return false;
       }
     } else if (fields[i] == kAttributeCandidateUsername) {
       username = fields[++i];
     } else if (fields[i] == kAttributeCandidatePassword) {
@@ skipping 342 matching lines @@
     // Build the ssrc-group lines.
     for (size_t i = 0; i < track->ssrc_groups.size(); ++i) {
       // RFC 5576
       // a=ssrc-group:<semantics> <ssrc-id> ...
       if (track->ssrc_groups[i].ssrcs.empty()) {
         continue;
       }
       std::ostringstream os;
       InitAttrLine(kAttributeSsrcGroup, &os);
       os << kSdpDelimiterColon << track->ssrc_groups[i].semantics;
-      std::vector<uint32>::const_iterator ssrc =
+      std::vector<uint32_t>::const_iterator ssrc =
           track->ssrc_groups[i].ssrcs.begin();
       for (; ssrc != track->ssrc_groups[i].ssrcs.end(); ++ssrc) {
-        os << kSdpDelimiterSpace << rtc::ToString<uint32>(*ssrc);
+        os << kSdpDelimiterSpace << rtc::ToString<uint32_t>(*ssrc);
       }
       AddLine(os.str(), message);
     }
     // Build the ssrc lines for each ssrc.
     for (size_t i = 0; i < track->ssrcs.size(); ++i) {
-      uint32 ssrc = track->ssrcs[i];
+      uint32_t ssrc = track->ssrcs[i];
       // RFC 5576
       // a=ssrc:<ssrc-id> cname:<value>
       AddSsrcLine(ssrc, kSsrcAttributeCname,
                   track->cname, message);
 
       // draft-alvestrand-mmusic-msid-00
       // a=ssrc:<ssrc-id> msid:identifier [appdata]
       // The appdata consists of the "id" attribute of a MediaStreamTrack, which
       // is corresponding to the "name" attribute of StreamParams.
       std::string appdata = track->id;
@@ skipping 1163 matching lines @@
 
   // Create tracks from the |ssrc_infos|.
   CreateTracksFromSsrcInfos(ssrc_infos, &tracks);
 
   // Add the ssrc group to the track.
   for (SsrcGroupVec::iterator ssrc_group = ssrc_groups.begin();
        ssrc_group != ssrc_groups.end(); ++ssrc_group) {
     if (ssrc_group->ssrcs.empty()) {
       continue;
     }
-    uint32 ssrc = ssrc_group->ssrcs.front();
+    uint32_t ssrc = ssrc_group->ssrcs.front();
     for (StreamParamsVec::iterator track = tracks.begin();
          track != tracks.end(); ++track) {
       if (track->has_ssrc(ssrc)) {
         track->ssrc_groups.push_back(*ssrc_group);
       }
     }
   }
 
   // Add the new tracks to the |media_desc|.
   for (StreamParamsVec::iterator track = tracks.begin();
@@ skipping 51 matching lines @@
                            &field1, &field2)) {
     const size_t expected_fields = 2;
     return ParseFailedExpectFieldNum(line, expected_fields, error);
   }
 
   // ssrc:<ssrc-id>
   std::string ssrc_id_s;
   if (!GetValue(field1, kAttributeSsrc, &ssrc_id_s, error)) {
     return false;
   }
-  uint32 ssrc_id = 0;
+  uint32_t ssrc_id = 0;
   if (!GetValueFromString(line, ssrc_id_s, &ssrc_id, error)) {
     return false;
   }
 
   std::string attribute;
   std::string value;
   if (!rtc::tokenize_first(field2, kSdpDelimiterColon, &attribute, &value)) {
     std::ostringstream description;
     description << "Failed to get the ssrc attribute value from " << field2
                 << ". Expected format <attribute>:<value>.";
@@ skipping 56 matching lines @@
   rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   std::string semantics;
   if (!GetValue(fields[0], kAttributeSsrcGroup, &semantics, error)) {
     return false;
   }
-  std::vector<uint32> ssrcs;
+  std::vector<uint32_t> ssrcs;
   for (size_t i = 1; i < fields.size(); ++i) {
-    uint32 ssrc = 0;
+    uint32_t ssrc = 0;
     if (!GetValueFromString(line, fields[i], &ssrc, error)) {
       return false;
     }
     ssrcs.push_back(ssrc);
   }
   ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
   return true;
 }
 
 bool ParseCryptoAttribute(const std::string& line,
@@ skipping 269 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc