Properly handle different transports having different SSL roles.

talk/app/webrtc/peerconnection.cc

 /*
  * 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 443 matching lines @@
   }
 
   if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio = (rtc_options.offer_to_receive_audio > 0);
   }
   if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video = (rtc_options.offer_to_receive_video > 0);
   }
 
   session_options->vad_enabled = rtc_options.voice_activity_detection;
-  session_options->transport_options.ice_restart = rtc_options.ice_restart;
+  session_options->audio_transport_options.ice_restart =
+      rtc_options.ice_restart;
+  session_options->video_transport_options.ice_restart =
+      rtc_options.ice_restart;
+  session_options->data_transport_options.ice_restart = rtc_options.ice_restart;
   session_options->bundle_enabled = rtc_options.use_rtp_mux;
 
   return true;
 }
 
 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
                                cricket::MediaSessionOptions* session_options) {
   bool value = false;
   size_t mandatory_constraints_satisfied = 0;
 
@@ skipping 25 matching lines @@
   if (FindConstraint(constraints, MediaConstraintsInterface::kUseRtpMux, &value,
                      &mandatory_constraints_satisfied)) {
     session_options->bundle_enabled = value;
   } else {
     // kUseRtpMux defaults to true according to spec.
     session_options->bundle_enabled = true;
   }
 
   if (FindConstraint(constraints, MediaConstraintsInterface::kIceRestart,
                      &value, &mandatory_constraints_satisfied)) {
-    session_options->transport_options.ice_restart = value;
+    session_options->audio_transport_options.ice_restart = value;
+    session_options->video_transport_options.ice_restart = value;
+    session_options->data_transport_options.ice_restart = value;
   } else {
     // kIceRestart defaults to false according to spec.
-    session_options->transport_options.ice_restart = false;
+    session_options->audio_transport_options.ice_restart = false;
+    session_options->video_transport_options.ice_restart = false;
+    session_options->data_transport_options.ice_restart = false;
   }
 
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers,
                      cricket::ServerAddresses* stun_servers,
@@ skipping 431 matching lines @@
   std::string error;
   if (!session_->SetLocalDescription(desc, &error)) {
     PostSetSessionDescriptionFailure(observer, error);
     return;
   }
 
   // If setting the description decided our SSL role, allocate any necessary
   // SCTP sids.
   rtc::SSLRole role;
   if (session_->data_channel_type() == cricket::DCT_SCTP &&
-      session_->GetSslRole(&role)) {
+      session_->data_channel() &&
+      session_->GetSslRole(session_->data_channel()->transport_name(), &role)) {

[pthatcher1, 2016/01/07 21:12:02]

Can you make a method so you can call like this?

session_->GetSslRole(session_->data_channel(), &role)?  That could be used in
three places here.

[Taylor Brandstetter, 2016/01/07 22:25:55]

This method will probably be refactored away when we support unified plan, but
sure.

     AllocateSctpSids(role);
   }
 
   // Update state and SSRC of local MediaStreams and DataChannels based on the
   // local session description.
   const cricket::ContentInfo* audio_content =
       GetFirstAudioContent(desc->description());
   if (audio_content) {
     if (audio_content->rejected) {
       RemoveTracks(cricket::MEDIA_TYPE_AUDIO);
@@ skipping 57 matching lines @@
   std::string error;
   if (!session_->SetRemoteDescription(desc, &error)) {
     PostSetSessionDescriptionFailure(observer, error);
     return;
   }
 
   // If setting the description decided our SSL role, allocate any necessary
   // SCTP sids.
   rtc::SSLRole role;
   if (session_->data_channel_type() == cricket::DCT_SCTP &&
-      session_->GetSslRole(&role)) {
+      session_->data_channel() &&
+      session_->GetSslRole(session_->data_channel()->transport_name(), &role)) {
     AllocateSctpSids(role);
   }
 
   const cricket::SessionDescription* remote_desc = desc->description();
   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
   const cricket::AudioContentDescription* audio_desc =
       GetFirstAudioContentDescription(remote_desc);
   const cricket::VideoContentDescription* video_desc =
       GetFirstVideoContentDescription(remote_desc);
@@ skipping 772 matching lines @@
   if (session_->data_channel_type() == cricket::DCT_NONE) {
     LOG(LS_ERROR)
         << "InternalCreateDataChannel: Data is not supported in this call.";
     return nullptr;
   }
   InternalDataChannelInit new_config =
       config ? (*config) : InternalDataChannelInit();
   if (session_->data_channel_type() == cricket::DCT_SCTP) {
     if (new_config.id < 0) {
       rtc::SSLRole role;
-      if (session_->GetSslRole(&role) &&
+      if ((session_->data_channel() &&
+           session_->GetSslRole(session_->data_channel()->transport_name(),
+                                &role)) &&
           !sid_allocator_.AllocateSid(role, &new_config.id)) {
         LOG(LS_ERROR) << "No id can be allocated for the SCTP data channel.";
         return nullptr;
       }
     } else if (!sid_allocator_.ReserveSid(new_config.id)) {
       LOG(LS_ERROR) << "Failed to create a SCTP data channel "
                     << "because the id is already in use or out of range.";
       return nullptr;
     }
   }
@@ skipping 160 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc