Consolidate setters into SetRecvParameters.

talk/media/webrtc/webrtcvideoengine2.h

 /*
  * libjingle
  * Copyright 2014 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 176 matching lines @@
 
   void OnMessage(rtc::Message* msg) override;
 
   void OnLoadUpdate(Load load) override;
 
   // Implemented for VideoMediaChannelTest.
   bool sending() const { return sending_; }
   uint32_t GetDefaultSendChannelSsrc() { return default_send_ssrc_; }
 
  private:
+  class WebRtcVideoReceiveStream;
   struct VideoCodecSettings {
     VideoCodecSettings();
 
     bool operator==(const VideoCodecSettings& other) const;
     bool operator!=(const VideoCodecSettings& other) const;
 
     VideoCodec codec;
     webrtc::FecConfig fec;
     int rtx_payload_type;
   };
 
   struct ChangedSendParameters {
     // These optionals are unset if not changed.
     rtc::Optional<VideoCodecSettings> codec;
     rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
     rtc::Optional<int> max_bandwidth_bps;
     rtc::Optional<VideoOptions> options;
     rtc::Optional<webrtc::RtcpMode> rtcp_mode;
   };
+
+  struct ChangedRecvParameters {
+    // These optionals are unset if not changed.
+    rtc::Optional<std::vector<VideoCodecSettings>> codec_settings;
+    rtc::Optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
+    rtc::Optional<webrtc::RtcpMode> rtcp_mode;
+  };
+
   bool GetChangedSendParameters(const VideoSendParameters& params,
                                 ChangedSendParameters* changed_params) const;
+  bool GetChangedRecvParameters(const VideoRecvParameters& params,
+                                ChangedRecvParameters* changed_params) const;
+
   bool MuteStream(uint32_t ssrc, bool mute);
-  class WebRtcVideoReceiveStream;
 
   void SetMaxSendBandwidth(int bps);
   void SetOptions(const VideoOptions& options);
-  bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
-  bool SetRecvRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions);
 
   void ConfigureReceiverRtp(webrtc::VideoReceiveStream::Config* config,
                             const StreamParams& sp) const;
   bool CodecIsExternallySupported(const std::string& name) const;
   bool ValidateSendSsrcAvailability(const StreamParams& sp) const
       EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
   bool ValidateReceiveSsrcAvailability(const StreamParams& sp) const
       EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
   void DeleteReceiveStream(WebRtcVideoReceiveStream* stream)
       EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
@@ skipping 158 matching lines @@
         const std::vector<VideoCodecSettings>& recv_codecs,
         bool disable_prerenderer_smoothing);
     ~WebRtcVideoReceiveStream();
 
     const std::vector<uint32_t>& GetSsrcs() const;
 
     void SetLocalSsrc(uint32_t local_ssrc);
     void SetFeedbackParameters(bool nack_enabled,
                                bool remb_enabled,
                                bool transport_cc_enabled);
-    void SetRecvCodecs(const std::vector<VideoCodecSettings>& recv_codecs);
-    void SetRtpExtensions(const std::vector<webrtc::RtpExtension>& extensions);
-    // TODO(deadbeef): Move logic from SetRecvCodecs/SetRtpExtensions/etc.
-    // into this method. Currently this method only sets the RTCP mode.
-    void SetRecvParameters(const VideoRecvParameters& recv_params);
+    void SetRecvParameters(const ChangedRecvParameters& recv_params);
 
     void RenderFrame(const webrtc::VideoFrame& frame,
                      int time_to_render_ms) override;
     bool IsTextureSupported() const override;
     bool SmoothsRenderedFrames() const override;
     bool IsDefaultStream() const;
 
     void SetSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink);
 
     VideoReceiverInfo GetVideoReceiverInfo();
 
    private:
     struct AllocatedDecoder {
       AllocatedDecoder(webrtc::VideoDecoder* decoder,
                        webrtc::VideoCodecType type,
                        bool external);
       webrtc::VideoDecoder* decoder;
       // Decoder wrapped into a fallback decoder to permit software fallback.
       webrtc::VideoDecoder* external_decoder;
       webrtc::VideoCodecType type;
       bool external;
     };
 
     void RecreateWebRtcStream();
 
+    void ConfigureCodecs(const std::vector<VideoCodecSettings>& recv_codecs,
+                         std::vector<AllocatedDecoder>* old_codecs);
     AllocatedDecoder CreateOrReuseVideoDecoder(
         std::vector<AllocatedDecoder>* old_decoder,
         const VideoCodec& codec);
     void ClearDecoders(std::vector<AllocatedDecoder>* allocated_decoders);
 
     std::string GetCodecNameFromPayloadType(int payload_type);
 
     webrtc::Call* const call_;
     const std::vector<uint32_t> ssrcs_;
     const std::vector<SsrcGroup> ssrc_groups_;
@@ skipping 82 matching lines @@
   VideoOptions options_;
   // TODO(deadbeef): Don't duplicate information between
   // send_params/recv_params, rtp_extensions, options, etc.
   VideoSendParameters send_params_;
   VideoRecvParameters recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_H_