Consolidate SetSendParameters into one setter.

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 110 matching lines @@
   // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does
   // not take the ownership of |decoder_factory|. The caller needs to make sure
   // that |decoder_factory| outlives the video engine.
   void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory);
   // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does
   // not take the ownership of |encoder_factory|. The caller needs to make sure
   // that |encoder_factory| outlives the video engine.
   virtual void SetExternalEncoderFactory(
       WebRtcVideoEncoderFactory* encoder_factory);
 
-  bool EnableTimedRender();
-
   bool FindCodec(const VideoCodec& in);
   // Check whether the supplied trace should be ignored.
   bool ShouldIgnoreTrace(const std::string& trace);
 
  private:
   std::vector<VideoCodec> GetSupportedCodecs() const;
 
   std::vector<VideoCodec> video_codecs_;
 
   bool initialized_;
@@ skipping 45 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:
+  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;
+    webrtc::RtcpMode rtcp_mode;
+  };
+  bool GetChangedSendParameters(const VideoSendParameters& params,
+                                ChangedSendParameters* changed_params) const;
   bool MuteStream(uint32_t ssrc, bool mute);
   class WebRtcVideoReceiveStream;
 
-  bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
-  bool SetSendRtpHeaderExtensions(
-      const std::vector<RtpHeaderExtension>& extensions);
-  bool SetMaxSendBandwidth(int bps);
-  bool SetOptions(const VideoOptions& options);
+  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_);
 
-  struct VideoCodecSettings {
-    VideoCodecSettings();
-
-    bool operator==(const VideoCodecSettings& other) const;
-    bool operator!=(const VideoCodecSettings& other) const;
-
-    VideoCodec codec;
-    webrtc::FecConfig fec;
-    int rtx_payload_type;
-  };
-
   static std::string CodecSettingsVectorToString(
       const std::vector<VideoCodecSettings>& codecs);
 
   // Wrapper for the sender part, this is where the capturer is connected and
   // frames are then converted from cricket frames to webrtc frames.
   class WebRtcVideoSendStream : public sigslot::has_slots<> {
    public:
     WebRtcVideoSendStream(
         webrtc::Call* call,
         const StreamParams& sp,
         const webrtc::VideoSendStream::Config& config,
         WebRtcVideoEncoderFactory* external_encoder_factory,
         const VideoOptions& options,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings,
         const std::vector<webrtc::RtpExtension>& rtp_extensions,
         const VideoSendParameters& send_params);
     ~WebRtcVideoSendStream();
 
     void SetOptions(const VideoOptions& options);
-    void SetCodec(const VideoCodecSettings& codec);
-    void SetRtpExtensions(
-        const std::vector<webrtc::RtpExtension>& rtp_extensions);
-    // TODO(deadbeef): Move logic from SetCodec/SetRtpExtensions/etc.
-    // into this method. Currently this method only sets the RTCP mode.
-    void SetSendParameters(const VideoSendParameters& send_params);
+    // TODO(pbos): Move logic from SetOptions into this method.
+    void SetSendParameters(const ChangedSendParameters& send_params);
 
     void InputFrame(VideoCapturer* capturer, const VideoFrame* frame);
     bool SetCapturer(VideoCapturer* capturer);
     bool SetVideoFormat(const VideoFormat& format);
     void MuteStream(bool mute);
     bool DisconnectCapturer();
 
-    void SetApplyRotation(bool apply_rotation);
-
     void Start();
     void Stop();
 
     const std::vector<uint32_t>& GetSsrcs() const;
     VideoSenderInfo GetVideoSenderInfo();
     void FillBandwidthEstimationInfo(BandwidthEstimationInfo* bwe_info);
 
-    void SetMaxBitrateBps(int max_bitrate_bps);
-
    private:
     // Parameters needed to reconstruct the underlying stream.
     // webrtc::VideoSendStream doesn't support setting a lot of options on the
     // fly, so when those need to be changed we tear down and reconstruct with
     // similar parameters depending on which options changed etc.
     struct VideoSendStreamParameters {
       VideoSendStreamParameters(
           const webrtc::VideoSendStream::Config& config,
           const VideoOptions& options,
           int max_bitrate_bps,
@@ skipping 69 matching lines @@
 
     const std::vector<uint32_t> ssrcs_;
     const std::vector<SsrcGroup> ssrc_groups_;
     webrtc::Call* const call_;
     WebRtcVideoEncoderFactory* const external_encoder_factory_
         GUARDED_BY(lock_);
 
     rtc::CriticalSection lock_;
     webrtc::VideoSendStream* stream_ GUARDED_BY(lock_);
     VideoSendStreamParameters parameters_ GUARDED_BY(lock_);
+    bool pending_encoder_reconfiguration_ GUARDED_BY(lock_);
     VideoEncoderSettings encoder_settings_ GUARDED_BY(lock_);
     AllocatedEncoder allocated_encoder_ GUARDED_BY(lock_);
     Dimensions last_dimensions_ GUARDED_BY(lock_);
 
     VideoCapturer* capturer_ GUARDED_BY(lock_);
     bool sending_ GUARDED_BY(lock_);
     bool muted_ GUARDED_BY(lock_);
     VideoFormat format_ GUARDED_BY(lock_);
     int old_adapt_changes_ GUARDED_BY(lock_);
 
@@ skipping 152 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_