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

talk/session/media/mediasession.cc

 /*
  * libjingle
  * Copyright 2004 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 27 matching lines @@
 #include "talk/session/media/srtpfilter.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/p2p/base/constants.h"
 
 #ifdef HAVE_SCTP
 #include "talk/media/sctp/sctpdataengine.h"
 #else
-static const uint32 kMaxSctpSid = 1023;
+static const uint32_t kMaxSctpSid = 1023;
 #endif
 
 namespace {
 const char kInline[] = "inline:";
 }
 
 namespace cricket {
 
 using rtc::scoped_ptr;
 
@@ skipping 184 matching lines @@
   } while (FindFirstStreamParamsByCname(params_vec, *cname));
 
   return true;
 }
 
 // Generate random SSRC values that are not already present in |params_vec|.
 // The generated values are added to |ssrcs|.
 // |num_ssrcs| is the number of the SSRC will be generated.
 static void GenerateSsrcs(const StreamParamsVec& params_vec,
                           int num_ssrcs,
-                          std::vector<uint32>* ssrcs) {
+                          std::vector<uint32_t>* ssrcs) {
   for (int i = 0; i < num_ssrcs; i++) {
-    uint32 candidate;
+    uint32_t candidate;
     do {
       candidate = rtc::CreateRandomNonZeroId();
     } while (GetStreamBySsrc(params_vec, candidate) ||
              std::count(ssrcs->begin(), ssrcs->end(), candidate) > 0);
     ssrcs->push_back(candidate);
   }
 }
 
 // Returns false if we exhaust the range of SIDs.
-static bool GenerateSctpSid(const StreamParamsVec& params_vec,
-                            uint32* sid) {
+static bool GenerateSctpSid(const StreamParamsVec& params_vec, uint32_t* sid) {
   if (params_vec.size() > kMaxSctpSid) {
     LOG(LS_WARNING) <<
         "Could not generate an SCTP SID: too many SCTP streams.";
     return false;
   }
   while (true) {
-    uint32 candidate = rtc::CreateRandomNonZeroId() % kMaxSctpSid;
+    uint32_t candidate = rtc::CreateRandomNonZeroId() % kMaxSctpSid;
     if (!GetStreamBySsrc(params_vec, candidate)) {
       *sid = candidate;
       return true;
     }
   }
 }
 
 static bool GenerateSctpSids(const StreamParamsVec& params_vec,
-                             std::vector<uint32>* sids) {
-  uint32 sid;
+                             std::vector<uint32_t>* sids) {
+  uint32_t sid;
   if (!GenerateSctpSid(params_vec, &sid)) {
     LOG(LS_WARNING) << "Could not generated an SCTP SID.";
     return false;
   }
   sids->push_back(sid);
   return true;
 }
 
 // Finds all StreamParams of all media types and attach them to stream_params.
 static void GetCurrentStreamParams(const SessionDescription* sdesc,
@@ skipping 140 matching lines @@
     MediaType media_type,
     const MediaSessionOptions::Streams& streams,
     StreamParamsVec* current_streams,
     MediaContentDescriptionImpl<C>* content_description,
     const bool add_legacy_stream) {
   const bool include_rtx_streams =
       ContainsRtxCodec(content_description->codecs());
 
   if (streams.empty() && add_legacy_stream) {
     // TODO(perkj): Remove this legacy stream when all apps use StreamParams.
-    std::vector<uint32> ssrcs;
+    std::vector<uint32_t> ssrcs;
     if (IsSctp(content_description)) {
       GenerateSctpSids(*current_streams, &ssrcs);
     } else {
       int num_ssrcs = include_rtx_streams ? 2 : 1;
       GenerateSsrcs(*current_streams, num_ssrcs, &ssrcs);
     }
     if (include_rtx_streams) {
       content_description->AddLegacyStream(ssrcs[0], ssrcs[1]);
       content_description->set_multistream(true);
     } else {
@@ skipping 14 matching lines @@
     // MediaSessionDescriptionFactory.
     if (!param) {
       // This is a new stream.
       // Get a CNAME. Either new or same as one of the other synched streams.
       std::string cname;
       if (!GenerateCname(*current_streams, streams, stream_it->sync_label,
                          &cname)) {
         return false;
       }
 
-      std::vector<uint32> ssrcs;
+      std::vector<uint32_t> ssrcs;
       if (IsSctp(content_description)) {
         GenerateSctpSids(*current_streams, &ssrcs);
       } else {
         GenerateSsrcs(*current_streams, stream_it->num_sim_layers, &ssrcs);
       }
       StreamParams stream_param;
       stream_param.id = stream_it->id;
       // Add the generated ssrc.
       for (size_t i = 0; i < ssrcs.size(); ++i) {
         stream_param.ssrcs.push_back(ssrcs[i]);
       }
       if (stream_it->num_sim_layers > 1) {
         SsrcGroup group(kSimSsrcGroupSemantics, stream_param.ssrcs);
         stream_param.ssrc_groups.push_back(group);
       }
       // Generate extra ssrcs for include_rtx_streams case.
       if (include_rtx_streams) {
         // Generate an RTX ssrc for every ssrc in the group.
-        std::vector<uint32> rtx_ssrcs;
+        std::vector<uint32_t> rtx_ssrcs;
         GenerateSsrcs(*current_streams, static_cast<int>(ssrcs.size()),
                       &rtx_ssrcs);
         for (size_t i = 0; i < ssrcs.size(); ++i) {
           stream_param.AddFidSsrc(ssrcs[i], rtx_ssrcs[i]);
         }
         content_description->set_multistream(true);
       }
       stream_param.cname = cname;
       stream_param.sync_label = stream_it->sync_label;
       content_description->AddStream(stream_param);
@@ skipping 1393 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 const DataContentDescription* GetFirstDataContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket