Adding support for Unified Plan offer/answer negotiation.

webrtc/pc/webrtcsessiondescriptionfactory.cc

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 12 matching lines @@
 
 namespace webrtc {
 namespace {
 static const char kFailedDueToIdentityFailed[] =
     " failed because DTLS identity request failed";
 static const char kFailedDueToSessionShutdown[] =
     " failed because the session was shut down";
 
 static const uint64_t kInitSessionVersion = 2;
 
-static bool CompareStream(const MediaSessionOptions::Stream& stream1,
-                          const MediaSessionOptions::Stream& stream2) {
-  return stream1.id < stream2.id;
+static bool CompareSenderOptions(const cricket::SenderOptions& sender1,
+                                 const cricket::SenderOptions& sender2) {
+  return sender1.track_id < sender2.track_id;
 }
 
-static bool SameId(const MediaSessionOptions::Stream& stream1,
-                   const MediaSessionOptions::Stream& stream2) {
-  return stream1.id == stream2.id;
+static bool SameId(const cricket::SenderOptions& sender1,
+                   const cricket::SenderOptions& sender2) {
+  return sender1.track_id == sender2.track_id;
 }
 
-// Checks if each Stream within the |streams| has unique id.
-static bool ValidStreams(const MediaSessionOptions::Streams& streams) {
-  MediaSessionOptions::Streams sorted_streams = streams;
-  std::sort(sorted_streams.begin(), sorted_streams.end(), CompareStream);
-  MediaSessionOptions::Streams::iterator it =
-      std::adjacent_find(sorted_streams.begin(), sorted_streams.end(),
-                         SameId);
-  return it == sorted_streams.end();
+// Check that each sender has a unique ID.
+static bool ValidMediaSessionOptions(
+    const cricket::MediaSessionOptions& session_options) {
+  std::vector<cricket::SenderOptions> sorted_senders;
+  for (const cricket::MediaDescriptionOptions& media_description_options :
+       session_options.media_description_options) {
+    sorted_senders.insert(sorted_senders.end(),
+                          media_description_options.sender_options.begin(),
+                          media_description_options.sender_options.end());
+  }
+  std::sort(sorted_senders.begin(), sorted_senders.end(), CompareSenderOptions);
+  std::vector<cricket::SenderOptions>::iterator it =
+      std::adjacent_find(sorted_senders.begin(), sorted_senders.end(), SameId);
+  return it == sorted_senders.end();
 }
 
 enum {
   MSG_CREATE_SESSIONDESCRIPTION_SUCCESS,
   MSG_CREATE_SESSIONDESCRIPTION_FAILED,
   MSG_USE_CONSTRUCTOR_CERTIFICATE
 };
 
 struct CreateSessionDescriptionMsg : public rtc::MessageData {
   explicit CreateSessionDescriptionMsg(
@@ skipping 60 matching lines @@
       // RFC 4566 suggested a Network Time Protocol (NTP) format timestamp
       // as the session id and session version. To simplify, it should be fine
       // to just use a random number as session id and start version from
       // |kInitSessionVersion|.
       session_version_(kInitSessionVersion),
       cert_generator_(std::move(cert_generator)),
       session_(session),
       session_id_(session_id),
       certificate_request_state_(CERTIFICATE_NOT_NEEDED) {
   RTC_DCHECK(signaling_thread_);
-  session_desc_factory_.set_add_legacy_streams(false);
   bool dtls_enabled = cert_generator_ || certificate;
   // SRTP-SDES is disabled if DTLS is on.
   SetSdesPolicy(dtls_enabled ? cricket::SEC_DISABLED : cricket::SEC_REQUIRED);
   if (!dtls_enabled) {
     LOG(LS_VERBOSE) << "DTLS-SRTP disabled.";
     return;
   }
 
   if (certificate) {
     // Use |certificate|.
@@ skipping 88 matching lines @@
     const PeerConnectionInterface::RTCOfferAnswerOptions& options,
     const cricket::MediaSessionOptions& session_options) {
   std::string error = "CreateOffer";
   if (certificate_request_state_ == CERTIFICATE_FAILED) {
     error += kFailedDueToIdentityFailed;
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
-  if (!ValidStreams(session_options.streams)) {
-    error += " called with invalid media streams.";
+  if (!ValidMediaSessionOptions(session_options)) {
+    error += " called with invalid session options";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
   CreateSessionDescriptionRequest request(
       CreateSessionDescriptionRequest::kOffer, observer, session_options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
@@ skipping 20 matching lines @@
     return;
   }
   if (session_->remote_description()->type() !=
       JsepSessionDescription::kOffer) {
     error += " failed because remote_description is not an offer.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
-  if (!ValidStreams(session_options.streams)) {
-    error += " called with invalid media streams.";
+  if (!ValidMediaSessionOptions(session_options)) {
+    error += " called with invalid session options.";
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
   CreateSessionDescriptionRequest request(
       CreateSessionDescriptionRequest::kAnswer, observer, session_options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
@@ skipping 39 matching lines @@
     }
     default:
       RTC_NOTREACHED();
       break;
   }
 }
 
 void WebRtcSessionDescriptionFactory::InternalCreateOffer(
     CreateSessionDescriptionRequest request) {
   if (session_->local_description()) {
-    for (const cricket::TransportInfo& transport :
-         session_->local_description()->description()->transport_infos()) {
-      // If the needs-ice-restart flag is set as described by JSEP, we should
-      // generate an offer with a new ufrag/password to trigger an ICE restart.
-      if (session_->NeedsIceRestart(transport.content_name)) {
-        request.options.transport_options[transport.content_name].ice_restart =
-            true;
+    // If the needs-ice-restart flag is set as described by JSEP, we should
+    // generate an offer with a new ufrag/password to trigger an ICE restart.
+    for (cricket::MediaDescriptionOptions& options :
+         request.options.media_description_options) {
+      if (session_->NeedsIceRestart(options.mid)) {
+        options.transport_options.ice_restart = true;
       }
     }
   }
 
   cricket::SessionDescription* desc(session_desc_factory_.CreateOffer(
       request.options, session_->local_description()
                            ? session_->local_description()->description()
                            : nullptr));
   // RFC 3264
   // When issuing an offer that modifies the session,
   // the "o=" line of the new SDP MUST be identical to that in the
   // previous SDP, except that the version in the origin field MUST
   // increment by one from the previous SDP.
 
   // Just increase the version number by one each time when a new offer
   // is created regardless if it's identical to the previous one or not.
   // The |session_version_| is a uint64_t, the wrap around should not happen.
   RTC_DCHECK(session_version_ + 1 > session_version_);
   JsepSessionDescription* offer(new JsepSessionDescription(
       JsepSessionDescription::kOffer));
   if (!offer->Initialize(desc, session_id_,
                          rtc::ToString(session_version_++))) {
     delete offer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the offer.");
     return;
   }
   if (session_->local_description()) {
-    for (const cricket::ContentInfo& content :
-         session_->local_description()->description()->contents()) {
-      // Include all local ICE candidates in the SessionDescription unless
-      // an ICE restart was requested.
-      if (!request.options.transport_options[content.name].ice_restart) {
+    for (const cricket::MediaDescriptionOptions& options :
+         request.options.media_description_options) {
+      if (!options.transport_options.ice_restart) {
         CopyCandidatesFromSessionDescription(session_->local_description(),
-                                             content.name, offer);
+                                             options.mid, offer);
       }
     }
   }
   PostCreateSessionDescriptionSucceeded(request.observer, offer);
 }
 
 void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
     CreateSessionDescriptionRequest request) {
   if (session_->remote_description()) {
-    for (const cricket::ContentInfo& content :
-         session_->remote_description()->description()->contents()) {
+    for (cricket::MediaDescriptionOptions& options :
+         request.options.media_description_options) {
       // According to http://tools.ietf.org/html/rfc5245#section-9.2.1.1
       // an answer should also contain new ICE ufrag and password if an offer
       // has been received with new ufrag and password.
-      request.options.transport_options[content.name].ice_restart =
-          session_->IceRestartPending(content.name);
+      options.transport_options.ice_restart =
+          session_->IceRestartPending(options.mid);
       // We should pass the current SSL role to the transport description
       // factory, if there is already an existing ongoing session.
       rtc::SSLRole ssl_role;
-      if (session_->GetSslRole(content.name, &ssl_role)) {
-        request.options.transport_options[content.name].prefer_passive_role =
+      if (session_->GetSslRole(options.mid, &ssl_role)) {
+        options.transport_options.prefer_passive_role =
             (rtc::SSL_SERVER == ssl_role);
       }
     }
   }
 
   cricket::SessionDescription* desc(session_desc_factory_.CreateAnswer(
       session_->remote_description()
           ? session_->remote_description()->description()
           : nullptr,
       request.options, session_->local_description()
@@ skipping 10 matching lines @@
   JsepSessionDescription* answer(new JsepSessionDescription(
       JsepSessionDescription::kAnswer));
   if (!answer->Initialize(desc, session_id_,
                           rtc::ToString(session_version_++))) {
     delete answer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the answer.");
     return;
   }
   if (session_->local_description()) {
-    for (const cricket::ContentInfo& content :
-         session_->local_description()->description()->contents()) {
-      // Include all local ICE candidates in the SessionDescription unless
-      // the remote peer has requested an ICE restart.
-      if (!request.options.transport_options[content.name].ice_restart) {
+    // Include all local ICE candidates in the SessionDescription unless
+    // the remote peer has requested an ICE restart.
+    for (const cricket::MediaDescriptionOptions& options :
+         request.options.media_description_options) {
+      if (!options.transport_options.ice_restart) {
         CopyCandidatesFromSessionDescription(session_->local_description(),
-                                             content.name, answer);
+                                             options.mid, answer);
       }
     }
   }
   PostCreateSessionDescriptionSucceeded(request.observer, answer);
 }
 
 void WebRtcSessionDescriptionFactory::FailPendingRequests(
     const std::string& reason) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   while (!create_session_description_requests_.empty()) {
@@ skipping 48 matching lines @@
     if (create_session_description_requests_.front().type ==
         CreateSessionDescriptionRequest::kOffer) {
       InternalCreateOffer(create_session_description_requests_.front());
     } else {
       InternalCreateAnswer(create_session_description_requests_.front());
     }
     create_session_description_requests_.pop();
   }
 }
 }  // namespace webrtc