Interface RTCRtpReceiver and RTCPeerConnection.getReceivers() added.

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

 /*
  * 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 23 matching lines @@
 #include <memory>
 #include "bindings/core/v8/ActiveScriptWrappable.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "core/dom/SuspendableObject.h"
 #include "modules/EventTargetModules.h"
 #include "modules/crypto/NormalizeAlgorithm.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/peerconnection/RTCIceCandidate.h"
 #include "platform/AsyncMethodRunner.h"
 #include "platform/WebFrameScheduler.h"
+#include "platform/heap/HeapAllocator.h"
 #include "public/platform/WebMediaConstraints.h"
 #include "public/platform/WebRTCPeerConnectionHandler.h"
 #include "public/platform/WebRTCPeerConnectionHandlerClient.h"
 
 namespace blink {
 class ExceptionState;
 class MediaStreamTrack;
 class RTCAnswerOptions;
 class RTCConfiguration;
 class RTCDTMFSender;
 class RTCDataChannel;
 class RTCIceCandidateInitOrRTCIceCandidate;
 class RTCOfferOptions;
 class RTCPeerConnectionErrorCallback;
+class RTCRtpReceiver;
 class RTCSessionDescription;
 class RTCSessionDescriptionCallback;
 class RTCSessionDescriptionInit;
 class RTCStatsCallback;
 class ScriptState;
 class VoidCallback;
 struct WebRTCConfiguration;
 
 class RTCPeerConnection final : public EventTargetWithInlineData,
                                 public WebRTCPeerConnectionHandlerClient,
@@ skipping 72 matching lines @@
                  const Dictionary& mediaConstraints,
                  ExceptionState&);
 
   void removeStream(MediaStream*, ExceptionState&);
 
   ScriptPromise getStats(ScriptState*,
                          RTCStatsCallback* successCallback,
                          MediaStreamTrack* selector = nullptr);
   ScriptPromise getStats(ScriptState*);
 
+  HeapVector<Member<RTCRtpReceiver>> getReceivers();
+
   RTCDataChannel* createDataChannel(ScriptState*,
                                     String label,
                                     const Dictionary& dataChannelDict,
                                     ExceptionState&);
 
   RTCDTMFSender* createDTMFSender(MediaStreamTrack*, ExceptionState&);
 
   void close(ExceptionState&);
 
   // We allow getStats after close, but not other calls or callbacks.
@@ skipping 56 matching lines @@
   RTCPeerConnection(ExecutionContext*,
                     const WebRTCConfiguration&,
                     WebMediaConstraints,
                     ExceptionState&);
   void dispose();
 
   void scheduleDispatchEvent(Event*);
   void scheduleDispatchEvent(Event*, std::unique_ptr<BoolFunction>);
   void dispatchScheduledEvent();
   bool hasLocalStreamWithTrackId(const String& trackId);
+  MediaStreamTrack* getRemoteTrackById(const String& trackId) const;
+  // Receivers returned by the handler are in use by the peer connection, a
+  // receiver that is no longer in use is permanently inactive and does not need
+  // to be referenced anymore. Removes such receivers from |m_rtpReceivers|.
+  void removeInactiveReceivers();
 
   void changeSignalingState(WebRTCPeerConnectionHandlerClient::SignalingState);
   void changeIceGatheringState(
       WebRTCPeerConnectionHandlerClient::ICEGatheringState);
   // Changes the state immediately; does not fire an event.
   // Returns true if the state was changed.
   bool setIceConnectionState(
       WebRTCPeerConnectionHandlerClient::ICEConnectionState);
   // Changes the state asynchronously and fires an event immediately after
   // changing the state.
   void changeIceConnectionState(
       WebRTCPeerConnectionHandlerClient::ICEConnectionState);
 
   void closeInternal();
 
   void recordRapporMetrics();
 
   SignalingState m_signalingState;
   ICEGatheringState m_iceGatheringState;
   ICEConnectionState m_iceConnectionState;
 
+  // TODO(hbos): Move away from "addStream" and "removeStream" in favor of
+  // "addTrack" and "removeTrack". Update tracks, senders and receivers on
+  // relevant events. https://crbug.com/705901
   MediaStreamVector m_localStreams;
   MediaStreamVector m_remoteStreams;
+  HeapHashMap<uintptr_t, Member<RTCRtpReceiver>> m_rtpReceivers;
 
   std::unique_ptr<WebRTCPeerConnectionHandler> m_peerHandler;
 
   Member<AsyncMethodRunner<RTCPeerConnection>> m_dispatchScheduledEventRunner;
   HeapVector<Member<EventWrapper>> m_scheduledEvents;
 
   // This handle notifies scheduler about an active connection associated
   // with a frame. Handle should be destroyed when connection is closed.
   std::unique_ptr<WebFrameScheduler::ActiveConnectionHandle>
       m_connectionHandleForScheduler;
 
   bool m_stopped;
   bool m_closed;
 
   bool m_hasDataChannels;  // For RAPPOR metrics
 };
 
 }  // namespace blink
 
 #endif  // RTCPeerConnection_h