Add support for negotiating RTCP with reduced size.

talk/session/media/mediasession.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 151 matching lines @@
 
   typedef std::vector<Stream> Streams;
   Streams streams;
 };
 
 // "content" (as used in XEP-0166) descriptions for voice and video.
 class MediaContentDescription : public ContentDescription {
  public:
   MediaContentDescription()
       : rtcp_mux_(false),
+        rtcp_reduced_size_(false),
         bandwidth_(kAutoBandwidth),
         crypto_required_(CT_NONE),
         rtp_header_extensions_set_(false),
         multistream_(false),
         conference_mode_(false),
         partial_(false),
         buffered_mode_latency_(kBufferedModeDisabled),
-        direction_(MD_SENDRECV) {
-  }
+        direction_(MD_SENDRECV) {}
 
   virtual MediaType type() const = 0;
   virtual bool has_codecs() const = 0;
 
   // |protocol| is the expected media transport protocol, such as RTP/AVPF,
   // RTP/SAVPF or SCTP/DTLS.
   std::string protocol() const { return protocol_; }
   void set_protocol(const std::string& protocol) { protocol_ = protocol; }
 
   MediaContentDirection direction() const { return direction_; }
   void set_direction(MediaContentDirection direction) {
     direction_ = direction;
   }
 
   bool rtcp_mux() const { return rtcp_mux_; }
   void set_rtcp_mux(bool mux) { rtcp_mux_ = mux; }
 
+  bool rtcp_reduced_size() const { return rtcp_reduced_size_; }
+  void set_rtcp_reduced_size(bool reduced_size) {
+    rtcp_reduced_size_ = reduced_size;
+  }
+
   int bandwidth() const { return bandwidth_; }
   void set_bandwidth(int bandwidth) { bandwidth_ = bandwidth; }
 
   const std::vector<CryptoParams>& cryptos() const { return cryptos_; }
   void AddCrypto(const CryptoParams& params) {
     cryptos_.push_back(params);
   }
   void set_cryptos(const std::vector<CryptoParams>& cryptos) {
     cryptos_ = cryptos;
   }
@@ skipping 77 matching lines @@
   void set_partial(bool partial) { partial_ = partial; }
   bool partial() const { return partial_;  }
 
   void set_buffered_mode_latency(int latency) {
     buffered_mode_latency_ = latency;
   }
   int buffered_mode_latency() const { return buffered_mode_latency_; }
 
  protected:
   bool rtcp_mux_;
+  bool rtcp_reduced_size_;
   int bandwidth_;
   std::string protocol_;
   std::vector<CryptoParams> cryptos_;
   CryptoType crypto_required_;
   std::vector<RtpHeaderExtension> rtp_header_extensions_;
   bool rtp_header_extensions_set_;
   bool multistream_;
   StreamParamsVec streams_;
   bool conference_mode_;
   bool partial_;
@@ skipping 261 matching lines @@
 bool GetMediaTypeFromChannelName(
     const std::string& channel_name, cricket::MediaType* media_type);
 
 void GetSupportedAudioCryptoSuites(std::vector<std::string>* crypto_suites);
 void GetSupportedVideoCryptoSuites(std::vector<std::string>* crypto_suites);
 void GetSupportedDataCryptoSuites(std::vector<std::string>* crypto_suites);
 void GetSupportedDefaultCryptoSuites(std::vector<std::string>* crypto_suites);
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_MEDIASESSION_H_