Fixing some issues with the direction attribute of m-lines in offers.

talk/app/webrtc/webrtcsdp.cc

 /*
  * libjingle
  * Copyright 2011 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 250 matching lines @@
                         std::string* message);
 static void BuildCandidate(const std::vector<Candidate>& candidates,
                            std::string* message);
 static void BuildIceOptions(const std::vector<std::string>& transport_options,
                             std::string* message);
 static bool IsRtp(const std::string& protocol);
 static bool IsDtlsSctp(const std::string& protocol);
 static bool ParseSessionDescription(const std::string& message, size_t* pos,
                                     std::string* session_id,
                                     std::string* session_version,
-                                    bool* supports_msid,
                                     TransportDescription* session_td,
                                     RtpHeaderExtensions* session_extmaps,
                                     cricket::SessionDescription* desc,
                                     SdpParseError* error);
 static bool ParseGroupAttribute(const std::string& line,
                                 cricket::SessionDescription* desc,
                                 SdpParseError* error);
 static bool ParseMediaDescription(
     const std::string& message,
     const TransportDescription& session_td,
     const RtpHeaderExtensions& session_extmaps,
-    bool supports_msid,
     size_t* pos, cricket::SessionDescription* desc,
     std::vector<JsepIceCandidate*>* candidates,
     SdpParseError* error);
 static bool ParseContent(const std::string& message,
                          const MediaType media_type,
                          int mline_index,
                          const std::string& protocol,
                          const std::vector<int>& codec_preference,
                          size_t* pos,
                          std::string* content_name,
@@ skipping 597 matching lines @@
 bool SdpDeserialize(const std::string& message,
                     JsepSessionDescription* jdesc,
                     SdpParseError* error) {
   std::string session_id;
   std::string session_version;
   TransportDescription session_td("", "");
   RtpHeaderExtensions session_extmaps;
   cricket::SessionDescription* desc = new cricket::SessionDescription();
   std::vector<JsepIceCandidate*> candidates;
   size_t current_pos = 0;
-  bool supports_msid = false;
 
   // Session Description
   if (!ParseSessionDescription(message, &current_pos, &session_id,
-                               &session_version, &supports_msid, &session_td,
-                               &session_extmaps, desc, error)) {
+                               &session_version, &session_td, &session_extmaps,
+                               desc, error)) {
     delete desc;
     return false;
   }
 
   // Media Description
-  if (!ParseMediaDescription(message, session_td, session_extmaps,
-                             supports_msid, &current_pos, desc, &candidates,
-                             error)) {
+  if (!ParseMediaDescription(message, session_td, session_extmaps, &current_pos,
+                             desc, &candidates, error)) {
     delete desc;
     for (std::vector<JsepIceCandidate*>::const_iterator
          it = candidates.begin(); it != candidates.end(); ++it) {
       delete *it;
     }
     return false;
   }
 
   jdesc->Initialize(desc, session_id, session_version);
 
@@ skipping 447 matching lines @@
   // implementation uses all media level.
   for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
     InitAttrLine(kAttributeExtmap, &os);
     os << kSdpDelimiterColon << media_desc->rtp_header_extensions()[i].id
        << kSdpDelimiterSpace << media_desc->rtp_header_extensions()[i].uri;
     AddLine(os.str(), message);
   }
 
   // RFC 3264
   // a=sendrecv || a=sendonly || a=sendrecv || a=inactive
-
-  cricket::MediaContentDirection direction = media_desc->direction();
-  if (media_desc->streams().empty() && direction == cricket::MD_SENDRECV) {
-    direction = cricket::MD_RECVONLY;
-  }
-
-  switch (direction) {
+  switch (media_desc->direction()) {
     case cricket::MD_INACTIVE:
       InitAttrLine(kAttributeInactive, &os);
       break;
     case cricket::MD_SENDONLY:
       InitAttrLine(kAttributeSendOnly, &os);
       break;
     case cricket::MD_RECVONLY:
       InitAttrLine(kAttributeRecvOnly, &os);
       break;
     case cricket::MD_SENDRECV:
@@ skipping 392 matching lines @@
 }
 
 bool IsDtlsSctp(const std::string& protocol) {
   // This intentionally excludes "SCTP" and "SCTP/DTLS".
   return protocol.find(cricket::kMediaProtocolDtlsSctp) != std::string::npos;
 }
 
 bool ParseSessionDescription(const std::string& message, size_t* pos,
                              std::string* session_id,
                              std::string* session_version,
-                             bool* supports_msid,
                              TransportDescription* session_td,
                              RtpHeaderExtensions* session_extmaps,
                              cricket::SessionDescription* desc,
                              SdpParseError* error) {
   std::string line;
 
+  desc->set_msid_supported(false);
+
   // RFC 4566
   // v=  (protocol version)
   if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
     return ParseFailedExpectLine(message, *pos, kLineTypeVersion,
                                  std::string(), error);
   }
   // RFC 4566
   // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
   // <unicast-address>
   if (!GetLineWithType(message, pos, &line, kLineTypeOrigin)) {
@@ skipping 111 matching lines @@
       session_td->identity_fingerprint.reset(fingerprint);
     } else if (HasAttribute(line, kAttributeSetup)) {
       if (!ParseDtlsSetup(line, &(session_td->connection_role), error)) {
         return false;
       }
     } else if (HasAttribute(line, kAttributeMsidSemantics)) {
       std::string semantics;
       if (!GetValue(line, kAttributeMsidSemantics, &semantics, error)) {
         return false;
       }
-      *supports_msid = CaseInsensitiveFind(semantics, kMediaStreamSemantic);
+      desc->set_msid_supported(
+          CaseInsensitiveFind(semantics, kMediaStreamSemantic));
     } else if (HasAttribute(line, kAttributeExtmap)) {
       RtpHeaderExtension extmap;
       if (!ParseExtmap(line, &extmap, error)) {
         return false;
       }
       session_extmaps->push_back(extmap);
     }
   }
 
   return true;
@@ skipping 189 matching lines @@
     return NULL;
   }
   // Sort the codecs according to the m-line fmt list.
   media_desc->SortCodecs();
   return media_desc;
 }
 
 bool ParseMediaDescription(const std::string& message,
                            const TransportDescription& session_td,
                            const RtpHeaderExtensions& session_extmaps,
-                           bool supports_msid,
                            size_t* pos,
                            cricket::SessionDescription* desc,
                            std::vector<JsepIceCandidate*>* candidates,
                            SdpParseError* error) {
   ASSERT(desc != NULL);
   std::string line;
   int mline_index = -1;
 
   // Zero or more media descriptions
   // RFC 4566
@@ skipping 74 matching lines @@
     } else {
       LOG(LS_WARNING) << "Unsupported media type: " << line;
       continue;
     }
     if (!content.get()) {
       // ParseContentDescription returns NULL if failed.
       return false;
     }
 
     if (IsRtp(protocol)) {
-      // Make sure to set the media direction correctly. If the direction is not
-      // MD_RECVONLY or Inactive and no streams are parsed,
-      // a default MediaStream will be created to prepare for receiving media.
-      if (supports_msid && content->streams().empty() &&
-          content->direction() == cricket::MD_SENDRECV) {
-        content->set_direction(cricket::MD_RECVONLY);
-      }
-
       // Set the extmap.
       if (!session_extmaps.empty() &&
           !content->rtp_header_extensions().empty()) {
         return ParseFailed("",
                            "The a=extmap MUST be either all session level or "
                            "all media level.",
                            error);
       }
       for (size_t i = 0; i < session_extmaps.size(); ++i) {
         content->AddRtpHeaderExtension(session_extmaps[i]);
@@ skipping 811 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc