Adding reduced size RTCP configuration down to the video stream level.

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 149 matching lines @@
     int num_sim_layers;
   };
 
   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),
-        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) {
-  }
+  MediaContentDescription() {}
 
   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 76 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_;
-  int bandwidth_;
+  bool rtcp_mux_ = false;
+  bool rtcp_reduced_size_ = false;
+  int bandwidth_ = kAutoBandwidth;
   std::string protocol_;
   std::vector<CryptoParams> cryptos_;
-  CryptoType crypto_required_;
+  CryptoType crypto_required_ = CT_NONE;
   std::vector<RtpHeaderExtension> rtp_header_extensions_;
-  bool rtp_header_extensions_set_;
-  bool multistream_;
+  bool rtp_header_extensions_set_ = false;
+  bool multistream_ = false;
   StreamParamsVec streams_;
-  bool conference_mode_;
-  bool partial_;
-  int buffered_mode_latency_;
-  MediaContentDirection direction_;
+  bool conference_mode_ = false;
+  bool partial_ = false;
+  int buffered_mode_latency_ = kBufferedModeDisabled;
+  MediaContentDirection direction_ = MD_SENDRECV;
 };
 
 template <class C>
 class MediaContentDescriptionImpl : public MediaContentDescription {
  public:
   struct PreferenceSort {
     bool operator()(C a, C b) { return a.preference > b.preference; }
   };
 
   const std::vector<C>& codecs() const { return codecs_; }
@@ skipping 239 matching lines @@
 void GetSupportedVideoCryptoSuiteNames(
     std::vector<std::string>* crypto_suite_names);
 void GetSupportedDataCryptoSuiteNames(
     std::vector<std::string>* crypto_suite_names);
 void GetDefaultSrtpCryptoSuiteNames(
     std::vector<std::string>* crypto_suite_names);
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_MEDIASESSION_H_