RTCRtpSender with track behind RuntimeEnabled flag

third_party/WebKit/Source/modules/peerconnection/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * 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
@@ skipping 50 matching lines @@
 #include "modules/peerconnection/RTCConfiguration.h"
 #include "modules/peerconnection/RTCDTMFSender.h"
 #include "modules/peerconnection/RTCDataChannel.h"
 #include "modules/peerconnection/RTCDataChannelEvent.h"
 #include "modules/peerconnection/RTCDataChannelInit.h"
 #include "modules/peerconnection/RTCIceServer.h"
 #include "modules/peerconnection/RTCOfferOptions.h"
 #include "modules/peerconnection/RTCPeerConnectionErrorCallback.h"
 #include "modules/peerconnection/RTCPeerConnectionIceEvent.h"
 #include "modules/peerconnection/RTCRtpReceiver.h"
+#include "modules/peerconnection/RTCRtpSender.h"
 #include "modules/peerconnection/RTCSessionDescription.h"
 #include "modules/peerconnection/RTCSessionDescriptionCallback.h"
 #include "modules/peerconnection/RTCSessionDescriptionInit.h"
 #include "modules/peerconnection/RTCSessionDescriptionRequestImpl.h"
 #include "modules/peerconnection/RTCSessionDescriptionRequestPromiseImpl.h"
 #include "modules/peerconnection/RTCStatsCallback.h"
 #include "modules/peerconnection/RTCStatsReport.h"
 #include "modules/peerconnection/RTCStatsRequestImpl.h"
 #include "modules/peerconnection/RTCVoidRequestImpl.h"
 #include "modules/peerconnection/RTCVoidRequestPromiseImpl.h"
@@ skipping 1035 matching lines @@
     return;
   }
 
   size_t pos = local_streams_.Find(stream);
   if (pos == kNotFound)
     return;
 
   local_streams_.erase(pos);
 
   peer_handler_->RemoveStream(stream->Descriptor());
+
+  // The senders of removed tracks will have become inactive.
+  RemoveInactiveSenders();
 }
 
 MediaStreamVector RTCPeerConnection::getLocalStreams() const {
   return local_streams_;
 }
 
 MediaStreamVector RTCPeerConnection::getRemoteStreams() const {
   return remote_streams_;
 }
 
@@ skipping 35 matching lines @@
   ExecutionContext* context = ExecutionContext::From(script_state);
   UseCounter::Count(context, UseCounter::kRTCPeerConnectionGetStats);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   peer_handler_->GetStats(WebRTCStatsReportCallbackResolver::Create(resolver));
 
   return promise;
 }
 
+HeapVector<Member<RTCRtpSender>> RTCPeerConnection::getSenders() {
+  WebVector<std::unique_ptr<WebRTCRtpSender>> web_rtp_senders =
+      peer_handler_->GetSenders();
+  HeapVector<Member<RTCRtpSender>> rtp_senders(web_rtp_senders.size());
+  for (size_t i = 0; i < web_rtp_senders.size(); ++i) {
+    uintptr_t id = web_rtp_senders[i]->Id();
+    const auto it = rtp_senders_.find(id);
+    if (it != rtp_senders_.end()) {
+      rtp_senders[i] = it->value;
+    } else {
+      // There does not exist an |RTCRtpSender| for this |WebRTCRtpSender|
+      // yet, create it.
+      MediaStreamTrack* track = nullptr;
+      if (web_rtp_senders[i]->Track()) {
+        track = GetLocalTrackById(web_rtp_senders[i]->Track()->Id());
+        DCHECK(track);
+      }
+      RTCRtpSender* rtp_sender =
+          new RTCRtpSender(std::move(web_rtp_senders[i]), track);
+      rtp_senders_.insert(id, rtp_sender);
+      rtp_senders[i] = rtp_sender;
+    }
+  }
+  return rtp_senders;
+}
+
 HeapVector<Member<RTCRtpReceiver>> RTCPeerConnection::getReceivers() {
   WebVector<std::unique_ptr<WebRTCRtpReceiver>> web_rtp_receivers =
       peer_handler_->GetReceivers();
   HeapVector<Member<RTCRtpReceiver>> rtp_receivers(web_rtp_receivers.size());
   for (size_t i = 0; i < web_rtp_receivers.size(); ++i) {
     uintptr_t id = web_rtp_receivers[i]->Id();
     const auto it = rtp_receivers_.find(id);
     if (it != rtp_receivers_.end()) {
       rtp_receivers[i] = it->value;
     } else {
@@ skipping 45 matching lines @@
   RTCDataChannel::ReadyState handler_state = channel->GetHandlerState();
   if (handler_state != RTCDataChannel::kReadyStateConnecting) {
     // There was an early state transition.  Don't miss it!
     channel->DidChangeReadyState(handler_state);
   }
   has_data_channels_ = true;
 
   return channel;
 }
 
-bool RTCPeerConnection::HasLocalStreamWithTrackId(const String& track_id) {
-  for (MediaStreamVector::iterator iter = local_streams_.begin();
-       iter != local_streams_.end(); ++iter) {
-    if ((*iter)->getTrackById(track_id))
-      return true;
+MediaStreamTrack* RTCPeerConnection::GetLocalTrackById(
+    const String& track_id) const {
+  for (const auto& local_stream : local_streams_) {
+    MediaStreamTrack* track = local_stream->getTrackById(track_id);
+    if (track)
+      return track;
   }
-  return false;
+  return nullptr;
 }
 
 MediaStreamTrack* RTCPeerConnection::GetRemoteTrackById(
     const String& track_id) const {
   for (const auto& remote_stream : remote_streams_) {
     MediaStreamTrack* track = remote_stream->getTrackById(track_id);
     if (track)
       return track;
   }
   return nullptr;
 }
 
+void RTCPeerConnection::RemoveInactiveSenders() {
+  std::set<uintptr_t> inactive_sender_ids;
+  for (uintptr_t id : rtp_senders_.Keys()) {
+    inactive_sender_ids.insert(id);
+  }
+  for (const auto& web_rtp_sender : peer_handler_->GetSenders()) {
+    inactive_sender_ids.erase(web_rtp_sender->Id());
+  }
+  for (uintptr_t id : inactive_sender_ids) {
+    rtp_senders_.erase(id);
+  }
+}
+
 void RTCPeerConnection::RemoveInactiveReceivers() {
   std::set<uintptr_t> inactive_receiver_ids;
   for (uintptr_t id : rtp_receivers_.Keys()) {
     inactive_receiver_ids.insert(id);
   }
   for (const auto& web_rtp_receiver : peer_handler_->GetReceivers()) {
     inactive_receiver_ids.erase(web_rtp_receiver->Id());
   }
   for (uintptr_t id : inactive_receiver_ids) {
     rtp_receivers_.erase(id);
   }
 }
 
 RTCDTMFSender* RTCPeerConnection::createDTMFSender(
     MediaStreamTrack* track,
     ExceptionState& exception_state) {
   if (ThrowExceptionIfSignalingStateClosed(signaling_state_, exception_state))
     return nullptr;
 
   DCHECK(track);
 
-  if (!HasLocalStreamWithTrackId(track->id())) {
+  if (!GetLocalTrackById(track->id())) {
     exception_state.ThrowDOMException(
         kSyntaxError, "No local stream is available for the track provided.");
     return nullptr;
   }
 
   RTCDTMFSender* dtmf_sender = RTCDTMFSender::Create(
       GetExecutionContext(), peer_handler_.get(), track, exception_state);
   if (exception_state.HadException())
     return nullptr;
   return dtmf_sender;
@@ skipping 247 matching lines @@
   }
 
   if (has_data_channels_)
     HostsUsingFeatures::CountAnyWorld(
         *document, HostsUsingFeatures::Feature::kRTCPeerConnectionDataChannel);
 }
 
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->Trace(local_streams_);
   visitor->Trace(remote_streams_);
+  visitor->Trace(rtp_senders_);
   visitor->Trace(rtp_receivers_);
   visitor->Trace(dispatch_scheduled_event_runner_);
   visitor->Trace(scheduled_events_);
   EventTargetWithInlineData::Trace(visitor);
   SuspendableObject::Trace(visitor);
 }
 
 }  // namespace blink