Create the API that returns the RTCConfiguration of the PeerConnection.

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 278 matching lines @@
         UseCounter::count(context, UseCounter::RTCIceServerURL);
         urlStrings.push_back(iceServer.url());
       } else {
         exceptionState.throwTypeError("Malformed RTCIceServer");
         return WebRTCConfiguration();
       }
 
       String username = iceServer.username();
       String credential = iceServer.credential();
 
+      Vector<WebURL> urls;
       for (const String& urlString : urlStrings) {
         KURL url(KURL(), urlString);
         if (!url.isValid()) {
           exceptionState.throwDOMException(
               SyntaxError, "'" + urlString + "' is not a valid URL.");
           return WebRTCConfiguration();
         }
         if (!(url.protocolIs("turn") || url.protocolIs("turns") ||
               url.protocolIs("stun"))) {
           exceptionState.throwDOMException(
               SyntaxError, "'" + url.protocol() +
                                "' is not one of the supported URL schemes "
                                "'stun', 'turn' or 'turns'.");
           return WebRTCConfiguration();
         }
         if ((url.protocolIs("turn") || url.protocolIs("turns")) &&
             (username.isNull() || credential.isNull())) {
           exceptionState.throwDOMException(InvalidAccessError,
                                            "Both username and credential are "
                                            "required when the URL scheme is "
                                            "\"turn\" or \"turns\".");
         }
-        iceServers.push_back(WebRTCIceServer{url, username, credential});
+        urls.push_back(url);
       }
+      iceServers.push_back(WebRTCIceServer{urls, username, credential});
     }
     webConfiguration.iceServers = iceServers;
   }
 
   if (configuration.hasCertificates()) {
     const HeapVector<Member<RTCCertificate>>& certificates =
         configuration.certificates();
     WebVector<std::unique_ptr<WebRTCCertificate>> certificatesCopy(
         certificates.size());
     for (size_t i = 0; i < certificates.size(); ++i) {
       certificatesCopy[i] = certificates[i]->certificateShallowCopy();
     }
     webConfiguration.certificates = std::move(certificatesCopy);
   }
 
   return webConfiguration;
 }
 
+RTCConfiguration getWebKitRtcConfiguration(WebRTCConfiguration& blinkConfig) {
+  RTCConfiguration rtcConfig;
+
+  switch (blinkConfig.iceTransportPolicy) {
+    case blink::WebRTCIceTransportPolicy::kNone:
+      rtcConfig.setIceTransportPolicy("none");
+      break;
+    case blink::WebRTCIceTransportPolicy::kRelay:
+      rtcConfig.setIceTransportPolicy("relay");
+      break;
+    case blink::WebRTCIceTransportPolicy::kAll:
+      rtcConfig.setIceTransportPolicy("all");
+      break;
+    default:

[Taylor_Brandstetter, 2017/03/02 22:30:45]

nit: Don't need any of the default cases in this function.

+      NOTREACHED();
+  }
+
+  switch (blinkConfig.bundlePolicy) {
+    case blink::WebRTCBundlePolicy::kBalanced:
+      rtcConfig.setBundlePolicy("balanced");
+      break;
+    case blink::WebRTCBundlePolicy::kMaxBundle:
+      rtcConfig.setBundlePolicy("max-bundle");
+      break;
+    case blink::WebRTCBundlePolicy::kMaxCompat:
+      rtcConfig.setBundlePolicy("max-compat");
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  switch (blinkConfig.rtcpMuxPolicy) {
+    case blink::WebRTCRtcpMuxPolicy::kNegotiate:
+      rtcConfig.setRtcpMuxPolicy("negotiate");
+      break;
+    case blink::WebRTCRtcpMuxPolicy::kRequire:
+      rtcConfig.setRtcpMuxPolicy("require");
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  HeapVector<RTCIceServer> servers;
+  for (WebRTCIceServer blink_server : blinkConfig.iceServers) {
+    RTCIceServer server;
+    Vector<String> urlStrings;
+    StringOrStringSequence urls;
+    for (WebURL blink_url : blink_server.urls) {
+      String urlString(blink_url.string().utf8().c_str());
+      urlStrings.push_back(urlString);
+    }
+    urls.setStringSequence(urlStrings);
+    server.setURLs(urls);
+    String username(blink_server.username.utf8().c_str());
+    server.setUsername(blink_server.username);
+    String credential(blink_server.credential.utf8().c_str());
+    server.setCredential(credential);
+    servers.push_back(server);
+  }
+  rtcConfig.setIceServers(servers);
+
+  HeapVector<Member<RTCCertificate>> certificates;
+  for (std::unique_ptr<blink::WebRTCCertificate>& blink_certificate :
+       blinkConfig.certificates) {
+    certificates.push_back(new RTCCertificate(std::move(blink_certificate)));
+  }
+  rtcConfig.setCertificates(certificates);
+
+  return rtcConfig;
+}
+
 RTCOfferOptionsPlatform* parseOfferOptions(const Dictionary& options,
                                            ExceptionState& exceptionState) {
   if (options.isUndefinedOrNull())
     return nullptr;
 
   const Vector<String>& propertyNames =
       options.getPropertyNames(exceptionState);
   if (exceptionState.hadException())
     return nullptr;
 
@@ skipping 435 matching lines @@
 
 RTCSessionDescription* RTCPeerConnection::remoteDescription() {
   WebRTCSessionDescription webSessionDescription =
       m_peerHandler->remoteDescription();
   if (webSessionDescription.isNull())
     return nullptr;
 
   return RTCSessionDescription::create(webSessionDescription);
 }
 
+void RTCPeerConnection::getConfiguration(RTCConfiguration& rtcConfig) {
+  blink::WebRTCConfiguration blinkConfig = m_peerHandler->getConfiguration();
+  rtcConfig = getWebKitRtcConfiguration(blinkConfig);
+}
+
 void RTCPeerConnection::setConfiguration(
     ScriptState* scriptState,
     const RTCConfiguration& rtcConfiguration,
     ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
     return;
 
   WebRTCConfiguration configuration = parseConfiguration(
       scriptState->getExecutionContext(), rtcConfiguration, exceptionState);
 
@@ skipping 687 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink