RTCRtpSender with track behind RuntimeEnabled flag

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 40 matching lines @@
 class MediaStreamTrack;
 class RTCAnswerOptions;
 class RTCConfiguration;
 class RTCDTMFSender;
 class RTCDataChannel;
 class RTCDataChannelInit;
 class RTCIceCandidateInitOrRTCIceCandidate;
 class RTCOfferOptions;
 class RTCPeerConnectionErrorCallback;
 class RTCRtpReceiver;
+class RTCRtpSender;
 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& media_constraints,
                  ExceptionState&);
 
   void removeStream(MediaStream*, ExceptionState&);
 
   ScriptPromise getStats(ScriptState*,
                          RTCStatsCallback* success_callback,
                          MediaStreamTrack* selector = nullptr);
   ScriptPromise getStats(ScriptState*);
 
+  HeapVector<Member<RTCRtpSender>> getSenders();
   HeapVector<Member<RTCRtpReceiver>> getReceivers();
 
   RTCDataChannel* createDataChannel(ScriptState*,
                                     String label,
                                     const RTCDataChannelInit&,
                                     ExceptionState&);
 
   RTCDTMFSender* createDTMFSender(MediaStreamTrack*, ExceptionState&);
 
   void close(ExceptionState&);
@@ skipping 57 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& track_id);
+  MediaStreamTrack* GetLocalTrackById(const String& track_id) const;
   MediaStreamTrack* GetRemoteTrackById(const String& track_id) 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|.
+  // Senders and receivers returned by the handler are in use by the peer
+  // connection, a sender or receiver that is no longer in use is permanently
+  // inactive and does not need to be referenced anymore. These methods removes
+  // such senders/receivers from |rtp_senders_|/|rtp_receivers_|.
+  void RemoveInactiveSenders();
   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 signaling_state_;
   ICEGatheringState ice_gathering_state_;
   ICEConnectionState ice_connection_state_;
 
   // 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 local_streams_;
   MediaStreamVector remote_streams_;
+  HeapHashMap<uintptr_t, Member<RTCRtpSender>> rtp_senders_;
   HeapHashMap<uintptr_t, Member<RTCRtpReceiver>> rtp_receivers_;
 
   std::unique_ptr<WebRTCPeerConnectionHandler> peer_handler_;
 
   Member<AsyncMethodRunner<RTCPeerConnection>> dispatch_scheduled_event_runner_;
   HeapVector<Member<EventWrapper>> scheduled_events_;
 
   // 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>
       connection_handle_for_scheduler_;
 
   bool stopped_;
   bool closed_;
 
   bool has_data_channels_;  // For RAPPOR metrics
 };
 
 }  // namespace blink
 
 #endif  // RTCPeerConnection_h