Removing `preference` field from `cricket::Codec`.

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 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 731 matching lines @@
     const MediaSessionOptions& options,
     const std::vector<C>& codecs,
     const SecurePolicy& secure_policy,
     const CryptoParamsVec* current_cryptos,
     const std::vector<std::string>& crypto_suites,
     const RtpHeaderExtensions& rtp_extensions,
     bool add_legacy_stream,
     StreamParamsVec* current_streams,
     MediaContentDescriptionImpl<C>* offer) {
   offer->AddCodecs(codecs);
-  offer->SortCodecs();
 
   if (secure_policy == SEC_REQUIRED) {
     offer->set_crypto_required(CT_SDES);
   }
   offer->set_rtcp_mux(options.rtcp_mux_enabled);
   if (offer->type() == cricket::MEDIA_TYPE_VIDEO) {
     offer->set_rtcp_reduced_size(true);
   }
   offer->set_multistream(options.is_muc);
   offer->set_rtp_header_extensions(rtp_extensions);
@@ skipping 40 matching lines @@
   }
   return codec1.Matches(codec2);
 }
 
 template <class C>
 static void NegotiateCodecs(const std::vector<C>& local_codecs,
                             const std::vector<C>& offered_codecs,
                             std::vector<C>* negotiated_codecs) {
   for (const C& ours : local_codecs) {
     C theirs;
+    // Note that we intentionally only find one matching codec for each of our
+    // local codecs, in case the remote offer contains duplicate codecs.
     if (FindMatchingCodec(local_codecs, offered_codecs, ours, &theirs)) {
       C negotiated = ours;
       negotiated.IntersectFeedbackParams(theirs);
       if (IsRtxCodec(negotiated)) {
         std::string offered_apt_value;
         theirs.GetParam(kCodecParamAssociatedPayloadType, &offered_apt_value);
         // FindMatchingCodec shouldn't return something with no apt value.
         RTC_DCHECK(!offered_apt_value.empty());
         negotiated.SetParam(kCodecParamAssociatedPayloadType,
                             offered_apt_value);
       }
       negotiated.id = theirs.id;
-      // RFC3264: Although the answerer MAY list the formats in their desired
-      // order of preference, it is RECOMMENDED that unless there is a
-      // specific reason, the answerer list formats in the same relative order
-      // they were present in the offer.
-      negotiated.preference = theirs.preference;
       negotiated_codecs->push_back(negotiated);
     }
   }
+  // RFC3264: Although the answerer MAY list the formats in their desired
+  // order of preference, it is RECOMMENDED that unless there is a
+  // specific reason, the answerer list formats in the same relative order
+  // they were present in the offer.
+  std::vector<int> offer_payload_types;
+  for (const C& codec : offered_codecs) {
+    offer_payload_types.push_back(codec.id);
+  }
+  std::sort(negotiated_codecs->begin(), negotiated_codecs->end(),
+            [offer_payload_types](const C& a, const C& b) {
+              return std::find(offer_payload_types.begin(),
+                               offer_payload_types.end(), a.id) <
+                     std::find(offer_payload_types.begin(),
+                               offer_payload_types.end(), b.id);
+            });

[pthatcher1, 2016/04/12 00:35:19]

If you're going to fix the sort in one place, you should probably fix it in
both.

[Taylor Brandstetter, 2016/04/12 01:23:29]

Done.

 }
 
 // Finds a codec in |codecs2| that matches |codec_to_match|, which is
 // a member of |codecs1|. If |codec_to_match| is an RTX codec, both
 // the codecs themselves and their associated codecs must match.
 template <class C>
 static bool FindMatchingCodec(const std::vector<C>& codecs1,
                               const std::vector<C>& codecs2,
                               const C& codec_to_match,
                               C* found_codec) {
@@ skipping 192 matching lines @@
     const SecurePolicy& sdes_policy,
     const CryptoParamsVec* current_cryptos,
     const RtpHeaderExtensions& local_rtp_extenstions,
     StreamParamsVec* current_streams,
     bool add_legacy_stream,
     bool bundle_enabled,
     MediaContentDescriptionImpl<C>* answer) {
   std::vector<C> negotiated_codecs;
   NegotiateCodecs(local_codecs, offer->codecs(), &negotiated_codecs);
   answer->AddCodecs(negotiated_codecs);
-  answer->SortCodecs();
   answer->set_protocol(offer->protocol());
   RtpHeaderExtensions negotiated_rtp_extensions;
   NegotiateRtpHeaderExtensions(local_rtp_extenstions,
                                offer->rtp_header_extensions(),
                                &negotiated_rtp_extensions);
   answer->set_rtp_header_extensions(negotiated_rtp_extensions);
 
   answer->set_rtcp_mux(options.rtcp_mux_enabled && offer->rtcp_mux());
   if (answer->type() == cricket::MEDIA_TYPE_VIDEO) {
     answer->set_rtcp_reduced_size(offer->rtcp_reduced_size());
@@ skipping 302 matching lines @@
     }
   }
 
   return offer.release();
 }
 
 SessionDescription* MediaSessionDescriptionFactory::CreateAnswer(
     const SessionDescription* offer, const MediaSessionOptions& options,
     const SessionDescription* current_description) const {
   // The answer contains the intersection of the codecs in the offer with the
-  // codecs we support, ordered by our local preference. As indicated by
-  // XEP-0167, we retain the same payload ids from the offer in the answer.
+  // codecs we support. As indicated by XEP-0167, we retain the same payload ids
+  // from the offer in the answer.
   std::unique_ptr<SessionDescription> answer(new SessionDescription());
 
   StreamParamsVec current_streams;
   GetCurrentStreamParams(current_description, &current_streams);
 
   if (offer) {
     ContentInfos::const_iterator it = offer->contents().begin();
     for (; it != offer->contents().end(); ++it) {
       if (IsMediaContentOfType(&*it, MEDIA_TYPE_AUDIO)) {
         if (!AddAudioContentForAnswer(offer, options, current_description,
@@ skipping 614 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 const DataContentDescription* GetFirstDataContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket