Introduce RtpStreamReceiver and RtpStreamReceiverControllerInterface.

webrtc/audio/audio_receive_stream.cc

Index: webrtc/audio/audio_receive_stream.cc
diff --git a/webrtc/audio/audio_receive_stream.cc b/webrtc/audio/audio_receive_stream.cc
index cb90a68a0f72e6898fe11726d31d2b99c9770c98..ac1f3038ae068bdced1410030fd224031049c1b6 100644
--- a/webrtc/audio/audio_receive_stream.cc
+++ b/webrtc/audio/audio_receive_stream.cc
@@ -20,6 +20,7 @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/call/rtp_stream_receiver_controller_interface.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
@@ -62,12 +63,12 @@ std::string AudioReceiveStream::Config::ToString() const {
 
 namespace internal {
 AudioReceiveStream::AudioReceiveStream(
+    RtpStreamReceiverControllerInterface* receiver_controller,
     PacketRouter* packet_router,
     const webrtc::AudioReceiveStream::Config& config,
     const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
     webrtc::RtcEventLog* event_log)
-    : config_(config),
-      audio_state_(audio_state) {
+    : config_(config), audio_state_(audio_state) {
   LOG(LS_INFO) << "AudioReceiveStream: " << config_.ToString();
   RTC_DCHECK_NE(config_.voe_channel_id, -1);
   RTC_DCHECK(audio_state_.get());
@@ -107,6 +108,10 @@ AudioReceiveStream::AudioReceiveStream(
   }
   // Configure bandwidth estimation.
   channel_proxy_->RegisterReceiverCongestionControlObjects(packet_router);
+
+  // Register with transport.
+  rtp_stream_receiver_ =

[the sun, 2017/06/16 13:37:39]

Exposing the controller to the stream so that it can register itself with it
feels somewhat questionable architecturally. Why does the stream need to own the
receiver?

Also, giving the receiver a pointer to "this" before the object is fully
constructed, is brittle even if it will work in this situation.

[nisse-webrtc, 2017/06/16 14:33:25]

The point is that the controller should own media-independent state, while the
receive stream should hook that up to any processing which depends on *both* rtp
and the media type.

The corresponding method on the video stream creates two receivers, one for
media and one for rtx, and the idea is that neither the controller or call
should need to know that's how we do video.
Who else should own the receiver(s)? In any case, we need to deregister from the
demuxer, and letting the receiver's destructor be responsible for that seems
reasonable to me (it was originally danil's suggestion, iirc).
It looks like we could pass channel_proxy_ instead, and delete the OnRtpPacket
method from this class. (But I think this way to use this is reasonable, even if
the subtleties could perhaps be better documented).

[the sun, 2017/06/16 15:00:13]

That sgtm.
I guess the Receiver could have shared ownership of the stream and be created
outside of the stream class. That would achieve the objective of decoupling the
transport layer from stream objects too. But very well...
No, please don't pass ChannelProxy. That's an interim solution.

[nisse-webrtc, 2017/06/19 07:21:01]

I did that change in ps#18. Please have a look, and tell me if you still want me
to undo that part. Note that this change is only about the internal division of
work between AudioReceiveStrean and ChannelProxy, and not in any other
interfaces. Whenever ChannelProxy is replaced by something else, the
CreateReceiver call needs to be updated with whatever is the replacement. 

ChannelProxy already has an OnRtpPacket method, to pass it to CreateReceiver all
that's needed is to tell the compiler it actually implements the
RtpPacketSinkInterface.

[the sun, 2017/06/20 07:11:36]

The problem is that it muddies the image of what ChannelProxy is - it is not
longer just a proxy for voe::Channel, mirroring what Channel provides. Now it is
an actor all of its own.

Please revert to the previous state.

+      receiver_controller->CreateReceiver(config_.rtp.remote_ssrc, this);
 }
 
 AudioReceiveStream::~AudioReceiveStream() {