content::RTCRtpSenders/Receivers using track adapter references.

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 193 matching lines @@
   void Resume() override;
   void ContextDestroyed(ExecutionContext*) override;
 
   // ScriptWrappable
   // We keep the this object alive until either stopped or closed.
   bool HasPendingActivity() const final { return !closed_ && !stopped_; }
 
   DECLARE_VIRTUAL_TRACE();
 
  private:
   friend class RTCPeerConnectionTest;

[Guido Urdaneta, 2017/06/20 11:32:16]

Maybe I missed this on another review, but can you change this friend to
FRIEND_TEST_ALL_PREFIXES?

[Guido Urdaneta, 2017/06/20 11:47:42]

Note that you don't have to fix this (if there is anything to fix, that is)  on
this CL

[hbos_chromium, 2017/06/20 12:05:49]

Done: https://codereview.chromium.org/2944323002/

 
   typedef Function<bool()> BoolFunction;
   class EventWrapper : public GarbageCollectedFinalized<EventWrapper> {
    public:
     EventWrapper(Event*, std::unique_ptr<BoolFunction>);
     // Returns true if |m_setupFunction| returns true or it is null.
     // |m_event| will only be fired if setup() returns true;
     bool Setup();
 
     DECLARE_TRACE();
 
     Member<Event> event_;
 
    private:
     std::unique_ptr<BoolFunction> setup_function_;
   };
 
   RTCPeerConnection(ExecutionContext*,
                     const WebRTCConfiguration&,
                     WebMediaConstraints,
                     ExceptionState&);
   void Dispose();
 
   void ScheduleDispatchEvent(Event*);
   void ScheduleDispatchEvent(Event*, std::unique_ptr<BoolFunction>);
   void DispatchScheduledEvent();
   MediaStreamTrack* GetTrack(const WebMediaStreamTrack& web_track) const;
-  // 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_;
 
   MediaStreamVector local_streams_;
   MediaStreamVector remote_streams_;
   // A map containing any track that is in use by the peer connection. This
   // includes tracks of |local_streams_|, |remote_streams_|, |rtp_senders_| and
   // |rtp_receivers_|.
   HeapHashMap<WeakMember<MediaStreamComponent>, WeakMember<MediaStreamTrack>>
       tracks_;
-  HeapHashMap<uintptr_t, Member<RTCRtpSender>> rtp_senders_;
-  HeapHashMap<uintptr_t, Member<RTCRtpReceiver>> rtp_receivers_;
+  HeapHashMap<uintptr_t, WeakMember<RTCRtpSender>> rtp_senders_;
+  HeapHashMap<uintptr_t, WeakMember<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