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

talk/media/base/fakemediaengine.h

 /*
  * 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 95 matching lines @@
   void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
   void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; }
   virtual bool AddSendStream(const StreamParams& sp) {
     if (std::find(send_streams_.begin(), send_streams_.end(), sp) !=
         send_streams_.end()) {
       return false;
     }
     send_streams_.push_back(sp);
     return true;
   }
-  virtual bool RemoveSendStream(uint32 ssrc) {
+  virtual bool RemoveSendStream(uint32_t ssrc) {
     return RemoveStreamBySsrc(&send_streams_, ssrc);
   }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (std::find(receive_streams_.begin(), receive_streams_.end(), sp) !=
         receive_streams_.end()) {
       return false;
     }
     receive_streams_.push_back(sp);
     return true;
   }
-  virtual bool RemoveRecvStream(uint32 ssrc) {
+  virtual bool RemoveRecvStream(uint32_t ssrc) {
     return RemoveStreamBySsrc(&receive_streams_, ssrc);
   }
-  bool IsStreamMuted(uint32 ssrc) const {
+  bool IsStreamMuted(uint32_t ssrc) const {
     bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
     // If |ssrc = 0| check if the first send stream is muted.
     if (!ret && ssrc == 0 && !send_streams_.empty()) {
       return muted_streams_.find(send_streams_[0].first_ssrc()) !=
              muted_streams_.end();
     }
     return ret;
   }
   const std::vector<StreamParams>& send_streams() const {
     return send_streams_;
   }
   const std::vector<StreamParams>& recv_streams() const {
     return receive_streams_;
   }
-  bool HasRecvStream(uint32 ssrc) const {
+  bool HasRecvStream(uint32_t ssrc) const {
     return GetStreamBySsrc(receive_streams_, ssrc) != nullptr;
   }
-  bool HasSendStream(uint32 ssrc) const {
+  bool HasSendStream(uint32_t ssrc) const {
     return GetStreamBySsrc(send_streams_, ssrc) != nullptr;
   }
   // TODO(perkj): This is to support legacy unit test that only check one
   // sending stream.
-  uint32 send_ssrc() const {
+  uint32_t send_ssrc() const {
     if (send_streams_.empty())
       return 0;
     return send_streams_[0].first_ssrc();
   }
 
   // TODO(perkj): This is to support legacy unit test that only check one
   // sending stream.
   const std::string rtcp_cname() {
     if (send_streams_.empty())
       return "";
     return send_streams_[0].cname;
   }
 
   bool ready_to_send() const {
     return ready_to_send_;
   }
 
  protected:
-  bool MuteStream(uint32 ssrc, bool mute) {
+  bool MuteStream(uint32_t ssrc, bool mute) {
     if (!HasSendStream(ssrc) && ssrc != 0) {
       return false;
     }
     if (mute) {
       muted_streams_.insert(ssrc);
     } else {
       muted_streams_.erase(ssrc);
     }
     return true;
   }
@@ skipping 28 matching lines @@
 
  private:
   bool sending_;
   bool playout_;
   std::vector<RtpHeaderExtension> recv_extensions_;
   std::vector<RtpHeaderExtension> send_extensions_;
   std::list<std::string> rtp_packets_;
   std::list<std::string> rtcp_packets_;
   std::vector<StreamParams> send_streams_;
   std::vector<StreamParams> receive_streams_;
-  std::set<uint32> muted_streams_;
+  std::set<uint32_t> muted_streams_;
   bool fail_set_send_codecs_;
   bool fail_set_recv_codecs_;
-  uint32 send_ssrc_;
+  uint32_t send_ssrc_;
   std::string rtcp_cname_;
   bool ready_to_send_;
 };
 
 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
  public:
   struct DtmfInfo {
-    DtmfInfo(uint32 ssrc, int event_code, int duration, int flags)
-        : ssrc(ssrc), event_code(event_code), duration(duration), flags(flags) {
-    }
-    uint32 ssrc;
+    DtmfInfo(uint32_t ssrc, int event_code, int duration, int flags)
+        : ssrc(ssrc),
+          event_code(event_code),
+          duration(duration),
+          flags(flags) {}
+    uint32_t ssrc;
     int event_code;
     int duration;
     int flags;
   };
   explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine,
                                  const AudioOptions& options)
       : engine_(engine),
         fail_set_send_(false),
         ringback_tone_ssrc_(0),
         ringback_tone_play_(false),
         ringback_tone_loop_(false),
         time_since_last_typing_(-1) {
     output_scalings_[0] = OutputScaling();  // For default channel.
     SetOptions(options);
   }
   ~FakeVoiceMediaChannel();
   const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
   const std::vector<DtmfInfo>& dtmf_info_queue() const {
     return dtmf_info_queue_;
   }
   const AudioOptions& options() const { return options_; }
 
-  uint32 ringback_tone_ssrc() const { return ringback_tone_ssrc_; }
+  uint32_t ringback_tone_ssrc() const { return ringback_tone_ssrc_; }
   bool ringback_tone_play() const { return ringback_tone_play_; }
   bool ringback_tone_loop() const { return ringback_tone_loop_; }
 
   virtual bool SetSendParameters(const AudioSendParameters& params) {
     return (SetSendCodecs(params.codecs) &&
             SetSendRtpHeaderExtensions(params.extensions) &&
             SetMaxSendBandwidth(params.max_bandwidth_bps) &&
             SetOptions(params.options));
   }
 
   virtual bool SetRecvParameters(const AudioRecvParameters& params) {
     return (SetRecvCodecs(params.codecs) &&
             SetRecvRtpHeaderExtensions(params.extensions));
   }
   virtual bool SetPlayout(bool playout) {
     set_playout(playout);
     return true;
   }
   virtual bool SetSend(SendFlags flag) {
     if (fail_set_send_) {
       return false;
     }
     return set_sending(flag != SEND_NOTHING);
   }
-  virtual bool SetAudioSend(uint32 ssrc, bool mute,
+  virtual bool SetAudioSend(uint32_t ssrc,
+                            bool mute,
                             const AudioOptions* options,
                             AudioRenderer* renderer) {
     if (!SetLocalRenderer(ssrc, renderer)) {
       return false;
     }
     if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, mute)) {
       return false;
     }
     if (!mute && options) {
       return SetOptions(*options);
     }
     return true;
   }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
       return false;
     output_scalings_[sp.first_ssrc()] = OutputScaling();
     return true;
   }
-  virtual bool RemoveRecvStream(uint32 ssrc) {
+  virtual bool RemoveRecvStream(uint32_t ssrc) {
     if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
       return false;
     output_scalings_.erase(ssrc);
     return true;
   }
-  virtual bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) {
-    std::map<uint32, AudioRenderer*>::iterator it =
+  virtual bool SetRemoteRenderer(uint32_t ssrc, AudioRenderer* renderer) {
+    std::map<uint32_t, AudioRenderer*>::iterator it =
         remote_renderers_.find(ssrc);
     if (renderer) {
       if (it != remote_renderers_.end()) {
         ASSERT(it->second == renderer);
       } else {
         remote_renderers_.insert(std::make_pair(ssrc, renderer));
         renderer->AddChannel(0);
       }
     } else {
       if (it != remote_renderers_.end()) {
         it->second->RemoveChannel(0);
         remote_renderers_.erase(it);
       } else {
         return false;
       }
     }
     return true;
   }
 
   virtual bool GetActiveStreams(AudioInfo::StreamList* streams) { return true; }
   virtual int GetOutputLevel() { return 0; }
   void set_time_since_last_typing(int ms) { time_since_last_typing_ = ms; }
   virtual int GetTimeSinceLastTyping() { return time_since_last_typing_; }
   virtual void SetTypingDetectionParameters(
       int time_window, int cost_per_typing, int reporting_threshold,
       int penalty_decay, int type_event_delay) {}
 
   virtual bool SetRingbackTone(const char* buf, int len) { return true; }
-  virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) {
+  virtual bool PlayRingbackTone(uint32_t ssrc, bool play, bool loop) {
     ringback_tone_ssrc_ = ssrc;
     ringback_tone_play_ = play;
     ringback_tone_loop_ = loop;
     return true;
   }
 
   virtual bool CanInsertDtmf() {
     for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
          it != send_codecs_.end(); ++it) {
       // Find the DTMF telephone event "codec".
       if (_stricmp(it->name.c_str(), "telephone-event") == 0) {
         return true;
       }
     }
     return false;
   }
-  virtual bool InsertDtmf(uint32 ssrc, int event_code, int duration,
+  virtual bool InsertDtmf(uint32_t ssrc,
+                          int event_code,
+                          int duration,
                           int flags) {
     dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration, flags));
     return true;
   }
 
-  virtual bool SetOutputScaling(uint32 ssrc, double left, double right) {
+  virtual bool SetOutputScaling(uint32_t ssrc, double left, double right) {
     if (0 == ssrc) {
-      std::map<uint32, OutputScaling>::iterator it;
+      std::map<uint32_t, OutputScaling>::iterator it;
       for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) {
         it->second.left = left;
         it->second.right = right;
       }
       return true;
     } else if (output_scalings_.find(ssrc) != output_scalings_.end()) {
       output_scalings_[ssrc].left = left;
       output_scalings_[ssrc].right = right;
       return true;
     }
     return false;
   }
-  bool GetOutputScaling(uint32 ssrc, double* left, double* right) {
+  bool GetOutputScaling(uint32_t ssrc, double* left, double* right) {
     if (output_scalings_.find(ssrc) == output_scalings_.end())
       return false;
     *left = output_scalings_[ssrc].left;
     *right = output_scalings_[ssrc].right;
     return true;
   }
 
   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
-  virtual void GetLastMediaError(uint32* ssrc,
+  virtual void GetLastMediaError(uint32_t* ssrc,
                                  VoiceMediaChannel::Error* error) {
     *ssrc = 0;
     *error = fail_set_send_ ? VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED
                             : VoiceMediaChannel::ERROR_NONE;
   }
 
   void set_fail_set_send(bool fail) { fail_set_send_ = fail; }
-  void TriggerError(uint32 ssrc, VoiceMediaChannel::Error error) {
+  void TriggerError(uint32_t ssrc, VoiceMediaChannel::Error error) {
     VoiceMediaChannel::SignalMediaError(ssrc, error);
   }
 
  private:
   struct OutputScaling {
     OutputScaling() : left(1.0), right(1.0) {}
     double left, right;
   };
 
   class VoiceChannelAudioSink : public AudioRenderer::Sink {
@@ skipping 36 matching lines @@
     }
     send_codecs_ = codecs;
     return true;
   }
   bool SetMaxSendBandwidth(int bps) { return true; }
   bool SetOptions(const AudioOptions& options) {
     // Does a "merge" of current options and set options.
     options_.SetAll(options);
     return true;
   }
-  bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) {
+  bool SetLocalRenderer(uint32_t ssrc, AudioRenderer* renderer) {
     auto it = local_renderers_.find(ssrc);
     if (renderer) {
       if (it != local_renderers_.end()) {
         ASSERT(it->second->renderer() == renderer);
       } else {
         local_renderers_.insert(std::make_pair(
             ssrc, new VoiceChannelAudioSink(renderer)));
       }
     } else {
       if (it != local_renderers_.end()) {
         delete it->second;
         local_renderers_.erase(it);
       }
     }
     return true;
   }
 
   FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
-  std::map<uint32, OutputScaling> output_scalings_;
+  std::map<uint32_t, OutputScaling> output_scalings_;
   std::vector<DtmfInfo> dtmf_info_queue_;
   bool fail_set_send_;
-  uint32 ringback_tone_ssrc_;
+  uint32_t ringback_tone_ssrc_;
   bool ringback_tone_play_;
   bool ringback_tone_loop_;
   int time_since_last_typing_;
   AudioOptions options_;
-  std::map<uint32, VoiceChannelAudioSink*> local_renderers_;
-  std::map<uint32, AudioRenderer*> remote_renderers_;
+  std::map<uint32_t, VoiceChannelAudioSink*> local_renderers_;
+  std::map<uint32_t, AudioRenderer*> remote_renderers_;
 };
 
 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
-                            uint32 ssrc, int event_code, int duration,
+                            uint32_t ssrc,
+                            int event_code,
+                            int duration,
                             int flags) {
   return (info.duration == duration && info.event_code == event_code &&
           info.flags == flags && info.ssrc == ssrc);
 }
 
 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
  public:
   explicit FakeVideoMediaChannel(FakeVideoEngine* engine,
                                  const VideoOptions& options)
       : engine_(engine),
         sent_intra_frame_(false),
         requested_intra_frame_(false),
         max_bps_(-1) {
     SetOptions(options);
   }
 
   ~FakeVideoMediaChannel();
 
   const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
   bool rendering() const { return playout(); }
   const VideoOptions& options() const { return options_; }
-  const std::map<uint32, VideoRenderer*>& renderers() const {
+  const std::map<uint32_t, VideoRenderer*>& renderers() const {
     return renderers_;
   }
   int max_bps() const { return max_bps_; }
-  bool GetSendStreamFormat(uint32 ssrc, VideoFormat* format) {
+  bool GetSendStreamFormat(uint32_t ssrc, VideoFormat* format) {
     if (send_formats_.find(ssrc) == send_formats_.end()) {
       return false;
     }
     *format = send_formats_[ssrc];
     return true;
   }
-  virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) {
+  virtual bool SetSendStreamFormat(uint32_t ssrc, const VideoFormat& format) {
     if (send_formats_.find(ssrc) == send_formats_.end()) {
       return false;
     }
     send_formats_[ssrc] = format;
     return true;
   }
   virtual bool SetSendParameters(const VideoSendParameters& params) {
     return (SetSendCodecs(params.codecs) &&
             SetSendRtpHeaderExtensions(params.extensions) &&
             SetMaxSendBandwidth(params.max_bandwidth_bps) &&
             SetOptions(params.options));
   }
 
   virtual bool SetRecvParameters(const VideoRecvParameters& params) {
     return (SetRecvCodecs(params.codecs) &&
             SetRecvRtpHeaderExtensions(params.extensions));
   }
   virtual bool AddSendStream(const StreamParams& sp) {
     if (!RtpHelper<VideoMediaChannel>::AddSendStream(sp)) {
       return false;
     }
     SetSendStreamDefaultFormat(sp.first_ssrc());
     return true;
   }
-  virtual bool RemoveSendStream(uint32 ssrc) {
+  virtual bool RemoveSendStream(uint32_t ssrc) {
     send_formats_.erase(ssrc);
     return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
   }
 
   virtual bool GetSendCodec(VideoCodec* send_codec) {
     if (send_codecs_.empty()) {
       return false;
     }
     *send_codec = send_codecs_[0];
     return true;
   }
   virtual bool SetRender(bool render) {
     set_playout(render);
     return true;
   }
-  virtual bool SetRenderer(uint32 ssrc, VideoRenderer* r) {
+  virtual bool SetRenderer(uint32_t ssrc, VideoRenderer* r) {
     if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
       return false;
     }
     if (ssrc != 0) {
       renderers_[ssrc] = r;
     }
     return true;
   }
 
   virtual bool SetSend(bool send) { return set_sending(send); }
-  virtual bool SetVideoSend(uint32 ssrc, bool mute,
+  virtual bool SetVideoSend(uint32_t ssrc,
+                            bool mute,
                             const VideoOptions* options) {
     if (!RtpHelper<VideoMediaChannel>::MuteStream(ssrc, mute)) {
       return false;
     }
     if (!mute && options) {
       return SetOptions(*options);
     }
     return true;
   }
-  virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
+  virtual bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
     capturers_[ssrc] = capturer;
     return true;
   }
-  bool HasCapturer(uint32 ssrc) const {
+  bool HasCapturer(uint32_t ssrc) const {
     return capturers_.find(ssrc) != capturers_.end();
   }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
       return false;
     renderers_[sp.first_ssrc()] = NULL;
     return true;
   }
-  virtual bool RemoveRecvStream(uint32 ssrc) {
+  virtual bool RemoveRecvStream(uint32_t ssrc) {
     if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
       return false;
     renderers_.erase(ssrc);
     return true;
   }
 
   virtual bool GetStats(VideoMediaInfo* info) { return false; }
   virtual bool SendIntraFrame() {
     sent_intra_frame_ = true;
     return true;
@@ skipping 33 matching lines @@
   bool SetOptions(const VideoOptions& options) {
     options_ = options;
     return true;
   }
   bool SetMaxSendBandwidth(int bps) {
     max_bps_ = bps;
     return true;
   }
 
   // Be default, each send stream uses the first send codec format.
-  void SetSendStreamDefaultFormat(uint32 ssrc) {
+  void SetSendStreamDefaultFormat(uint32_t ssrc) {
     if (!send_codecs_.empty()) {
       send_formats_[ssrc] = VideoFormat(
           send_codecs_[0].width, send_codecs_[0].height,
           cricket::VideoFormat::FpsToInterval(send_codecs_[0].framerate),
           cricket::FOURCC_I420);
     }
   }
 
   FakeVideoEngine* engine_;
   std::vector<VideoCodec> recv_codecs_;
   std::vector<VideoCodec> send_codecs_;
-  std::map<uint32, VideoRenderer*> renderers_;
-  std::map<uint32, VideoFormat> send_formats_;
-  std::map<uint32, VideoCapturer*> capturers_;
+  std::map<uint32_t, VideoRenderer*> renderers_;
+  std::map<uint32_t, VideoFormat> send_formats_;
+  std::map<uint32_t, VideoCapturer*> capturers_;
   bool sent_intra_frame_;
   bool requested_intra_frame_;
   VideoOptions options_;
   int max_bps_;
 };
 
 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
  public:
   explicit FakeDataMediaChannel(void* unused, const DataOptions& options)
       : send_blocked_(false), max_bps_(-1) {}
@@ skipping 13 matching lines @@
   virtual bool SetSend(bool send) { return set_sending(send); }
   virtual bool SetReceive(bool receive) {
     set_playout(receive);
     return true;
   }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (!RtpHelper<DataMediaChannel>::AddRecvStream(sp))
       return false;
     return true;
   }
-  virtual bool RemoveRecvStream(uint32 ssrc) {
+  virtual bool RemoveRecvStream(uint32_t ssrc) {
     if (!RtpHelper<DataMediaChannel>::RemoveRecvStream(ssrc))
       return false;
     return true;
   }
 
   virtual bool SendData(const SendDataParams& params,
                         const rtc::Buffer& payload,
                         SendDataResult* result) {
     if (send_blocked_) {
       *result = SDR_BLOCK;
@@ skipping 140 matching lines @@
     options_changed_ = true;
     return true;
   }
 
   int GetInputLevel() { return 0; }
 
   bool SetLocalMonitor(bool enable) { return true; }
 
   bool StartAecDump(rtc::PlatformFile file) { return false; }
 
-  bool RegisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
+  bool RegisterProcessor(uint32_t ssrc,
+                         VoiceProcessor* voice_processor,
                          MediaProcessorDirection direction) {
     if (direction == MPD_RX) {
       rx_processor_ = voice_processor;
       return true;
     } else if (direction == MPD_TX) {
       tx_processor_ = voice_processor;
       return true;
     }
     return false;
   }
 
-  bool UnregisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
+  bool UnregisterProcessor(uint32_t ssrc,
+                           VoiceProcessor* voice_processor,
                            MediaProcessorDirection direction) {
     bool unregistered = false;
     if (direction & MPD_RX) {
       rx_processor_ = NULL;
       unregistered = true;
     }
     if (direction & MPD_TX) {
       tx_processor_ = NULL;
       unregistered = true;
     }
@@ skipping 207 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_