Fixing issue with default stream upon setting 2nd remote description.

talk/app/webrtc/peerconnection.h

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * 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 notice,
@@ skipping 140 matching lines @@
  protected:
   ~PeerConnection() override;
 
  private:
   struct TrackInfo {
     TrackInfo() : ssrc(0) {}
     TrackInfo(const std::string& stream_label,
               const std::string track_id,
               uint32_t ssrc)
         : stream_label(stream_label), track_id(track_id), ssrc(ssrc) {}
+    bool operator==(const TrackInfo& other) {
+      return this->stream_label == other.stream_label &&
+             this->track_id == other.track_id && this->ssrc == other.ssrc;
+    }
     std::string stream_label;
     std::string track_id;
     uint32_t ssrc;
   };
   typedef std::vector<TrackInfo> TrackInfos;
 
-  struct RemotePeerInfo {
-    RemotePeerInfo()
-        : msid_supported(false),
-          default_audio_track_needed(false),
-          default_video_track_needed(false) {}
-    // True if it has been discovered that the remote peer support MSID.
-    bool msid_supported;
-    // The remote peer indicates in the session description that audio will be
-    // sent but no MSID is given.
-    bool default_audio_track_needed;
-    // The remote peer indicates in the session description that video will be
-    // sent but no MSID is given.
-    bool default_video_track_needed;
-
-    bool IsDefaultMediaStreamNeeded() {
-      return !msid_supported &&
-             (default_audio_track_needed || default_video_track_needed);
-    }
-  };
-
   // Implements MessageHandler.
   void OnMessage(rtc::Message* msg) override;
 
   void CreateAudioReceiver(MediaStreamInterface* stream,
                            AudioTrackInterface* audio_track,
                            uint32_t ssrc);
   void CreateVideoReceiver(MediaStreamInterface* stream,
                            VideoTrackInterface* video_track,
                            uint32_t ssrc);
   void DestroyAudioReceiver(MediaStreamInterface* stream,
@@ skipping 46 matching lines @@
   // Returns a MediaSessionOptions struct with options decided by
   // |constraints|, the local MediaStreams and DataChannels.
   virtual bool GetOptionsForAnswer(
       const MediaConstraintsInterface* constraints,
       cricket::MediaSessionOptions* session_options);
 
   // Remove all local and remote tracks of type |media_type|.
   // Called when a media type is rejected (m-line set to port 0).
   void RemoveTracks(cricket::MediaType media_type);
 
-  // Makes sure a MediaStream Track is created for each StreamParam in
-  // |streams|. |media_type| is the type of the |streams| and can be either
-  // audio or video.
+  // Makes sure a MediaStreamTrack is created for each StreamParam in |streams|,
+  // and existing MediaStreamTracks are removed if there is no corresponding
+  // StreamParam. If |default_track_needed| is true, a default MediaStreamTrack
+  // is created if it doesn't exist; if false, it's removed if it exists.
+  // |media_type| is the type of the |streams| and can be either audio or video.
   // If a new MediaStream is created it is added to |new_streams|.
   void UpdateRemoteStreamsList(
       const std::vector<cricket::StreamParams>& streams,
+      bool default_track_needed,
       cricket::MediaType media_type,
       StreamCollection* new_streams);
 
   // Triggered when a remote track has been seen for the first time in a remote
   // session description. It creates a remote MediaStreamTrackInterface
   // implementation and triggers CreateAudioReceiver or CreateVideoReceiver.
   void OnRemoteTrackSeen(const std::string& stream_label,
                          const std::string& track_id,
                          uint32_t ssrc,
                          cricket::MediaType media_type);
 
   // Triggered when a remote track has been removed from a remote session
   // description. It removes the remote track with id |track_id| from a remote
   // MediaStream and triggers DestroyAudioReceiver or DestroyVideoReceiver.
   void OnRemoteTrackRemoved(const std::string& stream_label,
                             const std::string& track_id,
                             cricket::MediaType media_type);
 
   // Finds remote MediaStreams without any tracks and removes them from
   // |remote_streams_| and notifies the observer that the MediaStreams no longer
   // exist.
   void UpdateEndedRemoteMediaStreams();
 
-  void MaybeCreateDefaultStream();
-
   // Set the MediaStreamTrackInterface::TrackState to |kEnded| on all remote
   // tracks of type |media_type|.
   void EndRemoteTracks(cricket::MediaType media_type);
 
   // Loops through the vector of |streams| and finds added and removed
   // StreamParams since last time this method was called.
   // For each new or removed StreamParam, OnLocalTrackSeen or
   // OnLocalTrackRemoved is invoked.
   void UpdateLocalTracks(const std::vector<cricket::StreamParams>& streams,
                          cricket::MediaType media_type);
@@ skipping 90 matching lines @@
   TrackInfos remote_audio_tracks_;
   TrackInfos remote_video_tracks_;
   TrackInfos local_audio_tracks_;
   TrackInfos local_video_tracks_;
 
   SctpSidAllocator sid_allocator_;
   // label -> DataChannel
   std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_;
   std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_;
 
-  RemotePeerInfo remote_info_;
+  bool remote_peer_supports_msid_ = false;
   rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_;
 
   std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_;
   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_;
 
   // The session_ scoped_ptr is declared at the bottom of PeerConnection
   // because its destruction fires signals (such as VoiceChannelDestroyed)
   // which will trigger some final actions in PeerConnection...
   rtc::scoped_ptr<WebRtcSession> session_;
   // ... But stats_ depends on session_ so it should be destroyed even earlier.
   rtc::scoped_ptr<StatsCollector> stats_;
 };
 
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_PEERCONNECTION_H_