Refactor pc/media_session_unittest.cc and introduce Yoda-test swapping tool.
This CL improves pc/media_session_unittest.cc by modernizing its structure
and improving assertion readability:
1. Transitioned several global and local Codec and RtpExtension constants
from raw arrays to std::vector.
2. Updated the CodecListsMatch matcher to use .Matches() for comparison,
making it resilient to dynamic payload type assignments.
3. Swapped GTest assertion arguments to follow the (value, constant) pattern,
eliminating "Yoda tests".
4. Refactored CodecLookupHelperForTesting to support explicit expectation
registration, improving test reliability under field trials.
5. Const-qualified PayloadType methods in api/payload_type.h to support
usage in refined test logic.
To facilitate and verify the argument swapping, a new tool and its unit
tests are added to the tools_webrtc directory.
Bug: None
Change-Id: I5e83ac5cebd67d7a38eafb7d2801d7e1c4bc0e54
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/470160
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#47646}
diff --git a/api/payload_type.h b/api/payload_type.h
index dc40b1f..fe401cb 100644
--- a/api/payload_type.h
+++ b/api/payload_type.h
@@ -47,7 +47,7 @@
// Factory function for the NotSet value. This should be the only way
// to create a value outside the valid range.
static constexpr PayloadType NotSet() { return PayloadType(Internal{}, -1); }
- bool Valid(bool rtcp_mux = false) {
+ bool Valid(bool rtcp_mux = false) const {
// A payload type is a 7-bit value in the RTP header, so max = 127.
// If RTCP multiplexing is used, the numbers from 64 to 95 are reserved
// for RTCP packets.
@@ -60,7 +60,7 @@
static bool IsValid(PayloadType id, bool rtcp_mux) {
return id.Valid(rtcp_mux);
}
- bool IsSet() { return value() >= 0; }
+ bool IsSet() const { return value() >= 0; }
private:
class Internal {};
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index 69a8bd2..4daa25f 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -10,14 +10,17 @@
#include "pc/media_session.h"
+#include <array>
#include <cstddef>
#include <cstdint>
+#include <initializer_list>
#include <map>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <tuple>
+#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
@@ -27,9 +30,9 @@
#include "api/candidate.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
-#include "api/field_trials.h"
#include "api/field_trials_view.h"
#include "api/media_types.h"
+#include "api/payload_type.h"
#include "api/rtp_parameters.h"
#include "api/rtp_transceiver_direction.h"
#include "api/sctp_transport_interface.h"
@@ -63,7 +66,7 @@
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/system/plan_b_only.h"
#include "rtc_base/unique_id_generator.h"
-#include "test/create_test_field_trials.h"
+#include "test/create_test_environment.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/pc/sctp/fake_sctp_transport.h"
@@ -111,54 +114,64 @@
return codec_vendor_.get();
}
- template <typename T>
- void SetVideoCodecs(const T& send, const T& receive) {
- media_engine_.SetVideoRecvCodecs(receive);
- media_engine_.SetVideoSendCodecs(send);
+ void RegisterExpectations(absl::string_view mid,
+ std::span<const Codec> codecs) {
+ for (const Codec& c : codecs) {
+ if (c.id.IsSet()) {
+ payload_type_suggester_.AddLocalMapping(mid, c.id, c);
+ }
+ }
+ }
+
+ void SetVideoCodecs(std::span<const Codec> send,
+ std::span<const Codec> receive) {
+ media_engine_.SetVideoRecvCodecs(
+ std::vector<Codec>(receive.begin(), receive.end()));
+ media_engine_.SetVideoSendCodecs(
+ std::vector<Codec>(send.begin(), send.end()));
+ if (field_trials_.IsEnabled("WebRTC-PayloadTypesInTransport")) {
+ RegisterExpectations(kVideoMid, send);
+ RegisterExpectations(kVideoMid, receive);
+ }
MaybeEnableRtx(send);
codec_vendor_.reset();
}
- template <typename T>
- void SetAudioCodecs(const T& send, const T& receive) {
- media_engine_.SetAudioSendCodecs(send);
- media_engine_.SetAudioRecvCodecs(receive);
+ void SetAudioCodecs(std::span<const Codec> send,
+ std::span<const Codec> receive) {
+ media_engine_.SetAudioSendCodecs(
+ std::vector<Codec>(send.begin(), send.end()));
+ media_engine_.SetAudioRecvCodecs(
+ std::vector<Codec>(receive.begin(), receive.end()));
+ if (field_trials_.IsEnabled("WebRTC-PayloadTypesInTransport")) {
+ RegisterExpectations(kAudioMid, send);
+ RegisterExpectations(kAudioMid, receive);
+ }
codec_vendor_.reset();
}
- void SetAudioCodecs(const std::vector<Codec>& codecs) {
+ void SetAudioCodecs(std::span<const Codec> codecs) {
SetAudioCodecs(codecs, codecs);
}
- void SetVideoCodecs(const std::vector<Codec>& codecs) {
+ void SetVideoCodecs(std::span<const Codec> codecs) {
SetVideoCodecs(codecs, codecs);
}
- void SetAudioCodecs(std::span<const Codec> codecs) {
- SetAudioCodecs(std::vector<Codec>(codecs.begin(), codecs.end()));
+ void SetAudioCodecs(std::initializer_list<Codec> codecs) {
+ SetAudioCodecs(std::span<const Codec>(codecs.begin(), codecs.end()));
}
- void SetVideoCodecs(std::span<const Codec> codecs) {
- SetVideoCodecs(std::vector<Codec>(codecs.begin(), codecs.end()));
- }
-
- template <typename U, size_t N>
- void SetAudioCodecs(U (&array)[N]) {
- SetAudioCodecs(std::span<const Codec>(&array[0], N));
- }
-
- template <typename U, size_t N>
- void SetVideoCodecs(U (&array)[N]) {
- SetVideoCodecs(std::span<const Codec>(&array[0], N));
+ void SetVideoCodecs(std::initializer_list<Codec> codecs) {
+ SetVideoCodecs(std::span<const Codec>(codecs.begin(), codecs.end()));
}
void ClearAudioCodecs() { SetAudioCodecs(std::vector<Codec>()); }
void ClearVideoCodecs() { SetVideoCodecs(std::vector<Codec>()); }
private:
- template <typename T>
- void MaybeEnableRtx(const T& codecs) {
- for (const auto& c : codecs) {
+ void MaybeEnableRtx(std::span<const Codec> codecs) {
+ for (const Codec& c : codecs) {
if (c.name == kRtxCodecName) {
rtx_enabled_ = true;
break;
@@ -179,34 +192,34 @@
return red;
}
-const Codec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
- CreateRedAudioCodec("111"),
- CreateAudioCodec(103, "G722", 16000, 1),
- CreateAudioCodec(0, "PCMU", 8000, 1),
- CreateAudioCodec(8, "PCMA", 8000, 1),
- CreateAudioCodec(107, "CN", 48000, 1)};
+const std::array kAudioCodecs1 = {CreateAudioCodec(111, "opus", 48000, 2),
+ CreateRedAudioCodec("111"),
+ CreateAudioCodec(103, "G722", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
+ CreateAudioCodec(8, "PCMA", 8000, 1),
+ CreateAudioCodec(107, "CN", 48000, 1)};
-const Codec kAudioCodecs2[] = {
+const std::array kAudioCodecs2 = {
CreateAudioCodec(126, "foo", 16000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
CreateAudioCodec(127, "G722", 16000, 1),
};
-const Codec kAudioCodecsAnswer[] = {
+const std::array kAudioCodecsAnswer = {
CreateAudioCodec(103, "G722", 16000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
};
-const Codec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
- CreateVideoCodec(97, "H264")};
+const std::array kVideoCodecs1 = {CreateVideoCodec(96, "H264-SVC"),
+ CreateVideoCodec(97, "H264")};
-const Codec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
- CreateVideoCodec(96, "H264-SVC")};
+const std::array kVideoCodecs1Reverse = {CreateVideoCodec(97, "H264"),
+ CreateVideoCodec(96, "H264-SVC")};
-const Codec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
- CreateVideoCodec(127, "H263")};
+const std::array kVideoCodecs2 = {CreateVideoCodec(126, "H264"),
+ CreateVideoCodec(127, "H263")};
-const Codec kVideoCodecsAnswer[] = {CreateVideoCodec(97, "H264")};
+const std::array kVideoCodecsAnswer = {CreateVideoCodec(97, "H264")};
// H.265 level-id, according to H.265 spec, is calculated this way:
// For any given H.265 level a.b, level-id = (a * 10 + b) * 3. For level 6.0,
@@ -248,65 +261,72 @@
kVideoCodecsH265Level6LevelId},
{"tx-mode", "SRST"}});
-const Codec kVideoCodecsH265Level31[] = {
+const std::array kVideoCodecsH265Level31 = {
CreateVideoCodec(96, kH265MainProfileLevel31Sdp)};
-const Codec kVideoCodecsH265Level4[] = {
+const std::array kVideoCodecsH265Level4 = {
CreateVideoCodec(96, kH265MainProfileLevel4Sdp)};
-const Codec kVideoCodecsH265Level5[] = {
+const std::array kVideoCodecsH265Level5 = {
CreateVideoCodec(96, kH265MainProfileLevel5Sdp)};
-const Codec kVideoCodecsH265Level52[] = {
+const std::array kVideoCodecsH265Level52 = {
CreateVideoCodec(96, kH265MainProfileLevel52Sdp)};
-const Codec kVideoCodecsH265Level6[] = {
+const std::array kVideoCodecsH265Level6 = {
CreateVideoCodec(96, kH265MainProfileLevel6Sdp)};
-// Match two codec lists for content, but ignore the ID.
-bool CodecListsMatch(std::span<const Codec> list1,
- std::span<const Codec> list2) {
- if (list1.size() != list2.size()) {
+// Match two codec lists for content, but ignore the ID and feedback params.
+MATCHER_P2(CodecListsMatch, expected, field_trials, "") {
+ if (expected.size() != arg.size()) {
return false;
}
- for (size_t i = 0; i < list1.size(); ++i) {
- Codec codec1 = list1[i];
- Codec codec2 = list2[i];
- codec1.id = Codec::kIdNotSet;
- codec2.id = Codec::kIdNotSet;
- if (codec1 != codec2) {
- RTC_LOG(LS_ERROR) << "Mismatch at position " << i << " between " << codec1
- << " and " << codec2;
+ for (size_t i = 0; i < expected.size(); ++i) {
+ if (!expected[i].Matches(arg[i])) {
return false;
}
}
return true;
}
-const RtpExtension kAudioRtpExtension1[] = {
+MATCHER_P(NamesMatchImpl, expected_names, "") {
+ std::vector<std::string> actual_names;
+ for (const auto& item : arg) {
+ actual_names.push_back(item.name);
+ }
+ return ::testing::ExplainMatchResult(
+ ::testing::ElementsAreArray(expected_names), actual_names,
+ result_listener);
+}
+
+inline auto NamesMatch(std::vector<std::string> expected_names) {
+ return NamesMatchImpl(std::move(expected_names));
+}
+
+const std::array kAudioRtpExtension1 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
RtpExtension("http://google.com/testing/audio_something", 10),
};
-const RtpExtension kAudioRtpExtensionEncrypted1[] = {
+const std::array kAudioRtpExtensionEncrypted1 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
RtpExtension("http://google.com/testing/audio_something", 11, true),
};
-const RtpExtension kAudioRtpExtension2[] = {
+const std::array kAudioRtpExtension2 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 2),
RtpExtension("http://google.com/testing/audio_something_else", 8),
RtpExtension("http://google.com/testing/both_audio_and_video", 7),
};
-const RtpExtension kAudioRtpExtensionEncrypted2[] = {
+const std::array kAudioRtpExtensionEncrypted2 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 2),
RtpExtension("http://google.com/testing/audio_something", 13, true),
RtpExtension("http://google.com/testing/audio_something_else", 5, true),
};
-const RtpExtension kAudioRtpExtension3[] = {
+const std::array kAudioRtpExtension3 = {
RtpExtension("http://google.com/testing/audio_something", 2),
RtpExtension("http://google.com/testing/both_audio_and_video", 3),
};
-const RtpExtension kAudioRtpExtensionMixedEncryption1[] = {
+const std::array kAudioRtpExtensionMixedEncryption1 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
RtpExtension("http://google.com/testing/audio_something", 9),
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 10, true),
@@ -314,7 +334,7 @@
RtpExtension("http://google.com/testing/audio_something_else", 12, true),
};
-const RtpExtension kAudioRtpExtensionMixedEncryption2[] = {
+const std::array kAudioRtpExtensionMixedEncryption2 = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 5),
RtpExtension("http://google.com/testing/audio_something", 6),
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 7, true),
@@ -322,89 +342,85 @@
RtpExtension("http://google.com/testing/audio_something_else", 9),
};
-const RtpExtension kAudioRtpExtensionAnswer[] = {
+const std::array kAudioRtpExtensionAnswer = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
};
-const RtpExtension kAudioRtpExtensionEncryptedAnswer[] = {
+const std::array kAudioRtpExtensionEncryptedAnswer = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
RtpExtension("http://google.com/testing/audio_something", 11, true),
};
-const RtpExtension kAudioRtpExtensionMixedEncryptionAnswerEncryptionEnabled[] =
- {
- RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 10, true),
- RtpExtension("http://google.com/testing/audio_something", 11, true),
+const std::array kAudioRtpExtensionMixedEncryptionAnswerEncryptionEnabled = {
+ RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 10, true),
+ RtpExtension("http://google.com/testing/audio_something", 11, true),
};
-const RtpExtension kAudioRtpExtensionMixedEncryptionAnswerEncryptionDisabled[] =
- {
- RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
- RtpExtension("http://google.com/testing/audio_something", 9),
+const std::array kAudioRtpExtensionMixedEncryptionAnswerEncryptionDisabled = {
+ RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
+ RtpExtension("http://google.com/testing/audio_something", 9),
};
-const RtpExtension kVideoRtpExtension1[] = {
+const std::array kVideoRtpExtension1 = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
RtpExtension("http://google.com/testing/video_something", 13),
};
-const RtpExtension kVideoRtpExtensionEncrypted1[] = {
+const std::array kVideoRtpExtensionEncrypted1 = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
RtpExtension("http://google.com/testing/video_something", 7, true),
};
-const RtpExtension kVideoRtpExtension2[] = {
+const std::array kVideoRtpExtension2 = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 2),
RtpExtension("http://google.com/testing/video_something_else", 14),
RtpExtension("http://google.com/testing/both_audio_and_video", 7),
};
-const RtpExtension kVideoRtpExtensionEncrypted2[] = {
+const std::array kVideoRtpExtensionEncrypted2 = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 8),
RtpExtension("http://google.com/testing/video_something", 10, true),
RtpExtension("http://google.com/testing/video_something_else", 4, true),
};
-const RtpExtension kVideoRtpExtension3[] = {
+const std::array kVideoRtpExtension3 = {
RtpExtension("http://google.com/testing/video_something", 4),
RtpExtension("http://google.com/testing/both_audio_and_video", 5),
};
-const RtpExtension kVideoRtpExtensionMixedEncryption[] = {
+const std::array kVideoRtpExtensionMixedEncryption = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
RtpExtension("http://google.com/testing/video_something", 13),
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 15, true),
RtpExtension("http://google.com/testing/video_something", 16, true),
};
-const RtpExtension kVideoRtpExtensionAnswer[] = {
+const std::array kVideoRtpExtensionAnswer = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
};
-const RtpExtension kVideoRtpExtensionEncryptedAnswer[] = {
+const std::array kVideoRtpExtensionEncryptedAnswer = {
RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
RtpExtension("http://google.com/testing/video_something", 7, true),
};
-const RtpExtension kVideoRtpExtensionMixedEncryptionAnswerEncryptionEnabled[] =
- {
- RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 15, true),
- RtpExtension("http://google.com/testing/video_something", 16, true),
+const std::array kVideoRtpExtensionMixedEncryptionAnswerEncryptionEnabled = {
+ RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 15, true),
+ RtpExtension("http://google.com/testing/video_something", 16, true),
};
-const RtpExtension kVideoRtpExtensionMixedEncryptionAnswerEncryptionDisabled[] =
- {
- RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
- RtpExtension("http://google.com/testing/video_something", 13),
+const std::array kVideoRtpExtensionMixedEncryptionAnswerEncryptionDisabled = {
+ RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14),
+ RtpExtension("http://google.com/testing/video_something", 13),
};
-const RtpExtension kRtpExtensionTransportSequenceNumber01[] = {
+const std::array kRtpExtensionTransportSequenceNumber01 = {
RtpExtension("http://www.ietf.org/id/"
"draft-holmer-rmcat-transport-wide-cc-extensions-01",
1),
};
-const RtpExtension kRtpExtensionTransportSequenceNumber01And02[] = {
+const std::array kRtpExtensionTransportSequenceNumber01And02 = {
RtpExtension("http://www.ietf.org/id/"
"draft-holmer-rmcat-transport-wide-cc-extensions-01",
1),
@@ -413,13 +429,13 @@
2),
};
-const RtpExtension kRtpExtensionTransportSequenceNumber02[] = {
+const std::array kRtpExtensionTransportSequenceNumber02 = {
RtpExtension(
"http://www.webrtc.org/experiments/rtp-hdrext/transport-wide-cc-02",
2),
};
-const RtpExtension kRtpExtensionGenericFrameDescriptorUri00[] = {
+const std::array kRtpExtensionGenericFrameDescriptorUri00 = {
RtpExtension("http://www.webrtc.org/experiments/rtp-hdrext/"
"generic-frame-descriptor-00",
3),
@@ -467,8 +483,7 @@
return sb.Release();
}
-bool IsMediaContentOfType(const ContentInfo* content,
- webrtc::MediaType media_type) {
+bool IsMediaContentOfType(const ContentInfo* content, MediaType media_type) {
RTC_DCHECK(content);
return content->media_description()->type() == media_type;
}
@@ -484,10 +499,10 @@
codecs->push_back(rtx_codec);
}
-std::vector<std::string> GetCodecNames(const std::vector<Codec>& codecs) {
+std::vector<std::string> GetCodecNames(std::span<const Codec> codecs) {
std::vector<std::string> codec_names;
codec_names.reserve(codecs.size());
- for (const auto& codec : codecs) {
+ for (const Codec& codec : codecs) {
codec_names.push_back(codec.name);
}
return codec_names;
@@ -513,7 +528,7 @@
}
// Add a media section to the `session_options`.
-void AddMediaDescriptionOptions(webrtc::MediaType type,
+void AddMediaDescriptionOptions(MediaType type,
const std::string& mid,
RtpTransceiverDirection direction,
bool stopped,
@@ -524,36 +539,40 @@
void AddAudioVideoSections(RtpTransceiverDirection direction,
MediaSessionOptions* opts) {
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid, direction,
- kActive, opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid, direction,
- kActive, opts);
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, direction, kActive,
+ opts);
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, direction, kActive,
+ opts);
}
void AddDataSection(RtpTransceiverDirection direction,
MediaSessionOptions* opts) {
- AddMediaDescriptionOptions(webrtc::MediaType::DATA, kDataMid, direction,
- kActive, opts);
+ AddMediaDescriptionOptions(MediaType::DATA, kDataMid, direction, kActive,
+ opts);
}
void AttachSenderToMediaDescriptionOptions(
const std::string& mid,
- webrtc::MediaType type,
+ MediaType type,
const std::string& track_id,
- const std::vector<std::string>& stream_ids,
- const std::vector<RidDescription>& rids,
+ std::span<const std::string> stream_ids,
+ std::span<const RidDescription> rids,
const SimulcastLayerList& simulcast_layers,
int num_sim_layer,
MediaSessionOptions* session_options) {
auto it = FindFirstMediaDescriptionByMid(mid, session_options);
RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN();
switch (type) {
- case webrtc::MediaType::AUDIO:
- it->AddAudioSender(track_id, stream_ids);
+ case MediaType::AUDIO:
+ it->AddAudioSender(track_id, std::vector<std::string>(stream_ids.begin(),
+ stream_ids.end()));
break;
- case webrtc::MediaType::VIDEO:
- it->AddVideoSender(track_id, stream_ids, rids, simulcast_layers,
- num_sim_layer);
+ case MediaType::VIDEO:
+ it->AddVideoSender(
+ track_id,
+ std::vector<std::string>(stream_ids.begin(), stream_ids.end()),
+ std::vector<RidDescription>(rids.begin(), rids.end()),
+ simulcast_layers, num_sim_layer);
break;
default:
RTC_DCHECK_NOTREACHED();
@@ -563,9 +582,23 @@
void AttachSenderToMediaDescriptionOptions(
const std::string& mid,
- webrtc::MediaType type,
+ MediaType type,
const std::string& track_id,
- const std::vector<std::string>& stream_ids,
+ std::initializer_list<std::string> stream_ids,
+ std::span<const RidDescription> rids,
+ const SimulcastLayerList& simulcast_layers,
+ int num_sim_layer,
+ MediaSessionOptions* session_options) {
+ AttachSenderToMediaDescriptionOptions(
+ mid, type, track_id, std::span<const std::string>(stream_ids), rids,
+ simulcast_layers, num_sim_layer, session_options);
+}
+
+void AttachSenderToMediaDescriptionOptions(
+ const std::string& mid,
+ MediaType type,
+ const std::string& track_id,
+ std::span<const std::string> stream_ids,
int num_sim_layer,
MediaSessionOptions* session_options) {
AttachSenderToMediaDescriptionOptions(mid, type, track_id, stream_ids, {},
@@ -573,6 +606,33 @@
session_options);
}
+void AttachSenderToMediaDescriptionOptions(
+ const std::string& mid,
+ MediaType type,
+ const std::string& track_id,
+ std::initializer_list<std::string> stream_ids,
+ int num_sim_layer,
+ MediaSessionOptions* session_options) {
+ AttachSenderToMediaDescriptionOptions(
+ mid, type, track_id, std::span<const std::string>(stream_ids),
+ num_sim_layer, session_options);
+}
+
+void AttachSenderToMediaDescriptionOptions(
+ const std::string& mid,
+ MediaType type,
+ const std::string& track_id,
+ std::initializer_list<std::string> stream_ids,
+ std::initializer_list<RidDescription> rids,
+ const SimulcastLayerList& simulcast_layers,
+ int num_sim_layer,
+ MediaSessionOptions* session_options) {
+ AttachSenderToMediaDescriptionOptions(
+ mid, type, track_id, std::span<const std::string>(stream_ids),
+ std::span<const RidDescription>(rids), simulcast_layers, num_sim_layer,
+ session_options);
+}
+
void DetachSenderFromMediaSection(const std::string& mid,
const std::string& track_id,
MediaSessionOptions* session_options) {
@@ -589,7 +649,7 @@
// Helper function used to create recv-only audio MediaSessionOptions.
MediaSessionOptions CreateAudioMediaSession() {
MediaSessionOptions session_options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&session_options);
return session_options;
@@ -602,8 +662,7 @@
class MediaSessionDescriptionFactoryTest : public testing::Test {
public:
MediaSessionDescriptionFactoryTest(absl::string_view field_trials_string = "")
- : env_(CreateEnvironment(std::make_unique<FieldTrials>(
- CreateTestFieldTrials(field_trials_string)))),
+ : env_(CreateTestEnvironment({.field_trials = field_trials_string})),
tdf1_(env_.field_trials()),
tdf2_(env_.field_trials()),
codec_lookup_helper_1_(env_.field_trials()),
@@ -705,10 +764,8 @@
EXPECT_EQ(current_audio_ufrag, ti_audio->description.ice_ufrag);
EXPECT_EQ(current_audio_pwd, ti_audio->description.ice_pwd);
} else {
- EXPECT_EQ(static_cast<size_t>(ICE_UFRAG_LENGTH),
- ti_audio->description.ice_ufrag.size());
- EXPECT_EQ(static_cast<size_t>(ICE_PWD_LENGTH),
- ti_audio->description.ice_pwd.size());
+ EXPECT_THAT(ti_audio->description.ice_ufrag, SizeIs(ICE_UFRAG_LENGTH));
+ EXPECT_THAT(ti_audio->description.ice_pwd, SizeIs(ICE_PWD_LENGTH));
}
auto media_desc_options_it =
FindFirstMediaDescriptionByMid(kAudioMid, options);
@@ -729,10 +786,9 @@
EXPECT_EQ(current_video_ufrag, ti_video->description.ice_ufrag);
EXPECT_EQ(current_video_pwd, ti_video->description.ice_pwd);
} else {
- EXPECT_EQ(static_cast<size_t>(ICE_UFRAG_LENGTH),
- ti_video->description.ice_ufrag.size());
- EXPECT_EQ(static_cast<size_t>(ICE_PWD_LENGTH),
- ti_video->description.ice_pwd.size());
+ EXPECT_THAT(ti_video->description.ice_ufrag,
+ SizeIs(ICE_UFRAG_LENGTH));
+ EXPECT_THAT(ti_video->description.ice_pwd, SizeIs(ICE_PWD_LENGTH));
}
}
EXPECT_EQ(
@@ -750,10 +806,8 @@
EXPECT_EQ(current_data_ufrag, ti_data->description.ice_ufrag);
EXPECT_EQ(current_data_pwd, ti_data->description.ice_pwd);
} else {
- EXPECT_EQ(static_cast<size_t>(ICE_UFRAG_LENGTH),
- ti_data->description.ice_ufrag.size());
- EXPECT_EQ(static_cast<size_t>(ICE_PWD_LENGTH),
- ti_data->description.ice_pwd.size());
+ EXPECT_THAT(ti_data->description.ice_ufrag, SizeIs(ICE_UFRAG_LENGTH));
+ EXPECT_THAT(ti_data->description.ice_pwd, SizeIs(ICE_PWD_LENGTH));
}
}
auto media_desc_options_it =
@@ -805,9 +859,9 @@
}
void TestTransportSequenceNumberNegotiation(
- const RtpHeaderExtensions& local,
- const RtpHeaderExtensions& offered,
- const RtpHeaderExtensions& expectedAnswer) {
+ std::span<const RtpExtension> local,
+ std::span<const RtpExtension> offered,
+ std::span<const RtpExtension> expectedAnswer) {
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
SetAudioVideoRtpHeaderExtensions(offered, offered, &opts);
@@ -829,9 +883,10 @@
}
std::vector<RtpHeaderExtensionCapability>
- HeaderExtensionCapabilitiesFromRtpExtensions(RtpHeaderExtensions extensions) {
+ HeaderExtensionCapabilitiesFromRtpExtensions(
+ std::span<const RtpExtension> extensions) {
std::vector<RtpHeaderExtensionCapability> capabilities;
- for (const auto& extension : extensions) {
+ for (const RtpExtension& extension : extensions) {
RtpHeaderExtensionCapability capability(
extension.uri, extension.id, extension.encrypt,
RtpTransceiverDirection::kSendRecv);
@@ -840,19 +895,20 @@
return capabilities;
}
- void SetAudioVideoRtpHeaderExtensions(RtpHeaderExtensions audio_exts,
- RtpHeaderExtensions video_exts,
- MediaSessionOptions* opts) {
+ void SetAudioVideoRtpHeaderExtensions(
+ std::span<const RtpExtension> audio_exts,
+ std::span<const RtpExtension> video_exts,
+ MediaSessionOptions* opts) {
std::vector<RtpHeaderExtensionCapability> audio_caps =
HeaderExtensionCapabilitiesFromRtpExtensions(audio_exts);
std::vector<RtpHeaderExtensionCapability> video_caps =
HeaderExtensionCapabilitiesFromRtpExtensions(video_exts);
- for (auto& entry : opts->media_description_options) {
+ for (MediaDescriptionOptions& entry : opts->media_description_options) {
switch (entry.type) {
- case webrtc::MediaType::AUDIO:
+ case MediaType::AUDIO:
entry.header_extensions = audio_caps;
break;
- case webrtc::MediaType::VIDEO:
+ case MediaType::VIDEO:
entry.header_extensions = video_caps;
break;
default:
@@ -884,16 +940,18 @@
const ContentInfo* vc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
EXPECT_FALSE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_THAT(codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs(),
- ElementsAreArray(acd->codecs()));
- EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached.
- EXPECT_EQ(kAutoBandwidth,
- acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor()
+ ->audio_sendrecv_codecs()
+ .codecs(),
+ &env_.field_trials()));
+ EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached.
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
- EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
+ EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf);
}
// Create an offer with just Opus and RED.
@@ -901,14 +959,13 @@
TestCreateAudioOfferWithJustOpusAndRed) {
// First, prefer to only use opus and red.
std::vector<RtpCodecCapability> preferences;
- preferences.push_back(webrtc::ToRtpCodecCapability(
+ preferences.push_back(ToRtpCodecCapability(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[0]));
- preferences.push_back(webrtc::ToRtpCodecCapability(
+ preferences.push_back(ToRtpCodecCapability(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[1]));
- EXPECT_EQ("opus", preferences[0].name);
- EXPECT_EQ("red", preferences[1].name);
+ EXPECT_THAT(preferences, NamesMatch({"opus", "red"}));
- auto opts = CreateAudioMediaSession();
+ MediaSessionOptions opts = CreateAudioMediaSession();
opts.media_description_options.at(0).codec_preferences = preferences;
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -917,26 +974,23 @@
const ContentInfo* vc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac != nullptr);
ASSERT_TRUE(vc == nullptr);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_EQ(2U, acd->codecs().size());
- EXPECT_EQ("opus", acd->codecs()[0].name);
- EXPECT_EQ("red", acd->codecs()[1].name);
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(), NamesMatch({"opus", "red"}));
}
// Create an offer with RED before Opus, which enables RED with Opus encoding.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOfferWithRedForOpus) {
// First, prefer to only use opus and red.
std::vector<RtpCodecCapability> preferences;
- preferences.push_back(webrtc::ToRtpCodecCapability(
+ preferences.push_back(ToRtpCodecCapability(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[1]));
- preferences.push_back(webrtc::ToRtpCodecCapability(
+ preferences.push_back(ToRtpCodecCapability(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[0]));
- EXPECT_EQ("red", preferences[0].name);
- EXPECT_EQ("opus", preferences[1].name);
+ EXPECT_THAT(preferences, NamesMatch({"red", "opus"}));
- auto opts = CreateAudioMediaSession();
+ MediaSessionOptions opts = CreateAudioMediaSession();
opts.media_description_options.at(0).codec_preferences = preferences;
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -945,12 +999,10 @@
const ContentInfo* vc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac != nullptr);
ASSERT_TRUE(vc == nullptr);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_EQ(2U, acd->codecs().size());
- EXPECT_EQ("red", acd->codecs()[0].name);
- EXPECT_EQ("opus", acd->codecs()[1].name);
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(), NamesMatch({"red", "opus"}));
}
// Create a typical video offer, and ensure it matches what we expect.
@@ -964,28 +1016,26 @@
const ContentInfo* vc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
ASSERT_TRUE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
- EXPECT_EQ(MediaProtocolType::kRtp, vc->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
+ EXPECT_EQ(vc->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
EXPECT_EQ(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs().codecs(),
acd->codecs());
- EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached
- EXPECT_EQ(kAutoBandwidth,
- acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
- EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
+ EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf);
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
EXPECT_EQ(
codec_lookup_helper_1_.GetCodecVendor()->video_sendrecv_codecs().codecs(),
vcd->codecs());
- EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached
- EXPECT_EQ(kAutoBandwidth,
- vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(vcd->first_ssrc(), 0U); // no sender is attached
+ EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
- EXPECT_EQ(kMediaProtocolDtlsSavpf, vcd->protocol());
+ EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf);
}
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferWithCustomCodecs) {
@@ -994,17 +1044,15 @@
SdpAudioFormat audio_format("custom-audio", 8000, 2);
Codec custom_audio_codec = CreateAudioCodec(audio_format);
custom_audio_codec.id = 123; // picked at random, but valid
- auto audio_options =
- MediaDescriptionOptions(webrtc::MediaType::AUDIO, "0",
- RtpTransceiverDirection::kSendRecv, kActive);
+ auto audio_options = MediaDescriptionOptions(
+ MediaType::AUDIO, "0", RtpTransceiverDirection::kSendRecv, kActive);
audio_options.codecs_to_include.push_back(custom_audio_codec);
opts.media_description_options.push_back(audio_options);
Codec custom_video_codec = CreateVideoCodec("custom-video");
custom_video_codec.id = 124; // picked at random, but valid
- auto video_options =
- MediaDescriptionOptions(webrtc::MediaType::VIDEO, "1",
- RtpTransceiverDirection::kSendRecv, kActive);
+ auto video_options = MediaDescriptionOptions(
+ MediaType::VIDEO, "1", RtpTransceiverDirection::kSendRecv, kActive);
video_options.codecs_to_include.push_back(custom_video_codec);
opts.media_description_options.push_back(video_options);
@@ -1015,19 +1063,15 @@
const ContentInfo* vc = offer->GetContentByName("1");
ASSERT_TRUE(ac);
ASSERT_TRUE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
- EXPECT_EQ(MediaProtocolType::kRtp, vc->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
+ EXPECT_EQ(vc->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- ASSERT_EQ(acd->codecs().size(), 1U);
- // Fields in codec are set during the gen process, so simple compare
- // does not work.
- EXPECT_EQ(acd->codecs()[0].name, custom_audio_codec.name);
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(), NamesMatch({custom_audio_codec.name}));
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
- ASSERT_EQ(vcd->codecs().size(), 1U);
- EXPECT_EQ(vcd->codecs()[0].name, custom_video_codec.name);
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
+ EXPECT_THAT(vcd->codecs(), NamesMatch({custom_video_codec.name}));
}
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerWithCustomCodecs) {
@@ -1042,17 +1086,15 @@
SdpAudioFormat audio_format("custom-audio", 8000, 2);
Codec custom_audio_codec = CreateAudioCodec(audio_format);
custom_audio_codec.id = 123; // picked at random, but valid
- auto audio_options =
- MediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
- RtpTransceiverDirection::kSendRecv, kActive);
+ auto audio_options = MediaDescriptionOptions(
+ MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive);
audio_options.codecs_to_include.push_back(custom_audio_codec);
answer_opts.media_description_options.push_back(audio_options);
Codec custom_video_codec = CreateVideoCodec("custom-video");
custom_video_codec.id = 124;
- auto video_options =
- MediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
- RtpTransceiverDirection::kSendRecv, kActive);
+ auto video_options = MediaDescriptionOptions(
+ MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive);
video_options.codecs_to_include.push_back(custom_video_codec);
answer_opts.media_description_options.push_back(video_options);
@@ -1065,19 +1107,15 @@
const ContentInfo* vc = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
ASSERT_TRUE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
- EXPECT_EQ(MediaProtocolType::kRtp, vc->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
+ EXPECT_EQ(vc->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- ASSERT_EQ(acd->codecs().size(), 1U);
- // Fields in codec are set during the gen process, so simple compare
- // does not work.
- EXPECT_EQ(acd->codecs()[0].name, custom_audio_codec.name);
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(), NamesMatch({custom_audio_codec.name}));
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
- ASSERT_EQ(vcd->codecs().size(), 1U);
- EXPECT_EQ(vcd->codecs()[0].name, custom_video_codec.name);
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
+ EXPECT_THAT(vcd->codecs(), NamesMatch({custom_video_codec.name}));
}
// Test creating an offer with bundle where the Codecs have the same dynamic
@@ -1111,10 +1149,10 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestCreateUpdatedVideoOfferWithBundle) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kInactive, kStopped,
&opts);
opts.bundle_enabled = true;
@@ -1136,8 +1174,8 @@
EXPECT_TRUE(vcd);
EXPECT_TRUE(acd);
- EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
- EXPECT_EQ(kMediaProtocolDtlsSavpf, vcd->protocol());
+ EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf);
+ EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf);
}
// Create an SCTP data offer with bundle without error.
@@ -1152,7 +1190,7 @@
auto dcd = GetFirstSctpDataContentDescription(offer.get());
ASSERT_TRUE(dcd);
// Since this transport is insecure, the protocol should be "SCTP".
- EXPECT_EQ(kMediaProtocolUdpDtlsSctp, dcd->protocol());
+ EXPECT_EQ(dcd->protocol(), kMediaProtocolUdpDtlsSctp);
}
// Create an SCTP data offer with bundle without error.
@@ -1167,7 +1205,7 @@
auto dcd = GetFirstSctpDataContentDescription(offer.get());
ASSERT_TRUE(dcd);
// The protocol should now be "UDP/DTLS/SCTP"
- EXPECT_EQ(kMediaProtocolUdpDtlsSctp, dcd->protocol());
+ EXPECT_EQ(dcd->protocol(), kMediaProtocolUdpDtlsSctp);
}
// Test creating an sctp data channel from an already generated offer.
@@ -1180,13 +1218,13 @@
ASSERT_TRUE(offer1.get());
const ContentInfo* data = offer1->GetContentByName(kDataMid);
ASSERT_TRUE(data);
- ASSERT_EQ(kMediaProtocolUdpDtlsSctp, data->media_description()->protocol());
+ ASSERT_EQ(data->media_description()->protocol(), kMediaProtocolUdpDtlsSctp);
std::unique_ptr<SessionDescription> offer2(
f1_.CreateOfferOrError(opts, offer1.get()).MoveValue());
data = offer2->GetContentByName(kDataMid);
ASSERT_TRUE(data);
- EXPECT_EQ(kMediaProtocolUdpDtlsSctp, data->media_description()->protocol());
+ EXPECT_EQ(data->media_description()->protocol(), kMediaProtocolUdpDtlsSctp);
}
// Test that if BUNDLE is enabled and all media sections are rejected then the
@@ -1194,7 +1232,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, ReOfferNoBundleGroupIfAllRejected) {
MediaSessionOptions opts;
opts.bundle_enabled = true;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -1213,7 +1251,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerNoBundleGroupIfAllRejected) {
MediaSessionOptions opts;
opts.bundle_enabled = true;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -1236,7 +1274,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, ReOfferChangeBundleOffererTagged) {
MediaSessionOptions opts;
opts.bundle_enabled = true;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -1244,7 +1282,7 @@
// Reject the audio m= section and add a video m= section.
opts.media_description_options[0].stopped = true;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> reoffer =
@@ -1262,7 +1300,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerChangedBundleOffererTagged) {
MediaSessionOptions opts;
opts.bundle_enabled = true;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -1272,7 +1310,7 @@
// Reject the audio m= section and add a video m= section.
opts.media_description_options[0].stopped = true;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> reoffer =
@@ -1292,16 +1330,16 @@
// Create an offer with 4 m= sections, initially without BUNDLE groups.
MediaSessionOptions opts;
opts.bundle_enabled = false;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "3",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "3",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "4",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "4",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -1431,26 +1469,22 @@
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSendOnlyOffer) {
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kSendOnly, &opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
- kAudioTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- EXPECT_EQ(2u, offer->contents().size());
- EXPECT_TRUE(
- IsMediaContentOfType(&offer->contents()[0], webrtc::MediaType::AUDIO));
- EXPECT_TRUE(
- IsMediaContentOfType(&offer->contents()[1], webrtc::MediaType::VIDEO));
+ EXPECT_EQ(offer->contents().size(), 2u);
+ EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[0], MediaType::AUDIO));
+ EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[1], MediaType::VIDEO));
- EXPECT_EQ(RtpTransceiverDirection::kSendOnly,
- GetMediaDirection(&offer->contents()[0]));
- EXPECT_EQ(RtpTransceiverDirection::kSendOnly,
- GetMediaDirection(&offer->contents()[1]));
+ EXPECT_EQ(GetMediaDirection(&offer->contents()[0]),
+ RtpTransceiverDirection::kSendOnly);
+ EXPECT_EQ(GetMediaDirection(&offer->contents()[1]),
+ RtpTransceiverDirection::kSendOnly);
}
// Verifies that the order of the media contents in the current
@@ -1462,35 +1496,29 @@
std::unique_ptr<SessionDescription> offer1(
f1_.CreateOfferOrError(opts, nullptr).MoveValue());
ASSERT_TRUE(offer1.get());
- EXPECT_EQ(1u, offer1->contents().size());
- EXPECT_TRUE(
- IsMediaContentOfType(&offer1->contents()[0], webrtc::MediaType::DATA));
+ EXPECT_EQ(offer1->contents().size(), 1u);
+ EXPECT_TRUE(IsMediaContentOfType(&offer1->contents()[0], MediaType::DATA));
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::unique_ptr<SessionDescription> offer2(
f1_.CreateOfferOrError(opts, offer1.get()).MoveValue());
ASSERT_TRUE(offer2.get());
- EXPECT_EQ(2u, offer2->contents().size());
- EXPECT_TRUE(
- IsMediaContentOfType(&offer2->contents()[0], webrtc::MediaType::DATA));
- EXPECT_TRUE(
- IsMediaContentOfType(&offer2->contents()[1], webrtc::MediaType::VIDEO));
+ EXPECT_EQ(offer2->contents().size(), 2u);
+ EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[0], MediaType::DATA));
+ EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[1], MediaType::VIDEO));
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::unique_ptr<SessionDescription> offer3(
f1_.CreateOfferOrError(opts, offer2.get()).MoveValue());
ASSERT_TRUE(offer3.get());
- EXPECT_EQ(3u, offer3->contents().size());
- EXPECT_TRUE(
- IsMediaContentOfType(&offer3->contents()[0], webrtc::MediaType::DATA));
- EXPECT_TRUE(
- IsMediaContentOfType(&offer3->contents()[1], webrtc::MediaType::VIDEO));
- EXPECT_TRUE(
- IsMediaContentOfType(&offer3->contents()[2], webrtc::MediaType::AUDIO));
+ EXPECT_EQ(offer3->contents().size(), 3u);
+ EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[0], MediaType::DATA));
+ EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[1], MediaType::VIDEO));
+ EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[2], MediaType::AUDIO));
}
// Create a typical audio answer, and ensure it matches what we expect.
@@ -1505,14 +1533,15 @@
const ContentInfo* vc = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
EXPECT_FALSE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
- EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached
- EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
+ EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw
EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
- EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
+ EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf);
}
// Create a typical audio answer with GCM ciphers enabled, and ensure it
@@ -1528,21 +1557,22 @@
const ContentInfo* vc = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
EXPECT_FALSE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
- EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached
- EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
+ EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw
EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
- EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
+ EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf);
}
// Create an audio answer with no common codecs, and ensure it is rejected.
TEST_F(MediaSessionDescriptionFactoryTest,
TestCreateAudioAnswerWithNoCommonCodecs) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
codec_lookup_helper_1_.SetAudioCodecs(
@@ -1571,27 +1601,29 @@
const ContentInfo* vc = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
ASSERT_TRUE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
- EXPECT_EQ(MediaProtocolType::kRtp, vc->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
+ EXPECT_EQ(vc->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
- EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // negotiated auto bw
- EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw
+ EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached
EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
- EXPECT_THAT(vcd->codecs(), ElementsAreArray(kVideoCodecsAnswer));
- EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials()));
+ EXPECT_EQ(vcd->first_ssrc(), 0U); // no sender is attached
EXPECT_TRUE(vcd->rtcp_mux()); // negotiated rtcp-mux
- EXPECT_EQ(kMediaProtocolDtlsSavpf, vcd->protocol());
+ EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf);
}
// Create a video answer with no common codecs, and ensure it is rejected.
TEST_F(MediaSessionDescriptionFactoryTest,
TestCreateVideoAnswerWithNoCommonCodecs) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
codec_lookup_helper_1_.SetVideoCodecs({CreateVideoCodec(96, "H264")});
@@ -1611,7 +1643,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestCreateVideoAnswerWithOnlyFecCodecsCommon) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
codec_lookup_helper_1_.SetVideoCodecs(
@@ -1723,7 +1755,7 @@
const SctpDataContentDescription* dcd_answer =
dc_answer->media_description()->as_sctp();
EXPECT_FALSE(dc_answer->rejected);
- EXPECT_EQ(1234, dcd_answer->max_message_size());
+ EXPECT_EQ(dcd_answer->max_message_size(), 1234);
}
TEST_F(MediaSessionDescriptionFactoryTest,
@@ -1746,7 +1778,7 @@
const SctpDataContentDescription* dcd_answer =
dc_answer->media_description()->as_sctp();
EXPECT_FALSE(dc_answer->rejected);
- EXPECT_EQ(webrtc::kSctpSendBufferSize, dcd_answer->max_message_size());
+ EXPECT_EQ(dcd_answer->max_message_size(), kSctpSendBufferSize);
}
class MediaSessionDescriptionFactorySnapTest
@@ -1837,7 +1869,7 @@
ASSERT_TRUE(offer1.get());
// Appends audio to the offer.
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::unique_ptr<SessionDescription> offer2(
@@ -1845,7 +1877,7 @@
ASSERT_TRUE(offer2.get());
// Appends video to the offer.
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::unique_ptr<SessionDescription> offer3(
@@ -1855,13 +1887,10 @@
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer3.get(), opts, nullptr).MoveValue();
ASSERT_TRUE(answer.get());
- EXPECT_EQ(3u, answer->contents().size());
- EXPECT_TRUE(
- IsMediaContentOfType(&answer->contents()[0], webrtc::MediaType::DATA));
- EXPECT_TRUE(
- IsMediaContentOfType(&answer->contents()[1], webrtc::MediaType::AUDIO));
- EXPECT_TRUE(
- IsMediaContentOfType(&answer->contents()[2], webrtc::MediaType::VIDEO));
+ EXPECT_EQ(answer->contents().size(), 3u);
+ EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[0], MediaType::DATA));
+ EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[1], MediaType::AUDIO));
+ EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[2], MediaType::VIDEO));
}
// TODO(deadbeef): Extend these tests to ensure the correct direction with other
@@ -1908,7 +1937,7 @@
const AudioContentDescription* offer_acd =
GetFirstAudioContentDescription(offer.get());
ASSERT_TRUE(offer_acd);
- EXPECT_EQ(kMediaProtocolAvpf, offer_acd->protocol());
+ EXPECT_EQ(offer_acd->protocol(), kMediaProtocolAvpf);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -1920,7 +1949,7 @@
const AudioContentDescription* answer_acd =
GetFirstAudioContentDescription(answer.get());
ASSERT_TRUE(answer_acd);
- EXPECT_EQ(kMediaProtocolAvpf, answer_acd->protocol());
+ EXPECT_EQ(answer_acd->protocol(), kMediaProtocolAvpf);
}
// Create a audio/video offer and answer and ensure that the
@@ -1929,66 +1958,65 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1LocalAndV1InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01, // Local.
+ kRtpExtensionTransportSequenceNumber01, // Offer.
+ kRtpExtensionTransportSequenceNumber01); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1LocalAndV1V2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01, // Local.
+ kRtpExtensionTransportSequenceNumber01And02, // Offer.
+ kRtpExtensionTransportSequenceNumber01); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1LocalAndV2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Offer.
- {}); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01, // Local.
+ kRtpExtensionTransportSequenceNumber02, // Offer.
+ {}); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV2LocalAndV1InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Offer.
- {}); // Expected answer.
+ kRtpExtensionTransportSequenceNumber02, // Local.
+ kRtpExtensionTransportSequenceNumber01, // Offer.
+ {}); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV2LocalAndV1V2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber02, // Local.
+ kRtpExtensionTransportSequenceNumber01And02, // Offer.
+ kRtpExtensionTransportSequenceNumber02); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV2LocalAndV2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber02, // Local.
+ kRtpExtensionTransportSequenceNumber02, // Offer.
+ kRtpExtensionTransportSequenceNumber02); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV1InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01And02, // Local.
+ kRtpExtensionTransportSequenceNumber01, // Offer.
+ kRtpExtensionTransportSequenceNumber01); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02), // Offer.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber02)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01And02, // Local.
+ kRtpExtensionTransportSequenceNumber02, // Offer.
+ kRtpExtensionTransportSequenceNumber02); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV1V2InOffer) {
TestTransportSequenceNumberNegotiation(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Local.
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01And02), // Offer.
- MAKE_VECTOR(
- kRtpExtensionTransportSequenceNumber01And02)); // Expected answer.
+ kRtpExtensionTransportSequenceNumber01And02, // Local.
+ kRtpExtensionTransportSequenceNumber01And02, // Offer.
+ kRtpExtensionTransportSequenceNumber01And02); // Expected answer.
}
TEST_F(MediaSessionDescriptionFactoryTest,
@@ -1996,14 +2024,14 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kRtpExtensionGenericFrameDescriptorUri00),
- MAKE_VECTOR(kRtpExtensionGenericFrameDescriptorUri00), &opts);
+ SetAudioVideoRtpHeaderExtensions(kRtpExtensionGenericFrameDescriptorUri00,
+ kRtpExtensionGenericFrameDescriptorUri00,
+ &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01),
- MAKE_VECTOR(kRtpExtensionTransportSequenceNumber01), &opts);
+ SetAudioVideoRtpHeaderExtensions(kRtpExtensionTransportSequenceNumber01,
+ kRtpExtensionTransportSequenceNumber01,
+ &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
EXPECT_THAT(
@@ -2019,9 +2047,9 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kRtpExtensionGenericFrameDescriptorUri00),
- MAKE_VECTOR(kRtpExtensionGenericFrameDescriptorUri00), &opts);
+ SetAudioVideoRtpHeaderExtensions(kRtpExtensionGenericFrameDescriptorUri00,
+ kRtpExtensionGenericFrameDescriptorUri00,
+ &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
std::unique_ptr<SessionDescription> answer =
@@ -2040,11 +2068,11 @@
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
RtpExtension offer_dd(RtpExtension::kDependencyDescriptorUri, 7);
- SetAudioVideoRtpHeaderExtensions({}, {offer_dd}, &opts);
+ SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{offer_dd}, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
RtpExtension local_tsn(RtpExtension::kTransportSequenceNumberUri, 5);
- SetAudioVideoRtpHeaderExtensions({}, {local_tsn}, &opts);
+ SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{local_tsn}, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
EXPECT_THAT(
@@ -2059,10 +2087,10 @@
RtpExtension offer_dd(RtpExtension::kDependencyDescriptorUri, 7);
RtpExtension local_dd(RtpExtension::kDependencyDescriptorUri, 5);
- SetAudioVideoRtpHeaderExtensions({}, {offer_dd}, &opts);
+ SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{offer_dd}, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
- SetAudioVideoRtpHeaderExtensions({}, {local_dd}, &opts);
+ SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{local_dd}, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
EXPECT_THAT(
@@ -2145,7 +2173,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
OffersUnstoppedExtensionsWithAudioVideoExtensionStopped) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2153,7 +2181,7 @@
RtpTransceiverDirection::kStopped),
RtpHeaderExtensionCapability("uri2", 3,
RtpTransceiverDirection::kSendOnly)};
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2179,7 +2207,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
OffersUnstoppedExtensionsWithAudioExtensionStopped) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2187,7 +2215,7 @@
RtpTransceiverDirection::kSendOnly),
RtpHeaderExtensionCapability("uri2", 3,
RtpTransceiverDirection::kStopped)};
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2215,7 +2243,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
OffersUnstoppedExtensionsWithVideoExtensionStopped) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2223,7 +2251,7 @@
RtpTransceiverDirection::kSendOnly),
RtpHeaderExtensionCapability("uri2", 7,
RtpTransceiverDirection::kSendRecv)};
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2250,7 +2278,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, AnswersUnstoppedExtensions) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2287,7 +2315,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
AppendsUnstoppedExtensionsToCurrentDescription) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2318,7 +2346,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
AllowsStoppedExtensionsToBeRemovedFromSubsequentOffer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
opts.media_description_options.back().header_extensions = {
@@ -2351,14 +2379,14 @@
TestOfferAnswerWithRtpExtensionHeadersWithNoEncryption) {
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtension1),
- MAKE_VECTOR(kVideoRtpExtension1), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension1, kVideoRtpExtension1,
+ &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtension2),
- MAKE_VECTOR(kVideoRtpExtension2), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension2, kVideoRtpExtension2,
+ &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -2384,15 +2412,13 @@
f1_.set_enable_encrypted_rtp_header_extensions(true);
f2_.set_enable_encrypted_rtp_header_extensions(true);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted1),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted1),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1,
+ kVideoRtpExtensionEncrypted1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted2),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted2),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2,
+ kVideoRtpExtensionEncrypted2, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -2417,15 +2443,13 @@
f2_.set_enable_encrypted_rtp_header_extensions(false);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted1),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted1),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1,
+ kVideoRtpExtensionEncrypted1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted2),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted2),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2,
+ kVideoRtpExtensionEncrypted2, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -2450,15 +2474,13 @@
f1_.set_enable_encrypted_rtp_header_extensions(false);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted1),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted1),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1,
+ kVideoRtpExtensionEncrypted1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtensionEncrypted2),
- MAKE_VECTOR(kVideoRtpExtensionEncrypted2),
- &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2,
+ kVideoRtpExtensionEncrypted2, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -2482,15 +2504,13 @@
opts.offer_extmap_allow_mixed = true;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kAudioRtpExtensionMixedEncryption1),
- MAKE_VECTOR(kVideoRtpExtensionMixedEncryption), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption1,
+ kVideoRtpExtensionMixedEncryption, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kAudioRtpExtensionMixedEncryption2),
- MAKE_VECTOR(kVideoRtpExtensionMixedEncryption), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption2,
+ kVideoRtpExtensionMixedEncryption, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_TRUE(answer.get());
@@ -2519,15 +2539,13 @@
f1_.set_enable_encrypted_rtp_header_extensions(false);
f2_.set_enable_encrypted_rtp_header_extensions(false);
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kAudioRtpExtensionMixedEncryption1),
- MAKE_VECTOR(kVideoRtpExtensionMixedEncryption), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption1,
+ kVideoRtpExtensionMixedEncryption, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
- SetAudioVideoRtpHeaderExtensions(
- MAKE_VECTOR(kAudioRtpExtensionMixedEncryption2),
- MAKE_VECTOR(kVideoRtpExtensionMixedEncryption), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption2,
+ kVideoRtpExtensionMixedEncryption, &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_TRUE(answer.get());
@@ -2642,10 +2660,10 @@
// Create an audio-only answer to a video offer.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -2728,10 +2746,10 @@
offer->GetContentDescriptionByName(kAudioMid);
MediaContentDescription* video_offer =
offer->GetContentDescriptionByName(kVideoMid);
- ASSERT_EQ(MediaContentDescription::kNo,
- audio_offer->extmap_allow_mixed_enum());
- ASSERT_EQ(MediaContentDescription::kNo,
- video_offer->extmap_allow_mixed_enum());
+ ASSERT_EQ(audio_offer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kNo);
+ ASSERT_EQ(video_offer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kNo);
std::unique_ptr<SessionDescription> answer(
f2_.CreateAnswerOrError(offer.get(), opts,
@@ -2742,10 +2760,10 @@
answer->GetContentDescriptionByName(kAudioMid);
MediaContentDescription* video_answer =
answer->GetContentDescriptionByName(kVideoMid);
- EXPECT_EQ(MediaContentDescription::kNo,
- audio_answer->extmap_allow_mixed_enum());
- EXPECT_EQ(MediaContentDescription::kNo,
- video_answer->extmap_allow_mixed_enum());
+ EXPECT_EQ(audio_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kNo);
+ EXPECT_EQ(video_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kNo);
}
TEST_F(MediaSessionDescriptionFactoryTest,
@@ -2771,10 +2789,10 @@
answer->GetContentDescriptionByName(kAudioMid);
MediaContentDescription* video_answer =
answer->GetContentDescriptionByName(kVideoMid);
- EXPECT_EQ(MediaContentDescription::kMedia,
- audio_answer->extmap_allow_mixed_enum());
- EXPECT_EQ(MediaContentDescription::kMedia,
- video_answer->extmap_allow_mixed_enum());
+ EXPECT_EQ(audio_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kMedia);
+ EXPECT_EQ(video_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kMedia);
}
TEST_F(MediaSessionDescriptionFactoryTest,
@@ -2800,10 +2818,10 @@
answer->GetContentDescriptionByName(kAudioMid);
MediaContentDescription* video_answer =
answer->GetContentDescriptionByName(kVideoMid);
- EXPECT_EQ(MediaContentDescription::kNo,
- audio_answer->extmap_allow_mixed_enum());
- EXPECT_EQ(MediaContentDescription::kMedia,
- video_answer->extmap_allow_mixed_enum());
+ EXPECT_EQ(audio_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kNo);
+ EXPECT_EQ(video_answer->extmap_allow_mixed_enum(),
+ MediaContentDescription::kMedia);
}
// Create an audio and video offer with:
@@ -2814,15 +2832,12 @@
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
- kAudioTrack1, {kMediaStream1}, 1,
- &opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
- kAudioTrack2, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kAudioMid, MediaType::AUDIO, kAudioTrack2, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -2834,47 +2849,43 @@
ASSERT_TRUE(vc);
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
EXPECT_EQ(
codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs().codecs(),
acd->codecs());
const StreamParamsVec& audio_streams = acd->streams();
- ASSERT_EQ(2U, audio_streams.size());
+ ASSERT_EQ(audio_streams.size(), 2U);
EXPECT_EQ(audio_streams[0].cname, audio_streams[1].cname);
- EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
- ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
- EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
- EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
- ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
- EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
+ EXPECT_EQ(audio_streams[0].id, kAudioTrack1);
+ ASSERT_EQ(audio_streams[0].ssrcs.size(), 1U);
+ EXPECT_NE(audio_streams[0].ssrcs[0], 0U);
+ EXPECT_EQ(audio_streams[1].id, kAudioTrack2);
+ ASSERT_EQ(audio_streams[1].ssrcs.size(), 1U);
+ EXPECT_NE(audio_streams[1].ssrcs[0], 0U);
- EXPECT_EQ(kAutoBandwidth,
- acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
EXPECT_EQ(
codec_lookup_helper_1_.GetCodecVendor()->video_sendrecv_codecs().codecs(),
vcd->codecs());
const StreamParamsVec& video_streams = vcd->streams();
- ASSERT_EQ(1U, video_streams.size());
+ ASSERT_EQ(video_streams.size(), 1U);
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
- EXPECT_EQ(kVideoTrack1, video_streams[0].id);
- EXPECT_EQ(kAutoBandwidth,
- vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(video_streams[0].id, kVideoTrack1);
+ EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
// Update the offer. Add a new video track that is not synched to the
// other tracks and replace audio track 2 with audio track 3.
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack2, {kMediaStream2}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts);
DetachSenderFromMediaSection(kAudioMid, kAudioTrack2, &opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
- kAudioTrack3, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kAudioMid, MediaType::AUDIO, kAudioTrack3, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> updated_offer(
f1_.CreateOfferOrError(opts, offer.get()).MoveValue());
@@ -2887,22 +2898,24 @@
const MediaContentDescription* updated_vcd = vc->media_description();
EXPECT_EQ(acd->type(), updated_acd->type());
- EXPECT_EQ(acd->codecs(), updated_acd->codecs());
+ EXPECT_THAT(updated_acd->codecs(),
+ CodecListsMatch(acd->codecs(), &env_.field_trials()));
EXPECT_EQ(vcd->type(), updated_vcd->type());
- EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
+ EXPECT_THAT(updated_vcd->codecs(),
+ CodecListsMatch(vcd->codecs(), &env_.field_trials()));
const StreamParamsVec& updated_audio_streams = updated_acd->streams();
- ASSERT_EQ(2U, updated_audio_streams.size());
+ ASSERT_EQ(updated_audio_streams.size(), 2U);
EXPECT_EQ(audio_streams[0], updated_audio_streams[0]);
- EXPECT_EQ(kAudioTrack3, updated_audio_streams[1].id); // New audio track.
- ASSERT_EQ(1U, updated_audio_streams[1].ssrcs.size());
- EXPECT_NE(0U, updated_audio_streams[1].ssrcs[0]);
+ EXPECT_EQ(updated_audio_streams[1].id, kAudioTrack3); // New audio track.
+ ASSERT_EQ(updated_audio_streams[1].ssrcs.size(), 1U);
+ EXPECT_NE(updated_audio_streams[1].ssrcs[0], 0U);
EXPECT_EQ(updated_audio_streams[0].cname, updated_audio_streams[1].cname);
const StreamParamsVec& updated_video_streams = updated_vcd->streams();
- ASSERT_EQ(2U, updated_video_streams.size());
+ ASSERT_EQ(updated_video_streams.size(), 2U);
EXPECT_EQ(video_streams[0], updated_video_streams[0]);
- EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
+ EXPECT_EQ(updated_video_streams[1].id, kVideoTrack2);
// All the media streams in one PeerConnection share one RTCP CNAME.
EXPECT_EQ(updated_video_streams[1].cname, updated_video_streams[0].cname);
}
@@ -2910,14 +2923,14 @@
// Create an offer with simulcast video stream.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
const int num_sim_layers = 3;
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1},
num_sim_layers, &opts);
std::unique_ptr<SessionDescription> offer =
@@ -2929,8 +2942,8 @@
const MediaContentDescription* vcd = vc->media_description();
const StreamParamsVec& video_streams = vcd->streams();
- ASSERT_EQ(1U, video_streams.size());
- EXPECT_EQ(kVideoTrack1, video_streams[0].id);
+ ASSERT_EQ(video_streams.size(), 1U);
+ EXPECT_EQ(video_streams[0].id, kVideoTrack1);
const SsrcGroup* sim_ssrc_group =
video_streams[0].get_ssrc_group(kSimSsrcGroupSemantics);
ASSERT_TRUE(sim_ssrc_group);
@@ -2946,7 +2959,7 @@
void CheckSimulcastInSessionDescription(
const SessionDescription* description,
const std::string& content_name,
- const std::vector<RidDescription>& send_rids,
+ std::span<const RidDescription> send_rids,
const SimulcastLayerList& send_layers) {
ASSERT_NE(description, nullptr);
const ContentInfo* content = description->GetContentByName(content_name);
@@ -2973,7 +2986,7 @@
// Create an offer with spec-compliant simulcast video stream.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateCompliantSimulcastOffer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::vector<RidDescription> send_rids;
@@ -2984,7 +2997,7 @@
simulcast_layers.AddLayer(SimulcastLayer(send_rids[0].rid, false));
simulcast_layers.AddLayer(SimulcastLayer(send_rids[1].rid, true));
simulcast_layers.AddLayer(SimulcastLayer(send_rids[2].rid, false));
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1},
send_rids, simulcast_layers, 0, &opts);
std::unique_ptr<SessionDescription> offer =
@@ -2998,11 +3011,11 @@
// In this scenario, RIDs do not need to be negotiated (there is only one).
TEST_F(MediaSessionDescriptionFactoryTest, TestOfferWithRidsNoSimulcast) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
RidDescription rid("f", RidDirection::kSend);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, {rid},
SimulcastLayerList(), 0, &opts);
std::unique_ptr<SessionDescription> offer =
@@ -3025,17 +3038,17 @@
// In this scenario, the SFU is the caller requesting that we send Simulcast.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateCompliantSimulcastAnswer) {
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
@@ -3049,7 +3062,7 @@
simulcast_layers.AddLayer(SimulcastLayer(rid_descriptions[1].rid, true));
simulcast_layers.AddLayer(SimulcastLayer(rid_descriptions[2].rid, false));
AttachSenderToMediaDescriptionOptions(
- kVideoMid, webrtc::MediaType::VIDEO, kVideoTrack1, {kMediaStream1},
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1},
rid_descriptions, simulcast_layers, 0, &answer_opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue();
@@ -3063,25 +3076,25 @@
// Note that RID Direction is not the same as the transceiver direction.
TEST_F(MediaSessionDescriptionFactoryTest, TestAnswerWithRidsNoSimulcast) {
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
RidDescription rid_offer("f", RidDirection::kSend);
AttachSenderToMediaDescriptionOptions(
- kVideoMid, webrtc::MediaType::VIDEO, kVideoTrack1, {kMediaStream1},
- {rid_offer}, SimulcastLayerList(), 0, &offer_opts);
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, {rid_offer},
+ SimulcastLayerList(), 0, &offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
RidDescription rid_answer("f", RidDirection::kReceive);
AttachSenderToMediaDescriptionOptions(
- kVideoMid, webrtc::MediaType::VIDEO, kVideoTrack1, {kMediaStream1},
- {rid_answer}, SimulcastLayerList(), 0, &answer_opts);
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, {rid_answer},
+ SimulcastLayerList(), 0, &answer_opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue();
@@ -3106,29 +3119,29 @@
// adding a new video track and removes one of the audio tracks.
TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&offer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
+ AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO,
kAudioTrack1, {kMediaStream1}, 1,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
+ AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO,
kAudioTrack2, {kMediaStream1}, 1,
&answer_opts);
@@ -3143,37 +3156,37 @@
const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description();
- EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
+ EXPECT_EQ(acd->type(), MediaType::AUDIO);
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
const StreamParamsVec& audio_streams = acd->streams();
- ASSERT_EQ(2U, audio_streams.size());
+ ASSERT_EQ(audio_streams.size(), 2U);
EXPECT_TRUE(audio_streams[0].cname == audio_streams[1].cname);
- EXPECT_EQ(kAudioTrack1, audio_streams[0].id);
- ASSERT_EQ(1U, audio_streams[0].ssrcs.size());
- EXPECT_NE(0U, audio_streams[0].ssrcs[0]);
- EXPECT_EQ(kAudioTrack2, audio_streams[1].id);
- ASSERT_EQ(1U, audio_streams[1].ssrcs.size());
- EXPECT_NE(0U, audio_streams[1].ssrcs[0]);
+ EXPECT_EQ(audio_streams[0].id, kAudioTrack1);
+ ASSERT_EQ(audio_streams[0].ssrcs.size(), 1U);
+ EXPECT_NE(audio_streams[0].ssrcs[0], 0U);
+ EXPECT_EQ(audio_streams[1].id, kAudioTrack2);
+ ASSERT_EQ(audio_streams[1].ssrcs.size(), 1U);
+ EXPECT_NE(audio_streams[1].ssrcs[0], 0U);
- EXPECT_EQ(kAutoBandwidth,
- acd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
- EXPECT_EQ(webrtc::MediaType::VIDEO, vcd->type());
- EXPECT_THAT(vcd->codecs(), ElementsAreArray(kVideoCodecsAnswer));
+ EXPECT_EQ(vcd->type(), MediaType::VIDEO);
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials()));
const StreamParamsVec& video_streams = vcd->streams();
- ASSERT_EQ(1U, video_streams.size());
+ ASSERT_EQ(video_streams.size(), 1U);
EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname);
- EXPECT_EQ(kVideoTrack1, video_streams[0].id);
- EXPECT_EQ(kAutoBandwidth,
- vcd->bandwidth()); // default bandwidth (auto)
+ EXPECT_EQ(video_streams[0].id, kVideoTrack1);
+ EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
// Update the answer. Add a new video track that is not synched to the
// other tracks and remove 1 audio track.
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack2, {kMediaStream2}, 1,
&answer_opts);
DetachSenderFromMediaSection(kAudioMid, kAudioTrack2, &answer_opts);
@@ -3190,18 +3203,20 @@
const MediaContentDescription* updated_vcd = vc->media_description();
EXPECT_EQ(acd->type(), updated_acd->type());
- EXPECT_EQ(acd->codecs(), updated_acd->codecs());
+ EXPECT_THAT(updated_acd->codecs(),
+ CodecListsMatch(acd->codecs(), &env_.field_trials()));
EXPECT_EQ(vcd->type(), updated_vcd->type());
- EXPECT_EQ(vcd->codecs(), updated_vcd->codecs());
+ EXPECT_THAT(updated_vcd->codecs(),
+ CodecListsMatch(vcd->codecs(), &env_.field_trials()));
const StreamParamsVec& updated_audio_streams = updated_acd->streams();
- ASSERT_EQ(1U, updated_audio_streams.size());
+ ASSERT_EQ(updated_audio_streams.size(), 1U);
EXPECT_TRUE(audio_streams[0] == updated_audio_streams[0]);
const StreamParamsVec& updated_video_streams = updated_vcd->streams();
- ASSERT_EQ(2U, updated_video_streams.size());
+ ASSERT_EQ(updated_video_streams.size(), 2U);
EXPECT_EQ(video_streams[0], updated_video_streams[0]);
- EXPECT_EQ(kVideoTrack2, updated_video_streams[1].id);
+ EXPECT_EQ(updated_video_streams[1].id, kVideoTrack2);
// All media streams in one PeerConnection share one CNAME.
EXPECT_EQ(updated_video_streams[1].cname, updated_video_streams[0].cname);
}
@@ -3221,11 +3236,13 @@
const AudioContentDescription* acd =
GetFirstAudioContentDescription(answer.get());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- EXPECT_THAT(vcd->codecs(), ElementsAreArray(kVideoCodecsAnswer));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials()));
std::unique_ptr<SessionDescription> updated_offer(
f2_.CreateOfferOrError(opts, answer.get()).MoveValue());
@@ -3235,7 +3252,7 @@
// preference order.
// TODO(wu): `updated_offer` should not include the codec
// (i.e. `kAudioCodecs2[0]`) the other side doesn't support.
- const Codec kUpdatedAudioCodecOffer[] = {
+ const std::vector<Codec> kUpdatedAudioCodecOffer = {
kAudioCodecsAnswer[0],
kAudioCodecsAnswer[1],
kAudioCodecs2[0],
@@ -3244,18 +3261,20 @@
// The expected video codecs are the common video codecs from the first
// offer/answer exchange plus the video codecs only `f2_` offer, sorted in
// preference order.
- const Codec kUpdatedVideoCodecOffer[] = {
+ const std::vector<Codec> kUpdatedVideoCodecOffer = {
kVideoCodecsAnswer[0],
kVideoCodecs2[1],
};
const AudioContentDescription* updated_acd =
GetFirstAudioContentDescription(updated_offer.get());
- EXPECT_TRUE(CodecListsMatch(updated_acd->codecs(), kUpdatedAudioCodecOffer));
+ EXPECT_THAT(updated_acd->codecs(),
+ CodecListsMatch(kUpdatedAudioCodecOffer, &env_.field_trials()));
const VideoContentDescription* updated_vcd =
GetFirstVideoContentDescription(updated_offer.get());
- EXPECT_TRUE(CodecListsMatch(updated_vcd->codecs(), kUpdatedVideoCodecOffer));
+ EXPECT_THAT(updated_vcd->codecs(),
+ CodecListsMatch(kUpdatedVideoCodecOffer, &env_.field_trials()));
}
// Test that a reoffer does not reuse audio codecs from a previous media section
@@ -3266,7 +3285,7 @@
codec_lookup_helper_2_.ClearVideoCodecs();
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "a0",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "a0",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -3283,13 +3302,7 @@
// section was not recycled the payload types would match the initial offerer.
const AudioContentDescription* acd =
GetFirstAudioContentDescription(reoffer.get());
- // EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecs2)),
- // except that we don't want to check the PT numbers.
- EXPECT_EQ(acd->codecs().size(),
- sizeof(kAudioCodecs2) / sizeof(kAudioCodecs2[0]));
- for (size_t i = 0; i < acd->codecs().size(); ++i) {
- EXPECT_EQ(acd->codecs()[i].name, kAudioCodecs2[i].name);
- }
+ EXPECT_THAT(acd->codecs(), NamesMatch(GetCodecNames(kAudioCodecs2)));
}
// Test that a reoffer does not reuse video codecs from a previous media section
@@ -3300,7 +3313,7 @@
codec_lookup_helper_2_.ClearAudioCodecs();
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "v0",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "v0",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -3317,7 +3330,8 @@
// section was not recycled the payload types would match the initial offerer.
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(reoffer.get());
- EXPECT_TRUE(CodecListsMatch(vcd->codecs(), kVideoCodecs2));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(kVideoCodecs2, &env_.field_trials()));
}
// Test that a reanswer does not reuse audio codecs from a previous media
@@ -3330,7 +3344,7 @@
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer).
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "a0",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "a0",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -3349,7 +3363,8 @@
// section was not recycled the payload types would match the initial offerer.
const AudioContentDescription* acd =
GetFirstAudioContentDescription(reanswer.get());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
}
// Test that a reanswer does not reuse video codecs from a previous media
@@ -3362,7 +3377,7 @@
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer).
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "v0",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "v0",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
@@ -3381,7 +3396,8 @@
// section was not recycled the payload types would match the initial offerer.
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(reanswer.get());
- EXPECT_THAT(vcd->codecs(), ElementsAreArray(kVideoCodecsAnswer));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials()));
}
// Create an updated offer after creating an answer to the original offer and
@@ -3390,15 +3406,15 @@
TEST_F(MediaSessionDescriptionFactoryTest,
RespondentCreatesOfferAfterCreatingAnswerWithRtx) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates rtx for H264 with the payload type `f1_` uses.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
// This creates rtx for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
@@ -3412,10 +3428,12 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+ std::vector<Codec> expected_codecs(kVideoCodecsAnswer.begin(),
+ kVideoCodecsAnswer.end());
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
- EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
// Now, make sure we get same result (except for the order) if `f2_` creates
// an updated offer even though the default payload types between `f1_` and
@@ -3430,7 +3448,8 @@
const VideoContentDescription* updated_vcd =
GetFirstVideoContentDescription(updated_answer.get());
- EXPECT_TRUE(CodecListsMatch(expected_codecs, updated_vcd->codecs()));
+ EXPECT_THAT(updated_vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
}
// Regression test for:
@@ -3441,7 +3460,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
RespondentCreatesOfferAfterCreatingAnswerWithRemappedRtxPayloadType) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
// We specifically choose different preferred payload types for VP8 to
@@ -3476,27 +3495,27 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(updated_offer.get());
- std::vector<Codec> codecs = vcd->codecs();
- ASSERT_EQ(4u, codecs.size());
- EXPECT_EQ(vp8_offerer, codecs[0]);
- EXPECT_EQ(vp8_offerer_rtx, codecs[1]);
- EXPECT_EQ(vp9, codecs[2]);
- EXPECT_EQ(vp9_rtx, codecs[3]);
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(std::vector<Codec>{vp8_offerer, vp8_offerer_rtx,
+ vp9, vp9_rtx},
+ &env_.field_trials()));
}
// Create an updated offer that adds video after creating an audio only answer
// to the original offer. This test verifies that if a video codec and the RTX
// codec have the same default payload type as an audio codec that is already in
// use, the added codecs payload types are changed.
+// TODO(bugs.webrtc.org/400630582): Investigate why this fails in the legacy
+// path with the new test-only PT registration.
TEST_F(MediaSessionDescriptionFactoryTest,
RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates rtx for H264 with the payload type `f1_` uses.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -3507,7 +3526,8 @@
const AudioContentDescription* acd =
GetFirstAudioContentDescription(answer.get());
- EXPECT_THAT(acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
// Now - let `f2_` add video with RTX and let the payload type the RTX codec
// reference be the same as an audio codec that was negotiated in the
@@ -3515,7 +3535,7 @@
opts.media_description_options.clear();
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
ASSERT_THAT(acd->codecs().size(), Gt(0));
int used_pl_type = acd->codecs()[0].id;
f2_codecs[0].id = used_pl_type; // Set the payload type for H264.
@@ -3530,14 +3550,15 @@
.MoveValue());
const AudioContentDescription* updated_acd =
- GetFirstAudioContentDescription(answer.get());
- EXPECT_THAT(updated_acd->codecs(), ElementsAreArray(kAudioCodecsAnswer));
+ GetFirstAudioContentDescription(updated_answer.get());
+ EXPECT_THAT(updated_acd->codecs(),
+ CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials()));
const VideoContentDescription* updated_vcd =
GetFirstVideoContentDescription(updated_answer.get());
- ASSERT_EQ("H264", updated_vcd->codecs()[0].name);
- ASSERT_EQ(kRtxCodecName, updated_vcd->codecs()[1].name);
+ ASSERT_EQ(updated_vcd->codecs()[0].name, "H264");
+ ASSERT_EQ(updated_vcd->codecs()[1].name, kRtxCodecName);
int new_h264_pl_type = updated_vcd->codecs()[0].id;
EXPECT_NE(used_pl_type, new_h264_pl_type);
Codec rtx = updated_vcd->codecs()[1];
@@ -3554,7 +3575,7 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
// This creates rtx for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
@@ -3568,8 +3589,10 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
- EXPECT_EQ(expected_codecs, vcd->codecs());
+ std::vector<Codec> expected_codecs(kVideoCodecsAnswer.begin(),
+ kVideoCodecsAnswer.end());
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
// Now, ensure that the RTX codec is created correctly when `f2_` creates an
// updated offer, even though the default payload types are different from
@@ -3584,21 +3607,22 @@
// New offer should attempt to add H263, and RTX for H264.
expected_codecs.push_back(kVideoCodecs2[1]);
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[1].id), &expected_codecs);
- EXPECT_TRUE(CodecListsMatch(expected_codecs, updated_vcd->codecs()));
+ EXPECT_THAT(updated_vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
}
// Test that RTX is ignored when there is no associated payload type parameter.
TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates RTX without associated payload type parameter.
AddRtxCodec(CreateVideoCodec(126, kRtxCodecName), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
// This creates RTX for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
@@ -3633,15 +3657,15 @@
// type doesn't match the local value.
TEST_F(MediaSessionDescriptionFactoryTest, FilterOutRtxIfAptDoesntMatch) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates RTX for H264 in sender.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
// This creates RTX for H263 in receiver.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
@@ -3664,10 +3688,10 @@
TEST_F(MediaSessionDescriptionFactoryTest,
FilterOutUnsupportedRtxWhenCreatingAnswer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates RTX for H264-SVC in sender.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
@@ -3676,7 +3700,7 @@
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
- std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end());
// This creates RTX for H264 in receiver.
AddRtxCodec(CreateVideoRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs, f1_codecs);
@@ -3690,20 +3714,22 @@
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+ std::vector<Codec> expected_codecs(kVideoCodecsAnswer.begin(),
+ kVideoCodecsAnswer.end());
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
- EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
}
// Test that after one RTX codec has been negotiated, a new offer can attempt
// to add another.
TEST_F(MediaSessionDescriptionFactoryTest, AddSecondRtxInNewOffer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end());
// This creates RTX for H264 for the offerer.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.SetVideoCodecs(f1_codecs);
@@ -3714,9 +3740,11 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(offer.get());
- std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> expected_codecs(kVideoCodecs1.begin(),
+ kVideoCodecs1.end());
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
- EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
// Now, attempt to add RTX for H264-SVC.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
@@ -3728,19 +3756,20 @@
vcd = GetFirstVideoContentDescription(updated_offer.get());
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &expected_codecs);
- EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
+ EXPECT_THAT(vcd->codecs(),
+ CodecListsMatch(expected_codecs, &env_.field_trials()));
}
// Test that when RTX is used in conjunction with simulcast, an RTX ssrc is
// generated for each simulcast ssrc and correctly grouped.
TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateMultipleRtxSsrcs) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Add simulcast streams.
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- "stream1", {"stream1label"}, 3, &opts);
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1",
+ {"stream1label"}, 3, &opts);
// Use a single real codec, and then add RTX for it.
std::vector<Codec> f1_codecs;
@@ -3758,19 +3787,19 @@
ASSERT_TRUE(media_desc);
const StreamParamsVec& streams = media_desc->streams();
// Single stream.
- ASSERT_EQ(1u, streams.size());
+ ASSERT_EQ(streams.size(), 1u);
// Stream should have 6 ssrcs: 3 for video, 3 for RTX.
- EXPECT_EQ(6u, streams[0].ssrcs.size());
+ EXPECT_EQ(streams[0].ssrcs.size(), 6u);
// And should have a SIM group for the simulcast.
EXPECT_TRUE(streams[0].has_ssrc_group("SIM"));
// And a FID group for RTX.
EXPECT_TRUE(streams[0].has_ssrc_group("FID"));
std::vector<uint32_t> primary_ssrcs;
streams[0].GetPrimarySsrcs(&primary_ssrcs);
- EXPECT_EQ(3u, primary_ssrcs.size());
+ EXPECT_EQ(primary_ssrcs.size(), 3u);
std::vector<uint32_t> fid_ssrcs;
streams[0].GetFidSsrcs(primary_ssrcs, &fid_ssrcs);
- EXPECT_EQ(3u, fid_ssrcs.size());
+ EXPECT_EQ(fid_ssrcs.size(), 3u);
}
class MediaSessionDescriptionFactoryFecTest
@@ -3784,12 +3813,12 @@
// together with a FEC-FR grouping. Guarded by WebRTC-FlexFEC-03 trial.
TEST_F(MediaSessionDescriptionFactoryFecTest, GenerateFlexfecSsrc) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Add single stream.
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- "stream1", {"stream1label"}, 1, &opts);
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1",
+ {"stream1label"}, 1, &opts);
// Use a single real codec, and then add FlexFEC for it.
std::vector<Codec> f1_codecs;
@@ -3807,14 +3836,14 @@
ASSERT_TRUE(media_desc);
const StreamParamsVec& streams = media_desc->streams();
// Single stream.
- ASSERT_EQ(1u, streams.size());
+ ASSERT_EQ(streams.size(), 1u);
// Stream should have 2 ssrcs: 1 for video, 1 for FlexFEC.
- EXPECT_EQ(2u, streams[0].ssrcs.size());
+ EXPECT_EQ(streams[0].ssrcs.size(), 2u);
// And should have a FEC-FR group for FlexFEC.
EXPECT_TRUE(streams[0].has_ssrc_group("FEC-FR"));
std::vector<uint32_t> primary_ssrcs;
streams[0].GetPrimarySsrcs(&primary_ssrcs);
- ASSERT_EQ(1u, primary_ssrcs.size());
+ ASSERT_EQ(primary_ssrcs.size(), 1u);
uint32_t flexfec_ssrc;
EXPECT_TRUE(streams[0].GetFecFrSsrc(primary_ssrcs[0], &flexfec_ssrc));
EXPECT_NE(flexfec_ssrc, 0u);
@@ -3825,12 +3854,12 @@
// multiple FlexfecSenders, or through multistream protection.
TEST_F(MediaSessionDescriptionFactoryFecTest, SimSsrcsGenerateNoFlexfecSsrcs) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Add simulcast streams.
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- "stream1", {"stream1label"}, 3, &opts);
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1",
+ {"stream1label"}, 3, &opts);
// Use a single real codec, and then add FlexFEC for it.
std::vector<Codec> f1_codecs;
@@ -3848,16 +3877,16 @@
ASSERT_TRUE(media_desc);
const StreamParamsVec& streams = media_desc->streams();
// Single stream.
- ASSERT_EQ(1u, streams.size());
+ ASSERT_EQ(streams.size(), 1u);
// Stream should have 3 ssrcs: 3 for video, 0 for FlexFEC.
- EXPECT_EQ(3u, streams[0].ssrcs.size());
+ EXPECT_EQ(streams[0].ssrcs.size(), 3u);
// And should have a SIM group for the simulcast.
EXPECT_TRUE(streams[0].has_ssrc_group("SIM"));
// And not a FEC-FR group for FlexFEC.
EXPECT_FALSE(streams[0].has_ssrc_group("FEC-FR"));
std::vector<uint32_t> primary_ssrcs;
streams[0].GetPrimarySsrcs(&primary_ssrcs);
- EXPECT_EQ(3u, primary_ssrcs.size());
+ EXPECT_EQ(primary_ssrcs.size(), 3u);
for (uint32_t primary_ssrc : primary_ssrcs) {
uint32_t flexfec_ssrc;
EXPECT_FALSE(streams[0].GetFecFrSsrc(primary_ssrc, &flexfec_ssrc));
@@ -3872,12 +3901,12 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtension1),
- MAKE_VECTOR(kVideoRtpExtension1), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension1, kVideoRtpExtension1,
+ &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtension2),
- MAKE_VECTOR(kVideoRtpExtension2), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension2, kVideoRtpExtension2,
+ &opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
@@ -3896,7 +3925,7 @@
// `f2_` offer.
// Since the default local extension id `f2_` uses has already been used by
// `f1_` for another extensions, it is changed to 13.
- const RtpExtension kUpdatedAudioRtpExtensions[] = {
+ const std::vector<RtpExtension> kUpdatedAudioRtpExtensions = {
kAudioRtpExtensionAnswer[0],
RtpExtension(kAudioRtpExtension2[1].uri, 13),
kAudioRtpExtension2[2],
@@ -3904,7 +3933,7 @@
// Since the default local extension id `f2_` uses has already been used by
// `f1_` for another extensions, is is changed to 12.
- const RtpExtension kUpdatedVideoRtpExtensions[] = {
+ const std::vector<RtpExtension> kUpdatedVideoRtpExtensions = {
kVideoRtpExtensionAnswer[0],
RtpExtension(kVideoRtpExtension2[1].uri, 12),
kVideoRtpExtension2[2],
@@ -3928,14 +3957,14 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- SetAudioVideoRtpHeaderExtensions(MAKE_VECTOR(kAudioRtpExtension3),
- MAKE_VECTOR(kVideoRtpExtension3), &opts);
+ SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension3, kVideoRtpExtension3,
+ &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
// Since the audio extensions used ID 3 for "both_audio_and_video", so should
// the video extensions.
- const RtpExtension kExpectedVideoRtpExtension[] = {
+ const std::vector<RtpExtension> kExpectedVideoRtpExtension = {
kVideoRtpExtension3[0],
kAudioRtpExtension3[1],
};
@@ -3959,18 +3988,20 @@
UnorderedElementsAreArray(kExpectedVideoRtpExtension));
}
-TEST(MediaSessionDescription, CopySessionDescription) {
+TEST_F(MediaSessionDescriptionFactoryTest, CopySessionDescription) {
SessionDescription source;
ContentGroup group(kAudioMid);
source.AddGroup(group);
std::unique_ptr<AudioContentDescription> acd =
std::make_unique<AudioContentDescription>();
- acd->set_codecs(MAKE_VECTOR(kAudioCodecs1));
+ acd->set_codecs(
+ std::vector<Codec>(kAudioCodecs1.begin(), kAudioCodecs1.end()));
acd->AddLegacyStream(1);
source.AddContent(kAudioMid, MediaProtocolType::kRtp, acd->Clone());
std::unique_ptr<VideoContentDescription> vcd =
std::make_unique<VideoContentDescription>();
- vcd->set_codecs(MAKE_VECTOR(kVideoCodecs1));
+ vcd->set_codecs(
+ std::vector<Codec>(kVideoCodecs1.begin(), kVideoCodecs1.end()));
vcd->AddLegacyStream(2);
source.AddContent(kVideoMid, MediaProtocolType::kRtp, vcd->Clone());
@@ -3981,22 +4012,24 @@
const ContentInfo* vc = copy->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
ASSERT_TRUE(vc);
- EXPECT_EQ(MediaProtocolType::kRtp, ac->type);
+ EXPECT_EQ(ac->type, MediaProtocolType::kRtp);
const MediaContentDescription* acd_copy = ac->media_description();
- EXPECT_EQ(acd->codecs(), acd_copy->codecs());
- EXPECT_EQ(1u, acd->first_ssrc());
+ EXPECT_THAT(acd_copy->codecs(),
+ CodecListsMatch(acd->codecs(), &env_.field_trials()));
+ EXPECT_EQ(acd->first_ssrc(), 1u);
- EXPECT_EQ(MediaProtocolType::kRtp, vc->type);
+ EXPECT_EQ(vc->type, MediaProtocolType::kRtp);
const MediaContentDescription* vcd_copy = vc->media_description();
- EXPECT_EQ(vcd->codecs(), vcd_copy->codecs());
- EXPECT_EQ(2u, vcd->first_ssrc());
+ EXPECT_THAT(vcd_copy->codecs(),
+ CodecListsMatch(vcd->codecs(), &env_.field_trials()));
+ EXPECT_EQ(vcd->first_ssrc(), 2u);
}
// The below TestTransportInfoXXX tests create different offers/answers, and
// ensure the TransportInfo in the SessionDescription matches what we expect.
TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudio) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
TestTransportInfo(true, options, false);
@@ -4005,7 +4038,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestTransportInfoOfferIceRenomination) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
options.media_description_options[0]
@@ -4015,7 +4048,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudioCurrent) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
TestTransportInfo(true, options, true);
@@ -4051,7 +4084,7 @@
TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerAudio) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
TestTransportInfo(false, options, false);
@@ -4060,7 +4093,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestTransportInfoAnswerIceRenomination) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
options.media_description_options[0]
@@ -4071,7 +4104,7 @@
TEST_F(MediaSessionDescriptionFactoryTest,
TestTransportInfoAnswerAudioCurrent) {
MediaSessionOptions options;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&options);
TestTransportInfo(false, options, true);
@@ -4128,7 +4161,7 @@
const MediaContentDescription* answer_audio_desc =
answer_content->media_description();
- EXPECT_EQ(kMediaProtocolDtlsSavpf, answer_audio_desc->protocol());
+ EXPECT_EQ(answer_audio_desc->protocol(), kMediaProtocolDtlsSavpf);
}
// Test that we accept a DTLS offer without SDES and create an appropriate
@@ -4194,13 +4227,13 @@
// Test that the generated MIDs match the existing offer.
TEST_F(MediaSessionDescriptionFactoryTest, TestMIDsMatchesExistingOffer) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio_modified",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio_modified",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video_modified",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video_modified",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::DATA, "data_modified",
+ AddMediaDescriptionOptions(MediaType::DATA, "data_modified",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Create offer.
@@ -4215,9 +4248,9 @@
ASSERT_TRUE(audio_content);
ASSERT_TRUE(video_content);
ASSERT_TRUE(data_content);
- EXPECT_EQ("audio_modified", audio_content->mid());
- EXPECT_EQ("video_modified", video_content->mid());
- EXPECT_EQ("data_modified", data_content->mid());
+ EXPECT_EQ(audio_content->mid(), "audio_modified");
+ EXPECT_EQ(video_content->mid(), "video_modified");
+ EXPECT_EQ(data_content->mid(), "data_modified");
}
// The following tests verify that the unified plan SDP is supported.
@@ -4226,61 +4259,57 @@
TEST_F(MediaSessionDescriptionFactoryTest,
CreateOfferWithMultipleAVMediaSections) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio_1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio_1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("audio_1", webrtc::MediaType::AUDIO,
- kAudioTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "audio_1", MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video_1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video_1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("video_1", webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "video_1", MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio_2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio_2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("audio_2", webrtc::MediaType::AUDIO,
- kAudioTrack2, {kMediaStream2}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "audio_2", MediaType::AUDIO, kAudioTrack2, {kMediaStream2}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video_2",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video_2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("video_2", webrtc::MediaType::VIDEO,
- kVideoTrack2, {kMediaStream2}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "video_2", MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(4u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 4u);
EXPECT_FALSE(offer->contents()[0].rejected);
const MediaContentDescription* acd = offer->contents()[0].media_description();
- ASSERT_EQ(1u, acd->streams().size());
- EXPECT_EQ(kAudioTrack1, acd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, acd->direction());
+ ASSERT_EQ(acd->streams().size(), 1u);
+ EXPECT_EQ(acd->streams()[0].id, kAudioTrack1);
+ EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(offer->contents()[1].rejected);
const MediaContentDescription* vcd = offer->contents()[1].media_description();
- ASSERT_EQ(1u, vcd->streams().size());
- EXPECT_EQ(kVideoTrack1, vcd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, vcd->direction());
+ ASSERT_EQ(vcd->streams().size(), 1u);
+ EXPECT_EQ(vcd->streams()[0].id, kVideoTrack1);
+ EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(offer->contents()[2].rejected);
acd = offer->contents()[2].media_description();
- ASSERT_EQ(1u, acd->streams().size());
- EXPECT_EQ(kAudioTrack2, acd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, acd->direction());
+ ASSERT_EQ(acd->streams().size(), 1u);
+ EXPECT_EQ(acd->streams()[0].id, kAudioTrack2);
+ EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(offer->contents()[3].rejected);
vcd = offer->contents()[3].media_description();
- ASSERT_EQ(1u, vcd->streams().size());
- EXPECT_EQ(kVideoTrack2, vcd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, vcd->direction());
+ ASSERT_EQ(vcd->streams().size(), 1u);
+ EXPECT_EQ(vcd->streams()[0].id, kVideoTrack2);
+ EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv);
}
// Test that we can create an answer with multiple media sections of same media
@@ -4288,33 +4317,29 @@
TEST_F(MediaSessionDescriptionFactoryTest,
CreateAnswerWithMultipleAVMediaSections) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio_1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio_1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("audio_1", webrtc::MediaType::AUDIO,
- kAudioTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "audio_1", MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video_1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video_1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("video_1", webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "video_1", MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio_2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio_2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("audio_2", webrtc::MediaType::AUDIO,
- kAudioTrack2, {kMediaStream2}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "audio_2", MediaType::AUDIO, kAudioTrack2, {kMediaStream2}, 1, &opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video_2",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video_2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions("video_2", webrtc::MediaType::VIDEO,
- kVideoTrack2, {kMediaStream2}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ "video_2", MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -4322,32 +4347,32 @@
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
- ASSERT_EQ(4u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 4u);
EXPECT_FALSE(answer->contents()[0].rejected);
const MediaContentDescription* acd =
answer->contents()[0].media_description();
- ASSERT_EQ(1u, acd->streams().size());
- EXPECT_EQ(kAudioTrack1, acd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, acd->direction());
+ ASSERT_EQ(acd->streams().size(), 1u);
+ EXPECT_EQ(acd->streams()[0].id, kAudioTrack1);
+ EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(answer->contents()[1].rejected);
const MediaContentDescription* vcd =
answer->contents()[1].media_description();
- ASSERT_EQ(1u, vcd->streams().size());
- EXPECT_EQ(kVideoTrack1, vcd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, vcd->direction());
+ ASSERT_EQ(vcd->streams().size(), 1u);
+ EXPECT_EQ(vcd->streams()[0].id, kVideoTrack1);
+ EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(answer->contents()[2].rejected);
acd = answer->contents()[2].media_description();
- ASSERT_EQ(1u, acd->streams().size());
- EXPECT_EQ(kAudioTrack2, acd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, acd->direction());
+ ASSERT_EQ(acd->streams().size(), 1u);
+ EXPECT_EQ(acd->streams()[0].id, kAudioTrack2);
+ EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv);
EXPECT_FALSE(answer->contents()[3].rejected);
vcd = answer->contents()[3].media_description();
- ASSERT_EQ(1u, vcd->streams().size());
- EXPECT_EQ(kVideoTrack2, vcd->streams()[0].id);
- EXPECT_EQ(RtpTransceiverDirection::kSendRecv, vcd->direction());
+ ASSERT_EQ(vcd->streams().size(), 1u);
+ EXPECT_EQ(vcd->streams()[0].id, kVideoTrack2);
+ EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv);
}
// Test that the media section will be rejected in offer if the corresponding
@@ -4356,16 +4381,16 @@
CreateOfferWithMediaSectionStoppedByOfferer) {
// Create an offer with two audio sections and one of them is stopped.
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio1",
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio2",
RtpTransceiverDirection::kInactive, kStopped,
&offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
EXPECT_FALSE(offer->contents()[0].rejected);
EXPECT_TRUE(offer->contents()[1].rejected);
}
@@ -4376,30 +4401,30 @@
CreateAnswerWithMediaSectionStoppedByOfferer) {
// Create an offer with two audio sections and one of them is stopped.
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio1",
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio2",
RtpTransceiverDirection::kInactive, kStopped,
&offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
EXPECT_FALSE(offer->contents()[0].rejected);
EXPECT_TRUE(offer->contents()[1].rejected);
// Create an answer based on the offer.
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio1",
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio2",
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue();
- ASSERT_EQ(2u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 2u);
EXPECT_FALSE(answer->contents()[0].rejected);
EXPECT_TRUE(answer->contents()[1].rejected);
}
@@ -4410,30 +4435,30 @@
CreateAnswerWithMediaSectionRejectedByAnswerer) {
// Create an offer with two audio sections.
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio1",
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio2",
RtpTransceiverDirection::kSendRecv, kActive,
&offer_opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
ASSERT_FALSE(offer->contents()[0].rejected);
ASSERT_FALSE(offer->contents()[1].rejected);
// The answerer rejects one of the audio sections.
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio1",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio1",
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio2",
+ AddMediaDescriptionOptions(MediaType::AUDIO, "audio2",
RtpTransceiverDirection::kInactive, kStopped,
&answer_opts);
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue();
- ASSERT_EQ(2u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 2u);
EXPECT_FALSE(answer->contents()[0].rejected);
EXPECT_TRUE(answer->contents()[1].rejected);
@@ -4449,19 +4474,19 @@
MediaSessionOptions opts;
// This tests put video section first because normally audio comes first by
// default.
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
- EXPECT_EQ(kVideoMid, offer->contents()[0].mid());
- EXPECT_EQ(kAudioMid, offer->contents()[1].mid());
+ ASSERT_EQ(offer->contents().size(), 2u);
+ EXPECT_EQ(offer->contents()[0].mid(), kVideoMid);
+ EXPECT_EQ(offer->contents()[1].mid(), kAudioMid);
}
// Test that different media sections using the same codec have same payload
@@ -4469,23 +4494,23 @@
TEST_F(MediaSessionDescriptionFactoryTest,
PayloadTypesSharedByMediaSectionsOfSameType) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video2",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Create an offer with two video sections using same codecs.
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
const MediaContentDescription* vcd1 =
offer->contents()[0].media_description();
const MediaContentDescription* vcd2 =
offer->contents()[1].media_description();
EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size());
- ASSERT_EQ(2u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 2u);
EXPECT_EQ(vcd1->codecs()[0].name, vcd2->codecs()[0].name);
EXPECT_EQ(vcd1->codecs()[0].id, vcd2->codecs()[0].id);
EXPECT_EQ(vcd1->codecs()[1].name, vcd2->codecs()[1].name);
@@ -4495,11 +4520,11 @@
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_THAT(answer, NotNull());
- ASSERT_EQ(2u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 2u);
vcd1 = answer->contents()[0].media_description();
vcd2 = answer->contents()[1].media_description();
EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size());
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].name, vcd2->codecs()[0].name);
EXPECT_EQ(vcd1->codecs()[0].id, vcd2->codecs()[0].id);
}
@@ -4693,7 +4718,7 @@
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4701,19 +4726,19 @@
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(1u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 1u);
const MediaContentDescription* vcd1 =
offer->contents()[0].media_description();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst");
// Create answer and negotiate the codecs.
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_THAT(answer, NotNull());
- ASSERT_EQ(1u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 1u);
vcd1 = answer->contents()[0].media_description();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst");
}
@@ -4729,7 +4754,7 @@
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4737,19 +4762,19 @@
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(1u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 1u);
const VideoContentDescription* vcd1 =
offer->contents()[0].media_description()->as_video();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst");
// Create answer and negotiate the codecs.
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_THAT(answer, NotNull());
- ASSERT_EQ(1u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 1u);
vcd1 = answer->contents()[0].media_description()->as_video();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].tx_mode, std::nullopt);
}
#endif
@@ -4766,7 +4791,7 @@
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4774,19 +4799,19 @@
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(1u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 1u);
const MediaContentDescription* vcd1 =
offer->contents()[0].media_description();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].packetization, "raw");
// Create answer and negotiate the codecs.
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_THAT(answer, NotNull());
- ASSERT_EQ(1u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 1u);
vcd1 = answer->contents()[0].media_description();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].packetization, "raw");
}
@@ -4802,7 +4827,7 @@
codec_lookup_helper_2_.SetVideoCodecs(f2_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4810,19 +4835,19 @@
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(1u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 1u);
const VideoContentDescription* vcd1 =
offer->contents()[0].media_description()->as_video();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].packetization, "raw");
// Create answer and negotiate the codecs.
std::unique_ptr<SessionDescription> answer =
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
ASSERT_THAT(answer, NotNull());
- ASSERT_EQ(1u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 1u);
vcd1 = answer->contents()[0].media_description()->as_video();
- ASSERT_EQ(1u, vcd1->codecs().size());
+ ASSERT_EQ(vcd1->codecs().size(), 1u);
EXPECT_EQ(vcd1->codecs()[0].packetization, std::nullopt);
}
@@ -4831,35 +4856,40 @@
TEST_F(MediaSessionDescriptionFactoryTest,
CreateOfferRespectsCodecPreferenceOrder) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video2",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Create an offer with two video sections using same codecs.
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
MediaContentDescription* vcd1 = offer->contents()[0].media_description();
const MediaContentDescription* vcd2 =
offer->contents()[1].media_description();
- auto video_codecs = MAKE_VECTOR(kVideoCodecs1);
- EXPECT_EQ(video_codecs, vcd1->codecs());
- EXPECT_EQ(video_codecs, vcd2->codecs());
+ auto video_codecs = kVideoCodecs1;
+ EXPECT_THAT(vcd1->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
+ EXPECT_THAT(vcd2->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
// Change the codec preference of the first video section and create a
// follow-up offer.
- auto video_codecs_reverse = MAKE_VECTOR(kVideoCodecs1Reverse);
- vcd1->set_codecs(video_codecs_reverse);
+ auto video_codecs_reverse = kVideoCodecs1Reverse;
+ vcd1->set_codecs(std::vector<Codec>(video_codecs_reverse.begin(),
+ video_codecs_reverse.end()));
std::unique_ptr<SessionDescription> updated_offer(
f1_.CreateOfferOrError(opts, offer.get()).MoveValue());
vcd1 = updated_offer->contents()[0].media_description();
vcd2 = updated_offer->contents()[1].media_description();
// The video codec preference order should be respected.
- EXPECT_EQ(video_codecs_reverse, vcd1->codecs());
- EXPECT_EQ(video_codecs, vcd2->codecs());
+ EXPECT_THAT(vcd1->codecs(),
+ CodecListsMatch(video_codecs_reverse, &env_.field_trials()));
+ EXPECT_THAT(vcd2->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
}
// Test that the codec preference order per media section is respected in
@@ -4867,35 +4897,40 @@
TEST_F(MediaSessionDescriptionFactoryTest,
CreateAnswerRespectsCodecPreferenceOrder) {
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video1",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video1",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video2",
+ AddMediaDescriptionOptions(MediaType::VIDEO, "video2",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
// Create an offer with two video sections using same codecs.
std::unique_ptr<SessionDescription> offer =
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_THAT(offer, NotNull());
- ASSERT_EQ(2u, offer->contents().size());
+ ASSERT_EQ(offer->contents().size(), 2u);
MediaContentDescription* vcd1 = offer->contents()[0].media_description();
const MediaContentDescription* vcd2 =
offer->contents()[1].media_description();
- auto video_codecs = MAKE_VECTOR(kVideoCodecs1);
- EXPECT_EQ(video_codecs, vcd1->codecs());
- EXPECT_EQ(video_codecs, vcd2->codecs());
+ auto video_codecs = kVideoCodecs1;
+ EXPECT_THAT(vcd1->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
+ EXPECT_THAT(vcd2->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
// Change the codec preference of the first video section and create an
// answer.
- auto video_codecs_reverse = MAKE_VECTOR(kVideoCodecs1Reverse);
- vcd1->set_codecs(video_codecs_reverse);
+ auto video_codecs_reverse = kVideoCodecs1Reverse;
+ vcd1->set_codecs(std::vector<Codec>(video_codecs_reverse.begin(),
+ video_codecs_reverse.end()));
std::unique_ptr<SessionDescription> answer =
f1_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
vcd1 = answer->contents()[0].media_description();
vcd2 = answer->contents()[1].media_description();
// The video codec preference order should be respected.
- EXPECT_EQ(video_codecs_reverse, vcd1->codecs());
- EXPECT_EQ(video_codecs, vcd2->codecs());
+ EXPECT_THAT(vcd1->codecs(),
+ CodecListsMatch(video_codecs_reverse, &env_.field_trials()));
+ EXPECT_THAT(vcd2->codecs(),
+ CodecListsMatch(video_codecs, &env_.field_trials()));
}
// Test that when creating an answer, the codecs use local parameters instead of
@@ -4908,10 +4943,10 @@
const std::string video_value1 = "video_v1";
const std::string video_value2 = "video_v2";
- auto audio_codecs1 = MAKE_VECTOR(kAudioCodecs1);
- auto audio_codecs2 = MAKE_VECTOR(kAudioCodecs1);
- auto video_codecs1 = MAKE_VECTOR(kVideoCodecs1);
- auto video_codecs2 = MAKE_VECTOR(kVideoCodecs1);
+ auto audio_codecs1 = kAudioCodecs1;
+ auto audio_codecs2 = kAudioCodecs1;
+ auto video_codecs1 = kVideoCodecs1;
+ auto video_codecs2 = kVideoCodecs1;
// Set the parameters for codecs.
audio_codecs1[0].SetParam(audio_param_name, audio_value1);
@@ -4925,10 +4960,10 @@
codec_lookup_helper_2_.SetVideoCodecs(video_codecs2);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4979,7 +5014,7 @@
codec_lookup_helper_2_.SetVideoCodecs({h264_pm1});
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
@@ -4993,9 +5028,9 @@
// Answer should have one negotiated codec with packetization-mode=1 using the
// offered payload type.
- ASSERT_EQ(1u, answer->contents().size());
+ ASSERT_EQ(answer->contents().size(), 1u);
auto answer_vcd = answer->contents()[0].media_description();
- ASSERT_EQ(1u, answer_vcd->codecs().size());
+ ASSERT_EQ(answer_vcd->codecs().size(), 1u);
auto answer_codec = answer_vcd->codecs()[0];
EXPECT_EQ(h264_pm1.id, answer_codec.id);
}
@@ -5053,7 +5088,7 @@
f1_.CreateOfferOrError(opts, nullptr).MoveValue();
ASSERT_TRUE(offer.get());
// Set the protocol for all the contents.
- for (auto& content : offer->contents()) {
+ for (ContentInfo& content : offer->contents()) {
content.media_description()->set_protocol(GetParam());
}
std::unique_ptr<SessionDescription> answer =
@@ -5077,21 +5112,6 @@
MediaProtocolTest,
ValuesIn(kMediaProtocolsDtls));
-// Compare the two vectors of codecs ignoring the payload type.
-bool CodecsMatch(const std::vector<Codec>& codecs1,
- const std::vector<Codec>& codecs2) {
- if (codecs1.size() != codecs2.size()) {
- return false;
- }
-
- for (size_t i = 0; i < codecs1.size(); ++i) {
- if (!codecs1[i].Matches(codecs2[i])) {
- return false;
- }
- }
- return true;
-}
-
void TestAudioCodecsOffer(RtpTransceiverDirection direction) {
Environment env(CreateEnvironment());
TransportDescriptionFactory tdf(env.field_trials());
@@ -5103,20 +5123,22 @@
FakeSctpTransportFactory sctpf;
MediaSessionDescriptionFactory sf(env, nullptr, false, &ssrc_generator, &tdf,
&sctpf, &codec_lookup_helper);
- const std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
- const std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
- const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
+ const std::vector<Codec> send_codecs(kAudioCodecs1.begin(),
+ kAudioCodecs1.end());
+ const std::vector<Codec> recv_codecs(kAudioCodecs2.begin(),
+ kAudioCodecs2.end());
+ const std::vector<Codec> sendrecv_codecs(kAudioCodecsAnswer.begin(),
+ kAudioCodecsAnswer.end());
codec_lookup_helper.SetAudioCodecs(send_codecs, recv_codecs);
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid, direction,
- kActive, &opts);
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, direction, kActive,
+ &opts);
if (direction == RtpTransceiverDirection::kSendRecv ||
direction == RtpTransceiverDirection::kSendOnly) {
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
- kAudioTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts);
}
std::unique_ptr<SessionDescription> offer =
@@ -5135,11 +5157,14 @@
// might eventually be used anything, but we don't know more at this
// moment.
if (acd->direction() == RtpTransceiverDirection::kSendOnly) {
- EXPECT_TRUE(CodecsMatch(send_codecs, acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(send_codecs, &env.field_trials()));
} else if (acd->direction() == RtpTransceiverDirection::kRecvOnly) {
- EXPECT_TRUE(CodecsMatch(recv_codecs, acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(recv_codecs, &env.field_trials()));
} else {
- EXPECT_TRUE(CodecsMatch(sendrecv_codecs, acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(sendrecv_codecs, &env.field_trials()));
}
}
}
@@ -5226,11 +5251,11 @@
VectorFromIndices(kOfferAnswerCodecs, kAnswerRecvCodecs));
MediaSessionOptions offer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
- offer_direction, kActive, &offer_opts);
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, offer_direction,
+ kActive, &offer_opts);
- if (webrtc::RtpTransceiverDirectionHasSend(offer_direction)) {
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
+ if (RtpTransceiverDirectionHasSend(offer_direction)) {
+ AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO,
kAudioTrack1, {kMediaStream1}, 1,
&offer_opts);
}
@@ -5240,11 +5265,11 @@
ASSERT_TRUE(offer.get());
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, kAudioMid,
- answer_direction, kActive, &answer_opts);
+ AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, answer_direction,
+ kActive, &answer_opts);
- if (webrtc::RtpTransceiverDirectionHasSend(answer_direction)) {
- AttachSenderToMediaDescriptionOptions(kAudioMid, webrtc::MediaType::AUDIO,
+ if (RtpTransceiverDirectionHasSend(answer_direction)) {
+ AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO,
kAudioTrack1, {kMediaStream1}, 1,
&answer_opts);
}
@@ -5258,7 +5283,7 @@
// to send nor receive audio. The checks are still in place if at some point
// we'd instead create an inactive stream.
if (ac) {
- ASSERT_EQ(webrtc::MediaType::AUDIO, ac->media_description()->type());
+ ASSERT_EQ(ac->media_description()->type(), MediaType::AUDIO);
const MediaContentDescription* acd = ac->media_description();
std::vector<Codec> target_codecs;
@@ -5294,11 +5319,11 @@
RTC_DCHECK_NOTREACHED();
}
- auto format_codecs = [](const std::vector<Codec>& codecs) {
+ auto format_codecs = [](std::span<const Codec> codecs) {
StringBuilder os;
bool first = true;
os << "{";
- for (const auto& c : codecs) {
+ for (const Codec& c : codecs) {
os << (first ? " " : ", ") << c.id << ":" << c.name;
first = false;
}
@@ -5306,14 +5331,14 @@
return os.Release();
};
- EXPECT_TRUE(acd->codecs() == target_codecs)
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(target_codecs, &env.field_trials()))
<< "Expected: " << format_codecs(target_codecs)
- << ", got: " << format_codecs(acd->codecs()) << "; Offered: "
- << webrtc::RtpTransceiverDirectionToString(offer_direction)
+ << ", got: " << format_codecs(acd->codecs())
+ << "; Offered: " << RtpTransceiverDirectionToString(offer_direction)
<< ", answerer wants: "
- << webrtc::RtpTransceiverDirectionToString(answer_direction)
- << "; got: "
- << webrtc::RtpTransceiverDirectionToString(acd->direction());
+ << RtpTransceiverDirectionToString(answer_direction)
+ << "; got: " << RtpTransceiverDirectionToString(acd->direction());
} else {
EXPECT_EQ(offer_direction, RtpTransceiverDirection::kInactive)
<< "Only inactive offers are allowed to not generate any audio "
@@ -5383,9 +5408,9 @@
std::unique_ptr<SSLIdentity>(new FakeSSLIdentity("answer_id"))));
}
- void CheckH265Level(const std::vector<Codec>& codecs,
+ void CheckH265Level(std::span<const Codec> codecs,
const std::string& expected_level) {
- for (const auto& codec : codecs) {
+ for (const Codec& codec : codecs) {
if (codec.name == "H265") {
auto it = codec.params.find("level-id");
ASSERT_TRUE(it != codec.params.end());
@@ -5412,24 +5437,26 @@
// Offer: level 5.2, SendRecv
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendRecvSymmetrical) {
- const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> sendrecv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs);
- EXPECT_EQ(sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor()
- ->video_sendrecv_codecs()
- .codecs());
+ EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor()
+ ->video_sendrecv_codecs()
+ .codecs(),
+ CodecListsMatch(sendrecv_codecs, &env_.field_trials()));
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5437,14 +5464,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5455,7 +5483,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5463,23 +5492,25 @@
// Offer: level 6.0, SendOnly
// Answer: level 6.0, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendOnlySymmetrical) {
- const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> sendrecv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs);
- EXPECT_EQ(sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor()
- ->video_sendrecv_codecs()
- .codecs());
+ EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor()
+ ->video_sendrecv_codecs()
+ .codecs(),
+ CodecListsMatch(sendrecv_codecs, &env_.field_trials()));
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5487,11 +5518,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -5502,7 +5534,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId);
}
@@ -5510,18 +5543,21 @@
// Offer: level 5.2, RecvOnly
// Answer: level 5.2, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest, TestRecvOnlySymmetrical) {
- const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> sendrecv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs);
- EXPECT_EQ(sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor()
- ->video_sendrecv_codecs()
- .codecs());
+ EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor()
+ ->video_sendrecv_codecs()
+ .codecs(),
+ CodecListsMatch(sendrecv_codecs, &env_.field_trials()));
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -5531,11 +5567,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
@@ -5546,7 +5583,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5556,16 +5594,16 @@
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5576,13 +5614,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5590,14 +5627,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5608,7 +5646,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5618,16 +5657,16 @@
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5638,13 +5677,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5652,14 +5690,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5670,7 +5709,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5680,16 +5720,16 @@
// Answer: level 3.1, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level5);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level31.begin(),
+ kVideoCodecsH265Level31.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level5.begin(),
+ kVideoCodecsH265Level5.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5700,13 +5740,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5714,14 +5753,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5732,7 +5772,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level31), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level31, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level31LevelId);
std::unique_ptr<SessionDescription> reoffer =
@@ -5741,8 +5782,8 @@
const ContentInfo* reoffer_oc = reoffer->GetContentByName(kVideoMid);
ASSERT_TRUE(reoffer_oc);
const MediaContentDescription* reoffer_ocd = reoffer_oc->media_description();
- EXPECT_TRUE(
- CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), reoffer_ocd->codecs()));
+ EXPECT_THAT(reoffer_ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5752,16 +5793,16 @@
// Answer: level 4, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5772,13 +5813,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5786,14 +5826,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5804,7 +5845,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId);
}
@@ -5814,16 +5856,16 @@
// Answer: level 4, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5834,13 +5876,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -5848,14 +5889,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5866,7 +5908,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId);
}
@@ -5876,16 +5919,16 @@
// Answer: level 6, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5896,7 +5939,7 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -5906,14 +5949,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5924,7 +5968,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId);
}
@@ -5934,16 +5979,16 @@
// Answer: level 5.2, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -5954,7 +5999,7 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -5964,14 +6009,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -5982,7 +6028,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -5992,16 +6039,16 @@
// Answer: level 3.1, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level5);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level31.begin(),
+ kVideoCodecsH265Level31.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level5.begin(),
+ kVideoCodecsH265Level5.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6012,7 +6059,7 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -6022,14 +6069,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -6040,7 +6088,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level31), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level31, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level31LevelId);
}
@@ -6050,16 +6099,16 @@
// Answer: level 4, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6070,7 +6119,7 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -6080,14 +6129,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -6098,7 +6148,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId);
}
@@ -6108,16 +6159,16 @@
// Answer: level 6, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6128,7 +6179,7 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
@@ -6138,14 +6189,15 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&answer_opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
+ AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO,
kVideoTrack1, {kMediaStream1}, 1,
&answer_opts);
@@ -6156,7 +6208,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId);
}
@@ -6166,16 +6219,16 @@
// Answer: level 5.2, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6186,13 +6239,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -6200,11 +6252,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6215,7 +6268,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level52), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId);
}
@@ -6225,16 +6279,16 @@
// Answer: level 6, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6245,13 +6299,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -6259,11 +6312,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6274,7 +6328,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId);
}
@@ -6284,16 +6339,16 @@
// Answer: level 5, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level5);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level31.begin(),
+ kVideoCodecsH265Level31.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level5.begin(),
+ kVideoCodecsH265Level5.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6304,13 +6359,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -6318,11 +6372,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6333,7 +6388,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level5), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level5, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level5LevelId);
}
@@ -6343,16 +6399,16 @@
// Answer: level 6, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6363,13 +6419,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -6377,11 +6432,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6392,7 +6448,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level6), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId);
}
@@ -6402,16 +6459,16 @@
// Answer: level 4, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6422,13 +6479,12 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendOnly, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::unique_ptr<SessionDescription> offer =
sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue();
@@ -6436,11 +6492,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6451,22 +6508,23 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId);
}
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode40Decode60AnswererEncode60Decode52WithPreference) {
- const std::vector<Codec> offerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> offerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> offerer_sendrecv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<Codec> answerer_send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<Codec> answerer_recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> offerer_send_codecs(kVideoCodecsH265Level4.begin(),
+ kVideoCodecsH265Level4.end());
+ const std::vector<Codec> offerer_recv_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> offerer_sendrecv_codecs(
+ kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end());
+ const std::vector<Codec> answerer_send_codecs(kVideoCodecsH265Level6.begin(),
+ kVideoCodecsH265Level6.end());
+ const std::vector<Codec> answerer_recv_codecs(kVideoCodecsH265Level52.begin(),
+ kVideoCodecsH265Level52.end());
codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs,
offerer_recv_codecs);
codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs,
@@ -6477,17 +6535,16 @@
.codecs());
MediaSessionOptions opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- AttachSenderToMediaDescriptionOptions(kVideoMid, webrtc::MediaType::VIDEO,
- kVideoTrack1, {kMediaStream1}, 1,
- &opts);
+ AttachSenderToMediaDescriptionOptions(
+ kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts);
std::vector<RtpCodecCapability> preferences;
- for (const auto& codec :
+ for (const Codec& codec :
codec_lookup_helper_offerer_.GetCodecVendor()->video_recv_codecs()) {
- preferences.push_back(webrtc::ToRtpCodecCapability(codec));
+ preferences.push_back(ToRtpCodecCapability(codec));
}
opts.media_description_options[0].codec_preferences = preferences;
@@ -6497,11 +6554,12 @@
const ContentInfo* oc = offer->GetContentByName(kVideoMid);
ASSERT_TRUE(oc);
const MediaContentDescription* ocd = oc->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), ocd->codecs()));
+ EXPECT_THAT(ocd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId);
MediaSessionOptions answer_opts;
- AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, kVideoMid,
+ AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid,
RtpTransceiverDirection::kRecvOnly, kActive,
&answer_opts);
@@ -6512,7 +6570,8 @@
const ContentInfo* ac = answer->GetContentByName(kVideoMid);
ASSERT_TRUE(ac);
const MediaContentDescription* acd = ac->media_description();
- EXPECT_TRUE(CodecsMatch(MAKE_VECTOR(kVideoCodecsH265Level4), acd->codecs()));
+ EXPECT_THAT(acd->codecs(),
+ CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials()));
CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId);
}
diff --git a/tools_webrtc/swap_gtest_args.py b/tools_webrtc/swap_gtest_args.py
new file mode 100644
index 0000000..1c57fe0
--- /dev/null
+++ b/tools_webrtc/swap_gtest_args.py
@@ -0,0 +1,167 @@
+# Copyright (c) 2026 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.
+"""Swaps gtest macro arguments with "Yoda testing"
+
+"Yoda testing" is where the constant comes first, and the value being
+tested comes second. This script will detect some cases of that, and
+swap the arguments.
+
+It depends on detecting constants, which is a heuristic, and it only handles
+order-independent cases (ASSERT_EQ), not comparators like ASSERT_LT.
+"""
+
+import re
+import sys
+
+
+def is_constant(arg):
+ arg = arg.strip()
+ # Casts
+ if (arg.startswith('static_cast<') or arg.startswith('reinterpret_cast<')):
+ match = re.search(r'cast<.*?>\s*\((.*)\)', arg, re.DOTALL)
+ if match:
+ return is_constant(match.group(1))
+ # Casts by brace initialization
+ match = re.match(r'^\w+\{\s*(.\w*)\}$', arg)
+ if match:
+ return is_constant(match.group(1))
+
+ # Numeric literals
+ if re.match(r'^-?\d+[Uu]?[Ll]{0,2}$', arg):
+ return True
+ if re.match(r'^0x[0-9a-fA-F]+[Uu]?$', arg):
+ return True
+ if re.match(r'^-?\d+\.\d+[fF]?$', arg):
+ return True
+
+ # String literals
+ if arg.startswith('"') and arg.endswith('"'):
+ return True
+
+ # Boolean literals
+ if arg in ['true', 'false']:
+ return True
+
+ # Nulls
+ if arg in ['nullptr', 'NULL', 'std::nullopt']:
+ return True
+
+ # k-prefixed constants
+ if re.match(r'^k[A-Z]\w*$', arg):
+ return True
+
+ # ALL_CAPS
+ if re.match(r'^[A-Z][A-Z0-9_]*$', arg):
+ return True
+
+ # Qualified enums
+ if '::' in arg:
+ parts = arg.split('::')
+ last_part = parts[-1].strip()
+ if (re.match(r'^[A-Z][A-Z0-9_]*$', last_part)
+ or re.match(r'^k[A-Z][a-zA-Z0-9]*$', last_part)):
+ return True
+
+ return False
+
+
+def split_args(args_str):
+ args = []
+ current = []
+ depth = 0
+ in_string = False
+ i = 0
+ while i < len(args_str):
+ char = args_str[i]
+ if char == '"' and (i == 0 or args_str[i - 1] != '\\'):
+ in_string = not in_string
+
+ if not in_string:
+ if char in '({[<':
+ depth += 1
+ elif char in ')}]>':
+ depth -= 1
+ elif char == ',' and depth == 0:
+ args.append(''.join(current))
+ current = []
+ i += 1
+ continue
+ current.append(char)
+ i += 1
+ args.append(''.join(current))
+ return args
+
+
+def find_matching_paren(content, start_idx):
+ depth = 0
+ in_string = False
+ for i in range(start_idx, len(content)):
+ char = content[i]
+ if char == '"' and (i == 0 or content[i - 1] != '\\'):
+ in_string = not in_string
+ if not in_string:
+ if char == '(':
+ depth += 1
+ elif char == ')':
+ depth -= 1
+ if depth == 0:
+ return i
+ return -1
+
+
+def find_macro_calls(content):
+ macro_names = ['EXPECT_EQ', 'EXPECT_NE', 'ASSERT_EQ', 'ASSERT_NE']
+ results = []
+ for name in macro_names:
+ start_pos = 0
+ while True:
+ idx = content.find(name + '(', start_pos)
+ if idx == -1:
+ break
+
+ end_idx = find_matching_paren(content, idx + len(name))
+
+ if end_idx != -1:
+ args_content = content[idx + len(name) + 1:end_idx]
+ results.append((idx, end_idx + 1, name, args_content))
+ start_pos = end_idx + 1
+ else:
+ start_pos = idx + len(name)
+ return sorted(results, key=lambda x: x[0], reverse=True)
+
+
+def process_content(content):
+ calls = find_macro_calls(content)
+
+ new_content = content
+ for start, end, macro, args_str in calls:
+ args = split_args(args_str)
+ if len(args) != 2:
+ continue
+
+ arg1 = args[0]
+ arg2 = args[1]
+
+ if is_constant(arg1) and not is_constant(arg2):
+ new_call = f"{macro}({arg2.strip()}, {arg1.strip()})"
+ new_content = new_content[:start] + new_call + new_content[end:]
+ return new_content
+
+
+def process_file(file_path):
+ with open(file_path, 'r') as f_in:
+ content = f_in.read()
+
+ new_content = process_content(content)
+
+ with open(file_path, 'w') as f_out:
+ f_out.write(new_content)
+
+
+if __name__ == "__main__":
+ process_file(sys.argv[1])
diff --git a/tools_webrtc/swap_gtest_args_unittest.py b/tools_webrtc/swap_gtest_args_unittest.py
new file mode 100644
index 0000000..72336de
--- /dev/null
+++ b/tools_webrtc/swap_gtest_args_unittest.py
@@ -0,0 +1,109 @@
+# Copyright (c) 2026 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.
+
+import unittest
+from swap_gtest_args import is_constant, split_args, find_macro_calls
+
+
+class TestSwapGtestArgs(unittest.TestCase):
+
+ def test_is_constant(self):
+ # Numeric literals
+ self.assertTrue(is_constant("0"))
+ self.assertTrue(is_constant("123"))
+ self.assertTrue(is_constant("0U"))
+ self.assertTrue(is_constant("-1"))
+ self.assertTrue(is_constant("0x10"))
+ self.assertTrue(is_constant("0.5"))
+ self.assertTrue(is_constant("1234"))
+
+ # String literals
+ self.assertTrue(is_constant('"foo"'))
+ self.assertTrue(is_constant('""'))
+
+ # Boolean literals
+ self.assertTrue(is_constant("true"))
+ self.assertTrue(is_constant("false"))
+
+ # Nulls
+ self.assertTrue(is_constant("nullptr"))
+ self.assertTrue(is_constant("NULL"))
+ self.assertTrue(is_constant("std::nullopt"))
+
+ # k-prefixed
+ self.assertTrue(is_constant("kAutoBandwidth"))
+ self.assertTrue(is_constant("kAudioMid"))
+
+ # Qualified enums
+ self.assertTrue(is_constant("webrtc::MediaType::AUDIO"))
+ self.assertTrue(is_constant("MediaProtocolType::kRtp"))
+ self.assertTrue(is_constant("RtpTransceiverDirection::kRecvOnly"))
+
+ # ALL_CAPS
+ self.assertTrue(is_constant("ICE_UFRAG_LENGTH"))
+ self.assertTrue(is_constant("GROUP_TYPE_BUNDLE"))
+
+ # Casts
+ self.assertTrue(is_constant("static_cast<size_t>(0)"))
+ self.assertTrue(is_constant("static_cast<int>(kFoo)"))
+ self.assertTrue(is_constant("size_t{kFoo}"))
+
+ # Non-constants
+ self.assertFalse(is_constant("acd->type()"))
+ self.assertFalse(is_constant("ti_audio->description.ice_ufrag"))
+ self.assertFalse(is_constant("vcd->codecs().size()"))
+ self.assertFalse(is_constant("a + b"))
+
+ def test_split_args(self):
+ self.assertEqual(split_args("a, b"), ["a", " b"])
+ self.assertEqual(split_args("func(a, b), c"), ["func(a, b)", " c"])
+ self.assertEqual(split_args("std::vector<int>{1, 2}, d"),
+ ["std::vector<int>{1, 2}", " d"])
+ self.assertEqual(split_args("\"string ending in backslash\\\""),
+ ["\"string ending in backslash\\\""])
+
+ def test_find_macro_calls(self):
+ content = 'EXPECT_EQ(0, x); ASSERT_NE(kFoo, y->bar());'
+ calls = find_macro_calls(content)
+ # find_macro_calls returns in reverse order of position
+ self.assertEqual(len(calls), 2)
+ self.assertEqual(calls[0][2], "ASSERT_NE")
+ self.assertEqual(calls[1][2], "EXPECT_EQ")
+
+ def test_complex_cases(self):
+ content = """
+ EXPECT_EQ(webrtc::MediaType::AUDIO, acd->type());
+ EXPECT_EQ(0U, acd->first_ssrc());
+ EXPECT_EQ(kAutoBandwidth, acd->bandwidth());
+ EXPECT_EQ("opus", preferences[0].name);
+ EXPECT_EQ(static_cast<size_t>(ICE_UFRAG_LENGTH),
+ ti_audio->description.ice_ufrag.size());
+ // Should not swap
+ EXPECT_EQ(x, y);
+ EXPECT_EQ(0, 1);
+ EXPECT_GT(x, kFive);
+ """
+
+ from swap_gtest_args import process_content
+ updated = process_content(content)
+ self.assertIn("EXPECT_EQ(acd->type(), webrtc::MediaType::AUDIO)",
+ updated)
+ self.assertIn("EXPECT_EQ(acd->first_ssrc(), 0U)", updated)
+ self.assertIn("EXPECT_EQ(acd->bandwidth(), kAutoBandwidth)", updated)
+ self.assertIn("EXPECT_EQ(preferences[0].name, \"opus\")", updated)
+ self.assertIn(
+ "EXPECT_EQ(ti_audio->description.ice_ufrag.size(), "
+ "static_cast<size_t>(ICE_UFRAG_LENGTH))", updated)
+ self.assertIn("EXPECT_EQ(x, y)", updated)
+ self.assertIn("EXPECT_EQ(0, 1)", updated)
+ # Argument order dependent operators are not swapped.
+ self.assertIn("EXPECT_GT(x, kFive)", updated)
+
+
+if __name__ == "__main__":
+ unittest.main()
