Provide move semantic for cricket::Codec and subclasses

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 59 matching lines @@
   }
   return false;
 }
 
 Codec::Codec(int id, const std::string& name, int clockrate)
     : id(id), name(name), clockrate(clockrate) {}
 
 Codec::Codec() : id(0), clockrate(0) {}
 
 Codec::Codec(const Codec& c) = default;
-
+Codec::Codec(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;
-  params = c.params;
-  feedback_params = c.feedback_params;
-  return *this;
-}
+Codec& Codec::operator=(const Codec& c) = default;
+Codec& Codec::operator=(Codec&& c) = default;
 
 bool Codec::operator==(const Codec& c) const {
   return this->id == c.id &&  // id is reserved in objective-c
          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);
+  return (id <= kMaxStaticPayloadId || codec.id <= kMaxStaticPayloadId)
+             ? (id == codec.id)
+             : (_stricmp(name.c_str(), codec.name.c_str()) == 0);
 }
 
 bool Codec::GetParam(const std::string& name, std::string* out) const {
   CodecParameterMap::const_iterator iter = params.find(name);
   if (iter == params.end())
     return false;
   *out = iter->second;
   return true;
 }
 
@@ skipping 40 matching lines @@
                        const std::string& name,
                        int clockrate,
                        int bitrate,
                        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;
-  return *this;
-}
+AudioCodec::AudioCodec(AudioCodec&& c) = default;
+AudioCodec& AudioCodec::operator=(const AudioCodec& c) = default;
+AudioCodec& AudioCodec::operator=(AudioCodec&& c) = default;
 
 bool AudioCodec::operator==(const AudioCodec& c) const {
   return bitrate == c.bitrate && channels == c.channels && Codec::operator==(c);
 }
 
 bool AudioCodec::Matches(const AudioCodec& codec) const {
   // If a nonzero clockrate is specified, it must match the actual clockrate.
   // If a nonzero bitrate is specified, it must match the actual bitrate,
   // unless the codec is VBR (0), where we just force the supplied value.
   // The number of channels must match exactly, with the exception
@@ skipping 32 matching lines @@
     : Codec(id, name, kVideoCodecClockrate) {}
 
 VideoCodec::VideoCodec(const std::string& name)
     : VideoCodec(0 /* id */, name) {}
 
 VideoCodec::VideoCodec() : Codec() {
   clockrate = kVideoCodecClockrate;
 }
 
 VideoCodec::VideoCodec(const VideoCodec& c) = default;
-
-VideoCodec& VideoCodec::operator=(const VideoCodec& c) {
-  Codec::operator=(c);
-  return *this;
-}
+VideoCodec::VideoCodec(VideoCodec&& c) = default;
+VideoCodec& VideoCodec::operator=(const VideoCodec& c) = default;
+VideoCodec& VideoCodec::operator=(VideoCodec&& c) = default;
 
 bool VideoCodec::operator==(const VideoCodec& c) const {
   return Codec::operator==(c);
 }
 
 VideoCodec VideoCodec::CreateRtxCodec(int rtx_payload_type,
                                       int associated_payload_type) {
   VideoCodec rtx_codec(rtx_payload_type, kRtxCodecName);
   rtx_codec.SetParam(kCodecParamAssociatedPayloadType, associated_payload_type);
   return rtx_codec;
@@ skipping 37 matching lines @@
 }
 
 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(DataCodec&& c) = default;
 DataCodec& DataCodec::operator=(const DataCodec& c) = default;
+DataCodec& DataCodec::operator=(DataCodec&& c) = default;
 
 std::string DataCodec::ToString() const {
   std::ostringstream os;
   os << "DataCodec[" << id << ":" << name << "]";
   return os.str();
 }
 
 bool HasNack(const Codec& codec) {
   return codec.HasFeedbackParam(
       FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
@@ skipping 30 matching lines @@
 
 bool IsCodecSupported(const std::vector<VideoCodec>& supported_codecs,
                       const VideoCodec& codec) {
   return std::any_of(supported_codecs.begin(), supported_codecs.end(),
                      [&codec](const VideoCodec& supported_codec) -> bool {
                        return CodecNamesEq(codec.name, supported_codec.name);
                      });
 }
 
 }  // namespace cricket