Move receive RtpRtcp ownership from ViEChannel to ViEReceiver.

webrtc/video/vie_channel.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 54 matching lines @@
              ProcessThread* module_process_thread,
              VideoCodingModule* vcm,
              RemoteBitrateEstimator* remote_bitrate_estimator,
              RtcpRttStats* rtt_stats,
              PacedSender* paced_sender,
              PacketRouter* packet_router);
   ~ViEChannel();
 
   int32_t Init();
 
+  RtpRtcp* rtp_rtcp() const { return vie_receiver_.rtp_rtcp(); }

[pbos-webrtc, 2016/04/22 15:16:58]

return rtp_rtcp_ right?

[mflodman, 2016/04/25 07:03:22]

Done.

+
   void SetProtectionMode(bool enable_nack,
                          bool enable_fec,
                          int payload_type_red,
                          int payload_type_fec);
 
   RtpState GetRtpStateForSsrc(uint32_t ssrc) const;
 
   // Implements RtpFeedback.
   int32_t OnInitializeDecoder(const int8_t payload_type,
                               const char payload_name[RTP_PAYLOAD_NAME_SIZE],
                               const int frequency,
                               const size_t channels,
                               const uint32_t rate) override;
   void OnIncomingSSRCChanged(const uint32_t ssrc) override;
   void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override;
 
   // Gets the module used by the channel.
-  RtpRtcp* rtp_rtcp() const;
   ViEReceiver* vie_receiver();
 
   CallStatsObserver* GetStatsObserver();
 
   // Implements VCMReceiveCallback.
   virtual int32_t FrameToRender(VideoFrame& video_frame);  // NOLINT
 
   // Implements VCMReceiveCallback.
   virtual int32_t ReceivedDecodedReferenceFrame(
       const uint64_t picture_id);
@@ skipping 40 matching lines @@
 
  private:
   // Assumed to be protected.
   void StartDecodeThread();
   void StopDecodeThread();
 
   void ProcessNACKRequest(const bool enable);
   // Compute NACK list parameters for the buffering mode.
   int GetRequiredNackListSize(int target_delay_ms);
 
-  // ViEChannel exposes methods that allow to modify observers and callbacks
-  // to be modified. Such an API-style is cumbersome to implement and maintain
-  // at all the levels when comparing to only setting them at construction. As
-  // so this class instantiates its children with a wrapper that can be modified
-  // at a later time.
-  template <class T>
-  class RegisterableCallback : public T {
-   public:
-    RegisterableCallback() : callback_(nullptr) {}
-
-    void Set(T* callback) {
-      rtc::CritScope lock(&critsect_);
-      callback_ = callback;
-    }
-
-   protected:
-    // Note: this should be implemented with a RW-lock to allow simultaneous
-    // calls into the callback. However that doesn't seem to be needed for the
-    // current type of callbacks covered by this class.
-    rtc::CriticalSection critsect_;
-    T* callback_ GUARDED_BY(critsect_);
-
-   private:
-    RTC_DISALLOW_COPY_AND_ASSIGN(RegisterableCallback);
-  };
-
-  class RegisterableRtcpPacketTypeCounterObserver
-      : public RegisterableCallback<RtcpPacketTypeCounterObserver> {
-   public:
-    void RtcpPacketTypesCounterUpdated(
-        uint32_t ssrc,
-        const RtcpPacketTypeCounter& packet_counter) override {
-      rtc::CritScope lock(&critsect_);
-      if (callback_)
-        callback_->RtcpPacketTypesCounterUpdated(ssrc, packet_counter);
-    }
-
-   private:
-  } rtcp_packet_type_counter_observer_;
-
-
   ProcessThread* const module_process_thread_;
 
   // Used for all registered callbacks except rendering.
   rtc::CriticalSection crit_;
 
   VideoCodingModule* const vcm_;
   ViEReceiver vie_receiver_;
+  RtpRtcp* const rtp_rtcp_;
 
   // Helper to report call statistics.
   std::unique_ptr<ChannelStatsObserver> stats_observer_;
 
   // Not owned.
   ReceiveStatisticsProxy* receive_stats_callback_ GUARDED_BY(crit_);
   FrameCounts receive_frame_counts_ GUARDED_BY(crit_);
   IncomingVideoStream* incoming_video_stream_ GUARDED_BY(crit_);
-  RtcpRttStats* const rtt_stats_;
-  PacedSender* const paced_sender_;
-  PacketRouter* const packet_router_;
 
   int max_nack_reordering_threshold_;
   I420FrameCallback* pre_render_callback_ GUARDED_BY(crit_);
 
   int64_t last_rtt_ms_ GUARDED_BY(crit_);
-
-  // RtpRtcp module, declared last as it use other members on construction.
-  const std::unique_ptr<RtpRtcp> rtp_rtcp_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_VIE_CHANNEL_H_