Commit 8d58b921 authored by Steve Anton's avatar Steve Anton Committed by Commit Bot

Onion soup most of WebRTCConfiguration

Bug: 787254
Change-Id: I081690b1e46a73705f86217f38a899706127feea
Reviewed-on: https://chromium-review.googlesource.com/1161614Reviewed-by: default avatarHenrik Boström <hbos@chromium.org>
Commit-Queue: Steve Anton <steveanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581141}
parent 558ec1da
...@@ -183,55 +183,10 @@ void GetNativeRtcConfiguration( ...@@ -183,55 +183,10 @@ void GetNativeRtcConfiguration(
webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) { webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) {
DCHECK(webrtc_config); DCHECK(webrtc_config);
webrtc_config->servers.clear(); webrtc_config->servers = blink_config.ice_servers;
for (const blink::WebRTCIceServer& blink_server : blink_config.ice_servers) { webrtc_config->type = blink_config.ice_transport_policy;
webrtc::PeerConnectionInterface::IceServer server; webrtc_config->bundle_policy = blink_config.bundle_policy;
server.username = blink_server.username.Utf8(); webrtc_config->rtcp_mux_policy = blink_config.rtcp_mux_policy;
server.password = blink_server.credential.Utf8();
server.uri = blink_server.url.GetString().Utf8();
webrtc_config->servers.push_back(server);
}
switch (blink_config.ice_transport_policy) {
case blink::WebRTCIceTransportPolicy::kRelay:
webrtc_config->type = webrtc::PeerConnectionInterface::kRelay;
break;
case blink::WebRTCIceTransportPolicy::kAll:
webrtc_config->type = webrtc::PeerConnectionInterface::kAll;
break;
default:
NOTREACHED();
}
switch (blink_config.bundle_policy) {
case blink::WebRTCBundlePolicy::kBalanced:
webrtc_config->bundle_policy =
webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
break;
case blink::WebRTCBundlePolicy::kMaxBundle:
webrtc_config->bundle_policy =
webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
break;
case blink::WebRTCBundlePolicy::kMaxCompat:
webrtc_config->bundle_policy =
webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
break;
default:
NOTREACHED();
}
switch (blink_config.rtcp_mux_policy) {
case blink::WebRTCRtcpMuxPolicy::kNegotiate:
webrtc_config->rtcp_mux_policy =
webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
break;
case blink::WebRTCRtcpMuxPolicy::kRequire:
webrtc_config->rtcp_mux_policy =
webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire;
break;
default:
NOTREACHED();
}
switch (blink_config.sdp_semantics) { switch (blink_config.sdp_semantics) {
case blink::WebRTCSdpSemantics::kPlanB: case blink::WebRTCSdpSemantics::kPlanB:
......
...@@ -33,35 +33,24 @@ ...@@ -33,35 +33,24 @@
#include "third_party/blink/public/platform/web_common.h" #include "third_party/blink/public/platform/web_common.h"
#include "third_party/blink/public/platform/web_rtc_certificate.h" #include "third_party/blink/public/platform/web_rtc_certificate.h"
#include "third_party/blink/public/platform/web_url.h"
#include "third_party/blink/public/platform/web_vector.h" #include "third_party/blink/public/platform/web_vector.h"
#include "third_party/webrtc/api/peerconnectioninterface.h"
#include <memory> #include <memory>
namespace blink { namespace blink {
class WebString; // This is distinct from webrtc::SdpSemantics to add the kDefault option.
struct WebRTCIceServer {
WebURL url;
WebString username;
WebString credential;
};
enum class WebRTCIceTransportPolicy { kRelay, kAll };
enum class WebRTCBundlePolicy { kBalanced, kMaxCompat, kMaxBundle };
enum class WebRTCRtcpMuxPolicy { kNegotiate, kRequire };
enum class WebRTCSdpSemantics { kDefault, kPlanB, kUnifiedPlan }; enum class WebRTCSdpSemantics { kDefault, kPlanB, kUnifiedPlan };
struct WebRTCConfiguration { struct WebRTCConfiguration {
WebVector<WebRTCIceServer> ice_servers; std::vector<webrtc::PeerConnectionInterface::IceServer> ice_servers;
WebRTCIceTransportPolicy ice_transport_policy = webrtc::PeerConnectionInterface::IceTransportsType ice_transport_policy =
WebRTCIceTransportPolicy::kAll; webrtc::PeerConnectionInterface::kAll;
WebRTCBundlePolicy bundle_policy = WebRTCBundlePolicy::kBalanced; webrtc::PeerConnectionInterface::BundlePolicy bundle_policy =
WebRTCRtcpMuxPolicy rtcp_mux_policy = WebRTCRtcpMuxPolicy::kRequire; webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
webrtc::PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire;
WebVector<std::unique_ptr<WebRTCCertificate>> certificates; WebVector<std::unique_ptr<WebRTCCertificate>> certificates;
int ice_candidate_pool_size = 0; int ice_candidate_pool_size = 0;
WebRTCSdpSemantics sdp_semantics = WebRTCSdpSemantics::kDefault; WebRTCSdpSemantics sdp_semantics = WebRTCSdpSemantics::kDefault;
......
...@@ -250,11 +250,12 @@ class WebRTCCertificateObserver : public WebRTCCertificateCallback { ...@@ -250,11 +250,12 @@ class WebRTCCertificateObserver : public WebRTCCertificateCallback {
Persistent<ScriptPromiseResolver> resolver_; Persistent<ScriptPromiseResolver> resolver_;
}; };
WebRTCIceTransportPolicy IceTransportPolicyFromString(const String& policy) { webrtc::PeerConnectionInterface::IceTransportsType IceTransportPolicyFromString(
const String& policy) {
if (policy == "relay") if (policy == "relay")
return WebRTCIceTransportPolicy::kRelay; return webrtc::PeerConnectionInterface::kRelay;
DCHECK_EQ(policy, "all"); DCHECK_EQ(policy, "all");
return WebRTCIceTransportPolicy::kAll; return webrtc::PeerConnectionInterface::kAll;
} }
WebRTCConfiguration ParseConfiguration(ExecutionContext* context, WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
...@@ -262,56 +263,47 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context, ...@@ -262,56 +263,47 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
ExceptionState& exception_state) { ExceptionState& exception_state) {
DCHECK(context); DCHECK(context);
WebRTCIceTransportPolicy ice_transport_policy = WebRTCConfiguration web_configuration;
WebRTCIceTransportPolicy::kAll;
if (configuration.hasIceTransportPolicy()) { if (configuration.hasIceTransportPolicy()) {
UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransportPolicy); UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransportPolicy);
ice_transport_policy = web_configuration.ice_transport_policy =
IceTransportPolicyFromString(configuration.iceTransportPolicy()); IceTransportPolicyFromString(configuration.iceTransportPolicy());
} else if (configuration.hasIceTransports()) { } else if (configuration.hasIceTransports()) {
UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransports); UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransports);
ice_transport_policy = web_configuration.ice_transport_policy =
IceTransportPolicyFromString(configuration.iceTransports()); IceTransportPolicyFromString(configuration.iceTransports());
} }
WebRTCBundlePolicy bundle_policy = WebRTCBundlePolicy::kBalanced; if (configuration.bundlePolicy() == "max-compat") {
String bundle_policy_string = configuration.bundlePolicy(); web_configuration.bundle_policy =
if (bundle_policy_string == "max-compat") { webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
bundle_policy = WebRTCBundlePolicy::kMaxCompat; } else if (configuration.bundlePolicy() == "max-bundle") {
} else if (bundle_policy_string == "max-bundle") { web_configuration.bundle_policy =
bundle_policy = WebRTCBundlePolicy::kMaxBundle; webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
} else { } else {
DCHECK_EQ(bundle_policy_string, "balanced"); DCHECK_EQ(configuration.bundlePolicy(), "balanced");
} }
WebRTCRtcpMuxPolicy rtcp_mux_policy = WebRTCRtcpMuxPolicy::kRequire; if (configuration.rtcpMuxPolicy() == "negotiate") {
String rtcp_mux_policy_string = configuration.rtcpMuxPolicy(); web_configuration.rtcp_mux_policy =
if (rtcp_mux_policy_string == "negotiate") { webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
rtcp_mux_policy = WebRTCRtcpMuxPolicy::kNegotiate;
Deprecation::CountDeprecation(context, WebFeature::kRtcpMuxPolicyNegotiate); Deprecation::CountDeprecation(context, WebFeature::kRtcpMuxPolicyNegotiate);
} else { } else {
DCHECK_EQ(rtcp_mux_policy_string, "require"); DCHECK_EQ(configuration.rtcpMuxPolicy(), "require");
} }
WebRTCSdpSemantics sdp_semantics = WebRTCSdpSemantics::kDefault;
if (configuration.hasSdpSemantics()) { if (configuration.hasSdpSemantics()) {
String sdp_semantics_string = configuration.sdpSemantics(); if (configuration.sdpSemantics() == "plan-b") {
if (sdp_semantics_string == "plan-b") { web_configuration.sdp_semantics = WebRTCSdpSemantics::kPlanB;
sdp_semantics = WebRTCSdpSemantics::kPlanB;
} else { } else {
DCHECK_EQ(sdp_semantics_string, "unified-plan"); DCHECK_EQ(configuration.sdpSemantics(), "unified-plan");
sdp_semantics = WebRTCSdpSemantics::kUnifiedPlan; web_configuration.sdp_semantics = WebRTCSdpSemantics::kUnifiedPlan;
} }
} }
WebRTCConfiguration web_configuration;
web_configuration.ice_transport_policy = ice_transport_policy;
web_configuration.bundle_policy = bundle_policy;
web_configuration.rtcp_mux_policy = rtcp_mux_policy;
web_configuration.sdp_semantics = sdp_semantics;
if (configuration.hasIceServers()) { if (configuration.hasIceServers()) {
Vector<WebRTCIceServer> ice_servers; std::vector<webrtc::PeerConnectionInterface::IceServer> ice_servers;
for (const RTCIceServer& ice_server : configuration.iceServers()) { for (const RTCIceServer& ice_server : configuration.iceServers()) {
Vector<String> url_strings; Vector<String> url_strings;
if (ice_server.hasURLs()) { if (ice_server.hasURLs()) {
...@@ -359,7 +351,11 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context, ...@@ -359,7 +351,11 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
"required when the URL scheme is " "required when the URL scheme is "
"\"turn\" or \"turns\"."); "\"turn\" or \"turns\".");
} }
ice_servers.push_back(WebRTCIceServer{url, username, credential}); ice_servers.emplace_back();
auto& converted_ice_server = ice_servers.back();
converted_ice_server.urls.push_back(WebString(url).Utf8());
converted_ice_server.username = WebString(username).Utf8();
converted_ice_server.password = WebString(credential).Utf8();
} }
} }
web_configuration.ice_servers = ice_servers; web_configuration.ice_servers = ice_servers;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment