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 1092 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

[foolip, 2017/03/29 10:07:58]

The RTCRtpReceiver is still not the JavaScript object, there's an additional
V8RTCRtpReceiver wrapping it and then I'm not sure if there's another layer
before we get real to JavaScript objects or not. No mention of JavaScript here
is probably best :)

[hbos_chromium, 2017/03/29 13:50:13]

Done.

+      // |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