Remove cricket::VideoCodec with, height and framerate properties

webrtc/media/base/codec_unittest.cc

 /*
  *  Copyright (c) 2009 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 113 matching lines @@
   EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, -1, 1)));
 
   // Stereo doesn't match channels = 0.
   AudioCodec c3(96, "A", 44100, 20000, 2);
   EXPECT_TRUE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 2)));
   EXPECT_FALSE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 1)));
   EXPECT_FALSE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 0)));
 }
 
 TEST(CodecTest, TestVideoCodecOperators) {
-  VideoCodec c0(96, "V", 320, 200, 30);
-  VideoCodec c1(95, "V", 320, 200, 30);
-  VideoCodec c2(96, "x", 320, 200, 30);
-  VideoCodec c3(96, "V", 120, 200, 30);
-  VideoCodec c4(96, "V", 320, 100, 30);
-  VideoCodec c5(96, "V", 320, 200, 10);
+  VideoCodec c0(96, "V");
+  VideoCodec c1(95, "V");
+  VideoCodec c2(96, "x");
+
   EXPECT_TRUE(c0 != c1);
   EXPECT_TRUE(c0 != c2);
-  EXPECT_TRUE(c0 != c3);
-  EXPECT_TRUE(c0 != c4);
-  EXPECT_TRUE(c0 != c5);
 
   VideoCodec c7;
-  VideoCodec c8(0, "", 0, 0, 0);
+  VideoCodec c8(0, "");
   VideoCodec c9 = c0;
   EXPECT_TRUE(c8 == c7);
   EXPECT_TRUE(c9 != c7);
   EXPECT_TRUE(c9 == c0);
 
   VideoCodec c10(c0);
   VideoCodec c11(c0);
   VideoCodec c12(c0);
   VideoCodec c13(c0);
   c10.params["x"] = "abc";
   c11.params["x"] = "def";
   c12.params["y"] = "abc";
   c13.params["x"] = "abc";
   EXPECT_TRUE(c10 != c0);
   EXPECT_TRUE(c11 != c0);
   EXPECT_TRUE(c11 != c10);
   EXPECT_TRUE(c12 != c0);
   EXPECT_TRUE(c12 != c10);
   EXPECT_TRUE(c12 != c11);
   EXPECT_TRUE(c13 == c10);
 }
 
 TEST(CodecTest, TestVideoCodecMatches) {
   // Test a codec with a static payload type.
-  VideoCodec c0(95, "V", 320, 200, 30);
-  EXPECT_TRUE(c0.Matches(VideoCodec(95, "", 640, 400, 15)));
-  EXPECT_FALSE(c0.Matches(VideoCodec(96, "", 320, 200, 30)));
+  VideoCodec c0(95, "V");
+  EXPECT_TRUE(c0.Matches(VideoCodec(95, "")));
+  EXPECT_FALSE(c0.Matches(VideoCodec(96, "")));
 
   // Test a codec with a dynamic payload type.
-  VideoCodec c1(96, "V", 320, 200, 30);
-  EXPECT_TRUE(c1.Matches(VideoCodec(96, "V", 640, 400, 15)));
-  EXPECT_TRUE(c1.Matches(VideoCodec(97, "V", 640, 400, 15)));
-  EXPECT_TRUE(c1.Matches(VideoCodec(96, "v", 640, 400, 15)));
-  EXPECT_TRUE(c1.Matches(VideoCodec(97, "v", 640, 400, 15)));
-  EXPECT_FALSE(c1.Matches(VideoCodec(96, "", 320, 200, 30)));
-  EXPECT_FALSE(c1.Matches(VideoCodec(95, "V", 640, 400, 15)));
+  VideoCodec c1(96, "V");
+  EXPECT_TRUE(c1.Matches(VideoCodec(96, "V")));
+  EXPECT_TRUE(c1.Matches(VideoCodec(97, "V")));
+  EXPECT_TRUE(c1.Matches(VideoCodec(96, "v")));
+  EXPECT_TRUE(c1.Matches(VideoCodec(97, "v")));
+  EXPECT_FALSE(c1.Matches(VideoCodec(96, "")));
+  EXPECT_FALSE(c1.Matches(VideoCodec(95, "V")));
 }
 
 TEST(CodecTest, TestVideoCodecMatchesH264Baseline) {
-  const VideoCodec no_params(96, cricket::kH264CodecName, 640, 480, 30);
+  const VideoCodec no_params(96, cricket::kH264CodecName);
 
-  VideoCodec baseline(96, cricket::kH264CodecName, 640, 480, 30);
+  VideoCodec baseline(96, cricket::kH264CodecName);
   baseline.SetParam(cricket::kH264FmtpProfileLevelId,
                     cricket::kH264FmtpDefaultProfileLevelId);
 
   EXPECT_TRUE(baseline.Matches(baseline));
   EXPECT_TRUE(baseline.Matches(no_params));
   EXPECT_TRUE(no_params.Matches(baseline));
   EXPECT_TRUE(no_params.Matches(no_params));
 }
 
 TEST(CodecTest, TestVideoCodecMatchesH264Profiles) {
-  VideoCodec baseline(96, cricket::kH264CodecName, 640, 480, 30);
+  VideoCodec baseline(96, cricket::kH264CodecName);
   baseline.SetParam(cricket::kH264FmtpProfileLevelId,
                     cricket::kH264FmtpDefaultProfileLevelId);
   baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
 
-  VideoCodec constrained_baseline(96, cricket::kH264CodecName, 640, 480, 30);
+  VideoCodec constrained_baseline(96, cricket::kH264CodecName);
   constrained_baseline.SetParam(cricket::kH264FmtpProfileLevelId,
                                 cricket::kH264ProfileLevelConstrainedBaseline);
   constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
 
   EXPECT_TRUE(baseline.Matches(baseline));
   EXPECT_FALSE(baseline.Matches(constrained_baseline));
   EXPECT_FALSE(constrained_baseline.Matches(baseline));
   EXPECT_TRUE(constrained_baseline.Matches(constrained_baseline));
 }
 
 TEST(CodecTest, TestVideoCodecMatchesH264LevelAsymmetry) {
   // Constrained Baseline Profile Level 1.0.
-  VideoCodec cbp_1_0(96, cricket::kH264CodecName, 640, 480, 30);
+  VideoCodec cbp_1_0(96, cricket::kH264CodecName);
   cbp_1_0.SetParam(cricket::kH264FmtpProfileLevelId,
                    "42e00a");
 
   VideoCodec cbp_1_0_asymmetry_allowed = cbp_1_0;
   cbp_1_0_asymmetry_allowed.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed,
                                      "1");
 
   // Constrained Baseline Profile Level 3.1.
-  VideoCodec cbp_3_1(96, cricket::kH264CodecName, 640, 480, 30);
+  VideoCodec cbp_3_1(96, cricket::kH264CodecName);
   cbp_3_1.SetParam(cricket::kH264FmtpProfileLevelId, "42e01f");
 
   VideoCodec cbp_3_1_asymmetry_allowed = cbp_3_1;
   cbp_3_1_asymmetry_allowed.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed,
                                      "1");
 
   // It's ok to differ in level-asymmetry-allowed param as long as the level is
   // the same.
   EXPECT_TRUE(cbp_1_0.Matches(cbp_1_0_asymmetry_allowed));
   EXPECT_TRUE(cbp_3_1.Matches(cbp_3_1_asymmetry_allowed));
@@ skipping 61 matching lines @@
   c2.AddFeedbackParam(b3);
 
   c1.IntersectFeedbackParams(c2);
   EXPECT_TRUE(c1.HasFeedbackParam(a1));
   EXPECT_FALSE(c1.HasFeedbackParam(b2));
   EXPECT_FALSE(c1.HasFeedbackParam(c3));
 }
 
 TEST(CodecTest, TestGetCodecType) {
   // Codec type comparison should be case insenstive on names.
-  const VideoCodec codec(96, "V", 320, 200, 30);
-  const VideoCodec rtx_codec(96, "rTx", 320, 200, 30);
-  const VideoCodec ulpfec_codec(96, "ulpFeC", 320, 200, 30);
-  const VideoCodec red_codec(96, "ReD", 320, 200, 30);
+  const VideoCodec codec(96, "V");
+  const VideoCodec rtx_codec(96, "rTx");
+  const VideoCodec ulpfec_codec(96, "ulpFeC");
+  const VideoCodec red_codec(96, "ReD");
   EXPECT_EQ(VideoCodec::CODEC_VIDEO, codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_RTX, rtx_codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_ULPFEC, ulpfec_codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_RED, red_codec.GetCodecType());
 }
 
 TEST(CodecTest, TestCreateRtxCodec) {
   VideoCodec rtx_codec = VideoCodec::CreateRtxCodec(96, 120);
   EXPECT_EQ(96, rtx_codec.id);
   EXPECT_EQ(VideoCodec::CODEC_RTX, rtx_codec.GetCodecType());
   int associated_payload_type;
   ASSERT_TRUE(rtx_codec.GetParam(kCodecParamAssociatedPayloadType,
                                  &associated_payload_type));
   EXPECT_EQ(120, associated_payload_type);
 }
 
 TEST(CodecTest, TestValidateCodecFormat) {
-  const VideoCodec codec(96, "V", 320, 200, 30);
+  const VideoCodec codec(96, "V");
   ASSERT_TRUE(codec.ValidateCodecFormat());
 
   // Accept 0-127 as payload types.
   VideoCodec low_payload_type = codec;
   low_payload_type.id = 0;
   VideoCodec high_payload_type = codec;
   high_payload_type.id = 127;
   ASSERT_TRUE(low_payload_type.ValidateCodecFormat());
   EXPECT_TRUE(high_payload_type.ValidateCodecFormat());
 
   // Reject negative payloads.
   VideoCodec negative_payload_type = codec;
   negative_payload_type.id = -1;
   EXPECT_FALSE(negative_payload_type.ValidateCodecFormat());
 
   // Reject too-high payloads.
   VideoCodec too_high_payload_type = codec;
   too_high_payload_type.id = 128;
   EXPECT_FALSE(too_high_payload_type.ValidateCodecFormat());
 
-  // Accept non-video codecs with zero dimensions.
-  VideoCodec zero_width_rtx_codec = VideoCodec::CreateRtxCodec(96, 120);
-  zero_width_rtx_codec.width = 0;
-  EXPECT_TRUE(zero_width_rtx_codec.ValidateCodecFormat());
-
   // Reject codecs with min bitrate > max bitrate.
   VideoCodec incorrect_bitrates = codec;
   incorrect_bitrates.params[kCodecParamMinBitrate] = "100";
   incorrect_bitrates.params[kCodecParamMaxBitrate] = "80";
   EXPECT_FALSE(incorrect_bitrates.ValidateCodecFormat());
 
   // Accept min bitrate == max bitrate.
   VideoCodec equal_bitrates = codec;
   equal_bitrates.params[kCodecParamMinBitrate] = "100";
   equal_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(equal_bitrates.ValidateCodecFormat());
 
   // Accept min bitrate < max bitrate.
   VideoCodec different_bitrates = codec;
   different_bitrates.params[kCodecParamMinBitrate] = "99";
   different_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(different_bitrates.ValidateCodecFormat());
 }
 
 TEST(CodecTest, TestToCodecParameters) {
-  const VideoCodec v(96, "V", 320, 200, 30);
+  const VideoCodec v(96, "V");
   webrtc::RtpCodecParameters codec_params_1 = v.ToCodecParameters();
   EXPECT_EQ(96, codec_params_1.payload_type);
   EXPECT_EQ("V", codec_params_1.mime_type);
   EXPECT_EQ(cricket::kVideoCodecClockrate, codec_params_1.clock_rate);
   EXPECT_EQ(1, codec_params_1.channels);
 
   const AudioCodec a(97, "A", 44100, 20000, 2);
   webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
   EXPECT_EQ(97, codec_params_2.payload_type);
   EXPECT_EQ("A", codec_params_2.mime_type);
   EXPECT_EQ(44100, codec_params_2.clock_rate);
   EXPECT_EQ(2, codec_params_2.channels);
 }