RTCPeerConnectionHandler: Unified Plan implementation.

This implements creating, updating and surfacing transceivers from the
content layer. This is in preparation for the blink layer to implement
its part, but split up for the sake of reviewability. For the big
picture, see:
https://chromium-review.googlesource.com/c/chromium/src/+/1138615

Because the blink layer is needed to surface the transceivers to
JavaScript, and because the codepaths are tested by LayoutTests, the
new code in this CL is not yet exercised or tested, as is ensured by
NOTREACHED(). Follow-up CLs will exercise the code in this CL.

This CL updates the following operations in RTCPeerConnectionHandler to
support both Plan B and Unified Plan once the new codepaths are
unlocked:
- AddTrack()
- RemoveTrack()
- SetLocalDescription()
- SetRemoteDescription()

The only operation missing in AddTransceiver(), to be added separately.

Bug: 777617
Change-Id: I225cf1d903e95e488599d6735b09a57aa2b279bb
Reviewed-on: https://chromium-review.googlesource.com/1141952
Commit-Queue: Henrik Boström <hbos@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#576286}

content/renderer/media/webrtc/mock_web_rtc_peer_connection_handler_client.h

@@ -14,6 +14,7 @@
 #include "third_party/blink/public/platform/web_rtc_ice_candidate.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler_client.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_receiver.h"
+#include "third_party/blink/public/platform/web_rtc_rtp_transceiver.h"
 
 namespace content {
 
@@ -39,6 +40,12 @@ class MockWebRTCPeerConnectionHandlerClient
       std::unique_ptr<blink::WebRTCRtpReceiver> web_rtp_receiver) override {
     DidRemoveReceiverPlanBForMock(&web_rtp_receiver);
   }
+  void DidModifyTransceivers(
+      std::vector<std::unique_ptr<blink::WebRTCRtpTransceiver>>
+          web_transceivers,
+      bool is_remote_description) override {
+    DidModifyTransceiversForMock(&web_transceivers, is_remote_description);
+  }
   MOCK_METHOD1(DidAddRemoteDataChannel, void(blink::WebRTCDataChannelHandler*));
   MOCK_METHOD0(ReleasePeerConnectionHandler, void());
 
@@ -48,6 +55,9 @@ class MockWebRTCPeerConnectionHandlerClient
                void(std::unique_ptr<blink::WebRTCRtpReceiver>*));
   MOCK_METHOD1(DidRemoveReceiverPlanBForMock,
                void(std::unique_ptr<blink::WebRTCRtpReceiver>*));
+  MOCK_METHOD2(DidModifyTransceiversForMock,
+               void(std::vector<std::unique_ptr<blink::WebRTCRtpTransceiver>>*,
+                    bool));
 
   void didGenerateICECandidateWorker(
       scoped_refptr<blink::WebRTCICECandidate> candidate);

content/renderer/media/webrtc/rtc_peer_connection_handler.h

@@ -149,7 +149,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   webrtc::RTCErrorOr<std::unique_ptr<blink::WebRTCRtpTransceiver>> AddTrack(
       const blink::WebMediaStreamTrack& web_track,
       const blink::WebVector<blink::WebMediaStream>& web_streams) override;
-  bool RemoveTrack(blink::WebRTCRtpSender* web_sender) override;
+  webrtc::RTCErrorOr<std::unique_ptr<blink::WebRTCRtpTransceiver>> RemoveTrack(
+      blink::WebRTCRtpSender* web_sender) override;
 
   blink::WebRTCDataChannelHandler* CreateDataChannel(
       const blink::WebString& label,
@@ -202,6 +203,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   void OnRenegotiationNeeded();
   void OnAddReceiverPlanB(RtpReceiverState receiver_state);
   void OnRemoveReceiverPlanB(uintptr_t receiver_id);
+  void OnModifyTransceivers(std::vector<RtpTransceiverState> transceiver_states,
+                            bool is_remote_description);
   void OnDataChannel(std::unique_ptr<RtcDataChannelHandler> handler);
   void OnIceCandidate(const std::string& sdp,
                       const std::string& sdp_mid,
@@ -245,7 +248,18 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
       TransceiverStateSurfacer* transceiver_state_surfacer,
       webrtc::RTCErrorOr<rtc::scoped_refptr<webrtc::RtpSenderInterface>>*
           error_or_sender);
+  bool RemoveTrackPlanB(blink::WebRTCRtpSender* web_sender);
+  webrtc::RTCErrorOr<std::unique_ptr<blink::WebRTCRtpTransceiver>>
+  RemoveTrackUnifiedPlan(blink::WebRTCRtpSender* web_sender);
+  void RemoveTrackUnifiedPlanOnSignalingThread(
+      rtc::scoped_refptr<webrtc::RtpSenderInterface> sender,
+      TransceiverStateSurfacer* transceiver_state_surfacer,
+      bool* result);
   std::vector<std::unique_ptr<RTCRtpSender>>::iterator FindSender(uintptr_t id);
+  std::vector<std::unique_ptr<RTCRtpTransceiver>>::iterator FindTransceiver(
+      uintptr_t id);
+  std::unique_ptr<RTCRtpTransceiver> CreateOrUpdateTransceiver(
+      RtpTransceiverState transceiver_state);
 
   scoped_refptr<base::SingleThreadTaskRunner> signaling_thread() const;
 
@@ -296,6 +310,8 @@ class CONTENT_EXPORT RTCPeerConnectionHandler
   // corresponding content layer receivers. The set of receivers is needed in
   // order to keep its associated track's and streams' adapters alive.
   std::map<uintptr_t, std::unique_ptr<RTCRtpReceiver>> rtp_receivers_;
+  // Content layer correspondents of |webrtc::RtpTransceiverInterface|.
+  std::vector<std::unique_ptr<RTCRtpTransceiver>> rtp_transceivers_;
 
   base::WeakPtr<PeerConnectionTracker> peer_connection_tracker_;
 

content/renderer/media/webrtc/rtc_peer_connection_handler_unittest.cc

@@ -435,12 +435,12 @@ class RTCPeerConnectionHandlerTest : public ::testing::Test {
     // https://crbug.com/799030
     for (const auto& web_audio_track : web_stream.AudioTracks()) {
       auto it = FindSenderForTrack(web_audio_track);
-      if (it != senders_.end() && pc_handler_->RemoveTrack((*it).get()))
+      if (it != senders_.end() && pc_handler_->RemoveTrack((*it).get()).ok())
         senders_.erase(it);
     }
     for (const auto& web_video_track : web_stream.VideoTracks()) {
       auto it = FindSenderForTrack(web_video_track);
-      if (it != senders_.end() && pc_handler_->RemoveTrack((*it).get()))
+      if (it != senders_.end() && pc_handler_->RemoveTrack((*it).get()).ok())
         senders_.erase(it);
     }
     return senders_size_before_remove > senders_.size();

third_party/blink/public/platform/web_rtc_peer_connection_handler.h

@@ -105,9 +105,12 @@ class WebRTCPeerConnectionHandler {
   virtual webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>> AddTrack(
       const WebMediaStreamTrack&,
       const WebVector<WebMediaStream>&) = 0;
-  // Removes the sender, returning whether successful. On success, the sender's
-  // track must have been set to null.
-  virtual bool RemoveTrack(WebRTCRtpSender*) = 0;
+  // Removes the sender.
+  // In Plan B: Returns OK() with value nullptr on success. The sender's track
+  // must be nulled by the caller.
+  // In Unified Plan: Returns OK() with the updated transceiver state.
+  virtual webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>> RemoveTrack(
+      WebRTCRtpSender*) = 0;
   virtual void Stop() = 0;
 
   // Origin Trial - RtcPeerConnectionId

third_party/blink/public/platform/web_rtc_peer_connection_handler_client.h

@@ -42,6 +42,7 @@ namespace blink {
 class WebRTCDataChannelHandler;
 class WebRTCICECandidate;
 class WebRTCRtpReceiver;
+class WebRTCRtpTransceiver;
 
 class BLINK_PLATFORM_EXPORT WebRTCPeerConnectionHandlerClient {
  public:
@@ -74,6 +75,9 @@ class BLINK_PLATFORM_EXPORT WebRTCPeerConnectionHandlerClient {
   virtual void DidChangeICEConnectionState(ICEConnectionState) = 0;
   virtual void DidAddReceiverPlanB(std::unique_ptr<WebRTCRtpReceiver>) = 0;
   virtual void DidRemoveReceiverPlanB(std::unique_ptr<WebRTCRtpReceiver>) = 0;
+  virtual void DidModifyTransceivers(
+      std::vector<std::unique_ptr<WebRTCRtpTransceiver>>,
+      bool is_remote_description) = 0;
   virtual void DidAddRemoteDataChannel(WebRTCDataChannelHandler*) = 0;
   virtual void ReleasePeerConnectionHandler() = 0;
   virtual void ClosePeerConnection();

third_party/blink/renderer/modules/peerconnection/rtc_peer_connection.cc

@@ -1532,12 +1532,11 @@ void RTCPeerConnection::removeTrack(RTCRtpSender* sender,
     return;
   }
 
-  if (!peer_handler_->RemoveTrack(sender->web_sender())) {
+  auto error_or_transceiver = peer_handler_->RemoveTrack(sender->web_sender());
+  if (!error_or_transceiver.ok()) {
     // Operation aborted. This indicates that the sender is no longer used by
     // the peer connection, i.e. that it was removed due to setting a remote
     // description of type "rollback".
-    // Note: Until the WebRTC library supports re-using senders, a sender will
-    // also stop being used as a result of being removed.
     return;
   }
   // Successfully removing the track results in the sender's track property
@@ -1845,6 +1844,14 @@ void RTCPeerConnection::DidRemoveReceiverPlanB(
       MediaStreamSource::kReadyStateMuted);
 }
 
+void RTCPeerConnection::DidModifyTransceivers(
+    std::vector<std::unique_ptr<WebRTCRtpTransceiver>> web_transceiver,
+    bool is_remote_description) {
+  DCHECK_EQ(sdp_semantics_, WebRTCSdpSemantics::kUnifiedPlan);
+  // TODO(hbos): Exercise this codepath. https://crbug.com/777617
+  NOTREACHED();
+}
+
 void RTCPeerConnection::DidAddRemoteDataChannel(
     WebRTCDataChannelHandler* handler) {
   DCHECK(!closed_);

third_party/blink/renderer/modules/peerconnection/rtc_peer_connection.h

@@ -224,6 +224,8 @@ class MODULES_EXPORT RTCPeerConnection final
   void DidChangeICEConnectionState(ICEConnectionState) override;
   void DidAddReceiverPlanB(std::unique_ptr<WebRTCRtpReceiver>) override;
   void DidRemoveReceiverPlanB(std::unique_ptr<WebRTCRtpReceiver>) override;
+  void DidModifyTransceivers(std::vector<std::unique_ptr<WebRTCRtpTransceiver>>,
+                             bool is_remote_description) override;
   void DidAddRemoteDataChannel(WebRTCDataChannelHandler*) override;
   void ReleasePeerConnectionHandler() override;
   void ClosePeerConnection() override;

third_party/blink/renderer/platform/testing/testing_platform_support_with_web_rtc.cc

@@ -21,12 +21,15 @@ class DummyWebRTCRtpSender : public WebRTCRtpSender {
   static uintptr_t last_id_;
 
  public:
-  DummyWebRTCRtpSender() : id_(++last_id_) {}
+  DummyWebRTCRtpSender(WebMediaStreamTrack track)
+      : id_(++last_id_), track_(std::move(track)) {}
   ~DummyWebRTCRtpSender() override {}
 
   uintptr_t Id() const override { return id_; }
-  WebMediaStreamTrack Track() const override { return WebMediaStreamTrack(); }
-  WebVector<WebString> StreamIds() const override { return {}; }
+  WebMediaStreamTrack Track() const override { return track_; }
+  WebVector<WebString> StreamIds() const override {
+    return std::vector<WebString>({WebString::FromUTF8("DummyStringId")});
+  }
   void ReplaceTrack(WebMediaStreamTrack, WebRTCVoidRequest) override {}
   std::unique_ptr<WebRTCDTMFSenderHandler> GetDtmfSender() const override {
     return nullptr;
@@ -39,15 +42,19 @@ class DummyWebRTCRtpSender : public WebRTCRtpSender {
                      WebRTCVoidRequest) override {}
   void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>) override {}
 
+  void set_track(WebMediaStreamTrack track) { track_ = std::move(track); }
+
  private:
   const uintptr_t id_;
+  WebMediaStreamTrack track_;
 };
 
 uintptr_t DummyWebRTCRtpSender::last_id_ = 0;
 
 class DummyRTCRtpTransceiver : public WebRTCRtpTransceiver {
  public:
-  DummyRTCRtpTransceiver() {}
+  DummyRTCRtpTransceiver(WebMediaStreamTrack track)
+      : track_(std::move(track)) {}
   ~DummyRTCRtpTransceiver() override {}
 
   WebRTCRtpTransceiverImplementationType ImplementationType() const override {
@@ -56,7 +63,7 @@ class DummyRTCRtpTransceiver : public WebRTCRtpTransceiver {
   uintptr_t Id() const override { return 0u; }
   WebString Mid() const override { return WebString(); }
   std::unique_ptr<WebRTCRtpSender> Sender() const override {
-    return std::make_unique<DummyWebRTCRtpSender>();
+    return std::make_unique<DummyWebRTCRtpSender>(track_);
   }
   std::unique_ptr<WebRTCRtpReceiver> Receiver() const override {
     return nullptr;
@@ -74,6 +81,9 @@ class DummyRTCRtpTransceiver : public WebRTCRtpTransceiver {
       const override {
     return base::nullopt;
   }
+
+ private:
+  WebMediaStreamTrack track_;
 };
 
 }  // namespace
@@ -131,15 +141,17 @@ void MockWebRTCPeerConnectionHandler::GetStats(
     std::unique_ptr<WebRTCStatsReportCallback>) {}
 
 webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>>
-MockWebRTCPeerConnectionHandler::AddTrack(const WebMediaStreamTrack&,
+MockWebRTCPeerConnectionHandler::AddTrack(const WebMediaStreamTrack& track,
                                           const WebVector<WebMediaStream>&) {
   std::unique_ptr<WebRTCRtpTransceiver> transceiver =
-      std::make_unique<DummyRTCRtpTransceiver>();
+      std::make_unique<DummyRTCRtpTransceiver>(track);
   return transceiver;
 }
 
-bool MockWebRTCPeerConnectionHandler::RemoveTrack(WebRTCRtpSender*) {
-  return true;
+webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>>
+MockWebRTCPeerConnectionHandler::RemoveTrack(WebRTCRtpSender* sender) {
+  static_cast<DummyWebRTCRtpSender*>(sender)->set_track(WebMediaStreamTrack());
+  return std::unique_ptr<WebRTCRtpTransceiver>(nullptr);
 }
 
 WebRTCDataChannelHandler* MockWebRTCPeerConnectionHandler::CreateDataChannel(

third_party/blink/renderer/platform/testing/testing_platform_support_with_web_rtc.h

@@ -40,7 +40,8 @@ class MockWebRTCPeerConnectionHandler : public WebRTCPeerConnectionHandler {
   webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>> AddTrack(
       const WebMediaStreamTrack&,
       const WebVector<WebMediaStream>&) override;
-  bool RemoveTrack(WebRTCRtpSender*) override;
+  webrtc::RTCErrorOr<std::unique_ptr<WebRTCRtpTransceiver>> RemoveTrack(
+      WebRTCRtpSender*) override;
   WebRTCDataChannelHandler* CreateDataChannel(
       const WebString& label,
       const WebRTCDataChannelInit&) override;