Onion soup most of WebRTCConfiguration

Bug: 787254
Change-Id: I081690b1e46a73705f86217f38a899706127feea
Reviewed-on: https://chromium-review.googlesource.com/1161614Reviewed-by: Henrik Boström <hbos@chromium.org>
Commit-Queue: Steve Anton <steveanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581141}

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -183,55 +183,10 @@ void GetNativeRtcConfiguration(
     webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) {
   DCHECK(webrtc_config);
 
-  webrtc_config->servers.clear();
-  for (const blink::WebRTCIceServer& blink_server : blink_config.ice_servers) {
-    webrtc::PeerConnectionInterface::IceServer server;
-    server.username = blink_server.username.Utf8();
-    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();
-  }
+  webrtc_config->servers = blink_config.ice_servers;
+  webrtc_config->type = blink_config.ice_transport_policy;
+  webrtc_config->bundle_policy = blink_config.bundle_policy;
+  webrtc_config->rtcp_mux_policy = blink_config.rtcp_mux_policy;
 
   switch (blink_config.sdp_semantics) {
     case blink::WebRTCSdpSemantics::kPlanB:

third_party/blink/public/platform/web_rtc_configuration.h

@@ -33,35 +33,24 @@
 
 #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_url.h"
 #include "third_party/blink/public/platform/web_vector.h"
+#include "third_party/webrtc/api/peerconnectioninterface.h"
 
 #include <memory>
 
 namespace blink {
 
-class WebString;
-
-struct WebRTCIceServer {
-  WebURL url;
-  WebString username;
-  WebString credential;
-};
-
-enum class WebRTCIceTransportPolicy { kRelay, kAll };
-
-enum class WebRTCBundlePolicy { kBalanced, kMaxCompat, kMaxBundle };
-
-enum class WebRTCRtcpMuxPolicy { kNegotiate, kRequire };
-
+// This is distinct from webrtc::SdpSemantics to add the kDefault option.
 enum class WebRTCSdpSemantics { kDefault, kPlanB, kUnifiedPlan };
 
 struct WebRTCConfiguration {
-  WebVector<WebRTCIceServer> ice_servers;
-  WebRTCIceTransportPolicy ice_transport_policy =
-      WebRTCIceTransportPolicy::kAll;
-  WebRTCBundlePolicy bundle_policy = WebRTCBundlePolicy::kBalanced;
-  WebRTCRtcpMuxPolicy rtcp_mux_policy = WebRTCRtcpMuxPolicy::kRequire;
+  std::vector<webrtc::PeerConnectionInterface::IceServer> ice_servers;
+  webrtc::PeerConnectionInterface::IceTransportsType ice_transport_policy =
+      webrtc::PeerConnectionInterface::kAll;
+  webrtc::PeerConnectionInterface::BundlePolicy bundle_policy =
+      webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
+  webrtc::PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
+      webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire;
   WebVector<std::unique_ptr<WebRTCCertificate>> certificates;
   int ice_candidate_pool_size = 0;
   WebRTCSdpSemantics sdp_semantics = WebRTCSdpSemantics::kDefault;

third_party/blink/renderer/modules/peerconnection/rtc_peer_connection.cc

@@ -250,11 +250,12 @@ class WebRTCCertificateObserver : public WebRTCCertificateCallback {
   Persistent<ScriptPromiseResolver> resolver_;
 };
 
-WebRTCIceTransportPolicy IceTransportPolicyFromString(const String& policy) {
+webrtc::PeerConnectionInterface::IceTransportsType IceTransportPolicyFromString(
+    const String& policy) {
   if (policy == "relay")
-    return WebRTCIceTransportPolicy::kRelay;
+    return webrtc::PeerConnectionInterface::kRelay;
   DCHECK_EQ(policy, "all");
-  return WebRTCIceTransportPolicy::kAll;
+  return webrtc::PeerConnectionInterface::kAll;
 }
 
 WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
@@ -262,56 +263,47 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
                                        ExceptionState& exception_state) {
   DCHECK(context);
 
-  WebRTCIceTransportPolicy ice_transport_policy =
-      WebRTCIceTransportPolicy::kAll;
+  WebRTCConfiguration web_configuration;
+
   if (configuration.hasIceTransportPolicy()) {
     UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransportPolicy);
-    ice_transport_policy =
+    web_configuration.ice_transport_policy =
         IceTransportPolicyFromString(configuration.iceTransportPolicy());
   } else if (configuration.hasIceTransports()) {
     UseCounter::Count(context, WebFeature::kRTCConfigurationIceTransports);
-    ice_transport_policy =
+    web_configuration.ice_transport_policy =
         IceTransportPolicyFromString(configuration.iceTransports());
   }
 
-  WebRTCBundlePolicy bundle_policy = WebRTCBundlePolicy::kBalanced;
-  String bundle_policy_string = configuration.bundlePolicy();
-  if (bundle_policy_string == "max-compat") {
-    bundle_policy = WebRTCBundlePolicy::kMaxCompat;
-  } else if (bundle_policy_string == "max-bundle") {
-    bundle_policy = WebRTCBundlePolicy::kMaxBundle;
+  if (configuration.bundlePolicy() == "max-compat") {
+    web_configuration.bundle_policy =
+        webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
+  } else if (configuration.bundlePolicy() == "max-bundle") {
+    web_configuration.bundle_policy =
+        webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
   } else {
-    DCHECK_EQ(bundle_policy_string, "balanced");
+    DCHECK_EQ(configuration.bundlePolicy(), "balanced");
   }
 
-  WebRTCRtcpMuxPolicy rtcp_mux_policy = WebRTCRtcpMuxPolicy::kRequire;
-  String rtcp_mux_policy_string = configuration.rtcpMuxPolicy();
-  if (rtcp_mux_policy_string == "negotiate") {
-    rtcp_mux_policy = WebRTCRtcpMuxPolicy::kNegotiate;
+  if (configuration.rtcpMuxPolicy() == "negotiate") {
+    web_configuration.rtcp_mux_policy =
+        webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
     Deprecation::CountDeprecation(context, WebFeature::kRtcpMuxPolicyNegotiate);
   } else {
-    DCHECK_EQ(rtcp_mux_policy_string, "require");
+    DCHECK_EQ(configuration.rtcpMuxPolicy(), "require");
   }
 
-  WebRTCSdpSemantics sdp_semantics = WebRTCSdpSemantics::kDefault;
   if (configuration.hasSdpSemantics()) {
-    String sdp_semantics_string = configuration.sdpSemantics();
-    if (sdp_semantics_string == "plan-b") {
-      sdp_semantics = WebRTCSdpSemantics::kPlanB;
+    if (configuration.sdpSemantics() == "plan-b") {
+      web_configuration.sdp_semantics = WebRTCSdpSemantics::kPlanB;
     } else {
-      DCHECK_EQ(sdp_semantics_string, "unified-plan");
-      sdp_semantics = WebRTCSdpSemantics::kUnifiedPlan;
+      DCHECK_EQ(configuration.sdpSemantics(), "unified-plan");
+      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()) {
-    Vector<WebRTCIceServer> ice_servers;
+    std::vector<webrtc::PeerConnectionInterface::IceServer> ice_servers;
     for (const RTCIceServer& ice_server : configuration.iceServers()) {
       Vector<String> url_strings;
       if (ice_server.hasURLs()) {
@@ -359,7 +351,11 @@ WebRTCConfiguration ParseConfiguration(ExecutionContext* context,
               "required when the URL scheme is "
               "\"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;