Support RTCConfiguration iceTransportPolicy

third_party/WebKit/Source/modules/peerconnection/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 200 matching lines @@
 
   void onSuccess(std::unique_ptr<WebRTCCertificate> certificate) override {
     m_resolver->resolve(new RTCCertificate(std::move(certificate)));
   }
 
   void onError() override { m_resolver->reject(); }
 
   Persistent<ScriptPromiseResolver> m_resolver;
 };
 
+WebRTCIceTransportPolicy iceTransportPolicyFromString(const String& policy) {
+  if (policy == "none")
+    return WebRTCIceTransportPolicy::kNone;
+  if (policy == "relay")
+    return WebRTCIceTransportPolicy::kRelay;
+  DCHECK_EQ(policy, "all");
+  return WebRTCIceTransportPolicy::kAll;
+}
+
 WebRTCConfiguration parseConfiguration(ExecutionContext* context,
                                        const RTCConfiguration& configuration,
                                        ExceptionState& exceptionState,
                                        RtcpMuxPolicy* selectedRtcpMuxPolicy) {
   DCHECK(context);
   DCHECK(selectedRtcpMuxPolicy);
 
-  WebRTCIceTransports iceTransports = WebRTCIceTransports::kAll;
-  String iceTransportsString = configuration.iceTransports();
-  if (iceTransportsString == "none") {
-    UseCounter::count(context, UseCounter::RTCConfigurationIceTransportsNone);
-    iceTransports = WebRTCIceTransports::kNone;
-  } else if (iceTransportsString == "relay") {
-    iceTransports = WebRTCIceTransports::kRelay;
-  } else {
-    DCHECK_EQ(iceTransportsString, "all");
+  WebRTCIceTransportPolicy iceTransportPolicy = WebRTCIceTransportPolicy::kAll;
+  if (configuration.hasIceTransportPolicy()) {
+    UseCounter::count(context, UseCounter::RTCConfigurationIceTransportPolicy);
+    iceTransportPolicy =
+        iceTransportPolicyFromString(configuration.iceTransportPolicy());
+    if (iceTransportPolicy == WebRTCIceTransportPolicy::kNone) {
+      UseCounter::count(context,
+                        UseCounter::RTCConfigurationIceTransportPolicyNone);
+    }
+  } else if (configuration.hasIceTransports()) {
+    UseCounter::count(context, UseCounter::RTCConfigurationIceTransports);
+    iceTransportPolicy =
+        iceTransportPolicyFromString(configuration.iceTransports());
+    if (iceTransportPolicy == WebRTCIceTransportPolicy::kNone)
+      UseCounter::count(context, UseCounter::RTCConfigurationIceTransportsNone);
   }
 
   WebRTCBundlePolicy bundlePolicy = WebRTCBundlePolicy::kBalanced;
   String bundlePolicyString = configuration.bundlePolicy();
   if (bundlePolicyString == "max-compat") {
     bundlePolicy = WebRTCBundlePolicy::kMaxCompat;
   } else if (bundlePolicyString == "max-bundle") {
     bundlePolicy = WebRTCBundlePolicy::kMaxBundle;
   } else {
     DCHECK_EQ(bundlePolicyString, "balanced");
   }
 
   // For the histogram value of "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
   *selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
   WebRTCRtcpMuxPolicy rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kNegotiate;
   if (configuration.hasRtcpMuxPolicy()) {
     String rtcpMuxPolicyString = configuration.rtcpMuxPolicy();
     if (rtcpMuxPolicyString == "require") {
       *selectedRtcpMuxPolicy = RtcpMuxPolicyRequire;
       rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kRequire;
     } else {
       DCHECK_EQ(rtcpMuxPolicyString, "negotiate");
       *selectedRtcpMuxPolicy = RtcpMuxPolicyNegotiate;
     }
   }
 
   WebRTCConfiguration webConfiguration;
-  webConfiguration.iceTransports = iceTransports;
+  webConfiguration.iceTransportPolicy = iceTransportPolicy;
   webConfiguration.bundlePolicy = bundlePolicy;
   webConfiguration.rtcpMuxPolicy = rtcpMuxPolicy;
 
   if (configuration.hasIceServers()) {
     Vector<WebRTCIceServer> iceServers;
     for (const RTCIceServer& iceServer : configuration.iceServers()) {
       Vector<String> urlStrings;
       if (iceServer.hasURLs()) {
         UseCounter::count(context, UseCounter::RTCIceServerURLs);
         const StringOrStringSequence& urls = iceServer.urls();
@@ skipping 1177 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   ActiveDOMObject::trace(visitor);
 }
 
 }  // namespace blink