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

webrtc/media/base/codec.cc

 /*
  *  Copyright (c) 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 53 matching lines @@
     for (std::vector<FeedbackParam>::const_iterator found = iter + 1;
          found != params_.end(); ++found) {
       if (*found == *iter) {
         return true;
       }
     }
   }
   return false;
 }
 
-Codec::Codec(int id, const std::string& name, int clockrate, int preference)
-    : id(id), name(name), clockrate(clockrate), preference(preference) {
-}
+Codec::Codec(int id, const std::string& name, int clockrate)
+    : id(id), name(name), clockrate(clockrate) {}
 
-Codec::Codec() : id(0), clockrate(0), preference(0) {
-}
+Codec::Codec() : id(0), clockrate(0) {}
 
 Codec::Codec(const Codec& c) = default;
 
 Codec::~Codec() = default;
 
 Codec& Codec::operator=(const Codec& c) {
   this->id = c.id;  // id is reserved in objective-c
   name = c.name;
   clockrate = c.clockrate;
-  preference = c.preference;
   params = c.params;
   feedback_params = c.feedback_params;
   return *this;
 }
 
 bool Codec::operator==(const Codec& c) const {
   return this->id == c.id &&  // id is reserved in objective-c
-         name == c.name && clockrate == c.clockrate &&
-         preference == c.preference && params == c.params &&
+         name == c.name && clockrate == c.clockrate && params == c.params &&
          feedback_params == c.feedback_params;
 }
 
 bool Codec::Matches(const Codec& codec) const {
   // Match the codec id/name based on the typical static/dynamic name rules.
   // Matching is case-insensitive.
   const int kMaxStaticPayloadId = 95;
   return (codec.id <= kMaxStaticPayloadId) ?
       (id == codec.id) : (_stricmp(name.c_str(), codec.name.c_str()) == 0);
 }
@@ skipping 34 matching lines @@
 }
 
 void Codec::IntersectFeedbackParams(const Codec& other) {
   feedback_params.Intersect(other.feedback_params);
 }
 
 AudioCodec::AudioCodec(int id,
                        const std::string& name,
                        int clockrate,
                        int bitrate,
-                       size_t channels,
-                       int preference)
-    : Codec(id, name, clockrate, preference),
-      bitrate(bitrate),
-      channels(channels) {
-}
+                       size_t channels)
+    : Codec(id, name, clockrate), bitrate(bitrate), channels(channels) {}
 
 AudioCodec::AudioCodec() : Codec(), bitrate(0), channels(0) {
 }
 
 AudioCodec::AudioCodec(const AudioCodec& c) = default;
 
 AudioCodec& AudioCodec::operator=(const AudioCodec& c) {
   Codec::operator=(c);
   bitrate = c.bitrate;
   channels = c.channels;
@@ skipping 17 matching lines @@
   return Codec::Matches(codec) &&
       ((codec.clockrate == 0 /*&& clockrate == 8000*/) ||
           clockrate == codec.clockrate) &&
       (codec.bitrate == 0 || bitrate <= 0 || bitrate == codec.bitrate) &&
       ((codec.channels < 2 && channels < 2) || channels == codec.channels);
 }
 
 std::string AudioCodec::ToString() const {
   std::ostringstream os;
   os << "AudioCodec[" << id << ":" << name << ":" << clockrate << ":" << bitrate
-     << ":" << channels << ":" << preference << "]";
+     << ":" << channels << "]";
   return os.str();
 }
 
 std::string VideoCodec::ToString() const {
   std::ostringstream os;
   os << "VideoCodec[" << id << ":" << name << ":" << width << ":" << height
-     << ":" << framerate << ":" << preference << "]";
+     << ":" << framerate << "]";
   return os.str();
 }
 
 VideoCodec::VideoCodec(int id,
                        const std::string& name,
                        int width,
                        int height,
-                       int framerate,
-                       int preference)
-    : Codec(id, name, kVideoCodecClockrate, preference),
+                       int framerate)
+    : Codec(id, name, kVideoCodecClockrate),
       width(width),
       height(height),
-      framerate(framerate) {
-}
+      framerate(framerate) {}
 
 VideoCodec::VideoCodec(int id, const std::string& name)
-    : Codec(id, name, kVideoCodecClockrate, 0),
+    : Codec(id, name, kVideoCodecClockrate),
       width(0),
       height(0),
-      framerate(0) {
-}
+      framerate(0) {}
 
 VideoCodec::VideoCodec() : Codec(), width(0), height(0), framerate(0) {
   clockrate = kVideoCodecClockrate;
 }
 
 VideoCodec::VideoCodec(const VideoCodec& c) = default;
 
 VideoCodec& VideoCodec::operator=(const VideoCodec& c) {
   Codec::operator=(c);
   width = c.width;
   height = c.height;
   framerate = c.framerate;
   return *this;
 }
 
 bool VideoCodec::operator==(const VideoCodec& c) const {
   return width == c.width && height == c.height && framerate == c.framerate &&
          Codec::operator==(c);
 }
 
 VideoCodec VideoCodec::CreateRtxCodec(int rtx_payload_type,
                                       int associated_payload_type) {
-  VideoCodec rtx_codec(rtx_payload_type, kRtxCodecName, 0, 0, 0, 0);
+  VideoCodec rtx_codec(rtx_payload_type, kRtxCodecName, 0, 0, 0);
   rtx_codec.SetParam(kCodecParamAssociatedPayloadType, associated_payload_type);
   return rtx_codec;
 }
 
 VideoCodec::CodecType VideoCodec::GetCodecType() const {
   const char* payload_name = name.c_str();
   if (_stricmp(payload_name, kRedCodecName) == 0) {
     return CODEC_RED;
   }
   if (_stricmp(payload_name, kUlpfecCodecName) == 0) {
@@ skipping 26 matching lines @@
   if (GetParam(kCodecParamMinBitrate, &min_bitrate) &&
       GetParam(kCodecParamMaxBitrate, &max_bitrate)) {
     if (max_bitrate < min_bitrate) {
       LOG(LS_ERROR) << "Codec with max < min bitrate: " << ToString();
       return false;
     }
   }
   return true;
 }
 
-DataCodec::DataCodec(int id, const std::string& name, int preference)
-    : Codec(id, name, kDataCodecClockrate, preference) {
-}
+DataCodec::DataCodec(int id, const std::string& name)
+    : Codec(id, name, kDataCodecClockrate) {}
 
 DataCodec::DataCodec() : Codec() {
   clockrate = kDataCodecClockrate;
 }
 
 DataCodec::DataCodec(const DataCodec& c) = default;
 
 DataCodec& DataCodec::operator=(const DataCodec& c) = default;
 
 std::string DataCodec::ToString() const {
@@ skipping 15 matching lines @@
 bool HasTransportCc(const Codec& codec) {
   return codec.HasFeedbackParam(
       FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
 }
 
 bool CodecNamesEq(const std::string& name1, const std::string& name2) {
   return _stricmp(name1.c_str(), name2.c_str()) == 0;
 }
 
 }  // namespace cricket