Interface RTCRtpReceiver and RTCPeerConnection.getReceivers() added.

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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/peerconnection/RTCPeerConnection.h"
 
 #include <algorithm>
 #include <memory>
+#include <set>
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "bindings/modules/v8/RTCIceCandidateInitOrRTCIceCandidate.h"
 #include "bindings/modules/v8/V8MediaStreamTrack.h"
@@ skipping 15 matching lines @@
 #include "modules/mediastream/MediaStreamEvent.h"
 #include "modules/peerconnection/RTCAnswerOptions.h"
 #include "modules/peerconnection/RTCConfiguration.h"
 #include "modules/peerconnection/RTCDTMFSender.h"
 #include "modules/peerconnection/RTCDataChannel.h"
 #include "modules/peerconnection/RTCDataChannelEvent.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/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 1087 matching lines @@
   ExecutionContext* context = scriptState->getExecutionContext();
   UseCounter::count(context, UseCounter::RTCPeerConnectionGetStats);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   m_peerHandler->getStats(WebRTCStatsReportCallbackResolver::create(resolver));
 
   return promise;
 }
 
+HeapVector<Member<RTCRtpReceiver>> RTCPeerConnection::getReceivers() {
+  WebVector<std::unique_ptr<WebRTCRtpReceiver>> webRtpReceivers =
+      m_peerHandler->getReceivers();
+  HeapVector<Member<RTCRtpReceiver>> rtpReceivers(webRtpReceivers.size());
+  for (size_t i = 0; i < webRtpReceivers.size(); ++i) {
+    uintptr_t id = webRtpReceivers[i]->id();
+    const auto it = m_rtpReceivers.find(id);
+    if (it != m_rtpReceivers.end()) {
+      rtpReceivers[i] = it->value;
+    } else {
+      // There does not exist a JavaScript |RTCRtpReceiver| for this
+      // |WebRTCRtpReceiver| yet, create it.
+      MediaStreamTrack* track =
+          getRemoteTrackById(webRtpReceivers[i]->track().id());
+      DCHECK(track);
+      RTCRtpReceiver* rtpReceiver =
+          new RTCRtpReceiver(std::move(webRtpReceivers[i]), track);
+      m_rtpReceivers.insert(id, rtpReceiver);
+      rtpReceivers[i] = rtpReceiver;
+    }
+  }
+  return rtpReceivers;
+}
+
 RTCDataChannel* RTCPeerConnection::createDataChannel(
     ScriptState* scriptState,
     String label,
     const Dictionary& options,
     ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
     return nullptr;
 
   WebRTCDataChannelInit init;
   DictionaryHelper::get(options, "ordered", init.ordered);
@@ skipping 35 matching lines @@
 
 bool RTCPeerConnection::hasLocalStreamWithTrackId(const String& trackId) {
   for (MediaStreamVector::iterator iter = m_localStreams.begin();
        iter != m_localStreams.end(); ++iter) {
     if ((*iter)->getTrackById(trackId))
       return true;
   }
   return false;
 }
 
+MediaStreamTrack* RTCPeerConnection::getRemoteTrackById(
+    const String& trackId) const {
+  for (const auto& remoteStream : m_remoteStreams) {
+    MediaStreamTrack* track = remoteStream->getTrackById(trackId);
+    if (track)
+      return track;
+  }
+  return nullptr;
+}
+
+void RTCPeerConnection::removeInactiveReceivers() {
+  std::set<uintptr_t> inactiveReceiverIds;
+  for (uintptr_t id : m_rtpReceivers.keys()) {
+    inactiveReceiverIds.insert(id);
+  }
+  for (const auto& webRtpReceiver : m_peerHandler->getReceivers()) {
+    inactiveReceiverIds.erase(webRtpReceiver->id());
+  }
+  for (uintptr_t id : inactiveReceiverIds) {
+    m_rtpReceivers.erase(id);
+  }
+}
+
 RTCDTMFSender* RTCPeerConnection::createDTMFSender(
     MediaStreamTrack* track,
     ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
     return nullptr;
 
   DCHECK(track);
 
   if (!hasLocalStreamWithTrackId(track->id())) {
     exceptionState.throwDOMException(
@@ skipping 79 matching lines @@
   MediaStream* stream = static_cast<MediaStream*>(streamDescriptor->client());
   stream->streamEnded();
 
   if (m_signalingState == SignalingStateClosed)
     return;
 
   size_t pos = m_remoteStreams.find(stream);
   DCHECK(pos != kNotFound);
   m_remoteStreams.remove(pos);
 
+  // The receivers of removed tracks will have become inactive.
+  removeInactiveReceivers();
+
   scheduleDispatchEvent(
       MediaStreamEvent::create(EventTypeNames::removestream, stream));
 }
 
 void RTCPeerConnection::didAddRemoteDataChannel(
     WebRTCDataChannelHandler* handler) {
   DCHECK(!m_closed);
   DCHECK(getExecutionContext()->isContextThread());
 
   if (m_signalingState == SignalingStateClosed)
@@ skipping 152 matching lines @@
   }
 
   if (m_hasDataChannels)
     HostsUsingFeatures::countAnyWorld(
         *document, HostsUsingFeatures::Feature::RTCPeerConnectionDataChannel);
 }
 
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
+  visitor->trace(m_rtpReceivers);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink